Store bounds in WindowConfiguration.
This changelist consolidates the usage of frame bounds in containers
into the WindowConfiguration. As a result, the bounds are now shared
across AM and WM. Any changes to the bounds on one side are
propagated to the other via override configuration changes. Previous
instrumentation to synchronize the two sides is no longer necessary.
This changelist does not attempt to consolidate common logic shared
between WM or AM components for setting bounds.
Bug: 68719294
Test: go/wm-smoke
Change-Id: Ia8978dba8525b83201640e159caefe16e626b7c1
diff --git a/services/core/java/com/android/server/wm/AppWindowContainerController.java b/services/core/java/com/android/server/wm/AppWindowContainerController.java
index a528ecd..00a0d3d 100644
--- a/services/core/java/com/android/server/wm/AppWindowContainerController.java
+++ b/services/core/java/com/android/server/wm/AppWindowContainerController.java
@@ -181,13 +181,12 @@
IApplicationToken token, AppWindowContainerListener listener, int index,
int requestedOrientation, boolean fullscreen, boolean showForAllUsers, int configChanges,
boolean voiceInteraction, boolean launchTaskBehind, boolean alwaysFocusable,
- int targetSdkVersion, int rotationAnimationHint, long inputDispatchingTimeoutNanos,
- Rect bounds) {
+ int targetSdkVersion, int rotationAnimationHint, long inputDispatchingTimeoutNanos) {
this(taskController, token, listener, index, requestedOrientation, fullscreen,
showForAllUsers,
configChanges, voiceInteraction, launchTaskBehind, alwaysFocusable,
targetSdkVersion, rotationAnimationHint, inputDispatchingTimeoutNanos,
- WindowManagerService.getInstance(), bounds);
+ WindowManagerService.getInstance());
}
public AppWindowContainerController(TaskWindowContainerController taskController,
@@ -195,7 +194,7 @@
int requestedOrientation, boolean fullscreen, boolean showForAllUsers, int configChanges,
boolean voiceInteraction, boolean launchTaskBehind, boolean alwaysFocusable,
int targetSdkVersion, int rotationAnimationHint, long inputDispatchingTimeoutNanos,
- WindowManagerService service, Rect bounds) {
+ WindowManagerService service) {
super(listener, service);
mHandler = new H(service.mH.getLooper());
mToken = token;
@@ -216,7 +215,7 @@
atoken = createAppWindow(mService, token, voiceInteraction, task.getDisplayContent(),
inputDispatchingTimeoutNanos, fullscreen, showForAllUsers, targetSdkVersion,
requestedOrientation, rotationAnimationHint, configChanges, launchTaskBehind,
- alwaysFocusable, this, bounds);
+ alwaysFocusable, this);
if (DEBUG_TOKEN_MOVEMENT || DEBUG_ADD_REMOVE) Slog.v(TAG_WM, "addAppToken: " + atoken
+ " controller=" + taskController + " at " + index);
task.addChild(atoken, index);
@@ -228,11 +227,11 @@
boolean voiceInteraction, DisplayContent dc, long inputDispatchingTimeoutNanos,
boolean fullscreen, boolean showForAllUsers, int targetSdk, int orientation,
int rotationAnimationHint, int configChanges, boolean launchTaskBehind,
- boolean alwaysFocusable, AppWindowContainerController controller, Rect bounds) {
+ boolean alwaysFocusable, AppWindowContainerController controller) {
return new AppWindowToken(service, token, voiceInteraction, dc,
inputDispatchingTimeoutNanos, fullscreen, showForAllUsers, targetSdk, orientation,
rotationAnimationHint, configChanges, launchTaskBehind, alwaysFocusable,
- controller, bounds);
+ controller);
}
public void removeContainer(int displayId) {
@@ -299,17 +298,6 @@
}
}
- // TODO(b/36505427): Maybe move to WindowContainerController so other sub-classes can use it as
- // a generic way to set override config. Need to untangle current ways the override config is
- // currently set for tasks and displays before we are doing that though.
- public void onOverrideConfigurationChanged(Configuration overrideConfiguration, Rect bounds) {
- synchronized(mWindowMap) {
- if (mContainer != null) {
- mContainer.onOverrideConfigurationChanged(overrideConfiguration, bounds);
- }
- }
- }
-
public void setDisablePreviewScreenshots(boolean disable) {
synchronized (mWindowMap) {
if (mContainer == null) {
diff --git a/services/core/java/com/android/server/wm/AppWindowToken.java b/services/core/java/com/android/server/wm/AppWindowToken.java
index 627f8ce..c39ce98 100644
--- a/services/core/java/com/android/server/wm/AppWindowToken.java
+++ b/services/core/java/com/android/server/wm/AppWindowToken.java
@@ -175,11 +175,6 @@
private boolean mLastContainsShowWhenLockedWindow;
private boolean mLastContainsDismissKeyguardWindow;
- // The bounds of this activity. Mainly used for aspect-ratio compatibility.
- // TODO(b/36505427): Every level on WindowContainer now has bounds information, which directly
- // affects the configuration. We should probably move this into that class.
- private final Rect mBounds = new Rect();
-
ArrayDeque<Rect> mFrozenBounds = new ArrayDeque<>();
ArrayDeque<Configuration> mFrozenMergedConfig = new ArrayDeque<>();
@@ -196,8 +191,8 @@
DisplayContent dc, long inputDispatchingTimeoutNanos, boolean fullscreen,
boolean showForAllUsers, int targetSdk, int orientation, int rotationAnimationHint,
int configChanges, boolean launchTaskBehind, boolean alwaysFocusable,
- AppWindowContainerController controller, Rect bounds) {
- this(service, token, voiceInteraction, dc, fullscreen, bounds);
+ AppWindowContainerController controller) {
+ this(service, token, voiceInteraction, dc, fullscreen);
setController(controller);
mInputDispatchingTimeoutNanos = inputDispatchingTimeoutNanos;
mShowForAllUsers = showForAllUsers;
@@ -214,7 +209,7 @@
}
AppWindowToken(WindowManagerService service, IApplicationToken token, boolean voiceInteraction,
- DisplayContent dc, boolean fillsParent, Rect bounds) {
+ DisplayContent dc, boolean fillsParent) {
super(service, token != null ? token.asBinder() : null, TYPE_APPLICATION, true, dc,
false /* ownerCanManageAppTokens */);
appToken = token;
@@ -222,27 +217,6 @@
mFillsParent = fillsParent;
mInputApplicationHandle = new InputApplicationHandle(this);
mAppAnimator = new AppWindowAnimator(this, service);
- if (bounds != null) {
- mBounds.set(bounds);
- }
- }
-
- void onOverrideConfigurationChanged(Configuration overrideConfiguration, Rect bounds) {
- onOverrideConfigurationChanged(overrideConfiguration);
- if (mBounds.equals(bounds)) {
- return;
- }
- // TODO(b/36505427): If bounds is in WC, then we can automatically call onResize() when set.
- mBounds.set(bounds);
- onResize();
- }
-
- void getBounds(Rect outBounds) {
- outBounds.set(mBounds);
- }
-
- boolean hasBounds() {
- return !mBounds.isEmpty();
}
void onFirstWindowDrawn(WindowState win, WindowStateAnimator winAnimator) {
diff --git a/services/core/java/com/android/server/wm/ConfigurationContainer.java b/services/core/java/com/android/server/wm/ConfigurationContainer.java
index b534b8a..d340923 100644
--- a/services/core/java/com/android/server/wm/ConfigurationContainer.java
+++ b/services/core/java/com/android/server/wm/ConfigurationContainer.java
@@ -36,6 +36,7 @@
import android.annotation.CallSuper;
import android.app.WindowConfiguration;
import android.content.res.Configuration;
+import android.graphics.Rect;
import android.util.proto.ProtoOutputStream;
import java.io.PrintWriter;
@@ -46,6 +47,11 @@
* hierarchy.
*/
public abstract class ConfigurationContainer<E extends ConfigurationContainer> {
+ /**
+ * {@link #Rect} returned from {@link #getOverrideBounds()} to prevent original value from being
+ * set directly.
+ */
+ private Rect mReturnBounds = new Rect();
/** Contains override configuration settings applied to this configuration container. */
private Configuration mOverrideConfiguration = new Configuration();
@@ -71,6 +77,16 @@
// TODO: Can't have ag/2592611 soon enough!
private final Configuration mTmpConfig = new Configuration();
+ // Used for setting bounds
+ private final Rect mTmpRect = new Rect();
+
+ static final int BOUNDS_CHANGE_NONE = 0;
+ // Return value from {@link setBounds} indicating the position of the override bounds changed.
+ static final int BOUNDS_CHANGE_POSITION = 1;
+ // Return value from {@link setBounds} indicating the size of the override bounds changed.
+ static final int BOUNDS_CHANGE_SIZE = 1 << 1;
+
+
/**
* Returns full configuration applied to this configuration container.
* This method should be used for getting settings applied in each particular level of the
@@ -148,6 +164,118 @@
}
}
+ /**
+ * Indicates whether this container has not specified any bounds different from its parent. In
+ * this case, it will inherit the bounds of the first ancestor which specifies a bounds.
+ * @return {@code true} if no explicit bounds have been set at this container level.
+ * {@code false} otherwise.
+ */
+ public boolean matchParentBounds() {
+ return getOverrideBounds().isEmpty();
+ }
+
+ /**
+ * Returns whether the bounds specified is considered the same as the existing override bounds.
+ * This is either when the two bounds are equal or the override bounds is empty and the
+ * specified bounds is null.
+ *
+ * @return {@code true} if the bounds are equivalent, {@code false} otherwise
+ */
+ public boolean equivalentOverrideBounds(Rect bounds) {
+ return equivalentBounds(getOverrideBounds(), bounds);
+ }
+
+ /**
+ * Returns whether the two bounds are equal to each other or are a combination of null or empty.
+ */
+ public static boolean equivalentBounds(Rect bounds, Rect other) {
+ return bounds == other
+ || (bounds != null && (bounds.equals(other) || (bounds.isEmpty() && other == null)))
+ || (other != null && other.isEmpty() && bounds == null);
+ }
+
+ /**
+ * Returns the effective bounds of this container, inheriting the first non-empty bounds set in
+ * its ancestral hierarchy, including itself.
+ * @return
+ */
+ public Rect getBounds() {
+ mReturnBounds.set(getConfiguration().windowConfiguration.getBounds());
+ return mReturnBounds;
+ }
+
+ public void getBounds(Rect outBounds) {
+ outBounds.set(getBounds());
+ }
+
+ /**
+ * Returns the current bounds explicitly set on this container. The {@link Rect} handed back is
+ * shared for all calls to this method and should not be modified.
+ */
+ public Rect getOverrideBounds() {
+ mReturnBounds.set(getOverrideConfiguration().windowConfiguration.getBounds());
+
+ return mReturnBounds;
+ }
+
+ /**
+ * Sets the passed in {@link Rect} to the current bounds.
+ * @see {@link #getOverrideBounds()}.
+ */
+ public void getOverrideBounds(Rect outBounds) {
+ outBounds.set(getOverrideBounds());
+ }
+
+ /**
+ * Sets the bounds at the current hierarchy level, overriding any bounds set on an ancestor.
+ * This value will be reported when {@link #getBounds()} and {@link #getOverrideBounds()}. If
+ * an empty {@link Rect} or null is specified, this container will be considered to match its
+ * parent bounds {@see #matchParentBounds} and will inherit bounds from its parent.
+ * @param bounds The bounds defining the container size.
+ * @return a bitmask representing the types of changes made to the bounds.
+ */
+ public int setBounds(Rect bounds) {
+ int boundsChange = diffOverrideBounds(bounds);
+
+ if (boundsChange == BOUNDS_CHANGE_NONE) {
+ return boundsChange;
+ }
+
+
+ mTmpConfig.setTo(getOverrideConfiguration());
+ mTmpConfig.windowConfiguration.setBounds(bounds);
+ onOverrideConfigurationChanged(mTmpConfig);
+
+ return boundsChange;
+ }
+
+ public int setBounds(int left, int top, int right, int bottom) {
+ mTmpRect.set(left, top, right, bottom);
+ return setBounds(mTmpRect);
+ }
+
+ int diffOverrideBounds(Rect bounds) {
+ if (equivalentOverrideBounds(bounds)) {
+ return BOUNDS_CHANGE_NONE;
+ }
+
+ int boundsChange = BOUNDS_CHANGE_NONE;
+
+ final Rect existingBounds = getOverrideBounds();
+
+ if (bounds == null || existingBounds.left != bounds.left
+ || existingBounds.top != bounds.top) {
+ boundsChange |= BOUNDS_CHANGE_POSITION;
+ }
+
+ if (bounds == null || existingBounds.width() != bounds.width()
+ || existingBounds.height() != bounds.height()) {
+ boundsChange |= BOUNDS_CHANGE_SIZE;
+ }
+
+ return boundsChange;
+ }
+
public WindowConfiguration getWindowConfiguration() {
return mFullConfiguration.windowConfiguration;
}
diff --git a/services/core/java/com/android/server/wm/DisplayContent.java b/services/core/java/com/android/server/wm/DisplayContent.java
index 44dfa07..3fb3773 100644
--- a/services/core/java/com/android/server/wm/DisplayContent.java
+++ b/services/core/java/com/android/server/wm/DisplayContent.java
@@ -314,6 +314,9 @@
private final Matrix mTmpMatrix = new Matrix();
private final Region mTmpRegion = new Region();
+ /** Used for handing back size of display */
+ private final Rect mTmpBounds = new Rect();
+
WindowManagerService mService;
/** Remove this display when animation on it has completed. */
@@ -1223,6 +1226,8 @@
mCompatibleScreenScale = CompatibilityInfo.computeCompatibleScaling(mDisplayMetrics,
mCompatDisplayMetrics);
}
+
+ updateBounds();
return mDisplayInfo;
}
@@ -1541,8 +1546,17 @@
// See {@link PhoneWindowManager#setInitialDisplaySize}...sigh...
mService.reconfigureDisplayLocked(this);
- getDockedDividerController().onConfigurationChanged();
- getPinnedStackController().onConfigurationChanged();
+ final DockedStackDividerController dividerController = getDockedDividerController();
+
+ if (dividerController != null) {
+ getDockedDividerController().onConfigurationChanged();
+ }
+
+ final PinnedStackController pinnedStackController = getPinnedStackController();
+
+ if (pinnedStackController != null) {
+ getPinnedStackController().onConfigurationChanged();
+ }
}
/**
@@ -1681,33 +1695,6 @@
mInitialDisplayDensity = mDisplayInfo.logicalDensityDpi;
}
- void getLogicalDisplayRect(Rect out) {
- // Uses same calculation as in LogicalDisplay#configureDisplayInTransactionLocked.
- final int orientation = mDisplayInfo.rotation;
- boolean rotated = (orientation == ROTATION_90 || orientation == ROTATION_270);
- final int physWidth = rotated ? mBaseDisplayHeight : mBaseDisplayWidth;
- final int physHeight = rotated ? mBaseDisplayWidth : mBaseDisplayHeight;
- int width = mDisplayInfo.logicalWidth;
- int left = (physWidth - width) / 2;
- int height = mDisplayInfo.logicalHeight;
- int top = (physHeight - height) / 2;
- out.set(left, top, left + width, top + height);
- }
-
- private void getLogicalDisplayRect(Rect out, int orientation) {
- getLogicalDisplayRect(out);
-
- // Rotate the Rect if needed.
- final int currentRotation = mDisplayInfo.rotation;
- final int rotationDelta = deltaRotation(currentRotation, orientation);
- if (rotationDelta == ROTATION_90 || rotationDelta == ROTATION_270) {
- createRotationMatrix(rotationDelta, mBaseDisplayWidth, mBaseDisplayHeight, mTmpMatrix);
- mTmpRectF.set(out);
- mTmpMatrix.mapRect(mTmpRectF);
- mTmpRectF.round(out);
- }
- }
-
/**
* If display metrics changed, overrides are not set and it's not just a rotation - update base
* values.
@@ -1775,6 +1762,8 @@
}
mBaseDisplayRect.set(0, 0, mBaseDisplayWidth, mBaseDisplayHeight);
+
+ updateBounds();
}
void getContentRect(Rect out) {
@@ -2104,7 +2093,7 @@
}
void rotateBounds(int oldRotation, int newRotation, Rect bounds) {
- getLogicalDisplayRect(mTmpRect, newRotation);
+ getBounds(mTmpRect, newRotation);
// Compute a transform matrix to undo the coordinate space transformation,
// and present the window at the same physical position it previously occupied.
@@ -2881,6 +2870,44 @@
return mTmpApplySurfaceChangesTransactionState.focusDisplayed;
}
+ private void updateBounds() {
+ calculateBounds(mTmpBounds);
+ setBounds(mTmpBounds);
+ }
+
+ // Determines the current display bounds based on the current state
+ private void calculateBounds(Rect out) {
+ // Uses same calculation as in LogicalDisplay#configureDisplayInTransactionLocked.
+ final int orientation = mDisplayInfo.rotation;
+ boolean rotated = (orientation == ROTATION_90 || orientation == ROTATION_270);
+ final int physWidth = rotated ? mBaseDisplayHeight : mBaseDisplayWidth;
+ final int physHeight = rotated ? mBaseDisplayWidth : mBaseDisplayHeight;
+ int width = mDisplayInfo.logicalWidth;
+ int left = (physWidth - width) / 2;
+ int height = mDisplayInfo.logicalHeight;
+ int top = (physHeight - height) / 2;
+ out.set(left, top, left + width, top + height);
+ }
+
+ @Override
+ public void getBounds(Rect out) {
+ calculateBounds(out);
+ }
+
+ private void getBounds(Rect out, int orientation) {
+ getBounds(out);
+
+ // Rotate the Rect if needed.
+ final int currentRotation = mDisplayInfo.rotation;
+ final int rotationDelta = deltaRotation(currentRotation, orientation);
+ if (rotationDelta == ROTATION_90 || rotationDelta == ROTATION_270) {
+ createRotationMatrix(rotationDelta, mBaseDisplayWidth, mBaseDisplayHeight, mTmpMatrix);
+ mTmpRectF.set(out);
+ mTmpMatrix.mapRect(mTmpRectF);
+ mTmpRectF.round(out);
+ }
+ }
+
void performLayout(boolean initial, boolean updateInputWindows) {
if (!isLayoutNeeded()) {
return;
diff --git a/services/core/java/com/android/server/wm/DockedStackDividerController.java b/services/core/java/com/android/server/wm/DockedStackDividerController.java
index 8308417..a37598e 100644
--- a/services/core/java/com/android/server/wm/DockedStackDividerController.java
+++ b/services/core/java/com/android/server/wm/DockedStackDividerController.java
@@ -655,8 +655,8 @@
}
private boolean isWithinDisplay(Task task) {
- task.mStack.getBounds(mTmpRect);
- mDisplayContent.getLogicalDisplayRect(mTmpRect2);
+ task.getBounds(mTmpRect);
+ mDisplayContent.getBounds(mTmpRect2);
return mTmpRect.intersect(mTmpRect2);
}
diff --git a/services/core/java/com/android/server/wm/InputMonitor.java b/services/core/java/com/android/server/wm/InputMonitor.java
index 18b0f97..7e29a3a 100644
--- a/services/core/java/com/android/server/wm/InputMonitor.java
+++ b/services/core/java/com/android/server/wm/InputMonitor.java
@@ -661,8 +661,8 @@
if (w.inPinnedWindowingMode()) {
if (mAddPipInputConsumerHandle
&& (inputWindowHandle.layer <= pipInputConsumer.mWindowHandle.layer)) {
- // Update the bounds of the Pip input consumer to match the Pinned stack
- w.getStack().getBounds(pipTouchableBounds);
+ // Update the bounds of the Pip input consumer to match the window bounds.
+ w.getBounds(pipTouchableBounds);
pipInputConsumer.mWindowHandle.touchableRegion.set(pipTouchableBounds);
addInputWindowHandle(pipInputConsumer.mWindowHandle);
mAddPipInputConsumerHandle = false;
diff --git a/services/core/java/com/android/server/wm/PinnedStackWindowController.java b/services/core/java/com/android/server/wm/PinnedStackWindowController.java
index 41f076d..b021a72 100644
--- a/services/core/java/com/android/server/wm/PinnedStackWindowController.java
+++ b/services/core/java/com/android/server/wm/PinnedStackWindowController.java
@@ -106,7 +106,7 @@
} else {
// Otherwise, use the display bounds
toBounds = new Rect();
- mContainer.getDisplayContent().getLogicalDisplayRect(toBounds);
+ mContainer.getDisplayContent().getBounds(toBounds);
}
} else if (fromFullscreen) {
schedulePipModeChangedState = SCHEDULE_PIP_MODE_CHANGED_ON_END;
diff --git a/services/core/java/com/android/server/wm/ScreenRotationAnimation.java b/services/core/java/com/android/server/wm/ScreenRotationAnimation.java
index 70bf15c..5a39de5 100644
--- a/services/core/java/com/android/server/wm/ScreenRotationAnimation.java
+++ b/services/core/java/com/android/server/wm/ScreenRotationAnimation.java
@@ -28,7 +28,6 @@
import android.content.Context;
import android.graphics.Matrix;
-import android.graphics.PixelFormat;
import android.graphics.Rect;
import android.util.Slog;
import android.util.proto.ProtoOutputStream;
@@ -230,7 +229,7 @@
mService = service;
mContext = context;
mDisplayContent = displayContent;
- displayContent.getLogicalDisplayRect(mOriginalDisplayRect);
+ displayContent.getBounds(mOriginalDisplayRect);
// Screenshot does NOT include rotation!
final Display display = displayContent.getDisplay();
@@ -312,7 +311,7 @@
float x = mTmpFloats[Matrix.MTRANS_X];
float y = mTmpFloats[Matrix.MTRANS_Y];
if (mForceDefaultOrientation) {
- mDisplayContent.getLogicalDisplayRect(mCurrentDisplayRect);
+ mDisplayContent.getBounds(mCurrentDisplayRect);
x -= mCurrentDisplayRect.left;
y -= mCurrentDisplayRect.top;
}
diff --git a/services/core/java/com/android/server/wm/StackWindowController.java b/services/core/java/com/android/server/wm/StackWindowController.java
index 95c1d53..c2a4be5 100644
--- a/services/core/java/com/android/server/wm/StackWindowController.java
+++ b/services/core/java/com/android/server/wm/StackWindowController.java
@@ -111,8 +111,7 @@
}
}
- public void positionChildAt(TaskWindowContainerController child, int position, Rect bounds,
- Configuration overrideConfig) {
+ public void positionChildAt(TaskWindowContainerController child, int position) {
synchronized (mWindowMap) {
if (DEBUG_STACK) Slog.i(TAG_WM, "positionChildAt: positioning task=" + child
+ " at " + position);
@@ -126,7 +125,7 @@
"positionChildAt: could not find stack for task=" + mContainer);
return;
}
- child.mContainer.positionAt(position, bounds, overrideConfig);
+ child.mContainer.positionAt(position);
mContainer.getDisplayContent().layoutAndAssignWindowLayersIfNeeded();
}
}
@@ -178,24 +177,22 @@
* Re-sizes a stack and its containing tasks.
*
* @param bounds New stack bounds. Passing in null sets the bounds to fullscreen.
- * @param configs Configurations for tasks in the resized stack, keyed by task id.
* @param taskBounds Bounds for tasks in the resized stack, keyed by task id.
- * @return True if the stack is now fullscreen.
+ * @param taskTempInsetBounds Inset bounds for individual tasks, keyed by task id.
*/
- public boolean resize(Rect bounds, SparseArray<Configuration> configs,
- SparseArray<Rect> taskBounds, SparseArray<Rect> taskTempInsetBounds) {
+ public void resize(Rect bounds, SparseArray<Rect> taskBounds,
+ SparseArray<Rect> taskTempInsetBounds) {
synchronized (mWindowMap) {
if (mContainer == null) {
throw new IllegalArgumentException("resizeStack: stack " + this + " not found.");
}
// We might trigger a configuration change. Save the current task bounds for freezing.
mContainer.prepareFreezingTaskBounds();
- if (mContainer.setBounds(bounds, configs, taskBounds, taskTempInsetBounds)
+ if (mContainer.setBounds(bounds, taskBounds, taskTempInsetBounds)
&& mContainer.isVisible()) {
mContainer.getDisplayContent().setLayoutNeeded();
mService.mWindowPlacerLocked.performSurfacePlacement();
}
- return mContainer.getRawFullscreen();
}
}
@@ -227,7 +224,7 @@
public void getRawBounds(Rect outBounds) {
synchronized (mWindowMap) {
- if (mContainer.getRawFullscreen()) {
+ if (mContainer.matchParentBounds()) {
outBounds.setEmpty();
} else {
mContainer.getRawBounds(outBounds);
@@ -275,6 +272,7 @@
final Rect parentAppBounds = parentConfig.windowConfiguration.getAppBounds();
+ config.windowConfiguration.setBounds(bounds);
config.windowConfiguration.setAppBounds(!bounds.isEmpty() ? bounds : null);
boolean intersectParentBounds = false;
diff --git a/services/core/java/com/android/server/wm/Task.java b/services/core/java/com/android/server/wm/Task.java
index f70845e..8aa129a 100644
--- a/services/core/java/com/android/server/wm/Task.java
+++ b/services/core/java/com/android/server/wm/Task.java
@@ -53,12 +53,6 @@
class Task extends WindowContainer<AppWindowToken> {
static final String TAG = TAG_WITH_CLASS_NAME ? "Task" : TAG_WM;
- // Return value from {@link setBounds} indicating no change was made to the Task bounds.
- private static final int BOUNDS_CHANGE_NONE = 0;
- // Return value from {@link setBounds} indicating the position of the Task bounds changed.
- private static final int BOUNDS_CHANGE_POSITION = 1;
- // Return value from {@link setBounds} indicating the size of the Task bounds changed.
- private static final int BOUNDS_CHANGE_SIZE = 1 << 1;
// TODO: Track parent marks like this in WindowContainer.
TaskStack mStack;
@@ -67,8 +61,6 @@
private boolean mDeferRemoval = false;
final WindowManagerService mService;
- // Content limits relative to the DisplayContent this sits in.
- private Rect mBounds = new Rect();
final Rect mPreparedFrozenBounds = new Rect();
final Configuration mPreparedFrozenMergedConfig = new Configuration();
@@ -78,13 +70,12 @@
// Device rotation as of the last time {@link #mBounds} was set.
private int mRotation;
- // Whether mBounds is fullscreen
- private boolean mFillsParent = true;
-
// For comparison with DisplayContent bounds.
private Rect mTmpRect = new Rect();
// For handling display rotations.
private Rect mTmpRect2 = new Rect();
+ // For retrieving dim bounds
+ private Rect mTmpRect3 = new Rect();
// Resize mode of the task. See {@link ActivityInfo#resizeMode}
private int mResizeMode;
@@ -108,8 +99,8 @@
private Dimmer mDimmer = new Dimmer(this);
private final Rect mTmpDimBoundsRect = new Rect();
- Task(int taskId, TaskStack stack, int userId, WindowManagerService service, Rect bounds,
- int resizeMode, boolean supportsPictureInPicture, TaskDescription taskDescription,
+ Task(int taskId, TaskStack stack, int userId, WindowManagerService service, int resizeMode,
+ boolean supportsPictureInPicture, TaskDescription taskDescription,
TaskWindowContainerController controller) {
mTaskId = taskId;
mStack = stack;
@@ -118,7 +109,7 @@
mResizeMode = resizeMode;
mSupportsPictureInPicture = supportsPictureInPicture;
setController(controller);
- setBounds(bounds, getOverrideConfiguration());
+ setBounds(getOverrideBounds());
mTaskDescription = taskDescription;
// Tasks have no set orientation value (including SCREEN_ORIENTATION_UNSPECIFIED).
@@ -227,9 +218,8 @@
}
/** @see com.android.server.am.ActivityManagerService#positionTaskInStack(int, int, int). */
- void positionAt(int position, Rect bounds, Configuration overrideConfig) {
+ void positionAt(int position) {
mStack.positionChildAt(position, this, false /* includingParents */);
- resizeLocked(bounds, overrideConfig, false /* force */);
}
@Override
@@ -271,48 +261,37 @@
}
}
- /** Set the task bounds. Passing in null sets the bounds to fullscreen. */
- // TODO: There is probably not a need to pass in overrideConfig anymore since any change to it
- // will be automatically propagated from the AM. Also, mBound is going to be in
- // WindowConfiguration long term.
- private int setBounds(Rect bounds, Configuration overrideConfig) {
- if (overrideConfig == null) {
- overrideConfig = EMPTY;
+ public int setBounds(Rect bounds, boolean forceResize) {
+ final int boundsChanged = setBounds(bounds);
+
+ if (forceResize && (boundsChanged & BOUNDS_CHANGE_SIZE) != BOUNDS_CHANGE_SIZE) {
+ onResize();
+ return BOUNDS_CHANGE_SIZE | boundsChanged;
}
- boolean oldFullscreen = mFillsParent;
+ return boundsChanged;
+ }
+
+ /** Set the task bounds. Passing in null sets the bounds to fullscreen. */
+ @Override
+ public int setBounds(Rect bounds) {
int rotation = Surface.ROTATION_0;
final DisplayContent displayContent = mStack.getDisplayContent();
if (displayContent != null) {
- displayContent.getLogicalDisplayRect(mTmpRect);
rotation = displayContent.getDisplayInfo().rotation;
- mFillsParent = bounds == null;
- if (mFillsParent) {
- bounds = mTmpRect;
- }
- }
-
- if (bounds == null) {
+ } else if (bounds == null) {
// Can't set to fullscreen if we don't have a display to get bounds from...
return BOUNDS_CHANGE_NONE;
}
- if (mBounds.equals(bounds) && oldFullscreen == mFillsParent && mRotation == rotation) {
+
+ if (equivalentOverrideBounds(bounds)) {
return BOUNDS_CHANGE_NONE;
}
- int boundsChange = BOUNDS_CHANGE_NONE;
- if (mBounds.left != bounds.left || mBounds.top != bounds.top) {
- boundsChange |= BOUNDS_CHANGE_POSITION;
- }
- if (mBounds.width() != bounds.width() || mBounds.height() != bounds.height()) {
- boundsChange |= BOUNDS_CHANGE_SIZE;
- }
-
- mBounds.set(bounds);
+ final int boundsChange = super.setBounds(bounds);
mRotation = rotation;
- onOverrideConfigurationChanged(overrideConfig);
return boundsChange;
}
@@ -360,28 +339,12 @@
return isResizeable();
}
- boolean resizeLocked(Rect bounds, Configuration overrideConfig, boolean forced) {
- int boundsChanged = setBounds(bounds, overrideConfig);
- if (forced) {
- boundsChanged |= BOUNDS_CHANGE_SIZE;
- }
- if (boundsChanged == BOUNDS_CHANGE_NONE) {
- return false;
- }
- if ((boundsChanged & BOUNDS_CHANGE_SIZE) == BOUNDS_CHANGE_SIZE) {
- onResize();
- } else {
- onMovedByResize();
- }
- return true;
- }
-
/**
* Prepares the task bounds to be frozen with the current size. See
* {@link AppWindowToken#freezeBounds}.
*/
void prepareFreezingBounds() {
- mPreparedFrozenBounds.set(mBounds);
+ mPreparedFrozenBounds.set(getBounds());
mPreparedFrozenMergedConfig.setTo(getConfiguration());
}
@@ -407,30 +370,30 @@
mTmpRect2.offsetTo(adjustedBounds.left, adjustedBounds.top);
}
setTempInsetBounds(tempInsetBounds);
- resizeLocked(mTmpRect2, getOverrideConfiguration(), false /* forced */);
+ setBounds(mTmpRect2, false /* forced */);
}
/** Return true if the current bound can get outputted to the rest of the system as-is. */
private boolean useCurrentBounds() {
final DisplayContent displayContent = getDisplayContent();
- return mFillsParent
+ return matchParentBounds()
|| !inSplitScreenSecondaryWindowingMode()
|| displayContent == null
|| displayContent.getSplitScreenPrimaryStackIgnoringVisibility() != null;
}
- /** Original bounds of the task if applicable, otherwise fullscreen rect. */
- void getBounds(Rect out) {
+ @Override
+ public void getBounds(Rect out) {
if (useCurrentBounds()) {
// No need to adjust the output bounds if fullscreen or the docked stack is visible
// since it is already what we want to represent to the rest of the system.
- out.set(mBounds);
+ super.getBounds(out);
return;
}
// The bounds has been adjusted to accommodate for a docked stack, but the docked stack is
// not currently visible. Go ahead a represent it as fullscreen to the rest of the system.
- mStack.getDisplayContent().getLogicalDisplayRect(out);
+ mStack.getDisplayContent().getBounds(out);
}
/**
@@ -490,7 +453,7 @@
return;
}
- if (!mFillsParent) {
+ if (!matchParentBounds()) {
// When minimizing the docked stack when going home, we don't adjust the task bounds
// so we need to intersect the task bounds with the stack bounds here.
//
@@ -501,11 +464,11 @@
mStack.getBounds(out);
} else {
mStack.getBounds(mTmpRect);
- mTmpRect.intersect(mBounds);
+ mTmpRect.intersect(getBounds());
}
out.set(mTmpRect);
} else {
- out.set(mBounds);
+ out.set(getBounds());
}
return;
}
@@ -513,7 +476,7 @@
// The bounds has been adjusted to accommodate for a docked stack, but the docked stack is
// not currently visible. Go ahead a represent it as fullscreen to the rest of the system.
if (displayContent != null) {
- displayContent.getLogicalDisplayRect(out);
+ displayContent.getBounds(out);
}
}
@@ -541,10 +504,10 @@
if (displayContent == null) {
return;
}
- if (mFillsParent) {
+ if (matchParentBounds()) {
// TODO: Yeah...not sure if this works with WindowConfiguration, but shouldn't be a
// problem once we move mBounds into WindowConfiguration.
- setBounds(null, getOverrideConfiguration());
+ setBounds(null);
return;
}
final int newRotation = displayContent.getDisplayInfo().rotation;
@@ -557,18 +520,18 @@
// task bounds so it stays in the same place.
// - Rotate the bounds and notify activity manager if the task can be resized independently
// from its stack. The stack will take care of task rotation for the other case.
- mTmpRect2.set(mBounds);
+ mTmpRect2.set(getBounds());
if (!getWindowConfiguration().canResizeTask()) {
- setBounds(mTmpRect2, getOverrideConfiguration());
+ setBounds(mTmpRect2);
return;
}
displayContent.rotateBounds(mRotation, newRotation, mTmpRect2);
- if (setBounds(mTmpRect2, getOverrideConfiguration()) != BOUNDS_CHANGE_NONE) {
+ if (setBounds(mTmpRect2) != BOUNDS_CHANGE_NONE) {
final TaskWindowContainerController controller = getController();
if (controller != null) {
- controller.requestResize(mBounds, RESIZE_MODE_SYSTEM_SCREEN_ROTATION);
+ controller.requestResize(getBounds(), RESIZE_MODE_SYSTEM_SCREEN_ROTATION);
}
}
}
@@ -632,7 +595,7 @@
boolean isFullscreen() {
if (useCurrentBounds()) {
- return mFillsParent;
+ return matchParentBounds();
}
// The bounds has been adjusted to accommodate for a docked stack, but the docked stack
// is not currently visible. Go ahead a represent it as fullscreen to the rest of the
@@ -661,7 +624,7 @@
@Override
boolean fillsParent() {
- return mFillsParent || !getWindowConfiguration().canResizeTask();
+ return matchParentBounds() || !getWindowConfiguration().canResizeTask();
}
@Override
@@ -711,8 +674,8 @@
final AppWindowToken appWindowToken = mChildren.get(i);
appWindowToken.writeToProto(proto, APP_WINDOW_TOKENS, trim);
}
- proto.write(FILLS_PARENT, mFillsParent);
- mBounds.writeToProto(proto, BOUNDS);
+ proto.write(FILLS_PARENT, matchParentBounds());
+ getBounds().writeToProto(proto, BOUNDS);
mTempInsetBounds.writeToProto(proto, TEMP_INSET_BOUNDS);
proto.end(token);
}
@@ -721,8 +684,7 @@
final String doublePrefix = prefix + " ";
pw.println(prefix + "taskId=" + mTaskId);
- pw.println(doublePrefix + "mFillsParent=" + mFillsParent);
- pw.println(doublePrefix + "mBounds=" + mBounds.toShortString());
+ pw.println(doublePrefix + "mBounds=" + getBounds().toShortString());
pw.println(doublePrefix + "mdr=" + mDeferRemoval);
pw.println(doublePrefix + "appTokens=" + mChildren);
pw.println(doublePrefix + "mTempInsetBounds=" + mTempInsetBounds.toShortString());
diff --git a/services/core/java/com/android/server/wm/TaskSnapshotSurface.java b/services/core/java/com/android/server/wm/TaskSnapshotSurface.java
index e3c7515..41915a3 100644
--- a/services/core/java/com/android/server/wm/TaskSnapshotSurface.java
+++ b/services/core/java/com/android/server/wm/TaskSnapshotSurface.java
@@ -18,9 +18,7 @@
import static android.graphics.Color.WHITE;
import static android.graphics.Color.alpha;
-import static android.view.SurfaceControl.HIDDEN;
import static android.view.WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM;
-import static android.view.WindowManager.LayoutParams.FLAG_DIM_BEHIND;
import static android.view.WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED;
import static android.view.WindowManager.LayoutParams.FLAG_IGNORE_CHEEK_PRESSES;
import static android.view.WindowManager.LayoutParams.FLAG_LOCAL_FOCUS_MODE;
diff --git a/services/core/java/com/android/server/wm/TaskStack.java b/services/core/java/com/android/server/wm/TaskStack.java
index 8a930ef..4a3a3fc 100644
--- a/services/core/java/com/android/server/wm/TaskStack.java
+++ b/services/core/java/com/android/server/wm/TaskStack.java
@@ -36,7 +36,6 @@
import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_ANIM;
import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_TASK_MOVEMENT;
import static com.android.server.wm.WindowManagerDebugConfig.TAG_WM;
-import static com.android.server.wm.WindowManagerService.LAYER_OFFSET_DIM;
import static com.android.server.wm.proto.StackProto.ANIMATION_BACKGROUND_SURFACE_IS_DIMMING;
import static com.android.server.wm.proto.StackProto.BOUNDS;
import static com.android.server.wm.proto.StackProto.FILLS_PARENT;
@@ -88,9 +87,6 @@
private Rect mTmpRect2 = new Rect();
private Rect mTmpRect3 = new Rect();
- /** Content limits relative to the DisplayContent this sits in. */
- private Rect mBounds = new Rect();
-
/** Stack bounds adjusted to screen content area (taking into account IM windows, etc.) */
private final Rect mAdjustedBounds = new Rect();
@@ -100,9 +96,6 @@
*/
private final Rect mFullyAdjustedImeBounds = new Rect();
- /** Whether mBounds is fullscreen */
- private boolean mFillsParent = true;
-
// Device rotation as of the last time {@link #mBounds} was set.
private int mRotation;
@@ -180,27 +173,20 @@
/**
* Set the bounds of the stack and its containing tasks.
* @param stackBounds New stack bounds. Passing in null sets the bounds to fullscreen.
- * @param configs Configuration for individual tasks, keyed by task id.
* @param taskBounds Bounds for individual tasks, keyed by task id.
+ * @param taskTempInsetBounds Inset bounds for individual tasks, keyed by task id.
* @return True if the stack bounds was changed.
* */
boolean setBounds(
- Rect stackBounds, SparseArray<Configuration> configs, SparseArray<Rect> taskBounds,
- SparseArray<Rect> taskTempInsetBounds) {
+ Rect stackBounds, SparseArray<Rect> taskBounds, SparseArray<Rect> taskTempInsetBounds) {
setBounds(stackBounds);
// Update bounds of containing tasks.
for (int taskNdx = mChildren.size() - 1; taskNdx >= 0; --taskNdx) {
final Task task = mChildren.get(taskNdx);
- Configuration config = configs.get(task.mTaskId);
- if (config != null) {
- Rect bounds = taskBounds.get(task.mTaskId);
- task.resizeLocked(bounds, config, false /* forced */);
- task.setTempInsetBounds(taskTempInsetBounds != null ?
- taskTempInsetBounds.get(task.mTaskId) : null);
- } else {
- Slog.wtf(TAG_WM, "No config for task: " + task + ", is there a mismatch with AM?");
- }
+ task.setBounds(taskBounds.get(task.mTaskId), false /* forced */);
+ task.setTempInsetBounds(taskTempInsetBounds != null ?
+ taskTempInsetBounds.get(task.mTaskId) : null);
}
return true;
}
@@ -227,20 +213,20 @@
final boolean adjusted = !mAdjustedBounds.isEmpty();
Rect insetBounds = null;
if (adjusted && isAdjustedForMinimizedDockedStack()) {
- insetBounds = mBounds;
+ insetBounds = getRawBounds();
} else if (adjusted && mAdjustedForIme) {
if (mImeGoingAway) {
- insetBounds = mBounds;
+ insetBounds = getRawBounds();
} else {
insetBounds = mFullyAdjustedImeBounds;
}
}
- alignTasksToAdjustedBounds(adjusted ? mAdjustedBounds : mBounds, insetBounds);
+ alignTasksToAdjustedBounds(adjusted ? mAdjustedBounds : getRawBounds(), insetBounds);
mDisplayContent.setLayoutNeeded();
}
private void alignTasksToAdjustedBounds(Rect adjustedBounds, Rect tempInsetBounds) {
- if (mFillsParent) {
+ if (matchParentBounds()) {
return;
}
@@ -253,13 +239,15 @@
}
}
- private void setAnimationBackgroundBounds(Rect bounds) {
+ private void updateAnimationBackgroundBounds() {
if (mAnimationBackgroundSurface == null) {
return;
}
+ getRawBounds(mTmpRect);
// TODO: Should be in relative coordinates.
- getPendingTransaction().setSize(mAnimationBackgroundSurface, bounds.width(), bounds.height())
- .setPosition(mAnimationBackgroundSurface, bounds.left, bounds.top);
+ getPendingTransaction().setSize(mAnimationBackgroundSurface, mTmpRect.width(),
+ mTmpRect.height()).setPosition(mAnimationBackgroundSurface, mTmpRect.left,
+ mTmpRect.top);
scheduleAnimation();
}
@@ -283,50 +271,53 @@
scheduleAnimation();
}
- private boolean setBounds(Rect bounds) {
- boolean oldFullscreen = mFillsParent;
+ @Override
+ public int setBounds(Rect bounds) {
+ return setBounds(getOverrideBounds(), bounds);
+ }
+
+ private int setBounds(Rect existing, Rect bounds) {
int rotation = Surface.ROTATION_0;
int density = DENSITY_DPI_UNDEFINED;
if (mDisplayContent != null) {
- mDisplayContent.getLogicalDisplayRect(mTmpRect);
+ mDisplayContent.getBounds(mTmpRect);
rotation = mDisplayContent.getDisplayInfo().rotation;
density = mDisplayContent.getDisplayInfo().logicalDensityDpi;
- mFillsParent = bounds == null;
- if (mFillsParent) {
- bounds = mTmpRect;
- }
}
- if (bounds == null) {
- // Can't set to fullscreen if we don't have a display to get bounds from...
- return false;
- }
- if (mBounds.equals(bounds) && oldFullscreen == mFillsParent && mRotation == rotation) {
- return false;
+ if (equivalentBounds(existing, bounds) && mRotation == rotation) {
+ return BOUNDS_CHANGE_NONE;
}
- setAnimationBackgroundBounds(bounds);
+ final int result = super.setBounds(bounds);
- mBounds.set(bounds);
+ if (mDisplayContent != null) {
+ updateAnimationBackgroundBounds();
+ }
+
mRotation = rotation;
mDensity = density;
updateAdjustedBounds();
- return true;
+ return result;
}
/** Bounds of the stack without adjusting for other factors in the system like visibility
* of docked stack.
- * Most callers should be using {@link #getBounds} as it take into consideration other system
- * factors. */
+ * Most callers should be using {@link ConfigurationContainer#getOverrideBounds} as it take into
+ * consideration other system factors. */
void getRawBounds(Rect out) {
- out.set(mBounds);
+ out.set(getRawBounds());
+ }
+
+ Rect getRawBounds() {
+ return super.getBounds();
}
/** Return true if the current bound can get outputted to the rest of the system as-is. */
private boolean useCurrentBounds() {
- if (mFillsParent
+ if (matchParentBounds()
|| !inSplitScreenSecondaryWindowingMode()
|| mDisplayContent == null
|| mDisplayContent.getSplitScreenPrimaryStack() != null) {
@@ -335,24 +326,29 @@
return false;
}
- public void getBounds(Rect out) {
+ @Override
+ public void getBounds(Rect bounds) {
+ bounds.set(getBounds());
+ }
+
+ @Override
+ public Rect getBounds() {
if (useCurrentBounds()) {
// If we're currently adjusting for IME or minimized docked stack, we use the adjusted
// bounds; otherwise, no need to adjust the output bounds if fullscreen or the docked
// stack is visible since it is already what we want to represent to the rest of the
// system.
if (!mAdjustedBounds.isEmpty()) {
- out.set(mAdjustedBounds);
+ return mAdjustedBounds;
} else {
- out.set(mBounds);
+ return super.getBounds();
}
- return;
}
// The bounds has been adjusted to accommodate for a docked stack, but the docked stack
// is not currently visible. Go ahead a represent it as fullscreen to the rest of the
// system.
- mDisplayContent.getLogicalDisplayRect(out);
+ return mDisplayContent.getBounds();
}
/**
@@ -373,7 +369,7 @@
mBoundsAnimationSourceHintBounds.setEmpty();
}
- mPreAnimationBounds.set(mBounds);
+ mPreAnimationBounds.set(getRawBounds());
}
/**
@@ -418,12 +414,12 @@
if (bounds != null) {
setBounds(bounds);
return;
- } else if (mFillsParent) {
+ } else if (matchParentBounds()) {
setBounds(null);
return;
}
- mTmpRect2.set(mBounds);
+ mTmpRect2.set(getRawBounds());
final int newRotation = mDisplayContent.getDisplayInfo().rotation;
final int newDensity = mDisplayContent.getDisplayInfo().logicalDensityDpi;
if (mRotation == newRotation && mDensity == newDensity) {
@@ -466,14 +462,14 @@
return false;
}
- if (mFillsParent) {
+ if (matchParentBounds()) {
// Update stack bounds again since rotation changed since updateDisplayInfo().
setBounds(null);
// Return false since we don't need the client to resize.
return false;
}
- mTmpRect2.set(mBounds);
+ mTmpRect2.set(getRawBounds());
mDisplayContent.rotateBounds(mRotation, newRotation, mTmpRect2);
if (inSplitScreenPrimaryWindowingMode()) {
repositionPrimarySplitScreenStackAfterRotation(mTmpRect2);
@@ -510,7 +506,7 @@
if (mDisplayContent.getDockedDividerController().canPrimaryStackDockTo(dockSide)) {
return;
}
- mDisplayContent.getLogicalDisplayRect(mTmpRect);
+ mDisplayContent.getBounds(mTmpRect);
dockSide = DockedDividerUtils.invertDockSide(dockSide);
switch (dockSide) {
case DOCKED_LEFT:
@@ -755,7 +751,7 @@
// not fullscreen. If it's fullscreen, it means that we are in the transition of
// dismissing it, so we must not resize this stack.
bounds = new Rect();
- mDisplayContent.getLogicalDisplayRect(mTmpRect);
+ mDisplayContent.getBounds(mTmpRect);
mTmpRect2.setEmpty();
if (splitScreenStack != null) {
splitScreenStack.getRawBounds(mTmpRect2);
@@ -818,7 +814,7 @@
}
if (!inSplitScreenWindowingMode() || mDisplayContent == null) {
- outStackBounds.set(mBounds);
+ outStackBounds.set(getRawBounds());
return;
}
@@ -833,7 +829,7 @@
// The docked stack is being dismissed, but we caught before it finished being
// dismissed. In that case we want to treat it as if it is not occupying any space and
// let others occupy the whole display.
- mDisplayContent.getLogicalDisplayRect(outStackBounds);
+ mDisplayContent.getBounds(outStackBounds);
return;
}
@@ -841,11 +837,11 @@
if (dockedSide == DOCKED_INVALID) {
// Not sure how you got here...Only thing we can do is return current bounds.
Slog.e(TAG_WM, "Failed to get valid docked side for docked stack=" + dockedStack);
- outStackBounds.set(mBounds);
+ outStackBounds.set(getRawBounds());
return;
}
- mDisplayContent.getLogicalDisplayRect(mTmpRect);
+ mDisplayContent.getBounds(mTmpRect);
dockedStack.getRawBounds(mTmpRect2);
final boolean dockedOnTopOrLeft = dockedSide == DOCKED_TOP || dockedSide == DOCKED_LEFT;
getStackDockedModeBounds(mTmpRect, outStackBounds, mTmpRect2,
@@ -1146,14 +1142,14 @@
// occluded by IME. We shift its bottom up by the height of the IME, but
// leaves at least 30% of the top stack visible.
final int minTopStackBottom =
- getMinTopStackBottom(displayContentRect, mBounds.bottom);
+ getMinTopStackBottom(displayContentRect, getRawBounds().bottom);
final int bottom = Math.max(
- mBounds.bottom - yOffset + dividerWidth - dividerWidthInactive,
+ getRawBounds().bottom - yOffset + dividerWidth - dividerWidthInactive,
minTopStackBottom);
- mTmpAdjustedBounds.set(mBounds);
- mTmpAdjustedBounds.bottom =
- (int) (mAdjustImeAmount * bottom + (1 - mAdjustImeAmount) * mBounds.bottom);
- mFullyAdjustedImeBounds.set(mBounds);
+ mTmpAdjustedBounds.set(getRawBounds());
+ mTmpAdjustedBounds.bottom = (int) (mAdjustImeAmount * bottom + (1 - mAdjustImeAmount)
+ * getRawBounds().bottom);
+ mFullyAdjustedImeBounds.set(getRawBounds());
} else {
// When the stack is on bottom and has no focus, it's only adjusted for divider width.
final int dividerWidthDelta = dividerWidthInactive - dividerWidth;
@@ -1163,22 +1159,24 @@
// We try to move it up by the height of the IME window, but only to the extent
// that leaves at least 30% of the top stack visible.
// 'top' is where the top of bottom stack will move to in this case.
- final int topBeforeImeAdjust = mBounds.top - dividerWidth + dividerWidthInactive;
+ final int topBeforeImeAdjust =
+ getRawBounds().top - dividerWidth + dividerWidthInactive;
final int minTopStackBottom =
- getMinTopStackBottom(displayContentRect, mBounds.top - dividerWidth);
+ getMinTopStackBottom(displayContentRect,
+ getRawBounds().top - dividerWidth);
final int top = Math.max(
- mBounds.top - yOffset, minTopStackBottom + dividerWidthInactive);
+ getRawBounds().top - yOffset, minTopStackBottom + dividerWidthInactive);
- mTmpAdjustedBounds.set(mBounds);
+ mTmpAdjustedBounds.set(getRawBounds());
// Account for the adjustment for IME and divider width separately.
// (top - topBeforeImeAdjust) is the amount of movement due to IME only,
// and dividerWidthDelta is due to divider width change only.
- mTmpAdjustedBounds.top = mBounds.top +
+ mTmpAdjustedBounds.top = getRawBounds().top +
(int) (mAdjustImeAmount * (top - topBeforeImeAdjust) +
mAdjustDividerAmount * dividerWidthDelta);
- mFullyAdjustedImeBounds.set(mBounds);
+ mFullyAdjustedImeBounds.set(getRawBounds());
mFullyAdjustedImeBounds.top = top;
- mFullyAdjustedImeBounds.bottom = top + mBounds.height();
+ mFullyAdjustedImeBounds.bottom = top + getRawBounds().height();
}
return true;
}
@@ -1192,21 +1190,21 @@
if (dockSide == DOCKED_TOP) {
mService.getStableInsetsLocked(DEFAULT_DISPLAY, mTmpRect);
int topInset = mTmpRect.top;
- mTmpAdjustedBounds.set(mBounds);
- mTmpAdjustedBounds.bottom =
- (int) (minimizeAmount * topInset + (1 - minimizeAmount) * mBounds.bottom);
+ mTmpAdjustedBounds.set(getRawBounds());
+ mTmpAdjustedBounds.bottom = (int) (minimizeAmount * topInset + (1 - minimizeAmount)
+ * getRawBounds().bottom);
} else if (dockSide == DOCKED_LEFT) {
- mTmpAdjustedBounds.set(mBounds);
- final int width = mBounds.width();
+ mTmpAdjustedBounds.set(getRawBounds());
+ final int width = getRawBounds().width();
mTmpAdjustedBounds.right =
(int) (minimizeAmount * mDockedStackMinimizeThickness
- + (1 - minimizeAmount) * mBounds.right);
+ + (1 - minimizeAmount) * getRawBounds().right);
mTmpAdjustedBounds.left = mTmpAdjustedBounds.right - width;
} else if (dockSide == DOCKED_RIGHT) {
- mTmpAdjustedBounds.set(mBounds);
- mTmpAdjustedBounds.left =
- (int) (minimizeAmount * (mBounds.right - mDockedStackMinimizeThickness)
- + (1 - minimizeAmount) * mBounds.left);
+ mTmpAdjustedBounds.set(getRawBounds());
+ mTmpAdjustedBounds.left = (int) (minimizeAmount *
+ (getRawBounds().right - mDockedStackMinimizeThickness)
+ + (1 - minimizeAmount) * getRawBounds().left);
}
return true;
}
@@ -1228,9 +1226,9 @@
if (dockSide == DOCKED_TOP) {
mService.getStableInsetsLocked(DEFAULT_DISPLAY, mTmpRect);
int topInset = mTmpRect.top;
- return mBounds.bottom - topInset;
+ return getRawBounds().bottom - topInset;
} else if (dockSide == DOCKED_LEFT || dockSide == DOCKED_RIGHT) {
- return mBounds.width() - mDockedStackMinimizeThickness;
+ return getRawBounds().width() - mDockedStackMinimizeThickness;
} else {
return 0;
}
@@ -1264,11 +1262,12 @@
return;
}
- final Rect insetBounds = mImeGoingAway ? mBounds : mFullyAdjustedImeBounds;
+ final Rect insetBounds = mImeGoingAway ? getRawBounds() : mFullyAdjustedImeBounds;
task.alignToAdjustedBounds(mAdjustedBounds, insetBounds, getDockSide() == DOCKED_TOP);
mDisplayContent.setLayoutNeeded();
}
+
boolean isAdjustedForMinimizedDockedStack() {
return mMinimizeAmount != 0f;
}
@@ -1282,8 +1281,8 @@
for (int taskNdx = mChildren.size() - 1; taskNdx >= 0; taskNdx--) {
mChildren.get(taskNdx).writeToProto(proto, TASKS, trim);
}
- proto.write(FILLS_PARENT, mFillsParent);
- mBounds.writeToProto(proto, BOUNDS);
+ proto.write(FILLS_PARENT, matchParentBounds());
+ getRawBounds().writeToProto(proto, BOUNDS);
proto.write(ANIMATION_BACKGROUND_SURFACE_IS_DIMMING, mAnimationBackgroundSurfaceIsShown);
proto.end(token);
}
@@ -1291,8 +1290,7 @@
public void dump(String prefix, PrintWriter pw) {
pw.println(prefix + "mStackId=" + mStackId);
pw.println(prefix + "mDeferRemoval=" + mDeferRemoval);
- pw.println(prefix + "mFillsParent=" + mFillsParent);
- pw.println(prefix + "mBounds=" + mBounds.toShortString());
+ pw.println(prefix + "mBounds=" + getRawBounds().toShortString());
if (mMinimizeAmount != 0f) {
pw.println(prefix + "mMinimizeAmount=" + mMinimizeAmount);
}
@@ -1323,18 +1321,10 @@
}
}
- /** Fullscreen status of the stack without adjusting for other factors in the system like
- * visibility of docked stack.
- * Most callers should be using {@link #fillsParent} as it take into consideration other
- * system factors. */
- boolean getRawFullscreen() {
- return mFillsParent;
- }
-
@Override
boolean fillsParent() {
if (useCurrentBounds()) {
- return mFillsParent;
+ return matchParentBounds();
}
// The bounds has been adjusted to accommodate for a docked stack, but the docked stack
// is not currently visible. Go ahead a represent it as fullscreen to the rest of the
@@ -1360,7 +1350,7 @@
* information which side of the screen was the dock anchored.
*/
int getDockSide() {
- return getDockSide(mBounds);
+ return getDockSide(getRawBounds());
}
private int getDockSide(Rect bounds) {
@@ -1370,7 +1360,7 @@
if (mDisplayContent == null) {
return DOCKED_INVALID;
}
- mDisplayContent.getLogicalDisplayRect(mTmpRect);
+ mDisplayContent.getBounds(mTmpRect);
final int orientation = mDisplayContent.getConfiguration().orientation;
return getDockSideUnchecked(bounds, mTmpRect, orientation);
}
@@ -1490,7 +1480,7 @@
*/
if (task.isActivityTypeHome() && isMinimizedDockAndHomeStackResizable()) {
- mDisplayContent.getLogicalDisplayRect(mTmpRect);
+ mDisplayContent.getBounds(mTmpRect);
} else {
task.getDimBounds(mTmpRect);
}
diff --git a/services/core/java/com/android/server/wm/TaskWindowContainerController.java b/services/core/java/com/android/server/wm/TaskWindowContainerController.java
index b3bb0b7..5caae32 100644
--- a/services/core/java/com/android/server/wm/TaskWindowContainerController.java
+++ b/services/core/java/com/android/server/wm/TaskWindowContainerController.java
@@ -18,7 +18,6 @@
import android.app.ActivityManager.TaskDescription;
import android.app.ActivityManager.TaskSnapshot;
-import android.content.res.Configuration;
import android.graphics.Rect;
import android.os.Handler;
import android.os.Looper;
@@ -30,6 +29,7 @@
import java.lang.ref.WeakReference;
import static com.android.server.EventLogTags.WM_TASK_CREATED;
+import static com.android.server.wm.ConfigurationContainer.BOUNDS_CHANGE_NONE;
import static com.android.server.wm.DragResizeMode.DRAG_RESIZE_MODE_DOCKED_DIVIDER;
import static com.android.server.wm.WindowContainer.POSITION_BOTTOM;
import static com.android.server.wm.WindowContainer.POSITION_TOP;
@@ -75,7 +75,7 @@
+ stackController);
}
EventLog.writeEvent(WM_TASK_CREATED, taskId, stack.mStackId);
- final Task task = createTask(taskId, stack, userId, bounds, resizeMode,
+ final Task task = createTask(taskId, stack, userId, resizeMode,
supportsPictureInPicture, taskDescription);
final int position = toTop ? POSITION_TOP : POSITION_BOTTOM;
// We only want to move the parents to the parents if we are creating this task at the
@@ -85,10 +85,10 @@
}
@VisibleForTesting
- Task createTask(int taskId, TaskStack stack, int userId, Rect bounds, int resizeMode,
+ Task createTask(int taskId, TaskStack stack, int userId, int resizeMode,
boolean supportsPictureInPicture, TaskDescription taskDescription) {
- return new Task(taskId, stack, userId, mService, bounds, resizeMode,
- supportsPictureInPicture, taskDescription, this);
+ return new Task(taskId, stack, userId, mService, resizeMode, supportsPictureInPicture,
+ taskDescription, this);
}
@Override
@@ -151,14 +151,14 @@
}
}
- public void resize(Rect bounds, Configuration overrideConfig, boolean relayout,
- boolean forced) {
+ public void resize(boolean relayout, boolean forced) {
synchronized (mWindowMap) {
if (mContainer == null) {
throw new IllegalArgumentException("resizeTask: taskId " + mTaskId + " not found.");
}
- if (mContainer.resizeLocked(bounds, overrideConfig, forced) && relayout) {
+ if (mContainer.setBounds(mContainer.getOverrideBounds(), forced) != BOUNDS_CHANGE_NONE
+ && relayout) {
mContainer.getDisplayContent().layoutAndAssignWindowLayersIfNeeded();
}
}
diff --git a/services/core/java/com/android/server/wm/WindowContainer.java b/services/core/java/com/android/server/wm/WindowContainer.java
index a5e6288..610453e 100644
--- a/services/core/java/com/android/server/wm/WindowContainer.java
+++ b/services/core/java/com/android/server/wm/WindowContainer.java
@@ -318,11 +318,24 @@
* @see #mFullConfiguration
*/
@Override
- final public void onOverrideConfigurationChanged(Configuration overrideConfiguration) {
+ public void onOverrideConfigurationChanged(Configuration overrideConfiguration) {
+ // We must diff before the configuration is applied so that we can capture the change
+ // against the existing bounds.
+ final int diff = diffOverrideBounds(overrideConfiguration.windowConfiguration.getBounds());
super.onOverrideConfigurationChanged(overrideConfiguration);
if (mParent != null) {
mParent.onDescendantOverrideConfigurationChanged();
}
+
+ if (diff == BOUNDS_CHANGE_NONE) {
+ return;
+ }
+
+ if ((diff & BOUNDS_CHANGE_SIZE) == BOUNDS_CHANGE_SIZE) {
+ onResize();
+ } else {
+ onMovedByResize();
+ }
}
/**
diff --git a/services/core/java/com/android/server/wm/WindowManagerService.java b/services/core/java/com/android/server/wm/WindowManagerService.java
index d88cf4d..1cd4080 100644
--- a/services/core/java/com/android/server/wm/WindowManagerService.java
+++ b/services/core/java/com/android/server/wm/WindowManagerService.java
@@ -126,7 +126,6 @@
import android.app.IActivityManager;
import android.app.IAssistDataReceiver;
import android.content.BroadcastReceiver;
-import android.content.ClipData;
import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
@@ -5517,7 +5516,7 @@
}
void reconfigureDisplayLocked(@NonNull DisplayContent displayContent) {
- if (!mDisplayReady) {
+ if (!displayContent.isReady()) {
return;
}
displayContent.configureDisplayPolicy();
diff --git a/services/core/java/com/android/server/wm/WindowState.java b/services/core/java/com/android/server/wm/WindowState.java
index e53fccf..90e9c23 100644
--- a/services/core/java/com/android/server/wm/WindowState.java
+++ b/services/core/java/com/android/server/wm/WindowState.java
@@ -814,7 +814,7 @@
layoutXDiff = 0;
layoutYDiff = 0;
} else {
- getContainerBounds(mContainingFrame);
+ getBounds(mContainingFrame);
if (mAppToken != null && !mAppToken.mFrozenBounds.isEmpty()) {
// If the bounds are frozen, we still want to translate the window freely and only
@@ -972,7 +972,7 @@
mContentInsets.setEmpty();
mVisibleInsets.setEmpty();
} else {
- getDisplayContent().getLogicalDisplayRect(mTmpRect);
+ getDisplayContent().getBounds(mTmpRect);
// Override right and/or bottom insets in case if the frame doesn't fit the screen in
// non-fullscreen mode.
boolean overrideRightInset = !windowsAreFloating && !inFullscreenContainer
@@ -1044,6 +1044,18 @@
+ " of=" + mOutsets.toShortString());
}
+ // TODO: Look into whether this override is still necessary.
+ @Override
+ public Rect getBounds() {
+ if (isInMultiWindowMode()) {
+ return getTask().getBounds();
+ } else if (mAppToken != null){
+ return mAppToken.getBounds();
+ } else {
+ return super.getBounds();
+ }
+ }
+
@Override
public Rect getFrameLw() {
return mFrame;
@@ -2951,33 +2963,12 @@
/** Is this window in a container that takes up the entire screen space? */
private boolean inFullscreenContainer() {
- if (mAppToken == null) {
- return true;
- }
- if (mAppToken.hasBounds()) {
- return false;
- }
- return !isInMultiWindowMode();
+ return mAppToken == null || (mAppToken.matchParentBounds() && !isInMultiWindowMode());
}
/** @return true when the window is in fullscreen task, but has non-fullscreen bounds set. */
boolean isLetterboxedAppWindow() {
- final Task task = getTask();
- final boolean taskIsFullscreen = task != null && task.isFullscreen();
- final boolean appWindowIsFullscreen = mAppToken != null && !mAppToken.hasBounds();
-
- return taskIsFullscreen && !appWindowIsFullscreen;
- }
-
- /** Returns the appropriate bounds to use for computing frames. */
- private void getContainerBounds(Rect outBounds) {
- if (isInMultiWindowMode()) {
- getTask().getBounds(outBounds);
- } else if (mAppToken != null){
- mAppToken.getBounds(outBounds);
- } else {
- outBounds.setEmpty();
- }
+ return !isInMultiWindowMode() && mAppToken != null && !mAppToken.matchParentBounds();
}
boolean isDragResizeChanged() {
diff --git a/services/core/java/com/android/server/wm/WindowStateAnimator.java b/services/core/java/com/android/server/wm/WindowStateAnimator.java
index d11b0db..d2b3748 100644
--- a/services/core/java/com/android/server/wm/WindowStateAnimator.java
+++ b/services/core/java/com/android/server/wm/WindowStateAnimator.java
@@ -1971,7 +1971,7 @@
final float width = w.mFrame.width();
final float height = w.mFrame.height();
- mService.getDefaultDisplayContentLocked().getLogicalDisplayRect(displayRect);
+ mService.getDefaultDisplayContentLocked().getBounds(displayRect);
final float displayWidth = displayRect.width();
final float displayHeight = displayRect.height();