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

Commit 809c5088 authored by Massimo Carli's avatar Massimo Carli Committed by Android (Google) Code Review
Browse files

Merge "[16/n] Create Overrides and Policy for AspectRatio" into main

parents b12c2ebf 228b4cd9

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

+5 −62
Original line number Diff line number Diff line
@@ -88,12 +88,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;
@@ -9790,60 +9784,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() {
@@ -10726,14 +10667,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.