Move mFrame and mLastFrame from WindowState to WindowFrames
Test: go/wm-smoke
Bug: 111359087
Change-Id: I10df265a5007a2f61d2b884668646abf4ebe7a74
diff --git a/services/core/java/com/android/server/wm/AccessibilityController.java b/services/core/java/com/android/server/wm/AccessibilityController.java
index a6ec3cf..f0898c0 100644
--- a/services/core/java/com/android/server/wm/AccessibilityController.java
+++ b/services/core/java/com/android/server/wm/AccessibilityController.java
@@ -549,7 +549,8 @@
touchableRegion.getBounds(touchableFrame);
RectF windowFrame = mTempRectF;
windowFrame.set(touchableFrame);
- windowFrame.offset(-windowState.mFrame.left, -windowState.mFrame.top);
+ windowFrame.offset(-windowState.getFrameLw().left,
+ -windowState.getFrameLw().top);
matrix.mapRect(windowFrame);
Region windowBounds = mTempRegion2;
windowBounds.set((int) windowFrame.left, (int) windowFrame.top,
@@ -1222,7 +1223,7 @@
// Move to origin as all transforms are captured by the matrix.
RectF windowFrame = mTempRectF;
windowFrame.set(touchableFrame);
- windowFrame.offset(-windowState.mFrame.left, -windowState.mFrame.top);
+ windowFrame.offset(-windowState.getFrameLw().left, -windowState.getFrameLw().top);
// Map the frame to get what appears on the screen.
Matrix matrix = mTempMatrix;
diff --git a/services/core/java/com/android/server/wm/AppWindowToken.java b/services/core/java/com/android/server/wm/AppWindowToken.java
index 7fcf17c..d9ddf9f 100644
--- a/services/core/java/com/android/server/wm/AppWindowToken.java
+++ b/services/core/java/com/android/server/wm/AppWindowToken.java
@@ -1523,7 +1523,7 @@
if (mLetterbox == null) {
mLetterbox = new Letterbox(() -> makeChildSurface(null));
}
- mLetterbox.layout(getParent().getBounds(), w.mFrame);
+ mLetterbox.layout(getParent().getBounds(), w.getFrameLw());
} else if (mLetterbox != null) {
mLetterbox.hide();
}
@@ -1808,7 +1808,7 @@
// won't exactly match the final freeform window frame (e.g. when overlapping with
// the status bar). In that case we need to use the final frame.
if (freeform) {
- frame.set(win.mFrame);
+ frame.set(win.getFrameLw());
} else if (win.isLetterboxedAppWindow()) {
frame.set(getTask().getBounds());
} else if (win.isDockedResizing()) {
@@ -2022,7 +2022,7 @@
if (win == null) {
return;
}
- final Rect frame = win.mFrame;
+ final Rect frame = win.getFrameLw();
final int thumbnailDrawableRes = getTask().mUserId == mService.mCurrentUserId
? R.drawable.ic_account_circle
: R.drawable.ic_corp_badge;
@@ -2034,7 +2034,8 @@
}
mThumbnail = new AppWindowThumbnail(getPendingTransaction(), this, thumbnail);
final Animation animation =
- mService.mAppTransition.createCrossProfileAppsThumbnailAnimationLocked(win.mFrame);
+ mService.mAppTransition.createCrossProfileAppsThumbnailAnimationLocked(
+ win.getFrameLw());
mThumbnail.startAnimation(getPendingTransaction(), animation, new Point(frame.left,
frame.top));
}
diff --git a/services/core/java/com/android/server/wm/DisplayContent.java b/services/core/java/com/android/server/wm/DisplayContent.java
index 5043214..be74ab7 100644
--- a/services/core/java/com/android/server/wm/DisplayContent.java
+++ b/services/core/java/com/android/server/wm/DisplayContent.java
@@ -578,7 +578,7 @@
w.mAppToken.layoutLetterbox(w);
}
- if (DEBUG_LAYOUT) Slog.v(TAG, " LAYOUT: mFrame=" + w.mFrame
+ if (DEBUG_LAYOUT) Slog.v(TAG, " LAYOUT: mFrame=" + w.getFrameLw()
+ " mContainingFrame=" + w.getContainingFrame()
+ " mDisplayFrame=" + w.getDisplayFrameLw());
}
@@ -606,7 +606,7 @@
w.prelayout();
mService.mPolicy.layoutWindowLw(w, w.getParentWindow(), mDisplayFrames);
w.mLayoutSeq = mLayoutSeq;
- if (DEBUG_LAYOUT) Slog.v(TAG, " LAYOUT: mFrame=" + w.mFrame
+ if (DEBUG_LAYOUT) Slog.v(TAG, " LAYOUT: mFrame=" + w.getFrameLw()
+ " mContainingFrame=" + w.getContainingFrame()
+ " mDisplayFrame=" + w.getDisplayFrameLw());
}
diff --git a/services/core/java/com/android/server/wm/InputMonitor.java b/services/core/java/com/android/server/wm/InputMonitor.java
index a626663..8ab4651 100644
--- a/services/core/java/com/android/server/wm/InputMonitor.java
+++ b/services/core/java/com/android/server/wm/InputMonitor.java
@@ -326,7 +326,7 @@
inputWindowHandle.ownerUid = child.mSession.mUid;
inputWindowHandle.inputFeatures = child.mAttrs.inputFeatures;
- final Rect frame = child.mFrame;
+ final Rect frame = child.getFrameLw();
inputWindowHandle.frameLeft = frame.left;
inputWindowHandle.frameTop = frame.top;
inputWindowHandle.frameRight = frame.right;
diff --git a/services/core/java/com/android/server/wm/WallpaperController.java b/services/core/java/com/android/server/wm/WallpaperController.java
index c63da77..3d349ce 100644
--- a/services/core/java/com/android/server/wm/WallpaperController.java
+++ b/services/core/java/com/android/server/wm/WallpaperController.java
@@ -295,7 +295,7 @@
float defaultWallpaperX = wallpaperWin.isRtl() ? 1f : 0f;
float wpx = mLastWallpaperX >= 0 ? mLastWallpaperX : defaultWallpaperX;
float wpxs = mLastWallpaperXStep >= 0 ? mLastWallpaperXStep : -1.0f;
- int availw = wallpaperWin.mFrame.right - wallpaperWin.mFrame.left - dw;
+ int availw = wallpaperWin.getFrameLw().right - wallpaperWin.getFrameLw().left - dw;
int offset = availw > 0 ? -(int)(availw * wpx + .5f) : 0;
if (mLastWallpaperDisplayOffsetX != Integer.MIN_VALUE) {
offset += mLastWallpaperDisplayOffsetX;
@@ -310,7 +310,7 @@
float wpy = mLastWallpaperY >= 0 ? mLastWallpaperY : 0.5f;
float wpys = mLastWallpaperYStep >= 0 ? mLastWallpaperYStep : -1.0f;
- int availh = wallpaperWin.mFrame.bottom - wallpaperWin.mFrame.top - dh;
+ int availh = wallpaperWin.getFrameLw().bottom - wallpaperWin.getFrameLw().top - dh;
offset = availh > 0 ? -(int)(availh * wpy + .5f) : 0;
if (mLastWallpaperDisplayOffsetY != Integer.MIN_VALUE) {
offset += mLastWallpaperDisplayOffsetY;
diff --git a/services/core/java/com/android/server/wm/WindowFrames.java b/services/core/java/com/android/server/wm/WindowFrames.java
index b833051..25317bb 100644
--- a/services/core/java/com/android/server/wm/WindowFrames.java
+++ b/services/core/java/com/android/server/wm/WindowFrames.java
@@ -20,6 +20,7 @@
import static com.android.server.wm.WindowFramesProto.CONTENT_FRAME;
import static com.android.server.wm.WindowFramesProto.DECOR_FRAME;
import static com.android.server.wm.WindowFramesProto.DISPLAY_FRAME;
+import static com.android.server.wm.WindowFramesProto.FRAME;
import static com.android.server.wm.WindowFramesProto.OUTSET_FRAME;
import static com.android.server.wm.WindowFramesProto.OVERSCAN_FRAME;
import static com.android.server.wm.WindowFramesProto.PARENT_FRAME;
@@ -102,6 +103,16 @@
*/
final Rect mContainingFrame = new Rect();
+ /**
+ * "Real" frame that the application sees, in display coordinate space.
+ */
+ final Rect mFrame = new Rect();
+
+ /**
+ * The last real frame that was reported to the client.
+ */
+ final Rect mLastFrame = new Rect();
+
public WindowFrames() {
}
@@ -134,6 +145,7 @@
mDecorFrame.writeToProto(proto, DECOR_FRAME);
mOutsetFrame.writeToProto(proto, OUTSET_FRAME);
mContainingFrame.writeToProto(proto, CONTAINING_FRAME);
+ mFrame.writeToProto(proto, FRAME);
proto.end(token);
}
@@ -156,6 +168,9 @@
pw.print(prefix); pw.print(" outset=");
mOutsetFrame.printShortString(pw);
pw.println();
+ pw.print(prefix); pw.print("mFrame="); mFrame.printShortString(pw);
+ pw.print(" last="); mLastFrame.printShortString(pw);
+ pw.println();
}
}
diff --git a/services/core/java/com/android/server/wm/WindowManagerService.java b/services/core/java/com/android/server/wm/WindowManagerService.java
index 2bd1305..51238aa 100644
--- a/services/core/java/com/android/server/wm/WindowManagerService.java
+++ b/services/core/java/com/android/server/wm/WindowManagerService.java
@@ -2166,7 +2166,7 @@
outStableInsets.set(win.mStableInsets);
outCutout.set(win.mDisplayCutout.getDisplayCutout());
outOutsets.set(win.mOutsets);
- outBackdropFrame.set(win.getBackdropFrame(win.mFrame));
+ outBackdropFrame.set(win.getBackdropFrame(win.getFrameLw()));
if (localLOGV) Slog.v(
TAG_WM, "Relayout given client " + client.asBinder()
+ ", requestedWidth=" + requestedWidth
@@ -7271,7 +7271,7 @@
synchronized (mWindowMap) {
WindowState windowState = mWindowMap.get(token);
if (windowState != null) {
- outBounds.set(windowState.mFrame);
+ outBounds.set(windowState.getFrameLw());
} else {
outBounds.setEmpty();
}
diff --git a/services/core/java/com/android/server/wm/WindowState.java b/services/core/java/com/android/server/wm/WindowState.java
index 1d443f9..d5afaba 100644
--- a/services/core/java/com/android/server/wm/WindowState.java
+++ b/services/core/java/com/android/server/wm/WindowState.java
@@ -123,7 +123,6 @@
import static com.android.server.wm.WindowStateProto.CUTOUT;
import static com.android.server.wm.WindowStateProto.DESTROYING;
import static com.android.server.wm.WindowStateProto.DISPLAY_ID;
-import static com.android.server.wm.WindowStateProto.FRAME;
import static com.android.server.wm.WindowStateProto.GIVEN_CONTENT_INSETS;
import static com.android.server.wm.WindowStateProto.HAS_SURFACE;
import static com.android.server.wm.WindowStateProto.IDENTIFIER;
@@ -394,9 +393,6 @@
float mLastHScale=1, mLastVScale=1;
final Matrix mTmpMatrix = new Matrix();
- // "Real" frame that the application sees, in display coordinate space.
- final Rect mFrame = new Rect();
- final Rect mLastFrame = new Rect();
private boolean mFrameSizeChanged = false;
// Frame that is scaled to the application's coordinate space when in
// screen size compatibility mode.
@@ -953,8 +949,8 @@
mWindowFrames.mOutsetFrame.set(windowFrames.mOutsetFrame);
}
- final int fw = mFrame.width();
- final int fh = mFrame.height();
+ final int fw = mWindowFrames.mFrame.width();
+ final int fh = mWindowFrames.mFrame.height();
applyGravityAndUpdateFrame(layoutContainingFrame, layoutDisplayFrame);
@@ -973,51 +969,54 @@
// Make sure the content and visible frames are inside of the
// final window frame.
- if (windowsAreFloating && !mFrame.isEmpty()) {
+ if (windowsAreFloating && !mWindowFrames.mFrame.isEmpty()) {
// For pinned workspace the frame isn't limited in any particular
// way since SystemUI controls the bounds. For freeform however
// we want to keep things inside the content frame.
- final Rect limitFrame =
- task.inPinnedWindowingMode() ? mFrame : mWindowFrames.mContentFrame;
+ final Rect limitFrame = task.inPinnedWindowingMode() ? mWindowFrames.mFrame
+ : mWindowFrames.mContentFrame;
// Keep the frame out of the blocked system area, limit it in size to the content area
// and make sure that there is always a minimum visible so that the user can drag it
// into a usable area..
- final int height = Math.min(mFrame.height(), limitFrame.height());
- final int width = Math.min(limitFrame.width(), mFrame.width());
+ final int height = Math.min(mWindowFrames.mFrame.height(), limitFrame.height());
+ final int width = Math.min(limitFrame.width(), mWindowFrames.mFrame.width());
final DisplayMetrics displayMetrics = getDisplayContent().getDisplayMetrics();
final int minVisibleHeight = Math.min(height, WindowManagerService.dipToPixel(
MINIMUM_VISIBLE_HEIGHT_IN_DP, displayMetrics));
final int minVisibleWidth = Math.min(width, WindowManagerService.dipToPixel(
MINIMUM_VISIBLE_WIDTH_IN_DP, displayMetrics));
final int top = Math.max(limitFrame.top,
- Math.min( mFrame.top, limitFrame.bottom - minVisibleHeight));
+ Math.min( mWindowFrames.mFrame.top, limitFrame.bottom - minVisibleHeight));
final int left = Math.max(limitFrame.left + minVisibleWidth - width,
- Math.min( mFrame.left, limitFrame.right - minVisibleWidth));
- mFrame.set(left, top, left + width, top + height);
- mWindowFrames.mContentFrame.set( mFrame);
+ Math.min( mWindowFrames.mFrame.left, limitFrame.right - minVisibleWidth));
+ mWindowFrames.mFrame.set(left, top, left + width, top + height);
+ mWindowFrames.mContentFrame.set( mWindowFrames.mFrame);
mWindowFrames.mVisibleFrame.set(mWindowFrames.mContentFrame);
mWindowFrames.mStableFrame.set(mWindowFrames.mContentFrame);
} else if (mAttrs.type == TYPE_DOCK_DIVIDER) {
- dc.getDockedDividerController().positionDockedStackedDivider(mFrame);
- mWindowFrames.mContentFrame.set(mFrame);
- if (!mFrame.equals(mLastFrame)) {
+ dc.getDockedDividerController().positionDockedStackedDivider(mWindowFrames.mFrame);
+ mWindowFrames.mContentFrame.set(mWindowFrames.mFrame);
+ if (!mWindowFrames.mFrame.equals(mWindowFrames.mLastFrame)) {
mMovedByResize = true;
}
} else {
- mWindowFrames.mContentFrame.set(Math.max(mWindowFrames.mContentFrame.left, mFrame.left),
- Math.max(mWindowFrames.mContentFrame.top, mFrame.top),
- Math.min(mWindowFrames.mContentFrame.right, mFrame.right),
- Math.min(mWindowFrames.mContentFrame.bottom, mFrame.bottom));
+ mWindowFrames.mContentFrame.set(
+ Math.max(mWindowFrames.mContentFrame.left, mWindowFrames.mFrame.left),
+ Math.max(mWindowFrames.mContentFrame.top, mWindowFrames.mFrame.top),
+ Math.min(mWindowFrames.mContentFrame.right, mWindowFrames.mFrame.right),
+ Math.min(mWindowFrames.mContentFrame.bottom, mWindowFrames.mFrame.bottom));
- mWindowFrames.mVisibleFrame.set(Math.max(mWindowFrames.mVisibleFrame.left, mFrame.left),
- Math.max(mWindowFrames.mVisibleFrame.top, mFrame.top),
- Math.min(mWindowFrames.mVisibleFrame.right, mFrame.right),
- Math.min(mWindowFrames.mVisibleFrame.bottom, mFrame.bottom));
+ mWindowFrames.mVisibleFrame.set(
+ Math.max(mWindowFrames.mVisibleFrame.left, mWindowFrames.mFrame.left),
+ Math.max(mWindowFrames.mVisibleFrame.top, mWindowFrames.mFrame.top),
+ Math.min(mWindowFrames.mVisibleFrame.right, mWindowFrames.mFrame.right),
+ Math.min(mWindowFrames.mVisibleFrame.bottom, mWindowFrames.mFrame.bottom));
- mWindowFrames.mStableFrame.set(Math.max(mWindowFrames.mStableFrame.left, mFrame.left),
- Math.max(mWindowFrames.mStableFrame.top, mFrame.top),
- Math.min(mWindowFrames.mStableFrame.right, mFrame.right),
- Math.min(mWindowFrames.mStableFrame.bottom, mFrame.bottom));
+ mWindowFrames.mStableFrame.set(
+ Math.max(mWindowFrames.mStableFrame.left, mWindowFrames.mFrame.left),
+ Math.max(mWindowFrames.mStableFrame.top, mWindowFrames.mFrame.top),
+ Math.min(mWindowFrames.mStableFrame.right, mWindowFrames.mFrame.right),
+ Math.min(mWindowFrames.mStableFrame.bottom, mWindowFrames.mFrame.bottom));
}
if (inFullscreenContainer && !windowsAreFloating) {
@@ -1055,42 +1054,44 @@
// Override right and/or bottom insets in case if the frame doesn't fit the screen in
// non-fullscreen mode.
boolean overrideRightInset = !windowsAreFloating && !inFullscreenContainer
- && mFrame.right > mTmpRect.right;
+ && mWindowFrames.mFrame.right > mTmpRect.right;
boolean overrideBottomInset = !windowsAreFloating && !inFullscreenContainer
- && mFrame.bottom > mTmpRect.bottom;
- mContentInsets.set(mWindowFrames.mContentFrame.left - mFrame.left,
- mWindowFrames.mContentFrame.top - mFrame.top,
+ && mWindowFrames.mFrame.bottom > mTmpRect.bottom;
+ mContentInsets.set(mWindowFrames.mContentFrame.left - mWindowFrames.mFrame.left,
+ mWindowFrames.mContentFrame.top - mWindowFrames.mFrame.top,
overrideRightInset ? mTmpRect.right - mWindowFrames.mContentFrame.right
- : mFrame.right - mWindowFrames.mContentFrame.right,
+ : mWindowFrames.mFrame.right - mWindowFrames.mContentFrame.right,
overrideBottomInset ? mTmpRect.bottom - mWindowFrames.mContentFrame.bottom
- : mFrame.bottom - mWindowFrames.mContentFrame.bottom);
+ : mWindowFrames.mFrame.bottom - mWindowFrames.mContentFrame.bottom);
- mVisibleInsets.set(mWindowFrames.mVisibleFrame.left - mFrame.left,
- mWindowFrames.mVisibleFrame.top - mFrame.top,
+ mVisibleInsets.set(mWindowFrames.mVisibleFrame.left - mWindowFrames.mFrame.left,
+ mWindowFrames.mVisibleFrame.top - mWindowFrames.mFrame.top,
overrideRightInset ? mTmpRect.right - mWindowFrames.mVisibleFrame.right
- : mFrame.right - mWindowFrames.mVisibleFrame.right,
+ : mWindowFrames.mFrame.right - mWindowFrames.mVisibleFrame.right,
overrideBottomInset ? mTmpRect.bottom - mWindowFrames.mVisibleFrame.bottom
- : mFrame.bottom - mWindowFrames.mVisibleFrame.bottom);
+ : mWindowFrames.mFrame.bottom - mWindowFrames.mVisibleFrame.bottom);
- mStableInsets.set(Math.max(mWindowFrames.mStableFrame.left - mFrame.left, 0),
- Math.max(mWindowFrames.mStableFrame.top - mFrame.top, 0),
+ mStableInsets.set(
+ Math.max(mWindowFrames.mStableFrame.left - mWindowFrames.mFrame.left, 0),
+ Math.max(mWindowFrames.mStableFrame.top - mWindowFrames.mFrame.top, 0),
overrideRightInset ? Math.max(mTmpRect.right - mWindowFrames.mStableFrame.right,
- 0) : Math.max(mFrame.right - mWindowFrames.mStableFrame.right, 0),
+ 0) : Math.max(
+ mWindowFrames.mFrame.right - mWindowFrames.mStableFrame.right, 0),
overrideBottomInset ? Math.max(
- mTmpRect.bottom - mWindowFrames.mStableFrame.bottom, 0)
- : Math.max(mFrame.bottom - mWindowFrames.mStableFrame.bottom, 0));
+ mTmpRect.bottom - mWindowFrames.mStableFrame.bottom, 0) : Math.max(
+ mWindowFrames.mFrame.bottom - mWindowFrames.mStableFrame.bottom, 0));
}
- mDisplayCutout = displayCutout.calculateRelativeTo(mFrame);
+ mDisplayCutout = displayCutout.calculateRelativeTo(mWindowFrames.mFrame);
// Offset the actual frame by the amount layout frame is off.
- mFrame.offset(-layoutXDiff, -layoutYDiff);
+ mWindowFrames.mFrame.offset(-layoutXDiff, -layoutYDiff);
mCompatFrame.offset(-layoutXDiff, -layoutYDiff);
mWindowFrames.mContentFrame.offset(-layoutXDiff, -layoutYDiff);
mWindowFrames.mVisibleFrame.offset(-layoutXDiff, -layoutYDiff);
mWindowFrames.mStableFrame.offset(-layoutXDiff, -layoutYDiff);
- mCompatFrame.set(mFrame);
+ mCompatFrame.set(mWindowFrames.mFrame);
if (mEnforceSizeCompat) {
// If there is a size compatibility scale being applied to the
// window, we need to apply this to its insets so that they are
@@ -1106,7 +1107,8 @@
mCompatFrame.scale(mInvGlobalScale);
}
- if (mIsWallpaper && (fw != mFrame.width() || fh != mFrame.height())) {
+ if (mIsWallpaper && (fw != mWindowFrames.mFrame.width()
+ || fh != mWindowFrames.mFrame.height())) {
final DisplayContent displayContent = getDisplayContent();
if (displayContent != null) {
final DisplayInfo displayInfo = displayContent.getDisplayInfo();
@@ -1119,7 +1121,7 @@
"Resolving (mRequestedWidth="
+ mRequestedWidth + ", mRequestedheight="
+ mRequestedHeight + ") to" + " (pw=" + pw + ", ph=" + ph
- + "): frame=" + mFrame.toShortString()
+ + "): frame=" + mWindowFrames.mFrame.toShortString()
+ " ci=" + mContentInsets.toShortString()
+ " vi=" + mVisibleInsets.toShortString()
+ " si=" + mStableInsets.toShortString()
@@ -1140,7 +1142,7 @@
@Override
public Rect getFrameLw() {
- return mFrame;
+ return mWindowFrames.mFrame;
}
@Override
@@ -1235,8 +1237,8 @@
mVisibleInsetsChanged |= !mLastVisibleInsets.equals(mVisibleInsets);
mStableInsetsChanged |= !mLastStableInsets.equals(mStableInsets);
mOutsetsChanged |= !mLastOutsets.equals(mOutsets);
- mFrameSizeChanged |= (mLastFrame.width() != mFrame.width()) ||
- (mLastFrame.height() != mFrame.height());
+ mFrameSizeChanged |= (mWindowFrames.mLastFrame.width() != mWindowFrames.mFrame.width()) ||
+ (mWindowFrames.mLastFrame.height() != mWindowFrames.mFrame.height());
mDisplayCutoutChanged |= !mLastDisplayCutout.equals(mDisplayCutout);
return mOverscanInsetsChanged || mContentInsetsChanged || mVisibleInsetsChanged
|| mOutsetsChanged || mFrameSizeChanged || mDisplayCutoutChanged;
@@ -1272,12 +1274,12 @@
&& !isDragResizingChangeReported();
if (localLOGV) Slog.v(TAG_WM, "Resizing " + this + ": configChanged=" + configChanged
- + " dragResizingChanged=" + dragResizingChanged + " last=" + mLastFrame
- + " frame=" + mFrame);
+ + " dragResizingChanged=" + dragResizingChanged
+ + " last=" + mWindowFrames.mLastFrame + " frame=" + mWindowFrames.mFrame);
// We update mLastFrame always rather than in the conditional with the last inset
// variables, because mFrameSizeChanged only tracks the width and height changing.
- mLastFrame.set(mFrame);
+ mWindowFrames.mLastFrame.set(mWindowFrames.mFrame);
if (mContentInsetsChanged
|| mVisibleInsetsChanged
@@ -1438,7 +1440,7 @@
}
if (bounds.isEmpty()) {
- bounds.set(mFrame);
+ bounds.set(mWindowFrames.mFrame);
if (intersectWithStackBounds) {
bounds.intersect(mTmpRect);
}
@@ -1795,8 +1797,8 @@
// Frame has moved, containing content frame has also moved, and we're not currently
// animating... let's do something.
- final int left = mFrame.left;
- final int top = mFrame.top;
+ final int left = mWindowFrames.mFrame.left;
+ final int top = mWindowFrames.mFrame.top;
final Task task = getTask();
final boolean adjustedForMinimizedDockOrIme = task != null
&& (task.mStack.isAdjustedForMinimizedDockedStack()
@@ -1830,7 +1832,8 @@
private boolean hasMoved() {
return mHasSurface && (mContentChanged || mMovedByResize)
&& !mAnimatingExit
- && (mFrame.top != mLastFrame.top || mFrame.left != mLastFrame.left)
+ && (mWindowFrames.mFrame.top != mWindowFrames.mLastFrame.top
+ || mWindowFrames.mFrame.left != mWindowFrames.mLastFrame.left)
&& (!mIsChildWindow || !getParentWindow().hasMoved());
}
@@ -1844,8 +1847,9 @@
boolean fillsDisplay() {
final DisplayInfo displayInfo = getDisplayInfo();
- return mFrame.left <= 0 && mFrame.top <= 0
- && mFrame.right >= displayInfo.appWidth && mFrame.bottom >= displayInfo.appHeight;
+ return mWindowFrames.mFrame.left <= 0 && mWindowFrames.mFrame.top <= 0
+ && mWindowFrames.mFrame.right >= displayInfo.appWidth
+ && mWindowFrames.mFrame.bottom >= displayInfo.appHeight;
}
/** Returns true if last applied config was not yet requested by client. */
@@ -2879,10 +2883,10 @@
// All window frames that are fullscreen extend above status bar, but some don't extend
// below navigation bar. Thus, check for display frame for top/left and stable frame for
// bottom right.
- if (win.mFrame.left <= win.getDisplayFrameLw().left
- && win.mFrame.top <= win.getDisplayFrameLw().top
- && win.mFrame.right >= win.getStableFrameLw().right
- && win.mFrame.bottom >= win.getStableFrameLw().bottom) {
+ if (win.getFrameLw().left <= win.getDisplayFrameLw().left
+ && win.getFrameLw().top <= win.getDisplayFrameLw().top
+ && win.getFrameLw().right >= win.getStableFrameLw().right
+ && win.getFrameLw().bottom >= win.getStableFrameLw().bottom) {
// Is a fullscreen window, like the clock alarm. Show to everyone.
return false;
}
@@ -2899,7 +2903,7 @@
}
void getTouchableRegion(Region outRegion) {
- final Rect frame = mFrame;
+ final Rect frame = mWindowFrames.mFrame;
switch (mTouchableInsets) {
default:
case TOUCHABLE_INSETS_FRAME:
@@ -2984,7 +2988,7 @@
if (DEBUG_ORIENTATION && mWinAnimator.mDrawState == DRAW_PENDING)
Slog.i(TAG, "Resizing " + this + " WITH DRAW PENDING");
- final Rect frame = mFrame;
+ final Rect frame = mWindowFrames.mFrame;
final Rect overscanInsets = mLastOverscanInsets;
final Rect contentInsets = mLastContentInsets;
final Rect visibleInsets = mLastVisibleInsets;
@@ -3149,7 +3153,7 @@
*/
private boolean frameCoversEntireAppTokenBounds() {
mTmpRect.set(mAppToken.getBounds());
- mTmpRect.intersectUnchecked(mFrame);
+ mTmpRect.intersectUnchecked(mWindowFrames.mFrame);
return mAppToken.getBounds().equals(mTmpRect);
}
@@ -3251,7 +3255,6 @@
proto.write(STACK_ID, getStackId());
mAttrs.writeToProto(proto, ATTRIBUTES);
mGivenContentInsets.writeToProto(proto, GIVEN_CONTENT_INSETS);
- mFrame.writeToProto(proto, FRAME);
mWindowFrames.writeToProto(proto, WINDOW_FRAMES);
mContentInsets.writeToProto(proto, CONTENT_INSETS);
mAttrs.surfaceInsets.writeToProto(proto, SURFACE_INSETS);
@@ -3388,11 +3391,6 @@
pw.print(prefix); pw.print("mHasSurface="); pw.print(mHasSurface);
pw.print(" isReadyForDisplay()="); pw.print(isReadyForDisplay());
pw.print(" mWindowRemovalAllowed="); pw.println(mWindowRemovalAllowed);
- if (dumpAll) {
- pw.print(prefix); pw.print("mFrame="); mFrame.printShortString(pw);
- pw.print(" last="); mLastFrame.printShortString(pw);
- pw.println();
- }
if (mEnforceSizeCompat) {
pw.print(prefix); pw.print("mCompatFrame="); mCompatFrame.printShortString(pw);
pw.println();
@@ -3579,16 +3577,16 @@
// Set mFrame
Gravity.apply(mAttrs.gravity, w, h, containingFrame,
(int) (x + mAttrs.horizontalMargin * pw),
- (int) (y + mAttrs.verticalMargin * ph), mFrame);
+ (int) (y + mAttrs.verticalMargin * ph), mWindowFrames.mFrame);
// Now make sure the window fits in the overall display frame.
if (fitToDisplay) {
- Gravity.applyDisplay(mAttrs.gravity, displayFrame, mFrame);
+ Gravity.applyDisplay(mAttrs.gravity, displayFrame, mWindowFrames.mFrame);
}
// We need to make sure we update the CompatFrame as it is used for
// cropping decisions, etc, on systems where we lack a decor layer.
- mCompatFrame.set(mFrame);
+ mCompatFrame.set(mWindowFrames.mFrame);
if (mEnforceSizeCompat) {
// See comparable block in computeFrameLw.
mCompatFrame.scale(mInvGlobalScale);
@@ -3701,7 +3699,7 @@
}
float translateToWindowX(float x) {
- float winX = x - mFrame.left;
+ float winX = x - mWindowFrames.mFrame.left;
if (mEnforceSizeCompat) {
winX *= mGlobalScale;
}
@@ -3709,7 +3707,7 @@
}
float translateToWindowY(float y) {
- float winY = y - mFrame.top;
+ float winY = y - mWindowFrames.mFrame.top;
if (mEnforceSizeCompat) {
winY *= mGlobalScale;
}
@@ -4319,11 +4317,11 @@
*/
private void calculateSystemDecorRect(Rect systemDecorRect) {
final Rect decorRect = mWindowFrames.mDecorFrame;
- final int width = mFrame.width();
- final int height = mFrame.height();
+ final int width = mWindowFrames.mFrame.width();
+ final int height = mWindowFrames.mFrame.height();
- final int left = mFrame.left;
- final int top = mFrame.top;
+ final int left = mWindowFrames.mFrame.left;
+ final int top = mWindowFrames.mFrame.top;
// Initialize the decor rect to the entire frame.
if (isDockedResizing()) {
@@ -4474,7 +4472,7 @@
void startAnimation(Animation anim) {
final DisplayInfo displayInfo = getDisplayContent().getDisplayInfo();
- anim.initialize(mFrame.width(), mFrame.height(),
+ anim.initialize(mWindowFrames.mFrame.width(), mWindowFrames.mFrame.height(),
displayInfo.appWidth, displayInfo.appHeight);
anim.restrictDuration(MAX_ANIMATION_DURATION);
anim.scaleCurrentDuration(mService.getWindowAnimationScaleLocked());
@@ -4489,7 +4487,8 @@
if (DEBUG_ANIM) Slog.v(TAG, "Setting move animation on " + this);
final Point oldPosition = new Point();
final Point newPosition = new Point();
- transformFrameToSurfacePosition(mLastFrame.left, mLastFrame.top, oldPosition);
+ transformFrameToSurfacePosition(mWindowFrames.mLastFrame.left, mWindowFrames.mLastFrame.top,
+ oldPosition);
transformFrameToSurfacePosition(left, top, newPosition);
final AnimationAdapter adapter = new LocalAnimationAdapter(
new MoveAnimationSpec(oldPosition.x, oldPosition.y, newPosition.x, newPosition.y),
@@ -4524,8 +4523,8 @@
final WindowContainer parent = getParent();
if (isChildWindow()) {
final WindowState parentWindow = getParentWindow();
- x += parentWindow.mFrame.left - parentWindow.mAttrs.surfaceInsets.left;
- y += parentWindow.mFrame.top - parentWindow.mAttrs.surfaceInsets.top;
+ x += parentWindow.mWindowFrames.mFrame.left - parentWindow.mAttrs.surfaceInsets.left;
+ y += parentWindow.mWindowFrames.mFrame.top - parentWindow.mAttrs.surfaceInsets.top;
} else if (parent != null) {
final Rect parentBounds = parent.getBounds();
x += parentBounds.left;
@@ -4678,7 +4677,8 @@
return;
}
- transformFrameToSurfacePosition(mFrame.left, mFrame.top, mSurfacePosition);
+ transformFrameToSurfacePosition(mWindowFrames.mFrame.left, mWindowFrames.mFrame.top,
+ mSurfacePosition);
if (!mSurfaceAnimator.hasLeash() && !mLastSurfacePosition.equals(mSurfacePosition)) {
t.setPosition(mSurfaceControl, mSurfacePosition.x, mSurfacePosition.y);
@@ -4704,8 +4704,8 @@
// Since the parent was outset by its surface insets, we need to undo the outsetting
// with insetting by the same amount.
final WindowState parent = getParentWindow();
- outPoint.offset(-parent.mFrame.left + parent.mAttrs.surfaceInsets.left,
- -parent.mFrame.top + parent.mAttrs.surfaceInsets.top);
+ outPoint.offset(-parent.mWindowFrames.mFrame.left + parent.mAttrs.surfaceInsets.left,
+ -parent.mWindowFrames.mFrame.top + parent.mAttrs.surfaceInsets.top);
} else if (parentWindowContainer != null) {
final Rect parentBounds = parentWindowContainer.getBounds();
outPoint.offset(-parentBounds.left, -parentBounds.top);
@@ -4846,7 +4846,7 @@
// we recompute the coordinates of mFrame in the new orientation, so the surface can be
// properly placed.
transformToRotation(oldRotation, newRotation, getDisplayInfo(), transform);
- transformRect(transform, mFrame, null /* tmpRectF */);
+ transformRect(transform, mWindowFrames.mFrame, null /* tmpRectF */);
updateSurfacePosition(t);
mWinAnimator.seamlesslyRotate(t, oldRotation, newRotation);
diff --git a/services/core/java/com/android/server/wm/WindowStateAnimator.java b/services/core/java/com/android/server/wm/WindowStateAnimator.java
index 39a310d..5ba1da8 100644
--- a/services/core/java/com/android/server/wm/WindowStateAnimator.java
+++ b/services/core/java/com/android/server/wm/WindowStateAnimator.java
@@ -540,13 +540,13 @@
}
if (WindowManagerService.localLOGV) Slog.v(TAG, "Got surface: " + mSurfaceController
- + ", set left=" + w.mFrame.left + " top=" + w.mFrame.top
+ + ", set left=" + w.getFrameLw().left + " top=" + w.getFrameLw().top
+ ", animLayer=" + mAnimLayer);
if (SHOW_LIGHT_TRANSACTIONS) {
Slog.i(TAG, ">>> OPEN TRANSACTION createSurfaceLocked");
WindowManagerService.logSurface(w, "CREATE pos=("
- + w.mFrame.left + "," + w.mFrame.top + ") ("
+ + w.getFrameLw().left + "," + w.getFrameLw().top + ") ("
+ width + "x" + height + "), layer=" + mAnimLayer + " HIDE", false);
}
@@ -691,7 +691,7 @@
if (screenAnimation) {
// cache often used attributes locally
- final Rect frame = mWin.mFrame;
+ final Rect frame = mWin.getFrameLw();
final float tmpFloats[] = mService.mTmpFloats;
final Matrix tmpMatrix = mWin.mTmpMatrix;
@@ -1504,8 +1504,8 @@
// We rotated the screen, but have not received a new buffer with the correct size yet. In
// the mean time, we rotate the buffer we have to the new orientation.
final Matrix transform = mService.mTmpTransform;
- transformToRotation(oldRotation, newRotation, w.mFrame.width(), w.mFrame.height(),
- transform);
+ transformToRotation(oldRotation, newRotation, w.getFrameLw().width(),
+ w.getFrameLw().height(), transform);
transform.getValues(mService.mTmpFloats);
float DsDx = mService.mTmpFloats[Matrix.MSCALE_X];
diff --git a/services/tests/servicestests/src/com/android/server/wm/WindowFrameTests.java b/services/tests/servicestests/src/com/android/server/wm/WindowFrameTests.java
index 14e2a53..6b410b6 100644
--- a/services/tests/servicestests/src/com/android/server/wm/WindowFrameTests.java
+++ b/services/tests/servicestests/src/com/android/server/wm/WindowFrameTests.java
@@ -163,7 +163,7 @@
// and stable frames work the same way.
final WindowFrames windowFrames = new WindowFrames(pf, df, of, cf, vf, dcf, sf, mEmptyRect);
w.computeFrameLw(windowFrames, WmDisplayCutout.NO_CUTOUT, false);
- assertRect(w.mFrame,0, 0, 1000, 1000);
+ assertRect(w.getFrameLw(),0, 0, 1000, 1000);
assertRect(w.mContentInsets, 0, topContentInset, 0, bottomContentInset);
assertRect(w.mVisibleInsets, 0, topVisibleInset, 0, bottomVisibleInset);
assertRect(w.mStableInsets, leftStableInset, 0, rightStableInset, 0);
@@ -171,19 +171,19 @@
assertTrue(cf.equals(w.getContentFrameLw()));
assertTrue(vf.equals(w.getVisibleFrameLw()));
assertTrue(sf.equals(w.getStableFrameLw()));
- // On the other hand mFrame doesn't extend past cf we won't get any insets
+ // On the other hand getFrame() doesn't extend past cf we won't get any insets
w.mAttrs.x = 100;
w.mAttrs.y = 100;
w.mAttrs.width = 100; w.mAttrs.height = 100; //have to clear MATCH_PARENT
w.mRequestedWidth = 100;
w.mRequestedHeight = 100;
w.computeFrameLw(windowFrames, WmDisplayCutout.NO_CUTOUT, false);
- assertRect(w.mFrame, 100, 100, 200, 200);
+ assertRect(w.getFrameLw(), 100, 100, 200, 200);
assertRect(w.mContentInsets, 0, 0, 0, 0);
// In this case the frames are shrunk to the window frame.
- assertTrue(w.mFrame.equals(w.getContentFrameLw()));
- assertTrue(w.mFrame.equals(w.getVisibleFrameLw()));
- assertTrue(w.mFrame.equals(w.getStableFrameLw()));
+ assertTrue(w.getFrameLw().equals(w.getContentFrameLw()));
+ assertTrue(w.getFrameLw().equals(w.getVisibleFrameLw()));
+ assertTrue(w.getFrameLw().equals(w.getStableFrameLw()));
}
@Test
@@ -200,7 +200,7 @@
// so we expect it to fill the entire available frame.
final WindowFrames windowFrames = new WindowFrames(pf, pf, pf, pf, pf, pf, pf, pf);
w.computeFrameLw(windowFrames, WmDisplayCutout.NO_CUTOUT, false);
- assertRect(w.mFrame, 0, 0, 1000, 1000);
+ assertRect(w.getFrameLw(), 0, 0, 1000, 1000);
// It can select various widths and heights within the bounds.
// Strangely the window attribute width is ignored for normal windows
@@ -210,14 +210,14 @@
w.computeFrameLw(windowFrames, WmDisplayCutout.NO_CUTOUT, false);
// Explicit width and height without requested width/height
// gets us nothing.
- assertRect(w.mFrame, 0, 0, 0, 0);
+ assertRect(w.getFrameLw(), 0, 0, 0, 0);
w.mRequestedWidth = 300;
w.mRequestedHeight = 300;
w.computeFrameLw(windowFrames, WmDisplayCutout.NO_CUTOUT, false);
// With requestedWidth/Height we can freely choose our size within the
// parent bounds.
- assertRect(w.mFrame, 0, 0, 300, 300);
+ assertRect(w.getFrameLw(), 0, 0, 300, 300);
// With FLAG_SCALED though, requestedWidth/height is used to control
// the unscaled surface size, and mAttrs.width/height becomes the
@@ -228,14 +228,14 @@
w.mAttrs.width = 100;
w.mAttrs.height = 100;
w.computeFrameLw(windowFrames, WmDisplayCutout.NO_CUTOUT, false);
- assertRect(w.mFrame, 0, 0, 100, 100);
+ assertRect(w.getFrameLw(), 0, 0, 100, 100);
w.mAttrs.flags = 0;
// But sizes too large will be clipped to the containing frame
w.mRequestedWidth = 1200;
w.mRequestedHeight = 1200;
w.computeFrameLw(windowFrames, WmDisplayCutout.NO_CUTOUT, false);
- assertRect(w.mFrame, 0, 0, 1000, 1000);
+ assertRect(w.getFrameLw(), 0, 0, 1000, 1000);
// Before they are clipped though windows will be shifted
w.mAttrs.x = 300;
@@ -243,7 +243,7 @@
w.mRequestedWidth = 1000;
w.mRequestedHeight = 1000;
w.computeFrameLw(windowFrames, WmDisplayCutout.NO_CUTOUT, false);
- assertRect(w.mFrame, 0, 0, 1000, 1000);
+ assertRect(w.getFrameLw(), 0, 0, 1000, 1000);
// If there is room to move around in the parent frame the window will be shifted according
// to gravity.
@@ -253,16 +253,16 @@
w.mRequestedHeight = 300;
w.mAttrs.gravity = Gravity.RIGHT | Gravity.TOP;
w.computeFrameLw(windowFrames, WmDisplayCutout.NO_CUTOUT, false);
- assertRect(w.mFrame, 700, 0, 1000, 300);
+ assertRect(w.getFrameLw(), 700, 0, 1000, 300);
w.mAttrs.gravity = Gravity.RIGHT | Gravity.BOTTOM;
w.computeFrameLw(windowFrames, WmDisplayCutout.NO_CUTOUT, false);
- assertRect(w.mFrame, 700, 700, 1000, 1000);
+ assertRect(w.getFrameLw(), 700, 700, 1000, 1000);
// Window specified x and y are interpreted as offsets in the opposite
// direction of gravity
w.mAttrs.x = 100;
w.mAttrs.y = 100;
w.computeFrameLw(windowFrames, WmDisplayCutout.NO_CUTOUT, false);
- assertRect(w.mFrame, 600, 600, 900, 900);
+ assertRect(w.getFrameLw(), 600, 600, 900, 900);
}
@Test
@@ -286,7 +286,7 @@
w.computeFrameLw(windowFrames, WmDisplayCutout.NO_CUTOUT, false);
// For non fullscreen tasks the containing frame is based off the
// task bounds not the parent frame.
- assertRect(w.mFrame, taskLeft, taskTop, taskRight, taskBottom);
+ assertRect(w.getFrameLw(), taskLeft, taskTop, taskRight, taskBottom);
assertRect(w.getContentFrameLw(), taskLeft, taskTop, taskRight, taskBottom);
assertRect(w.mContentInsets, 0, 0, 0, 0);
@@ -298,7 +298,7 @@
windowFrames.setFrames(pf, pf, pf, cf, cf, pf, cf, mEmptyRect);
w.computeFrameLw(windowFrames, WmDisplayCutout.NO_CUTOUT, false);
- assertRect(w.mFrame, taskLeft, taskTop, taskRight, taskBottom);
+ assertRect(w.getFrameLw(), taskLeft, taskTop, taskRight, taskBottom);
int contentInsetRight = taskRight - cfRight;
int contentInsetBottom = taskBottom - cfBottom;
assertRect(w.mContentInsets, 0, 0, contentInsetRight, contentInsetBottom);
@@ -317,7 +317,7 @@
windowFrames.setFrames(pf, pf, pf, cf, cf, pf, cf, mEmptyRect);
w.computeFrameLw(windowFrames, WmDisplayCutout.NO_CUTOUT, false);
- assertRect(w.mFrame, taskLeft, taskTop, taskRight, taskBottom);
+ assertRect(w.getFrameLw(), taskLeft, taskTop, taskRight, taskBottom);
contentInsetRight = insetRight - cfRight;
contentInsetBottom = insetBottom - cfBottom;
assertRect(w.mContentInsets, 0, 0, contentInsetRight, contentInsetBottom);
@@ -409,7 +409,7 @@
w.computeFrameLw(windowFrames, WmDisplayCutout.NO_CUTOUT, false);
// For non fullscreen tasks the containing frame is based off the
// task bounds not the parent frame.
- assertRect(w.mFrame, taskLeft, taskTop, taskRight, taskBottom);
+ assertRect(w.getFrameLw(), taskLeft, taskTop, taskRight, taskBottom);
assertRect(w.getContentFrameLw(), taskLeft, taskTop, taskRight, taskBottom);
assertRect(w.mContentInsets, 0, 0, 0, 0);
@@ -425,7 +425,7 @@
windowFrames.setFrames(pf, pf, pf, cf, cf, pf, cf, mEmptyRect);
w.computeFrameLw(windowFrames, WmDisplayCutout.NO_CUTOUT, false);
- assertEquals(cf, w.mFrame);
+ assertEquals(cf, w.getFrameLw());
assertEquals(cf, w.getContentFrameLw());
assertRect(w.mContentInsets, 0, 0, 0, 0);
}
diff --git a/services/tests/servicestests/src/com/android/server/wm/WindowStateTests.java b/services/tests/servicestests/src/com/android/server/wm/WindowStateTests.java
index 9f113ad..0ddba6a 100644
--- a/services/tests/servicestests/src/com/android/server/wm/WindowStateTests.java
+++ b/services/tests/servicestests/src/com/android/server/wm/WindowStateTests.java
@@ -364,15 +364,15 @@
app.mSurfaceControl = mock(SurfaceControl.class);
app.mWinAnimator.mSurfaceController = mock(WindowSurfaceController.class);
try {
- app.mFrame.set(10, 20, 60, 80);
+ app.getFrameLw().set(10, 20, 60, 80);
app.seamlesslyRotate(t, ROTATION_0, ROTATION_90);
assertTrue(app.mSeamlesslyRotated);
assertEquals(new Rect(20, mDisplayInfo.logicalWidth - 60,
- 80, mDisplayInfo.logicalWidth - 10), app.mFrame);
+ 80, mDisplayInfo.logicalWidth - 10), app.getFrameLw());
- verify(t).setPosition(app.mSurfaceControl, app.mFrame.left, app.mFrame.top);
+ verify(t).setPosition(app.mSurfaceControl, app.getFrameLw().left, app.getFrameLw().top);
verify(app.mWinAnimator.mSurfaceController).setPosition(t, 0, 50, false);
verify(app.mWinAnimator.mSurfaceController).setMatrix(t, 0, -1, 1, 0, false);
} finally {