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

   1 /*
   2  * Copyright (C) 2014 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.view.WindowManager.LayoutParams.FLAG_SHOW_WALLPAPER;
  20 import static android.view.WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED;
  21
  22 import static android.view.WindowManager.LayoutParams.PRIVATE_FLAG_KEYGUARD;
  23 import static android.view.WindowManager.LayoutParams.PRIVATE_FLAG_SYSTEM_ERROR;
  24 import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_STARTING;
  25 import static com.android.server.wm.WindowManagerService.DEBUG_KEYGUARD;
  26 import static com.android.server.wm.WindowManagerService.LayoutFields.SET_UPDATE_ROTATION;
  27 import static com.android.server.wm.WindowManagerService.LayoutFields.SET_WALLPAPER_MAY_CHANGE;
  28 import static com.android.server.wm.WindowManagerService.LayoutFields.SET_FORCE_HIDING_CHANGED;
  29 import static com.android.server.wm.WindowManagerService.LayoutFields.SET_ORIENTATION_CHANGE_COMPLETE;
  30 import static com.android.server.wm.WindowManagerService.LayoutFields.SET_WALLPAPER_ACTION_PENDING;
  31
  32 import android.content.Context;
  33 import android.os.Debug;
  34 import android.os.SystemClock;
  35 import android.util.Slog;
  36 import android.util.SparseArray;
  37 import android.util.SparseIntArray;
  38 import android.util.TimeUtils;
  39 import android.view.Display;
  40 import android.view.SurfaceControl;
  41 import android.view.WindowManagerPolicy;
  42 import android.view.animation.AlphaAnimation;
  43 import android.view.animation.Animation;
  44
  45 import com.android.server.wm.WindowManagerService.LayoutFields;
  46
  47 import java.io.PrintWriter;
  48 import java.util.ArrayList;
  49
  50 /**
  51  * Singleton class that carries out the animations and Surface operations in a separate task
  52  * on behalf of WindowManagerService.
  53  */
  54 public class WindowAnimator {
  55     private static final String TAG = "WindowAnimator";
  56
  57     /** How long to give statusbar to clear the private keyguard flag when animating out */
  58     private static final long KEYGUARD_ANIM_TIMEOUT_MS = 1000;
  59
  60     final WindowManagerService mService;
  61     final Context mContext;
  62     final WindowManagerPolicy mPolicy;
  63
  64     boolean mAnimating;
  65
  66     final Runnable mAnimationRunnable;
  67
  68     /** Time of current animation step. Reset on each iteration */
  69     long mCurrentTime;
  70
  71     /** Skip repeated AppWindowTokens initialization. Note that AppWindowsToken's version of this
  72      * is a long initialized to Long.MIN_VALUE so that it doesn't match this value on startup. */
  73     private int mAnimTransactionSequence;
  74
  75     /** Window currently running an animation that has requested it be detached
  76      * from the wallpaper.  This means we need to ensure the wallpaper is
  77      * visible behind it in case it animates in a way that would allow it to be
  78      * seen. If multiple windows satisfy this, use the lowest window. */
  79     WindowState mWindowDetachedWallpaper = null;
  80
  81     WindowStateAnimator mUniverseBackground = null;
  82     int mAboveUniverseLayer = 0;
  83
  84     int mBulkUpdateParams = 0;
  85     Object mLastWindowFreezeSource;
  86
  87     SparseArray<DisplayContentsAnimator> mDisplayContentsAnimators =
  88             new SparseArray<DisplayContentsAnimator>(2);
  89
  90     boolean mInitialized = false;
  91
  92     boolean mKeyguardGoingAway;
  93     boolean mKeyguardGoingAwayToNotificationShade;
  94     boolean mKeyguardGoingAwayDisableWindowAnimations;
  95
  96     /** Use one animation for all entering activities after keyguard is dismissed. */
  97     Animation mPostKeyguardExitAnimation;
  98
  99     // forceHiding states.
 100     static final int KEYGUARD_NOT_SHOWN     = 0;
 101     static final int KEYGUARD_ANIMATING_IN  = 1;
 102     static final int KEYGUARD_SHOWN         = 2;
 103     static final int KEYGUARD_ANIMATING_OUT = 3;
 104     int mForceHiding = KEYGUARD_NOT_SHOWN;
 105
 106     private String forceHidingToString() {
 107         switch (mForceHiding) {
 108             case KEYGUARD_NOT_SHOWN:    return "KEYGUARD_NOT_SHOWN";
 109             case KEYGUARD_ANIMATING_IN: return "KEYGUARD_ANIMATING_IN";
 110             case KEYGUARD_SHOWN:        return "KEYGUARD_SHOWN";
 111             case KEYGUARD_ANIMATING_OUT:return "KEYGUARD_ANIMATING_OUT";
 112             default: return "KEYGUARD STATE UNKNOWN " + mForceHiding;
 113         }
 114     }
 115
 116     WindowAnimator(final WindowManagerService service) {
 117         mService = service;
 118         mContext = service.mContext;
 119         mPolicy = service.mPolicy;
 120
 121         mAnimationRunnable = new Runnable() {
 122             @Override
 123             public void run() {
 124                 synchronized (mService.mWindowMap) {
 125                     mService.mAnimationScheduled = false;
 126                     animateLocked();
 127                 }
 128             }
 129         };
 130     }
 131
 132     void addDisplayLocked(final int displayId) {
 133         // Create the DisplayContentsAnimator object by retrieving it.
 134         getDisplayContentsAnimatorLocked(displayId);
 135         if (displayId == Display.DEFAULT_DISPLAY) {
 136             mInitialized = true;
 137         }
 138     }
 139
 140     void removeDisplayLocked(final int displayId) {
 141         final DisplayContentsAnimator displayAnimator = mDisplayContentsAnimators.get(displayId);
 142         if (displayAnimator != null) {
 143             if (displayAnimator.mScreenRotationAnimation != null) {
 144                 displayAnimator.mScreenRotationAnimation.kill();
 145                 displayAnimator.mScreenRotationAnimation = null;
 146             }
 147         }
 148
 149         mDisplayContentsAnimators.delete(displayId);
 150     }
 151
 152     void hideWallpapersLocked(final WindowState w) {
 153         final WindowState wallpaperTarget = mService.mWallpaperTarget;
 154         final WindowState lowerWallpaperTarget = mService.mLowerWallpaperTarget;
 155         final ArrayList<WindowToken> wallpaperTokens = mService.mWallpaperTokens;
 156
 157         if ((wallpaperTarget == w && lowerWallpaperTarget == null) || wallpaperTarget == null) {
 158             final int numTokens = wallpaperTokens.size();
 159             for (int i = numTokens - 1; i >= 0; i--) {
 160                 final WindowToken token = wallpaperTokens.get(i);
 161                 final int numWindows = token.windows.size();
 162                 for (int j = numWindows - 1; j >= 0; j--) {
 163                     final WindowState wallpaper = token.windows.get(j);
 164                     final WindowStateAnimator winAnimator = wallpaper.mWinAnimator;
 165                     if (!winAnimator.mLastHidden) {
 166                         winAnimator.hide();
 167                         mService.dispatchWallpaperVisibility(wallpaper, false);
 168                         setPendingLayoutChanges(Display.DEFAULT_DISPLAY,
 169                                 WindowManagerPolicy.FINISH_LAYOUT_REDO_WALLPAPER);
 170                     }
 171                 }
 172                 if (WindowManagerService.DEBUG_WALLPAPER_LIGHT && !token.hidden) Slog.d(TAG,
 173                         "Hiding wallpaper " + token + " from " + w
 174                         + " target=" + wallpaperTarget + " lower=" + lowerWallpaperTarget
 175                         + "\n" + Debug.getCallers(5, "  "));
 176                 token.hidden = true;
 177             }
 178         }
 179     }
 180
 181     private void updateAppWindowsLocked(int displayId) {
 182         ArrayList<TaskStack> stacks = mService.getDisplayContentLocked(displayId).getStacks();
 183         for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
 184             final TaskStack stack = stacks.get(stackNdx);
 185             final ArrayList<Task> tasks = stack.getTasks();
 186             for (int taskNdx = tasks.size() - 1; taskNdx >= 0; --taskNdx) {
 187                 final AppTokenList tokens = tasks.get(taskNdx).mAppTokens;
 188                 for (int tokenNdx = tokens.size() - 1; tokenNdx >= 0; --tokenNdx) {
 189                     final AppWindowAnimator appAnimator = tokens.get(tokenNdx).mAppAnimator;
 190                     final boolean wasAnimating = appAnimator.animation != null
 191                             && appAnimator.animation != AppWindowAnimator.sDummyAnimation;
 192                     if (appAnimator.stepAnimationLocked(mCurrentTime)) {
 193                         mAnimating = true;
 194                     } else if (wasAnimating) {
 195                         // stopped animating, do one more pass through the layout
 196                         setAppLayoutChanges(appAnimator,
 197                                 WindowManagerPolicy.FINISH_LAYOUT_REDO_WALLPAPER,
 198                                 "appToken " + appAnimator.mAppToken + " done");
 199                         if (WindowManagerService.DEBUG_ANIM) Slog.v(TAG,
 200                                 "updateWindowsApps...: done animating " + appAnimator.mAppToken);
 201                     }
 202                 }
 203             }
 204
 205             final AppTokenList exitingAppTokens = stack.mExitingAppTokens;
 206             final int NEAT = exitingAppTokens.size();
 207             for (int i = 0; i < NEAT; i++) {
 208                 final AppWindowAnimator appAnimator = exitingAppTokens.get(i).mAppAnimator;
 209                 final boolean wasAnimating = appAnimator.animation != null
 210                         && appAnimator.animation != AppWindowAnimator.sDummyAnimation;
 211                 if (appAnimator.stepAnimationLocked(mCurrentTime)) {
 212                     mAnimating = true;
 213                 } else if (wasAnimating) {
 214                     // stopped animating, do one more pass through the layout
 215                     setAppLayoutChanges(appAnimator, WindowManagerPolicy.FINISH_LAYOUT_REDO_WALLPAPER,
 216                         "exiting appToken " + appAnimator.mAppToken + " done");
 217                     if (WindowManagerService.DEBUG_ANIM) Slog.v(TAG,
 218                             "updateWindowsApps...: done animating exiting " + appAnimator.mAppToken);
 219                 }
 220             }
 221         }
 222     }
 223
 224     private boolean shouldForceHide(WindowState win) {
 225         final WindowState imeTarget = mService.mInputMethodTarget;
 226         final boolean showImeOverKeyguard = imeTarget != null && imeTarget.isVisibleNow() &&
 227                 (imeTarget.getAttrs().flags & FLAG_SHOW_WHEN_LOCKED) != 0;
 228
 229         final WindowState winShowWhenLocked = (WindowState) mPolicy.getWinShowWhenLockedLw();
 230         final AppWindowToken appShowWhenLocked = winShowWhenLocked == null ?
 231                 null : winShowWhenLocked.mAppToken;
 232         final boolean hideWhenLocked =
 233                 !(((win.mIsImWindow || imeTarget == win) && showImeOverKeyguard)
 234                         || (appShowWhenLocked != null && (appShowWhenLocked == win.mAppToken ||
 235                         // Show error dialogs over apps that dismiss keyguard.
 236                         (win.mAttrs.privateFlags & PRIVATE_FLAG_SYSTEM_ERROR) != 0)));
 237         return ((mForceHiding == KEYGUARD_ANIMATING_IN)
 238                 && (!win.mWinAnimator.isAnimating() || hideWhenLocked))
 239                 || ((mForceHiding == KEYGUARD_SHOWN) && hideWhenLocked);
 240     }
 241
 242     private void updateWindowsLocked(final int displayId) {
 243         ++mAnimTransactionSequence;
 244
 245         final WindowList windows = mService.getWindowListLocked(displayId);
 246
 247         if (mKeyguardGoingAway) {
 248             for (int i = windows.size() - 1; i >= 0; i--) {
 249                 WindowState win = windows.get(i);
 250                 if (!mPolicy.isKeyguardHostWindow(win.mAttrs)) {
 251                     continue;
 252                 }
 253                 final WindowStateAnimator winAnimator = win.mWinAnimator;
 254                 if ((win.mAttrs.privateFlags & PRIVATE_FLAG_KEYGUARD) != 0) {
 255                     if (!winAnimator.mAnimating) {
 256                         if (DEBUG_KEYGUARD) Slog.d(TAG,
 257                                 "updateWindowsLocked: creating delay animation");
 258
 259                         // Create a new animation to delay until keyguard is gone on its own.
 260                         winAnimator.mAnimation = new AlphaAnimation(1.0f, 1.0f);
 261                         winAnimator.mAnimation.setDuration(KEYGUARD_ANIM_TIMEOUT_MS);
 262                         winAnimator.mAnimationIsEntrance = false;
 263                         winAnimator.mAnimationStartTime = -1;
 264                     }
 265                 } else {
 266                     if (DEBUG_KEYGUARD) Slog.d(TAG,
 267                             "updateWindowsLocked: StatusBar is no longer keyguard");
 268                     mKeyguardGoingAway = false;
 269                     winAnimator.clearAnimation();
 270                 }
 271                 break;
 272             }
 273         }
 274
 275         mForceHiding = KEYGUARD_NOT_SHOWN;
 276
 277         boolean wallpaperInUnForceHiding = false;
 278         boolean startingInUnForceHiding = false;
 279         ArrayList<WindowStateAnimator> unForceHiding = null;
 280         WindowState wallpaper = null;
 281         for (int i = windows.size() - 1; i >= 0; i--) {
 282             WindowState win = windows.get(i);
 283             WindowStateAnimator winAnimator = win.mWinAnimator;
 284             final int flags = win.mAttrs.flags;
 285             boolean canBeForceHidden = mPolicy.canBeForceHidden(win, win.mAttrs);
 286             boolean shouldBeForceHidden = shouldForceHide(win);
 287             if (winAnimator.mSurfaceControl != null) {
 288                 final boolean wasAnimating = winAnimator.mWasAnimating;
 289                 final boolean nowAnimating = winAnimator.stepAnimationLocked(mCurrentTime);
 290                 mAnimating |= nowAnimating;
 291
 292                 if (WindowManagerService.DEBUG_WALLPAPER) {
 293                     Slog.v(TAG, win + ": wasAnimating=" + wasAnimating +
 294                             ", nowAnimating=" + nowAnimating);
 295                 }
 296
 297                 if (wasAnimating && !winAnimator.mAnimating && mService.mWallpaperTarget == win) {
 298                     mBulkUpdateParams |= SET_WALLPAPER_MAY_CHANGE;
 299                     setPendingLayoutChanges(Display.DEFAULT_DISPLAY,
 300                             WindowManagerPolicy.FINISH_LAYOUT_REDO_WALLPAPER);
 301                     if (WindowManagerService.DEBUG_LAYOUT_REPEATS) {
 302                         mService.debugLayoutRepeats("updateWindowsAndWallpaperLocked 2",
 303                                 getPendingLayoutChanges(Display.DEFAULT_DISPLAY));
 304                     }
 305                 }
 306
 307                 if (mPolicy.isForceHiding(win.mAttrs)) {
 308                     if (!wasAnimating && nowAnimating) {
 309                         if (DEBUG_KEYGUARD || WindowManagerService.DEBUG_ANIM ||
 310                                 WindowManagerService.DEBUG_VISIBILITY) Slog.v(TAG,
 311                                 "Animation started that could impact force hide: " + win);
 312                         mBulkUpdateParams |= SET_FORCE_HIDING_CHANGED;
 313                         setPendingLayoutChanges(displayId,
 314                                 WindowManagerPolicy.FINISH_LAYOUT_REDO_WALLPAPER);
 315                         if (WindowManagerService.DEBUG_LAYOUT_REPEATS) {
 316                             mService.debugLayoutRepeats("updateWindowsAndWallpaperLocked 3",
 317                                     getPendingLayoutChanges(displayId));
 318                         }
 319                         mService.mFocusMayChange = true;
 320                     } else if (mKeyguardGoingAway && !nowAnimating) {
 321                         // Timeout!!
 322                         Slog.e(TAG, "Timeout waiting for animation to startup");
 323                         mPolicy.startKeyguardExitAnimation(0, 0);
 324                         mKeyguardGoingAway = false;
 325                     }
 326                     if (win.isReadyForDisplay()) {
 327                         if (nowAnimating) {
 328                             if (winAnimator.mAnimationIsEntrance) {
 329                                 mForceHiding = KEYGUARD_ANIMATING_IN;
 330                             } else {
 331                                 mForceHiding = KEYGUARD_ANIMATING_OUT;
 332                             }
 333                         } else {
 334                             mForceHiding = win.isDrawnLw() ? KEYGUARD_SHOWN : KEYGUARD_NOT_SHOWN;
 335                         }
 336                     }
 337                     if (DEBUG_KEYGUARD || WindowManagerService.DEBUG_VISIBILITY) Slog.v(TAG,
 338                             "Force hide " + forceHidingToString()
 339                             + " hasSurface=" + win.mHasSurface
 340                             + " policyVis=" + win.mPolicyVisibility
 341                             + " destroying=" + win.mDestroying
 342                             + " attHidden=" + win.mAttachedHidden
 343                             + " vis=" + win.mViewVisibility
 344                             + " hidden=" + win.mRootToken.hidden
 345                             + " anim=" + win.mWinAnimator.mAnimation);
 346                 } else if (canBeForceHidden) {
 347                     if (shouldBeForceHidden) {
 348                         if (!win.hideLw(false, false)) {
 349                             // Was already hidden
 350                             continue;
 351                         }
 352                         if (DEBUG_KEYGUARD || WindowManagerService.DEBUG_VISIBILITY) Slog.v(TAG,
 353                                 "Now policy hidden: " + win);
 354                     } else {
 355                         boolean applyExistingExitAnimation = mPostKeyguardExitAnimation != null
 356                                 && !winAnimator.mKeyguardGoingAwayAnimation
 357                                 && win.hasDrawnLw()
 358                                 && win.mAttachedWindow == null
 359                                 && mForceHiding != KEYGUARD_NOT_SHOWN;
 360
 361                         // If the window is already showing and we don't need to apply an existing
 362                         // Keyguard exit animation, skip.
 363                         if (!win.showLw(false, false) && !applyExistingExitAnimation) {
 364                             continue;
 365                         }
 366                         final boolean visibleNow = win.isVisibleNow();
 367                         if (!visibleNow) {
 368                             // Couldn't really show, must showLw() again when win becomes visible.
 369                             win.hideLw(false, false);
 370                             continue;
 371                         }
 372                         if (DEBUG_KEYGUARD || WindowManagerService.DEBUG_VISIBILITY) Slog.v(TAG,
 373                                 "Now policy shown: " + win);
 374                         if ((mBulkUpdateParams & SET_FORCE_HIDING_CHANGED) != 0
 375                                 && win.mAttachedWindow == null) {
 376                             if (unForceHiding == null) {
 377                                 unForceHiding = new ArrayList<>();
 378                             }
 379                             unForceHiding.add(winAnimator);
 380                             if ((flags & FLAG_SHOW_WALLPAPER) != 0) {
 381                                 wallpaperInUnForceHiding = true;
 382                             }
 383                             if (win.mAttrs.type == TYPE_APPLICATION_STARTING) {
 384                                 startingInUnForceHiding = true;
 385                             }
 386                         } else if (applyExistingExitAnimation) {
 387                             // We're already in the middle of an animation. Use the existing
 388                             // animation to bring in this window.
 389                             if (DEBUG_KEYGUARD) Slog.v(TAG,
 390                                     "Applying existing Keyguard exit animation to new window: win="
 391                                             + win);
 392                             Animation a = mPolicy.createForceHideEnterAnimation(
 393                                     false, mKeyguardGoingAwayToNotificationShade);
 394                             winAnimator.setAnimation(a, mPostKeyguardExitAnimation.getStartTime());
 395                             winAnimator.mKeyguardGoingAwayAnimation = true;
 396                         }
 397                         final WindowState currentFocus = mService.mCurrentFocus;
 398                         if (currentFocus == null || currentFocus.mLayer < win.mLayer) {
 399                             // We are showing on top of the current
 400                             // focus, so re-evaluate focus to make
 401                             // sure it is correct.
 402                             if (WindowManagerService.DEBUG_FOCUS_LIGHT) Slog.v(TAG,
 403                                     "updateWindowsLocked: setting mFocusMayChange true");
 404                             mService.mFocusMayChange = true;
 405                         }
 406                     }
 407                     if ((flags & FLAG_SHOW_WALLPAPER) != 0) {
 408                         mBulkUpdateParams |= SET_WALLPAPER_MAY_CHANGE;
 409                         setPendingLayoutChanges(Display.DEFAULT_DISPLAY,
 410                                 WindowManagerPolicy.FINISH_LAYOUT_REDO_WALLPAPER);
 411                         if (WindowManagerService.DEBUG_LAYOUT_REPEATS) {
 412                             mService.debugLayoutRepeats("updateWindowsAndWallpaperLocked 4",
 413                                     getPendingLayoutChanges(Display.DEFAULT_DISPLAY));
 414                         }
 415                     }
 416                 }
 417             }
 418
 419             // If the window doesn't have a surface, the only thing we care about is the correct
 420             // policy visibility.
 421             else if (canBeForceHidden) {
 422                 if (shouldBeForceHidden) {
 423                     win.hideLw(false, false);
 424                 } else {
 425                     win.showLw(false, false);
 426                 }
 427             }
 428
 429             final AppWindowToken atoken = win.mAppToken;
 430             if (winAnimator.mDrawState == WindowStateAnimator.READY_TO_SHOW) {
 431                 if (atoken == null || atoken.allDrawn) {
 432                     if (winAnimator.performShowLocked()) {
 433                         setPendingLayoutChanges(displayId,
 434                                 WindowManagerPolicy.FINISH_LAYOUT_REDO_ANIM);
 435                         if (WindowManagerService.DEBUG_LAYOUT_REPEATS) {
 436                             mService.debugLayoutRepeats("updateWindowsAndWallpaperLocked 5",
 437                                     getPendingLayoutChanges(displayId));
 438                         }
 439                     }
 440                 }
 441             }
 442             final AppWindowAnimator appAnimator = winAnimator.mAppAnimator;
 443             if (appAnimator != null && appAnimator.thumbnail != null) {
 444                 if (appAnimator.thumbnailTransactionSeq != mAnimTransactionSequence) {
 445                     appAnimator.thumbnailTransactionSeq = mAnimTransactionSequence;
 446                     appAnimator.thumbnailLayer = 0;
 447                 }
 448                 if (appAnimator.thumbnailLayer < winAnimator.mAnimLayer) {
 449                     appAnimator.thumbnailLayer = winAnimator.mAnimLayer;
 450                 }
 451             }
 452             if (win.mIsWallpaper) {
 453                 wallpaper = win;
 454             }
 455         } // end forall windows
 456
 457         // If we have windows that are being show due to them no longer
 458         // being force-hidden, apply the appropriate animation to them if animations are not
 459         // disabled.
 460         if (unForceHiding != null) {
 461             if (!mKeyguardGoingAwayDisableWindowAnimations) {
 462                 boolean first = true;
 463                 for (int i=unForceHiding.size()-1; i>=0; i--) {
 464                     final WindowStateAnimator winAnimator = unForceHiding.get(i);
 465                     Animation a = mPolicy.createForceHideEnterAnimation(
 466                             wallpaperInUnForceHiding && !startingInUnForceHiding,
 467                             mKeyguardGoingAwayToNotificationShade);
 468                     if (a != null) {
 469                         if (DEBUG_KEYGUARD) Slog.v(TAG,
 470                                 "Starting keyguard exit animation on window " + winAnimator.mWin);
 471                         winAnimator.setAnimation(a);
 472                         winAnimator.mKeyguardGoingAwayAnimation = true;
 473                         if (first) {
 474                             mPostKeyguardExitAnimation = a;
 475                             mPostKeyguardExitAnimation.setStartTime(mCurrentTime);
 476                             first = false;
 477                         }
 478                     }
 479                 }
 480             } else if (mKeyguardGoingAway) {
 481                 mPolicy.startKeyguardExitAnimation(mCurrentTime, 0 /* duration */);
 482                 mKeyguardGoingAway = false;
 483             }
 484
 485
 486             // Wallpaper is going away in un-force-hide motion, animate it as well.
 487             if (!wallpaperInUnForceHiding && wallpaper != null
 488                     && !mKeyguardGoingAwayDisableWindowAnimations) {
 489                 if (DEBUG_KEYGUARD) Slog.d(TAG, "updateWindowsLocked: wallpaper animating away");
 490                 Animation a = mPolicy.createForceHideWallpaperExitAnimation(
 491                         mKeyguardGoingAwayToNotificationShade);
 492                 if (a != null) {
 493                     wallpaper.mWinAnimator.setAnimation(a);
 494                 }
 495             }
 496         }
 497
 498         if (mPostKeyguardExitAnimation != null) {
 499             // We're in the midst of a keyguard exit animation.
 500             if (mKeyguardGoingAway) {
 501                 mPolicy.startKeyguardExitAnimation(mCurrentTime +
 502                         mPostKeyguardExitAnimation.getStartOffset(),
 503                         mPostKeyguardExitAnimation.getDuration());
 504                 mKeyguardGoingAway = false;
 505             } else if (mCurrentTime - mPostKeyguardExitAnimation.getStartTime()
 506                     > mPostKeyguardExitAnimation.getDuration()) {
 507                 // Done with the animation, reset.
 508                 if (DEBUG_KEYGUARD) Slog.v(TAG, "Done with Keyguard exit animations.");
 509                 mPostKeyguardExitAnimation = null;
 510             }
 511         }
 512     }
 513
 514     private void updateWallpaperLocked(int displayId) {
 515         mService.getDisplayContentLocked(displayId).resetAnimationBackgroundAnimator();
 516
 517         final WindowList windows = mService.getWindowListLocked(displayId);
 518         WindowState detachedWallpaper = null;
 519
 520         for (int i = windows.size() - 1; i >= 0; i--) {
 521             final WindowState win = windows.get(i);
 522             WindowStateAnimator winAnimator = win.mWinAnimator;
 523             if (winAnimator.mSurfaceControl == null) {
 524                 continue;
 525             }
 526
 527             final int flags = win.mAttrs.flags;
 528
 529             // If this window is animating, make a note that we have
 530             // an animating window and take care of a request to run
 531             // a detached wallpaper animation.
 532             if (winAnimator.mAnimating) {
 533                 if (winAnimator.mAnimation != null) {
 534                     if ((flags & FLAG_SHOW_WALLPAPER) != 0
 535                             && winAnimator.mAnimation.getDetachWallpaper()) {
 536                         detachedWallpaper = win;
 537                     }
 538                     final int color = winAnimator.mAnimation.getBackgroundColor();
 539                     if (color != 0) {
 540                         final TaskStack stack = win.getStack();
 541                         if (stack != null) {
 542                             stack.setAnimationBackground(winAnimator, color);
 543                         }
 544                     }
 545                 }
 546                 mAnimating = true;
 547             }
 548
 549             // If this window's app token is running a detached wallpaper
 550             // animation, make a note so we can ensure the wallpaper is
 551             // displayed behind it.
 552             final AppWindowAnimator appAnimator = winAnimator.mAppAnimator;
 553             if (appAnimator != null && appAnimator.animation != null
 554                     && appAnimator.animating) {
 555                 if ((flags & FLAG_SHOW_WALLPAPER) != 0
 556                         && appAnimator.animation.getDetachWallpaper()) {
 557                     detachedWallpaper = win;
 558                 }
 559
 560                 final int color = appAnimator.animation.getBackgroundColor();
 561                 if (color != 0) {
 562                     final TaskStack stack = win.getStack();
 563                     if (stack != null) {
 564                         stack.setAnimationBackground(winAnimator, color);
 565                     }
 566                 }
 567             }
 568         } // end forall windows
 569
 570         if (mWindowDetachedWallpaper != detachedWallpaper) {
 571             if (WindowManagerService.DEBUG_WALLPAPER) Slog.v(TAG,
 572                     "Detached wallpaper changed from " + mWindowDetachedWallpaper
 573                     + " to " + detachedWallpaper);
 574             mWindowDetachedWallpaper = detachedWallpaper;
 575             mBulkUpdateParams |= SET_WALLPAPER_MAY_CHANGE;
 576         }
 577     }
 578
 579     /** See if any windows have been drawn, so they (and others associated with them) can now be
 580      *  shown. */
 581     private void testTokenMayBeDrawnLocked(int displayId) {
 582         // See if any windows have been drawn, so they (and others
 583         // associated with them) can now be shown.
 584         final ArrayList<Task> tasks = mService.getDisplayContentLocked(displayId).getTasks();
 585         final int numTasks = tasks.size();
 586         for (int taskNdx = 0; taskNdx < numTasks; ++taskNdx) {
 587             final AppTokenList tokens = tasks.get(taskNdx).mAppTokens;
 588             final int numTokens = tokens.size();
 589             for (int tokenNdx = 0; tokenNdx < numTokens; ++tokenNdx) {
 590                 final AppWindowToken wtoken = tokens.get(tokenNdx);
 591                 AppWindowAnimator appAnimator = wtoken.mAppAnimator;
 592                 final boolean allDrawn = wtoken.allDrawn;
 593                 if (allDrawn != appAnimator.allDrawn) {
 594                     appAnimator.allDrawn = allDrawn;
 595                     if (allDrawn) {
 596                         // The token has now changed state to having all
 597                         // windows shown...  what to do, what to do?
 598                         if (appAnimator.freezingScreen) {
 599                             appAnimator.showAllWindowsLocked();
 600                             mService.unsetAppFreezingScreenLocked(wtoken, false, true);
 601                             if (WindowManagerService.DEBUG_ORIENTATION) Slog.i(TAG,
 602                                     "Setting mOrientationChangeComplete=true because wtoken "
 603                                     + wtoken + " numInteresting=" + wtoken.numInterestingWindows
 604                                     + " numDrawn=" + wtoken.numDrawnWindows);
 605                             // This will set mOrientationChangeComplete and cause a pass through layout.
 606                             setAppLayoutChanges(appAnimator,
 607                                     WindowManagerPolicy.FINISH_LAYOUT_REDO_WALLPAPER,
 608                                     "testTokenMayBeDrawnLocked: freezingScreen");
 609                         } else {
 610                             setAppLayoutChanges(appAnimator,
 611                                     WindowManagerPolicy.FINISH_LAYOUT_REDO_ANIM,
 612                                     "testTokenMayBeDrawnLocked");
 613
 614                             // We can now show all of the drawn windows!
 615                             if (!mService.mOpeningApps.contains(wtoken)) {
 616                                 mAnimating |= appAnimator.showAllWindowsLocked();
 617                             }
 618                         }
 619                     }
 620                 }
 621             }
 622         }
 623     }
 624
 625
 626     /** Locked on mService.mWindowMap. */
 627     private void animateLocked() {
 628         if (!mInitialized) {
 629             return;
 630         }
 631
 632         mCurrentTime = SystemClock.uptimeMillis();
 633         mBulkUpdateParams = SET_ORIENTATION_CHANGE_COMPLETE;
 634         boolean wasAnimating = mAnimating;
 635         mAnimating = false;
 636         if (WindowManagerService.DEBUG_WINDOW_TRACE) {
 637             Slog.i(TAG, "!!! animate: entry time=" + mCurrentTime);
 638         }
 639
 640         if (WindowManagerService.SHOW_TRANSACTIONS) Slog.i(
 641                 TAG, ">>> OPEN TRANSACTION animateLocked");
 642         SurfaceControl.openTransaction();
 643         SurfaceControl.setAnimationTransaction();
 644         try {
 645             final int numDisplays = mDisplayContentsAnimators.size();
 646             for (int i = 0; i < numDisplays; i++) {
 647                 final int displayId = mDisplayContentsAnimators.keyAt(i);
 648                 updateAppWindowsLocked(displayId);
 649                 DisplayContentsAnimator displayAnimator = mDisplayContentsAnimators.valueAt(i);
 650
 651                 final ScreenRotationAnimation screenRotationAnimation =
 652                         displayAnimator.mScreenRotationAnimation;
 653                 if (screenRotationAnimation != null && screenRotationAnimation.isAnimating()) {
 654                     if (screenRotationAnimation.stepAnimationLocked(mCurrentTime)) {
 655                         mAnimating = true;
 656                     } else {
 657                         mBulkUpdateParams |= SET_UPDATE_ROTATION;
 658                         screenRotationAnimation.kill();
 659                         displayAnimator.mScreenRotationAnimation = null;
 660
 661                         //TODO (multidisplay): Accessibility supported only for the default display.
 662                         if (mService.mAccessibilityController != null
 663                                 && displayId == Display.DEFAULT_DISPLAY) {
 664                             // We just finished rotation animation which means we did not
 665                             // anounce the rotation and waited for it to end, announce now.
 666                             mService.mAccessibilityController.onRotationChangedLocked(
 667                                     mService.getDefaultDisplayContentLocked(), mService.mRotation);
 668                         }
 669                     }
 670                 }
 671
 672                 // Update animations of all applications, including those
 673                 // associated with exiting/removed apps
 674                 updateWindowsLocked(displayId);
 675                 updateWallpaperLocked(displayId);
 676
 677                 final WindowList windows = mService.getWindowListLocked(displayId);
 678                 final int N = windows.size();
 679                 for (int j = 0; j < N; j++) {
 680                     windows.get(j).mWinAnimator.prepareSurfaceLocked(true);
 681                 }
 682             }
 683
 684             for (int i = 0; i < numDisplays; i++) {
 685                 final int displayId = mDisplayContentsAnimators.keyAt(i);
 686
 687                 testTokenMayBeDrawnLocked(displayId);
 688
 689                 final ScreenRotationAnimation screenRotationAnimation =
 690                         mDisplayContentsAnimators.valueAt(i).mScreenRotationAnimation;
 691                 if (screenRotationAnimation != null) {
 692                     screenRotationAnimation.updateSurfacesInTransaction();
 693                 }
 694
 695                 mAnimating |= mService.getDisplayContentLocked(displayId).animateDimLayers();
 696
 697                 //TODO (multidisplay): Magnification is supported only for the default display.
 698                 if (mService.mAccessibilityController != null
 699                         && displayId == Display.DEFAULT_DISPLAY) {
 700                     mService.mAccessibilityController.drawMagnifiedRegionBorderIfNeededLocked();
 701                 }
 702             }
 703
 704             if (mAnimating) {
 705                 mService.scheduleAnimationLocked();
 706             }
 707
 708             mService.setFocusedStackLayer();
 709
 710             if (mService.mWatermark != null) {
 711                 mService.mWatermark.drawIfNeeded();
 712             }
 713         } catch (RuntimeException e) {
 714             Slog.wtf(TAG, "Unhandled exception in Window Manager", e);
 715         } finally {
 716             SurfaceControl.closeTransaction();
 717             if (WindowManagerService.SHOW_TRANSACTIONS) Slog.i(
 718                     TAG, "<<< CLOSE TRANSACTION animateLocked");
 719         }
 720
 721         boolean hasPendingLayoutChanges = false;
 722         final int numDisplays = mService.mDisplayContents.size();
 723         for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
 724             final DisplayContent displayContent = mService.mDisplayContents.valueAt(displayNdx);
 725             final int pendingChanges = getPendingLayoutChanges(displayContent.getDisplayId());
 726             if ((pendingChanges & WindowManagerPolicy.FINISH_LAYOUT_REDO_WALLPAPER) != 0) {
 727                 mBulkUpdateParams |= SET_WALLPAPER_ACTION_PENDING;
 728             }
 729             if (pendingChanges != 0) {
 730                 hasPendingLayoutChanges = true;
 731             }
 732         }
 733
 734         boolean doRequest = false;
 735         if (mBulkUpdateParams != 0) {
 736             doRequest = mService.copyAnimToLayoutParamsLocked();
 737         }
 738
 739         if (hasPendingLayoutChanges || doRequest) {
 740             mService.requestTraversalLocked();
 741         }
 742
 743         if (!mAnimating && wasAnimating) {
 744             mService.requestTraversalLocked();
 745         }
 746         if (WindowManagerService.DEBUG_WINDOW_TRACE) {
 747             Slog.i(TAG, "!!! animate: exit mAnimating=" + mAnimating
 748                 + " mBulkUpdateParams=" + Integer.toHexString(mBulkUpdateParams)
 749                 + " mPendingLayoutChanges(DEFAULT_DISPLAY)="
 750                 + Integer.toHexString(getPendingLayoutChanges(Display.DEFAULT_DISPLAY)));
 751         }
 752     }
 753
 754     static String bulkUpdateParamsToString(int bulkUpdateParams) {
 755         StringBuilder builder = new StringBuilder(128);
 756         if ((bulkUpdateParams & LayoutFields.SET_UPDATE_ROTATION) != 0) {
 757             builder.append(" UPDATE_ROTATION");
 758         }
 759         if ((bulkUpdateParams & LayoutFields.SET_WALLPAPER_MAY_CHANGE) != 0) {
 760             builder.append(" WALLPAPER_MAY_CHANGE");
 761         }
 762         if ((bulkUpdateParams & LayoutFields.SET_FORCE_HIDING_CHANGED) != 0) {
 763             builder.append(" FORCE_HIDING_CHANGED");
 764         }
 765         if ((bulkUpdateParams & LayoutFields.SET_ORIENTATION_CHANGE_COMPLETE) != 0) {
 766             builder.append(" ORIENTATION_CHANGE_COMPLETE");
 767         }
 768         if ((bulkUpdateParams & LayoutFields.SET_TURN_ON_SCREEN) != 0) {
 769             builder.append(" TURN_ON_SCREEN");
 770         }
 771         return builder.toString();
 772     }
 773
 774     public void dumpLocked(PrintWriter pw, String prefix, boolean dumpAll) {
 775         final String subPrefix = "  " + prefix;
 776         final String subSubPrefix = "  " + subPrefix;
 777
 778         for (int i = 0; i < mDisplayContentsAnimators.size(); i++) {
 779             pw.print(prefix); pw.print("DisplayContentsAnimator #");
 780                     pw.print(mDisplayContentsAnimators.keyAt(i));
 781                     pw.println(":");
 782             DisplayContentsAnimator displayAnimator = mDisplayContentsAnimators.valueAt(i);
 783             final WindowList windows =
 784                     mService.getWindowListLocked(mDisplayContentsAnimators.keyAt(i));
 785             final int N = windows.size();
 786             for (int j = 0; j < N; j++) {
 787                 WindowStateAnimator wanim = windows.get(j).mWinAnimator;
 788                 pw.print(subPrefix); pw.print("Window #"); pw.print(j);
 789                         pw.print(": "); pw.println(wanim);
 790             }
 791             if (displayAnimator.mScreenRotationAnimation != null) {
 792                 pw.print(subPrefix); pw.println("mScreenRotationAnimation:");
 793                 displayAnimator.mScreenRotationAnimation.printTo(subSubPrefix, pw);
 794             } else if (dumpAll) {
 795                 pw.print(subPrefix); pw.println("no ScreenRotationAnimation ");
 796             }
 797         }
 798
 799         pw.println();
 800
 801         if (dumpAll) {
 802             pw.print(prefix); pw.print("mAnimTransactionSequence=");
 803                     pw.print(mAnimTransactionSequence);
 804                     pw.print(" mForceHiding="); pw.println(forceHidingToString());
 805             pw.print(prefix); pw.print("mCurrentTime=");
 806                     pw.println(TimeUtils.formatUptime(mCurrentTime));
 807         }
 808         if (mBulkUpdateParams != 0) {
 809             pw.print(prefix); pw.print("mBulkUpdateParams=0x");
 810                     pw.print(Integer.toHexString(mBulkUpdateParams));
 811                     pw.println(bulkUpdateParamsToString(mBulkUpdateParams));
 812         }
 813         if (mWindowDetachedWallpaper != null) {
 814             pw.print(prefix); pw.print("mWindowDetachedWallpaper=");
 815                 pw.println(mWindowDetachedWallpaper);
 816         }
 817         if (mUniverseBackground != null) {
 818             pw.print(prefix); pw.print("mUniverseBackground="); pw.print(mUniverseBackground);
 819                     pw.print(" mAboveUniverseLayer="); pw.println(mAboveUniverseLayer);
 820         }
 821     }
 822
 823     int getPendingLayoutChanges(final int displayId) {
 824         if (displayId < 0) {
 825             return 0;
 826         }
 827         DisplayContent displayContent = mService.getDisplayContentLocked(displayId);
 828         return (displayContent != null) ? displayContent.pendingLayoutChanges : 0;
 829     }
 830
 831     void setPendingLayoutChanges(final int displayId, final int changes) {
 832         if (displayId >= 0) {
 833             DisplayContent displayContent = mService.getDisplayContentLocked(displayId);
 834             if (displayContent != null) {
 835                 displayContent.pendingLayoutChanges |= changes;
 836             }
 837         }
 838     }
 839
 840     void setAppLayoutChanges(final AppWindowAnimator appAnimator, final int changes, String s) {
 841         // Used to track which displays layout changes have been done.
 842         SparseIntArray displays = new SparseIntArray(2);
 843         WindowList windows = appAnimator.mAppToken.allAppWindows;
 844         for (int i = windows.size() - 1; i >= 0; i--) {
 845             final int displayId = windows.get(i).getDisplayId();
 846             if (displayId >= 0 && displays.indexOfKey(displayId) < 0) {
 847                 setPendingLayoutChanges(displayId, changes);
 848                 if (WindowManagerService.DEBUG_LAYOUT_REPEATS) {
 849                     mService.debugLayoutRepeats(s, getPendingLayoutChanges(displayId));
 850                 }
 851                 // Keep from processing this display again.
 852                 displays.put(displayId, changes);
 853             }
 854         }
 855     }
 856
 857     private DisplayContentsAnimator getDisplayContentsAnimatorLocked(int displayId) {
 858         DisplayContentsAnimator displayAnimator = mDisplayContentsAnimators.get(displayId);
 859         if (displayAnimator == null) {
 860             displayAnimator = new DisplayContentsAnimator();
 861             mDisplayContentsAnimators.put(displayId, displayAnimator);
 862         }
 863         return displayAnimator;
 864     }
 865
 866     void setScreenRotationAnimationLocked(int displayId, ScreenRotationAnimation animation) {
 867         if (displayId >= 0) {
 868             getDisplayContentsAnimatorLocked(displayId).mScreenRotationAnimation = animation;
 869         }
 870     }
 871
 872     ScreenRotationAnimation getScreenRotationAnimationLocked(int displayId) {
 873         if (displayId < 0) {
 874             return null;
 875         }
 876         return getDisplayContentsAnimatorLocked(displayId).mScreenRotationAnimation;
 877     }
 878
 879     private class DisplayContentsAnimator {
 880         ScreenRotationAnimation mScreenRotationAnimation = null;
 881     }
 882 }