Android 13 WMS-动画流程_android13 apptransition

动画的类型如下

    @IntDef(flag = true, prefix = { "ANIMATION_TYPE_" }, value = {
            ANIMATION_TYPE_NONE,
            ANIMATION_TYPE_APP_TRANSITION,
            ANIMATION_TYPE_SCREEN_ROTATION,
            ANIMATION_TYPE_DIMMER,
            ANIMATION_TYPE_RECENTS,
            ANIMATION_TYPE_WINDOW_ANIMATION,
            ANIMATION_TYPE_INSETS_CONTROL,
            ANIMATION_TYPE_TOKEN_TRANSFORM,
            ANIMATION_TYPE_STARTING_REVEAL
    })

ANIMATION_TYPE_APP_TRANSITION动画

当点击一个二级页面时, 会有如下调用栈

动画的type = ANIMATION_TYPE_APP_TRANSITION

03-05 14:55:37.752  3059  3163 D jinyanmeianimation: SurfaceAnimator startAnimation mAnimation:com.android.server.wm.LocalAnimationAdapter@71444ae
03-05 14:55:37.752  3059  3163 D jinyanmeianimation: SurfaceAnimator startAnimation mLeash:Surface(name=Surface(name=ActivityRecord{8b5f0f2 u0 com.android.settings/.MainSettings} t76})/@0xaa929f3 - animation-leash of app_transition)/@0x9c116b0
03-05 14:55:37.752  3059  3163 D jinyanmeianimation: SurfaceAnimator startAnimation t:android.view.SurfaceControl$Transaction@8d14824
03-05 14:55:37.752  3059  3163 D jinyanmeianimation: SurfaceAnimator startAnimation type:1
03-05 14:55:37.752  3059  3163 D jinyanmeianimation: SurfaceAnimator startAnimation mInnerAnimationFinishedCallback:com.android.server.wm.SurfaceAnimator$$ExternalSyntheticLambda0@d22724f
03-05 14:55:37.752  3059  3163 D jinyanmeianimation: java.lang.RuntimeException: jinyanmeianimation
03-05 14:55:37.752  3059  3163 D jinyanmeianimation: 	at com.android.server.wm.SurfaceAnimator.startAnimation(SurfaceAnimator.java:200)
03-05 14:55:37.752  3059  3163 D jinyanmeianimation: 	at com.android.server.wm.WindowContainer.startAnimation(WindowContainer.java:2912)
03-05 14:55:37.752  3059  3163 D jinyanmeianimation: 	at com.android.server.wm.WindowContainer$AnimationRunnerBuilder.lambda$build$4$com-android-server-wm-WindowContainer$AnimationRunnerBuilder(WindowContainer.java:4257)
03-05 14:55:37.752  3059  3163 D jinyanmeianimation: 	at com.android.server.wm.WindowContainer$AnimationRunnerBuilder$$ExternalSyntheticLambda4.startAnimation(Unknown Source:7)
03-05 14:55:37.752  3059  3163 D jinyanmeianimation: 	at com.android.server.wm.WindowContainer.applyAnimationUnchecked(WindowContainer.java:3384)
03-05 14:55:37.752  3059  3163 D jinyanmeianimation: 	at com.android.server.wm.WindowContainer.applyAnimation(WindowContainer.java:3072)
03-05 14:55:37.752  3059  3163 D jinyanmeianimation: 	at com.android.server.wm.ActivityRecord.applyAnimation(ActivityRecord.java:6074)
03-05 14:55:37.752  3059  3163 D jinyanmeianimation: 	at com.android.server.wm.AppTransitionController.applyAnimations(AppTransitionController.java:876)
03-05 14:55:37.752  3059  3163 D jinyanmeianimation: 	at com.android.server.wm.AppTransitionController.applyAnimations(AppTransitionController.java:1083)
03-05 14:55:37.752  3059  3163 D jinyanmeianimation: 	at com.android.server.wm.AppTransitionController.handleAppTransitionReady(AppTransitionController.java:293)
03-05 14:55:37.752  3059  3163 D jinyanmeianimation: 	at com.android.server.wm.RootWindowContainer.checkAppTransitionReady(RootWindowContainer.java:1070)
03-05 14:55:37.752  3059  3163 D jinyanmeianimation: 	at com.android.server.wm.RootWindowContainer.performSurfacePlacementNoTrace(RootWindowContainer.java:937)
03-05 14:55:37.752  3059  3163 D jinyanmeianimation: 	at com.android.server.wm.RootWindowContainer.performSurfacePlacement(RootWindowContainer.java:877)
03-05 14:55:37.752  3059  3163 D jinyanmeianimation: 	at com.android.server.wm.WindowSurfacePlacer.performSurfacePlacementLoop(WindowSurfacePlacer.java:199)
03-05 14:55:37.752  3059  3163 D jinyanmeianimation: 	at com.android.server.wm.WindowSurfacePlacer.performSurfacePlacement(WindowSurfacePlacer.java:148)
03-05 14:55:37.752  3059  3163 D jinyanmeianimation: 	at com.android.server.wm.WindowSurfacePlacer.performSurfacePlacement(WindowSurfacePlacer.java:137)
03-05 14:55:37.752  3059  3163 D jinyanmeianimation: 	at com.android.server.wm.WindowSurfacePlacer$Traverser.run(WindowSurfacePlacer.java:79)
03-05 14:55:37.752  3059  3163 D jinyanmeianimation: 	at android.os.Handler.handleCallback(Handler.java:942)
03-05 14:55:37.752  3059  3163 D jinyanmeianimation: 	at android.os.Handler.dispatchMessage(Handler.java:99)
03-05 14:55:37.752  3059  3163 D jinyanmeianimation: 	at android.os.Looper.loopOnce(Looper.java:211)
03-05 14:55:37.752  3059  3163 D jinyanmeianimation: 	at android.os.Looper.loop(Looper.java:300)
03-05 14:55:37.752  3059  3163 D jinyanmeianimation: 	at android.os.HandlerThread.run(HandlerThread.java:67)

每次循环都要检查是否开始一个动画

void handleAppTransitionReady() {
183          mTempTransitionReasons.clear();
//        //检查app transition是否已经准备好
 
184          if (!transitionGoodToGo(mDisplayContent.mOpeningApps, mTempTransitionReasons)
185                  || !transitionGoodToGo(mDisplayContent.mChangingContainers, mTempTransitionReasons)
186                  || !transitionGoodToGoForTaskFragments()) {
187              return;
188          }
189          Trace.traceBegin(Trace.TRACE_TAG_WINDOW_MANAGER, "AppTransitionReady");
190  
191          ProtoLog.v(WM_DEBUG_APP_TRANSITIONS, "**** GOOD TO GO");
192          // TODO(b/205335975): Remove window which stuck in animatingExit status. Find actual cause.
193          mDisplayContent.forAllWindows(WindowState::cleanupAnimatingExitWindow,
194                  true /* traverseTopToBottom */);
195          // TODO(new-app-transition): Remove code using appTransition.getAppTransition()
196          final AppTransition appTransition = mDisplayContent.mAppTransition;
197  
198          mDisplayContent.mNoAnimationNotifyOnTransitionFinished.clear();
199  
200          appTransition.removeAppTransitionTimeoutCallbacks();
201  
202          mDisplayContent.mWallpaperMayChange = false;
203  
204          int appCount = mDisplayContent.mOpeningApps.size();
205          for (int i = 0; i < appCount; ++i) {
206              // Clearing the mAnimatingExit flag before entering animation. It's set to true if app
207              // window is removed, or window relayout to invisible. This also affects window
208              // visibility. We need to clear it *before* maybeUpdateTransitToWallpaper() as the
209              // transition selection depends on wallpaper target visibility.
210              mDisplayContent.mOpeningApps.valueAtUnchecked(i).clearAnimatingFlags();
211          }
212          appCount = mDisplayContent.mChangingContainers.size();
213          for (int i = 0; i < appCount; ++i) {
214              // Clearing for same reason as above.
215              final ActivityRecord activity = getAppFromContainer(
216                      mDisplayContent.mChangingContainers.valueAtUnchecked(i));
217              if (activity != null) {
218                  activity.clearAnimatingFlags();
219              }
220          }
221  
222          // Adjust wallpaper before we pull the lower/upper target, since pending changes
223          // (like the clearAnimatingFlags() above) might affect wallpaper target result.
224          // Or, the opening app window should be a wallpaper target.
225          mWallpaperControllerLocked.adjustWallpaperWindowsForAppTransitionIfNeeded(
226                  mDisplayContent.mOpeningApps);
227  
228          // Remove launcher from app transition animation while recents is running. Recents animation
229          // is managed outside of app transition framework, so we just need to commit visibility.
230          final boolean excludeLauncherFromAnimation =
231                  mDisplayContent.mOpeningApps.stream().anyMatch(
232                          (app) -> app.isAnimating(PARENTS, ANIMATION_TYPE_RECENTS))
233                  || mDisplayContent.mClosingApps.stream().anyMatch(
234                          (app) -> app.isAnimating(PARENTS, ANIMATION_TYPE_RECENTS));
235          final ArraySet<ActivityRecord> openingAppsForAnimation = getAppsForAnimation(
236                  mDisplayContent.mOpeningApps, excludeLauncherFromAnimation);
237          final ArraySet<ActivityRecord> closingAppsForAnimation = getAppsForAnimation(
238                  mDisplayContent.mClosingApps, excludeLauncherFromAnimation);
239  
240          @TransitionOldType final int transit = getTransitCompatType(
241                  mDisplayContent.mAppTransition, openingAppsForAnimation, closingAppsForAnimation,
242                  mDisplayContent.mChangingContainers,
243                  mWallpaperControllerLocked.getWallpaperTarget(), getOldWallpaper(),
244                  mDisplayContent.mSkipAppTransitionAnimation);
245          mDisplayContent.mSkipAppTransitionAnimation = false;
246  
247          ProtoLog.v(WM_DEBUG_APP_TRANSITIONS,
248                  "handleAppTransitionReady: displayId=%d appTransition={%s}"
249                  + " excludeLauncherFromAnimation=%b openingApps=[%s] closingApps=[%s] transit=%s",
250                  mDisplayContent.mDisplayId, appTransition.toString(), excludeLauncherFromAnimation,
251                  mDisplayContent.mOpeningApps, mDisplayContent.mClosingApps,
252                  AppTransition.appTransitionOldToString(transit));
253  
254          // Find the layout params of the top-most application window in the tokens, which is
255          // what will control the animation theme. If all closing windows are obscured, then there is
256          // no need to do an animation. This is the case, for example, when this transition is being
257          // done behind a dream window.
258          final ArraySet<Integer> activityTypes = collectActivityTypes(openingAppsForAnimation,
259                  closingAppsForAnimation, mDisplayContent.mChangingContainers);
//首先会获取当前需要opening和closing的app window列表（ActivityRecord类型）
260          final ActivityRecord animLpActivity = findAnimLayoutParamsToken(transit, activityTypes,
261                  openingAppsForAnimation, closingAppsForAnimation,
262                  mDisplayContent.mChangingContainers);
263          final ActivityRecord topOpeningApp =
264                  getTopApp(openingAppsForAnimation, false /* ignoreHidden */);
265          final ActivityRecord topClosingApp =
266                  getTopApp(closingAppsForAnimation, false /* ignoreHidden */);
267          final ActivityRecord topChangingApp =
268                  getTopApp(mDisplayContent.mChangingContainers, false /* ignoreHidden */);
269          final WindowManager.LayoutParams animLp = getAnimLp(animLpActivity);
270  
271          // Check if there is any override
272          if (!overrideWithTaskFragmentRemoteAnimation(transit, activityTypes)) {
273              // Unfreeze the windows that were previously frozen for TaskFragment animation.
274              unfreezeEmbeddedChangingWindows();
275              overrideWithRemoteAnimationIfSet(animLpActivity, transit, activityTypes);
276          }
277  
278          final boolean voiceInteraction = containsVoiceInteraction(closingAppsForAnimation)
279                  || containsVoiceInteraction(openingAppsForAnimation);
280  
281          final int layoutRedo;
282          mService.mSurfaceAnimationRunner.deferStartingAnimations();
283          try {
//然后在applyAnimations方法里面对window列表进行遍历WindowContainer的动画applyAnimation方法的调用
284              applyAnimations(openingAppsForAnimation, closingAppsForAnimation, transit, animLp,
285                      voiceInteraction);
286              handleClosingApps();
287              handleOpeningApps();
288              handleChangingApps(transit);
289  
290              appTransition.setLastAppTransition(transit, topOpeningApp,
291                      topClosingApp, topChangingApp);
292  
293              final int flags = appTransition.getTransitFlags();
294              layoutRedo = appTransition.goodToGo(transit, topOpeningApp);
295              handleNonAppWindowsInTransition(transit, flags);
296              appTransition.postAnimationCallback();
297              appTransition.clear();
298          } finally {
299              mService.mSurfaceAnimationRunner.continueStartingAnimations();
300          }
301  
302          mService.mTaskSnapshotController.onTransitionStarting(mDisplayContent);
303  
304          mDisplayContent.mOpeningApps.clear();
305          mDisplayContent.mClosingApps.clear();
306          mDisplayContent.mChangingContainers.clear();
307          mDisplayContent.mUnknownAppVisibilityController.clear();
308  
309          // This has changed the visibility of windows, so perform
310          // a new layout to get them all up-to-date.
311          mDisplayContent.setLayoutNeeded();
312  
313          mDisplayContent.computeImeTarget(true /* updateImeTarget */);
314  
315          mService.mAtmService.mTaskSupervisor.getActivityMetricsLogger().notifyTransitionStarting(
316                  mTempTransitionReasons);
317  
318          Trace.traceEnd(Trace.TRACE_TAG_WINDOW_MANAGER);
319  
320          mDisplayContent.pendingLayoutChanges |=
321                  layoutRedo | FINISH_LAYOUT_REDO_LAYOUT | FINISH_LAYOUT_REDO_CONFIG;
322      }

applyAnimationUnchecked包含两部分, 

第一先通过getAnimationAdapter加载合适的动画

如果是普通的窗口动画，比如app内部activity的切换，当前的场景是设置主菜单跳转子菜单，根据当前场景获取到具体的transit，transit=TRANSIT_OLD_ACTIVITY_OPEN，然后再结合enter为true或者false，可以最终可以找到设置主菜单的动画xml资源是activity_open_exit.xml，设置子菜单的动画xml资源是activity_open_enter.xml，在获取到具体xml资源名字后，通过AnimationUtils.loadAnimation方法把xml资源转成Animation对象。
之后就会创建一个WindowAnimationSpec对象，并把Animation对象作为构造方法的第一个参数传给了WindowAnimationSpec

第二开始动画 

protected void applyAnimationUnchecked(WindowManager.LayoutParams lp, boolean enter,
2994              @TransitionOldType int transit, boolean isVoiceInteraction,
2995              @Nullable ArrayList<WindowContainer> sources) {
2996          final Task task = asTask();
2997          if (task != null && !enter && !task.isActivityTypeHomeOrRecents()) {
2998              final InsetsControlTarget imeTarget = mDisplayContent.getImeTarget(IME_TARGET_LAYERING);
2999              final boolean isImeLayeringTarget = imeTarget != null && imeTarget.getWindow() != null
3000                      && imeTarget.getWindow().getTask() == task;
3001              // Attach and show the IME screenshot when the task is the IME target and performing
3002              // task closing transition to the next task.
3003              if (isImeLayeringTarget && AppTransition.isTaskCloseTransitOld(transit)) {
3004                  mDisplayContent.showImeScreenshot();
3005              }
3006          }
3007          final Pair<AnimationAdapter, AnimationAdapter> adapters = getAnimationAdapter(lp,
3008                  transit, enter, isVoiceInteraction);
3009          AnimationAdapter adapter = adapters.first;
3010          AnimationAdapter thumbnailAdapter = adapters.second;
3011          if (adapter != null) {
3012              if (sources != null) {
3013                  mSurfaceAnimationSources.addAll(sources);
3014              }
3015  
3016              AnimationRunnerBuilder animationRunnerBuilder = new AnimationRunnerBuilder();
3017  
3018              if (isTaskTransitOld(transit)) {
3019                  animationRunnerBuilder.setTaskBackgroundColor(getTaskAnimationBackgroundColor());
3020                  // TODO: Remove when we migrate to shell (b/202383002)
3021                  if (mWmService.mTaskTransitionSpec != null) {
3022                      animationRunnerBuilder.hideInsetSourceViewOverflows(
3023                              mWmService.mTaskTransitionSpec.animationBoundInsets);
3024                  }
3025              }
3026  
3027              final ActivityRecord activityRecord = asActivityRecord();
3028              if (activityRecord != null && isActivityTransitOld(transit)
3029                      && adapter.getShowBackground()) {
3030                  final @ColorInt int backgroundColorForTransition;
3031                  if (adapter.getBackgroundColor() != 0) {
3032                      // If available use the background color provided through getBackgroundColor
3033                      // which if set originates from a call to overridePendingAppTransition.
3034                      backgroundColorForTransition = adapter.getBackgroundColor();
3035                  } else {
3036                      // Otherwise default to the window's background color if provided through
3037                      // the theme as the background color for the animation - the top most window
3038                      // with a valid background color and showBackground set takes precedence.
3039                      final Task arTask = activityRecord.getTask();
3040                      backgroundColorForTransition = ColorUtils.setAlphaComponent(
3041                              arTask.getTaskDescription().getBackgroundColor(), 255);
3042                  }
3043                  animationRunnerBuilder.setTaskBackgroundColor(backgroundColorForTransition);
3044              }
3045  
3046              animationRunnerBuilder.build()
3047                      .startAnimation(getPendingTransaction(), adapter, !isVisible(),
3048                              ANIMATION_TYPE_APP_TRANSITION, thumbnailAdapter);
3049  
3050              if (adapter.getShowWallpaper()) {
3051                  getDisplayContent().pendingLayoutChanges |= FINISH_LAYOUT_REDO_WALLPAPER;
3052              }
3053          }
3054      }
3055  

 计算transition的类型

在getTransitCompatType中会对动画做转换，将动画转化为old类型的动画

 @TransitionOldType static int getTransitCompatType(AppTransition appTransition,
            ArraySet<ActivityRecord> openingApps, ArraySet<ActivityRecord> closingApps,
            ArraySet<WindowContainer> changingContainers, @Nullable WindowState wallpaperTarget,
            @Nullable WindowState oldWallpaper, boolean skipAppTransitionAnimation) {
        Slog.d("jinyanmeianimation","getTransitCompatType appTransition :" + appTransition );
 
        Slog.d("jinyanmeianimation","getTransitCompatType appTransition :" + appTransition , new RuntimeException("jinyanmeianimation"));
 
 
        // Determine if closing and opening app token sets are wallpaper targets, in which case
        // special animations are needed.
        final boolean openingAppHasWallpaper = canBeWallpaperTarget(openingApps)
                && wallpaperTarget != null;
        final boolean closingAppHasWallpaper = canBeWallpaperTarget(closingApps)
                && wallpaperTarget != null;
 
        // Keyguard transit has highest priority.
        switch (appTransition.getKeyguardTransition()) {
            case TRANSIT_KEYGUARD_GOING_AWAY:
                return openingAppHasWallpaper ? TRANSIT_OLD_KEYGUARD_GOING_AWAY_ON_WALLPAPER
                        : TRANSIT_OLD_KEYGUARD_GOING_AWAY;
            case TRANSIT_KEYGUARD_OCCLUDE:
                // When there is a closing app, the keyguard has already been occluded by an
                // activity, and another activity has started on top of that activity, so normal
                // app transition animation should be used.
                return closingApps.isEmpty() ? TRANSIT_OLD_KEYGUARD_OCCLUDE
                        : TRANSIT_OLD_ACTIVITY_OPEN;
            case TRANSIT_KEYGUARD_UNOCCLUDE:
                return TRANSIT_OLD_KEYGUARD_UNOCCLUDE;
        }
 
        // This is not keyguard transition and one of the app has request to skip app transition.
        // MIUI MOD: START
        // For Stage Split Screen: Drag to enter split-screen feature.
        // if (skipAppTransitionAnimation) {
        if (skipAppTransitionAnimation ||
                ActivityTaskManagerServiceStub.get().removeSplitTaskShotIfNeed()) {
        // END
            return WindowManager.TRANSIT_OLD_UNSET;
        }
        @TransitionFlags final int flags = appTransition.getTransitFlags();
        @TransitionType final int firstTransit = appTransition.getFirstAppTransition();
 
        // Special transitions
        // TODO(new-app-transitions): Revisit if those can be rewritten by using flags.
        if (appTransition.containsTransitRequest(TRANSIT_CHANGE) && !changingContainers.isEmpty()) {
            // MIUI ADD: START Activity Embedding Resizing
            if (MiuiEmbeddingWindowServiceStub.get()
                    .skipAppTransitionAnimationForEmbeddingDivider()) {
                return WindowManager.TRANSIT_OLD_UNSET;
            }
            // END
            @TransitContainerType int changingType =
                    getTransitContainerType(changingContainers.valueAt(0));
            switch (changingType) {
                case TYPE_TASK:
                    return TRANSIT_OLD_TASK_CHANGE_WINDOWING_MODE;
                case TYPE_TASK_FRAGMENT:
                    return TRANSIT_OLD_TASK_FRAGMENT_CHANGE;
                default:
                    throw new IllegalStateException(
                            "TRANSIT_CHANGE with unrecognized changing type=" + changingType);
            }
        }
        if ((flags & TRANSIT_FLAG_APP_CRASHED) != 0) {
            return TRANSIT_OLD_CRASHING_ACTIVITY_CLOSE;
        }
        if (firstTransit == TRANSIT_NONE) {
            return TRANSIT_OLD_NONE;
        }
 
        /*
         * There are cases where we open/close a new task/activity, but in reality only a
         * translucent activity on top of existing activities is opening/closing. For that one, we
         * have a different animation because non of the task/activity animations actually work well
         * with translucent apps.
         */
        if (isNormalTransit(firstTransit)) {
            boolean allOpeningVisible = true;
            boolean allTranslucentOpeningApps = !openingApps.isEmpty();
            for (int i = openingApps.size() - 1; i >= 0; i--) {
                final ActivityRecord activity = openingApps.valueAt(i);
                if (!activity.isVisible()) {
                    allOpeningVisible = false;
                    if (activity.fillsParent()) {
                        allTranslucentOpeningApps = false;
                    }
                }
            }
            boolean allTranslucentClosingApps = !closingApps.isEmpty();
            for (int i = closingApps.size() - 1; i >= 0; i--) {
                if (closingApps.valueAt(i).fillsParent()) {
                    allTranslucentClosingApps = false;
                    break;
                }
            }
 
            if (allTranslucentClosingApps && allOpeningVisible) {
                return TRANSIT_OLD_TRANSLUCENT_ACTIVITY_CLOSE;
            }
            if (allTranslucentOpeningApps && closingApps.isEmpty()) {
                return TRANSIT_OLD_TRANSLUCENT_ACTIVITY_OPEN;
            }
        }
 
        final ActivityRecord topOpeningApp = getTopApp(openingApps,
                false /* ignoreHidden */);
        final ActivityRecord topClosingApp = getTopApp(closingApps,
                true /* ignoreHidden */);
 
        if (closingAppHasWallpaper && openingAppHasWallpaper) {
            ProtoLog.v(WM_DEBUG_APP_TRANSITIONS, "Wallpaper animation!");
            switch (firstTransit) {
                case TRANSIT_OPEN:
                case TRANSIT_TO_FRONT:
                    return TRANSIT_OLD_WALLPAPER_INTRA_OPEN;
                case TRANSIT_CLOSE:
                case TRANSIT_TO_BACK:
                    return TRANSIT_OLD_WALLPAPER_INTRA_CLOSE;
            }
        } else if (oldWallpaper != null && !openingApps.isEmpty()
                && !openingApps.contains(oldWallpaper.mActivityRecord)
                && closingApps.contains(oldWallpaper.mActivityRecord)
                && topClosingApp == oldWallpaper.mActivityRecord) {
            // We are transitioning from an activity with a wallpaper to one without.
            return TRANSIT_OLD_WALLPAPER_CLOSE;
        } else if (wallpaperTarget != null && wallpaperTarget.isVisible()
                && openingApps.contains(wallpaperTarget.mActivityRecord)
                && topOpeningApp == wallpaperTarget.mActivityRecord
                /* && transit != TRANSIT_TRANSLUCENT_ACTIVITY_CLOSE */) {
            // We are transitioning from an activity without
            // a wallpaper to now showing the wallpaper
            return TRANSIT_OLD_WALLPAPER_OPEN;
        }
 
        final ArraySet<WindowContainer> openingWcs = getAnimationTargets(
                openingApps, closingApps, true /* visible */);
        final ArraySet<WindowContainer> closingWcs = getAnimationTargets(
                openingApps, closingApps, false /* visible */);
        final WindowContainer<?> openingContainer = !openingWcs.isEmpty()
                ? openingWcs.valueAt(0) : null;
        final WindowContainer<?> closingContainer = !closingWcs.isEmpty()
                ? closingWcs.valueAt(0) : null;
        @TransitContainerType int openingType = getTransitContainerType(openingContainer);
        @TransitContainerType int closingType = getTransitContainerType(closingContainer);
        if (appTransition.containsTransitRequest(TRANSIT_TO_FRONT) && openingType == TYPE_TASK) {
            return TRANSIT_OLD_TASK_TO_FRONT;
        }
        if (appTransition.containsTransitRequest(TRANSIT_TO_BACK) && closingType == TYPE_TASK) {
            return TRANSIT_OLD_TASK_TO_BACK;
        }
        if (appTransition.containsTransitRequest(TRANSIT_OPEN)) {
            if (openingType == TYPE_TASK) {
                return (appTransition.getTransitFlags() & TRANSIT_FLAG_OPEN_BEHIND) != 0
                        ? TRANSIT_OLD_TASK_OPEN_BEHIND : TRANSIT_OLD_TASK_OPEN;
            }
            if (openingType == TYPE_ACTIVITY) {
                return TRANSIT_OLD_ACTIVITY_OPEN;
            }
            if (openingType == TYPE_TASK_FRAGMENT) {
                return TRANSIT_OLD_TASK_FRAGMENT_OPEN;
            }
        }
        if (appTransition.containsTransitRequest(TRANSIT_CLOSE)) {
            if (closingType == TYPE_TASK) {
                return TRANSIT_OLD_TASK_CLOSE;
            }
            if (closingType == TYPE_TASK_FRAGMENT) {
                return TRANSIT_OLD_TASK_FRAGMENT_CLOSE;
            }
            if (closingType == TYPE_ACTIVITY) {
                for (int i = closingApps.size() - 1; i >= 0; i--) {
                    if (closingApps.valueAt(i).visibleIgnoringKeyguard) {
                        return TRANSIT_OLD_ACTIVITY_CLOSE;
                    }
                }
                // Skip close activity transition since no closing app can be visible
                return WindowManager.TRANSIT_OLD_UNSET;
            }
        }
        if (appTransition.containsTransitRequest(TRANSIT_RELAUNCH)
                && !openingWcs.isEmpty() && !openingApps.isEmpty()) {
            return TRANSIT_OLD_ACTIVITY_RELAUNCH;
        }
        return TRANSIT_OLD_NONE;
    }

加载和开始动画

getAnimationAdapter加载动画

首先遍历所有的windowContainer 调用applyAnimation

    private void applyAnimations(ArraySet<WindowContainer> wcs, ArraySet<ActivityRecord> apps,
            @TransitionOldType int transit, boolean visible, LayoutParams animLp,
            boolean voiceInteraction) {
        final int wcsCount = wcs.size();
        for (int i = 0; i < wcsCount; i++) {
            final WindowContainer wc = wcs.valueAt(i);
            // If app transition animation target is promoted to higher level, SurfaceAnimator
            // triggers WC#onAnimationFinished only on the promoted target. So we need to take care
            // of triggering AR#onAnimationFinished on each ActivityRecord which is a part of the
            // app transition.
            final ArrayList<ActivityRecord> transitioningDescendants = new ArrayList<>();
            for (int j = 0; j < apps.size(); ++j) {
                final ActivityRecord app = apps.valueAt(j);
                if (app.isDescendantOf(wc)) {
                    transitioningDescendants.add(app);
                }
            }
            wc.applyAnimation(animLp, transit, visible, voiceInteraction, transitioningDescendants);
        }
    }

然后调用getAnimationAdapter 根据窗口层次结构中给定的窗口布局属性获取动画适配器

startAnimation 创建leash开始动画

SurfaceAnimation.java
166      void startAnimation(Transaction t, AnimationAdapter anim, boolean hidden,
167              @AnimationType int type,
168              @Nullable OnAnimationFinishedCallback animationFinishedCallback,
169              @Nullable Runnable animationCancelledCallback,
170              @Nullable AnimationAdapter snapshotAnim, @Nullable SurfaceFreezer freezer) {
171          cancelAnimation(t, true /* restarting */, true /* forwardCancel */);
172          mAnimation = anim;
173          mAnimationType = type;
174          mSurfaceAnimationFinishedCallback = animationFinishedCallback;
175          mAnimationCancelledCallback = animationCancelledCallback;
176          final SurfaceControl surface = mAnimatable.getSurfaceControl();
177          if (surface == null) {
178              Slog.w(TAG, "Unable to start animation, surface is null or no children.");
179              cancelAnimation();
180              return;
181          }
182          mLeash = freezer != null ? freezer.takeLeashForAnimation() : null;
183          if (mLeash == null) {
184              mLeash = createAnimationLeash(mAnimatable, surface, t, type,
185                      mAnimatable.getSurfaceWidth(), mAnimatable.getSurfaceHeight(), 0 /* x */,
186                      0 /* y */, hidden, mService.mTransactionFactory);
187              mAnimatable.onAnimationLeashCreated(t, mLeash);
188          }
189          mAnimatable.onLeashAnimationStarting(t, mLeash);
190          if (mAnimationStartDelayed) {
191              ProtoLog.i(WM_DEBUG_ANIM, "Animation start delayed for %s", mAnimatable);
192              return;
193          }
194          mAnimation.startAnimation(mLeash, t, type, mInnerAnimationFinishedCallback);
195          if (ProtoLogImpl.isEnabled(WM_DEBUG_ANIM)) {
196              StringWriter sw = new StringWriter();
197              PrintWriter pw = new PrintWriter(sw);
198              mAnimation.dump(pw, "");
199              ProtoLog.d(WM_DEBUG_ANIM, "Animation start for %s, anim=%s", mAnimatable, sw);
200          }
201          if (snapshotAnim != null) {
202              mSnapshot = freezer.takeSnapshotForAnimation();
203              if (mSnapshot == null) {
204                  Slog.e(TAG, "No snapshot target to start animation on for " + mAnimatable);
205                  return;
206              }
207              mSnapshot.startAnimation(t, snapshotAnim, type);
208          }
209      }

可见创建一个SuefaceControl, 然后把 WindowContainer的surface挂在了leash上面, 然后对leash做动画

455      static SurfaceControl createAnimationLeash(Animatable animatable, SurfaceControl surface,
456              Transaction t, @AnimationType int type, int width, int height, int x, int y,
457              boolean hidden, Supplier<Transaction> transactionFactory) {
458          ProtoLog.i(WM_DEBUG_ANIM, "Reparenting to leash for %s", animatable);
459          final SurfaceControl.Builder builder = animatable.makeAnimationLeash()
460                  .setParent(animatable.getAnimationLeashParent())
461                  .setName(surface + " - animation-leash of " + animationTypeToString(type))
462                  // TODO(b/151665759) Defer reparent calls
463                  // We want the leash to be visible immediately because the transaction which shows
464                  // the leash may be deferred but the reparent will not. This will cause the leashed
465                  // surface to be invisible until the deferred transaction is applied. If this
466                  // doesn't work, you will can see the 2/3 button nav bar flicker during seamless
467                  // rotation.
468                  .setHidden(hidden)
469                  .setEffectLayer()
470                  .setCallsite("SurfaceAnimator.createAnimationLeash");
471          final SurfaceControl leash = builder.build();
472          t.setWindowCrop(leash, width, height);
473          t.setPosition(leash, x, y);
474          t.show(leash);
475          t.setAlpha(leash, hidden ? 0 : 1);
476  
477          t.reparent(surface, leash);
478          return leash;
479      }

SurfaceAnimationRunner.java
 
171      void startAnimation(AnimationSpec a, SurfaceControl animationLeash, Transaction t,
172              Runnable finishCallback) {
173          synchronized (mLock) {
174              final RunningAnimation runningAnim = new RunningAnimation(a, animationLeash,
175                      finishCallback);
176              boolean requiresEdgeExtension = requiresEdgeExtension(a);
177  
178              if (requiresEdgeExtension) {
179                  final ArrayList<SurfaceControl> extensionSurfaces = new ArrayList<>();
180                  synchronized (mEdgeExtensionLock) {
181                      mEdgeExtensions.put(animationLeash, extensionSurfaces);
182                  }
183  
184                  mPreProcessingAnimations.put(animationLeash, runningAnim);
185  
186                  // We must wait for t to be committed since otherwise the leash doesn't have the
187                  // windows we want to screenshot and extend as children.
188                  t.addTransactionCommittedListener(mEdgeExtensionExecutor, () -> {
189                      final WindowAnimationSpec animationSpec = a.asWindowAnimationSpec();
190  
191                      final Transaction edgeExtensionCreationTransaction = new Transaction();
192                      edgeExtendWindow(animationLeash,
193                              animationSpec.getRootTaskBounds(), animationSpec.getAnimation(),
194                              edgeExtensionCreationTransaction);
195  
196                      synchronized (mLock) {
197                          // only run if animation is not yet canceled by this point
198                          if (mPreProcessingAnimations.get(animationLeash) == runningAnim) {
199                              // In the case the animation is cancelled, edge extensions are removed
200                              // onAnimationLeashLost which is called before onAnimationCancelled.
201                              // So we need to check if the edge extensions have already been removed
202                              // or not, and if so we don't want to apply the transaction.
203                              synchronized (mEdgeExtensionLock) {
204                                  if (!mEdgeExtensions.isEmpty()) {
205                                      edgeExtensionCreationTransaction.apply();
206                                  }
207                              }
208  
209                              mPreProcessingAnimations.remove(animationLeash);
210                              mPendingAnimations.put(animationLeash, runningAnim);
211                              if (!mAnimationStartDeferred && mPreProcessingAnimations.isEmpty()) {
212                                  mChoreographer.postFrameCallback(this::startAnimations);
213                              }
214                          }
215                      }
216                  });
217              }
218  
219              if (!requiresEdgeExtension) {
220                  mPendingAnimations.put(animationLeash, runningAnim);
221                  if (!mAnimationStartDeferred && mPreProcessingAnimations.isEmpty()) {
222                      mChoreographer.postFrameCallback(this::startAnimations);
223                  }
224              }
225  
226              // Some animations (e.g. move animations) require the initial transform to be
227              // applied immediately.
228              applyTransformation(runningAnim, t, 0 /* currentPlayTime */);
229          }
230      }

发送消息

scheduleFrameLocked:862, Choreographer (android.view)
postCallbackDelayedInternal:605, Choreographer (android.view)
postFrameCallbackDelayed:702, Choreographer (android.view)
postFrameCallback:682, Choreographer (android.view)
continueStartingAnimations:173, SurfaceAnimationRunner (com.android.server.wm)
handleAppTransitionReady:312, AppTransitionController (com.android.server.wm)
checkAppTransitionReady:1070, RootWindowContainer (com.android.server.wm)
performSurfacePlacementNoTrace:937, RootWindowContainer (com.android.server.wm)
performSurfacePlacement:877, RootWindowContainer (com.android.server.wm)
performSurfacePlacementLoop:199, WindowSurfacePlacer (com.android.server.wm)
performSurfacePlacement:148, WindowSurfacePlacer (com.android.server.wm)
performSurfacePlacement:137, WindowSurfacePlacer (com.android.server.wm)
handleAppTransitionTimeout:1814, AppTransition (com.android.server.wm)
lambda$new$0$com-android-server-wm-AppTransition:243, AppTransition (com.android.server.wm)
run:-1, AppTransition$$ExternalSyntheticLambda3 (com.android.server.wm)
handleCallback:942, Handler (android.os)
dispatchMessage:99, Handler (android.os)
loopOnce:211, Looper (android.os)
loop:300, Looper (android.os)
run:67, HandlerThread (android.os)
run:46, ServiceThread (com.android.server)

为动画添加listener

SurfaceAnimationRunner.java
 private void startAnimationLocked(RunningAnimation a) {
270          final ValueAnimator anim = mAnimatorFactory.makeAnimator();
271  
272          // Animation length is already expected to be scaled.
273          anim.overrideDurationScale(1.0f);
274          anim.setDuration(a.mAnimSpec.getDuration());
275          anim.addUpdateListener(animation -> {
276              synchronized (mCancelLock) {
277                  if (!a.mCancelled) {
278                      final long duration = anim.getDuration();
279                      long currentPlayTime = anim.getCurrentPlayTime();
280                      if (currentPlayTime > duration) {
281                          currentPlayTime = duration;
282                      }
283                      applyTransformation(a, mFrameTransaction, currentPlayTime);
284                  }
285              }
286  
287              // Transaction will be applied in the commit phase.
288              scheduleApplyTransaction();
289          });
290  
291          anim.addListener(new AnimatorListenerAdapter() {
292              @Override
293              public void onAnimationStart(Animator animation) {
294                  synchronized (mCancelLock) {
295                      if (!a.mCancelled) {
296                          // TODO: change this back to use show instead of alpha when b/138459974 is
297                          // fixed.
298                          mFrameTransaction.setAlpha(a.mLeash, 1);
299                      }
300                  }
301              }
302  
303              @Override
304              public void onAnimationEnd(Animator animation) {
305                  synchronized (mLock) {
306                      mRunningAnimations.remove(a.mLeash);
307                      synchronized (mCancelLock) {
308                          if (!a.mCancelled) {
309  
310                              // Post on other thread that we can push final state without jank.
311                              mAnimationThreadHandler.post(a.mFinishCallback);
312                          }
313                      }
314                  }
315              }
316          });
317          a.mAnim = anim;
318          mRunningAnimations.put(a.mLeash, a);
319  
320          anim.start();
321          if (a.mAnimSpec.canSkipFirstFrame()) {
322              // If we can skip the first frame, we start one frame later.
323              anim.setCurrentPlayTime(mChoreographer.getFrameIntervalNanos() / NANOS_PER_MS);
324          }
325  
326          // Immediately start the animation by manually applying an animation frame. Otherwise, the
327          // start time would only be set in the next frame, leading to a delay.
328          anim.doAnimationFrame(mChoreographer.getFrameTime());
329      }
330  

doFrame时更新动画位置

放vsync到来后, 执行onAnimationUpdate

    private void applyTransformation(RunningAnimation a, Transaction t, long currentPlayTime) {
        a.mAnimSpec.apply(t, a.mLeash, currentPlayTime);
    }

再来看下apply方法的具体实现，通过之前以具体xml资源创建的mAnimation对象，根据当前时间片currentPlayTime获取到当前的tmp.transformation，对leash对象实现了Matrix（大小，位置），Alpha，Crop等transformation变化，再通过Transaction 交给surfaceflinger显示，从而实现了动画当前时间片的显示效果。对比旧动画机制，这个transformation变化是在WindowStateAnimator类里面实现的。为什么要重点关注这个方法呢？因为如果窗口动画出bug了（位置大小不对？透明度异常？），就可以在这个方法里面打印window的相关参数来初步定位原因。 

119      @Override
120      public void apply(Transaction t, SurfaceControl leash, long currentPlayTime) {
121          final TmpValues tmp = mThreadLocalTmps.get();
122          tmp.transformation.clear();
123          mAnimation.getTransformation(currentPlayTime, tmp.transformation);
124          tmp.transformation.getMatrix().postTranslate(mPosition.x, mPosition.y);
125          t.setMatrix(leash, tmp.transformation.getMatrix(), tmp.floats);
126          t.setAlpha(leash, tmp.transformation.getAlpha());
127  
128          boolean cropSet = false;
129          if (mRootTaskClipMode == ROOT_TASK_CLIP_NONE) {
130              if (tmp.transformation.hasClipRect()) {
131                  final Rect clipRect = tmp.transformation.getClipRect();
132                  accountForExtension(tmp.transformation, clipRect);
133                  t.setWindowCrop(leash, clipRect);
134                  cropSet = true;
135              }
136          } else {
137              mTmpRect.set(mRootTaskBounds);
138              if (tmp.transformation.hasClipRect()) {
139                  mTmpRect.intersect(tmp.transformation.getClipRect());
140              }
141              accountForExtension(tmp.transformation, mTmpRect);
142              t.setWindowCrop(leash, mTmpRect);
143              cropSet = true;
144          }
145  
146          // We can only apply rounded corner if a crop is set, as otherwise the value is meaningless,
147          // since it doesn't have anything it's relative to.
148          if (cropSet && mAnimation.hasRoundedCorners() && mWindowCornerRadius > 0) {
149              t.setCornerRadius(leash, mWindowCornerRadius);
150          }
151      }

6、ValueAnimator类，从上面的介绍可以得知，窗口动画的最终本质就是一个ValueAnimator属性动画，理解了这一点，就相当于把窗口动画简单化了，最终的实现就类比于我们普通app的属性动画的实现（app属性动画的对象是view，窗口属性动画的对象是window），只不过整个流程比较复杂而已，但是最终的实现原理是一样的，殊途同归，这个才是android窗口动画机制的精髓所在

Rotation动画 ANIMATION_TYPE_SCREEN_ROTATION

1. 根据sensor导致的旋转动画

最终也会到SurfaceAnimation

 拿到动画适配器:

FadeAnimationController.java
 
    public void fadeWindowToken(boolean show, WindowToken windowToken, int animationType) {
        if (windowToken == null || windowToken.getParent() == null) {
            return;
        }
 
        final Animation animation = show ? getFadeInAnimation() : getFadeOutAnimation();
        final FadeAnimationAdapter animationAdapter = animation != null
                ? createAdapter(createAnimationSpec(animation), show, windowToken) : null;
        if (animationAdapter == null) {
            return;
        }
 
        windowToken.startAnimation(windowToken.getPendingTransaction(), animationAdapter,
                show /* hidden */, animationType, null /* finishedCallback */);
    }