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

Commit e429b9ba authored by Yunfan Chen's avatar Yunfan Chen Committed by Automerger Merge Worker
Browse files

Merge "Make extra navigation bar count towards non decor frame" into tm-dev am: 7cf2c5f5

Original change: https://googleplex-android-review.googlesource.com/c/platform/frameworks/base/+/17076728

Change-Id: Idfc8db39040c9490a48493ec197c34f4cd10722e
parents a7cfc9bb 7cf2c5f5
Loading
Loading
Loading
Loading
+3 −4
Original line number Original line Diff line number Diff line
@@ -306,7 +306,6 @@ import android.util.TypedXmlPullParser;
import android.util.TypedXmlSerializer;
import android.util.TypedXmlSerializer;
import android.util.proto.ProtoOutputStream;
import android.util.proto.ProtoOutputStream;
import android.view.AppTransitionAnimationSpec;
import android.view.AppTransitionAnimationSpec;
import android.view.DisplayCutout;
import android.view.DisplayInfo;
import android.view.DisplayInfo;
import android.view.IAppTransitionAnimationSpecsFuture;
import android.view.IAppTransitionAnimationSpecsFuture;
import android.view.InputApplicationHandle;
import android.view.InputApplicationHandle;
@@ -349,6 +348,7 @@ import com.android.server.wm.ActivityMetricsLogger.TransitionInfoSnapshot;
import com.android.server.wm.SurfaceAnimator.AnimationType;
import com.android.server.wm.SurfaceAnimator.AnimationType;
import com.android.server.wm.WindowManagerService.H;
import com.android.server.wm.WindowManagerService.H;
import com.android.server.wm.utils.InsetUtils;
import com.android.server.wm.utils.InsetUtils;
import com.android.server.wm.utils.WmDisplayCutout;


import dalvik.annotation.optimization.NeverCompile;
import dalvik.annotation.optimization.NeverCompile;


@@ -9420,9 +9420,8 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A
                final boolean rotated = (rotation == ROTATION_90 || rotation == ROTATION_270);
                final boolean rotated = (rotation == ROTATION_90 || rotation == ROTATION_270);
                final int dw = rotated ? display.mBaseDisplayHeight : display.mBaseDisplayWidth;
                final int dw = rotated ? display.mBaseDisplayHeight : display.mBaseDisplayWidth;
                final int dh = rotated ? display.mBaseDisplayWidth : display.mBaseDisplayHeight;
                final int dh = rotated ? display.mBaseDisplayWidth : display.mBaseDisplayHeight;
                final DisplayCutout cutout = display.calculateDisplayCutoutForRotation(rotation)
                final WmDisplayCutout cutout = display.calculateDisplayCutoutForRotation(rotation);
                        .getDisplayCutout();
                policy.getNonDecorInsetsLw(rotation, dw, dh, cutout, mNonDecorInsets[rotation]);
                policy.getNonDecorInsetsLw(rotation, cutout, mNonDecorInsets[rotation]);
                mStableInsets[rotation].set(mNonDecorInsets[rotation]);
                mStableInsets[rotation].set(mNonDecorInsets[rotation]);
                policy.convertNonDecorInsetsToStableInsets(mStableInsets[rotation], rotation);
                policy.convertNonDecorInsetsToStableInsets(mStableInsets[rotation], rotation);


+60 −82
Original line number Original line Diff line number Diff line
@@ -424,7 +424,7 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
     */
     */
    final DisplayMetrics mRealDisplayMetrics = new DisplayMetrics();
    final DisplayMetrics mRealDisplayMetrics = new DisplayMetrics();


    /** @see #computeCompatSmallestWidth(boolean, int, int, int) */
    /** @see #computeCompatSmallestWidth(boolean, int, int) */
    private final DisplayMetrics mTmpDisplayMetrics = new DisplayMetrics();
    private final DisplayMetrics mTmpDisplayMetrics = new DisplayMetrics();


    /**
    /**
@@ -1967,7 +1967,7 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
        // the top of the method, the caller is obligated to call computeNewConfigurationLocked().
        // the top of the method, the caller is obligated to call computeNewConfigurationLocked().
        // By updating the Display info here it will be available to
        // By updating the Display info here it will be available to
        // #computeScreenConfiguration() later.
        // #computeScreenConfiguration() later.
        updateDisplayAndOrientation(getConfiguration().uiMode, null /* outConfig */);
        updateDisplayAndOrientation(null /* outConfig */);


        // NOTE: We disable the rotation in the emulator because
        // NOTE: We disable the rotation in the emulator because
        //       it doesn't support hardware OpenGL emulation yet.
        //       it doesn't support hardware OpenGL emulation yet.
@@ -2017,7 +2017,7 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
     * changed.
     * changed.
     * Do not call if {@link WindowManagerService#mDisplayReady} == false.
     * Do not call if {@link WindowManagerService#mDisplayReady} == false.
     */
     */
    private DisplayInfo updateDisplayAndOrientation(int uiMode, Configuration outConfig) {
    private DisplayInfo updateDisplayAndOrientation(Configuration outConfig) {
        // Use the effective "visual" dimensions based on current rotation
        // Use the effective "visual" dimensions based on current rotation
        final int rotation = getRotation();
        final int rotation = getRotation();
        final boolean rotated = (rotation == ROTATION_90 || rotation == ROTATION_270);
        final boolean rotated = (rotation == ROTATION_90 || rotation == ROTATION_270);
@@ -2029,16 +2029,14 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
        final DisplayCutout displayCutout = wmDisplayCutout.getDisplayCutout();
        final DisplayCutout displayCutout = wmDisplayCutout.getDisplayCutout();
        final RoundedCorners roundedCorners = calculateRoundedCornersForRotation(rotation);
        final RoundedCorners roundedCorners = calculateRoundedCornersForRotation(rotation);


        final int appWidth = mDisplayPolicy.getNonDecorDisplayWidth(dw, dh, rotation, uiMode,
        final Rect appFrame = mDisplayPolicy.getNonDecorDisplayFrame(dw, dh, rotation,
                displayCutout);
                wmDisplayCutout);
        final int appHeight = mDisplayPolicy.getNonDecorDisplayHeight(dh, rotation,
                displayCutout);
        mDisplayInfo.rotation = rotation;
        mDisplayInfo.rotation = rotation;
        mDisplayInfo.logicalWidth = dw;
        mDisplayInfo.logicalWidth = dw;
        mDisplayInfo.logicalHeight = dh;
        mDisplayInfo.logicalHeight = dh;
        mDisplayInfo.logicalDensityDpi = mBaseDisplayDensity;
        mDisplayInfo.logicalDensityDpi = mBaseDisplayDensity;
        mDisplayInfo.appWidth = appWidth;
        mDisplayInfo.appWidth = appFrame.width();
        mDisplayInfo.appHeight = appHeight;
        mDisplayInfo.appHeight = appFrame.height();
        if (isDefaultDisplay) {
        if (isDefaultDisplay) {
            mDisplayInfo.getLogicalMetrics(mRealDisplayMetrics,
            mDisplayInfo.getLogicalMetrics(mRealDisplayMetrics,
                    CompatibilityInfo.DEFAULT_COMPATIBILITY_INFO, null);
                    CompatibilityInfo.DEFAULT_COMPATIBILITY_INFO, null);
@@ -2052,7 +2050,7 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
            mDisplayInfo.flags &= ~Display.FLAG_SCALING_DISABLED;
            mDisplayInfo.flags &= ~Display.FLAG_SCALING_DISABLED;
        }
        }


        computeSizeRangesAndScreenLayout(mDisplayInfo, rotated, uiMode, dw, dh,
        computeSizeRangesAndScreenLayout(mDisplayInfo, rotated, dw, dh,
                mDisplayMetrics.density, outConfig);
                mDisplayMetrics.density, outConfig);


        mWmService.mDisplayManagerInternal.setDisplayInfoOverrideFromWindowManager(mDisplayId,
        mWmService.mDisplayManagerInternal.setDisplayInfoOverrideFromWindowManager(mDisplayId,
@@ -2136,10 +2134,8 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
        outConfig.windowConfiguration.setMaxBounds(0, 0, dw, dh);
        outConfig.windowConfiguration.setMaxBounds(0, 0, dw, dh);
        outConfig.windowConfiguration.setBounds(outConfig.windowConfiguration.getMaxBounds());
        outConfig.windowConfiguration.setBounds(outConfig.windowConfiguration.getMaxBounds());


        final int uiMode = getConfiguration().uiMode;
        final WmDisplayCutout wmDisplayCutout = calculateDisplayCutoutForRotation(rotation);
        final DisplayCutout displayCutout =
        computeScreenAppConfiguration(outConfig, dw, dh, rotation, wmDisplayCutout);
                calculateDisplayCutoutForRotation(rotation).getDisplayCutout();
        computeScreenAppConfiguration(outConfig, dw, dh, rotation, uiMode, displayCutout);


        final DisplayInfo displayInfo = new DisplayInfo(mDisplayInfo);
        final DisplayInfo displayInfo = new DisplayInfo(mDisplayInfo);
        displayInfo.rotation = rotation;
        displayInfo.rotation = rotation;
@@ -2148,38 +2144,33 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
        final Rect appBounds = outConfig.windowConfiguration.getAppBounds();
        final Rect appBounds = outConfig.windowConfiguration.getAppBounds();
        displayInfo.appWidth = appBounds.width();
        displayInfo.appWidth = appBounds.width();
        displayInfo.appHeight = appBounds.height();
        displayInfo.appHeight = appBounds.height();
        final DisplayCutout displayCutout = wmDisplayCutout.getDisplayCutout();
        displayInfo.displayCutout = displayCutout.isEmpty() ? null : displayCutout;
        displayInfo.displayCutout = displayCutout.isEmpty() ? null : displayCutout;
        computeSizeRangesAndScreenLayout(displayInfo, rotated, uiMode, dw, dh,
        computeSizeRangesAndScreenLayout(displayInfo, rotated, dw, dh,
                mDisplayMetrics.density, outConfig);
                mDisplayMetrics.density, outConfig);
        return displayInfo;
        return displayInfo;
    }
    }


    /** Compute configuration related to application without changing current display. */
    /** Compute configuration related to application without changing current display. */
    private void computeScreenAppConfiguration(Configuration outConfig, int dw, int dh,
    private void computeScreenAppConfiguration(Configuration outConfig, int dw, int dh,
            int rotation, int uiMode, DisplayCutout displayCutout) {
            int rotation, WmDisplayCutout wmDisplayCutout) {
        final int appWidth = mDisplayPolicy.getNonDecorDisplayWidth(dw, dh, rotation, uiMode,
        final Rect appFrame = mDisplayPolicy.getNonDecorDisplayFrame(dw, dh, rotation,
                displayCutout);
                wmDisplayCutout);
        final int appHeight = mDisplayPolicy.getNonDecorDisplayHeight(dh, rotation,
                displayCutout);
        mDisplayPolicy.getNonDecorInsetsLw(rotation, displayCutout, mTmpRect);
        final int leftInset = mTmpRect.left;
        final int topInset = mTmpRect.top;
        // AppBounds at the root level should mirror the app screen size.
        // AppBounds at the root level should mirror the app screen size.
        outConfig.windowConfiguration.setAppBounds(leftInset /* left */, topInset /* top */,
        outConfig.windowConfiguration.setAppBounds(appFrame);
                leftInset + appWidth /* right */, topInset + appHeight /* bottom */);
        outConfig.windowConfiguration.setRotation(rotation);
        outConfig.windowConfiguration.setRotation(rotation);
        outConfig.orientation = (dw <= dh) ? ORIENTATION_PORTRAIT : ORIENTATION_LANDSCAPE;
        outConfig.orientation = (dw <= dh) ? ORIENTATION_PORTRAIT : ORIENTATION_LANDSCAPE;


        final float density = mDisplayMetrics.density;
        final float density = mDisplayMetrics.density;
        outConfig.screenWidthDp = (int) (mDisplayPolicy.getConfigDisplayWidth(dw, dh, rotation,
        final Point configSize = mDisplayPolicy.getConfigDisplaySize(dw, dh, rotation,
                uiMode, displayCutout) / density);
                wmDisplayCutout);
        outConfig.screenHeightDp = (int) (mDisplayPolicy.getConfigDisplayHeight(dw, dh, rotation,
        outConfig.screenWidthDp = (int) (configSize.x / density);
                uiMode, displayCutout) / density);
        outConfig.screenHeightDp = (int) (configSize.y / density);
        outConfig.compatScreenWidthDp = (int) (outConfig.screenWidthDp / mCompatibleScreenScale);
        outConfig.compatScreenWidthDp = (int) (outConfig.screenWidthDp / mCompatibleScreenScale);
        outConfig.compatScreenHeightDp = (int) (outConfig.screenHeightDp / mCompatibleScreenScale);
        outConfig.compatScreenHeightDp = (int) (outConfig.screenHeightDp / mCompatibleScreenScale);


        final boolean rotated = (rotation == ROTATION_90 || rotation == ROTATION_270);
        final boolean rotated = (rotation == ROTATION_90 || rotation == ROTATION_270);
        outConfig.compatSmallestScreenWidthDp = computeCompatSmallestWidth(rotated, uiMode, dw, dh);
        outConfig.compatSmallestScreenWidthDp = computeCompatSmallestWidth(rotated, dw, dh);
        outConfig.windowConfiguration.setDisplayRotation(rotation);
        outConfig.windowConfiguration.setDisplayRotation(rotation);
    }
    }


@@ -2188,7 +2179,7 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
     * Do not call if mDisplayReady == false.
     * Do not call if mDisplayReady == false.
     */
     */
    void computeScreenConfiguration(Configuration config) {
    void computeScreenConfiguration(Configuration config) {
        final DisplayInfo displayInfo = updateDisplayAndOrientation(config.uiMode, config);
        final DisplayInfo displayInfo = updateDisplayAndOrientation(config);
        final int dw = displayInfo.logicalWidth;
        final int dw = displayInfo.logicalWidth;
        final int dh = displayInfo.logicalHeight;
        final int dh = displayInfo.logicalHeight;
        mTmpRect.set(0, 0, dw, dh);
        mTmpRect.set(0, 0, dw, dh);
@@ -2197,8 +2188,8 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
        config.windowConfiguration.setWindowingMode(getWindowingMode());
        config.windowConfiguration.setWindowingMode(getWindowingMode());
        config.windowConfiguration.setDisplayWindowingMode(getWindowingMode());
        config.windowConfiguration.setDisplayWindowingMode(getWindowingMode());


        computeScreenAppConfiguration(config, dw, dh, displayInfo.rotation, config.uiMode,
        computeScreenAppConfiguration(config, dw, dh, displayInfo.rotation,
                displayInfo.displayCutout);
                calculateDisplayCutoutForRotation(getRotation()));


        config.screenLayout = (config.screenLayout & ~Configuration.SCREENLAYOUT_ROUND_MASK)
        config.screenLayout = (config.screenLayout & ~Configuration.SCREENLAYOUT_ROUND_MASK)
                | ((displayInfo.flags & Display.FLAG_ROUND) != 0
                | ((displayInfo.flags & Display.FLAG_ROUND) != 0
@@ -2287,7 +2278,7 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
        mWmService.mPolicy.adjustConfigurationLw(config, keyboardPresence, navigationPresence);
        mWmService.mPolicy.adjustConfigurationLw(config, keyboardPresence, navigationPresence);
    }
    }


    private int computeCompatSmallestWidth(boolean rotated, int uiMode, int dw, int dh) {
    private int computeCompatSmallestWidth(boolean rotated, int dw, int dh) {
        mTmpDisplayMetrics.setTo(mDisplayMetrics);
        mTmpDisplayMetrics.setTo(mDisplayMetrics);
        final DisplayMetrics tmpDm = mTmpDisplayMetrics;
        final DisplayMetrics tmpDm = mTmpDisplayMetrics;
        final int unrotDw, unrotDh;
        final int unrotDw, unrotDh;
@@ -2298,25 +2289,20 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
            unrotDw = dw;
            unrotDw = dw;
            unrotDh = dh;
            unrotDh = dh;
        }
        }
        int sw = reduceCompatConfigWidthSize(0, Surface.ROTATION_0, uiMode, tmpDm, unrotDw,
        int sw = reduceCompatConfigWidthSize(0, Surface.ROTATION_0, tmpDm, unrotDw, unrotDh);
                unrotDh);
        sw = reduceCompatConfigWidthSize(sw, Surface.ROTATION_90, tmpDm, unrotDh, unrotDw);
        sw = reduceCompatConfigWidthSize(sw, Surface.ROTATION_90, uiMode, tmpDm, unrotDh,
        sw = reduceCompatConfigWidthSize(sw, Surface.ROTATION_180, tmpDm, unrotDw, unrotDh);
                unrotDw);
        sw = reduceCompatConfigWidthSize(sw, Surface.ROTATION_270, tmpDm, unrotDh, unrotDw);
        sw = reduceCompatConfigWidthSize(sw, Surface.ROTATION_180, uiMode, tmpDm, unrotDw,
                unrotDh);
        sw = reduceCompatConfigWidthSize(sw, Surface.ROTATION_270, uiMode, tmpDm, unrotDh,
                unrotDw);
        return sw;
        return sw;
    }
    }


    private int reduceCompatConfigWidthSize(int curSize, int rotation, int uiMode,
    private int reduceCompatConfigWidthSize(int curSize, int rotation,
            DisplayMetrics dm, int dw, int dh) {
            DisplayMetrics dm, int dw, int dh) {
        final DisplayCutout displayCutout = calculateDisplayCutoutForRotation(
        final WmDisplayCutout wmDisplayCutout = calculateDisplayCutoutForRotation(rotation);
                rotation).getDisplayCutout();
        final Rect nonDecorSize = mDisplayPolicy.getNonDecorDisplayFrame(dw, dh, rotation,
        dm.noncompatWidthPixels = mDisplayPolicy.getNonDecorDisplayWidth(dw, dh, rotation, uiMode,
                wmDisplayCutout);
                displayCutout);
        dm.noncompatWidthPixels = nonDecorSize.width();
        dm.noncompatHeightPixels = mDisplayPolicy.getNonDecorDisplayHeight(dh, rotation,
        dm.noncompatHeightPixels = nonDecorSize.height();
                displayCutout);
        float scale = CompatibilityInfo.computeCompatibleScaling(dm, null);
        float scale = CompatibilityInfo.computeCompatibleScaling(dm, null);
        int size = (int)(((dm.noncompatWidthPixels / scale) / dm.density) + .5f);
        int size = (int)(((dm.noncompatWidthPixels / scale) / dm.density) + .5f);
        if (curSize == 0 || size < curSize) {
        if (curSize == 0 || size < curSize) {
@@ -2326,7 +2312,7 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
    }
    }


    private void computeSizeRangesAndScreenLayout(DisplayInfo displayInfo, boolean rotated,
    private void computeSizeRangesAndScreenLayout(DisplayInfo displayInfo, boolean rotated,
            int uiMode, int dw, int dh, float density, Configuration outConfig) {
            int dw, int dh, float density, Configuration outConfig) {


        // We need to determine the smallest width that will occur under normal
        // We need to determine the smallest width that will occur under normal
        // operation.  To this, start with the base screen size and compute the
        // operation.  To this, start with the base screen size and compute the
@@ -2344,36 +2330,33 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
        displayInfo.smallestNominalAppHeight = 1<<30;
        displayInfo.smallestNominalAppHeight = 1<<30;
        displayInfo.largestNominalAppWidth = 0;
        displayInfo.largestNominalAppWidth = 0;
        displayInfo.largestNominalAppHeight = 0;
        displayInfo.largestNominalAppHeight = 0;
        adjustDisplaySizeRanges(displayInfo, Surface.ROTATION_0, uiMode, unrotDw, unrotDh);
        adjustDisplaySizeRanges(displayInfo, Surface.ROTATION_0, unrotDw, unrotDh);
        adjustDisplaySizeRanges(displayInfo, Surface.ROTATION_90, uiMode, unrotDh, unrotDw);
        adjustDisplaySizeRanges(displayInfo, Surface.ROTATION_90, unrotDh, unrotDw);
        adjustDisplaySizeRanges(displayInfo, Surface.ROTATION_180, uiMode, unrotDw, unrotDh);
        adjustDisplaySizeRanges(displayInfo, Surface.ROTATION_180, unrotDw, unrotDh);
        adjustDisplaySizeRanges(displayInfo, Surface.ROTATION_270, uiMode, unrotDh, unrotDw);
        adjustDisplaySizeRanges(displayInfo, Surface.ROTATION_270, unrotDh, unrotDw);


        if (outConfig == null) {
        if (outConfig == null) {
            return;
            return;
        }
        }
        int sl = Configuration.resetScreenLayout(outConfig.screenLayout);
        int sl = Configuration.resetScreenLayout(outConfig.screenLayout);
        sl = reduceConfigLayout(sl, Surface.ROTATION_0, density, unrotDw, unrotDh, uiMode);
        sl = reduceConfigLayout(sl, Surface.ROTATION_0, density, unrotDw, unrotDh);
        sl = reduceConfigLayout(sl, Surface.ROTATION_90, density, unrotDh, unrotDw, uiMode);
        sl = reduceConfigLayout(sl, Surface.ROTATION_90, density, unrotDh, unrotDw);
        sl = reduceConfigLayout(sl, Surface.ROTATION_180, density, unrotDw, unrotDh, uiMode);
        sl = reduceConfigLayout(sl, Surface.ROTATION_180, density, unrotDw, unrotDh);
        sl = reduceConfigLayout(sl, Surface.ROTATION_270, density, unrotDh, unrotDw, uiMode);
        sl = reduceConfigLayout(sl, Surface.ROTATION_270, density, unrotDh, unrotDw);
        outConfig.smallestScreenWidthDp = (int)(displayInfo.smallestNominalAppWidth / density);
        outConfig.smallestScreenWidthDp = (int)(displayInfo.smallestNominalAppWidth / density);
        outConfig.screenLayout = sl;
        outConfig.screenLayout = sl;
    }
    }


    private int reduceConfigLayout(int curLayout, int rotation, float density, int dw, int dh,
    private int reduceConfigLayout(int curLayout, int rotation, float density, int dw, int dh) {
            int uiMode) {
        // Get the display cutout at this rotation.
        // Get the display cutout at this rotation.
        final DisplayCutout displayCutout = calculateDisplayCutoutForRotation(
        final WmDisplayCutout wmDisplayCutout = calculateDisplayCutoutForRotation(rotation);
                rotation).getDisplayCutout();


        // Get the app screen size at this rotation.
        // Get the app screen size at this rotation.
        int w = mDisplayPolicy.getNonDecorDisplayWidth(dw, dh, rotation, uiMode, displayCutout);
        final Rect size = mDisplayPolicy.getNonDecorDisplayFrame(dw, dh, rotation, wmDisplayCutout);
        int h = mDisplayPolicy.getNonDecorDisplayHeight(dh, rotation, displayCutout);


        // Compute the screen layout size class for this rotation.
        // Compute the screen layout size class for this rotation.
        int longSize = w;
        int longSize = size.width();
        int shortSize = h;
        int shortSize = size.height();
        if (longSize < shortSize) {
        if (longSize < shortSize) {
            int tmp = longSize;
            int tmp = longSize;
            longSize = shortSize;
            longSize = shortSize;
@@ -2384,25 +2367,20 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
        return Configuration.reduceScreenLayout(curLayout, longSize, shortSize);
        return Configuration.reduceScreenLayout(curLayout, longSize, shortSize);
    }
    }


    private void adjustDisplaySizeRanges(DisplayInfo displayInfo, int rotation,
    private void adjustDisplaySizeRanges(DisplayInfo displayInfo, int rotation, int dw, int dh) {
            int uiMode, int dw, int dh) {
        final WmDisplayCutout wmDisplayCutout = calculateDisplayCutoutForRotation(rotation);
        final DisplayCutout displayCutout = calculateDisplayCutoutForRotation(
        final Point size = mDisplayPolicy.getConfigDisplaySize(dw, dh, rotation, wmDisplayCutout);
                rotation).getDisplayCutout();
        if (size.x < displayInfo.smallestNominalAppWidth) {
        final int width = mDisplayPolicy.getConfigDisplayWidth(dw, dh, rotation, uiMode,
            displayInfo.smallestNominalAppWidth = size.x;
                displayCutout);
        if (width < displayInfo.smallestNominalAppWidth) {
            displayInfo.smallestNominalAppWidth = width;
        }
        }
        if (width > displayInfo.largestNominalAppWidth) {
        if (size.x > displayInfo.largestNominalAppWidth) {
            displayInfo.largestNominalAppWidth = width;
            displayInfo.largestNominalAppWidth = size.x;
        }
        }
        final int height = mDisplayPolicy.getConfigDisplayHeight(dw, dh, rotation, uiMode,
        if (size.y < displayInfo.smallestNominalAppHeight) {
                displayCutout);
            displayInfo.smallestNominalAppHeight = size.y;
        if (height < displayInfo.smallestNominalAppHeight) {
            displayInfo.smallestNominalAppHeight = height;
        }
        }
        if (height > displayInfo.largestNominalAppHeight) {
        if (size.y > displayInfo.largestNominalAppHeight) {
            displayInfo.largestNominalAppHeight = height;
            displayInfo.largestNominalAppHeight = size.y;
        }
        }
    }
    }


+70 −129

File changed.

Preview size limit exceeded, changes collapsed.

+4 −2
Original line number Original line Diff line number Diff line
@@ -2058,8 +2058,10 @@ class TaskFragment extends WindowContainer<WindowContainer> {
        mTmpBounds.set(0, 0, displayInfo.logicalWidth, displayInfo.logicalHeight);
        mTmpBounds.set(0, 0, displayInfo.logicalWidth, displayInfo.logicalHeight);


        final DisplayPolicy policy = rootTask.mDisplayContent.getDisplayPolicy();
        final DisplayPolicy policy = rootTask.mDisplayContent.getDisplayPolicy();
        policy.getNonDecorInsetsLw(displayInfo.rotation,
        policy.getNonDecorInsetsLw(displayInfo.rotation, displayInfo.logicalWidth,
                displayInfo.displayCutout, mTmpInsets);
                displayInfo.logicalHeight,
                rootTask.mDisplayContent.calculateDisplayCutoutForRotation(displayInfo.rotation),
                mTmpInsets);
        intersectWithInsetsIfFits(outNonDecorBounds, mTmpBounds, mTmpInsets);
        intersectWithInsetsIfFits(outNonDecorBounds, mTmpBounds, mTmpInsets);


        policy.convertNonDecorInsetsToStableInsets(mTmpInsets, displayInfo.rotation);
        policy.convertNonDecorInsetsToStableInsets(mTmpInsets, displayInfo.rotation);
+6 −4
Original line number Original line Diff line number Diff line
@@ -314,6 +314,7 @@ import com.android.server.policy.WindowManagerPolicy;
import com.android.server.policy.WindowManagerPolicy.ScreenOffListener;
import com.android.server.policy.WindowManagerPolicy.ScreenOffListener;
import com.android.server.power.ShutdownThread;
import com.android.server.power.ShutdownThread;
import com.android.server.utils.PriorityDump;
import com.android.server.utils.PriorityDump;
import com.android.server.wm.utils.WmDisplayCutout;


import dalvik.annotation.optimization.NeverCompile;
import dalvik.annotation.optimization.NeverCompile;


@@ -6247,9 +6248,8 @@ public class WindowManagerService extends IWindowManager.Stub
                        + " callers=" + Debug.getCallers(3));
                        + " callers=" + Debug.getCallers(3));
                return NAV_BAR_INVALID;
                return NAV_BAR_INVALID;
            }
            }
            displayContent.performLayout(false /* initial */,
            return displayContent.getDisplayPolicy().navigationBarPosition(
                    false /* updateInputWindows */);
                    displayContent.getDisplayRotation().getRotation());
            return displayContent.getDisplayPolicy().getNavBarPosition();
        }
        }
    }
    }


@@ -7090,7 +7090,9 @@ public class WindowManagerService extends IWindowManager.Stub
        final DisplayContent dc = mRoot.getDisplayContent(displayId);
        final DisplayContent dc = mRoot.getDisplayContent(displayId);
        if (dc != null) {
        if (dc != null) {
            final DisplayInfo di = dc.getDisplayInfo();
            final DisplayInfo di = dc.getDisplayInfo();
            dc.getDisplayPolicy().getStableInsetsLw(di.rotation, di.displayCutout, outInsets);
            final WmDisplayCutout cutout = dc.calculateDisplayCutoutForRotation(di.rotation);
            dc.getDisplayPolicy().getStableInsetsLw(di.rotation, di.logicalWidth, di.logicalHeight,
                    cutout, outInsets);
        }
        }
    }
    }


Loading