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 
DockedStackDividerController(WindowManagerService service, DisplayContent displayContent)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 
getSmallestWidthDpForBounds(Rect bounds)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 
initSnapAlgorithmForRotations()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 
loadDimens()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 
onConfigurationChanged()231     void onConfigurationChanged() {
232         loadDimens();
233     }
234 
isResizing()235     boolean isResizing() {
236         return mResizing;
237     }
238 
getContentWidth()239     int getContentWidth() {
240         return mDividerWindowWidth - 2 * mDividerInsets;
241     }
242 
getContentInsets()243     int getContentInsets() {
244         return mDividerInsets;
245     }
246 
getContentWidthInactive()247     int getContentWidthInactive() {
248         return mDividerWindowWidthInactive;
249     }
250 
setResizing(boolean resizing)251     void setResizing(boolean resizing) {
252         if (mResizing != resizing) {
253             mResizing = resizing;
254             resetDragResizingChangeReported();
255         }
256     }
257 
setTouchRegion(Rect touchRegion)258     void setTouchRegion(Rect touchRegion) {
259         mTouchRegion.set(touchRegion);
260     }
261 
getTouchRegion(Rect outRegion)262     void getTouchRegion(Rect outRegion) {
263         outRegion.set(mTouchRegion);
264         outRegion.offset(mWindow.getFrameLw().left, mWindow.getFrameLw().top);
265     }
266 
resetDragResizingChangeReported()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 
setWindow(WindowState window)274     void setWindow(WindowState window) {
275         mWindow = window;
276         reevaluateVisibility(false);
277     }
278 
reevaluateVisibility(boolean force)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 
wasVisible()297     boolean wasVisible() {
298         return mLastVisibility;
299     }
300 
setAdjustedForIme( boolean adjustedForIme, boolean adjustedForDivider, boolean animate, WindowState imeWin, int imeHeight)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 
getImeHeightAdjustedFor()318     int getImeHeightAdjustedFor() {
319         return mImeHeight;
320     }
321 
positionDockedStackedDivider(Rect frame)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 
notifyDockedDividerVisibilityChanged(boolean visible)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 
notifyDockedStackExistsChanged(boolean exists)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      */
resetImeHideRequested()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      */
isImeHideRequested()410     boolean isImeHideRequested() {
411         return mImeHideRequested;
412     }
413 
notifyDockedStackMinimizedChanged(boolean minimizedDock, long animDuration)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 
notifyDockSideChanged(int newDockSide)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 
notifyAdjustedForImeChanged(boolean adjustedForIme, long animDuration)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 
registerDockedStackListener(IDockedStackListener listener)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 
setResizeDimLayer(boolean visible, int targetStackId, float alpha)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      */
notifyAppVisibilityChanged()491     void notifyAppVisibilityChanged() {
492         checkMinimizeChanged(false /* animate */);
493     }
494 
notifyAppTransitionStarting()495     void notifyAppTransitionStarting() {
496         checkMinimizeChanged(true /* animate */);
497     }
498 
isMinimizedDock()499     boolean isMinimizedDock() {
500         return mMinimizedDock;
501     }
502 
checkMinimizeChanged(boolean animate)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 
isWithinDisplay(Task task)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      */
setMinimizedDockedStack(boolean minimizedDock, boolean animate)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 
clearImeAdjustAnimation()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 
startAdjustAnimation(float from, float to)572     private void startAdjustAnimation(float from, float to) {
573         mAnimatingForMinimizedDockedStack = true;
574         mAnimationStarted = false;
575         mAnimationStart = from;
576         mAnimationTarget = to;
577     }
578 
startImeAdjustAnimation( boolean adjustedForIme, boolean adjustedForDivider, WindowState imeWin)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 
setMinimizedDockedStack(boolean minimized)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 
isAnimationMaximizing()648     private boolean isAnimationMaximizing() {
649         return mAnimationTarget == 0f;
650     }
651 
animate(long now)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 
animateForIme(long now)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 
animateForMinimizedDockedStack(long now)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 
getInterpolatedAnimationValue(float t)742     private float getInterpolatedAnimationValue(float t) {
743         return t * mAnimationTarget + (1 - t) * mAnimationStart;
744     }
745 
getInterpolatedDividerValue(float t)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      */
getMinimizeAmount(TaskStack stack, float t)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      */
adjustMaximizeAmount(TaskStack stack, float t, float naturalAmount)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      */
getClipRevealMeetFraction(TaskStack stack)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
dimFullscreen()799     public boolean dimFullscreen() {
800         return false;
801     }
802 
803     @Override
getDisplayInfo()804     public DisplayInfo getDisplayInfo() {
805         return mDisplayContent.getDisplayInfo();
806     }
807 
808     @Override
getDimBounds(Rect outBounds)809     public void getDimBounds(Rect outBounds) {
810         // This dim layer user doesn't need this.
811     }
812 
813     @Override
toShortString()814     public String toShortString() {
815         return TAG;
816     }
817 
getWindow()818     WindowState getWindow() {
819         return mWindow;
820     }
821 
dump(String prefix, PrintWriter pw)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 }
834