devbox
Monodyee
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android T 远程动画显示流程其三——桌面侧动画启动到系统侧结束流程

作者：Monodyee | 2024-03-01 13:41:00

赞

踩

Android T 远程动画显示流程其三——桌面侧动画启动到系统侧结束流程

前言

接着前文分析Android T 远程动画显示流程其二
我们通过IRemoteAnimationRunner跨进程通信从系统进程来到了桌面进程，这里是真正动画播放的逻辑。
之后又通过IRemoteAnimationFinishedCallback跨进程通信回到系统进程，处理动画结束时的逻辑。

进入桌面进程启动动画

跨进程通信，实现IRemoteAnimationRunner

代码路径：frameworks/base/packages/SystemUI/shared/src/com/android/systemui/shared/system/RemoteAnimationRunnerCompat.java

public abstract class RemoteAnimationRunnerCompat extends IRemoteAnimationRunner.Stub {

    public abstract void onAnimationStart(@WindowManager.TransitionOldType int transit,
            RemoteAnimationTarget[] apps, RemoteAnimationTarget[] wallpapers,
            RemoteAnimationTarget[] nonApps, Runnable finishedCallback);

    @Override
    public final void onAnimationStart(@TransitionOldType int transit,
            RemoteAnimationTarget[] apps,
            RemoteAnimationTarget[] wallpapers,
            RemoteAnimationTarget[] nonApps,
            final IRemoteAnimationFinishedCallback finishedCallback) {
        //调用自身抽象方法onAnimationStart
        onAnimationStart(transit, apps, wallpapers,
                nonApps, () -> {
                    try {
                        finishedCallback.onAnimationFinished();
                    } catch (RemoteException e) {
                        Log.e("ActivityOptionsCompat", "Failed to call app controlled animation"
                                + " finished callback", e);
                    }
                });
    }
    ......
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

这里传递的参数都是前面RemoteAnimationController.goodToGo方法中获取的值。
transit的值是TRANSIT_OLD_WALLPAPER_CLOSE（12）；
app指的是桌面和应用的RemoteAnimationTarget；
wallpapers壁纸的RemoteAnimationTarget；
nonApp非APP类型的RemoteAnimationTarget；
finishedCallback是FinishedCallback对象，这里传递的是调用了其onAnimationFinished()方法。

这方方法调用了自身抽象方法调用自身抽象方法onAnimationStart，onAnimationStart方法真正的实现在LauncherAnimationRunner类中

@TargetApi(Build.VERSION_CODES.P)
public class LauncherAnimationRunner extends RemoteAnimationRunnerCompat {
    ......
    @BinderThread
    public void onAnimationStart(
            int transit,
            RemoteAnimationTarget[] appTargets,
            RemoteAnimationTarget[] wallpaperTargets,
            RemoteAnimationTarget[] nonAppTargets,
            Runnable runnable) {
        Runnable r = () -> {
            //退出动画的流程，此时mAnimationResult为空，尚未进入该流程
            finishExistingAnimation();
            //创建AnimationResult，传递了两个runnable
            //() -> mAnimationResult = null,把AnimationResult对象置空
            //runnable,就是前面传递的IRemoteAnimationFinishedCallback.onAnimationFinished
            mAnimationResult = new AnimationResult(() -> mAnimationResult = null, runnable);
            //传递从系统侧调用过来的参数创建动画
            getFactory().onCreateAnimation(transit, appTargets, wallpaperTargets, nonAppTargets,
                    mAnimationResult);
        };
        //根据mStartAtFrontOfQueue的值，执行线程 r
        if (mStartAtFrontOfQueue) {
            //将Runnable插入到消息队列的前面，以确保它尽快被执行
            postAtFrontOfQueueAsynchronously(mHandler, r);
        } else {
            //将Runnable异步地插入到消息队列中，它将在队列中的其他消息之后执行。
            postAsyncCallback(mHandler, r);
        }
    }
    ......
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32

  • 退出动画的流程
    finishExistingAnimation();

        @UiThread
    private void finishExistingAnimation() {
        if (mAnimationResult != null) {
            mAnimationResult.finish();
            mAnimationResult = null;
        }
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    根据mAnimationResult是否为空执行finish方法，主要就是执行mASyncFinishRunnable，后续会在动画退出流程中细讲finish方法。

  • 创建AnimationResult
    mAnimationResult = new AnimationResult(() -> mAnimationResult = null, runnable);

        public static final class AnimationResult {
        ......
        private AnimationResult(Runnable syncFinishRunnable, Runnable asyncFinishRunnable) {
            mSyncFinishRunnable = syncFinishRunnable;
            mASyncFinishRunnable = asyncFinishRunnable;
        }
        ......
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    AnimationResult主要用来返回当前动画播放结果，以便后续执行动画播放完成时的回调（mASyncFinishRunnable）。
    () -> mAnimationResult = null，一个把AnimationResult对象置空的Runnable，保存到mSyncFinishRunnable中；
    runnable，就是前面传递的IRemoteAnimationFinishedCallback.onAnimationFinished，保存到mASyncFinishRunnable中。

  • 传递从系统侧创建的参数创建动画

    getFactory().onCreateAnimation(transit, appTargets, wallpaperTargets, nonAppTargets,
                    mAnimationResult);

    • 1
    • 2

    传递了从系统侧创建的参数，并传递了mAnimationResult对象。这里调用的是RemoteAnimationFactory接口中的onCreateAnimation方法。

        /**
     * Used with LauncherAnimationRunner as an interface for the runner to call back to the
     * implementation.
     */
    @FunctionalInterface
    public interface RemoteAnimationFactory {

        /**
         * Called on the UI thread when the animation targets are received. The implementation must
         * call {@link AnimationResult#setAnimation} with the target animation to be run.
         */
        void onCreateAnimation(int transit,
                RemoteAnimationTarget[] appTargets,
                RemoteAnimationTarget[] wallpaperTargets,
                RemoteAnimationTarget[] nonAppTargets,
                LauncherAnimationRunner.AnimationResult result);
        ......
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    在最开始Launcher.startActivitySafely流程中，QuickstepTransitionManager.getActivityLaunchOptions方法中创建了AppLaunchAnimationRunner对象，并作为RemoteAnimationFactory对象传递到了。

            mAppLaunchRunner = new AppLaunchAnimationRunner(v, onEndCallback);
        RemoteAnimationRunnerCompat runner = new LauncherAnimationRunner(
                mHandler, mAppLaunchRunner, true /* startAtFrontOfQueue */);

    • 1
    • 2
    • 3

    因此我们这里RemoteAnimationFactory的实现，就是在QuickstepTransitionManager.AppLaunchAnimationRunner中。

传递从系统侧创建的参数创建动画

代码路径：packages/apps/Launcher3/quickstep/src/com/android/launcher3/QuickstepTransitionManager.java

    private class AppLaunchAnimationRunner implements RemoteAnimationFactory {

        private final View mV;
        private final RunnableList mOnEndCallback;

        AppLaunchAnimationRunner(View v, RunnableList onEndCallback) {
            mV = v;
            mOnEndCallback = onEndCallback;
        }

        @Override
        public void onCreateAnimation(int transit,
                RemoteAnimationTarget[] appTargets,
                RemoteAnimationTarget[] wallpaperTargets,
                RemoteAnimationTarget[] nonAppTargets,
                LauncherAnimationRunner.AnimationResult result) {
            //创建AnimatorSet
            AnimatorSet anim = new AnimatorSet();
            //判断桌面的是否已经不在前台
            boolean launcherClosing =
                    launcherIsATargetWithMode(appTargets, MODE_CLOSING);

            //检查是否从桌面小部件启动应用
            final boolean launchingFromWidget = mV instanceof LauncherAppWidgetHostView;
            //检查是否从最近应用列表启动应用
            final boolean launchingFromRecents = isLaunchingFromRecents(mV, appTargets);
            //决定是否跳过动画的第一帧
            final boolean skipFirstFrame;
            if (launchingFromWidget) {//从桌面小部件启动应用的动画
                composeWidgetLaunchAnimator(anim, (LauncherAppWidgetHostView) mV, appTargets,
                        wallpaperTargets, nonAppTargets, launcherClosing);
                addCujInstrumentation(
                        anim, InteractionJankMonitorWrapper.CUJ_APP_LAUNCH_FROM_WIDGET);
                skipFirstFrame = true;
            } else if (launchingFromRecents) {//从最近任务启动应用的动画
                composeRecentsLaunchAnimator(anim, mV, appTargets, wallpaperTargets, nonAppTargets,
                        launcherClosing);
                addCujInstrumentation(
                        anim, InteractionJankMonitorWrapper.CUJ_APP_LAUNCH_FROM_RECENTS);
                skipFirstFrame = true;
            } else {//点击桌面图标启动应用的动画
                composeIconLaunchAnimator(anim, mV, appTargets, wallpaperTargets, nonAppTargets,
                        launcherClosing);
                addCujInstrumentation(anim, InteractionJankMonitorWrapper.CUJ_APP_LAUNCH_FROM_ICON);
                skipFirstFrame = false;
            }

            //桌面不在前台给动画添加一个监听器
            if (launcherClosing) {
                anim.addListener(mForceInvisibleListener);
            }
            //设置动画和回调
            result.setAnimation(anim, mLauncher, mOnEndCallback::executeAllAndDestroy,
                    skipFirstFrame);
        }

        @Override
        public void onAnimationCancelled() {
            mOnEndCallback.executeAllAndDestroy();
        }
    }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61

这里我们主要关注点击桌面图标启动应用的动画逻辑

点击桌面图标启动应用的动画

composeIconLaunchAnimator(anim, mV, appTargets, wallpaperTargets, nonAppTargets,
                        launcherClosing);

  • 1
  • 2

anim一个AnimatorSet对象；
mV这里指的是启动的应用图标，比如com.android.launcher3.BubbleTextView{bace738 VFED..CL. ........ 582,525-859,945 #7f09016a app:id/icon}；
appTargets指的是桌面和应用的RemoteAnimationTarget；
wallpaperTargets壁纸的RemoteAnimationTarget；
nonAppTargets非APP类型的RemoteAnimationTarget；
launcherClosing此时桌面的是否已经不在前台，因此值为true

    /**
     * Compose the animations for a launch from the app icon.
     *
     * @param anim            the animation to add to
     * @param v               the launching view with the icon
     * @param appTargets      the list of opening/closing apps
     * @param launcherClosing true if launcher is closing
     */
    private void composeIconLaunchAnimator(@NonNull AnimatorSet anim, @NonNull View v,
            @NonNull RemoteAnimationTarget[] appTargets,
            @NonNull RemoteAnimationTarget[] wallpaperTargets,
            @NonNull RemoteAnimationTarget[] nonAppTargets,
            boolean launcherClosing) {
        // Set the state animation first so that any state listeners are called
        // before our internal listeners.
        //setCurrentAnimation(anim)取消任何正在运行的动画，设置新的动画
        //即将动画设置为当前状态动画
        mLauncher.getStateManager().setCurrentAnimation(anim);

        // Note: the targetBounds are relative to the launcher
        int startDelay = getSingleFrameMs(mLauncher);
        //设置动画参数
        Animator windowAnimator = getOpeningWindowAnimators(
                v, appTargets, wallpaperTargets, nonAppTargets, launcherClosing);
        //设置动画启动延时
        windowAnimator.setStartDelay(startDelay);
        //设置windowAnimator给AnimatorSet对象
        anim.play(windowAnimator);
        //如果桌面已经不在最顶层显示
        if (launcherClosing) {
            // Delay animation by a frame to avoid jank.
            //将动画延迟一帧以避免抖动
            //创建一个launcherAnimator动画和endListener线程
            Pair<AnimatorSet, Runnable> launcherContentAnimator =
                    getLauncherContentAnimator(true /* isAppOpening */, startDelay, false);
            //把launcherAnimator动画放到AnimatorSet
            anim.play(launcherContentAnimator.first);
            anim.addListener(new AnimatorListenerAdapter() {
                @Override
                public void onAnimationEnd(Animator animation) {
                    //运行endListener线程
                    launcherContentAnimator.second.run();
                }
            });
        }
    }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46

之前最为关键的就是getOpeningWindowAnimators方法

Animator windowAnimator = getOpeningWindowAnimators(
                v, appTargets, wallpaperTargets, nonAppTargets, launcherClosing);

  • 1
  • 2

这个方法是动画真正的设置部分

设置动画相关参数、监听等

    /**
     * @return Animator that controls the window of the opening targets from app icons.
     */
    private Animator getOpeningWindowAnimators(View v,
            RemoteAnimationTarget[] appTargets,
            RemoteAnimationTarget[] wallpaperTargets,
            RemoteAnimationTarget[] nonAppTargets,
            boolean launcherClosing) {
        //获取应用方向
        int rotationChange = getRotationChange(appTargets);
        //获取启动应用的窗口边界
        Rect windowTargetBounds = getWindowTargetBounds(appTargets, rotationChange);
        //检查appTargets中所有应用目标是否半透明
        //areAllTargetsTranslucent方法返回的的是，
        //mode值为MODE_OPENING(正在打开的应用)的RemoteAnimationTarget的isTranslucent的值
        boolean appTargetsAreTranslucent = areAllTargetsTranslucent(appTargets);

        RectF launcherIconBounds = new RectF();
        //获取一个浮动图标视图
        FloatingIconView floatingView = FloatingIconView.getFloatingIconView(mLauncher, v,
                !appTargetsAreTranslucent, launcherIconBounds, true /* isOpening */);
        Rect crop = new Rect();
        Matrix matrix = new Matrix();

        //创建mMode为MODE_OPENING的RemoteAnimationTargets对象
        //把app、壁纸和非app类型的RemoteAnimationTarget对象保存到RemoteAnimationTargets中
        RemoteAnimationTargets openingTargets = new RemoteAnimationTargets(appTargets,
                wallpaperTargets, nonAppTargets, MODE_OPENING);
        //创建SurfaceTransactionApplier对象
        SurfaceTransactionApplier surfaceApplier =
                new SurfaceTransactionApplier(floatingView);
        //为了确保动画完成时，释放相关资源
        openingTargets.addReleaseCheck(surfaceApplier);
        //获取导航栏的RemoteAnimationTarget对象
        RemoteAnimationTarget navBarTarget = openingTargets.getNavBarRemoteAnimationTarget();

        //DragLayer是一个ViewGroup，协调处理它的子view拖动的容器
        //getLocationOnScreen获取DragLayer在屏幕上的绝对位置
        int[] dragLayerBounds = new int[2];
        mDragLayer.getLocationOnScreen(dragLayerBounds);

        //检查是否支持冷启动窗口Splash Screen
        final boolean hasSplashScreen;
        if (supportsSSplashScreen()) {
            int taskId = openingTargets.getFirstAppTargetTaskId();
            Pair<Integer, Integer> defaultParams = Pair.create(STARTING_WINDOW_TYPE_NONE, 0);
            Pair<Integer, Integer> taskParams =
                    mTaskStartParams.getOrDefault(taskId, defaultParams);
            mTaskStartParams.remove(taskId);
            hasSplashScreen = taskParams.first == STARTING_WINDOW_TYPE_SPLASH_SCREEN;
        } else {
            hasSplashScreen = false;
        }

        //创建AnimOpenProperties对象，设置应用启动时的动画属性
        AnimOpenProperties prop = new AnimOpenProperties(mLauncher.getResources(), mDeviceProfile,
                windowTargetBounds, launcherIconBounds, v, dragLayerBounds[0], dragLayerBounds[1],
                hasSplashScreen, floatingView.isDifferentFromAppIcon());
        //计算裁剪区域的边界
        int left = prop.cropCenterXStart - prop.cropWidthStart / 2;
        int top = prop.cropCenterYStart - prop.cropHeightStart / 2;
        int right = left + prop.cropWidthStart;
        int bottom = top + prop.cropHeightStart;
        // Set the crop here so we can calculate the corner radius below.
        crop.set(left, top, right, bottom);

        //创建临时矩形和点对象
        RectF floatingIconBounds = new RectF();
        RectF tmpRectF = new RectF();
        Point tmpPos = new Point();

        //设置动画的一些参数和监听
        AnimatorSet animatorSet = new AnimatorSet();
        ValueAnimator appAnimator = ValueAnimator.ofFloat(0, 1);
        appAnimator.setDuration(APP_LAUNCH_DURATION);
        //设置动画的插值器为LINEAR。插值器决定了动画的速度曲线。LINEAR意味着动画将匀速进行
        appAnimator.setInterpolator(LINEAR);
        //为appAnimator添加一个动画监听器floatingView。
        //当动画开始、结束、取消或重复时，floatingView上的相应方法将被调用。
        appAnimator.addListener(floatingView);
        appAnimator.addListener(new AnimatorListenerAdapter() {
            @Override
            //监听动开始
            public void onAnimationStart(Animator animation) {
                //获取LauncherTaskbarUIController的实例
                LauncherTaskbarUIController taskbarController = mLauncher.getTaskbarUIController();
                //检查是否应该调用shouldShowEdu()
                if (taskbarController != null && taskbarController.shouldShowEdu()) {
                    // LAUNCHER_TASKBAR_EDUCATION_SHOWING is set to true here, when the education
                    // flow is about to start, to avoid a race condition with other components
                    // that would show something else to the user as soon as the app is opened.
                    //将LAUNCHER_TASKBAR_EDUCATION_SHOWING设置为true，以避免与其他组件发生竞争
                    Settings.Secure.putInt(mLauncher.getContentResolver(),
                            LAUNCHER_TASKBAR_EDUCATION_SHOWING, 1);
                }
            }

            @Override
            //监听动结束
            public void onAnimationEnd(Animator animation) {
                if (v instanceof BubbleTextView) {
                    //我们这里v是BubbleTextView类型
                    //设置控件v保持按下的状态为false
                    ((BubbleTextView) v).setStayPressed(false);
                }
                //获取LauncherTaskbarUIController的实例
                LauncherTaskbarUIController taskbarController = mLauncher.getTaskbarUIController();
                if (taskbarController != null) {
                    //调用shouldShowEdu()
                    taskbarController.showEdu();
                }
                //释放所有类型的RemoteAnimationTarget对象
                //包含壁纸、app和非app类型的RemoteAnimationTarget对象
                openingTargets.release();
            }
        });
        
        //initialWindowRadius用于设置动画开始时的窗口圆角半径
        //supportsRoundedCornersOnWindows(mLauncher.getResources()判断桌面是否支持窗口圆角
        final float initialWindowRadius = supportsRoundedCornersOnWindows(mLauncher.getResources())
                ? Math.max(crop.width(), crop.height()) / 2f
                : 0f;
        //finalWindowRadius用于设置动画结束时的窗口圆角半径
        //mDeviceProfile.isMultiWindowMode检查是否处于多窗口模式
        //getWindowCornerRadius(mLauncher)获取桌面窗口的圆角半径
        final float finalWindowRadius = mDeviceProfile.isMultiWindowMode
                ? 0 : getWindowCornerRadius(mLauncher);
        //inalShadowRadius用于设置动画结束时的阴影半径
        //appTargetsAreTranslucent表示应用目标是否半透明
        //mMaxShadowRadius最大阴影半径值
        final float finalShadowRadius = appTargetsAreTranslucent ? 0 : mMaxShadowRadius;
        
        MultiValueUpdateListener listener = new MultiValueUpdateListener() {
            //mDx：这个属性表示在动画过程中，X轴上的位移变化。
            //它从0开始，到prop.dX结束，动画时长为APP_LAUNCH_DURATION，使用mOpeningXInterpolator作为插值器。
            FloatProp mDx = new FloatProp(0, prop.dX, 0, APP_LAUNCH_DURATION,
                    mOpeningXInterpolator);
            //这个属性表示在动画过程中，Y轴上的位移变化。
            //它从0开始，到prop.dY结束，动画时长为APP_LAUNCH_DURATION，使用mOpeningInterpolator作为插值器。
            FloatProp mDy = new FloatProp(0, prop.dY, 0, APP_LAUNCH_DURATION,
                    mOpeningInterpolator);
            
            //mIconScaleToFitScreen：这个属性表示应用图标在屏幕上的缩放变化。
            //它从prop.initialAppIconScale开始，到prop.finalAppIconScale结束，
            //动画时长为APP_LAUNCH_DURATION，使用mOpeningInterpolator作为插值器。
            FloatProp mIconScaleToFitScreen = new FloatProp(prop.initialAppIconScale,
                    prop.finalAppIconScale, 0, APP_LAUNCH_DURATION, mOpeningInterpolator);
            //mIconAlpha：这个属性表示应用图标的透明度变化。
            //它从prop.iconAlphaStart开始，到0结束，
            //动画的开始延迟为APP_LAUNCH_ALPHA_START_DELAY，时长为APP_LAUNCH_ALPHA_DURATION，
            //使用线性插值器（LINEAR）。
            FloatProp mIconAlpha = new FloatProp(prop.iconAlphaStart, 0f,
                    APP_LAUNCH_ALPHA_START_DELAY, APP_LAUNCH_ALPHA_DURATION, LINEAR);

            //mWindowRadius：这个属性表示窗口圆角的半径变化。
            //它从initialWindowRadius开始，到finalWindowRadius结束，动画时长为APP_LAUNCH_DURATION，
            //使用mOpeningInterpolator作为插值器。
            FloatProp mWindowRadius = new FloatProp(initialWindowRadius, finalWindowRadius, 0,
                    APP_LAUNCH_DURATION, mOpeningInterpolator);
            //mShadowRadius：这个属性表示阴影的半径变化。
            //它从0开始，到finalShadowRadius结束，动画时长为APP_LAUNCH_DURATION，
            //使用mOpeningInterpolator作为插值器。
            FloatProp mShadowRadius = new FloatProp(0, finalShadowRadius, 0,
                    APP_LAUNCH_DURATION, mOpeningInterpolator);
 
            //mCropRectCenterX、mCropRectCenterY、mCropRectWidth、mCropRectHeight
            //这些属性分别表示裁剪矩形的中心X坐标、中心Y坐标、宽度和高度的变化。
            //它们都有各自的起始值和结束值，动画时长为APP_LAUNCH_DURATION，使用mOpeningInterpolator作为插值器。
            FloatProp mCropRectCenterX = new FloatProp(prop.cropCenterXStart, prop.cropCenterXEnd,
                    0, APP_LAUNCH_DURATION, mOpeningInterpolator);
            FloatProp mCropRectCenterY = new FloatProp(prop.cropCenterYStart, prop.cropCenterYEnd,
                    0, APP_LAUNCH_DURATION, mOpeningInterpolator);
            FloatProp mCropRectWidth = new FloatProp(prop.cropWidthStart, prop.cropWidthEnd, 0,
                    APP_LAUNCH_DURATION, mOpeningInterpolator);
            FloatProp mCropRectHeight = new FloatProp(prop.cropHeightStart, prop.cropHeightEnd, 0,
                    APP_LAUNCH_DURATION, mOpeningInterpolator);

            //这个属性表示导航栏的淡出效果。
            //它从1开始，到0结束，动画时长为ANIMATION_NAV_FADE_OUT_DURATION，
            //使用NAV_FADE_OUT_INTERPOLATOR作为插值器。
            FloatProp mNavFadeOut = new FloatProp(1f, 0f, 0, ANIMATION_NAV_FADE_OUT_DURATION,
                    NAV_FADE_OUT_INTERPOLATOR);
            //mNavFadeIn：这个属性表示导航栏的淡入效果。它从0开始，到1结束，
            //动画的开始延迟为ANIMATION_DELAY_NAV_FADE_IN，时长为ANIMATION_NAV_FADE_IN_DURATION，
            //使用NAV_FADE_IN_INTERPOLATOR作为插值器。
            FloatProp mNavFadeIn = new FloatProp(0f, 1f, ANIMATION_DELAY_NAV_FADE_IN,
                    ANIMATION_NAV_FADE_IN_DURATION, NAV_FADE_IN_INTERPOLATOR);
             
			//动画的更新
            @Override
            public void onUpdate(float percent, boolean initOnly) {
                // Calculate the size of the scaled icon.
				//计算缩放图标的大小
                float iconWidth = launcherIconBounds.width() * mIconScaleToFitScreen.value;
                float iconHeight = launcherIconBounds.height() * mIconScaleToFitScreen.value;

                int left = (int) (mCropRectCenterX.value - mCropRectWidth.value / 2);
                int top = (int) (mCropRectCenterY.value - mCropRectHeight.value / 2);
                int right = (int) (left + mCropRectWidth.value);
                int bottom = (int) (top + mCropRectHeight.value);
                crop.set(left, top, right, bottom);

                final int windowCropWidth = crop.width();
                final int windowCropHeight = crop.height();
                if (rotationChange != 0) {
                    Utilities.rotateBounds(crop, mDeviceProfile.widthPx,
                            mDeviceProfile.heightPx, rotationChange);
                }

                // Scale the size of the icon to match the size of the window crop.
				//缩放图标的大小以匹配窗口裁剪的大小。
                float scaleX = iconWidth / windowCropWidth;
                float scaleY = iconHeight / windowCropHeight;
                float scale = Math.min(1f, Math.max(scaleX, scaleY));

                float scaledCropWidth = windowCropWidth * scale;
                float scaledCropHeight = windowCropHeight * scale;
                float offsetX = (scaledCropWidth - iconWidth) / 2;
                float offsetY = (scaledCropHeight - iconHeight) / 2;

                // Calculate the window position to match the icon position.
				//计算窗口位置以匹配图标位置。
                tmpRectF.set(launcherIconBounds);
                tmpRectF.offset(dragLayerBounds[0], dragLayerBounds[1]);
                tmpRectF.offset(mDx.value, mDy.value);
                Utilities.scaleRectFAboutCenter(tmpRectF, mIconScaleToFitScreen.value);
                float windowTransX0 = tmpRectF.left - offsetX - crop.left * scale;
                float windowTransY0 = tmpRectF.top - offsetY - crop.top * scale;

                // Calculate the icon position.
				//计算图标位置
                floatingIconBounds.set(launcherIconBounds);
                floatingIconBounds.offset(mDx.value, mDy.value);
                Utilities.scaleRectFAboutCenter(floatingIconBounds, mIconScaleToFitScreen.value);
                floatingIconBounds.left -= offsetX;
                floatingIconBounds.top -= offsetY;
                floatingIconBounds.right += offsetX;
                floatingIconBounds.bottom += offsetY;

                if (initOnly) {
                    // For the init pass, we want full alpha since the window is not yet ready.
                    //使用floatingView.update方法更新浮动视图的属性，包括透明度、边界、半径等。  
                    floatingView.update(1f, 255, floatingIconBounds, percent, 0f,
                            mWindowRadius.value * scale, true /* isOpening */);
                    return;
                }

                SurfaceTransaction transaction = new SurfaceTransaction();
                
                //遍历桌面和启动应用的RemoteAnimationTarget，获取其leash，分别做处理
                for (int i = appTargets.length - 1; i >= 0; i--) {
                    RemoteAnimationTarget target = appTargets[i];
                    SurfaceProperties builder = transaction.forSurface(target.leash);

                    if (target.mode == MODE_OPENING) {
                    /**
                     * 如果目标模式是MODE_OPENING（打开模式），代码会设置一个矩阵（matrix）来进行缩放和平移操作。
                     * 根据rotationChange的值（可能是表示屏幕旋转的变量），代码会决定如何平移窗口。  
                     * 然后，使用floatingView.update方法更新浮动视图的属性，包括透明度、边界、半径等。  
                     * 接着，通过builder.setMatrix等方法设置窗口的矩阵、裁剪区域、透明度、圆角半径和阴影半径。
                     */
                        matrix.setScale(scale, scale);
                        if (rotationChange == 1) {
                            matrix.postTranslate(windowTransY0,
                                    mDeviceProfile.widthPx - (windowTransX0 + scaledCropWidth));
                        } else if (rotationChange == 2) {
                            matrix.postTranslate(
                                    mDeviceProfile.widthPx - (windowTransX0 + scaledCropWidth),
                                    mDeviceProfile.heightPx - (windowTransY0 + scaledCropHeight));
                        } else if (rotationChange == 3) {
                            matrix.postTranslate(
                                    mDeviceProfile.heightPx - (windowTransY0 + scaledCropHeight),
                                    windowTransX0);
                        } else {
                            matrix.postTranslate(windowTransX0, windowTransY0);
                        }

                        floatingView.update(mIconAlpha.value, 255, floatingIconBounds, percent, 0f,
                                mWindowRadius.value * scale, true /* isOpening */);
                        builder.setMatrix(matrix)
                                .setWindowCrop(crop)
                                .setAlpha(1f - mIconAlpha.value)
                                .setCornerRadius(mWindowRadius.value)
                                .setShadowRadius(mShadowRadius.value);
                    } else if (target.mode == MODE_CLOSING) {
                    /**
                     * 如果目标模式是MODE_CLOSING（关闭模式），代码会处理关闭动画。
                     * 首先，根据目标的本地边界或位置设置临时位置（tmpPos）。
                     * 然后，根据rotationChange的值，可能需要对裁剪区域（crop）和临时位置进行旋转调整。
                     * 最后，设置窗口的矩阵和裁剪区域，并将透明度设置为1（完全不透明）。
                     */
                        if (target.localBounds != null) {
                            tmpPos.set(target.localBounds.left, target.localBounds.top);
                        } else {
                            tmpPos.set(target.position.x, target.position.y);
                        }
                        final Rect crop = new Rect(target.screenSpaceBounds);
                        crop.offsetTo(0, 0);

                        if ((rotationChange % 2) == 1) {
                            int tmp = crop.right;
                            crop.right = crop.bottom;
                            crop.bottom = tmp;
                            tmp = tmpPos.x;
                            tmpPos.x = tmpPos.y;
                            tmpPos.y = tmp;
                        }
                        matrix.setTranslate(tmpPos.x, tmpPos.y);
                        builder.setMatrix(matrix)
                                .setWindowCrop(crop)
                                .setAlpha(1f);
                    }
                }

                /**
                 * 如果navBarTarget不为空（即存在导航栏目标），代码会为其设置动画和视图属性。 
                 * 根据`mNavFadeIn.value`的值，决定是淡入还是淡出导航栏。如果淡入值大于起始值，则应用淡入动画；
                 */
                if (navBarTarget != null) {
                    SurfaceProperties navBuilder =
                            transaction.forSurface(navBarTarget.leash);
                    if (mNavFadeIn.value > mNavFadeIn.getStartValue()) {
                        matrix.setScale(scale, scale);
                        matrix.postTranslate(windowTransX0, windowTransY0);
                        navBuilder.setMatrix(matrix)
                                .setWindowCrop(crop)
                                .setAlpha(mNavFadeIn.value);
                    } else {
                        navBuilder.setAlpha(mNavFadeOut.value);
                    }
                }
                surfaceApplier.scheduleApply(transaction);
            }
        };
        appAnimator.addUpdateListener(listener);
        // Since we added a start delay, call update here to init the FloatingIconView properly.
        //调用MultiValueUpdateListener.update更新动画显示
        listener.onUpdate(0, true /* initOnly */);

        // If app targets are translucent, do not animate the background as it causes a visible
        // flicker when it resets itself at the end of its animation.
        //appTargetsAreTranslucent，启动的应用为半透明
        //或 !launcherClosing，桌面在最顶层
        if (appTargetsAreTranslucent || !launcherClosing) {
            //仅设置appAnimator给animatorSet
            animatorSet.play(appAnimator);
        } else {
            //设置appAnimator和getBackgroundAnimator() (背景动画)
            //用于并行播放
            animatorSet.playTogether(appAnimator, getBackgroundAnimator());
        }
        return animatorSet;
    }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223
  • 224
  • 225
  • 226
  • 227
  • 228
  • 229
  • 230
  • 231
  • 232
  • 233
  • 234
  • 235
  • 236
  • 237
  • 238
  • 239
  • 240
  • 241
  • 242
  • 243
  • 244
  • 245
  • 246
  • 247
  • 248
  • 249
  • 250
  • 251
  • 252
  • 253
  • 254
  • 255
  • 256
  • 257
  • 258
  • 259
  • 260
  • 261
  • 262
  • 263
  • 264
  • 265
  • 266
  • 267
  • 268
  • 269
  • 270
  • 271
  • 272
  • 273
  • 274
  • 275
  • 276
  • 277
  • 278
  • 279
  • 280
  • 281
  • 282
  • 283
  • 284
  • 285
  • 286
  • 287
  • 288
  • 289
  • 290
  • 291
  • 292
  • 293
  • 294
  • 295
  • 296
  • 297
  • 298
  • 299
  • 300
  • 301
  • 302
  • 303
  • 304
  • 305
  • 306
  • 307
  • 308
  • 309
  • 310
  • 311
  • 312
  • 313
  • 314
  • 315
  • 316
  • 317
  • 318
  • 319
  • 320
  • 321
  • 322
  • 323
  • 324
  • 325
  • 326
  • 327
  • 328
  • 329
  • 330
  • 331
  • 332
  • 333
  • 334
  • 335
  • 336
  • 337
  • 338
  • 339
  • 340
  • 341
  • 342
  • 343
  • 344
  • 345
  • 346
  • 347
  • 348
  • 349
  • 350
  • 351
  • 352
  • 353

设置一些动画相关参数和监听，通过MultiValueUpdateListener.update方法更新动画显示。

调用setAnimation设置动画和回调

回到QuickstepTransitionManager.AppLaunchAnimationRunner.onCreateAnimation方法中，继续看到setAnimation方法：

result.setAnimation(anim, mLauncher, mOnEndCallback::executeAllAndDestroy,
                    skipFirstFrame);

  • 1
  • 2

前面的在getOpeningWindowAnimators方法中设置的动画，通过anim播放

动画的启动与结束

代码路径：packages/apps/Launcher3/quickstep/src/com/android/launcher3/LauncherAnimationRunner.java

        /**
         * Sets the animation to play for this app launch
         * @param skipFirstFrame Iff true, we skip the first frame of the animation.
         *                       We set to false when skipping first frame causes jank.
         */
        @UiThread
        public void setAnimation(AnimatorSet animation, Context context,
                @Nullable Runnable onCompleteCallback, boolean skipFirstFrame) {
            if (mInitialized) {
                throw new IllegalStateException("Animation already initialized");
            }
            mInitialized = true;
            mAnimator = animation;
            mOnCompleteCallback = onCompleteCallback;
            //如果动画为空，直接调用finish方法，走结束动画流程
            if (mAnimator == null) {
                finish();
            } else if (mFinished) {//mFinished为true，表示动画播放结束
                // Animation callback was already finished, skip the animation.
                //调用mAnimator.start()和mAnimator.end()来跳过动画
                mAnimator.start();
                mAnimator.end();
                if (mOnCompleteCallback != null) {
                    mOnCompleteCallback.run();
                }
            } else {
                // Start the animation
                //添加动画监听
                mAnimator.addListener(new AnimatorListenerAdapter() {
                    @Override
                    //动画结束时的监听，调用finish()方法
                    public void onAnimationEnd(Animator animation) {
                        finish();
                    }
                });
                //开始播放动画
                mAnimator.start();
                
                //如果skipFirstFrame为true
                if (skipFirstFrame) {
                    // Because t=0 has the app icon in its original spot, we can skip the
                    // first frame and have the same movement one frame earlier.
                    //调用mAnimator.setCurrentPlayTime()来设置动画的当前播放时间,
                    //该时间为动画总时长与getSingleFrameMs(context)的较小值。
                    //这可以使得应用图标从原始位置开始的移动提前一帧，
                    //因为t=0时应用图标位于其原始位置。
                    mAnimator.setCurrentPlayTime(
                            Math.min(getSingleFrameMs(context), mAnimator.getTotalDuration()));
                }
            }
        }
    }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52

这个方法主要是通过mAnimator.start();启动动画的播放。当动画播放结束时，使用finish();方法进入动画结束播放流程。

动画播放结束

动画播放结束时，调用finish方法进入结束动画流程

代码路径：packages/apps/Launcher3/quickstep/src/com/android/launcher3/LauncherAnimationRunner.java

    public static final class AnimationResult {
        ......
        @UiThread
        private void finish() {
            if (!mFinished) {
                //运行的是 () -> mAnimationResult = null
                //即把AnimationResult对象置空
                mSyncFinishRunnable.run();
                UI_HELPER_EXECUTOR.execute(() -> {
                    //运行的是IRemoteAnimationFinishedCallback.onAnimationFinished
                    mASyncFinishRunnable.run();
                    if (mOnCompleteCallback != null) {
                        MAIN_EXECUTOR.execute(mOnCompleteCallback);
                    }
                });
                //mFinished标志位置为true，表示动画播放完成。
                mFinished = true;
            }
        }
        ......
    }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

前面跨进程通信时，对AnimationResult构造方法进行了初始化

private AnimationResult(Runnable syncFinishRunnable, Runnable asyncFinishRunnable) {
            mSyncFinishRunnable = syncFinishRunnable;
            mASyncFinishRunnable = asyncFinishRunnable;
        }

  • 1
  • 2
  • 3
  • 4

并且onAnimationStart方法中给创建了AnimationResult对象，传递了两个runnable。
mAnimationResult = new AnimationResult(() -> mAnimationResult = null, runnable);
这里传递的runnable就是跨进程通信传递过来的动画完成时回调。

即mSyncFinishRunnable表示的就是() -> mAnimationResult = null，置空AnimationResult对象；
mASyncFinishRunnable表示的就是IRemoteAnimationFinishedCallback.onAnimationFinished方法，即跨进程调用结束动画流程。

跨进程通信进入动画结束流程

代码路径：frameworks/base/core/java/android/view/IRemoteAnimationFinishedCallback.aidl

/**
 * Interface to be invoked by the controlling process when a remote animation has finished.
 *
 * @see IRemoteAnimationRunner
 * {@hide}
 */
oneway interface IRemoteAnimationFinishedCallback {
    @UnsupportedAppUsage
    void onAnimationFinished();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

IRemoteAnimationFinishedCallback的实现在RemoteAnimationController.FinishedCallback类中

进入系统进程结束动画

跨进程通信，实现IRemoteAnimationFinishedCallback

代码路径：frameworks/base/services/core/java/com/android/server/wm/RemoteAnimationController.java

    private static final class FinishedCallback extends IRemoteAnimationFinishedCallback.Stub {

        RemoteAnimationController mOuter;

        FinishedCallback(RemoteAnimationController outer) {
            mOuter = outer;
        }

        @Override
        public void onAnimationFinished() throws RemoteException {
            ProtoLog.d(WM_DEBUG_REMOTE_ANIMATIONS, "app-onAnimationFinished(): mOuter=%s", mOuter);
            final long token = Binder.clearCallingIdentity();
            try {
                if (mOuter != null) {
                    mOuter.onAnimationFinished();

                    // In case the client holds on to the finish callback, make sure we don't leak
                    // RemoteAnimationController which in turn would leak the runner on the client.
                    mOuter = null;
                }
            } finally {
                Binder.restoreCallingIdentity(token);
            }
        }

        /**
         * Marks this callback as not be used anymore by releasing the reference to the outer class
         * to prevent memory leak.
         */
        void release() {
            ProtoLog.d(WM_DEBUG_REMOTE_ANIMATIONS, "app-release(): mOuter=%s", mOuter);
            mOuter = null;
        }
    };

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34

这段代码的关键就是调用mOuter.onAnimationFinished();

onAnimationFinished方法的实现

private void onAnimationFinished() {
        ProtoLog.d(WM_DEBUG_REMOTE_ANIMATIONS, "onAnimationFinished(): mPendingAnimations=%d",
                mPendingAnimations.size());
        //移除超时回调
        mHandler.removeCallbacks(mTimeoutRunnable);
        synchronized (mService.mGlobalLock) {
            //解除绑定IRemoteAnimationRunner
            unlinkToDeathOfRunner();
            //释放绑定的IRemoteAnimationFinishedCallback
            releaseFinishedCallback();
            //开启事务
            mService.openSurfaceTransaction();
            try {
                ProtoLog.d(WM_DEBUG_REMOTE_ANIMATIONS,
                        "onAnimationFinished(): Notify animation finished:");
                //app类型动画结束时回调
                //调用桌面和启动应用的动画结束时回调
                for (int i = mPendingAnimations.size() - 1; i >= 0; i--) {
                    final RemoteAnimationRecord adapters = mPendingAnimations.get(i);
                    if (adapters.mAdapter != null) {
                        adapters.mAdapter.mCapturedFinishCallback
                                .onAnimationFinished(adapters.mAdapter.mAnimationType,
                                        adapters.mAdapter);
                    }
                    if (adapters.mThumbnailAdapter != null) {
                        adapters.mThumbnailAdapter.mCapturedFinishCallback
                                .onAnimationFinished(adapters.mThumbnailAdapter.mAnimationType,
                                        adapters.mThumbnailAdapter);
                    }
                    mPendingAnimations.remove(i);
                    ProtoLog.d(WM_DEBUG_REMOTE_ANIMATIONS, "\tcontainer=%s",
                            adapters.mWindowContainer);
                }

                //壁纸类型动画结束时回调
                for (int i = mPendingWallpaperAnimations.size() - 1; i >= 0; i--) {
                    final WallpaperAnimationAdapter adapter = mPendingWallpaperAnimations.get(i);
                    adapter.getLeashFinishedCallback().onAnimationFinished(
                            adapter.getLastAnimationType(), adapter);
                    mPendingWallpaperAnimations.remove(i);
                    ProtoLog.d(WM_DEBUG_REMOTE_ANIMATIONS, "\twallpaper=%s", adapter.getToken());
                }

                //非App类型动画结束时回调
                for (int i = mPendingNonAppAnimations.size() - 1; i >= 0; i--) {
                    final NonAppWindowAnimationAdapter adapter = mPendingNonAppAnimations.get(i);
                    adapter.getLeashFinishedCallback().onAnimationFinished(
                            adapter.getLastAnimationType(), adapter);
                    mPendingNonAppAnimations.remove(i);
                    ProtoLog.d(WM_DEBUG_REMOTE_ANIMATIONS, "\tnonApp=%s",
                            adapter.getWindowContainer());
                }
            } catch (Exception e) {
                Slog.e(TAG, "Failed to finish remote animation", e);
                throw e;
            } finally {
                mService.closeSurfaceTransaction("RemoteAnimationController#finished");
            }
            // Reset input for all activities when the remote animation is finished.
            final Consumer<ActivityRecord> updateActivities =
                    activity -> activity.setDropInputForAnimation(false);
            mDisplayContent.forAllActivities(updateActivities);
        }
        setRunningRemoteAnimation(false);
        ProtoLog.i(WM_DEBUG_REMOTE_ANIMATIONS, "Finishing remote animation");
    }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66

我们这里主要关注的是App类型的动画结束流程，这里通过循环，把桌面和启动的应用动画结束时流程逐个调用。这个循环是反向遍历，因此先走的是桌面动画结束时的回调。

adapters.mAdapter.mCapturedFinishCallback
		  .onAnimationFinished(adapters.mAdapter.mAnimationType,
		          adapters.mAdapter);

  • 1
  • 2
  • 3

mCapturedFinishCallback是RemoteAnimationAdapterWrapper对象，它其实就是SurfaceAnimator.getFinishedCallback方法。

在创建动画leash的流程中，SurfaceAnimator.startAnimation方法中有调用mAnimation.startAnimation(mLeash, t, type, mInnerAnimationFinishedCallback);，这里把mInnerAnimationFinishedCallback赋值给了RemoteAnimationAdapterWrapper的mCapturedFinishCallback，mInnerAnimationFinishedCallback在SurfaceAnimator的构造方法初始化的值是getFinishedCallback(staticAnimationFinishedCallback)，即动画完成时的回调mCapturedFinishCallback对应的就是getFinishedCallback(staticAnimationFinishedCallback)。

所以这里mCapturedFinishCallback.onAnimationFinished调用的，实际是调用就是SurfaceAnimator.getFinishedCallback中匿名的(type, anim) -> {......}

回调处理动画完成的逻辑

这里的流程与本地动画流程相似
代码路径：frameworks/base/services/core/java/com/android/server/wm/SurfaceAnimator.java

    private OnAnimationFinishedCallback getFinishedCallback(
            @Nullable OnAnimationFinishedCallback staticAnimationFinishedCallback) {
        return (type, anim) -> {
            synchronized (mService.mGlobalLock) {
                //移除AnimationAdapter对应的SurfaceAnimator，并将这个SurfaceAnimator返回给target
                //mAnimationTransferMap属于启动窗口的动画场景，这里我们不涉及
                final SurfaceAnimator target = mService.mAnimationTransferMap.remove(anim);
                if (target != null) {
                    //递归调用onAnimationFinished(type, anim)，即return (type, anim) -> {......}
                    //直到所有的SurfaceAnimator移除完
                    target.mInnerAnimationFinishedCallback.onAnimationFinished(type, anim);
                    return;
                }

                //检查动画是否已被新动画替换，如果当前动画 (anim) 不等于之前存储的动画 (mAnimation)，则不执行后续操作
                if (anim != mAnimation) {
                    return;
                }
                //定义一个名为 resetAndInvokeFinish 的 Runnable
                final Runnable resetAndInvokeFinish = () -> {
                    // We need to check again if the animation has been replaced with a new
                    // animation because the animatable may defer to finish.
                    //再次检查动画是否已被新动画替换，因为可设置动画可能会延迟到完成。
                    if (anim != mAnimation) {
                        return;
                    }
                    //mSurfaceAnimationFinishedCallback是在WindowContainer.startAnimation中赋值的
                    //其传递值为null，最终SurfaceAnimator.startAnimation赋值给mSurfaceAnimationFinishedCallback
                    final OnAnimationFinishedCallback animationFinishCallback =
                            mSurfaceAnimationFinishedCallback;
                    //重置与动画相关的状态
                    reset(mAnimatable.getSyncTransaction(), true /* destroyLeash */);
                    //WindowContainer构造方法中给SurfaceAnimator构造方法传递了staticAnimationFinishedCallback
                    if (staticAnimationFinishedCallback != null) {
                        //当一个Surface上的动画结束或取消且不重新启动时，这个回调将被执行。
                        //这是一个静态回调，它对通过这个 SurfaceAnimator 启动的所有动画都有效。
                        //回调WindowContainer.onAnimationFinished方法
                        staticAnimationFinishedCallback.onAnimationFinished(type, anim);
                    }
                    //mSurfaceAnimationFinishedCallback的值为null，因此animationFinishCallback的值为null
                    if (animationFinishCallback != null) {
                        //当一个Surface上的动画结束或取消且不重新启动时，这个回调将被执行。
                        //这个回调是每个动画（即每个 AnimationAdapter）特有的。
                        //如果在WindowContainer.startAnimation方法中有赋值，
                        //则回调WindowContainer.onAnimationFinished方法
                        animationFinishCallback.onAnimationFinished(type, anim);
                    }
                };
                // If both the Animatable and AnimationAdapter requests to be deferred, only the
                // first one will be called.
                //如果 mAnimatable 或动画本身请求延迟动画完成，并且它们都没有被延迟，
                //那么直接执行 resetAndInvokeFinish.run()。否则，延迟执行。
                if (!(mAnimatable.shouldDeferAnimationFinish(resetAndInvokeFinish)
                        || anim.shouldDeferAnimationFinish(resetAndInvokeFinish))) {
                    resetAndInvokeFinish.run();
                }
                //设置动画完成标志,将 mAnimationFinished 设置为 true
                mAnimationFinished = true;
            }
        };
    }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61

这个方法主要做了这几件事：

  1. 通过递归的方式移除所有AnimationAdapter对应的SurfaceAnimator
    其中的mAnimationTransferMap在启动窗口流程中，ActivityRecord.addStartingWindow中有调用transferStartingWindow方法，逐步调用到SurfaceAnimator.transferAnimation中进行添加mService.mAnimationTransferMap.put(mAnimation, this);，这里我们不涉及，因此target的值为null
  2. 使用shouldDeferAnimationFinish方法（默认返回false）用来判断是否需要延迟完成动画
  3. 执行resetAndInvokeFinish.run()，调用reset(mAnimatable.getSyncTransaction(), true /* destroyLeash */);重置动画相关状态
  4. 最后调用回调通过staticAnimationFinishedCallback.onAnimationFinished(type, anim);，调用WindowContainer.onAnimationFinished方法处理和响应动画完成的逻辑

重置动画相关状态并移除leash

reset(mAnimatable.getSyncTransaction(), true /* destroyLeash */);
代码路径：frameworks/base/services/core/java/com/android/server/wm/SurfaceAnimator.java

    private void reset(Transaction t, boolean destroyLeash) {
        //移除AnimationAdapter对应的SurfaceAnimator
        mService.mAnimationTransferMap.remove(mAnimation);
        mAnimation = null;
        mSurfaceAnimationFinishedCallback = null;
        //动画类型置为空
        mAnimationType = ANIMATION_TYPE_NONE;
        //屏幕冻结时的快照
        final SurfaceFreezer.Snapshot snapshot = mSnapshot;
        mSnapshot = null;
        if (snapshot != null) {
            // Reset the mSnapshot reference before calling the callback to prevent circular reset.
            //如果有屏幕冻结时的快照，取消该动画。
            //最终会调用到SurfaceAnimationRunner.onAnimationCancelled
            snapshot.cancelAnimation(t, !destroyLeash);
        }
        if (mLeash == null) {
            return;
        }
        //使用leash存储动画图层mLeash
        SurfaceControl leash = mLeash;
        //把动画图层置为空
        mLeash = null;
        //移除leash
        final boolean scheduleAnim = removeLeash(t, mAnimatable, leash, destroyLeash);
        //将mAnimationFinished设置为false
        mAnimationFinished = false;
        if (scheduleAnim) {
            //leash成功移除后,在WMS中会通过WindowAnimator调度动画，协调各个窗口
            mService.scheduleAnimationLocked();
        }
    }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
移除leash

调用removeLeash方法移除leash
final boolean scheduleAnim = removeLeash(t, mAnimatable, leash, destroyLeash);
传递的mAnimatable表示当前窗口，leash就是动画图层，destroyLeash在前面getFinishedCallback流程中传递的值为true

    static boolean removeLeash(Transaction t, Animatable animatable, @NonNull SurfaceControl leash,
                               boolean destroy) {
        /* log add start*/
        Slog.i("WindowManager:","removeLeash leash = " + leash , new Exception());
        /* log add end*/
        //scheduleAnim一个标志位，初始值为false
        //为true时，走前面reset方法中的mService.scheduleAnimationLocked()流程
        boolean scheduleAnim = false;
        //获取当前窗口的SurfaceControl
        final SurfaceControl surface = animatable.getSurfaceControl();
        //获取当前窗口的父窗口的SurfaceControl
        final SurfaceControl parent = animatable.getParentSurfaceControl();
        //获取动画图层
        final SurfaceControl curAnimationLeash = animatable.getAnimationLeash();
        // If the surface was destroyed or the leash is invalid, we don't care to reparent it back.
        // Note that we also set this variable to true even if the parent isn't valid anymore, in
        // order to ensure onAnimationLeashLost still gets called in this case.
        // If the animation leash is set, and it is different from the removing leash, it means the
        // surface now has a new animation surface. We don't want to reparent for that.
        //1.surface不为空
        //2.curAnimationLeash不为空，且curAnimationLeash等于leash
        //因此reparent值为true
        final boolean reparent = surface != null && (curAnimationLeash == null
                || curAnimationLeash.equals(leash));
        if (reparent) {
            ProtoLog.i(WM_DEBUG_ANIM, "Reparenting to original parent: %s for %s",
                    parent, animatable);
            // We shouldn't really need these isValid checks but we do
            // b/130364451
            //判断当前窗口的surface是否有效，以及该窗口的父窗口的图层不为空且有效
            if (surface.isValid() && parent != null && parent.isValid()) {
                //把当前窗口图层和其父窗口的图层重新建立父子关系
                t.reparent(surface, parent);
                //scheduleAnim置为true
                scheduleAnim = true;
            }
        }
        //destroy传递过来值为true
        if (destroy) {
            //移除图层
            t.remove(leash);
            //scheduleAnim置为true
            scheduleAnim = true;
        }

        if (reparent) {
            // Make sure to inform the animatable after the surface was reparented (or reparent
            // wasn't possible, but we still need to invoke the callback)
            //1.移除和leash相关联的窗口和surface(这个只在前面requiresEdgeExtension为true时逻辑中有涉及)
            //2.调整surface
            animatable.onAnimationLeashLost(t);
            //scheduleAnim置为true
            scheduleAnim = true;
        }
        return scheduleAnim;
    }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56

  • 获取当前窗口的图层
    final SurfaceControl surface = animatable.getSurfaceControl();
    代码路径：frameworks/base/services/core/java/com/android/server/wm/WindowContainer.java

        /**
     * @return The SurfaceControl for this container.
     *         The SurfaceControl must be valid if non-null.
     */
    @Override
    public SurfaceControl getSurfaceControl() {
        return mSurfaceControl;
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    直接返回一个SurfaceControl。

  • 获取当前窗口父窗口的图层
    代码路径：frameworks/base/services/core/java/com/android/server/wm/WindowContainer.java

        /*
     * @return The SurfaceControl parent for this containers SurfaceControl.
     *         The SurfaceControl must be valid if non-null.
     */
    @Override
    public SurfaceControl getParentSurfaceControl() {
        final WindowContainer parent = getParent();
        if (parent == null) {
            return null;
        }
        return parent.getSurfaceControl();
    }
    
   @Override
   final protected WindowContainer getParent() {
       return mParent;
   }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    先获取当前窗口的父窗口，在获取父窗口的SurfaceControl。

  • 获取动画图层
    代码路径：frameworks/base/services/core/java/com/android/server/wm/WindowContainer.java

    @Override
    public SurfaceControl getAnimationLeash() {
        return mAnimationLeash;
    }

    • 1
    • 2
    • 3
    • 4

    mAnimationLeash是前面SurfaceAnimator的startAnimation方法中的mAnimatable.onAnimationLeashCreated(t, mLeash);，把mLeash赋值给了mAnimationLeash，因此这个方法获取的是动画图层。

  • 当前窗口图层和其父窗口的图层重新建立父子关系
    t.reparent(surface, parent);
    桌面的SurfaceControl重新认DefaultTaskDsiplayArea的SurfaceControl为父。
    代码路径：frameworks/base/core/java/android/view/SurfaceControl.java

            /**
         * Re-parents a given layer to a new parent. Children inherit transform (position, scaling)
         * crop, visibility, and Z-ordering from their parents, as if the children were pixels within the
         * parent Surface.
         *
         * @param sc The SurfaceControl to reparent
         * @param newParent The new parent for the given control.
         * @return This Transaction
         */
        @NonNull
        public Transaction reparent(@NonNull SurfaceControl sc,
                @Nullable SurfaceControl newParent) {
            //检查传入的SurfaceControl对象是否满足某些预设条件
            checkPreconditions(sc);
            long otherObject = 0;
            if (newParent != null) {
            	//检查新父对象是否被释放。如果已经被释放，那么它会抛出异常。
                newParent.checkNotReleased();
                //新父对象不为null且未被释放，那么将新父对象的Native对象赋值给otherObject。
                otherObject = newParent.mNativeObject;
            }
            //传入了三个参数：1.当前对象的Native对象 2.被重新设置父对象的SurfaceControl的Native对象 3.新父对象的Native对象。
            //用于实现重新设置父对象的具体操作。
            nativeReparent(mNativeObject, sc.mNativeObject, otherObject);
            //把被重新设置父对象的SurfaceControl和新父对象存储到mReparentedSurfaces这个map中。
            mReparentedSurfaces.put(sc, newParent);
            return this;
        }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

    前面说过reparent方法中通过mReparentedSurfaces这个ArrayMap临时存储父子关系，key值存储SurfaceControl对象，value为其父SurfaceControl对象（当前窗口的父窗口的SurfaceControl，即DefaultTaskDsiplayArea的SurfaceControl）
    此时leash还没有被释放，DefaultTaskDsiplayArea的SurfaceControl有两个儿子SurfaceControl，(以桌面为例)关系如下图所示：
    在这里插入图片描述

    此时leash逐渐发现不对劲，但是假装不知道
    假如我们后面不执行移除leash图层的操作，那么这个图层一直会保持这个状态挂在DefaultTaskDsiplayArea上和桌面Task共享父亲。

  • 移除动画图层
    t.remove(leash);

            /**
         * Equivalent to reparent with a null parent, in that it removes
         * the SurfaceControl from the scene, but it also releases
         * the local resources (by calling {@link SurfaceControl#release})
         * after this method returns, {@link SurfaceControl#isValid} will return
         * false for the argument.
         *
         * @param sc The surface to remove and release.
         * @return This transaction
         * @hide
         */
        @NonNull
        public Transaction remove(@NonNull SurfaceControl sc) {
            reparent(sc, null);
            sc.release();
            return this;
        }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    同样调用了reparent方法，先把需要remove的图层的父图层置空，然后释放。
    过程如下所示：
    在这里插入图片描述
    leash：原来我才是多余的那个，悠悠苍天，何薄于我！

  • 移除和leash相关联的窗口和surface并调整surface
    animatable.onAnimationLeashLost(t);
    代码路径：frameworks/base/services/core/java/com/android/server/wm/WindowContainer.java

        @Override
    public void onAnimationLeashLost(Transaction t) {
        mLastLayer = -1;
        //调用mWmService中的mSurfaceAnimationRunner对象的onAnimationLeashLost方法
        //用于移除和leash相关联的窗口,这个只在前面requiresEdgeExtension为true时逻辑中有涉及
        mWmService.mSurfaceAnimationRunner.onAnimationLeashLost(mAnimationLeash, t);
        //mAnimationLeash置为空
        mAnimationLeash = null;
        mNeedsZBoost = false;
        //调整其所有child的z-order
        reassignLayer(t);
        //更新Surface位置
        updateSurfacePosition(t);
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    其中mWmService.mSurfaceAnimationRunner.onAnimationLeashLost(mAnimationLeash, t);的mAnimationLeash前面说过就是动画图层。这个只在前面SurfaceAnimationRunner的startAnimation方法中requiresEdgeExtension为true时逻辑中有涉及，其为true时才会操作mEdgeExtensions这个ArrayList，这里不讨论。

协调动画显示

在SurfaceAnimator.reset()方法最后调用了mService.scheduleAnimationLocked();
代码路径：frameworks/base/services/core/java/com/android/server/wm/WindowManagerService.java

    void scheduleAnimationLocked() {
        mAnimator.scheduleAnimation();
    }

    void scheduleAnimation() {
        if (!mAnimationFrameCallbackScheduled) {
            //mAnimationFrameCallbackScheduled 设置为 true，表示动画帧回调已经安排
            mAnimationFrameCallbackScheduled = true;
            //每一帧被绘制时，回调mAnimationFrameCallback
            mChoreographer.postFrameCallback(mAnimationFrameCallback);
        }
    }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

这个方法的主要作用是确保动画帧回调被正确地安排，以便在每一帧绘制时执行，可以确保动画在每一帧都被调用，从而平滑地更新和显示动画。

处理和响应动画完成的逻辑

回到SurfaceAnimator.getFinishedCallback中匿名的onAnimationFinished方法中有调用staticAnimationFinishedCallback.onAnimationFinished(type, anim);处理和响应动画完成的逻辑。

这里的staticAnimationFinishedCallback也是在SurfaceAnimator构造方法中初始化的

  SurfaceAnimator(Animatable animatable,
           @Nullable OnAnimationFinishedCallback staticAnimationFinishedCallback,
           WindowManagerService service) {
       mAnimatable = animatable;
       mService = service;
       mStaticAnimationFinishedCallback = staticAnimationFinishedCallback;
       mInnerAnimationFinishedCallback = getFinishedCallback(staticAnimationFinishedCallback);
   }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

在WindowContainer构造方法中初始化mSurfaceAnimator = new SurfaceAnimator(this, this::onAnimationFinished, wms);，因此staticAnimationFinishedCallback.onAnimationFinished对应的就是WindowContainer.onAnimationFinished方法

代码路径：frameworks/base/services/core/java/com/android/server/wm/WindowContainer.java

    /**
     * Called when an animation has finished running.
     */
		protected void onAnimationFinished(@AnimationType int type, AnimationAdapter anim) {
		       //主要用于 清空 mSurfaceAnimationSources 列表
		       doAnimationFinished(type, anim);
		       //WindowManagerService中实现onAnimationFinished()
		       //用于唤醒所有等待mGlobalLock对象的线程，确保多个线程能够正确地执行任务
		       mWmService.onAnimationFinished();
		       //将 mNeedsZBoost 设置为 false，表示不再需要Z轴增强
		       mNeedsZBoost = false;
		   }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

这个里面又调用了另一个doAnimationFinished(type, anim);

		private void doAnimationFinished(@AnimationType int type, AnimationAdapter anim) {
	        for (int i = 0; i < mSurfaceAnimationSources.size(); ++i) {
	            //mSurfaceAnimationSources中每个容器，做对应的onAnimationFinished
	            mSurfaceAnimationSources.valueAt(i).onAnimationFinished(type, anim);
	        }
	        //清除动画源列表
	        mSurfaceAnimationSources.clear();
	        if (mDisplayContent != null) {
		        //调用DisplayContent的onWindowAnimationFinished方法
		        //从当前源码上看，主要是针对输入法相关做了一些操作
	            mDisplayContent.onWindowAnimationFinished(this, type);
	        }
	    }

		

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

WindowContainer.cancelAnimation方法中调用的doAnimationFinished也是这个方法。

我们这里mSurfaceAnimationSources是保存的是需要做动画的ActivityRecord，即桌面ActivityRecord和启动应用的ActivityRecord。
mSurfaceAnimationSources的值是在前面系统侧动画启动流程中WindowContainer.applyAnimationUnchecked方法中添加的。
mSurfaceAnimationSources.valueAt(i).onAnimationFinished(type, anim);调用了不同容器onAnimationFinished方法，在ActivityRecord和WindowState中都重写了这个方法。我们这里是远程动画，主要调用的就是ActivityRecord中重写的onAnimationFinished方法。

代码路径：frameworks/base/services/core/java/com/android/server/wm/ActivityRecord.java

    @Override
    protected void onAnimationFinished(@AnimationType int type, AnimationAdapter anim) {
        super.onAnimationFinished(type, anim);

        Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, "AR#onAnimationFinished");
        //更新标志位
        mTransit = TRANSIT_OLD_UNSET;
        mTransitFlags = 0;
       
        //更新应用的布局变化
        setAppLayoutChanges(FINISH_LAYOUT_REDO_ANIM | FINISH_LAYOUT_REDO_WALLPAPER,
                "ActivityRecord");

        //清除缩略图
        clearThumbnail();
        //更新应用的可见性状态
        setClientVisible(isVisible() || mVisibleRequested);

        getDisplayContent().computeImeTargetIfNeeded(this);

        ProtoLog.v(WM_DEBUG_ANIM, "Animation done in %s"
                + ": reportedVisible=%b okToDisplay=%b okToAnimate=%b startingDisplayed=%b",
                this, reportedVisible, okToDisplay(), okToAnimate(),
                isStartingWindowDisplayed());

        // clean up thumbnail window
        if (mThumbnail != null) {
            mThumbnail.destroy();
            mThumbnail = null;
        }

        // WindowState.onExitAnimationDone might modify the children list, so make a copy and then
        // traverse the copy.
        //通知子窗口动画结束
        final ArrayList<WindowState> children = new ArrayList<>(mChildren);
        children.forEach(WindowState::onExitAnimationDone);
        // The starting window could transfer to another activity after app transition started, in
        // that case the latest top activity might not receive exit animation done callback if the
        // starting window didn't applied exit animation success. Notify animation finish to the
        // starting window if needed.
        //通知启动窗口动画结束
        if (task != null && startingMoved) {
            final WindowState transferredStarting = task.getWindow(w ->
                    w.mAttrs.type == TYPE_APPLICATION_STARTING);
            if (transferredStarting != null && transferredStarting.mAnimatingExit
                    && !transferredStarting.isSelfAnimating(0 /* flags */,
                    ANIMATION_TYPE_WINDOW_ANIMATION)) {
                transferredStarting.onExitAnimationDone();
            }
        }
        //通知应用过渡动画结束
        getDisplayContent().mAppTransition.notifyAppTransitionFinishedLocked(token);
        //协调动画显示
        scheduleAnimation();

        // Schedule to handle the stopping and finishing activities which the animation is done
        // because the activities which were animating have not been stopped yet.
        // 如果需要，调度处理停止和结束活动的任务。这是必要的，因为正在动画的活动可能还没有被停止。
        mTaskSupervisor.scheduleProcessStoppingAndFinishingActivitiesIfNeeded();
        Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);
    }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61

协调动画显示

和前面在SurfaceAnimator.reset()方法最后调用了mService.scheduleAnimationLocked();相似，
这里我们调用的scheduleAnimation();
代码路径：frameworks/base/services/core/java/com/android/server/wm/WindowContainer.java

    /**
     * Trigger a call to prepareSurfaces from the animation thread, such that pending transactions
     * will be applied.
     */
    void scheduleAnimation() {
        mWmService.scheduleAnimationLocked();
    }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

代码路径：frameworks/base/services/core/java/com/android/server/wm/WindowManagerService.java

    void scheduleAnimationLocked() {
        mAnimator.scheduleAnimation();
    }


  • 1
  • 2
  • 3
  • 4

最终调用到了WindowAnimator.scheduleAnimation()
代码路径：frameworks/base/services/core/java/com/android/server/wm/WindowAnimator.java

    void scheduleAnimation() {
        if (!mAnimationFrameCallbackScheduled) {
            //mAnimationFrameCallbackScheduled 设置为 true，表示动画帧回调已经安排
            mAnimationFrameCallbackScheduled = true;
            //每一帧被绘制时，回调mAnimationFrameCallback
            mChoreographer.postFrameCallback(mAnimationFrameCallback);
        }
    }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

这个方法的主要作用是确保动画帧回调被正确地安排，以便在每一帧绘制时执行，可以确保动画在每一帧都被调用，从而平滑地更新和显示动画。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Monodyee/article/detail/174328
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号