Craig Mautner | c2c0a61 | 2014-02-20 20:25:41 -0800 | [diff] [blame] | 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 | */ |
Craig Mautner | 764983d | 2012-03-22 11:37:36 -0700 | [diff] [blame] | 16 | |
| 17 | package com.android.server.wm; |
| 18 | |
Filip Gruszczynski | 0bd180d | 2015-12-07 15:43:52 -0800 | [diff] [blame] | 19 | import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_WINDOW_TRACE; |
| 20 | import static com.android.server.wm.WindowManagerDebugConfig.SHOW_TRANSACTIONS; |
| 21 | import static com.android.server.wm.WindowManagerDebugConfig.TAG_WITH_CLASS_NAME; |
| 22 | import static com.android.server.wm.WindowManagerDebugConfig.TAG_WM; |
Filip Gruszczynski | 4501d23 | 2015-09-02 13:00:02 -0700 | [diff] [blame] | 23 | import static com.android.server.wm.WindowSurfacePlacer.SET_ORIENTATION_CHANGE_COMPLETE; |
Filip Gruszczynski | 78a08ee | 2015-11-08 18:04:32 -0800 | [diff] [blame] | 24 | import static com.android.server.wm.WindowSurfacePlacer.SET_UPDATE_ROTATION; |
Craig Mautner | a608b88 | 2012-03-30 13:03:49 -0700 | [diff] [blame] | 25 | |
Craig Mautner | 764983d | 2012-03-22 11:37:36 -0700 | [diff] [blame] | 26 | import android.content.Context; |
Jorim Jaggi | d9cabc5 | 2015-10-27 09:38:16 -0700 | [diff] [blame] | 27 | import android.os.Trace; |
Craig Mautner | 764983d | 2012-03-22 11:37:36 -0700 | [diff] [blame] | 28 | import android.util.Slog; |
Craig Mautner | a91f9e2 | 2012-09-14 16:22:08 -0700 | [diff] [blame] | 29 | import android.util.SparseArray; |
Dianne Hackborn | 529e744 | 2012-11-01 14:22:28 -0700 | [diff] [blame] | 30 | import android.util.TimeUtils; |
Filip Gruszczynski | 78a08ee | 2015-11-08 18:04:32 -0800 | [diff] [blame] | 31 | import android.view.Choreographer; |
Robert Carr | ae606b4 | 2018-02-15 15:36:23 -0800 | [diff] [blame] | 32 | import android.view.SurfaceControl; |
Craig Mautner | 764983d | 2012-03-22 11:37:36 -0700 | [diff] [blame] | 33 | |
Jorim Jaggi | ed7993b | 2017-03-28 18:50:01 +0100 | [diff] [blame] | 34 | import com.android.server.AnimationThread; |
Adrian Roos | e99bc05 | 2017-11-20 17:55:31 +0100 | [diff] [blame] | 35 | import com.android.server.policy.WindowManagerPolicy; |
Jorim Jaggi | d6d6de6 | 2017-03-31 15:05:13 +0200 | [diff] [blame] | 36 | |
Craig Mautner | e7ae250 | 2012-03-26 17:11:19 -0700 | [diff] [blame] | 37 | import java.io.PrintWriter; |
Jorim Jaggi | a384403 | 2018-01-03 15:54:43 +0100 | [diff] [blame] | 38 | import java.util.ArrayList; |
Craig Mautner | e7ae250 | 2012-03-26 17:11:19 -0700 | [diff] [blame] | 39 | |
Craig Mautner | 764983d | 2012-03-22 11:37:36 -0700 | [diff] [blame] | 40 | /** |
Craig Mautner | 764983d | 2012-03-22 11:37:36 -0700 | [diff] [blame] | 41 | * Singleton class that carries out the animations and Surface operations in a separate task |
| 42 | * on behalf of WindowManagerService. |
| 43 | */ |
| 44 | public class WindowAnimator { |
Filip Gruszczynski | 0bd180d | 2015-12-07 15:43:52 -0800 | [diff] [blame] | 45 | private static final String TAG = TAG_WITH_CLASS_NAME ? "WindowAnimator" : TAG_WM; |
Craig Mautner | 764983d | 2012-03-22 11:37:36 -0700 | [diff] [blame] | 46 | |
| 47 | final WindowManagerService mService; |
| 48 | final Context mContext; |
| 49 | final WindowManagerPolicy mPolicy; |
| 50 | |
Jorim Jaggi | 3787561 | 2015-02-19 21:05:31 +0100 | [diff] [blame] | 51 | /** Is any window animating? */ |
Wale Ogunwale | 69cf50f | 2015-11-13 11:08:36 -0800 | [diff] [blame] | 52 | private boolean mAnimating; |
Jorim Jaggi | b0fc817 | 2017-11-23 17:04:08 +0000 | [diff] [blame] | 53 | private boolean mLastRootAnimating; |
Craig Mautner | 01cd0e7 | 2012-06-18 10:19:11 -0700 | [diff] [blame] | 54 | |
Riley Andrews | 6d35416 | 2014-11-19 15:21:52 -0800 | [diff] [blame] | 55 | final Choreographer.FrameCallback mAnimationFrameCallback; |
Craig Mautner | 1caa399 | 2012-06-22 09:46:48 -0700 | [diff] [blame] | 56 | |
Craig Mautner | 764983d | 2012-03-22 11:37:36 -0700 | [diff] [blame] | 57 | /** Time of current animation step. Reset on each iteration */ |
| 58 | long mCurrentTime; |
| 59 | |
Craig Mautner | a608b88 | 2012-03-30 13:03:49 -0700 | [diff] [blame] | 60 | int mBulkUpdateParams = 0; |
Dianne Hackborn | a57c695 | 2013-03-29 14:46:40 -0700 | [diff] [blame] | 61 | Object mLastWindowFreezeSource; |
Craig Mautner | a608b88 | 2012-03-30 13:03:49 -0700 | [diff] [blame] | 62 | |
Filip Gruszczynski | 4501d23 | 2015-09-02 13:00:02 -0700 | [diff] [blame] | 63 | SparseArray<DisplayContentsAnimator> mDisplayContentsAnimators = new SparseArray<>(2); |
Craig Mautner | d09cc4b | 2012-04-04 10:23:31 -0700 | [diff] [blame] | 64 | |
Jorim Jaggi | 4130a68 | 2018-01-09 14:28:44 +0100 | [diff] [blame] | 65 | private boolean mInitialized = false; |
Craig Mautner | b47bbc3 | 2012-08-22 17:41:48 -0700 | [diff] [blame] | 66 | |
Filip Gruszczynski | 78a08ee | 2015-11-08 18:04:32 -0800 | [diff] [blame] | 67 | // When set to true the animator will go over all windows after an animation frame is posted and |
| 68 | // check if some got replaced and can be removed. |
| 69 | private boolean mRemoveReplacedWindows = false; |
| 70 | |
Jorim Jaggi | ed7993b | 2017-03-28 18:50:01 +0100 | [diff] [blame] | 71 | private Choreographer mChoreographer; |
Jorim Jaggi | ed7993b | 2017-03-28 18:50:01 +0100 | [diff] [blame] | 72 | |
Jorim Jaggi | 561eeb5 | 2017-04-28 16:39:19 +0200 | [diff] [blame] | 73 | /** |
| 74 | * Indicates whether we have an animation frame callback scheduled, which will happen at |
| 75 | * vsync-app and then schedule the animation tick at the right time (vsync-sf). |
| 76 | */ |
| 77 | private boolean mAnimationFrameCallbackScheduled; |
| 78 | |
Jorim Jaggi | a384403 | 2018-01-03 15:54:43 +0100 | [diff] [blame] | 79 | /** |
| 80 | * A list of runnable that need to be run after {@link WindowContainer#prepareSurfaces} is |
| 81 | * executed and the corresponding transaction is closed and applied. |
| 82 | */ |
| 83 | private final ArrayList<Runnable> mAfterPrepareSurfacesRunnables = new ArrayList<>(); |
Chavi Weingarten | 16d0d07 | 2018-02-12 23:50:28 +0000 | [diff] [blame] | 84 | private boolean mInExecuteAfterPrepareSurfacesRunnables; |
Jorim Jaggi | a384403 | 2018-01-03 15:54:43 +0100 | [diff] [blame] | 85 | |
Robert Carr | ae606b4 | 2018-02-15 15:36:23 -0800 | [diff] [blame] | 86 | private final SurfaceControl.Transaction mTransaction = new SurfaceControl.Transaction(); |
| 87 | |
Craig Mautner | 918b53b | 2012-07-09 14:15:54 -0700 | [diff] [blame] | 88 | WindowAnimator(final WindowManagerService service) { |
Craig Mautner | 764983d | 2012-03-22 11:37:36 -0700 | [diff] [blame] | 89 | mService = service; |
Craig Mautner | 918b53b | 2012-07-09 14:15:54 -0700 | [diff] [blame] | 90 | mContext = service.mContext; |
| 91 | mPolicy = service.mPolicy; |
Jorim Jaggi | ed7993b | 2017-03-28 18:50:01 +0100 | [diff] [blame] | 92 | AnimationThread.getHandler().runWithScissors( |
Jorim Jaggi | 34a0cdb | 2017-06-08 15:40:38 -0700 | [diff] [blame] | 93 | () -> mChoreographer = Choreographer.getSfInstance(), 0 /* timeout */); |
Craig Mautner | 1caa399 | 2012-06-22 09:46:48 -0700 | [diff] [blame] | 94 | |
Jorim Jaggi | d6d6de6 | 2017-03-31 15:05:13 +0200 | [diff] [blame] | 95 | mAnimationFrameCallback = frameTimeNs -> { |
Wale Ogunwale | db485de | 2018-10-29 09:47:07 -0700 | [diff] [blame] | 96 | synchronized (mService.mGlobalLock) { |
Jorim Jaggi | 561eeb5 | 2017-04-28 16:39:19 +0200 | [diff] [blame] | 97 | mAnimationFrameCallbackScheduled = false; |
Jorim Jaggi | 561eeb5 | 2017-04-28 16:39:19 +0200 | [diff] [blame] | 98 | } |
Jorim Jaggi | 34a0cdb | 2017-06-08 15:40:38 -0700 | [diff] [blame] | 99 | animate(frameTimeNs); |
Jorim Jaggi | d6d6de6 | 2017-03-31 15:05:13 +0200 | [diff] [blame] | 100 | }; |
Craig Mautner | b47bbc3 | 2012-08-22 17:41:48 -0700 | [diff] [blame] | 101 | } |
Craig Mautner | 9e80944 | 2012-06-22 17:13:04 -0700 | [diff] [blame] | 102 | |
Craig Mautner | a91f9e2 | 2012-09-14 16:22:08 -0700 | [diff] [blame] | 103 | void addDisplayLocked(final int displayId) { |
Bryce Lee | d187126 | 2017-06-12 14:12:29 -0700 | [diff] [blame] | 104 | // Create the DisplayContentsAnimator object by retrieving it if the associated |
| 105 | // {@link DisplayContent} exists. |
Craig Mautner | ac439e5 | 2012-09-21 08:58:34 -0700 | [diff] [blame] | 106 | getDisplayContentsAnimatorLocked(displayId); |
Craig Mautner | a91f9e2 | 2012-09-14 16:22:08 -0700 | [diff] [blame] | 107 | } |
| 108 | |
| 109 | void removeDisplayLocked(final int displayId) { |
Craig Mautner | d5523dc | 2012-10-02 13:49:22 -0700 | [diff] [blame] | 110 | final DisplayContentsAnimator displayAnimator = mDisplayContentsAnimators.get(displayId); |
| 111 | if (displayAnimator != null) { |
Craig Mautner | d5523dc | 2012-10-02 13:49:22 -0700 | [diff] [blame] | 112 | if (displayAnimator.mScreenRotationAnimation != null) { |
| 113 | displayAnimator.mScreenRotationAnimation.kill(); |
| 114 | displayAnimator.mScreenRotationAnimation = null; |
| 115 | } |
Craig Mautner | d5523dc | 2012-10-02 13:49:22 -0700 | [diff] [blame] | 116 | } |
| 117 | |
Craig Mautner | a91f9e2 | 2012-09-14 16:22:08 -0700 | [diff] [blame] | 118 | mDisplayContentsAnimators.delete(displayId); |
Craig Mautner | 1caa399 | 2012-06-22 09:46:48 -0700 | [diff] [blame] | 119 | } |
| 120 | |
Riddle Hsu | f53da81 | 2018-08-15 22:00:27 +0800 | [diff] [blame] | 121 | void ready() { |
| 122 | mInitialized = true; |
| 123 | } |
| 124 | |
Jorim Jaggi | 9b19fd4 | 2017-05-11 16:27:06 +0200 | [diff] [blame] | 125 | /** |
| 126 | * DO NOT HOLD THE WINDOW MANAGER LOCK WHILE CALLING THIS METHOD. Reason: the method closes |
| 127 | * an animation transaction, that might be blocking until the next sf-vsync, so we want to make |
| 128 | * sure other threads can make progress if this happens. |
| 129 | */ |
| 130 | private void animate(long frameTimeNs) { |
Craig Mautner | a91f9e2 | 2012-09-14 16:22:08 -0700 | [diff] [blame] | 131 | |
Wale Ogunwale | db485de | 2018-10-29 09:47:07 -0700 | [diff] [blame] | 132 | synchronized (mService.mGlobalLock) { |
Jorim Jaggi | 836dac4 | 2017-08-08 15:12:20 +0200 | [diff] [blame] | 133 | if (!mInitialized) { |
| 134 | return; |
| 135 | } |
Svetoslav | b180d77 | 2014-09-10 22:07:19 -0700 | [diff] [blame] | 136 | |
Jorim Jaggi | 836dac4 | 2017-08-08 15:12:20 +0200 | [diff] [blame] | 137 | // Schedule next frame already such that back-pressure happens continuously |
| 138 | scheduleAnimation(); |
| 139 | } |
Jorim Jaggi | 9b19fd4 | 2017-05-11 16:27:06 +0200 | [diff] [blame] | 140 | |
Wale Ogunwale | db485de | 2018-10-29 09:47:07 -0700 | [diff] [blame] | 141 | synchronized (mService.mGlobalLock) { |
Jorim Jaggi | 836dac4 | 2017-08-08 15:12:20 +0200 | [diff] [blame] | 142 | mCurrentTime = frameTimeNs / TimeUtils.NANOS_PER_MS; |
| 143 | mBulkUpdateParams = SET_ORIENTATION_CHANGE_COMPLETE; |
| 144 | mAnimating = false; |
Jorim Jaggi | 836dac4 | 2017-08-08 15:12:20 +0200 | [diff] [blame] | 145 | if (DEBUG_WINDOW_TRACE) { |
| 146 | Slog.i(TAG, "!!! animate: entry time=" + mCurrentTime); |
| 147 | } |
| 148 | |
| 149 | if (SHOW_TRANSACTIONS) Slog.i(TAG, ">>> OPEN TRANSACTION animate"); |
| 150 | mService.openSurfaceTransaction(); |
| 151 | try { |
Jorim Jaggi | 9b19fd4 | 2017-05-11 16:27:06 +0200 | [diff] [blame] | 152 | final AccessibilityController accessibilityController = |
| 153 | mService.mAccessibilityController; |
| 154 | final int numDisplays = mDisplayContentsAnimators.size(); |
| 155 | for (int i = 0; i < numDisplays; i++) { |
| 156 | final int displayId = mDisplayContentsAnimators.keyAt(i); |
Bryce Lee | f19cbe2 | 2018-02-02 15:09:21 -0800 | [diff] [blame] | 157 | final DisplayContent dc = mService.mRoot.getDisplayContent(displayId); |
Jorim Jaggi | 9b19fd4 | 2017-05-11 16:27:06 +0200 | [diff] [blame] | 158 | DisplayContentsAnimator displayAnimator = mDisplayContentsAnimators.valueAt(i); |
| 159 | |
| 160 | final ScreenRotationAnimation screenRotationAnimation = |
| 161 | displayAnimator.mScreenRotationAnimation; |
| 162 | if (screenRotationAnimation != null && screenRotationAnimation.isAnimating()) { |
| 163 | if (screenRotationAnimation.stepAnimationLocked(mCurrentTime)) { |
| 164 | setAnimating(true); |
| 165 | } else { |
| 166 | mBulkUpdateParams |= SET_UPDATE_ROTATION; |
| 167 | screenRotationAnimation.kill(); |
| 168 | displayAnimator.mScreenRotationAnimation = null; |
| 169 | |
Jorim Jaggi | 9b19fd4 | 2017-05-11 16:27:06 +0200 | [diff] [blame] | 170 | // display. |
Rhed Jao | 02655dc | 2018-10-30 20:44:52 +0800 | [diff] [blame] | 171 | if (accessibilityController != null) { |
Jorim Jaggi | 9b19fd4 | 2017-05-11 16:27:06 +0200 | [diff] [blame] | 172 | // We just finished rotation animation which means we did not |
| 173 | // announce the rotation and waited for it to end, announce now. |
Rhed Jao | 02655dc | 2018-10-30 20:44:52 +0800 | [diff] [blame] | 174 | accessibilityController.onRotationChangedLocked(dc); |
Jorim Jaggi | 9b19fd4 | 2017-05-11 16:27:06 +0200 | [diff] [blame] | 175 | } |
Svetoslav | b180d77 | 2014-09-10 22:07:19 -0700 | [diff] [blame] | 176 | } |
Craig Mautner | a91f9e2 | 2012-09-14 16:22:08 -0700 | [diff] [blame] | 177 | } |
Jorim Jaggi | 9b19fd4 | 2017-05-11 16:27:06 +0200 | [diff] [blame] | 178 | |
| 179 | // Update animations of all applications, including those |
| 180 | // associated with exiting/removed apps |
Jorim Jaggi | 8f52087 | 2018-08-14 17:00:20 +0200 | [diff] [blame] | 181 | dc.updateWindowsForAnimator(); |
| 182 | dc.updateBackgroundForAnimator(); |
Robert Carr | b1579c8 | 2017-09-05 14:54:47 -0700 | [diff] [blame] | 183 | dc.prepareSurfaces(); |
Jorim Jaggi | 9b19fd4 | 2017-05-11 16:27:06 +0200 | [diff] [blame] | 184 | } |
| 185 | |
| 186 | for (int i = 0; i < numDisplays; i++) { |
| 187 | final int displayId = mDisplayContentsAnimators.keyAt(i); |
Bryce Lee | f19cbe2 | 2018-02-02 15:09:21 -0800 | [diff] [blame] | 188 | final DisplayContent dc = mService.mRoot.getDisplayContent(displayId); |
Jorim Jaggi | 9b19fd4 | 2017-05-11 16:27:06 +0200 | [diff] [blame] | 189 | |
| 190 | dc.checkAppWindowsReadyToShow(); |
| 191 | |
| 192 | final ScreenRotationAnimation screenRotationAnimation = |
| 193 | mDisplayContentsAnimators.valueAt(i).mScreenRotationAnimation; |
| 194 | if (screenRotationAnimation != null) { |
Robert Carr | ae606b4 | 2018-02-15 15:36:23 -0800 | [diff] [blame] | 195 | screenRotationAnimation.updateSurfaces(mTransaction); |
Jorim Jaggi | 9b19fd4 | 2017-05-11 16:27:06 +0200 | [diff] [blame] | 196 | } |
Jorim Jaggi | 9b19fd4 | 2017-05-11 16:27:06 +0200 | [diff] [blame] | 197 | orAnimating(dc.getDockedDividerController().animate(mCurrentTime)); |
Rhed Jao | 02655dc | 2018-10-30 20:44:52 +0800 | [diff] [blame] | 198 | if (accessibilityController != null) { |
| 199 | accessibilityController.drawMagnifiedRegionBorderIfNeededLocked(displayId); |
Jorim Jaggi | 9b19fd4 | 2017-05-11 16:27:06 +0200 | [diff] [blame] | 200 | } |
Craig Mautner | a91f9e2 | 2012-09-14 16:22:08 -0700 | [diff] [blame] | 201 | } |
Craig Mautner | ea3a09a | 2012-09-04 09:49:35 -0700 | [diff] [blame] | 202 | |
Jorim Jaggi | 836dac4 | 2017-08-08 15:12:20 +0200 | [diff] [blame] | 203 | if (!mAnimating) { |
| 204 | cancelAnimation(); |
Svetoslav Ganov | 545252f | 2012-12-10 18:29:24 -0800 | [diff] [blame] | 205 | } |
Craig Mautner | 764983d | 2012-03-22 11:37:36 -0700 | [diff] [blame] | 206 | |
Jorim Jaggi | 9b19fd4 | 2017-05-11 16:27:06 +0200 | [diff] [blame] | 207 | if (mService.mWatermark != null) { |
| 208 | mService.mWatermark.drawIfNeeded(); |
| 209 | } |
Robert Carr | ae606b4 | 2018-02-15 15:36:23 -0800 | [diff] [blame] | 210 | |
| 211 | SurfaceControl.mergeToGlobalTransaction(mTransaction); |
Jorim Jaggi | 836dac4 | 2017-08-08 15:12:20 +0200 | [diff] [blame] | 212 | } catch (RuntimeException e) { |
| 213 | Slog.wtf(TAG, "Unhandled exception in Window Manager", e); |
| 214 | } finally { |
Adrian Roos | 111aff9 | 2017-09-27 18:11:46 +0200 | [diff] [blame] | 215 | mService.closeSurfaceTransaction("WindowAnimator"); |
Jorim Jaggi | 9b19fd4 | 2017-05-11 16:27:06 +0200 | [diff] [blame] | 216 | if (SHOW_TRANSACTIONS) Slog.i(TAG, "<<< CLOSE TRANSACTION animate"); |
Jorim Jaggi | a41b729 | 2017-05-11 23:50:34 +0200 | [diff] [blame] | 217 | } |
Jorim Jaggi | d9cabc5 | 2015-10-27 09:38:16 -0700 | [diff] [blame] | 218 | |
Jorim Jaggi | 9b19fd4 | 2017-05-11 16:27:06 +0200 | [diff] [blame] | 219 | boolean hasPendingLayoutChanges = mService.mRoot.hasPendingLayoutChanges(this); |
| 220 | boolean doRequest = false; |
| 221 | if (mBulkUpdateParams != 0) { |
| 222 | doRequest = mService.mRoot.copyAnimToLayoutParams(); |
Jorim Jaggi | d9cabc5 | 2015-10-27 09:38:16 -0700 | [diff] [blame] | 223 | } |
Chong Zhang | 97782b4 | 2015-10-07 16:01:23 -0700 | [diff] [blame] | 224 | |
Jorim Jaggi | 9b19fd4 | 2017-05-11 16:27:06 +0200 | [diff] [blame] | 225 | if (hasPendingLayoutChanges || doRequest) { |
Jorim Jaggi | 4130a68 | 2018-01-09 14:28:44 +0100 | [diff] [blame] | 226 | mService.mWindowPlacerLocked.requestTraversal(); |
Jorim Jaggi | 9b19fd4 | 2017-05-11 16:27:06 +0200 | [diff] [blame] | 227 | } |
Filip Gruszczynski | 78a08ee | 2015-11-08 18:04:32 -0800 | [diff] [blame] | 228 | |
Jorim Jaggi | b0fc817 | 2017-11-23 17:04:08 +0000 | [diff] [blame] | 229 | final boolean rootAnimating = mService.mRoot.isSelfOrChildAnimating(); |
| 230 | if (rootAnimating && !mLastRootAnimating) { |
Chong Zhang | 97782b4 | 2015-10-07 16:01:23 -0700 | [diff] [blame] | 231 | |
Jorim Jaggi | 9b19fd4 | 2017-05-11 16:27:06 +0200 | [diff] [blame] | 232 | // Usually app transitions but quite a load onto the system already (with all the |
| 233 | // things happening in app), so pause task snapshot persisting to not increase the |
| 234 | // load. |
| 235 | mService.mTaskSnapshotController.setPersisterPaused(true); |
Jorim Jaggi | dc9385a | 2017-05-13 02:00:31 +0200 | [diff] [blame] | 236 | Trace.asyncTraceBegin(Trace.TRACE_TAG_WINDOW_MANAGER, "animating", 0); |
Jorim Jaggi | 9b19fd4 | 2017-05-11 16:27:06 +0200 | [diff] [blame] | 237 | } |
Jorim Jaggi | b0fc817 | 2017-11-23 17:04:08 +0000 | [diff] [blame] | 238 | if (!rootAnimating && mLastRootAnimating) { |
Jorim Jaggi | 4130a68 | 2018-01-09 14:28:44 +0100 | [diff] [blame] | 239 | mService.mWindowPlacerLocked.requestTraversal(); |
Jorim Jaggi | 9b19fd4 | 2017-05-11 16:27:06 +0200 | [diff] [blame] | 240 | mService.mTaskSnapshotController.setPersisterPaused(false); |
Jorim Jaggi | dc9385a | 2017-05-13 02:00:31 +0200 | [diff] [blame] | 241 | Trace.asyncTraceEnd(Trace.TRACE_TAG_WINDOW_MANAGER, "animating", 0); |
Jorim Jaggi | 9b19fd4 | 2017-05-11 16:27:06 +0200 | [diff] [blame] | 242 | } |
| 243 | |
Jorim Jaggi | b0fc817 | 2017-11-23 17:04:08 +0000 | [diff] [blame] | 244 | mLastRootAnimating = rootAnimating; |
Jorim Jaggi | dc9385a | 2017-05-13 02:00:31 +0200 | [diff] [blame] | 245 | |
Jorim Jaggi | 9b19fd4 | 2017-05-11 16:27:06 +0200 | [diff] [blame] | 246 | if (mRemoveReplacedWindows) { |
| 247 | mService.mRoot.removeReplacedWindows(); |
| 248 | mRemoveReplacedWindows = false; |
| 249 | } |
| 250 | |
Jorim Jaggi | 9b19fd4 | 2017-05-11 16:27:06 +0200 | [diff] [blame] | 251 | mService.destroyPreservedSurfaceLocked(); |
Jorim Jaggi | 9b19fd4 | 2017-05-11 16:27:06 +0200 | [diff] [blame] | 252 | |
Jorim Jaggi | a384403 | 2018-01-03 15:54:43 +0100 | [diff] [blame] | 253 | executeAfterPrepareSurfacesRunnables(); |
Robert Carr | b1579c8 | 2017-09-05 14:54:47 -0700 | [diff] [blame] | 254 | |
Jorim Jaggi | 9b19fd4 | 2017-05-11 16:27:06 +0200 | [diff] [blame] | 255 | if (DEBUG_WINDOW_TRACE) { |
| 256 | Slog.i(TAG, "!!! animate: exit mAnimating=" + mAnimating |
| 257 | + " mBulkUpdateParams=" + Integer.toHexString(mBulkUpdateParams) |
lumark | a483f31 | 2018-11-20 15:24:05 +0800 | [diff] [blame] | 258 | + " hasPendingLayoutChanges=" + hasPendingLayoutChanges); |
Jorim Jaggi | 9b19fd4 | 2017-05-11 16:27:06 +0200 | [diff] [blame] | 259 | } |
Craig Mautner | 7d8df39 | 2012-04-06 15:26:23 -0700 | [diff] [blame] | 260 | } |
Craig Mautner | 764983d | 2012-03-22 11:37:36 -0700 | [diff] [blame] | 261 | } |
| 262 | |
Filip Gruszczynski | 4501d23 | 2015-09-02 13:00:02 -0700 | [diff] [blame] | 263 | private static String bulkUpdateParamsToString(int bulkUpdateParams) { |
Dianne Hackborn | 529e744 | 2012-11-01 14:22:28 -0700 | [diff] [blame] | 264 | StringBuilder builder = new StringBuilder(128); |
Filip Gruszczynski | 4501d23 | 2015-09-02 13:00:02 -0700 | [diff] [blame] | 265 | if ((bulkUpdateParams & WindowSurfacePlacer.SET_UPDATE_ROTATION) != 0) { |
Dianne Hackborn | 529e744 | 2012-11-01 14:22:28 -0700 | [diff] [blame] | 266 | builder.append(" UPDATE_ROTATION"); |
| 267 | } |
Filip Gruszczynski | 4501d23 | 2015-09-02 13:00:02 -0700 | [diff] [blame] | 268 | if ((bulkUpdateParams & WindowSurfacePlacer.SET_ORIENTATION_CHANGE_COMPLETE) != 0) { |
Dianne Hackborn | 529e744 | 2012-11-01 14:22:28 -0700 | [diff] [blame] | 269 | builder.append(" ORIENTATION_CHANGE_COMPLETE"); |
| 270 | } |
Dianne Hackborn | 529e744 | 2012-11-01 14:22:28 -0700 | [diff] [blame] | 271 | return builder.toString(); |
| 272 | } |
| 273 | |
Craig Mautner | a91f9e2 | 2012-09-14 16:22:08 -0700 | [diff] [blame] | 274 | public void dumpLocked(PrintWriter pw, String prefix, boolean dumpAll) { |
Dianne Hackborn | 529e744 | 2012-11-01 14:22:28 -0700 | [diff] [blame] | 275 | final String subPrefix = " " + prefix; |
| 276 | final String subSubPrefix = " " + subPrefix; |
| 277 | |
Dianne Hackborn | 529e744 | 2012-11-01 14:22:28 -0700 | [diff] [blame] | 278 | for (int i = 0; i < mDisplayContentsAnimators.size(); i++) { |
| 279 | pw.print(prefix); pw.print("DisplayContentsAnimator #"); |
| 280 | pw.print(mDisplayContentsAnimators.keyAt(i)); |
| 281 | pw.println(":"); |
Wale Ogunwale | 824ab5c | 2016-10-20 09:31:56 -0700 | [diff] [blame] | 282 | final DisplayContentsAnimator displayAnimator = mDisplayContentsAnimators.valueAt(i); |
| 283 | final DisplayContent dc = |
Bryce Lee | f19cbe2 | 2018-02-02 15:09:21 -0800 | [diff] [blame] | 284 | mService.mRoot.getDisplayContent(mDisplayContentsAnimators.keyAt(i)); |
Wale Ogunwale | 824ab5c | 2016-10-20 09:31:56 -0700 | [diff] [blame] | 285 | dc.dumpWindowAnimators(pw, subPrefix); |
Dianne Hackborn | 529e744 | 2012-11-01 14:22:28 -0700 | [diff] [blame] | 286 | if (displayAnimator.mScreenRotationAnimation != null) { |
| 287 | pw.print(subPrefix); pw.println("mScreenRotationAnimation:"); |
| 288 | displayAnimator.mScreenRotationAnimation.printTo(subSubPrefix, pw); |
| 289 | } else if (dumpAll) { |
| 290 | pw.print(subPrefix); pw.println("no ScreenRotationAnimation "); |
| 291 | } |
Craig Mautner | e7cfceb | 2015-02-04 15:57:06 -0800 | [diff] [blame] | 292 | pw.println(); |
Dianne Hackborn | 529e744 | 2012-11-01 14:22:28 -0700 | [diff] [blame] | 293 | } |
| 294 | |
| 295 | pw.println(); |
| 296 | |
| 297 | if (dumpAll) { |
Dianne Hackborn | 529e744 | 2012-11-01 14:22:28 -0700 | [diff] [blame] | 298 | pw.print(prefix); pw.print("mCurrentTime="); |
| 299 | pw.println(TimeUtils.formatUptime(mCurrentTime)); |
Dianne Hackborn | 529e744 | 2012-11-01 14:22:28 -0700 | [diff] [blame] | 300 | } |
| 301 | if (mBulkUpdateParams != 0) { |
| 302 | pw.print(prefix); pw.print("mBulkUpdateParams=0x"); |
| 303 | pw.print(Integer.toHexString(mBulkUpdateParams)); |
| 304 | pw.println(bulkUpdateParamsToString(mBulkUpdateParams)); |
| 305 | } |
Craig Mautner | e7ae250 | 2012-03-26 17:11:19 -0700 | [diff] [blame] | 306 | } |
Craig Mautner | bec53f7 | 2012-04-05 11:49:05 -0700 | [diff] [blame] | 307 | |
Craig Mautner | 66f78d7 | 2012-12-04 16:46:50 -0800 | [diff] [blame] | 308 | int getPendingLayoutChanges(final int displayId) { |
Craig Mautner | df88d73 | 2014-01-27 09:21:32 -0800 | [diff] [blame] | 309 | if (displayId < 0) { |
| 310 | return 0; |
| 311 | } |
Bryce Lee | f19cbe2 | 2018-02-02 15:09:21 -0800 | [diff] [blame] | 312 | final DisplayContent displayContent = mService.mRoot.getDisplayContent(displayId); |
Wale Ogunwale | f16a281 | 2015-04-01 11:23:15 -0700 | [diff] [blame] | 313 | return (displayContent != null) ? displayContent.pendingLayoutChanges : 0; |
Craig Mautner | 66f78d7 | 2012-12-04 16:46:50 -0800 | [diff] [blame] | 314 | } |
| 315 | |
Craig Mautner | 76a7165 | 2012-09-03 23:23:58 -0700 | [diff] [blame] | 316 | void setPendingLayoutChanges(final int displayId, final int changes) { |
Wale Ogunwale | f16a281 | 2015-04-01 11:23:15 -0700 | [diff] [blame] | 317 | if (displayId < 0) { |
| 318 | return; |
| 319 | } |
Bryce Lee | f19cbe2 | 2018-02-02 15:09:21 -0800 | [diff] [blame] | 320 | final DisplayContent displayContent = mService.mRoot.getDisplayContent(displayId); |
Wale Ogunwale | f16a281 | 2015-04-01 11:23:15 -0700 | [diff] [blame] | 321 | if (displayContent != null) { |
| 322 | displayContent.pendingLayoutChanges |= changes; |
Craig Mautner | df88d73 | 2014-01-27 09:21:32 -0800 | [diff] [blame] | 323 | } |
Craig Mautner | 76a7165 | 2012-09-03 23:23:58 -0700 | [diff] [blame] | 324 | } |
| 325 | |
Craig Mautner | a91f9e2 | 2012-09-14 16:22:08 -0700 | [diff] [blame] | 326 | private DisplayContentsAnimator getDisplayContentsAnimatorLocked(int displayId) { |
Bryce Lee | d187126 | 2017-06-12 14:12:29 -0700 | [diff] [blame] | 327 | if (displayId < 0) { |
| 328 | return null; |
| 329 | } |
| 330 | |
Craig Mautner | a91f9e2 | 2012-09-14 16:22:08 -0700 | [diff] [blame] | 331 | DisplayContentsAnimator displayAnimator = mDisplayContentsAnimators.get(displayId); |
Bryce Lee | d187126 | 2017-06-12 14:12:29 -0700 | [diff] [blame] | 332 | |
| 333 | // It is possible that this underlying {@link DisplayContent} has been removed. In this |
| 334 | // case, we do not want to create an animator associated with it as {link #animate} will |
| 335 | // fail. |
| 336 | if (displayAnimator == null && mService.mRoot.getDisplayContent(displayId) != null) { |
Craig Mautner | 05d2903 | 2013-05-03 13:40:13 -0700 | [diff] [blame] | 337 | displayAnimator = new DisplayContentsAnimator(); |
Craig Mautner | a91f9e2 | 2012-09-14 16:22:08 -0700 | [diff] [blame] | 338 | mDisplayContentsAnimators.put(displayId, displayAnimator); |
| 339 | } |
| 340 | return displayAnimator; |
| 341 | } |
| 342 | |
| 343 | void setScreenRotationAnimationLocked(int displayId, ScreenRotationAnimation animation) { |
Bryce Lee | d187126 | 2017-06-12 14:12:29 -0700 | [diff] [blame] | 344 | final DisplayContentsAnimator animator = getDisplayContentsAnimatorLocked(displayId); |
| 345 | |
| 346 | if (animator != null) { |
| 347 | animator.mScreenRotationAnimation = animation; |
Craig Mautner | df88d73 | 2014-01-27 09:21:32 -0800 | [diff] [blame] | 348 | } |
Craig Mautner | a91f9e2 | 2012-09-14 16:22:08 -0700 | [diff] [blame] | 349 | } |
| 350 | |
| 351 | ScreenRotationAnimation getScreenRotationAnimationLocked(int displayId) { |
Craig Mautner | df88d73 | 2014-01-27 09:21:32 -0800 | [diff] [blame] | 352 | if (displayId < 0) { |
| 353 | return null; |
| 354 | } |
Bryce Lee | d187126 | 2017-06-12 14:12:29 -0700 | [diff] [blame] | 355 | |
| 356 | DisplayContentsAnimator animator = getDisplayContentsAnimatorLocked(displayId); |
| 357 | return animator != null? animator.mScreenRotationAnimation : null; |
Craig Mautner | a91f9e2 | 2012-09-14 16:22:08 -0700 | [diff] [blame] | 358 | } |
| 359 | |
Filip Gruszczynski | 78a08ee | 2015-11-08 18:04:32 -0800 | [diff] [blame] | 360 | void requestRemovalOfReplacedWindows(WindowState win) { |
Filip Gruszczynski | 78a08ee | 2015-11-08 18:04:32 -0800 | [diff] [blame] | 361 | mRemoveReplacedWindows = true; |
| 362 | } |
| 363 | |
Jorim Jaggi | ed7993b | 2017-03-28 18:50:01 +0100 | [diff] [blame] | 364 | void scheduleAnimation() { |
Jorim Jaggi | 561eeb5 | 2017-04-28 16:39:19 +0200 | [diff] [blame] | 365 | if (!mAnimationFrameCallbackScheduled) { |
| 366 | mAnimationFrameCallbackScheduled = true; |
Jorim Jaggi | ed7993b | 2017-03-28 18:50:01 +0100 | [diff] [blame] | 367 | mChoreographer.postFrameCallback(mAnimationFrameCallback); |
| 368 | } |
| 369 | } |
| 370 | |
Jorim Jaggi | 836dac4 | 2017-08-08 15:12:20 +0200 | [diff] [blame] | 371 | private void cancelAnimation() { |
| 372 | if (mAnimationFrameCallbackScheduled) { |
| 373 | mAnimationFrameCallbackScheduled = false; |
| 374 | mChoreographer.removeFrameCallback(mAnimationFrameCallback); |
| 375 | } |
| 376 | } |
| 377 | |
Craig Mautner | ac439e5 | 2012-09-21 08:58:34 -0700 | [diff] [blame] | 378 | private class DisplayContentsAnimator { |
Craig Mautner | a91f9e2 | 2012-09-14 16:22:08 -0700 | [diff] [blame] | 379 | ScreenRotationAnimation mScreenRotationAnimation = null; |
| 380 | } |
Wale Ogunwale | 69cf50f | 2015-11-13 11:08:36 -0800 | [diff] [blame] | 381 | |
| 382 | boolean isAnimating() { |
| 383 | return mAnimating; |
| 384 | } |
| 385 | |
Jorim Jaggi | ed7993b | 2017-03-28 18:50:01 +0100 | [diff] [blame] | 386 | boolean isAnimationScheduled() { |
Jorim Jaggi | 34a0cdb | 2017-06-08 15:40:38 -0700 | [diff] [blame] | 387 | return mAnimationFrameCallbackScheduled; |
Jorim Jaggi | ed7993b | 2017-03-28 18:50:01 +0100 | [diff] [blame] | 388 | } |
| 389 | |
| 390 | Choreographer getChoreographer() { |
| 391 | return mChoreographer; |
| 392 | } |
| 393 | |
Wale Ogunwale | 69cf50f | 2015-11-13 11:08:36 -0800 | [diff] [blame] | 394 | void setAnimating(boolean animating) { |
| 395 | mAnimating = animating; |
| 396 | } |
| 397 | |
| 398 | void orAnimating(boolean animating) { |
| 399 | mAnimating |= animating; |
| 400 | } |
Jorim Jaggi | a384403 | 2018-01-03 15:54:43 +0100 | [diff] [blame] | 401 | |
| 402 | /** |
| 403 | * Adds a runnable to be executed after {@link WindowContainer#prepareSurfaces} is called and |
| 404 | * the corresponding transaction is closed and applied. |
| 405 | */ |
| 406 | void addAfterPrepareSurfacesRunnable(Runnable r) { |
Chavi Weingarten | 16d0d07 | 2018-02-12 23:50:28 +0000 | [diff] [blame] | 407 | // If runnables are already being handled in executeAfterPrepareSurfacesRunnable, then just |
| 408 | // immediately execute the runnable passed in. |
| 409 | if (mInExecuteAfterPrepareSurfacesRunnables) { |
| 410 | r.run(); |
| 411 | return; |
| 412 | } |
| 413 | |
Jorim Jaggi | a384403 | 2018-01-03 15:54:43 +0100 | [diff] [blame] | 414 | mAfterPrepareSurfacesRunnables.add(r); |
| 415 | scheduleAnimation(); |
| 416 | } |
| 417 | |
Chavi Weingarten | 16d0d07 | 2018-02-12 23:50:28 +0000 | [diff] [blame] | 418 | void executeAfterPrepareSurfacesRunnables() { |
| 419 | |
| 420 | // Don't even think about to start recursing! |
| 421 | if (mInExecuteAfterPrepareSurfacesRunnables) { |
| 422 | return; |
| 423 | } |
| 424 | mInExecuteAfterPrepareSurfacesRunnables = true; |
Jorim Jaggi | a384403 | 2018-01-03 15:54:43 +0100 | [diff] [blame] | 425 | |
| 426 | // Traverse in order they were added. |
| 427 | final int size = mAfterPrepareSurfacesRunnables.size(); |
| 428 | for (int i = 0; i < size; i++) { |
| 429 | mAfterPrepareSurfacesRunnables.get(i).run(); |
| 430 | } |
| 431 | mAfterPrepareSurfacesRunnables.clear(); |
Chavi Weingarten | 16d0d07 | 2018-02-12 23:50:28 +0000 | [diff] [blame] | 432 | mInExecuteAfterPrepareSurfacesRunnables = false; |
Jorim Jaggi | a384403 | 2018-01-03 15:54:43 +0100 | [diff] [blame] | 433 | } |
Craig Mautner | 764983d | 2012-03-22 11:37:36 -0700 | [diff] [blame] | 434 | } |