Merge "Remove beginLayoutLw and redundant logic about layout" (5b28dc65) · Commits · e / os / android_frameworks_base

core/java/android/view/InsetsSource.java

+8 −0

Original line number	Diff line number	Diff line
		@@ -65,6 +65,14 @@ public class InsetsSource implements Parcelable {
		: null;
		}

		public void set(InsetsSource other) {
		mFrame.set(other.mFrame);
		mVisible = other.mVisible;
		mVisibleFrame = other.mVisibleFrame != null
		? new Rect(other.mVisibleFrame)
		: null;
		}

		public void setFrame(int left, int top, int right, int bottom) {
		mFrame.set(left, top, right, bottom);
		}

core/java/android/view/WindowManager.java

+0 −14

Original line number	Diff line number	Diff line
		@@ -2202,15 +2202,6 @@ public interface WindowManager extends ViewManager {
		*/
		public static final int PRIVATE_FLAG_FORCE_SHOW_STATUS_BAR = 0x00001000;

		/**
		* Flag indicating that the x, y, width, and height members should be
		* ignored (and thus their previous value preserved). For example
		* because they are being managed externally through repositionChild.
		*
		* {@hide}
		*/
		public static final int PRIVATE_FLAG_PRESERVE_GEOMETRY = 0x00002000;

		/**
		* Flag that will make window ignore app visibility and instead depend purely on the decor
		* view visibility for determining window visibility. This is used by recents to keep
		@@ -2367,7 +2358,6 @@ public interface WindowManager extends ViewManager {
		PRIVATE_FLAG_SYSTEM_ERROR,
		PRIVATE_FLAG_DISABLE_WALLPAPER_TOUCH_EVENTS,
		PRIVATE_FLAG_FORCE_SHOW_STATUS_BAR,
		PRIVATE_FLAG_PRESERVE_GEOMETRY,
		PRIVATE_FLAG_FORCE_DECOR_VIEW_VISIBILITY,
		PRIVATE_FLAG_WILL_NOT_REPLACE_ON_RELAUNCH,
		PRIVATE_FLAG_LAYOUT_CHILD_WINDOW_IN_PARENT_FRAME,
		@@ -2430,10 +2420,6 @@ public interface WindowManager extends ViewManager {
		mask = PRIVATE_FLAG_FORCE_SHOW_STATUS_BAR,
		equals = PRIVATE_FLAG_FORCE_SHOW_STATUS_BAR,
		name = "FORCE_STATUS_BAR_VISIBLE"),
		@ViewDebug.FlagToString(
		mask = PRIVATE_FLAG_PRESERVE_GEOMETRY,
		equals = PRIVATE_FLAG_PRESERVE_GEOMETRY,
		name = "PRESERVE_GEOMETRY"),
		@ViewDebug.FlagToString(
		mask = PRIVATE_FLAG_FORCE_DECOR_VIEW_VISIBILITY,
		equals = PRIVATE_FLAG_FORCE_DECOR_VIEW_VISIBILITY,

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

+18 −31

Original line number	Diff line number	Diff line
		@@ -129,7 +129,6 @@ import static com.android.server.wm.WindowManagerDebugConfig.SHOW_STACK_CRAWLS;
		import static com.android.server.wm.WindowManagerDebugConfig.TAG_WITH_CLASS_NAME;
		import static com.android.server.wm.WindowManagerDebugConfig.TAG_WM;
		import static com.android.server.wm.WindowManagerService.H.REPORT_HARD_KEYBOARD_STATUS_CHANGE;
		import static com.android.server.wm.WindowManagerService.H.UPDATE_MULTI_WINDOW_STACKS;
		import static com.android.server.wm.WindowManagerService.H.WINDOW_HIDE_TIMEOUT;
		import static com.android.server.wm.WindowManagerService.LAYOUT_REPEAT_THRESHOLD;
		import static com.android.server.wm.WindowManagerService.SEAMLESS_ROTATION_TIMEOUT_DURATION;
		@@ -754,8 +753,7 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
		private final Consumer<WindowState> mPerformLayout = w -> {
		// Don't do layout of a window if it is not visible, or soon won't be visible, to avoid
		// wasting time and funky changes while a window is animating away.
		final boolean gone = (mTmpWindow != null && mWmService.mPolicy.canBeHiddenByKeyguardLw(w))
		\|\| w.isGoneForLayout();
		final boolean gone = w.isGoneForLayout();

		if (DEBUG_LAYOUT && !w.mLayoutAttached) {
		Slog.v(TAG, "1ST PASS " + w + ": gone=" + gone + " mHaveFrame=" + w.mHaveFrame
		@@ -830,9 +828,6 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
		// If this view is GONE, then skip it -- keep the current frame, and let the caller
		// know so they can ignore it if they want. (We do the normal layout for INVISIBLE
		// windows, since that means "perform layout as normal, just don't display").
		if (mTmpWindow != null && mWmService.mPolicy.canBeHiddenByKeyguardLw(w)) {
		return;
		}
		if ((w.mViewVisibility != GONE && w.mRelayoutCalled) \|\| !w.mHaveFrame
		\|\| w.mLayoutNeeded) {
		if (mTmpInitial) {
		@@ -985,8 +980,9 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
		mSystemGestureExclusionLimit = mWmService.mConstants.mSystemGestureExclusionLimitDp
		* mDisplayMetrics.densityDpi / DENSITY_DEFAULT;
		isDefaultDisplay = mDisplayId == DEFAULT_DISPLAY;
		mDisplayFrames = new DisplayFrames(mDisplayId, mDisplayInfo,
		calculateDisplayCutoutForRotation(mDisplayInfo.rotation));
		mInsetsStateController = new InsetsStateController(this);
		mDisplayFrames = new DisplayFrames(mDisplayId, mInsetsStateController.getRawInsetsState(),
		mDisplayInfo, calculateDisplayCutoutForRotation(mDisplayInfo.rotation));
		initializeDisplayBaseInfo();

		mAppTransition = new AppTransition(mWmService.mContext, mWmService, this);
		@@ -1069,7 +1065,6 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
		onDisplayChanged(this);

		mInputMonitor = new InputMonitor(mWmService, this);
		mInsetsStateController = new InsetsStateController(this);
		mInsetsPolicy = new InsetsPolicy(mInsetsStateController, this);

		if (DEBUG_DISPLAY) Slog.v(TAG_WM, "Creating display=" + display);
		@@ -1700,7 +1695,8 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
		mTmpConfiguration.unset();
		final DisplayInfo info = computeScreenConfiguration(mTmpConfiguration, rotation);
		final WmDisplayCutout cutout = calculateDisplayCutoutForRotation(rotation);
		final DisplayFrames displayFrames = new DisplayFrames(mDisplayId, info, cutout);
		final DisplayFrames displayFrames = new DisplayFrames(mDisplayId, new InsetsState(), info,
		cutout);
		token.applyFixedRotationTransform(info, displayFrames, mTmpConfiguration);
		}

		@@ -1868,9 +1864,6 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp

		mDisplayPolicy.updateConfigurationAndScreenSizeDependentBehaviors();
		mDisplayRotation.configure(width, height, shortSizeDp, longSizeDp);

		mDisplayFrames.onDisplayInfoUpdated(mDisplayInfo,
		calculateDisplayCutoutForRotation(mDisplayInfo.rotation));
		}

		/**
		@@ -1930,6 +1923,8 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
		mCompatDisplayMetrics);
		}

		onDisplayInfoChanged();

		return mDisplayInfo;
		}

		@@ -2479,9 +2474,17 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
		mDisplay.getDisplayInfo(mDisplayInfo);
		mDisplay.getMetrics(mDisplayMetrics);

		onDisplayInfoChanged();
		onDisplayChanged(this);
		}

		void onDisplayInfoChanged() {
		final DisplayInfo info = mDisplayInfo;
		mDisplayFrames.onDisplayInfoUpdated(info, calculateDisplayCutoutForRotation(info.rotation));
		mInputMonitor.layoutInputConsumers(info.logicalWidth, info.logicalHeight);
		mDisplayPolicy.onDisplayInfoChanged(info);
		}

		@Override
		void onDisplayChanged(DisplayContent dc) {
		super.onDisplayChanged(dc);
		@@ -4263,18 +4266,12 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
		}
		clearLayoutNeeded();

		final int dw = mDisplayInfo.logicalWidth;
		final int dh = mDisplayInfo.logicalHeight;
		if (DEBUG_LAYOUT) {
		Slog.v(TAG, "-------------------------------------");
		Slog.v(TAG, "performLayout: needed=" + isLayoutNeeded() + " dw=" + dw
		+ " dh=" + dh);
		Slog.v(TAG, "performLayout: dw=" + mDisplayInfo.logicalWidth
		+ " dh=" + mDisplayInfo.logicalHeight);
		}

		mDisplayFrames.onDisplayInfoUpdated(mDisplayInfo,
		calculateDisplayCutoutForRotation(mDisplayInfo.rotation));
		mDisplayPolicy.beginLayoutLw(mDisplayFrames, getConfiguration().uiMode);

		// Used to indicate that we have processed the insets windows. This needs to be after
		// beginLayoutLw to ensure the raw insets state display related info is initialized.
		final InsetsState rawInsetsState = getInsetsStateController().getRawInsetsState();
		@@ -4287,32 +4284,22 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
		if (seq < 0) seq = 0;
		mLayoutSeq = seq;

		// Used to indicate that we have processed the dream window and all additional windows are
		// behind it.
		mTmpWindow = null;
		mTmpInitial = initial;


		// First perform layout of any root windows (not attached to another window).
		forAllWindows(mPerformLayout, true /* traverseTopToBottom */);

		// Used to indicate that we have processed the dream window and all additional attached
		// windows are behind it.
		mTmpWindow = null;

		// Now perform layout of attached windows, which usually depend on the position of the
		// window they are attached to. XXX does not deal with windows that are attached to windows
		// that are themselves attached.
		forAllWindows(mPerformLayoutAttached, true /* traverseTopToBottom */);

		// Window frames may have changed. Tell the input dispatcher about it.
		mInputMonitor.layoutInputConsumers(dw, dh);
		mInputMonitor.setUpdateInputWindowsNeededLw();
		if (updateInputWindows) {
		mInputMonitor.updateInputWindowsLw(false /force/);
		}

		mWmService.mH.sendEmptyMessage(UPDATE_MULTI_WINDOW_STACKS);
		}

		/**

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

+7 −8

Original line number	Diff line number	Diff line
		@@ -39,6 +39,8 @@ import java.io.PrintWriter;
		public class DisplayFrames {
		public final int mDisplayId;

		public final InsetsState mInsetsState;

		/**
		* The current visible size of the screen; really; (ir)regardless of whether the status bar can
		* be hidden but not extending into the overscan area.
		@@ -48,9 +50,6 @@ public class DisplayFrames {
		/** The display cutout used for layout (after rotation) */
		@NonNull public WmDisplayCutout mDisplayCutout = WmDisplayCutout.NO_CUTOUT;

		/** The cutout as supplied by display info */
		@NonNull public WmDisplayCutout mDisplayInfoCutout = WmDisplayCutout.NO_CUTOUT;

		/**
		* During layout, the frame that is display-cutout safe, i.e. that does not intersect with it.
		*/
		@@ -61,8 +60,10 @@ public class DisplayFrames {

		public int mRotation;

		public DisplayFrames(int displayId, DisplayInfo info, WmDisplayCutout displayCutout) {
		public DisplayFrames(int displayId, InsetsState insetsState, DisplayInfo info,
		WmDisplayCutout displayCutout) {
		mDisplayId = displayId;
		mInsetsState = insetsState;
		onDisplayInfoUpdated(info, displayCutout);
		}

		@@ -70,11 +71,9 @@ public class DisplayFrames {
		mDisplayWidth = info.logicalWidth;
		mDisplayHeight = info.logicalHeight;
		mRotation = info.rotation;
		mDisplayInfoCutout = displayCutout != null ? displayCutout : WmDisplayCutout.NO_CUTOUT;
		}
		mDisplayCutout = displayCutout != null ? displayCutout : WmDisplayCutout.NO_CUTOUT;

		public void onBeginLayout(InsetsState state) {
		mDisplayCutout = mDisplayInfoCutout;
		final InsetsState state = mInsetsState;
		final Rect unrestricted = mUnrestricted;
		final Rect safe = mDisplayCutoutSafe;
		final DisplayCutout cutout = mDisplayCutout.getDisplayCutout();

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

+24 −36

Original line number	Diff line number	Diff line
		@@ -130,6 +130,7 @@ import android.util.PrintWriterPrinter;
		import android.util.Slog;
		import android.util.SparseArray;
		import android.view.DisplayCutout;
		import android.view.DisplayInfo;
		import android.view.Gravity;
		import android.view.InsetsFlags;
		import android.view.InsetsSource;
		@@ -1433,8 +1434,8 @@ public class DisplayPolicy {
		}

		private void simulateLayoutDecorWindow(WindowState win, DisplayFrames displayFrames,
		InsetsState insetsState, WindowFrames simulatedWindowFrames,
		SparseArray<Rect> contentFrames, Consumer<Rect> layout) {
		WindowFrames simulatedWindowFrames, SparseArray<Rect> contentFrames,
		Consumer<Rect> layout) {
		win.setSimulatedWindowFrames(simulatedWindowFrames);
		final Rect contentFrame = new Rect();
		try {
		@@ -1443,46 +1444,31 @@ public class DisplayPolicy {
		win.setSimulatedWindowFrames(null);
		}
		contentFrames.put(win.mAttrs.type, contentFrame);
		mDisplayContent.getInsetsStateController().computeSimulatedState(insetsState, win,
		displayFrames, simulatedWindowFrames);
		mDisplayContent.getInsetsStateController().computeSimulatedState(
		win, displayFrames, simulatedWindowFrames);
		}

		/**
		* Computes the frames of display (its logical size, rotation and cutout should already be set)
		* used to layout window. The result of display frames and insets state should be the same as
		* using {@link #beginLayoutLw}, but this method only changes the given display frames, insets
		* state and some temporal states. In other words, it doesn't change the window frames used to
		* show on screen.
		* used to layout window. This method only changes the given display frames, insets state and
		* some temporal states, but doesn't change the window frames used to show on screen.
		*/
		void simulateLayoutDisplay(DisplayFrames displayFrames, InsetsState insetsState,
		SparseArray<Rect> barContentFrames) {
		displayFrames.onBeginLayout(insetsState);
		void simulateLayoutDisplay(DisplayFrames displayFrames, SparseArray<Rect> barContentFrames) {
		final WindowFrames simulatedWindowFrames = new WindowFrames();
		if (mNavigationBar != null) {
		simulateLayoutDecorWindow(mNavigationBar, displayFrames, insetsState,
		simulatedWindowFrames, barContentFrames,
		contentFrame -> layoutNavigationBar(displayFrames,
		mDisplayContent.getConfiguration().uiMode, contentFrame));
		simulateLayoutDecorWindow(mNavigationBar, displayFrames, simulatedWindowFrames,
		barContentFrames, contentFrame -> layoutNavigationBar(displayFrames,
		contentFrame));
		}
		if (mStatusBar != null) {
		simulateLayoutDecorWindow(mStatusBar, displayFrames, insetsState,
		simulatedWindowFrames, barContentFrames,
		contentFrame -> layoutStatusBar(displayFrames, contentFrame));
		simulateLayoutDecorWindow(mStatusBar, displayFrames, simulatedWindowFrames,
		barContentFrames, contentFrame -> layoutStatusBar(displayFrames, contentFrame));
		}
		}

		/**
		* Called when layout of the windows is about to start.
		*
		* @param displayFrames frames of the display we are doing layout on.
		* @param uiMode The current uiMode in configuration.
		*/
		public void beginLayoutLw(DisplayFrames displayFrames, int uiMode) {
		displayFrames.onBeginLayout(mDisplayContent.getInsetsStateController().getRawInsetsState());
		mSystemGestures.screenWidth = displayFrames.mUnrestricted.width();
		mSystemGestures.screenHeight = displayFrames.mUnrestricted.height();
		layoutNavigationBar(displayFrames, uiMode, null /* simulatedContentFrame */);
		layoutStatusBar(displayFrames, null /* simulatedContentFrame */);
		void onDisplayInfoChanged(DisplayInfo info) {
		mSystemGestures.screenWidth = info.logicalWidth;
		mSystemGestures.screenHeight = info.logicalHeight;
		}

		private void layoutStatusBar(DisplayFrames displayFrames, Rect simulatedContentFrame) {
		@@ -1524,12 +1510,12 @@ public class DisplayPolicy {
		}
		}

		private void layoutNavigationBar(DisplayFrames displayFrames, int uiMode,
		Rect simulatedContentFrame) {
		private void layoutNavigationBar(DisplayFrames displayFrames, Rect simulatedContentFrame) {
		if (mNavigationBar == null) {
		return;
		}

		final int uiMode = mDisplayContent.getConfiguration().uiMode;
		final Rect navigationFrame = sTmpNavFrame;
		// Force the navigation bar to its appropriate place and size. We need to do this directly,
		// instead of relying on it to bubble up from the nav bar, because this needs to change
		@@ -1620,10 +1606,12 @@ public class DisplayPolicy {
		* @param displayFrames The display frames.
		*/
		public void layoutWindowLw(WindowState win, WindowState attached, DisplayFrames displayFrames) {
		// We've already done the navigation bar, status bar, and all screen decor windows. If the
		// status bar can receive input, we need to layout it again to accommodate for the IME
		// window.
		if ((win == mStatusBar && !canReceiveInput(win)) \|\| win == mNavigationBar) {
		if (win == mNavigationBar) {
		layoutNavigationBar(displayFrames, null /* simulatedContentFrame */);
		return;
		}
		if ((win == mStatusBar && !canReceiveInput(win))) {
		layoutStatusBar(displayFrames, null /* simulatedContentFrame */);
		return;
		}
		final WindowManager.LayoutParams attrs = win.getAttrs();