diff options
12 files changed, 157 insertions, 139 deletions
diff --git a/core/proto/android/server/windowmanagerservice.proto b/core/proto/android/server/windowmanagerservice.proto index 9863941847b1..710fe3d6e3e9 100644 --- a/core/proto/android/server/windowmanagerservice.proto +++ b/core/proto/android/server/windowmanagerservice.proto @@ -288,8 +288,8 @@ message WindowStateProto { optional int32 stack_id = 4; optional .android.view.WindowLayoutParamsProto attributes = 5; optional .android.graphics.RectProto given_content_insets = 6; - optional .android.graphics.RectProto frame = 7; - reserved 8 to 10; + reserved 7 to 10; +// optional .android.graphics.RectProto frame = 7; // optional .android.graphics.RectProto containing_frame = 8; // optional .android.graphics.RectProto parent_frame = 9; // optional .android.graphics.RectProto content_frame = 10; @@ -394,8 +394,9 @@ message WindowFramesProto { optional .android.graphics.RectProto content_frame = 2; optional .android.graphics.RectProto decor_frame = 3; optional .android.graphics.RectProto display_frame = 4; - optional .android.graphics.RectProto outset_frame = 5; - optional .android.graphics.RectProto overscan_frame = 6; - optional .android.graphics.RectProto parent_frame = 7; - optional .android.graphics.RectProto visible_frame = 8; + optional .android.graphics.RectProto frame = 5; + optional .android.graphics.RectProto outset_frame = 6; + optional .android.graphics.RectProto overscan_frame = 7; + optional .android.graphics.RectProto parent_frame = 8; + optional .android.graphics.RectProto visible_frame = 9; } diff --git a/services/core/java/com/android/server/wm/AccessibilityController.java b/services/core/java/com/android/server/wm/AccessibilityController.java index a6ec3cff1b2c..f0898c0228b2 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 @@ final class AccessibilityController { 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 @@ final class AccessibilityController { // 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 7fcf17cf3e1b..d9ddf9f9b3a4 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 @@ class AppWindowToken extends WindowToken implements WindowManagerService.AppFree 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 @@ class AppWindowToken extends WindowToken implements WindowManagerService.AppFree // 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 @@ class AppWindowToken extends WindowToken implements WindowManagerService.AppFree 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 @@ class AppWindowToken extends WindowToken implements WindowManagerService.AppFree } 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 04632f11aa85..8a1c4a4e88e9 100644 --- a/services/core/java/com/android/server/wm/DisplayContent.java +++ b/services/core/java/com/android/server/wm/DisplayContent.java @@ -579,7 +579,7 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo 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()); } @@ -607,7 +607,7 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo 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 a626663c2e67..8ab46518ed4d 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 @@ final class InputMonitor implements InputManagerService.WindowManagerCallbacks { 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 c63da77d4a47..3d349ce34d6b 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 @@ class WallpaperController { 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 @@ class WallpaperController { 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 b833051082ae..25317bb69768 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.CONTAINING_FRAME; 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 @@ public class WindowFrames { */ 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 @@ public class WindowFrames { 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 @@ public class WindowFrames { 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 74e6e9427169..16ab45655d7f 100644 --- a/services/core/java/com/android/server/wm/WindowManagerService.java +++ b/services/core/java/com/android/server/wm/WindowManagerService.java @@ -2168,7 +2168,7 @@ public class WindowManagerService extends IWindowManager.Stub 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 @@ -7252,7 +7252,7 @@ public class WindowManagerService extends IWindowManager.Stub 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 bb0c591a64a2..2d44b1368fa9 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.CONTENT_INSETS; 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 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP 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 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP 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 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP // 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 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP // 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 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP 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 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP "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 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP @Override public Rect getFrameLw() { - return mFrame; + return mWindowFrames.mFrame; } @Override @@ -1235,8 +1237,8 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP 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 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP && !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 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP } if (bounds.isEmpty()) { - bounds.set(mFrame); + bounds.set(mWindowFrames.mFrame); if (intersectWithStackBounds) { bounds.intersect(mTmpRect); } @@ -1795,8 +1797,8 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP // 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 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP 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 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP 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 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP // 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 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP } void getTouchableRegion(Region outRegion) { - final Rect frame = mFrame; + final Rect frame = mWindowFrames.mFrame; switch (mTouchableInsets) { default: case TOUCHABLE_INSETS_FRAME: @@ -2984,7 +2988,7 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP 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 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP */ private boolean frameCoversEntireAppTokenBounds() { mTmpRect.set(mAppToken.getBounds()); - mTmpRect.intersectUnchecked(mFrame); + mTmpRect.intersectUnchecked(mWindowFrames.mFrame); return mAppToken.getBounds().equals(mTmpRect); } @@ -3251,7 +3255,6 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP 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 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP 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 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP // 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 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP } float translateToWindowX(float x) { - float winX = x - mFrame.left; + float winX = x - mWindowFrames.mFrame.left; if (mEnforceSizeCompat) { winX *= mGlobalScale; } @@ -3709,7 +3707,7 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP } float translateToWindowY(float y) { - float winY = y - mFrame.top; + float winY = y - mWindowFrames.mFrame.top; if (mEnforceSizeCompat) { winY *= mGlobalScale; } @@ -4319,11 +4317,11 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP */ 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 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP 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 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP 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 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP 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 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP 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 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP // 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 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP // 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 39a310d5ad40..5ba1da80abfe 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 @@ class WindowStateAnimator { } 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 @@ class WindowStateAnimator { 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 @@ class WindowStateAnimator { // 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 14e2a53d481c..6b410b68c45d 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 @@ public class WindowFrameTests extends WindowTestsBase { // 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 @@ public class WindowFrameTests extends WindowTestsBase { 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 @@ public class WindowFrameTests extends WindowTestsBase { // 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 @@ public class WindowFrameTests extends WindowTestsBase { 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 @@ public class WindowFrameTests extends WindowTestsBase { 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 @@ public class WindowFrameTests extends WindowTestsBase { 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 @@ public class WindowFrameTests extends WindowTestsBase { 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 @@ public class WindowFrameTests extends WindowTestsBase { 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 @@ public class WindowFrameTests extends WindowTestsBase { 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 @@ public class WindowFrameTests extends WindowTestsBase { 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 @@ public class WindowFrameTests extends WindowTestsBase { 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 @@ public class WindowFrameTests extends WindowTestsBase { 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 9f113ad3137e..0ddba6ac401c 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 @@ public class WindowStateTests extends WindowTestsBase { 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 { |