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

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

+3 −4

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

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

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

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

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