services/core/java/com/android/server/wm/DockedStackDividerController.java

   1 /*
   2  * Copyright (C) 2012 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.android.server.wm;
  18
  19 import static android.app.ActivityManager.StackId.DOCKED_STACK_ID;
  20 import static android.app.ActivityManager.StackId.FULLSCREEN_WORKSPACE_STACK_ID;
  21 import static android.app.ActivityManager.StackId.INVALID_STACK_ID;
  22 import static android.content.res.Configuration.ORIENTATION_LANDSCAPE;
  23 import static android.content.res.Configuration.ORIENTATION_PORTRAIT;
  24 import static android.view.Surface.ROTATION_270;
  25 import static android.view.Surface.ROTATION_90;
  26 import static android.view.WindowManager.DOCKED_BOTTOM;
  27 import static android.view.WindowManager.DOCKED_LEFT;
  28 import static android.view.WindowManager.DOCKED_RIGHT;
  29 import static android.view.WindowManager.DOCKED_TOP;
  30 import static com.android.server.wm.AppTransition.DEFAULT_APP_TRANSITION_DURATION;
  31 import static com.android.server.wm.AppTransition.TOUCH_RESPONSE_INTERPOLATOR;
  32 import static com.android.server.wm.WindowManagerDebugConfig.TAG_WITH_CLASS_NAME;
  33 import static com.android.server.wm.WindowManagerDebugConfig.TAG_WM;
  34 import static com.android.server.wm.WindowManagerService.H.NOTIFY_DOCKED_STACK_MINIMIZED_CHANGED;
  35
  36 import android.content.Context;
  37 import android.content.res.Configuration;
  38 import android.graphics.Rect;
  39 import android.os.RemoteCallbackList;
  40 import android.os.RemoteException;
  41 import android.util.Slog;
  42 import android.view.DisplayInfo;
  43 import android.view.IDockedStackListener;
  44 import android.view.SurfaceControl;
  45 import android.view.animation.AnimationUtils;
  46 import android.view.animation.Interpolator;
  47 import android.view.animation.PathInterpolator;
  48 import android.view.inputmethod.InputMethodManagerInternal;
  49
  50 import com.android.internal.policy.DividerSnapAlgorithm;
  51 import com.android.internal.policy.DockedDividerUtils;
  52 import com.android.server.LocalServices;
  53 import com.android.server.wm.DimLayer.DimLayerUser;
  54 import com.android.server.wm.WindowManagerService.H;
  55
  56 import java.io.PrintWriter;
  57 import java.util.ArrayList;
  58
  59 /**
  60  * Keeps information about the docked stack divider.
  61  */
  62 public class DockedStackDividerController implements DimLayerUser {
  63
  64     private static final String TAG = TAG_WITH_CLASS_NAME ? "DockedStackDividerController" : TAG_WM;
  65
  66     /**
  67      * The fraction during the maximize/clip reveal animation the divider meets the edge of the clip
  68      * revealing surface at the earliest.
  69      */
  70     private static final float CLIP_REVEAL_MEET_EARLIEST = 0.6f;
  71
  72     /**
  73      * The fraction during the maximize/clip reveal animation the divider meets the edge of the clip
  74      * revealing surface at the latest.
  75      */
  76     private static final float CLIP_REVEAL_MEET_LAST = 1f;
  77
  78     /**
  79      * If the app translates at least CLIP_REVEAL_MEET_FRACTION_MIN * minimize distance, we start
  80      * meet somewhere between {@link #CLIP_REVEAL_MEET_LAST} and {@link #CLIP_REVEAL_MEET_EARLIEST}.
  81      */
  82     private static final float CLIP_REVEAL_MEET_FRACTION_MIN = 0.4f;
  83
  84     /**
  85      * If the app translates equals or more than CLIP_REVEAL_MEET_FRACTION_MIN * minimize distance,
  86      * we meet at {@link #CLIP_REVEAL_MEET_EARLIEST}.
  87      */
  88     private static final float CLIP_REVEAL_MEET_FRACTION_MAX = 0.8f;
  89
  90     private static final Interpolator IME_ADJUST_ENTRY_INTERPOLATOR =
  91             new PathInterpolator(0.2f, 0f, 0.1f, 1f);
  92
  93     private static final long IME_ADJUST_ANIM_DURATION = 280;
  94
  95     private static final long IME_ADJUST_DRAWN_TIMEOUT = 200;
  96
  97     private static final int DIVIDER_WIDTH_INACTIVE_DP = 4;
  98
  99     private final WindowManagerService mService;
 100     private final DisplayContent mDisplayContent;
 101     private int mDividerWindowWidth;
 102     private int mDividerWindowWidthInactive;
 103     private int mDividerInsets;
 104     private boolean mResizing;
 105     private WindowState mWindow;
 106     private final Rect mTmpRect = new Rect();
 107     private final Rect mTmpRect2 = new Rect();
 108     private final Rect mTmpRect3 = new Rect();
 109     private final Rect mLastRect = new Rect();
 110     private boolean mLastVisibility = false;
 111     private final RemoteCallbackList<IDockedStackListener> mDockedStackListeners
 112             = new RemoteCallbackList<>();
 113     private final DimLayer mDimLayer;
 114
 115     private boolean mMinimizedDock;
 116     private boolean mAnimatingForMinimizedDockedStack;
 117     private boolean mAnimationStarted;
 118     private long mAnimationStartTime;
 119     private float mAnimationStart;
 120     private float mAnimationTarget;
 121     private long mAnimationDuration;
 122     private boolean mAnimationStartDelayed;
 123     private final Interpolator mMinimizedDockInterpolator;
 124     private float mMaximizeMeetFraction;
 125     private final Rect mTouchRegion = new Rect();
 126     private boolean mAnimatingForIme;
 127     private boolean mAdjustedForIme;
 128     private int mImeHeight;
 129     private WindowState mDelayedImeWin;
 130     private boolean mAdjustedForDivider;
 131     private float mDividerAnimationStart;
 132     private float mDividerAnimationTarget;
 133     private float mLastAnimationProgress;
 134     private float mLastDividerProgress;
 135     private final DividerSnapAlgorithm[] mSnapAlgorithmForRotation = new DividerSnapAlgorithm[4];
 136     private boolean mImeHideRequested;
 137
 138     DockedStackDividerController(WindowManagerService service, DisplayContent displayContent) {
 139         mService = service;
 140         mDisplayContent = displayContent;
 141         final Context context = service.mContext;
 142         mDimLayer = new DimLayer(displayContent.mService, this, displayContent.getDisplayId(),
 143                 "DockedStackDim");
 144         mMinimizedDockInterpolator = AnimationUtils.loadInterpolator(
 145                 context, android.R.interpolator.fast_out_slow_in);
 146         loadDimens();
 147     }
 148
 149     int getSmallestWidthDpForBounds(Rect bounds) {
 150         final DisplayInfo di = mDisplayContent.getDisplayInfo();
 151
 152         // If the bounds are fullscreen, return the value of the fullscreen configuration
 153         if (bounds == null || (bounds.left == 0 && bounds.top == 0
 154                 && bounds.right == di.logicalWidth && bounds.bottom == di.logicalHeight)) {
 155             return mService.mCurConfiguration.smallestScreenWidthDp;
 156         }
 157         final int baseDisplayWidth = mDisplayContent.mBaseDisplayWidth;
 158         final int baseDisplayHeight = mDisplayContent.mBaseDisplayHeight;
 159         int minWidth = Integer.MAX_VALUE;
 160
 161         // Go through all screen orientations and find the orientation in which the task has the
 162         // smallest width.
 163         for (int rotation = 0; rotation < 4; rotation++) {
 164             mTmpRect.set(bounds);
 165             mDisplayContent.rotateBounds(di.rotation, rotation, mTmpRect);
 166             final boolean rotated = (rotation == ROTATION_90 || rotation == ROTATION_270);
 167             mTmpRect2.set(0, 0,
 168                     rotated ? baseDisplayHeight : baseDisplayWidth,
 169                     rotated ? baseDisplayWidth : baseDisplayHeight);
 170             final int orientation = mTmpRect2.width() <= mTmpRect2.height()
 171                     ? ORIENTATION_PORTRAIT
 172                     : ORIENTATION_LANDSCAPE;
 173             final int dockSide = TaskStack.getDockSideUnchecked(mTmpRect, mTmpRect2, orientation);
 174             final int position = DockedDividerUtils.calculatePositionForBounds(mTmpRect, dockSide,
 175                     getContentWidth());
 176
 177             // Since we only care about feasible states, snap to the closest snap target, like it
 178             // would happen when actually rotating the screen.
 179             final int snappedPosition = mSnapAlgorithmForRotation[rotation]
 180                     .calculateNonDismissingSnapTarget(position).position;
 181             DockedDividerUtils.calculateBoundsForPosition(snappedPosition, dockSide, mTmpRect,
 182                     mTmpRect2.width(), mTmpRect2.height(), getContentWidth());
 183             mService.mPolicy.getStableInsetsLw(rotation, mTmpRect2.width(), mTmpRect2.height(),
 184                     mTmpRect3);
 185             mService.subtractInsets(mTmpRect2, mTmpRect3, mTmpRect);
 186             minWidth = Math.min(mTmpRect.width(), minWidth);
 187         }
 188         return (int) (minWidth / mDisplayContent.getDisplayMetrics().density);
 189     }
 190
 191     private void initSnapAlgorithmForRotations() {
 192         final Configuration baseConfig = mService.mCurConfiguration;
 193
 194         // Initialize the snap algorithms for all 4 screen orientations.
 195         final Configuration config = new Configuration();
 196         for (int rotation = 0; rotation < 4; rotation++) {
 197             final boolean rotated = (rotation == ROTATION_90 || rotation == ROTATION_270);
 198             final int dw = rotated
 199                     ? mDisplayContent.mBaseDisplayHeight
 200                     : mDisplayContent.mBaseDisplayWidth;
 201             final int dh = rotated
 202                     ? mDisplayContent.mBaseDisplayWidth
 203                     : mDisplayContent.mBaseDisplayHeight;
 204             mService.mPolicy.getStableInsetsLw(rotation, dw, dh, mTmpRect);
 205             config.setToDefaults();
 206             config.orientation = (dw <= dh) ? ORIENTATION_PORTRAIT : ORIENTATION_LANDSCAPE;
 207             config.screenWidthDp = (int)
 208                     (mService.mPolicy.getConfigDisplayWidth(dw, dh, rotation, baseConfig.uiMode) /
 209                             mDisplayContent.getDisplayMetrics().density);
 210             config.screenHeightDp = (int)
 211                     (mService.mPolicy.getConfigDisplayHeight(dw, dh, rotation, baseConfig.uiMode) /
 212                             mDisplayContent.getDisplayMetrics().density);
 213             final Context rotationContext = mService.mContext.createConfigurationContext(config);
 214             mSnapAlgorithmForRotation[rotation] = new DividerSnapAlgorithm(
 215                     rotationContext.getResources(), dw, dh, getContentWidth(),
 216                     config.orientation == ORIENTATION_PORTRAIT, mTmpRect);
 217         }
 218     }
 219
 220     private void loadDimens() {
 221         final Context context = mService.mContext;
 222         mDividerWindowWidth = context.getResources().getDimensionPixelSize(
 223                 com.android.internal.R.dimen.docked_stack_divider_thickness);
 224         mDividerInsets = context.getResources().getDimensionPixelSize(
 225                 com.android.internal.R.dimen.docked_stack_divider_insets);
 226         mDividerWindowWidthInactive = WindowManagerService.dipToPixel(
 227                 DIVIDER_WIDTH_INACTIVE_DP, mDisplayContent.getDisplayMetrics());
 228         initSnapAlgorithmForRotations();
 229     }
 230
 231     void onConfigurationChanged() {
 232         loadDimens();
 233     }
 234
 235     boolean isResizing() {
 236         return mResizing;
 237     }
 238
 239     int getContentWidth() {
 240         return mDividerWindowWidth - 2 * mDividerInsets;
 241     }
 242
 243     int getContentInsets() {
 244         return mDividerInsets;
 245     }
 246
 247     int getContentWidthInactive() {
 248         return mDividerWindowWidthInactive;
 249     }
 250
 251     void setResizing(boolean resizing) {
 252         if (mResizing != resizing) {
 253             mResizing = resizing;
 254             resetDragResizingChangeReported();
 255         }
 256     }
 257
 258     void setTouchRegion(Rect touchRegion) {
 259         mTouchRegion.set(touchRegion);
 260     }
 261
 262     void getTouchRegion(Rect outRegion) {
 263         outRegion.set(mTouchRegion);
 264         outRegion.offset(mWindow.getFrameLw().left, mWindow.getFrameLw().top);
 265     }
 266
 267     private void resetDragResizingChangeReported() {
 268         final WindowList windowList = mDisplayContent.getWindowList();
 269         for (int i = windowList.size() - 1; i >= 0; i--) {
 270             windowList.get(i).resetDragResizingChangeReported();
 271         }
 272     }
 273
 274     void setWindow(WindowState window) {
 275         mWindow = window;
 276         reevaluateVisibility(false);
 277     }
 278
 279     void reevaluateVisibility(boolean force) {
 280         if (mWindow == null) {
 281             return;
 282         }
 283         TaskStack stack = mDisplayContent.mService.mStackIdToStack.get(DOCKED_STACK_ID);
 284
 285         // If the stack is invisible, we policy force hide it in WindowAnimator.shouldForceHide
 286         final boolean visible = stack != null;
 287         if (mLastVisibility == visible && !force) {
 288             return;
 289         }
 290         mLastVisibility = visible;
 291         notifyDockedDividerVisibilityChanged(visible);
 292         if (!visible) {
 293             setResizeDimLayer(false, INVALID_STACK_ID, 0f);
 294         }
 295     }
 296
 297     boolean wasVisible() {
 298         return mLastVisibility;
 299     }
 300
 301     void setAdjustedForIme(
 302             boolean adjustedForIme, boolean adjustedForDivider,
 303             boolean animate, WindowState imeWin, int imeHeight) {
 304         if (mAdjustedForIme != adjustedForIme || (adjustedForIme && mImeHeight != imeHeight)
 305                 || mAdjustedForDivider != adjustedForDivider) {
 306             if (animate && !mAnimatingForMinimizedDockedStack) {
 307                 startImeAdjustAnimation(adjustedForIme, adjustedForDivider, imeWin);
 308             } else {
 309                 // Animation might be delayed, so only notify if we don't run an animation.
 310                 notifyAdjustedForImeChanged(adjustedForIme || adjustedForDivider, 0 /* duration */);
 311             }
 312             mAdjustedForIme = adjustedForIme;
 313             mImeHeight = imeHeight;
 314             mAdjustedForDivider = adjustedForDivider;
 315         }
 316     }
 317
 318     int getImeHeightAdjustedFor() {
 319         return mImeHeight;
 320     }
 321
 322     void positionDockedStackedDivider(Rect frame) {
 323         TaskStack stack = mDisplayContent.getDockedStackLocked();
 324         if (stack == null) {
 325             // Unfortunately we might end up with still having a divider, even though the underlying
 326             // stack was already removed. This is because we are on AM thread and the removal of the
 327             // divider was deferred to WM thread and hasn't happened yet. In that case let's just
 328             // keep putting it in the same place it was before the stack was removed to have
 329             // continuity and prevent it from jumping to the center. It will get hidden soon.
 330             frame.set(mLastRect);
 331             return;
 332         } else {
 333             stack.getDimBounds(mTmpRect);
 334         }
 335         int side = stack.getDockSide();
 336         switch (side) {
 337             case DOCKED_LEFT:
 338                 frame.set(mTmpRect.right - mDividerInsets, frame.top,
 339                         mTmpRect.right + frame.width() - mDividerInsets, frame.bottom);
 340                 break;
 341             case DOCKED_TOP:
 342                 frame.set(frame.left, mTmpRect.bottom - mDividerInsets,
 343                         mTmpRect.right, mTmpRect.bottom + frame.height() - mDividerInsets);
 344                 break;
 345             case DOCKED_RIGHT:
 346                 frame.set(mTmpRect.left - frame.width() + mDividerInsets, frame.top,
 347                         mTmpRect.left + mDividerInsets, frame.bottom);
 348                 break;
 349             case DOCKED_BOTTOM:
 350                 frame.set(frame.left, mTmpRect.top - frame.height() + mDividerInsets,
 351                         frame.right, mTmpRect.top + mDividerInsets);
 352                 break;
 353         }
 354         mLastRect.set(frame);
 355     }
 356
 357     void notifyDockedDividerVisibilityChanged(boolean visible) {
 358         final int size = mDockedStackListeners.beginBroadcast();
 359         for (int i = 0; i < size; ++i) {
 360             final IDockedStackListener listener = mDockedStackListeners.getBroadcastItem(i);
 361             try {
 362                 listener.onDividerVisibilityChanged(visible);
 363             } catch (RemoteException e) {
 364                 Slog.e(TAG_WM, "Error delivering divider visibility changed event.", e);
 365             }
 366         }
 367         mDockedStackListeners.finishBroadcast();
 368     }
 369
 370     void notifyDockedStackExistsChanged(boolean exists) {
 371         final int size = mDockedStackListeners.beginBroadcast();
 372         for (int i = 0; i < size; ++i) {
 373             final IDockedStackListener listener = mDockedStackListeners.getBroadcastItem(i);
 374             try {
 375                 listener.onDockedStackExistsChanged(exists);
 376             } catch (RemoteException e) {
 377                 Slog.e(TAG_WM, "Error delivering docked stack exists changed event.", e);
 378             }
 379         }
 380         mDockedStackListeners.finishBroadcast();
 381         if (exists) {
 382             InputMethodManagerInternal inputMethodManagerInternal =
 383                     LocalServices.getService(InputMethodManagerInternal.class);
 384             if (inputMethodManagerInternal != null) {
 385
 386                 // Hide the current IME to avoid problems with animations from IME adjustment when
 387                 // attaching the docked stack.
 388                 inputMethodManagerInternal.hideCurrentInputMethod();
 389                 mImeHideRequested = true;
 390             }
 391         } else {
 392             setMinimizedDockedStack(false);
 393         }
 394     }
 395
 396     /**
 397      * Resets the state that IME hide has been requested. See {@link #isImeHideRequested}.
 398      */
 399     void resetImeHideRequested() {
 400         mImeHideRequested = false;
 401     }
 402
 403     /**
 404      * The docked stack divider controller makes sure the IME gets hidden when attaching the docked
 405      * stack, to avoid animation problems. This flag indicates whether the request to hide the IME
 406      * has been sent in an asynchronous manner, and the IME should be treated as hidden already.
 407      *
 408      * @return whether IME hide request has been sent
 409      */
 410     boolean isImeHideRequested() {
 411         return mImeHideRequested;
 412     }
 413
 414     void notifyDockedStackMinimizedChanged(boolean minimizedDock, long animDuration) {
 415         mService.mH.removeMessages(NOTIFY_DOCKED_STACK_MINIMIZED_CHANGED);
 416         mService.mH.obtainMessage(NOTIFY_DOCKED_STACK_MINIMIZED_CHANGED,
 417                 minimizedDock ? 1 : 0, 0).sendToTarget();
 418         final int size = mDockedStackListeners.beginBroadcast();
 419         for (int i = 0; i < size; ++i) {
 420             final IDockedStackListener listener = mDockedStackListeners.getBroadcastItem(i);
 421             try {
 422                 listener.onDockedStackMinimizedChanged(minimizedDock, animDuration);
 423             } catch (RemoteException e) {
 424                 Slog.e(TAG_WM, "Error delivering minimized dock changed event.", e);
 425             }
 426         }
 427         mDockedStackListeners.finishBroadcast();
 428     }
 429
 430     void notifyDockSideChanged(int newDockSide) {
 431         final int size = mDockedStackListeners.beginBroadcast();
 432         for (int i = 0; i < size; ++i) {
 433             final IDockedStackListener listener = mDockedStackListeners.getBroadcastItem(i);
 434             try {
 435                 listener.onDockSideChanged(newDockSide);
 436             } catch (RemoteException e) {
 437                 Slog.e(TAG_WM, "Error delivering dock side changed event.", e);
 438             }
 439         }
 440         mDockedStackListeners.finishBroadcast();
 441     }
 442
 443     void notifyAdjustedForImeChanged(boolean adjustedForIme, long animDuration) {
 444         final int size = mDockedStackListeners.beginBroadcast();
 445         for (int i = 0; i < size; ++i) {
 446             final IDockedStackListener listener = mDockedStackListeners.getBroadcastItem(i);
 447             try {
 448                 listener.onAdjustedForImeChanged(adjustedForIme, animDuration);
 449             } catch (RemoteException e) {
 450                 Slog.e(TAG_WM, "Error delivering adjusted for ime changed event.", e);
 451             }
 452         }
 453         mDockedStackListeners.finishBroadcast();
 454     }
 455
 456     void registerDockedStackListener(IDockedStackListener listener) {
 457         mDockedStackListeners.register(listener);
 458         notifyDockedDividerVisibilityChanged(wasVisible());
 459         notifyDockedStackExistsChanged(
 460                 mDisplayContent.mService.mStackIdToStack.get(DOCKED_STACK_ID) != null);
 461         notifyDockedStackMinimizedChanged(mMinimizedDock, 0 /* animDuration */);
 462         notifyAdjustedForImeChanged(mAdjustedForIme, 0 /* animDuration */);
 463
 464     }
 465
 466     void setResizeDimLayer(boolean visible, int targetStackId, float alpha) {
 467         SurfaceControl.openTransaction();
 468         final TaskStack stack = mDisplayContent.mService.mStackIdToStack.get(targetStackId);
 469         final TaskStack dockedStack = mDisplayContent.getDockedStackLocked();
 470         boolean visibleAndValid = visible && stack != null && dockedStack != null;
 471         if (visibleAndValid) {
 472             stack.getDimBounds(mTmpRect);
 473             if (mTmpRect.height() > 0 && mTmpRect.width() > 0) {
 474                 mDimLayer.setBounds(mTmpRect);
 475                 mDimLayer.show(mService.mLayersController.getResizeDimLayer(),
 476                         alpha, 0 /* duration */);
 477             } else {
 478                 visibleAndValid = false;
 479             }
 480         }
 481         if (!visibleAndValid) {
 482             mDimLayer.hide();
 483         }
 484         SurfaceControl.closeTransaction();
 485     }
 486
 487     /**
 488      * Notifies the docked stack divider controller of a visibility change that happens without
 489      * an animation.
 490      */
 491     void notifyAppVisibilityChanged() {
 492         checkMinimizeChanged(false /* animate */);
 493     }
 494
 495     void notifyAppTransitionStarting() {
 496         checkMinimizeChanged(true /* animate */);
 497     }
 498
 499     boolean isMinimizedDock() {
 500         return mMinimizedDock;
 501     }
 502
 503     private void checkMinimizeChanged(boolean animate) {
 504         if (mDisplayContent.getDockedStackVisibleForUserLocked() == null) {
 505             return;
 506         }
 507         final TaskStack homeStack = mDisplayContent.getHomeStack();
 508         if (homeStack == null) {
 509             return;
 510         }
 511         final Task homeTask = homeStack.findHomeTask();
 512         if (homeTask == null || !isWithinDisplay(homeTask)) {
 513             return;
 514         }
 515         final TaskStack fullscreenStack
 516                 = mService.mStackIdToStack.get(FULLSCREEN_WORKSPACE_STACK_ID);
 517         final ArrayList<Task> homeStackTasks = homeStack.getTasks();
 518         final Task topHomeStackTask = homeStackTasks.get(homeStackTasks.size() - 1);
 519         final boolean homeVisible = homeTask.getTopVisibleAppToken() != null;
 520         final boolean homeBehind = (fullscreenStack != null && fullscreenStack.isVisibleLocked())
 521                 || (homeStackTasks.size() > 1 && topHomeStackTask != homeTask);
 522         setMinimizedDockedStack(homeVisible && !homeBehind, animate);
 523     }
 524
 525     private boolean isWithinDisplay(Task task) {
 526         task.mStack.getBounds(mTmpRect);
 527         mDisplayContent.getLogicalDisplayRect(mTmpRect2);
 528         return mTmpRect.intersect(mTmpRect2);
 529     }
 530
 531     /**
 532      * Sets whether the docked stack is currently in a minimized state, i.e. all the tasks in the
 533      * docked stack are heavily clipped so you can only see a minimal peek state.
 534      *
 535      * @param minimizedDock Whether the docked stack is currently minimized.
 536      * @param animate Whether to animate the change.
 537      */
 538     private void setMinimizedDockedStack(boolean minimizedDock, boolean animate) {
 539         final boolean wasMinimized = mMinimizedDock;
 540         mMinimizedDock = minimizedDock;
 541         if (minimizedDock == wasMinimized) {
 542             return;
 543         }
 544
 545         clearImeAdjustAnimation();
 546         if (minimizedDock) {
 547             if (animate) {
 548                 startAdjustAnimation(0f, 1f);
 549             } else {
 550                 setMinimizedDockedStack(true);
 551             }
 552         } else {
 553             if (animate) {
 554                 startAdjustAnimation(1f, 0f);
 555             } else {
 556                 setMinimizedDockedStack(false);
 557             }
 558         }
 559     }
 560
 561     private void clearImeAdjustAnimation() {
 562         final ArrayList<TaskStack> stacks = mDisplayContent.getStacks();
 563         for (int i = stacks.size() - 1; i >= 0; --i) {
 564             final TaskStack stack = stacks.get(i);
 565             if (stack != null && stack.isAdjustedForIme()) {
 566                 stack.resetAdjustedForIme(true /* adjustBoundsNow */);
 567             }
 568         }
 569         mAnimatingForIme = false;
 570     }
 571
 572     private void startAdjustAnimation(float from, float to) {
 573         mAnimatingForMinimizedDockedStack = true;
 574         mAnimationStarted = false;
 575         mAnimationStart = from;
 576         mAnimationTarget = to;
 577     }
 578
 579     private void startImeAdjustAnimation(
 580             boolean adjustedForIme, boolean adjustedForDivider, WindowState imeWin) {
 581
 582         // If we're not in an animation, the starting point depends on whether we're adjusted
 583         // or not. If we're already in an animation, we start from where the current animation
 584         // left off, so that the motion doesn't look discontinuous.
 585         if (!mAnimatingForIme) {
 586             mAnimationStart = mAdjustedForIme ? 1 : 0;
 587             mDividerAnimationStart = mAdjustedForDivider ? 1 : 0;
 588             mLastAnimationProgress = mAnimationStart;
 589             mLastDividerProgress = mDividerAnimationStart;
 590         } else {
 591             mAnimationStart = mLastAnimationProgress;
 592             mDividerAnimationStart = mLastDividerProgress;
 593         }
 594         mAnimatingForIme = true;
 595         mAnimationStarted = false;
 596         mAnimationTarget = adjustedForIme ? 1 : 0;
 597         mDividerAnimationTarget = adjustedForDivider ? 1 : 0;
 598
 599         final ArrayList<TaskStack> stacks = mDisplayContent.getStacks();
 600         for (int i = stacks.size() - 1; i >= 0; --i) {
 601             final TaskStack stack = stacks.get(i);
 602             if (stack.isVisibleLocked() && stack.isAdjustedForIme()) {
 603                 stack.beginImeAdjustAnimation();
 604             }
 605         }
 606
 607         // We put all tasks into drag resizing mode - wait until all of them have completed the
 608         // drag resizing switch.
 609         if (!mService.mWaitingForDrawn.isEmpty()) {
 610             mService.mH.removeMessages(H.WAITING_FOR_DRAWN_TIMEOUT);
 611             mService.mH.sendEmptyMessageDelayed(H.WAITING_FOR_DRAWN_TIMEOUT,
 612                     IME_ADJUST_DRAWN_TIMEOUT);
 613             mAnimationStartDelayed = true;
 614             if (imeWin != null) {
 615
 616                 // There might be an old window delaying the animation start - clear it.
 617                 if (mDelayedImeWin != null) {
 618                     mDelayedImeWin.mWinAnimator.endDelayingAnimationStart();
 619                 }
 620                 mDelayedImeWin = imeWin;
 621                 imeWin.mWinAnimator.startDelayingAnimationStart();
 622             }
 623             mService.mWaitingForDrawnCallback = () -> {
 624                 mAnimationStartDelayed = false;
 625                 if (mDelayedImeWin != null) {
 626                     mDelayedImeWin.mWinAnimator.endDelayingAnimationStart();
 627                 }
 628                 notifyAdjustedForImeChanged(
 629                         adjustedForIme || adjustedForDivider, IME_ADJUST_ANIM_DURATION);
 630             };
 631         } else {
 632             notifyAdjustedForImeChanged(
 633                     adjustedForIme || adjustedForDivider, IME_ADJUST_ANIM_DURATION);
 634         }
 635     }
 636
 637     private void setMinimizedDockedStack(boolean minimized) {
 638         final TaskStack stack = mDisplayContent.getDockedStackVisibleForUserLocked();
 639         notifyDockedStackMinimizedChanged(minimized, 0);
 640         if (stack == null) {
 641             return;
 642         }
 643         if (stack.setAdjustedForMinimizedDock(minimized ? 1f : 0f)) {
 644             mService.mWindowPlacerLocked.performSurfacePlacement();
 645         }
 646     }
 647
 648     private boolean isAnimationMaximizing() {
 649         return mAnimationTarget == 0f;
 650     }
 651
 652     public boolean animate(long now) {
 653         if (mWindow == null) {
 654             return false;
 655         }
 656         if (mAnimatingForMinimizedDockedStack) {
 657             return animateForMinimizedDockedStack(now);
 658         } else if (mAnimatingForIme) {
 659             return animateForIme(now);
 660         } else {
 661             if (mDimLayer != null && mDimLayer.isDimming()) {
 662                 mDimLayer.setLayer(mService.mLayersController.getResizeDimLayer());
 663             }
 664             return false;
 665         }
 666     }
 667
 668     private boolean animateForIme(long now) {
 669         if (!mAnimationStarted || mAnimationStartDelayed) {
 670             mAnimationStarted = true;
 671             mAnimationStartTime = now;
 672             mAnimationDuration = (long)
 673                     (IME_ADJUST_ANIM_DURATION * mService.getWindowAnimationScaleLocked());
 674         }
 675         float t = Math.min(1f, (float) (now - mAnimationStartTime) / mAnimationDuration);
 676         t = (mAnimationTarget == 1f ? IME_ADJUST_ENTRY_INTERPOLATOR : TOUCH_RESPONSE_INTERPOLATOR)
 677                 .getInterpolation(t);
 678         final ArrayList<TaskStack> stacks = mDisplayContent.getStacks();
 679         boolean updated = false;
 680         for (int i = stacks.size() - 1; i >= 0; --i) {
 681             final TaskStack stack = stacks.get(i);
 682             if (stack != null && stack.isAdjustedForIme()) {
 683                 if (t >= 1f && mAnimationTarget == 0f && mDividerAnimationTarget == 0f) {
 684                     stack.resetAdjustedForIme(true /* adjustBoundsNow */);
 685                     updated = true;
 686                 } else {
 687                     mLastAnimationProgress = getInterpolatedAnimationValue(t);
 688                     mLastDividerProgress = getInterpolatedDividerValue(t);
 689                     updated |= stack.updateAdjustForIme(
 690                             mLastAnimationProgress,
 691                             mLastDividerProgress,
 692                             false /* force */);
 693                 }
 694                 if (t >= 1f) {
 695                     stack.endImeAdjustAnimation();
 696                 }
 697             }
 698         }
 699         if (updated) {
 700             mService.mWindowPlacerLocked.performSurfacePlacement();
 701         }
 702         if (t >= 1.0f) {
 703             mLastAnimationProgress = mAnimationTarget;
 704             mLastDividerProgress = mDividerAnimationTarget;
 705             mAnimatingForIme = false;
 706             return false;
 707         } else {
 708             return true;
 709         }
 710     }
 711
 712     private boolean animateForMinimizedDockedStack(long now) {
 713         final TaskStack stack = mService.mStackIdToStack.get(DOCKED_STACK_ID);
 714         if (!mAnimationStarted) {
 715             mAnimationStarted = true;
 716             mAnimationStartTime = now;
 717             final long transitionDuration = isAnimationMaximizing()
 718                     ? mService.mAppTransition.getLastClipRevealTransitionDuration()
 719                     : DEFAULT_APP_TRANSITION_DURATION;
 720             mAnimationDuration = (long)
 721                     (transitionDuration * mService.getTransitionAnimationScaleLocked());
 722             mMaximizeMeetFraction = getClipRevealMeetFraction(stack);
 723             notifyDockedStackMinimizedChanged(mMinimizedDock,
 724                     (long) (mAnimationDuration * mMaximizeMeetFraction));
 725         }
 726         float t = Math.min(1f, (float) (now - mAnimationStartTime) / mAnimationDuration);
 727         t = (isAnimationMaximizing() ? TOUCH_RESPONSE_INTERPOLATOR : mMinimizedDockInterpolator)
 728                 .getInterpolation(t);
 729         if (stack != null) {
 730             if (stack.setAdjustedForMinimizedDock(getMinimizeAmount(stack, t))) {
 731                 mService.mWindowPlacerLocked.performSurfacePlacement();
 732             }
 733         }
 734         if (t >= 1.0f) {
 735             mAnimatingForMinimizedDockedStack = false;
 736             return false;
 737         } else {
 738             return true;
 739         }
 740     }
 741
 742     private float getInterpolatedAnimationValue(float t) {
 743         return t * mAnimationTarget + (1 - t) * mAnimationStart;
 744     }
 745
 746     private float getInterpolatedDividerValue(float t) {
 747         return t * mDividerAnimationTarget + (1 - t) * mDividerAnimationStart;
 748     }
 749
 750     /**
 751      * Gets the amount how much to minimize a stack depending on the interpolated fraction t.
 752      */
 753     private float getMinimizeAmount(TaskStack stack, float t) {
 754         final float naturalAmount = getInterpolatedAnimationValue(t);
 755         if (isAnimationMaximizing()) {
 756             return adjustMaximizeAmount(stack, t, naturalAmount);
 757         } else {
 758             return naturalAmount;
 759         }
 760     }
 761
 762     /**
 763      * When maximizing the stack during a clip reveal transition, this adjusts the minimize amount
 764      * during the transition such that the edge of the clip reveal rect is met earlier in the
 765      * transition so we don't create a visible "hole", but only if both the clip reveal and the
 766      * docked stack divider start from about the same portion on the screen.
 767      */
 768     private float adjustMaximizeAmount(TaskStack stack, float t, float naturalAmount) {
 769         if (mMaximizeMeetFraction == 1f) {
 770             return naturalAmount;
 771         }
 772         final int minimizeDistance = stack.getMinimizeDistance();
 773         float startPrime = mService.mAppTransition.getLastClipRevealMaxTranslation()
 774                 / (float) minimizeDistance;
 775         final float amountPrime = t * mAnimationTarget + (1 - t) * startPrime;
 776         final float t2 = Math.min(t / mMaximizeMeetFraction, 1);
 777         return amountPrime * t2 + naturalAmount * (1 - t2);
 778     }
 779
 780     /**
 781      * Retrieves the animation fraction at which the docked stack has to meet the clip reveal
 782      * edge. See {@link #adjustMaximizeAmount}.
 783      */
 784     private float getClipRevealMeetFraction(TaskStack stack) {
 785         if (!isAnimationMaximizing() || stack == null ||
 786                 !mService.mAppTransition.hadClipRevealAnimation()) {
 787             return 1f;
 788         }
 789         final int minimizeDistance = stack.getMinimizeDistance();
 790         final float fraction = Math.abs(mService.mAppTransition.getLastClipRevealMaxTranslation())
 791                 / (float) minimizeDistance;
 792         final float t = Math.max(0, Math.min(1, (fraction - CLIP_REVEAL_MEET_FRACTION_MIN)
 793                 / (CLIP_REVEAL_MEET_FRACTION_MAX - CLIP_REVEAL_MEET_FRACTION_MIN)));
 794         return CLIP_REVEAL_MEET_EARLIEST
 795                 + (1 - t) * (CLIP_REVEAL_MEET_LAST - CLIP_REVEAL_MEET_EARLIEST);
 796     }
 797
 798     @Override
 799     public boolean dimFullscreen() {
 800         return false;
 801     }
 802
 803     @Override
 804     public DisplayInfo getDisplayInfo() {
 805         return mDisplayContent.getDisplayInfo();
 806     }
 807
 808     @Override
 809     public void getDimBounds(Rect outBounds) {
 810         // This dim layer user doesn't need this.
 811     }
 812
 813     @Override
 814     public String toShortString() {
 815         return TAG;
 816     }
 817
 818     WindowState getWindow() {
 819         return mWindow;
 820     }
 821
 822     void dump(String prefix, PrintWriter pw) {
 823         pw.println(prefix + "DockedStackDividerController");
 824         pw.println(prefix + "  mLastVisibility=" + mLastVisibility);
 825         pw.println(prefix + "  mMinimizedDock=" + mMinimizedDock);
 826         pw.println(prefix + "  mAdjustedForIme=" + mAdjustedForIme);
 827         pw.println(prefix + "  mAdjustedForDivider=" + mAdjustedForDivider);
 828         if (mDimLayer.isDimming()) {
 829             pw.println(prefix + "  Dim layer is dimming: ");
 830             mDimLayer.printTo(prefix + "    ", pw);
 831         }
 832     }
 833 }