private void setMinimizedDockedStack(boolean minimized) {
final TaskStack stack = mDisplayContent.getDockedStackVisibleForUserLocked();
notifyDockedStackMinimizedChanged(minimized, 0);
- setMinimizeAmount(stack, minimized ? 1f : 0f);
+ if (stack == null) {
+ return;
+ }
+ if (stack.setAdjustedForMinimizedDock(minimized ? 1f : 0f)) {
+ mService.mWindowPlacerLocked.performSurfacePlacement();
+ }
}
private boolean isAnimationMaximizing() {
float t = Math.min(1f, (float) (now - mAnimationStartTime) / mAnimationDuration);
t = (isAnimationMaximizing() ? TOUCH_RESPONSE_INTERPOLATOR : mMinimizedDockInterpolator)
.getInterpolation(t);
- setMinimizeAmount(stack, getMinimizeAmount(stack, t));
-
+ if (stack != null) {
+ if (stack.setAdjustedForMinimizedDock(getMinimizeAmount(stack, t))) {
+ mService.mWindowPlacerLocked.performSurfacePlacement();
+ }
+ }
if (t >= 1.0f) {
mAnimatingForMinimizedDockedStack = false;
return false;
}
}
- void setMinimizeAmount(TaskStack dockedStack, float minimizeAmount) {
- final ArrayList<TaskStack> 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;
}
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
insetBounds = mFullyAdjustedImeBounds;
}
}
- if (!mAdjustedForForComplementDock) {
- alignTasksToAdjustedBounds(adjusted ? mAdjustedBounds : mBounds, insetBounds);
- }
+ alignTasksToAdjustedBounds(adjusted ? mAdjustedBounds : mBounds, insetBounds);
mDisplayContent.layoutNeeded = true;
}
mImeWin = imeWin;
mImeGoingAway = false;
if (!mAdjustedForIme || forceUpdate) {
- mAdjustedForForComplementDock = false;
mAdjustedForIme = true;
mAdjustImeAmount = 0f;
mAdjustDividerAmount = 0f;
* @return Whether the amount has changed and a layout is needed.
*/
boolean setAdjustedForMinimizedDock(float minimizeAmount) {
- mAdjustedForForComplementDock = false;
-
if (minimizeAmount != mMinimizeAmount) {
mMinimizeAmount = minimizeAmount;
updateAdjustedBounds();
- return true;
+ return isVisibleForUserLocked();
} else {
return false;
}
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.
import static android.view.WindowManager.LayoutParams.FLAG_SCALED;
import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_STARTING;
import static android.view.WindowManager.LayoutParams.TYPE_INPUT_METHOD;
-import static android.view.WindowManager.LayoutParams.TYPE_WALLPAPER;
import static com.android.server.wm.AppWindowAnimator.sDummyAnimation;
import static com.android.server.wm.DragResizeMode.DRAG_RESIZE_MODE_FREEFORM;
import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_ADD_REMOVE;
return;
}
- // We crop wallpaper windows to the stack bounds of their current target to avoid them
- // showing behind transparent windows in other stacks in split-screen mode.
- if (w.getBaseType() == TYPE_WALLPAPER) {
- final WindowState wallpaperTarget = mWallpaperControllerLocked.getWallpaperTarget();
- if (wallpaperTarget != null) {
- final Task task = wallpaperTarget.getTask();
- final WindowStateAnimator winAnimator = wallpaperTarget.mWinAnimator;
- // We can only crop the wallpaper using final crop with stack bounds if the target
- // is not animating, or if it's animating with clip mode STACK_CLIP_AFTER_ANIM.
- // If it's animating with mode STACK_CLIP_NONE, we shouldn't crop either the task
- // itself or the wallpaper. If it's animating with STACK_CLIP_BEFORE_ANIM, the crop
- // is before the transform on the task itself.
- final boolean useFinalCropOnWallpaper = !winAnimator.isAnimationSet()
- || winAnimator.resolveStackClip() == STACK_CLIP_AFTER_ANIM;
- if (task != null && !task.isFullscreen()
- && task.cropWindowsToStackBounds()
- && useFinalCropOnWallpaper){
- final TaskStack stack = task.mStack;
- if (stack != null && !stack.isFullscreen()) {
- stack.getDimBounds(mTmpStackBounds);
- finalClipRect.set(mTmpStackBounds);
- }
- }
- }
- return;
- }
-
final Task task = w.getTask();
if (task == null || !task.cropWindowsToStackBounds()) {
return;
// We need to ensure for each surface, that we disable transformation matrix
// scaling in the same transaction which we resize the surface in.
// As we are in SCALING_MODE_SCALE_TO_WINDOW, SurfaceFlinger will
- // then take over the scaling until the new buffer arrives, and things
+ // then take over the scaling until the new buffer arrives, and things
// will be seamless.
mForceScaleUntilResize = true;
} else {
OSDN Git Service
