Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 228b4cd9 authored by Massimo Carli's avatar Massimo Carli
Browse files

[16/n] Create Overrides and Policy for AspectRatio 

Flag: EXEMPT refactor
Bug: 350513585
Test: atest WmTests:LetterboxUiControllerTest
Test: atest WmTests:SizeCompatTests
Test: atest WmTests:TaskTests

Change-Id: If570bc1c3d4e33f769b6bf4b857bfedf6e5ca906
parent 92716088

services/core/java/com/android/server/wm/ActivityRecord.java

+5 −62
Original line number Diff line number Diff line
@@ -89,12 +89,6 @@ import static android.content.pm.ActivityInfo.LOCK_TASK_LAUNCH_MODE_DEFAULT; 
import static android.content.pm.ActivityInfo.LOCK_TASK_LAUNCH_MODE_IF_ALLOWLISTED;

import static android.content.pm.ActivityInfo.LOCK_TASK_LAUNCH_MODE_NEVER;

import static android.content.pm.ActivityInfo.OVERRIDE_ENABLE_INSETS_DECOUPLED_CONFIGURATION;

import static android.content.pm.ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_EXCLUDE_PORTRAIT_FULLSCREEN;

import static android.content.pm.ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_LARGE;

import static android.content.pm.ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_MEDIUM;

import static android.content.pm.ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_PORTRAIT_ONLY;

import static android.content.pm.ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_SMALL;

import static android.content.pm.ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_TO_ALIGN_WITH_SPLIT_SCREEN;

import static android.content.pm.ActivityInfo.PERSIST_ACROSS_REBOOTS;

import static android.content.pm.ActivityInfo.PERSIST_ROOT_ONLY;

import static android.content.pm.ActivityInfo.RESIZE_MODE_FORCE_RESIZEABLE;
@@ -9889,60 +9883,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 
     * Returns the min aspect ratio of this activity.

     */

    float getMinAspectRatio() {

        if (mAppCompatController.getTransparentPolicy().isRunning()) {

            return mAppCompatController.getTransparentPolicy().getInheritedMinAspectRatio();

        }

        if (info.applicationInfo == null) {

            return info.getMinAspectRatio();

        }

        if (mLetterboxUiController.shouldApplyUserMinAspectRatioOverride()) {

            return mLetterboxUiController.getUserMinAspectRatio();

        }

        if (!mLetterboxUiController.shouldOverrideMinAspectRatio()

                && !mAppCompatController.getAppCompatCameraOverrides()

                    .shouldOverrideMinAspectRatioForCamera()) {

            return info.getMinAspectRatio();

        }

        if (info.isChangeEnabled(OVERRIDE_MIN_ASPECT_RATIO_PORTRAIT_ONLY)

                && !ActivityInfo.isFixedOrientationPortrait(

                        getOverrideOrientation())) {

            return info.getMinAspectRatio();

        }













        if (info.isChangeEnabled(OVERRIDE_MIN_ASPECT_RATIO_EXCLUDE_PORTRAIT_FULLSCREEN)













                && isParentFullscreenPortrait()) {













            // We are using the parent configuration here as this is the most recent one that gets













            // passed to onConfigurationChanged when a relevant change takes place













            return info.getMinAspectRatio();













        }

























        if (info.isChangeEnabled(OVERRIDE_MIN_ASPECT_RATIO_TO_ALIGN_WITH_SPLIT_SCREEN)) {













            return Math.max(mLetterboxUiController.getSplitScreenAspectRatio(),













                    info.getMinAspectRatio());













        }

























        if (info.isChangeEnabled(OVERRIDE_MIN_ASPECT_RATIO_LARGE)) {













            return Math.max(ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_LARGE_VALUE,













                    info.getMinAspectRatio());













        }

























        if (info.isChangeEnabled(OVERRIDE_MIN_ASPECT_RATIO_MEDIUM)) {













            return Math.max(ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_MEDIUM_VALUE,













                    info.getMinAspectRatio());













        }

























        if (info.isChangeEnabled(OVERRIDE_MIN_ASPECT_RATIO_SMALL)) {













            return Math.max(ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_SMALL_VALUE,













                    info.getMinAspectRatio());













        }













        return info.getMinAspectRatio();













    }

























    private boolean isParentFullscreenPortrait() {













        final WindowContainer parent = getParent();













        return parent != null













                && parent.getConfiguration().orientation == ORIENTATION_PORTRAIT













                && parent.getWindowConfiguration().getWindowingMode() == WINDOWING_MODE_FULLSCREEN;













        return mAppCompatController.getAppCompatAspectRatioPolicy().getMinAspectRatio();















    }





























    float getMaxAspectRatio() {










@@ -10825,14 +10766,16 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A













                mAppCompatController.getAppCompatCameraOverrides()















                        .shouldRefreshActivityViaPauseForCameraCompat());















        proto.write(SHOULD_OVERRIDE_MIN_ASPECT_RATIO,













                mLetterboxUiController.shouldOverrideMinAspectRatio());













                mAppCompatController.getAppCompatAspectRatioOverrides()













                        .shouldOverrideMinAspectRatio());















        proto.write(SHOULD_IGNORE_ORIENTATION_REQUEST_LOOP,















                mAppCompatController.getAppCompatOrientationOverrides()















                        .shouldIgnoreOrientationRequestLoop());















        proto.write(SHOULD_OVERRIDE_FORCE_RESIZE_APP,















                mLetterboxUiController.shouldOverrideForceResizeApp());















        proto.write(SHOULD_ENABLE_USER_ASPECT_RATIO_SETTINGS,













                mLetterboxUiController.shouldEnableUserAspectRatioSettings());













                mAppCompatController.getAppCompatAspectRatioOverrides()













                        .shouldEnableUserAspectRatioSettings());















        proto.write(IS_USER_FULLSCREEN_OVERRIDE_ENABLED,















                mLetterboxUiController.isUserFullscreenOverrideEnabled());















    }

































services/core/java/com/android/server/wm/AppCompatAspectRatioOverrides.java
0 → 100644



+300
−0




























Original line number
Diff line number
Diff line













/*













 * Copyright (C) 2024 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 com.android.server.wm;



























import static android.content.pm.ActivityInfo.OVERRIDE_ANY_ORIENTATION_TO_USER;













import static android.content.pm.ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO;













import static android.content.pm.ActivityInfo.isFixedOrientationLandscape;













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_APP_DEFAULT;













import static android.content.pm.PackageManager.USER_MIN_ASPECT_RATIO_DISPLAY_SIZE;













import static android.content.pm.PackageManager.USER_MIN_ASPECT_RATIO_FULLSCREEN;













import static android.content.pm.PackageManager.USER_MIN_ASPECT_RATIO_SPLIT_SCREEN;













import static android.content.pm.PackageManager.USER_MIN_ASPECT_RATIO_UNSET;













import static android.view.WindowManager.PROPERTY_COMPAT_ALLOW_MIN_ASPECT_RATIO_OVERRIDE;













import static android.view.WindowManager.PROPERTY_COMPAT_ALLOW_ORIENTATION_OVERRIDE;













import static android.view.WindowManager.PROPERTY_COMPAT_ALLOW_USER_ASPECT_RATIO_FULLSCREEN_OVERRIDE;













import static android.view.WindowManager.PROPERTY_COMPAT_ALLOW_USER_ASPECT_RATIO_OVERRIDE;



























import static com.android.server.wm.ActivityRecord.computeAspectRatio;













import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_ATM;













import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_WITH_CLASS_NAME;













import static com.android.server.wm.LetterboxConfiguration.LETTERBOX_POSITION_MULTIPLIER_CENTER;













import static com.android.server.wm.LetterboxConfiguration.MIN_FIXED_ORIENTATION_LETTERBOX_ASPECT_RATIO;



























import android.annotation.NonNull;













import android.content.pm.PackageManager;













import android.content.res.Configuration;













import android.content.res.Resources;













import android.graphics.Rect;













import android.os.RemoteException;













import android.util.Slog;



























import com.android.internal.R;













import com.android.internal.annotations.VisibleForTesting;













import com.android.server.wm.utils.OptPropFactory;



























import java.util.function.Function;



























/**













 * Encapsulates app compat configurations and overrides related to aspect ratio.













 */













class AppCompatAspectRatioOverrides {



























    private static final String TAG =













            TAG_WITH_CLASS_NAME ? "AppCompatAspectRatioOverrides" : TAG_ATM;



























    @NonNull













    private final ActivityRecord mActivityRecord;













    @NonNull













    private final LetterboxConfiguration mLetterboxConfiguration;













    @NonNull













    private final UserAspectRatioState mUserAspectRatioState;



























    @NonNull













    private final OptPropFactory.OptProp mAllowMinAspectRatioOverrideOptProp;













    @NonNull













    private final OptPropFactory.OptProp mAllowUserAspectRatioOverrideOptProp;













    @NonNull













    private final OptPropFactory.OptProp mAllowUserAspectRatioFullscreenOverrideOptProp;













    @NonNull













    private final OptPropFactory.OptProp mAllowOrientationOverrideOptProp;













    @NonNull













    private final Function<Boolean, Boolean> mIsDisplayFullScreenAndInPostureProvider;













    @NonNull













    private final Function<Configuration, Float> mGetHorizontalPositionMultiplierProvider;



























    AppCompatAspectRatioOverrides(@NonNull ActivityRecord activityRecord,













            @NonNull LetterboxConfiguration letterboxConfiguration,













            @NonNull OptPropFactory optPropBuilder,













            @NonNull Function<Boolean, Boolean> isDisplayFullScreenAndInPostureProvider,













            @NonNull Function<Configuration, Float> getHorizontalPositionMultiplierProvider) {













        mActivityRecord = activityRecord;













        mLetterboxConfiguration = letterboxConfiguration;













        mUserAspectRatioState = new UserAspectRatioState();













        mIsDisplayFullScreenAndInPostureProvider = isDisplayFullScreenAndInPostureProvider;













        mGetHorizontalPositionMultiplierProvider = getHorizontalPositionMultiplierProvider;













        mAllowMinAspectRatioOverrideOptProp = optPropBuilder.create(













                PROPERTY_COMPAT_ALLOW_MIN_ASPECT_RATIO_OVERRIDE);













        mAllowUserAspectRatioOverrideOptProp = optPropBuilder.create(













                PROPERTY_COMPAT_ALLOW_USER_ASPECT_RATIO_OVERRIDE,













                mLetterboxConfiguration::isUserAppAspectRatioSettingsEnabled);













        mAllowUserAspectRatioFullscreenOverrideOptProp = optPropBuilder.create(













                PROPERTY_COMPAT_ALLOW_USER_ASPECT_RATIO_FULLSCREEN_OVERRIDE,













                mLetterboxConfiguration::isUserAppAspectRatioFullscreenEnabled);













        mAllowOrientationOverrideOptProp = optPropBuilder.create(













                PROPERTY_COMPAT_ALLOW_ORIENTATION_OVERRIDE);













    }



























    /**













     * Whether we should apply the min aspect ratio per-app override. When this override is applied













     * the min aspect ratio given in the app's manifest will be overridden to the largest enabled













     * aspect ratio treatment unless the app's manifest value is higher. The treatment will also













     * apply if no value is provided in the manifest.













     *













     * <p>This method returns {@code true} when the following conditions are met:













     * <ul>













     *     <li>Opt-out component property isn't enabled













     *     <li>Per-app override is enabled













     * </ul>













     */













    boolean shouldOverrideMinAspectRatio() {













        return mAllowMinAspectRatioOverrideOptProp.shouldEnableWithOptInOverrideAndOptOutProperty(













                isCompatChangeEnabled(OVERRIDE_MIN_ASPECT_RATIO));













    }



























    /**













     * Whether we should apply the user aspect ratio override to the min aspect ratio for the













     * current app.













     */













    boolean shouldApplyUserMinAspectRatioOverride() {













        if (!shouldEnableUserAspectRatioSettings()) {













            return false;













        }



























        mUserAspectRatioState.mUserAspectRatio = getUserMinAspectRatioOverrideCode();



























        return mUserAspectRatioState.mUserAspectRatio != USER_MIN_ASPECT_RATIO_UNSET













                && mUserAspectRatioState.mUserAspectRatio != USER_MIN_ASPECT_RATIO_APP_DEFAULT













                && mUserAspectRatioState.mUserAspectRatio != USER_MIN_ASPECT_RATIO_FULLSCREEN;













    }



























    boolean shouldApplyUserFullscreenOverride() {













        if (isUserFullscreenOverrideEnabled()) {













            mUserAspectRatioState.mUserAspectRatio = getUserMinAspectRatioOverrideCode();



























            return mUserAspectRatioState.mUserAspectRatio == USER_MIN_ASPECT_RATIO_FULLSCREEN;













        }



























        return false;













    }



























    boolean isUserFullscreenOverrideEnabled() {













        if (mAllowUserAspectRatioOverrideOptProp.isFalse()













                || mAllowUserAspectRatioFullscreenOverrideOptProp.isFalse()













                || !mLetterboxConfiguration.isUserAppAspectRatioFullscreenEnabled()) {













            return false;













        }













        return true;













    }



























    boolean isSystemOverrideToFullscreenEnabled() {













        return isCompatChangeEnabled(OVERRIDE_ANY_ORIENTATION_TO_USER)













                && !mAllowOrientationOverrideOptProp.isFalse()













                && (mUserAspectRatioState.mUserAspectRatio == USER_MIN_ASPECT_RATIO_UNSET













                || mUserAspectRatioState.mUserAspectRatio == USER_MIN_ASPECT_RATIO_FULLSCREEN);













    }



























    /**













     * Whether we should enable users to resize the current app.













     */













    boolean shouldEnableUserAspectRatioSettings() {













        // We use mBooleanPropertyAllowUserAspectRatioOverride to allow apps to opt-out which has













        // effect only if explicitly false. If mBooleanPropertyAllowUserAspectRatioOverride is null,













        // the current app doesn't opt-out so the first part of the predicate is true.













        return !mAllowUserAspectRatioOverrideOptProp.isFalse()













                && mLetterboxConfiguration.isUserAppAspectRatioSettingsEnabled()













                && mActivityRecord.mDisplayContent != null













                && mActivityRecord.mDisplayContent.getIgnoreOrientationRequest();













    }



























    float getUserMinAspectRatio() {













        switch (mUserAspectRatioState.mUserAspectRatio) {













            case USER_MIN_ASPECT_RATIO_DISPLAY_SIZE:













                return getDisplaySizeMinAspectRatio();













            case USER_MIN_ASPECT_RATIO_SPLIT_SCREEN:













                return getSplitScreenAspectRatio();













            case USER_MIN_ASPECT_RATIO_16_9:













                return 16 / 9f;













            case USER_MIN_ASPECT_RATIO_4_3:













                return 4 / 3f;













            case USER_MIN_ASPECT_RATIO_3_2:













                return 3 / 2f;













            default:













                throw new AssertionError("Unexpected user min aspect ratio override: "













                        + mUserAspectRatioState.mUserAspectRatio);













        }













    }



























    float getSplitScreenAspectRatio() {













        // Getting the same aspect ratio that apps get in split screen.













        final DisplayArea displayArea = mActivityRecord.getDisplayArea();













        if (displayArea == null) {













            return getDefaultMinAspectRatioForUnresizableApps();













        }













        int dividerWindowWidth =













                getResources().getDimensionPixelSize(R.dimen.docked_stack_divider_thickness);













        int dividerInsets =













                getResources().getDimensionPixelSize(R.dimen.docked_stack_divider_insets);













        int dividerSize = dividerWindowWidth - dividerInsets * 2;













        final Rect bounds = new Rect(displayArea.getWindowConfiguration().getAppBounds());













        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);













    }



























    float getFixedOrientationLetterboxAspectRatio(@NonNull Configuration parentConfiguration) {













        return shouldUseSplitScreenAspectRatio(parentConfiguration)













                ? getSplitScreenAspectRatio()













                : mActivityRecord.shouldCreateCompatDisplayInsets()













                        ? getDefaultMinAspectRatioForUnresizableApps()













                        : getDefaultMinAspectRatio();













    }



























    private float getDisplaySizeMinAspectRatio() {













        final DisplayArea displayArea = mActivityRecord.getDisplayArea();













        if (displayArea == null) {













            return mActivityRecord.info.getMinAspectRatio();













        }













        final Rect bounds = new Rect(displayArea.getWindowConfiguration().getAppBounds());













        return computeAspectRatio(bounds);













    }



























    private boolean shouldUseSplitScreenAspectRatio(@NonNull Configuration parentConfiguration) {













        final boolean isBookMode = mIsDisplayFullScreenAndInPostureProvider













                .apply(/* isTabletop */false);













        final boolean isNotCenteredHorizontally = mGetHorizontalPositionMultiplierProvider.apply(













                parentConfiguration) != LETTERBOX_POSITION_MULTIPLIER_CENTER;













        final boolean isTabletopMode = mIsDisplayFullScreenAndInPostureProvider













                .apply(/* isTabletop */ true);













        final boolean isLandscape = isFixedOrientationLandscape(













                mActivityRecord.getOverrideOrientation());













        final AppCompatCameraOverrides cameraOverrides =













                mActivityRecord.mAppCompatController.getAppCompatCameraOverrides();













        final AppCompatCameraPolicy cameraPolicy =













                mActivityRecord.mAppCompatController.getAppCompatCameraPolicy();













        // Don't resize to split screen size when in book mode if letterbox position is centered













        return (isBookMode && isNotCenteredHorizontally || isTabletopMode && isLandscape)













                || cameraOverrides.isCameraCompatSplitScreenAspectRatioAllowed()













                && (cameraPolicy != null













                    && cameraPolicy.isTreatmentEnabledForActivity(mActivityRecord));













    }



























    @VisibleForTesting













    int getUserMinAspectRatioOverrideCode() {













        try {













            return mActivityRecord.mAtmService.getPackageManager()













                    .getUserMinAspectRatio(mActivityRecord.packageName, mActivityRecord.mUserId);













        } catch (RemoteException e) {













            Slog.w(TAG, "Exception thrown retrieving aspect ratio user override " + this, e);













        }













        return mUserAspectRatioState.mUserAspectRatio;













    }



























    private float getDefaultMinAspectRatioForUnresizableApps() {













        if (!mLetterboxConfiguration.getIsSplitScreenAspectRatioForUnresizableAppsEnabled()













                || mActivityRecord.getDisplayArea() == null) {













            return mLetterboxConfiguration.getDefaultMinAspectRatioForUnresizableApps()













                    > MIN_FIXED_ORIENTATION_LETTERBOX_ASPECT_RATIO













                    ? mLetterboxConfiguration.getDefaultMinAspectRatioForUnresizableApps()













                    : getDefaultMinAspectRatio();













        }



























        return getSplitScreenAspectRatio();













    }



























    private float getDefaultMinAspectRatio() {













        if (mActivityRecord.getDisplayArea() == null













                || !mLetterboxConfiguration













                .getIsDisplayAspectRatioEnabledForFixedOrientationLetterbox()) {













            return mLetterboxConfiguration.getFixedOrientationLetterboxAspectRatio();













        }













        return getDisplaySizeMinAspectRatio();













    }



























    private static class UserAspectRatioState {













        // TODO(b/315140179): Make mUserAspectRatio final













        // The min aspect ratio override set by user













        @PackageManager.UserMinAspectRatio













        private int mUserAspectRatio = USER_MIN_ASPECT_RATIO_UNSET;













    }



























    private boolean isCompatChangeEnabled(long overrideChangeId) {













        return mActivityRecord.info.isChangeEnabled(overrideChangeId);













    }



























    private Resources getResources() {













        return mActivityRecord.mWmService.mContext.getResources();













    }













}
























services/core/java/com/android/server/wm/AppCompatAspectRatioPolicy.java
0 → 100644



+118
−0




























Original line number
Diff line number
Diff line













/*













 * Copyright (C) 2024 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 com.android.server.wm;



























import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;













import static android.content.pm.ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_EXCLUDE_PORTRAIT_FULLSCREEN;













import static android.content.pm.ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_LARGE;













import static android.content.pm.ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_MEDIUM;













import static android.content.pm.ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_PORTRAIT_ONLY;













import static android.content.pm.ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_SMALL;













import static android.content.pm.ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_TO_ALIGN_WITH_SPLIT_SCREEN;













import static android.content.res.Configuration.ORIENTATION_PORTRAIT;



























import android.annotation.NonNull;













import android.content.pm.ActivityInfo;



























/**













 * Encapsulate app compat policy logic related to aspect ratio.













 */













class AppCompatAspectRatioPolicy {



























    @NonNull













    private final ActivityRecord mActivityRecord;













    @NonNull













    private final TransparentPolicy mTransparentPolicy;













    @NonNull













    private final AppCompatOrientationPolicy mAppCompatOrientationPolicy;













    @NonNull













    private final AppCompatOverrides mAppCompatOverrides;



























    AppCompatAspectRatioPolicy(@NonNull ActivityRecord activityRecord,













            @NonNull TransparentPolicy transparentPolicy,













            @NonNull AppCompatOrientationPolicy orientationPolicy,













            @NonNull AppCompatOverrides appCompatOverrides) {













        mActivityRecord = activityRecord;













        mTransparentPolicy = transparentPolicy;













        mAppCompatOrientationPolicy = orientationPolicy;













        mAppCompatOverrides = appCompatOverrides;













    }



























    /**













     * Returns the min aspect ratio of this activity.













     */













    float getMinAspectRatio() {













        if (mTransparentPolicy.isRunning()) {













            return mTransparentPolicy.getInheritedMinAspectRatio();













        }













        final ActivityInfo info = mActivityRecord.info;













        if (info.applicationInfo == null) {













            return info.getMinAspectRatio();













        }













        final AppCompatAspectRatioOverrides aspectRatioOverrides =













                mAppCompatOverrides.getAppCompatAspectRatioOverrides();













        if (aspectRatioOverrides.shouldApplyUserMinAspectRatioOverride()) {













            return aspectRatioOverrides.getUserMinAspectRatio();













        }













        if (!aspectRatioOverrides.shouldOverrideMinAspectRatio()













                && !mAppCompatOverrides.getAppCompatCameraOverrides()













                .shouldOverrideMinAspectRatioForCamera()) {













            return info.getMinAspectRatio();













        }



























        if (info.isChangeEnabled(OVERRIDE_MIN_ASPECT_RATIO_PORTRAIT_ONLY)













                && !ActivityInfo.isFixedOrientationPortrait(













                    mActivityRecord.getOverrideOrientation())) {













            return info.getMinAspectRatio();













        }



























        if (info.isChangeEnabled(OVERRIDE_MIN_ASPECT_RATIO_EXCLUDE_PORTRAIT_FULLSCREEN)













                && isParentFullscreenPortrait()) {













            // We are using the parent configuration here as this is the most recent one that gets













            // passed to onConfigurationChanged when a relevant change takes place













            return info.getMinAspectRatio();













        }



























        if (info.isChangeEnabled(OVERRIDE_MIN_ASPECT_RATIO_TO_ALIGN_WITH_SPLIT_SCREEN)) {













            return Math.max(aspectRatioOverrides.getSplitScreenAspectRatio(),













                    info.getMinAspectRatio());













        }



























        if (info.isChangeEnabled(OVERRIDE_MIN_ASPECT_RATIO_LARGE)) {













            return Math.max(ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_LARGE_VALUE,













                    info.getMinAspectRatio());













        }



























        if (info.isChangeEnabled(OVERRIDE_MIN_ASPECT_RATIO_MEDIUM)) {













            return Math.max(ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_MEDIUM_VALUE,













                    info.getMinAspectRatio());













        }



























        if (info.isChangeEnabled(OVERRIDE_MIN_ASPECT_RATIO_SMALL)) {













            return Math.max(ActivityInfo.OVERRIDE_MIN_ASPECT_RATIO_SMALL_VALUE,













                    info.getMinAspectRatio());













        }













        return info.getMinAspectRatio();













    }



























    private boolean isParentFullscreenPortrait() {













        final WindowContainer<?> parent = mActivityRecord.getParent();













        return parent != null













                && parent.getConfiguration().orientation == ORIENTATION_PORTRAIT













                && parent.getWindowConfiguration().getWindowingMode() == WINDOWING_MODE_FULLSCREEN;













    }













}
























services/core/java/com/android/server/wm/AppCompatController.java



+15
−6


























File changed.
Preview size limit exceeded, changes collapsed.
























services/core/java/com/android/server/wm/AppCompatOrientationPolicy.java



+10
−20


























File changed.
Preview size limit exceeded, changes collapsed.