From f0b76b071c8434fbf4a76798e9cdd56ab67e523d Mon Sep 17 00:00:00 2001 From: Chong Zhang Date: Fri, 13 May 2016 18:04:23 -0700 Subject: [PATCH] Fix wallpaper cropped too soon when unminimizing dock Set adjusted bounds on the stack that's side-by-side to the docked stack, so that TaskStack.getDimBounds returns the adjusted bounds during unminimizing dock animation. This way wallpaper is not cropped too soon to the final stack bounds. The adjusted bounds won't be used for alignment for minimizing. bug: 28763785 Change-Id: Ifea4366dd4b1bd35f2ed720dd1819a10bdfd86fa --- .../wm/DockedStackDividerController.java | 50 +++++++++++++++---- .../java/com/android/server/wm/TaskStack.java | 37 +++++++++++++- 2 files changed, 74 insertions(+), 13 deletions(-) diff --git a/services/core/java/com/android/server/wm/DockedStackDividerController.java b/services/core/java/com/android/server/wm/DockedStackDividerController.java index d2d93635d9c9e..7a387adfba267 100644 --- a/services/core/java/com/android/server/wm/DockedStackDividerController.java +++ b/services/core/java/com/android/server/wm/DockedStackDividerController.java @@ -606,12 +606,7 @@ public class DockedStackDividerController implements DimLayerUser { private void setMinimizedDockedStack(boolean minimized) { final TaskStack stack = mDisplayContent.getDockedStackVisibleForUserLocked(); notifyDockedStackMinimizedChanged(minimized, 0); - if (stack == null) { - return; - } - if (stack.setAdjustedForMinimizedDock(minimized ? 1f : 0f)) { - mService.mWindowPlacerLocked.performSurfacePlacement(); - } + setMinimizeAmount(stack, minimized ? 1f : 0f); } private boolean isAnimationMaximizing() { @@ -695,11 +690,8 @@ public class DockedStackDividerController implements DimLayerUser { float t = Math.min(1f, (float) (now - mAnimationStartTime) / mAnimationDuration); t = (isAnimationMaximizing() ? TOUCH_RESPONSE_INTERPOLATOR : mMinimizedDockInterpolator) .getInterpolation(t); - if (stack != null) { - if (stack.setAdjustedForMinimizedDock(getMinimizeAmount(stack, t))) { - mService.mWindowPlacerLocked.performSurfacePlacement(); - } - } + setMinimizeAmount(stack, getMinimizeAmount(stack, t)); + if (t >= 1.0f) { mAnimatingForMinimizedDockedStack = false; return false; @@ -708,6 +700,42 @@ public class DockedStackDividerController implements DimLayerUser { } } + void setMinimizeAmount(TaskStack dockedStack, float minimizeAmount) { + final ArrayList stacks = mDisplayContent.getStacks(); + + // If the docked stack is not visible, clear the complementary stack on all stacks. + if (dockedStack == null) { + for (int i = stacks.size() - 1; i >= 0; --i) { + final TaskStack stack = stacks.get(i); + stack.resetAdjustedForComplementDock(); + } + return; + } + + // Otherwise if the docked stack minimize amount has changed, update the adjusted bounds + // on the other stack that's currently visible, so that the stack's getDimBounds() + // occupies what's left by the docked stack. This is needed so that stuff like wallpaper + // gets cropped properly to the area left by the dock. + if (dockedStack.setAdjustedForMinimizedDock(minimizeAmount)) { + final boolean adjusted = + dockedStack.isVisibleForUserLocked() && minimizeAmount != 0.0f; + dockedStack.getDimBounds(mTmpRect2); + int dockSide = dockedStack.getDockSide(); + for (int i = stacks.size() - 1; i >= 0; --i) { + final TaskStack stack = stacks.get(i); + if (stack == dockedStack) { + continue; + } + if (stack.isVisibleLocked() && adjusted) { + stack.setAdjustedForComplementDock(mTmpRect2, dockSide); + } else { + stack.resetAdjustedForComplementDock(); + } + } + mService.mWindowPlacerLocked.performSurfacePlacement(); + } + } + private float getInterpolatedAnimationValue(float t) { return t * mAnimationTarget + (1 - t) * mAnimationStart; } diff --git a/services/core/java/com/android/server/wm/TaskStack.java b/services/core/java/com/android/server/wm/TaskStack.java index 1852b4c9a23db..777f6613457a2 100644 --- a/services/core/java/com/android/server/wm/TaskStack.java +++ b/services/core/java/com/android/server/wm/TaskStack.java @@ -122,6 +122,7 @@ public class TaskStack implements DimLayer.DimLayerUser, private float mAdjustImeAmount; private float mAdjustDividerAmount; private final int mDockedStackMinimizeThickness; + private boolean mAdjustedForForComplementDock; // If this is true, we are in the bounds animating mode. // The task will be down or upscaled to perfectly fit the @@ -247,7 +248,9 @@ public class TaskStack implements DimLayer.DimLayerUser, insetBounds = mFullyAdjustedImeBounds; } } - alignTasksToAdjustedBounds(adjusted ? mAdjustedBounds : mBounds, insetBounds); + if (!mAdjustedForForComplementDock) { + alignTasksToAdjustedBounds(adjusted ? mAdjustedBounds : mBounds, insetBounds); + } mDisplayContent.layoutNeeded = true; } @@ -854,6 +857,7 @@ public class TaskStack implements DimLayer.DimLayerUser, mImeWin = imeWin; mImeGoingAway = false; if (!mAdjustedForIme || forceUpdate) { + mAdjustedForForComplementDock = false; mAdjustedForIme = true; mAdjustImeAmount = 0f; mAdjustDividerAmount = 0f; @@ -916,10 +920,12 @@ public class TaskStack implements DimLayer.DimLayerUser, * @return Whether the amount has changed and a layout is needed. */ boolean setAdjustedForMinimizedDock(float minimizeAmount) { + mAdjustedForForComplementDock = false; + if (minimizeAmount != mMinimizeAmount) { mMinimizeAmount = minimizeAmount; updateAdjustedBounds(); - return isVisibleForUserLocked(); + return true; } else { return false; } @@ -929,6 +935,33 @@ public class TaskStack implements DimLayer.DimLayerUser, return mMinimizeAmount != 0f; } + void setAdjustedForComplementDock(Rect dockBounds, int dockSide) { + if (mMinimizeAmount != 0f || mAdjustedForIme) { + return; + } + mTmpAdjustedBounds.set(mBounds); + if (dockSide == DOCKED_TOP) { + mTmpAdjustedBounds.top = dockBounds.bottom; + } else if (dockSide == DOCKED_LEFT) { + mTmpAdjustedBounds.left = dockBounds.right; + } else if (dockSide == DOCKED_RIGHT) { + mTmpAdjustedBounds.right = dockBounds.left; + } else { + Slog.w(TAG_WM, "setAdjustedForComplementDock: invalid dock side " + dockSide); + return; + } + mAdjustedForForComplementDock = true; + setAdjustedBounds(mTmpAdjustedBounds); + } + + void resetAdjustedForComplementDock() { + if (mAdjustedForForComplementDock) { + mAdjustedForForComplementDock = false; + mTmpAdjustedBounds.setEmpty(); + setAdjustedBounds(mTmpAdjustedBounds); + } + } + /** * Puts all visible tasks that are adjusted for IME into resizing mode and adds the windows * to the list of to be drawn windows the service is waiting for.