From 215e9c0f3b0ca4165735852fb962dacaa493b91f Mon Sep 17 00:00:00 2001 From: Marzia Favaro Date: Wed, 23 Oct 2024 10:45:17 +0000 Subject: [PATCH] Override aspect ratio to fullscreen when unset for universal resizeable Bug: 374968702 Test: UserAspectRatioDetailsTest Test: UserAspectRatioManagerTest Test: manual, verify which option is selected by default after app installation Flag: com.android.window.flags.universal_resizable_by_default Change-Id: I04063e4a130d42a4bfd7e548940ca5e654a6d012 --- .../appcompat/UserAspectRatioManager.java | 40 ++++++++-- .../appcompat/UserAspectRatioManagerTest.java | 76 ++++++++++++++++--- 2 files changed, 100 insertions(+), 16 deletions(-) diff --git a/src/com/android/settings/applications/appcompat/UserAspectRatioManager.java b/src/com/android/settings/applications/appcompat/UserAspectRatioManager.java index 0550a9af426..db239aabffc 100644 --- a/src/com/android/settings/applications/appcompat/UserAspectRatioManager.java +++ b/src/com/android/settings/applications/appcompat/UserAspectRatioManager.java @@ -36,6 +36,7 @@ import static java.lang.Boolean.FALSE; import android.app.AppGlobals; import android.app.compat.CompatChanges; import android.content.Context; +import android.content.pm.ActivityInfo; import android.content.pm.ApplicationInfo; import android.content.pm.IPackageManager; import android.content.pm.LauncherApps; @@ -44,6 +45,7 @@ import android.os.RemoteException; import android.os.UserHandle; import android.provider.DeviceConfig; import android.util.ArrayMap; +import android.util.Log; import android.util.SparseIntArray; import androidx.annotation.NonNull; @@ -71,6 +73,7 @@ public class UserAspectRatioManager { private static final boolean DEFAULT_VALUE_ENABLE_USER_ASPECT_RATIO_FULLSCREEN = true; final boolean mIsUserMinAspectRatioAppDefaultFlagEnabled = Flags.userMinAspectRatioAppDefault(); + private final boolean mIgnoreActivityOrientationRequest; private final Context mContext; private final IPackageManager mIPm; @@ -90,6 +93,8 @@ public class UserAspectRatioManager { mUserAspectRatioA11yMap = new ArrayMap<>(); mUserAspectRatioOrder = new SparseIntArray(); mUserAspectRatioMap = getUserMinAspectRatioMapping(); + mIgnoreActivityOrientationRequest = getValueFromDeviceConfig( + "ignore_activity_orientation_request", false); } /** @@ -113,6 +118,24 @@ public class UserAspectRatioManager { ? aspectRatio : USER_MIN_ASPECT_RATIO_UNSET; } + // TODO b/374903057 reuse method from ActivityRecord + boolean isUniversalResizeable(@NonNull String packageName, int userId) { + try { + final ApplicationInfo info = mIPm.getApplicationInfo( + packageName, 0 /* flags */, userId); + if (info == null || info.category == ApplicationInfo.CATEGORY_GAME) { + return false; + } + final boolean compatEnabled = Flags.universalResizableByDefault() + && info.isChangeEnabled(ActivityInfo.UNIVERSAL_RESIZABLE_BY_DEFAULT); + return compatEnabled || mIgnoreActivityOrientationRequest; + } catch (RemoteException e) { + Log.e("UserAspectRatioManager", "Could not access application info for " + + packageName + ":\n" + e); + return false; + } + } + /** * @return corresponding string for {@link PackageManager.UserMinAspectRatio} value */ @@ -127,7 +150,7 @@ public class UserAspectRatioManager { return appDefault; } - return isCurrentSelectionFromManufacturerOverride(packageName, userId, aspectRatio) + return isUnsetAndRequiresFullscreenOverride(packageName, userId, aspectRatio) ? getUserMinAspectRatioEntry(USER_MIN_ASPECT_RATIO_FULLSCREEN, packageName, userId) : mUserAspectRatioMap.getOrDefault(aspectRatio, appDefault); } @@ -139,7 +162,7 @@ public class UserAspectRatioManager { public CharSequence getAccessibleEntry(@PackageManager.UserMinAspectRatio int aspectRatio, @NonNull String packageName) { final int userId = mContext.getUserId(); - return isCurrentSelectionFromManufacturerOverride(packageName, userId, aspectRatio) + return isUnsetAndRequiresFullscreenOverride(packageName, userId, aspectRatio) ? getAccessibleEntry(USER_MIN_ASPECT_RATIO_FULLSCREEN, packageName) : mUserAspectRatioA11yMap.getOrDefault(aspectRatio, getUserMinAspectRatioEntry(aspectRatio, packageName, userId)); @@ -203,7 +226,7 @@ public class UserAspectRatioManager { @PackageManager.UserMinAspectRatio int userOverride) { return (userOverride != USER_MIN_ASPECT_RATIO_UNSET && userOverride != USER_MIN_ASPECT_RATIO_APP_DEFAULT) - || isCurrentSelectionFromManufacturerOverride(app.packageName, getUserId(app.uid), + || isUnsetAndRequiresFullscreenOverride(app.packageName, getUserId(app.uid), userOverride); } @@ -224,7 +247,7 @@ public class UserAspectRatioManager { /** * Whether the device manufacturer has overridden app's orientation to * {@link android.content.pm.ActivityInfo#SCREEN_ORIENTATION_USER} to force app to fullscreen - * and app has not opted-out from the treatment + * or app is universal resizeable, and app has not opted-out from the treatment */ boolean isOverrideToFullscreenEnabled(String pkgName, int userId) { Boolean appAllowsOrientationOverride = readComponentProperty(mContext.getPackageManager(), @@ -232,7 +255,8 @@ public class UserAspectRatioManager { return mIsUserMinAspectRatioAppDefaultFlagEnabled && hasAspectRatioOption(USER_MIN_ASPECT_RATIO_FULLSCREEN, pkgName) && !FALSE.equals(appAllowsOrientationOverride) - && isFullscreenCompatChangeEnabled(pkgName, userId); + && (isFullscreenCompatChangeEnabled(pkgName, userId) + || isUniversalResizeable(pkgName, userId)); } boolean isFullscreenCompatChangeEnabled(String pkgName, int userId) { @@ -240,7 +264,11 @@ public class UserAspectRatioManager { OVERRIDE_ANY_ORIENTATION_TO_USER, pkgName, UserHandle.of(userId)); } - private boolean isCurrentSelectionFromManufacturerOverride(String pkgName, int userId, + /** + * Whether the aspect ratio is unset and we desire to interpret it as fullscreen rather than + * app default because of manufacturer override or because the app is universal resizeable + */ + private boolean isUnsetAndRequiresFullscreenOverride(String pkgName, int userId, @PackageManager.UserMinAspectRatio int aspectRatio) { return aspectRatio == USER_MIN_ASPECT_RATIO_UNSET && isOverrideToFullscreenEnabled(pkgName, userId); diff --git a/tests/unit/src/com/android/settings/applications/appcompat/UserAspectRatioManagerTest.java b/tests/unit/src/com/android/settings/applications/appcompat/UserAspectRatioManagerTest.java index 342212afc7b..4c0755510b6 100644 --- a/tests/unit/src/com/android/settings/applications/appcompat/UserAspectRatioManagerTest.java +++ b/tests/unit/src/com/android/settings/applications/appcompat/UserAspectRatioManagerTest.java @@ -331,9 +331,7 @@ public class UserAspectRatioManagerTest { .isEqualTo(getUserMinAspectRatioEntry(USER_MIN_ASPECT_RATIO_UNSET, mPackageName)); } - @Test - public void testGetUserMinAspectRatioEntry_enabledFullscreenOverride_returnsFullscreen() { - setIsOverrideToFullscreenEnabled(true); + private void assertUnsetIsFullscreen() { // Fullscreen option is pre-selected assertThat(getUserMinAspectRatioEntry(USER_MIN_ASPECT_RATIO_UNSET, mPackageName)) .isEqualTo(ResourcesUtils.getResourcesString( @@ -347,9 +345,7 @@ public class UserAspectRatioManagerTest { "user_aspect_ratio_app_default")); } - @Test - public void testGetUserMinAspectRatioEntry_disabledFullscreenOverride_returnsUnchanged() { - setIsOverrideToFullscreenEnabled(false); + private void assertUnsetIsAppDefault() { // Fullscreen option is not pre-selected assertThat(getUserMinAspectRatioEntry(USER_MIN_ASPECT_RATIO_UNSET, mPackageName)) .isEqualTo(ResourcesUtils.getResourcesString( @@ -358,9 +354,43 @@ public class UserAspectRatioManagerTest { } @Test - public void testIsOverrideToFullscreenEnabled_returnsTrue() + public void testGetUserMinAspectRatioEntry_enabledFullscreenCompatChange_returnsFullscreen() { + setIsOverrideToFullscreenEnabledBecauseCompatChange(true); + assertUnsetIsFullscreen(); + } + + @Test + public void testGetUserMinAspectRatioEntry_enabledFullscreenOverrideUniRes_returnsFullscreen() { + setIsOverrideToFullscreenEnabledBecauseUniversalResizeable(true); + assertUnsetIsFullscreen(); + } + + @Test + public void testGetUserMinAspectRatioEntry_noFullscreenCompatChange_returnsUnchanged() { + setIsOverrideToFullscreenEnabledBecauseCompatChange(false); + assertUnsetIsAppDefault(); + } + + @Test + public void testGetUserMinAspectRatioEntry_noFullscreenUnivRes_returnsUnchanged() { + setIsOverrideToFullscreenEnabledBecauseUniversalResizeable(false); + assertUnsetIsAppDefault(); + } + + @Test + public void testIsOverrideToFullscreenEnabledCompatChange_returnsTrue() throws PackageManager.NameNotFoundException { - setIsOverrideToFullscreenEnabled(true); + setIsOverrideToFullscreenEnabledBecauseCompatChange(true); + assertTrue(mUtils.isOverrideToFullscreenEnabled(mPackageName, mContext.getUserId())); + + mockProperty(PROPERTY_COMPAT_ALLOW_ORIENTATION_OVERRIDE, true); + assertTrue(mUtils.isOverrideToFullscreenEnabled(mPackageName, mContext.getUserId())); + } + + @Test + public void testIsOverrideToFullscreenEnabledUnivRes_returnsTrue() + throws PackageManager.NameNotFoundException { + setIsOverrideToFullscreenEnabledBecauseUniversalResizeable(true); assertTrue(mUtils.isOverrideToFullscreenEnabled(mPackageName, mContext.getUserId())); mockProperty(PROPERTY_COMPAT_ALLOW_ORIENTATION_OVERRIDE, true); @@ -370,7 +400,7 @@ public class UserAspectRatioManagerTest { @Test public void testIsOverrideToFullscreenEnabled_optOut_returnsFalse() throws PackageManager.NameNotFoundException { - setIsOverrideToFullscreenEnabled(true); + setIsOverrideToFullscreenEnabledBecauseCompatChange(true); mockProperty(PROPERTY_COMPAT_ALLOW_ORIENTATION_OVERRIDE, false); assertFalse(mUtils.isOverrideToFullscreenEnabled(mPackageName, mContext.getUserId())); } @@ -381,6 +411,12 @@ public class UserAspectRatioManagerTest { assertFalse(mUtils.isOverrideToFullscreenEnabled(mPackageName, mContext.getUserId())); } + @Test + public void testIsOverrideToFullscreenEnabledUnivRes_flagDisabled_returnsFalse() { + mUtils.setFullscreenCompatChange(true); + assertFalse(mUtils.isOverrideToFullscreenEnabled(mPackageName, mContext.getUserId())); + } + @Test public void testIsOverrideToFullscreenEnabled_optionDisabled_returnsFalse() { mUtils.setFullscreenCompatChange(true); @@ -389,7 +425,7 @@ public class UserAspectRatioManagerTest { assertFalse(mUtils.isOverrideToFullscreenEnabled(mPackageName, mContext.getUserId())); } - private void setIsOverrideToFullscreenEnabled(boolean enabled) { + private void setIsOverrideToFullscreenEnabledBecauseCompatChange(boolean enabled) { if (enabled) { mSetFlagsRule.enableFlags(FLAG_USER_MIN_ASPECT_RATIO_APP_DEFAULT); mUtils = new FakeUserAspectRatioManager(mContext, mIPm); @@ -399,6 +435,16 @@ public class UserAspectRatioManagerTest { .thenReturn(enabled); } + private void setIsOverrideToFullscreenEnabledBecauseUniversalResizeable(boolean enabled) { + if (enabled) { + mSetFlagsRule.enableFlags(FLAG_USER_MIN_ASPECT_RATIO_APP_DEFAULT); + mUtils = new FakeUserAspectRatioManager(mContext, mIPm); + } + mUtils.setUniversalResizeable(enabled); + when(mUtils.hasAspectRatioOption(USER_MIN_ASPECT_RATIO_FULLSCREEN, mPackageName)) + .thenReturn(enabled); + } + private void enableAllDefaultAspectRatioOptions() { final int[] aspectRatioOptions = new int[] { USER_MIN_ASPECT_RATIO_UNSET, @@ -457,6 +503,7 @@ public class UserAspectRatioManagerTest { private static class FakeUserAspectRatioManager extends UserAspectRatioManager { private boolean mFullscreenCompatChange = false; + private boolean mIsUniversalResizeable = false; private FakeUserAspectRatioManager(@NonNull Context context, IPackageManager pm) { super(context, pm); @@ -467,8 +514,17 @@ public class UserAspectRatioManagerTest { return mFullscreenCompatChange; } + @Override + boolean isUniversalResizeable(String pkgName, int userId) { + return mIsUniversalResizeable; + } + void setFullscreenCompatChange(boolean enabled) { mFullscreenCompatChange = enabled; } + + void setUniversalResizeable(boolean enabled) { + mIsUniversalResizeable = enabled; + } } }