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