diff options
9 files changed, 722 insertions, 192 deletions
diff --git a/core/java/android/app/AppCompatTaskInfo.java b/core/java/android/app/AppCompatTaskInfo.java index 81e9df66e18a..8370c2e522f3 100644 --- a/core/java/android/app/AppCompatTaskInfo.java +++ b/core/java/android/app/AppCompatTaskInfo.java @@ -95,6 +95,8 @@ public class AppCompatTaskInfo implements Parcelable { private static final int FLAG_FULLSCREEN_OVERRIDE_SYSTEM = FLAG_BASE << 7; /** Top activity flag for whether has activity has been overridden to fullscreen by user. */ private static final int FLAG_FULLSCREEN_OVERRIDE_USER = FLAG_BASE << 8; + /** Top activity flag for whether min aspect ratio of the activity has been overridden.*/ + public static final int FLAG_HAS_MIN_ASPECT_RATIO_OVERRIDE = FLAG_BASE << 9; @Retention(RetentionPolicy.SOURCE) @IntDef(flag = true, value = { @@ -108,7 +110,8 @@ public class AppCompatTaskInfo implements Parcelable { FLAG_IS_FROM_LETTERBOX_DOUBLE_TAP, FLAG_ELIGIBLE_FOR_USER_ASPECT_RATIO_BUTTON, FLAG_FULLSCREEN_OVERRIDE_SYSTEM, - FLAG_FULLSCREEN_OVERRIDE_USER + FLAG_FULLSCREEN_OVERRIDE_USER, + FLAG_HAS_MIN_ASPECT_RATIO_OVERRIDE }) public @interface TopActivityFlag {} @@ -118,7 +121,7 @@ public class AppCompatTaskInfo implements Parcelable { @TopActivityFlag private static final int FLAGS_ORGANIZER_INTERESTED = FLAG_IS_FROM_LETTERBOX_DOUBLE_TAP | FLAG_ELIGIBLE_FOR_USER_ASPECT_RATIO_BUTTON | FLAG_FULLSCREEN_OVERRIDE_SYSTEM - | FLAG_FULLSCREEN_OVERRIDE_USER; + | FLAG_FULLSCREEN_OVERRIDE_USER | FLAG_HAS_MIN_ASPECT_RATIO_OVERRIDE; @TopActivityFlag private static final int FLAGS_COMPAT_UI_INTERESTED = FLAGS_ORGANIZER_INTERESTED @@ -301,6 +304,21 @@ public class AppCompatTaskInfo implements Parcelable { setTopActivityFlag(FLAG_LETTERBOXED, enable); } + /** + * @return {@code true} if the top activity's min aspect ratio has been overridden. + */ + public boolean hasMinAspectRatioOverride() { + return isTopActivityFlagEnabled(FLAG_HAS_MIN_ASPECT_RATIO_OVERRIDE); + } + + /** + * Sets the top activity flag for whether the min aspect ratio of the activity has been + * overridden. + */ + public void setHasMinAspectRatioOverride(boolean enable) { + setTopActivityFlag(FLAG_HAS_MIN_ASPECT_RATIO_OVERRIDE, enable); + } + /** Clear all top activity flags and set to false. */ public void clearTopActivityFlags() { mTopActivityFlags = FLAG_UNDEFINED; @@ -392,6 +410,7 @@ public class AppCompatTaskInfo implements Parcelable { + " topActivityLetterboxAppHeight=" + topActivityLetterboxAppHeight + " isUserFullscreenOverrideEnabled=" + isUserFullscreenOverrideEnabled() + " isSystemFullscreenOverrideEnabled=" + isSystemFullscreenOverrideEnabled() + + " hasMinAspectRatioOverride=" + hasMinAspectRatioOverride() + " cameraCompatTaskInfo=" + cameraCompatTaskInfo.toString() + "}"; } diff --git a/libs/WindowManager/Shell/src/com/android/wm/shell/desktopmode/DesktopModeUtils.kt b/libs/WindowManager/Shell/src/com/android/wm/shell/desktopmode/DesktopModeUtils.kt index 6c03dc333515..b68b436f2c1b 100644 --- a/libs/WindowManager/Shell/src/com/android/wm/shell/desktopmode/DesktopModeUtils.kt +++ b/libs/WindowManager/Shell/src/com/android/wm/shell/desktopmode/DesktopModeUtils.kt @@ -66,7 +66,7 @@ fun calculateInitialBounds( val initialSize: Size = when (taskInfo.configuration.orientation) { ORIENTATION_LANDSCAPE -> { - if (taskInfo.isResizeable) { + if (taskInfo.canChangeAspectRatio) { if (isFixedOrientationPortrait(topActivityInfo.screenOrientation)) { // For portrait resizeable activities, respect apps fullscreen width but // apply ideal size height. @@ -85,7 +85,7 @@ fun calculateInitialBounds( ORIENTATION_PORTRAIT -> { val customPortraitWidthForLandscapeApp = screenBounds.width() - (DESKTOP_MODE_LANDSCAPE_APP_PADDING * 2) - if (taskInfo.isResizeable) { + if (taskInfo.canChangeAspectRatio) { if (isFixedOrientationLandscape(topActivityInfo.screenOrientation)) { // For landscape resizeable activities, respect apps fullscreen height and // apply custom app width. @@ -189,6 +189,13 @@ private fun positionInScreen(desiredSize: Size, stableBounds: Rect): Rect = } /** + * Whether the activity's aspect ratio can be changed or if it should be maintained as if it was + * unresizeable. + */ +private val TaskInfo.canChangeAspectRatio: Boolean + get() = isResizeable && !appCompatTaskInfo.hasMinAspectRatioOverride() + +/** * Adjusts bounds to be positioned in the middle of the area provided, not necessarily the * entire screen, as area can be offset by left and top start. */ @@ -204,7 +211,7 @@ fun centerInArea(desiredSize: Size, areaBounds: Rect, leftStart: Int, topStart: return Rect(newLeft, newTop, newRight, newBottom) } -fun TaskInfo.hasPortraitTopActivity(): Boolean { +private fun TaskInfo.hasPortraitTopActivity(): Boolean { val topActivityScreenOrientation = topActivityInfo?.screenOrientation ?: SCREEN_ORIENTATION_UNSPECIFIED val appBounds = configuration.windowConfiguration.appBounds diff --git a/libs/WindowManager/Shell/tests/unittest/src/com/android/wm/shell/desktopmode/DesktopTasksControllerTest.kt b/libs/WindowManager/Shell/tests/unittest/src/com/android/wm/shell/desktopmode/DesktopTasksControllerTest.kt index 18c62282f035..979e9bc5968a 100644 --- a/libs/WindowManager/Shell/tests/unittest/src/com/android/wm/shell/desktopmode/DesktopTasksControllerTest.kt +++ b/libs/WindowManager/Shell/tests/unittest/src/com/android/wm/shell/desktopmode/DesktopTasksControllerTest.kt @@ -867,6 +867,18 @@ class DesktopTasksControllerTest : ShellTestCase() { @Test @EnableFlags(Flags.FLAG_ENABLE_WINDOWING_DYNAMIC_INITIAL_BOUNDS) + fun addMoveToDesktopChanges_landscapeDevice_portraitResizableApp_aspectRatioOverridden() { + setUpLandscapeDisplay() + val task = setUpFullscreenTask(screenOrientation = SCREEN_ORIENTATION_PORTRAIT, + shouldLetterbox = true, aspectRatioOverrideApplied = true) + val wct = WindowContainerTransaction() + controller.addMoveToDesktopChanges(wct, task) + + assertThat(findBoundsChange(wct, task)).isEqualTo(UNRESIZABLE_PORTRAIT_BOUNDS) + } + + @Test + @EnableFlags(Flags.FLAG_ENABLE_WINDOWING_DYNAMIC_INITIAL_BOUNDS) fun addMoveToDesktopChanges_portraitDevice_userFullscreenOverride_defaultPortraitBounds() { setUpPortraitDisplay() val task = setUpFullscreenTask(enableUserFullscreenOverride = true) @@ -888,6 +900,19 @@ class DesktopTasksControllerTest : ShellTestCase() { } @Test + @EnableFlags(Flags.FLAG_ENABLE_WINDOWING_DYNAMIC_INITIAL_BOUNDS) + fun addMoveToDesktopChanges_portraitDevice_landscapeResizableApp_aspectRatioOverridden() { + setUpPortraitDisplay() + val task = setUpFullscreenTask(screenOrientation = SCREEN_ORIENTATION_LANDSCAPE, + deviceOrientation = ORIENTATION_PORTRAIT, + shouldLetterbox = true, aspectRatioOverrideApplied = true) + val wct = WindowContainerTransaction() + controller.addMoveToDesktopChanges(wct, task) + + assertThat(findBoundsChange(wct, task)).isEqualTo(UNRESIZABLE_LANDSCAPE_BOUNDS) + } + + @Test fun moveToDesktop_tdaFullscreen_windowingModeSetToFreeform() { val task = setUpFullscreenTask() val tda = rootTaskDisplayAreaOrganizer.getDisplayAreaInfo(DEFAULT_DISPLAY)!! @@ -2883,7 +2908,8 @@ class DesktopTasksControllerTest : ShellTestCase() { shouldLetterbox: Boolean = false, gravity: Int = Gravity.NO_GRAVITY, enableUserFullscreenOverride: Boolean = false, - enableSystemFullscreenOverride: Boolean = false + enableSystemFullscreenOverride: Boolean = false, + aspectRatioOverrideApplied: Boolean = false ): RunningTaskInfo { val task = createFullscreenTask(displayId) val activityInfo = ActivityInfo() @@ -2898,6 +2924,7 @@ class DesktopTasksControllerTest : ShellTestCase() { appCompatTaskInfo.isSystemFullscreenOverrideEnabled = enableSystemFullscreenOverride if (shouldLetterbox) { + appCompatTaskInfo.setHasMinAspectRatioOverride(aspectRatioOverrideApplied) if (deviceOrientation == ORIENTATION_LANDSCAPE && screenOrientation == SCREEN_ORIENTATION_PORTRAIT) { // Letterbox to portrait size diff --git a/services/core/java/com/android/server/wm/AppCompatAspectRatioOverrides.java b/services/core/java/com/android/server/wm/AppCompatAspectRatioOverrides.java index 44276055f346..cd795ae167ea 100644 --- a/services/core/java/com/android/server/wm/AppCompatAspectRatioOverrides.java +++ b/services/core/java/com/android/server/wm/AppCompatAspectRatioOverrides.java @@ -233,7 +233,8 @@ class AppCompatAspectRatioOverrides { return mAppCompatConfiguration.getIsSplitScreenAspectRatioForUnresizableAppsEnabled(); } - private float getDisplaySizeMinAspectRatio() { + @VisibleForTesting + float getDisplaySizeMinAspectRatio() { final DisplayArea displayArea = mActivityRecord.getDisplayArea(); if (displayArea == null) { return mActivityRecord.info.getMinAspectRatio(); @@ -270,7 +271,6 @@ class AppCompatAspectRatioOverrides { return !mAllowUserAspectRatioOverrideOptProp.isFalse(); } - @VisibleForTesting int getUserMinAspectRatioOverrideCode() { try { return mActivityRecord.mAtmService.getPackageManager() diff --git a/services/core/java/com/android/server/wm/AppCompatUtils.java b/services/core/java/com/android/server/wm/AppCompatUtils.java index 94ad61f3f4de..e3ff85171c0e 100644 --- a/services/core/java/com/android/server/wm/AppCompatUtils.java +++ b/services/core/java/com/android/server/wm/AppCompatUtils.java @@ -187,6 +187,8 @@ final class AppCompatUtils { appCompatTaskInfo.setTopActivityLetterboxed(top.areBoundsLetterboxed()); appCompatTaskInfo.cameraCompatTaskInfo.freeformCameraCompatMode = top.mAppCompatController .getAppCompatCameraOverrides().getFreeformCameraCompatMode(); + appCompatTaskInfo.setHasMinAspectRatioOverride(top.mAppCompatController + .getDesktopAppCompatAspectRatioPolicy().hasMinAspectRatioOverride(task)); } /** diff --git a/services/core/java/com/android/server/wm/DesktopAppCompatAspectRatioPolicy.java b/services/core/java/com/android/server/wm/DesktopAppCompatAspectRatioPolicy.java index 8477c6c5b1da..b936556c3264 100644 --- a/services/core/java/com/android/server/wm/DesktopAppCompatAspectRatioPolicy.java +++ b/services/core/java/com/android/server/wm/DesktopAppCompatAspectRatioPolicy.java @@ -258,7 +258,7 @@ public class DesktopAppCompatAspectRatioPolicy { * Whether we should apply the user aspect ratio override to the min aspect ratio for the * current app. */ - private boolean shouldApplyUserMinAspectRatioOverride(@NonNull Task task) { + boolean shouldApplyUserMinAspectRatioOverride(@NonNull Task task) { if (!shouldEnableUserAspectRatioSettings(task)) { return false; } diff --git a/services/core/java/com/android/server/wm/DesktopModeBoundsCalculator.java b/services/core/java/com/android/server/wm/DesktopModeBoundsCalculator.java index 8f1828d741c5..c3db7dd7bfaf 100644 --- a/services/core/java/com/android/server/wm/DesktopModeBoundsCalculator.java +++ b/services/core/java/com/android/server/wm/DesktopModeBoundsCalculator.java @@ -16,31 +16,28 @@ package com.android.server.wm; +import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_LOCKED; +import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_PORTRAIT; +import static android.content.pm.ActivityInfo.isFixedOrientation; import static android.content.pm.ActivityInfo.isFixedOrientationLandscape; import static android.content.pm.ActivityInfo.isFixedOrientationPortrait; import static android.content.res.Configuration.ORIENTATION_LANDSCAPE; import static android.content.res.Configuration.ORIENTATION_PORTRAIT; -import static com.android.server.wm.AppCompatConfiguration.DEFAULT_LETTERBOX_ASPECT_RATIO_FOR_MULTI_WINDOW; -import static com.android.server.wm.AppCompatConfiguration.MIN_FIXED_ORIENTATION_LETTERBOX_ASPECT_RATIO; -import static com.android.server.wm.AppCompatUtils.computeAspectRatio; import static com.android.server.wm.LaunchParamsUtil.applyLayoutGravity; import static com.android.server.wm.LaunchParamsUtil.calculateLayoutBounds; import android.annotation.NonNull; import android.annotation.Nullable; import android.app.ActivityOptions; -import android.app.AppCompatTaskInfo; import android.app.TaskInfo; -import android.content.pm.ActivityInfo; -import android.content.res.Configuration; +import android.content.pm.ActivityInfo.ScreenOrientation; +import android.content.pm.ActivityInfo.WindowLayout; import android.graphics.Rect; import android.os.SystemProperties; import android.util.Size; import android.view.Gravity; -import com.android.internal.R; -import com.android.internal.annotations.VisibleForTesting; import com.android.server.wm.utils.DesktopModeFlagsUtil; import java.util.function.Consumer; @@ -60,7 +57,7 @@ public final class DesktopModeBoundsCalculator { * Updates launch bounds for an activity with respect to its activity options, window layout, * android manifest and task configuration. */ - static void updateInitialBounds(@NonNull Task task, @Nullable ActivityInfo.WindowLayout layout, + static void updateInitialBounds(@NonNull Task task, @Nullable WindowLayout layout, @Nullable ActivityRecord activity, @Nullable ActivityOptions options, @NonNull Rect outBounds, @NonNull Consumer<String> logger) { // Use stable frame instead of raw frame to avoid launching freeform windows on top of @@ -98,7 +95,8 @@ public final class DesktopModeBoundsCalculator { * fullscreen size, aspect ratio, orientation and resizability to calculate an area this is * compatible with the applications previous configuration. */ - private static @NonNull Rect calculateInitialBounds(@NonNull Task task, + @NonNull + private static Rect calculateInitialBounds(@NonNull Task task, @NonNull ActivityRecord activity, @NonNull Rect stableBounds ) { final TaskInfo taskInfo = task.getTaskInfo(); @@ -116,18 +114,19 @@ public final class DesktopModeBoundsCalculator { // applied. return centerInScreen(idealSize, screenBounds); } - // TODO(b/353457301): Replace with app compat aspect ratio method when refactoring complete. - float appAspectRatio = calculateAspectRatio(task, activity); + final DesktopAppCompatAspectRatioPolicy desktopAppCompatAspectRatioPolicy = + activity.mAppCompatController.getDesktopAppCompatAspectRatioPolicy(); + float appAspectRatio = desktopAppCompatAspectRatioPolicy.calculateAspectRatio(task); final float tdaWidth = stableBounds.width(); final float tdaHeight = stableBounds.height(); - final int activityOrientation = activity.getOverrideOrientation(); + final int activityOrientation = getActivityOrientation(activity, task); final Size initialSize = switch (taskInfo.configuration.orientation) { case ORIENTATION_LANDSCAPE -> { // Device in landscape orientation. if (appAspectRatio == 0) { appAspectRatio = 1; } - if (taskInfo.isResizeable) { + if (canChangeAspectRatio(desktopAppCompatAspectRatioPolicy, taskInfo, task)) { if (isFixedOrientationPortrait(activityOrientation)) { // For portrait resizeable activities, respect apps fullscreen width but // apply ideal size height. @@ -139,14 +138,13 @@ public final class DesktopModeBoundsCalculator { } // If activity is unresizeable, regardless of orientation, calculate maximum size // (within the ideal size) maintaining original aspect ratio. - yield maximizeSizeGivenAspectRatio( - activity.getOverrideOrientation(), idealSize, appAspectRatio); + yield maximizeSizeGivenAspectRatio(activityOrientation, idealSize, appAspectRatio); } case ORIENTATION_PORTRAIT -> { // Device in portrait orientation. final int customPortraitWidthForLandscapeApp = screenBounds.width() - (DESKTOP_MODE_LANDSCAPE_APP_PADDING * 2); - if (taskInfo.isResizeable) { + if (canChangeAspectRatio(desktopAppCompatAspectRatioPolicy, taskInfo, task)) { if (isFixedOrientationLandscape(activityOrientation)) { if (appAspectRatio == 0) { appAspectRatio = tdaWidth / (tdaWidth - 1); @@ -180,11 +178,38 @@ public final class DesktopModeBoundsCalculator { } /** + * Whether the activity's aspect ratio can be changed or if it should be maintained as if it was + * unresizeable. + */ + private static boolean canChangeAspectRatio( + @NonNull DesktopAppCompatAspectRatioPolicy desktopAppCompatAspectRatioPolicy, + @NonNull TaskInfo taskInfo, @NonNull Task task) { + return taskInfo.isResizeable + && !desktopAppCompatAspectRatioPolicy.hasMinAspectRatioOverride(task); + } + + private static @ScreenOrientation int getActivityOrientation( + @NonNull ActivityRecord activity, @NonNull Task task) { + final int activityOrientation = activity.getOverrideOrientation(); + final DesktopAppCompatAspectRatioPolicy desktopAppCompatAspectRatioPolicy = + activity.mAppCompatController.getDesktopAppCompatAspectRatioPolicy(); + if (desktopAppCompatAspectRatioPolicy.shouldApplyUserMinAspectRatioOverride(task) + && (!isFixedOrientation(activityOrientation) + || activityOrientation == SCREEN_ORIENTATION_LOCKED)) { + // If a user aspect ratio override should be applied, treat the activity as portrait if + // it has not specified a fix orientation. + return SCREEN_ORIENTATION_PORTRAIT; + } + return activityOrientation; + } + + /** * Calculates the largest size that can fit in a given area while maintaining a specific aspect * ratio. */ - private static @NonNull Size maximizeSizeGivenAspectRatio( - @ActivityInfo.ScreenOrientation int orientation, + @NonNull + private static Size maximizeSizeGivenAspectRatio( + @ScreenOrientation int orientation, @NonNull Size targetArea, float aspectRatio ) { @@ -229,68 +254,11 @@ public final class DesktopModeBoundsCalculator { } /** - * Calculates the aspect ratio of an activity from its fullscreen bounds. - */ - @VisibleForTesting - static float calculateAspectRatio(@NonNull Task task, @NonNull ActivityRecord activity) { - final TaskInfo taskInfo = task.getTaskInfo(); - final float fullscreenWidth = task.getDisplayArea().getBounds().width(); - final float fullscreenHeight = task.getDisplayArea().getBounds().height(); - final float maxAspectRatio = activity.getMaxAspectRatio(); - final float minAspectRatio = activity.getMinAspectRatio(); - float desiredAspectRatio = 0; - if (taskInfo.isRunning) { - final AppCompatTaskInfo appCompatTaskInfo = taskInfo.appCompatTaskInfo; - final int appLetterboxWidth = - taskInfo.appCompatTaskInfo.topActivityLetterboxAppWidth; - final int appLetterboxHeight = - taskInfo.appCompatTaskInfo.topActivityLetterboxAppHeight; - if (appCompatTaskInfo.isTopActivityLetterboxed()) { - desiredAspectRatio = (float) Math.max(appLetterboxWidth, appLetterboxHeight) - / Math.min(appLetterboxWidth, appLetterboxHeight); - } else { - desiredAspectRatio = Math.max(fullscreenHeight, fullscreenWidth) - / Math.min(fullscreenHeight, fullscreenWidth); - } - } else { - final float letterboxAspectRatioOverride = - getFixedOrientationLetterboxAspectRatio(activity, task); - if (!task.mDisplayContent.getIgnoreOrientationRequest()) { - desiredAspectRatio = DEFAULT_LETTERBOX_ASPECT_RATIO_FOR_MULTI_WINDOW; - } else if (letterboxAspectRatioOverride - > MIN_FIXED_ORIENTATION_LETTERBOX_ASPECT_RATIO) { - desiredAspectRatio = letterboxAspectRatioOverride; - } - } - // If the activity matches display orientation, the display aspect ratio should be used - if (activityMatchesDisplayOrientation( - taskInfo.configuration.orientation, - activity.getOverrideOrientation())) { - desiredAspectRatio = Math.max(fullscreenWidth, fullscreenHeight) - / Math.min(fullscreenWidth, fullscreenHeight); - } - if (maxAspectRatio >= 1 && desiredAspectRatio > maxAspectRatio) { - desiredAspectRatio = maxAspectRatio; - } else if (minAspectRatio >= 1 && desiredAspectRatio < minAspectRatio) { - desiredAspectRatio = minAspectRatio; - } - return desiredAspectRatio; - } - - private static boolean activityMatchesDisplayOrientation( - @Configuration.Orientation int deviceOrientation, - @ActivityInfo.ScreenOrientation int activityOrientation) { - if (deviceOrientation == ORIENTATION_PORTRAIT) { - return isFixedOrientationPortrait(activityOrientation); - } - return isFixedOrientationLandscape(activityOrientation); - } - - /** * Calculates the desired initial bounds for applications in desktop windowing. This is done as * a scale of the screen bounds. */ - private static @NonNull Size calculateIdealSize(@NonNull Rect screenBounds, float scale) { + @NonNull + private static Size calculateIdealSize(@NonNull Rect screenBounds, float scale) { final int width = (int) (screenBounds.width() * scale); final int height = (int) (screenBounds.height() * scale); return new Size(width, height); @@ -299,7 +267,8 @@ public final class DesktopModeBoundsCalculator { /** * Adjusts bounds to be positioned in the middle of the screen. */ - private static @NonNull Rect centerInScreen(@NonNull Size desiredSize, + @NonNull + private static Rect centerInScreen(@NonNull Size desiredSize, @NonNull Rect screenBounds) { // TODO(b/325240051): Position apps with bottom heavy offset final int heightOffset = (screenBounds.height() - desiredSize.getHeight()) / 2; @@ -309,57 +278,4 @@ public final class DesktopModeBoundsCalculator { resultBounds.offset(screenBounds.left + widthOffset, screenBounds.top + heightOffset); return resultBounds; } - - private static float getFixedOrientationLetterboxAspectRatio(@NonNull ActivityRecord activity, - @NonNull Task task) { - return activity.shouldCreateCompatDisplayInsets() - ? getDefaultMinAspectRatioForUnresizableApps(activity, task) - : activity.mAppCompatController.getAppCompatAspectRatioOverrides() - .getDefaultMinAspectRatio(); - } - - private static float getDefaultMinAspectRatioForUnresizableApps( - @NonNull ActivityRecord activity, - @NonNull Task task) { - final AppCompatAspectRatioOverrides appCompatAspectRatioOverrides = - activity.mAppCompatController.getAppCompatAspectRatioOverrides(); - if (appCompatAspectRatioOverrides.isSplitScreenAspectRatioForUnresizableAppsEnabled()) { - // Default letterbox aspect ratio for unresizable apps. - return getSplitScreenAspectRatio(activity, task); - } - - if (appCompatAspectRatioOverrides.getDefaultMinAspectRatioForUnresizableAppsFromConfig() - > MIN_FIXED_ORIENTATION_LETTERBOX_ASPECT_RATIO) { - return appCompatAspectRatioOverrides - .getDefaultMinAspectRatioForUnresizableAppsFromConfig(); - } - - return appCompatAspectRatioOverrides.getDefaultMinAspectRatio(); - } - - /** - * Calculates the aspect ratio of the available display area when an app enters split-screen on - * a given device, taking into account any dividers and insets. - */ - private static float getSplitScreenAspectRatio(@NonNull ActivityRecord activity, - @NonNull Task task) { - final int dividerWindowWidth = - activity.mWmService.mContext.getResources().getDimensionPixelSize( - R.dimen.docked_stack_divider_thickness); - final int dividerInsets = - activity.mWmService.mContext.getResources().getDimensionPixelSize( - R.dimen.docked_stack_divider_insets); - final int dividerSize = dividerWindowWidth - dividerInsets * 2; - final Rect bounds = new Rect(0, 0, - task.mDisplayContent.getDisplayInfo().appWidth, - task.mDisplayContent.getDisplayInfo().appHeight); - if (bounds.width() >= bounds.height()) { - bounds.inset(/* dx */ dividerSize / 2, /* dy */ 0); - bounds.right = bounds.centerX(); - } else { - bounds.inset(/* dx */ 0, /* dy */ dividerSize / 2); - bounds.bottom = bounds.centerY(); - } - return computeAspectRatio(bounds); - } } diff --git a/services/tests/wmtests/src/com/android/server/wm/DesktopModeLaunchParamsModifierTests.java b/services/tests/wmtests/src/com/android/server/wm/DesktopModeLaunchParamsModifierTests.java index 07e95d83d7bc..6d508eabcd52 100644 --- a/services/tests/wmtests/src/com/android/server/wm/DesktopModeLaunchParamsModifierTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/DesktopModeLaunchParamsModifierTests.java @@ -21,11 +21,19 @@ import static android.app.WindowConfiguration.ACTIVITY_TYPE_STANDARD; import static android.app.WindowConfiguration.ACTIVITY_TYPE_UNDEFINED; import static android.app.WindowConfiguration.WINDOWING_MODE_FREEFORM; import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN; +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_MIN_ASPECT_RATIO_SMALL_VALUE; import static android.content.pm.ActivityInfo.RESIZE_MODE_RESIZEABLE; import static android.content.pm.ActivityInfo.RESIZE_MODE_UNRESIZEABLE; import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE; import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_PORTRAIT; import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED; +import static android.content.pm.PackageManager.USER_MIN_ASPECT_RATIO_16_9; +import static android.content.pm.PackageManager.USER_MIN_ASPECT_RATIO_3_2; +import static android.content.pm.PackageManager.USER_MIN_ASPECT_RATIO_4_3; +import static android.content.pm.PackageManager.USER_MIN_ASPECT_RATIO_DISPLAY_SIZE; +import static android.content.pm.PackageManager.USER_MIN_ASPECT_RATIO_SPLIT_SCREEN; import static android.content.res.Configuration.ORIENTATION_LANDSCAPE; import static android.content.res.Configuration.ORIENTATION_PORTRAIT; import static android.util.DisplayMetrics.DENSITY_DEFAULT; @@ -34,7 +42,6 @@ import static com.android.dx.mockito.inline.extended.ExtendedMockito.doReturn; import static com.android.dx.mockito.inline.extended.ExtendedMockito.spyOn; import static com.android.server.wm.DesktopModeBoundsCalculator.DESKTOP_MODE_INITIAL_BOUNDS_SCALE; import static com.android.server.wm.DesktopModeBoundsCalculator.DESKTOP_MODE_LANDSCAPE_APP_PADDING; -import static com.android.server.wm.DesktopModeBoundsCalculator.calculateAspectRatio; import static com.android.server.wm.LaunchParamsController.LaunchParamsModifier.PHASE_DISPLAY; import static com.android.server.wm.LaunchParamsController.LaunchParamsModifier.RESULT_CONTINUE; import static com.android.server.wm.LaunchParamsController.LaunchParamsModifier.RESULT_SKIP; @@ -44,6 +51,8 @@ import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.mock; import android.app.ActivityOptions; +import android.compat.testing.PlatformCompatChangeRule; +import android.content.ComponentName; import android.content.pm.ActivityInfo; import android.graphics.Rect; import android.platform.test.annotations.DisableFlags; @@ -55,8 +64,12 @@ import androidx.test.filters.SmallTest; import com.android.window.flags.Flags; +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 org.junit.runner.RunWith; /** @@ -74,6 +87,9 @@ public class DesktopModeLaunchParamsModifierTests extends private static final Rect PORTRAIT_DISPLAY_BOUNDS = new Rect(0, 0, 1600, 2560); private static final float LETTERBOX_ASPECT_RATIO = 1.3f; + @Rule + public TestRule compatChangeRule = new PlatformCompatChangeRule(); + @Before public void setUp() throws Exception { mActivity = new ActivityBuilder(mAtm).build(); @@ -199,14 +215,17 @@ public class DesktopModeLaunchParamsModifierTests extends final TestDisplayContent display = createDisplayContent(ORIENTATION_LANDSCAPE, LANDSCAPE_DISPLAY_BOUNDS); - final Task task = createTask(display, SCREEN_ORIENTATION_UNSPECIFIED, true); + final Task task = createTask(display, /* isResizeable */ true); + final ActivityRecord activity = createActivity(display, SCREEN_ORIENTATION_UNSPECIFIED, + task, /* ignoreOrientationRequest */ true); final int desiredWidth = (int) (LANDSCAPE_DISPLAY_BOUNDS.width() * DESKTOP_MODE_INITIAL_BOUNDS_SCALE); final int desiredHeight = (int) (LANDSCAPE_DISPLAY_BOUNDS.height() * DESKTOP_MODE_INITIAL_BOUNDS_SCALE); - assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task).calculate()); + assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task) + .setActivity(activity).calculate()); assertEquals(desiredWidth, mResult.mBounds.width()); assertEquals(desiredHeight, mResult.mBounds.height()); } @@ -219,14 +238,17 @@ public class DesktopModeLaunchParamsModifierTests extends final TestDisplayContent display = createDisplayContent(ORIENTATION_LANDSCAPE, LANDSCAPE_DISPLAY_BOUNDS); - final Task task = createTask(display, SCREEN_ORIENTATION_LANDSCAPE, true); + final Task task = createTask(display, /* isResizeable */ true); + final ActivityRecord activity = createActivity(display, SCREEN_ORIENTATION_LANDSCAPE, + task, /* ignoreOrientationRequest */ true); final int desiredWidth = (int) (LANDSCAPE_DISPLAY_BOUNDS.width() * DESKTOP_MODE_INITIAL_BOUNDS_SCALE); final int desiredHeight = (int) (LANDSCAPE_DISPLAY_BOUNDS.height() * DESKTOP_MODE_INITIAL_BOUNDS_SCALE); - assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task).calculate()); + assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task) + .setActivity(activity).calculate()); assertEquals(desiredWidth, mResult.mBounds.width()); assertEquals(desiredHeight, mResult.mBounds.height()); } @@ -239,7 +261,9 @@ public class DesktopModeLaunchParamsModifierTests extends final TestDisplayContent display = createDisplayContent(ORIENTATION_LANDSCAPE, LANDSCAPE_DISPLAY_BOUNDS); - final Task task = createTask(display, SCREEN_ORIENTATION_LANDSCAPE, true); + final Task task = createTask(display, /* isResizeable */ true); + final ActivityRecord activity = createActivity(display, SCREEN_ORIENTATION_LANDSCAPE, + task, /* ignoreOrientationRequest */ true); spyOn(mActivity.mAppCompatController.getAppCompatAspectRatioOverrides()); doReturn(true).when( @@ -251,7 +275,8 @@ public class DesktopModeLaunchParamsModifierTests extends final int desiredHeight = (int) (LANDSCAPE_DISPLAY_BOUNDS.height() * DESKTOP_MODE_INITIAL_BOUNDS_SCALE); - assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task).calculate()); + assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task) + .setActivity(activity).calculate()); assertEquals(desiredWidth, mResult.mBounds.width()); assertEquals(desiredHeight, mResult.mBounds.height()); } @@ -264,7 +289,9 @@ public class DesktopModeLaunchParamsModifierTests extends final TestDisplayContent display = createDisplayContent(ORIENTATION_LANDSCAPE, LANDSCAPE_DISPLAY_BOUNDS); - final Task task = createTask(display, SCREEN_ORIENTATION_LANDSCAPE, true); + final Task task = createTask(display, /* isResizeable */ true); + final ActivityRecord activity = createActivity(display, SCREEN_ORIENTATION_LANDSCAPE, + task, /* ignoreOrientationRequest */ true); spyOn(mActivity.mAppCompatController.getAppCompatAspectRatioOverrides()); doReturn(true).when( @@ -276,7 +303,8 @@ public class DesktopModeLaunchParamsModifierTests extends final int desiredHeight = (int) (LANDSCAPE_DISPLAY_BOUNDS.height() * DESKTOP_MODE_INITIAL_BOUNDS_SCALE); - assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task).calculate()); + assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task) + .setActivity(activity).calculate()); assertEquals(desiredWidth, mResult.mBounds.width()); assertEquals(desiredHeight, mResult.mBounds.height()); } @@ -285,19 +313,466 @@ public class DesktopModeLaunchParamsModifierTests extends @EnableFlags(Flags.FLAG_ENABLE_WINDOWING_DYNAMIC_INITIAL_BOUNDS) public void testResizablePortraitBounds_landscapeDevice_resizable_portraitOrientation() { setupDesktopModeLaunchParamsModifier(); - doReturn(LETTERBOX_ASPECT_RATIO).when(() - -> calculateAspectRatio(any(), any())); final TestDisplayContent display = createDisplayContent(ORIENTATION_LANDSCAPE, LANDSCAPE_DISPLAY_BOUNDS); - final Task task = createTask(display, SCREEN_ORIENTATION_PORTRAIT, true); + final Task task = createTask(display, /* isResizeable */ true); + final ActivityRecord activity = createActivity(display, SCREEN_ORIENTATION_PORTRAIT, + task, /* ignoreOrientationRequest */ true); + + spyOn(activity.mAppCompatController.getDesktopAppCompatAspectRatioPolicy()); + doReturn(LETTERBOX_ASPECT_RATIO).when(activity.mAppCompatController + .getDesktopAppCompatAspectRatioPolicy()).calculateAspectRatio(any()); final int desiredWidth = (int) ((LANDSCAPE_DISPLAY_BOUNDS.height() / LETTERBOX_ASPECT_RATIO) + 0.5f); final int desiredHeight = (int) (LANDSCAPE_DISPLAY_BOUNDS.height() * DESKTOP_MODE_INITIAL_BOUNDS_SCALE); - assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task).calculate()); + assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task) + .setActivity(activity).calculate()); + assertEquals(desiredWidth, mResult.mBounds.width()); + assertEquals(desiredHeight, mResult.mBounds.height()); + } + + @Test + @EnableFlags(Flags.FLAG_ENABLE_WINDOWING_DYNAMIC_INITIAL_BOUNDS) + @EnableCompatChanges({ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO, + ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_SMALL}) + public void testSmallAspectRatioOverride_landscapeDevice() { + setupDesktopModeLaunchParamsModifier(); + + final TestDisplayContent display = createDisplayContent(ORIENTATION_LANDSCAPE, + LANDSCAPE_DISPLAY_BOUNDS); + final Task task = createTask(display, /* isResizeable */ true); + final ActivityRecord activity = createActivity(display, SCREEN_ORIENTATION_PORTRAIT, + task, /* ignoreOrientationRequest */ false); + + final int desiredHeight = + (int) (LANDSCAPE_DISPLAY_BOUNDS.height() * DESKTOP_MODE_INITIAL_BOUNDS_SCALE); + final int desiredWidth = + (int) (desiredHeight / OVERRIDE_MIN_ASPECT_RATIO_SMALL_VALUE); + + assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task) + .setActivity(activity).calculate()); + assertEquals(desiredWidth, mResult.mBounds.width()); + assertEquals(desiredHeight, mResult.mBounds.height()); + } + + @Test + @EnableFlags(Flags.FLAG_ENABLE_WINDOWING_DYNAMIC_INITIAL_BOUNDS) + @EnableCompatChanges({ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO, + ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_MEDIUM}) + public void testMediumAspectRatioOverride_landscapeDevice() { + setupDesktopModeLaunchParamsModifier(); + + final TestDisplayContent display = createDisplayContent(ORIENTATION_LANDSCAPE, + LANDSCAPE_DISPLAY_BOUNDS); + final Task task = createTask(display, /* isResizeable */ true); + final ActivityRecord activity = createActivity(display, SCREEN_ORIENTATION_PORTRAIT, + task, /* ignoreOrientationRequest */ false); + + final int desiredHeight = + (int) (LANDSCAPE_DISPLAY_BOUNDS.height() * DESKTOP_MODE_INITIAL_BOUNDS_SCALE); + final int desiredWidth = + (int) (desiredHeight / OVERRIDE_MIN_ASPECT_RATIO_MEDIUM_VALUE); + + assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task) + .setActivity(activity).calculate()); + assertEquals(desiredWidth, mResult.mBounds.width()); + assertEquals(desiredHeight, mResult.mBounds.height()); + } + + @Test + @EnableFlags(Flags.FLAG_ENABLE_WINDOWING_DYNAMIC_INITIAL_BOUNDS) + @EnableCompatChanges({ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO, + ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_LARGE}) + public void testLargeAspectRatioOverride_landscapeDevice() { + setupDesktopModeLaunchParamsModifier(); + + final TestDisplayContent display = createDisplayContent(ORIENTATION_LANDSCAPE, + LANDSCAPE_DISPLAY_BOUNDS); + final Task task = createTask(display, /* isResizeable */ true); + final ActivityRecord activity = createActivity(display, SCREEN_ORIENTATION_PORTRAIT, + task, /* ignoreOrientationRequest */ false); + + final int desiredHeight = + (int) (LANDSCAPE_DISPLAY_BOUNDS.height() * DESKTOP_MODE_INITIAL_BOUNDS_SCALE); + final int desiredWidth = + (int) (desiredHeight / OVERRIDE_MIN_ASPECT_RATIO_LARGE_VALUE); + + assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task) + .setActivity(activity).calculate()); + assertEquals(desiredWidth, mResult.mBounds.width()); + assertEquals(desiredHeight, mResult.mBounds.height()); + } + + @Test + @EnableFlags(Flags.FLAG_ENABLE_WINDOWING_DYNAMIC_INITIAL_BOUNDS) + @EnableCompatChanges({ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO, + ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_TO_ALIGN_WITH_SPLIT_SCREEN}) + public void testSplitScreenAspectRatioOverride_landscapeDevice() { + setupDesktopModeLaunchParamsModifier(); + + final TestDisplayContent display = createDisplayContent(ORIENTATION_LANDSCAPE, + LANDSCAPE_DISPLAY_BOUNDS); + final Task task = createTask(display, /* isResizeable */ true); + final ActivityRecord activity = createActivity(display, SCREEN_ORIENTATION_PORTRAIT, + task, /* ignoreOrientationRequest */ false); + + final int desiredHeight = + (int) (LANDSCAPE_DISPLAY_BOUNDS.height() * DESKTOP_MODE_INITIAL_BOUNDS_SCALE); + final int desiredWidth = + (int) (desiredHeight / activity.mAppCompatController + .getAppCompatAspectRatioOverrides().getSplitScreenAspectRatio()); + + assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task) + .setActivity(activity).calculate()); + assertEquals(desiredWidth, mResult.mBounds.width()); + assertEquals(desiredHeight, mResult.mBounds.height()); + } + + @Test + @EnableFlags(Flags.FLAG_ENABLE_WINDOWING_DYNAMIC_INITIAL_BOUNDS) + @EnableCompatChanges({ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO, + ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_SMALL}) + public void testSmallAspectRatioOverride_portraitDevice() { + setupDesktopModeLaunchParamsModifier(); + + final TestDisplayContent display = createDisplayContent(ORIENTATION_PORTRAIT, + PORTRAIT_DISPLAY_BOUNDS); + final Task task = createTask(display, /* isResizeable */ true); + final ActivityRecord activity = createActivity(display, SCREEN_ORIENTATION_PORTRAIT, + task, /* ignoreOrientationRequest */ false); + // Mock desired aspect ratio so min override can take effect. + setDesiredAspectRatio(activity, /* aspectRatio */ 1f); + + final int desiredWidth = + (int) (PORTRAIT_DISPLAY_BOUNDS.width() * DESKTOP_MODE_INITIAL_BOUNDS_SCALE); + final int desiredHeight = (int) (desiredWidth * OVERRIDE_MIN_ASPECT_RATIO_SMALL_VALUE); + + assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task) + .setActivity(activity).calculate()); + assertEquals(desiredWidth, mResult.mBounds.width()); + assertEquals(desiredHeight, mResult.mBounds.height()); + } + + @Test + @EnableFlags(Flags.FLAG_ENABLE_WINDOWING_DYNAMIC_INITIAL_BOUNDS) + @EnableCompatChanges({ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO, + ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_MEDIUM}) + public void testMediumAspectRatioOverride_portraitDevice() { + setupDesktopModeLaunchParamsModifier(); + + final TestDisplayContent display = createDisplayContent(ORIENTATION_PORTRAIT, + PORTRAIT_DISPLAY_BOUNDS); + final Task task = createTask(display, /* isResizeable */ true); + final ActivityRecord activity = createActivity(display, SCREEN_ORIENTATION_PORTRAIT, + task, /* ignoreOrientationRequest */ false); + // Mock desired aspect ratio so min override can take effect. + setDesiredAspectRatio(activity, /* aspectRatio */ 1f); + + final int desiredWidth = + (int) (PORTRAIT_DISPLAY_BOUNDS.width() * DESKTOP_MODE_INITIAL_BOUNDS_SCALE); + final int desiredHeight = (int) (desiredWidth * OVERRIDE_MIN_ASPECT_RATIO_MEDIUM_VALUE); + + assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task) + .setActivity(activity).calculate()); + assertEquals(desiredWidth, mResult.mBounds.width()); + assertEquals(desiredHeight, mResult.mBounds.height()); + } + + @Test + @EnableFlags(Flags.FLAG_ENABLE_WINDOWING_DYNAMIC_INITIAL_BOUNDS) + @EnableCompatChanges({ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO, + ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_LARGE}) + public void testLargeAspectRatioOverride_portraitDevice() { + setupDesktopModeLaunchParamsModifier(); + + final TestDisplayContent display = createDisplayContent(ORIENTATION_PORTRAIT, + PORTRAIT_DISPLAY_BOUNDS); + final Task task = createTask(display, /* isResizeable */ true); + final ActivityRecord activity = createActivity(display, SCREEN_ORIENTATION_PORTRAIT, + task, /* ignoreOrientationRequest */ false); + // Mock desired aspect ratio so min override can take effect. + setDesiredAspectRatio(activity, /* aspectRatio */ 1f); + + final int desiredHeight = + (int) (PORTRAIT_DISPLAY_BOUNDS.height() * DESKTOP_MODE_INITIAL_BOUNDS_SCALE); + final int desiredWidth = (int) (desiredHeight / OVERRIDE_MIN_ASPECT_RATIO_LARGE_VALUE); + + assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task) + .setActivity(activity).calculate()); + assertEquals(desiredWidth, mResult.mBounds.width()); + assertEquals(desiredHeight, mResult.mBounds.height()); + } + + @Test + @EnableFlags(Flags.FLAG_ENABLE_WINDOWING_DYNAMIC_INITIAL_BOUNDS) + @EnableCompatChanges({ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO, + ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_TO_ALIGN_WITH_SPLIT_SCREEN}) + public void testSplitScreenAspectRatioOverride_portraitDevice() { + setupDesktopModeLaunchParamsModifier(); + + final TestDisplayContent display = createDisplayContent(ORIENTATION_PORTRAIT, + PORTRAIT_DISPLAY_BOUNDS); + final Task task = createTask(display, true); + final ActivityRecord activity = createActivity(display, SCREEN_ORIENTATION_PORTRAIT, + task, /* ignoreOrientationRequest */ false); + // Mock desired aspect ratio so min override can take effect. + setDesiredAspectRatio(activity, /* aspectRatio */ 1f); + + final int desiredWidth = + (int) (PORTRAIT_DISPLAY_BOUNDS.width() * DESKTOP_MODE_INITIAL_BOUNDS_SCALE); + final int desiredHeight = (int) (desiredWidth * activity.mAppCompatController + .getAppCompatAspectRatioOverrides().getSplitScreenAspectRatio()); + + assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task) + .setActivity(activity).calculate()); + assertEquals(desiredWidth, mResult.mBounds.width()); + assertEquals(desiredHeight, mResult.mBounds.height()); + } + + @Test + @EnableFlags(Flags.FLAG_ENABLE_WINDOWING_DYNAMIC_INITIAL_BOUNDS) + public void testUserAspectRatio32Override_landscapeDevice() { + setupDesktopModeLaunchParamsModifier(); + + final TestDisplayContent display = createDisplayContent(ORIENTATION_LANDSCAPE, + LANDSCAPE_DISPLAY_BOUNDS); + final Task task = createTask(display, /* isResizeable */ true); + final ActivityRecord activity = createActivity(display, SCREEN_ORIENTATION_UNSPECIFIED, + task, /* ignoreOrientationRequest */ true); + final float userAspectRatioOverrideValue3_2 = 3 / 2f; + applyUserMinAspectRatioOverride(activity, USER_MIN_ASPECT_RATIO_3_2, + userAspectRatioOverrideValue3_2); + + final int desiredHeight = + (int) (LANDSCAPE_DISPLAY_BOUNDS.height() * DESKTOP_MODE_INITIAL_BOUNDS_SCALE); + final int desiredWidth = (int) (desiredHeight / userAspectRatioOverrideValue3_2); + + assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task) + .setActivity(activity).calculate()); + assertEquals(desiredWidth, mResult.mBounds.width()); + assertEquals(desiredHeight, mResult.mBounds.height()); + } + + @Test + @EnableFlags(Flags.FLAG_ENABLE_WINDOWING_DYNAMIC_INITIAL_BOUNDS) + public void testUserAspectRatio43Override_landscapeDevice() { + setupDesktopModeLaunchParamsModifier(); + + final TestDisplayContent display = createDisplayContent(ORIENTATION_LANDSCAPE, + LANDSCAPE_DISPLAY_BOUNDS); + final Task task = createTask(display, /* isResizeable */ true); + final ActivityRecord activity = createActivity(display, SCREEN_ORIENTATION_UNSPECIFIED, + task, /* ignoreOrientationRequest */ true); + final float userAspectRatioOverrideValue4_3 = 4 / 3f; + applyUserMinAspectRatioOverride(activity, USER_MIN_ASPECT_RATIO_4_3, + userAspectRatioOverrideValue4_3); + + final int desiredHeight = + (int) (LANDSCAPE_DISPLAY_BOUNDS.height() * DESKTOP_MODE_INITIAL_BOUNDS_SCALE); + final int desiredWidth = (int) (desiredHeight / userAspectRatioOverrideValue4_3); + + assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task) + .setActivity(activity).calculate()); + assertEquals(desiredWidth, mResult.mBounds.width()); + assertEquals(desiredHeight, mResult.mBounds.height()); + } + + @Test + @EnableFlags(Flags.FLAG_ENABLE_WINDOWING_DYNAMIC_INITIAL_BOUNDS) + public void testUserAspectRatio169Override_landscapeDevice() { + setupDesktopModeLaunchParamsModifier(); + + final TestDisplayContent display = createDisplayContent(ORIENTATION_LANDSCAPE, + LANDSCAPE_DISPLAY_BOUNDS); + final Task task = createTask(display, /* isResizeable */ true); + final ActivityRecord activity = createActivity(display, SCREEN_ORIENTATION_UNSPECIFIED, + task, /* ignoreOrientationRequest */ true); + final float userAspectRatioOverrideValue16_9 = 16 / 9f; + applyUserMinAspectRatioOverride(activity, USER_MIN_ASPECT_RATIO_16_9, + userAspectRatioOverrideValue16_9); + + final int desiredHeight = + (int) (LANDSCAPE_DISPLAY_BOUNDS.height() * DESKTOP_MODE_INITIAL_BOUNDS_SCALE); + final int desiredWidth = (int) (desiredHeight / userAspectRatioOverrideValue16_9); + + assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task) + .setActivity(activity).calculate()); + assertEquals(desiredWidth, mResult.mBounds.width()); + assertEquals(desiredHeight, mResult.mBounds.height()); + } + + @Test + @EnableFlags(Flags.FLAG_ENABLE_WINDOWING_DYNAMIC_INITIAL_BOUNDS) + public void testUserAspectRatioSplitScreenOverride_landscapeDevice() { + setupDesktopModeLaunchParamsModifier(); + + final TestDisplayContent display = createDisplayContent(ORIENTATION_LANDSCAPE, + LANDSCAPE_DISPLAY_BOUNDS); + final Task task = createTask(display, /* isResizeable */ true); + final ActivityRecord activity = createActivity(display, SCREEN_ORIENTATION_UNSPECIFIED, + task, /* ignoreOrientationRequest */ true); + final float userAspectRatioOverrideValueSplitScreen = activity.mAppCompatController + .getAppCompatAspectRatioOverrides().getSplitScreenAspectRatio(); + applyUserMinAspectRatioOverride(activity, USER_MIN_ASPECT_RATIO_SPLIT_SCREEN, + userAspectRatioOverrideValueSplitScreen); + + final int desiredHeight = + (int) (LANDSCAPE_DISPLAY_BOUNDS.height() * DESKTOP_MODE_INITIAL_BOUNDS_SCALE); + final int desiredWidth = (int) (desiredHeight / userAspectRatioOverrideValueSplitScreen); + + assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task) + .setActivity(activity).calculate()); + assertEquals(desiredWidth, mResult.mBounds.width()); + assertEquals(desiredHeight, mResult.mBounds.height()); + } + + @Test + @EnableFlags(Flags.FLAG_ENABLE_WINDOWING_DYNAMIC_INITIAL_BOUNDS) + public void testUserAspectRatioDisplaySizeOverride_landscapeDevice() { + setupDesktopModeLaunchParamsModifier(); + + final TestDisplayContent display = createDisplayContent(ORIENTATION_LANDSCAPE, + LANDSCAPE_DISPLAY_BOUNDS); + final Task task = createTask(display, /* isResizeable */ true); + final ActivityRecord activity = createActivity(display, SCREEN_ORIENTATION_UNSPECIFIED, + task, /* ignoreOrientationRequest */ true); + final float userAspectRatioOverrideValueDisplaySize = activity.mAppCompatController + .getAppCompatAspectRatioOverrides().getDisplaySizeMinAspectRatio(); + applyUserMinAspectRatioOverride(activity, USER_MIN_ASPECT_RATIO_DISPLAY_SIZE, + userAspectRatioOverrideValueDisplaySize); + + final int desiredHeight = + (int) (LANDSCAPE_DISPLAY_BOUNDS.height() * DESKTOP_MODE_INITIAL_BOUNDS_SCALE); + final int desiredWidth = (int) (desiredHeight / userAspectRatioOverrideValueDisplaySize); + + assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task) + .setActivity(activity).calculate()); + assertEquals(desiredWidth, mResult.mBounds.width()); + assertEquals(desiredHeight, mResult.mBounds.height()); + } + + @Test + @EnableFlags(Flags.FLAG_ENABLE_WINDOWING_DYNAMIC_INITIAL_BOUNDS) + public void testUserAspectRatio32Override_portraitDevice() { + setupDesktopModeLaunchParamsModifier(); + + final TestDisplayContent display = createDisplayContent(ORIENTATION_PORTRAIT, + PORTRAIT_DISPLAY_BOUNDS); + final Task task = createTask(display, /* isResizeable */ true); + final ActivityRecord activity = createActivity(display, SCREEN_ORIENTATION_UNSPECIFIED, + task, /* ignoreOrientationRequest */ true); + final float userAspectRatioOverrideValue3_2 = 3 / 2f; + applyUserMinAspectRatioOverride(activity, USER_MIN_ASPECT_RATIO_3_2, + userAspectRatioOverrideValue3_2); + + final int desiredWidth = + (int) (PORTRAIT_DISPLAY_BOUNDS.width() * DESKTOP_MODE_INITIAL_BOUNDS_SCALE); + final int desiredHeight = (int) (desiredWidth * userAspectRatioOverrideValue3_2); + + assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task) + .setActivity(activity).calculate()); + assertEquals(desiredWidth, mResult.mBounds.width()); + assertEquals(desiredHeight, mResult.mBounds.height()); + } + + @Test + @EnableFlags(Flags.FLAG_ENABLE_WINDOWING_DYNAMIC_INITIAL_BOUNDS) + public void testUserAspectRatio43Override_portraitDevice() { + setupDesktopModeLaunchParamsModifier(); + + final TestDisplayContent display = createDisplayContent(ORIENTATION_PORTRAIT, + PORTRAIT_DISPLAY_BOUNDS); + final Task task = createTask(display, /* isResizeable */ true); + final ActivityRecord activity = createActivity(display, SCREEN_ORIENTATION_UNSPECIFIED, + task, /* ignoreOrientationRequest */ true); + final float userAspectRatioOverrideValue4_3 = 4 / 3f; + applyUserMinAspectRatioOverride(activity, USER_MIN_ASPECT_RATIO_4_3, + userAspectRatioOverrideValue4_3); + + final int desiredWidth = + (int) (PORTRAIT_DISPLAY_BOUNDS.width() * DESKTOP_MODE_INITIAL_BOUNDS_SCALE); + final int desiredHeight = (int) (desiredWidth * userAspectRatioOverrideValue4_3); + + assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task) + .setActivity(activity).calculate()); + assertEquals(desiredWidth, mResult.mBounds.width()); + assertEquals(desiredHeight, mResult.mBounds.height()); + } + + @Test + @EnableFlags(Flags.FLAG_ENABLE_WINDOWING_DYNAMIC_INITIAL_BOUNDS) + public void testUserAspectRatio169Override_portraitDevice() { + setupDesktopModeLaunchParamsModifier(); + + final TestDisplayContent display = createDisplayContent(ORIENTATION_PORTRAIT, + PORTRAIT_DISPLAY_BOUNDS); + final Task task = createTask(display, /* isResizeable */ true); + final ActivityRecord activity = createActivity(display, SCREEN_ORIENTATION_UNSPECIFIED, + task, /* ignoreOrientationRequest */ true); + final float userAspectRatioOverrideValue16_9 = 16 / 9f; + applyUserMinAspectRatioOverride(activity, USER_MIN_ASPECT_RATIO_16_9, + userAspectRatioOverrideValue16_9); + + final int desiredHeight = + (int) (PORTRAIT_DISPLAY_BOUNDS.height() * DESKTOP_MODE_INITIAL_BOUNDS_SCALE); + final int desiredWidth = (int) (desiredHeight / userAspectRatioOverrideValue16_9); + + assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task) + .setActivity(activity).calculate()); + assertEquals(desiredWidth, mResult.mBounds.width()); + assertEquals(desiredHeight, mResult.mBounds.height()); + } + + @Test + @EnableFlags(Flags.FLAG_ENABLE_WINDOWING_DYNAMIC_INITIAL_BOUNDS) + public void testUserAspectRatioSplitScreenOverride_portraitDevice() { + setupDesktopModeLaunchParamsModifier(); + + final TestDisplayContent display = createDisplayContent(ORIENTATION_PORTRAIT, + PORTRAIT_DISPLAY_BOUNDS); + final Task task = createTask(display, /* isResizeable */ true); + final ActivityRecord activity = createActivity(display, SCREEN_ORIENTATION_UNSPECIFIED, + task, /* ignoreOrientationRequest */ true); + final float userAspectRatioOverrideValueSplitScreen = activity.mAppCompatController + .getAppCompatAspectRatioOverrides().getSplitScreenAspectRatio(); + applyUserMinAspectRatioOverride(activity, USER_MIN_ASPECT_RATIO_SPLIT_SCREEN, + userAspectRatioOverrideValueSplitScreen); + + final int desiredWidth = + (int) (PORTRAIT_DISPLAY_BOUNDS.width() * DESKTOP_MODE_INITIAL_BOUNDS_SCALE); + final int desiredHeight = (int) (desiredWidth * userAspectRatioOverrideValueSplitScreen); + + assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task) + .setActivity(activity).calculate()); + assertEquals(desiredWidth, mResult.mBounds.width()); + assertEquals(desiredHeight, mResult.mBounds.height()); + } + + @Test + @EnableFlags(Flags.FLAG_ENABLE_WINDOWING_DYNAMIC_INITIAL_BOUNDS) + public void testUserAspectRatioDisplaySizeOverride_portraitDevice() { + setupDesktopModeLaunchParamsModifier(); + + final TestDisplayContent display = createDisplayContent(ORIENTATION_PORTRAIT, + PORTRAIT_DISPLAY_BOUNDS); + final Task task = createTask(display, /* isResizeable */ true); + final ActivityRecord activity = createActivity(display, SCREEN_ORIENTATION_UNSPECIFIED, + task, /* ignoreOrientationRequest */ true); + final float userAspectRatioOverrideValueDisplaySize = activity.mAppCompatController + .getAppCompatAspectRatioOverrides().getDisplaySizeMinAspectRatio(); + applyUserMinAspectRatioOverride(activity, USER_MIN_ASPECT_RATIO_DISPLAY_SIZE, + userAspectRatioOverrideValueDisplaySize); + + final int desiredWidth = + (int) (PORTRAIT_DISPLAY_BOUNDS.width() * DESKTOP_MODE_INITIAL_BOUNDS_SCALE); + final int desiredHeight = (int) (desiredWidth * userAspectRatioOverrideValueDisplaySize); + + assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task) + .setActivity(activity).calculate()); assertEquals(desiredWidth, mResult.mBounds.width()); assertEquals(desiredHeight, mResult.mBounds.height()); } @@ -310,14 +785,18 @@ public class DesktopModeLaunchParamsModifierTests extends final TestDisplayContent display = createDisplayContent(ORIENTATION_LANDSCAPE, LANDSCAPE_DISPLAY_BOUNDS); - final Task task = createTask(display, SCREEN_ORIENTATION_LANDSCAPE, false); + final Task task = createTask(display, /* isResizeable */ false); + final ActivityRecord activity = createActivity(display, SCREEN_ORIENTATION_LANDSCAPE, + task, /* ignoreOrientationRequest */ true); + final int desiredWidth = (int) (LANDSCAPE_DISPLAY_BOUNDS.width() * DESKTOP_MODE_INITIAL_BOUNDS_SCALE); final int desiredHeight = (int) (LANDSCAPE_DISPLAY_BOUNDS.height() * DESKTOP_MODE_INITIAL_BOUNDS_SCALE); - assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task).calculate()); + assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task) + .setActivity(activity).calculate()); assertEquals(desiredWidth, mResult.mBounds.width()); assertEquals(desiredHeight, mResult.mBounds.height()); } @@ -326,18 +805,23 @@ public class DesktopModeLaunchParamsModifierTests extends @EnableFlags(Flags.FLAG_ENABLE_WINDOWING_DYNAMIC_INITIAL_BOUNDS) public void testUnResizablePortraitBounds_landscapeDevice_unResizable_portraitOrientation() { setupDesktopModeLaunchParamsModifier(); - doReturn(LETTERBOX_ASPECT_RATIO).when(() - -> calculateAspectRatio(any(), any())); final TestDisplayContent display = createDisplayContent(ORIENTATION_LANDSCAPE, LANDSCAPE_DISPLAY_BOUNDS); - final Task task = createTask(display, SCREEN_ORIENTATION_PORTRAIT, false); + final Task task = createTask(display, /* isResizeable */ false); + final ActivityRecord activity = createActivity(display, SCREEN_ORIENTATION_PORTRAIT, + task, /* ignoreOrientationRequest */ true); + + spyOn(activity.mAppCompatController.getDesktopAppCompatAspectRatioPolicy()); + doReturn(LETTERBOX_ASPECT_RATIO).when(activity.mAppCompatController + .getDesktopAppCompatAspectRatioPolicy()).calculateAspectRatio(any()); final int desiredHeight = (int) (LANDSCAPE_DISPLAY_BOUNDS.height() * DESKTOP_MODE_INITIAL_BOUNDS_SCALE); final int desiredWidth = (int) (desiredHeight / LETTERBOX_ASPECT_RATIO); - assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task).calculate()); + assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task) + .setActivity(activity).calculate()); assertEquals(desiredWidth, mResult.mBounds.width()); assertEquals(desiredHeight, mResult.mBounds.height()); } @@ -350,14 +834,17 @@ public class DesktopModeLaunchParamsModifierTests extends final TestDisplayContent display = createDisplayContent(ORIENTATION_PORTRAIT, PORTRAIT_DISPLAY_BOUNDS); - final Task task = createTask(display, SCREEN_ORIENTATION_UNSPECIFIED, true); + final Task task = createTask(display, /* isResizeable */ true); + final ActivityRecord activity = createActivity(display, SCREEN_ORIENTATION_UNSPECIFIED, + task, /* ignoreOrientationRequest */ true); final int desiredWidth = (int) (PORTRAIT_DISPLAY_BOUNDS.width() * DESKTOP_MODE_INITIAL_BOUNDS_SCALE); final int desiredHeight = (int) (PORTRAIT_DISPLAY_BOUNDS.height() * DESKTOP_MODE_INITIAL_BOUNDS_SCALE); - assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task).calculate()); + assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task) + .setActivity(activity).calculate()); assertEquals(desiredWidth, mResult.mBounds.width()); assertEquals(desiredHeight, mResult.mBounds.height()); } @@ -370,14 +857,17 @@ public class DesktopModeLaunchParamsModifierTests extends final TestDisplayContent display = createDisplayContent(ORIENTATION_PORTRAIT, PORTRAIT_DISPLAY_BOUNDS); - final Task task = createTask(display, SCREEN_ORIENTATION_PORTRAIT, true); + final Task task = createTask(display, /* isResizeable */ true); + final ActivityRecord activity = createActivity(display, SCREEN_ORIENTATION_PORTRAIT, + task, /* ignoreOrientationRequest */ true); final int desiredWidth = (int) (PORTRAIT_DISPLAY_BOUNDS.width() * DESKTOP_MODE_INITIAL_BOUNDS_SCALE); final int desiredHeight = (int) (PORTRAIT_DISPLAY_BOUNDS.height() * DESKTOP_MODE_INITIAL_BOUNDS_SCALE); - assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task).calculate()); + assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task) + .setActivity(activity).calculate()); assertEquals(desiredWidth, mResult.mBounds.width()); assertEquals(desiredHeight, mResult.mBounds.height()); } @@ -390,11 +880,13 @@ public class DesktopModeLaunchParamsModifierTests extends final TestDisplayContent display = createDisplayContent(ORIENTATION_PORTRAIT, PORTRAIT_DISPLAY_BOUNDS); - final Task task = createTask(display, SCREEN_ORIENTATION_PORTRAIT, true); + final Task task = createTask(display, /* isResizeable */ true); + final ActivityRecord activity = createActivity(display, SCREEN_ORIENTATION_PORTRAIT, + task, /* ignoreOrientationRequest */ true); - spyOn(mActivity.mAppCompatController.getAppCompatAspectRatioOverrides()); + spyOn(activity.mAppCompatController.getAppCompatAspectRatioOverrides()); doReturn(true).when( - mActivity.mAppCompatController.getAppCompatAspectRatioOverrides()) + activity.mAppCompatController.getAppCompatAspectRatioOverrides()) .isUserFullscreenOverrideEnabled(); final int desiredWidth = @@ -402,7 +894,8 @@ public class DesktopModeLaunchParamsModifierTests extends final int desiredHeight = (int) (PORTRAIT_DISPLAY_BOUNDS.height() * DESKTOP_MODE_INITIAL_BOUNDS_SCALE); - assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task).calculate()); + assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task) + .setActivity(activity).calculate()); assertEquals(desiredWidth, mResult.mBounds.width()); assertEquals(desiredHeight, mResult.mBounds.height()); } @@ -415,11 +908,13 @@ public class DesktopModeLaunchParamsModifierTests extends final TestDisplayContent display = createDisplayContent(ORIENTATION_PORTRAIT, PORTRAIT_DISPLAY_BOUNDS); - final Task task = createTask(display, SCREEN_ORIENTATION_PORTRAIT, true); + final Task task = createTask(display, /* isResizeable */ true); + final ActivityRecord activity = createActivity(display, SCREEN_ORIENTATION_PORTRAIT, + task, /* ignoreOrientationRequest */ true); - spyOn(mActivity.mAppCompatController.getAppCompatAspectRatioOverrides()); + spyOn(activity.mAppCompatController.getAppCompatAspectRatioOverrides()); doReturn(true).when( - mActivity.mAppCompatController.getAppCompatAspectRatioOverrides()) + activity.mAppCompatController.getAppCompatAspectRatioOverrides()) .isSystemOverrideToFullscreenEnabled(); final int desiredWidth = @@ -427,7 +922,8 @@ public class DesktopModeLaunchParamsModifierTests extends final int desiredHeight = (int) (PORTRAIT_DISPLAY_BOUNDS.height() * DESKTOP_MODE_INITIAL_BOUNDS_SCALE); - assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task).calculate()); + assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task) + .setActivity(activity).calculate()); assertEquals(desiredWidth, mResult.mBounds.width()); assertEquals(desiredHeight, mResult.mBounds.height()); } @@ -436,19 +932,24 @@ public class DesktopModeLaunchParamsModifierTests extends @EnableFlags(Flags.FLAG_ENABLE_WINDOWING_DYNAMIC_INITIAL_BOUNDS) public void testResizableLandscapeBounds_portraitDevice_resizable_landscapeOrientation() { setupDesktopModeLaunchParamsModifier(); - doReturn(LETTERBOX_ASPECT_RATIO).when(() - -> calculateAspectRatio(any(), any())); final TestDisplayContent display = createDisplayContent(ORIENTATION_PORTRAIT, PORTRAIT_DISPLAY_BOUNDS); - final Task task = createTask(display, SCREEN_ORIENTATION_LANDSCAPE, true); + final Task task = createTask(display, /* isResizeable */ true); + final ActivityRecord activity = createActivity(display, SCREEN_ORIENTATION_LANDSCAPE, + task, /* ignoreOrientationRequest */ true); + + spyOn(activity.mAppCompatController.getDesktopAppCompatAspectRatioPolicy()); + doReturn(LETTERBOX_ASPECT_RATIO).when(activity.mAppCompatController + .getDesktopAppCompatAspectRatioPolicy()).calculateAspectRatio(any()); final int desiredWidth = PORTRAIT_DISPLAY_BOUNDS.width() - (DESKTOP_MODE_LANDSCAPE_APP_PADDING * 2); final int desiredHeight = (int) ((PORTRAIT_DISPLAY_BOUNDS.width() / LETTERBOX_ASPECT_RATIO) + 0.5f); - assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task).calculate()); + assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task) + .setActivity(activity).calculate()); assertEquals(desiredWidth, mResult.mBounds.width()); assertEquals(desiredHeight, mResult.mBounds.height()); } @@ -461,14 +962,18 @@ public class DesktopModeLaunchParamsModifierTests extends final TestDisplayContent display = createDisplayContent(ORIENTATION_PORTRAIT, PORTRAIT_DISPLAY_BOUNDS); - final Task task = createTask(display, SCREEN_ORIENTATION_PORTRAIT, false); + final Task task = createTask(display, /* isResizeable */ false); + final ActivityRecord activity = createActivity(display, SCREEN_ORIENTATION_PORTRAIT, + task, /* ignoreOrientationRequest */ true); + final int desiredWidth = (int) (PORTRAIT_DISPLAY_BOUNDS.width() * DESKTOP_MODE_INITIAL_BOUNDS_SCALE); final int desiredHeight = (int) (PORTRAIT_DISPLAY_BOUNDS.height() * DESKTOP_MODE_INITIAL_BOUNDS_SCALE); - assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task).calculate()); + assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task) + .setActivity(activity).calculate()); assertEquals(desiredWidth, mResult.mBounds.width()); assertEquals(desiredHeight, mResult.mBounds.height()); } @@ -477,18 +982,23 @@ public class DesktopModeLaunchParamsModifierTests extends @EnableFlags(Flags.FLAG_ENABLE_WINDOWING_DYNAMIC_INITIAL_BOUNDS) public void testUnResizableLandscapeBounds_portraitDevice_unResizable_landscapeOrientation() { setupDesktopModeLaunchParamsModifier(); - doReturn(LETTERBOX_ASPECT_RATIO).when(() - -> calculateAspectRatio(any(), any())); final TestDisplayContent display = createDisplayContent(ORIENTATION_PORTRAIT, PORTRAIT_DISPLAY_BOUNDS); - final Task task = createTask(display, SCREEN_ORIENTATION_LANDSCAPE, false); + final Task task = createTask(display, /* isResizeable */ false); + final ActivityRecord activity = createActivity(display, SCREEN_ORIENTATION_LANDSCAPE, + task, /* ignoreOrientationRequest */ true); + + spyOn(activity.mAppCompatController.getDesktopAppCompatAspectRatioPolicy()); + doReturn(LETTERBOX_ASPECT_RATIO).when(activity.mAppCompatController + .getDesktopAppCompatAspectRatioPolicy()).calculateAspectRatio(any()); final int desiredWidth = PORTRAIT_DISPLAY_BOUNDS.width() - (DESKTOP_MODE_LANDSCAPE_APP_PADDING * 2); final int desiredHeight = (int) (desiredWidth / LETTERBOX_ASPECT_RATIO); - assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task).calculate()); + assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().setTask(task) + .setActivity(activity).calculate()); assertEquals(desiredWidth, mResult.mBounds.width()); assertEquals(desiredHeight, mResult.mBounds.height()); } @@ -755,24 +1265,64 @@ public class DesktopModeLaunchParamsModifierTests extends assertEquals(WINDOWING_MODE_FREEFORM, mResult.mWindowingMode); } - private Task createTask(DisplayContent display, int orientation, Boolean isResizeable) { + private Task createTask(DisplayContent display, Boolean isResizeable) { final int resizeMode = isResizeable ? RESIZE_MODE_RESIZEABLE : RESIZE_MODE_UNRESIZEABLE; final Task task = new TaskBuilder(mSupervisor).setActivityType( ACTIVITY_TYPE_STANDARD).setDisplay(display).build(); task.setResizeMode(resizeMode); - mActivity = new ActivityBuilder(task.mAtmService) + return task; + } + + private ActivityRecord createActivity(DisplayContent display, int orientation, Task task, + boolean ignoreOrientationRequest) { + final ActivityRecord activity = new ActivityBuilder(task.mAtmService) .setTask(task) + .setComponent(ComponentName.createRelative(task.mAtmService.mContext, + DesktopModeLaunchParamsModifierTests.class.getName())) + .setUid(android.os.Process.myUid()) .setScreenOrientation(orientation) .setOnTop(true).build(); + activity.onDisplayChanged(display); + activity.setOccludesParent(true); + activity.setVisible(true); + activity.setVisibleRequested(true); + activity.mDisplayContent.setIgnoreOrientationRequest(ignoreOrientationRequest); - mActivity.onDisplayChanged(display); - mActivity.setOccludesParent(true); - mActivity.setVisible(true); - mActivity.setVisibleRequested(true); - mActivity.mDisplayContent.setIgnoreOrientationRequest(/* ignoreOrientationRequest */ true); + return activity; + } - return task; + private void setDesiredAspectRatio(ActivityRecord activity, float aspectRatio) { + final DesktopAppCompatAspectRatioPolicy desktopAppCompatAspectRatioPolicy = + activity.mAppCompatController.getDesktopAppCompatAspectRatioPolicy(); + spyOn(desktopAppCompatAspectRatioPolicy); + doReturn(aspectRatio).when(desktopAppCompatAspectRatioPolicy) + .getDesiredAspectRatio(any()); + } + + private void applyUserMinAspectRatioOverride(ActivityRecord activity, int overrideCode, + float overrideValue) { + // Set desired aspect ratio to be below minimum so override can take effect. + final DesktopAppCompatAspectRatioPolicy desktopAppCompatAspectRatioPolicy = + activity.mAppCompatController.getDesktopAppCompatAspectRatioPolicy(); + spyOn(desktopAppCompatAspectRatioPolicy); + doReturn(1f).when(desktopAppCompatAspectRatioPolicy) + .getDesiredAspectRatio(any()); + + // Enable user aspect ratio settings + final AppCompatConfiguration appCompatConfiguration = + activity.mWmService.mAppCompatConfiguration; + spyOn(appCompatConfiguration); + doReturn(true).when(appCompatConfiguration) + .isUserAppAspectRatioSettingsEnabled(); + + // Simulate user min aspect ratio override being set. + final AppCompatAspectRatioOverrides appCompatAspectRatioOverrides = + activity.mAppCompatController.getAppCompatAspectRatioOverrides(); + spyOn(appCompatAspectRatioOverrides); + doReturn(overrideValue).when(appCompatAspectRatioOverrides).getUserMinAspectRatio(); + doReturn(overrideCode).when(appCompatAspectRatioOverrides) + .getUserMinAspectRatioOverrideCode(); } private TestDisplayContent createDisplayContent(int orientation, Rect displayBounds) { diff --git a/services/tests/wmtests/src/com/android/server/wm/SizeCompatTests.java b/services/tests/wmtests/src/com/android/server/wm/SizeCompatTests.java index 65e3baad87d1..1e1055bb233a 100644 --- a/services/tests/wmtests/src/com/android/server/wm/SizeCompatTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/SizeCompatTests.java @@ -2394,7 +2394,13 @@ public class SizeCompatTests extends WindowTestsBase { private void testUserOverrideAspectRatio(boolean isUnresizable, int screenOrientation, float expectedAspectRatio, @PackageManager.UserMinAspectRatio int aspectRatio, boolean enabled) { - final ActivityRecord activity = getActivityBuilderOnSameTask().build(); + final ActivityRecord activity = getActivityBuilderWithoutTask().build(); + final DesktopAppCompatAspectRatioPolicy desktopAppCompatAspectRatioPolicy = + activity.mAppCompatController.getDesktopAppCompatAspectRatioPolicy(); + spyOn(desktopAppCompatAspectRatioPolicy); + doReturn(enabled).when(desktopAppCompatAspectRatioPolicy) + .hasMinAspectRatioOverride(any()); + mTask.addChild(activity); activity.mDisplayContent.setIgnoreOrientationRequest(true /* ignoreOrientationRequest */); spyOn(activity.mWmService.mAppCompatConfiguration); doReturn(enabled).when(activity.mWmService.mAppCompatConfiguration) @@ -4944,8 +4950,11 @@ public class SizeCompatTests extends WindowTestsBase { } private ActivityBuilder getActivityBuilderOnSameTask() { + return getActivityBuilderWithoutTask().setTask(mTask); + } + + private ActivityBuilder getActivityBuilderWithoutTask() { return new ActivityBuilder(mAtm) - .setTask(mTask) .setComponent(ComponentName.createRelative(mContext, SizeCompatTests.class.getName())) .setUid(android.os.Process.myUid()); |