Merge "Make extra navigation bar count towards non decor frame" into tm-dev (7cf2c5f5) · Commits · e / os / android_frameworks_base

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

+3 −4

Original line number	Diff line number	Diff line
		@@ -306,7 +306,6 @@ import android.util.TypedXmlPullParser;
		import android.util.TypedXmlSerializer;
		import android.util.proto.ProtoOutputStream;
		import android.view.AppTransitionAnimationSpec;
		import android.view.DisplayCutout;
		import android.view.DisplayInfo;
		import android.view.IAppTransitionAnimationSpecsFuture;
		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.WindowManagerService.H;
		import com.android.server.wm.utils.InsetUtils;
		import com.android.server.wm.utils.WmDisplayCutout;

		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 int dw = rotated ? display.mBaseDisplayHeight : display.mBaseDisplayWidth;
		final int dh = rotated ? display.mBaseDisplayWidth : display.mBaseDisplayHeight;
		final DisplayCutout cutout = display.calculateDisplayCutoutForRotation(rotation)
		.getDisplayCutout();
		policy.getNonDecorInsetsLw(rotation, cutout, mNonDecorInsets[rotation]);
		final WmDisplayCutout cutout = display.calculateDisplayCutoutForRotation(rotation);
		policy.getNonDecorInsetsLw(rotation, dw, dh, cutout, mNonDecorInsets[rotation]);
		mStableInsets[rotation].set(mNonDecorInsets[rotation]);
		policy.convertNonDecorInsetsToStableInsets(mStableInsets[rotation], rotation);

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

+60 −82

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

		/** @see #computeCompatSmallestWidth(boolean, int, int, int) */
		/** @see #computeCompatSmallestWidth(boolean, int, int) */
		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().
		// By updating the Display info here it will be available to
		// #computeScreenConfiguration() later.
		updateDisplayAndOrientation(getConfiguration().uiMode, null /* outConfig */);
		updateDisplayAndOrientation(null /* outConfig */);

		// NOTE: We disable the rotation in the emulator because
		// it doesn't support hardware OpenGL emulation yet.
		@@ -2017,7 +2017,7 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
		* changed.
		* 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
		final int rotation = getRotation();
		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 RoundedCorners roundedCorners = calculateRoundedCornersForRotation(rotation);

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

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

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

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

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

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

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

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

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

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

		config.screenLayout = (config.screenLayout & ~Configuration.SCREENLAYOUT_ROUND_MASK)
		\| ((displayInfo.flags & Display.FLAG_ROUND) != 0
		@@ -2287,7 +2278,7 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
		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);
		final DisplayMetrics tmpDm = mTmpDisplayMetrics;
		final int unrotDw, unrotDh;
		@@ -2298,25 +2289,20 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
		unrotDw = dw;
		unrotDh = dh;
		}
		int sw = reduceCompatConfigWidthSize(0, Surface.ROTATION_0, uiMode, tmpDm, unrotDw,
		unrotDh);
		sw = reduceCompatConfigWidthSize(sw, Surface.ROTATION_90, uiMode, tmpDm, unrotDh,
		unrotDw);
		sw = reduceCompatConfigWidthSize(sw, Surface.ROTATION_180, uiMode, tmpDm, unrotDw,
		unrotDh);
		sw = reduceCompatConfigWidthSize(sw, Surface.ROTATION_270, uiMode, tmpDm, unrotDh,
		unrotDw);
		int sw = reduceCompatConfigWidthSize(0, Surface.ROTATION_0, tmpDm, unrotDw, unrotDh);
		sw = reduceCompatConfigWidthSize(sw, Surface.ROTATION_90, tmpDm, unrotDh, unrotDw);
		sw = reduceCompatConfigWidthSize(sw, Surface.ROTATION_180, tmpDm, unrotDw, unrotDh);
		sw = reduceCompatConfigWidthSize(sw, Surface.ROTATION_270, tmpDm, unrotDh, unrotDw);
		return sw;
		}

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

		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
		// 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.largestNominalAppWidth = 0;
		displayInfo.largestNominalAppHeight = 0;
		adjustDisplaySizeRanges(displayInfo, Surface.ROTATION_0, uiMode, unrotDw, unrotDh);
		adjustDisplaySizeRanges(displayInfo, Surface.ROTATION_90, uiMode, unrotDh, unrotDw);
		adjustDisplaySizeRanges(displayInfo, Surface.ROTATION_180, uiMode, unrotDw, unrotDh);
		adjustDisplaySizeRanges(displayInfo, Surface.ROTATION_270, uiMode, unrotDh, unrotDw);
		adjustDisplaySizeRanges(displayInfo, Surface.ROTATION_0, unrotDw, unrotDh);
		adjustDisplaySizeRanges(displayInfo, Surface.ROTATION_90, unrotDh, unrotDw);
		adjustDisplaySizeRanges(displayInfo, Surface.ROTATION_180, unrotDw, unrotDh);
		adjustDisplaySizeRanges(displayInfo, Surface.ROTATION_270, unrotDh, unrotDw);

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

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

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

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

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

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

+70 −129

File changed.

Preview size limit exceeded, changes collapsed.

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

+4 −2

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

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

		policy.convertNonDecorInsetsToStableInsets(mTmpInsets, displayInfo.rotation);

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

+6 −4

Original line number	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.power.ShutdownThread;
		import com.android.server.utils.PriorityDump;
		import com.android.server.wm.utils.WmDisplayCutout;

		import dalvik.annotation.optimization.NeverCompile;

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

		@@ -7090,7 +7090,9 @@ public class WindowManagerService extends IWindowManager.Stub
		final DisplayContent dc = mRoot.getDisplayContent(displayId);
		if (dc != null) {
		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);
		}
		}