WindowManagerService动画分析

  我们知道Android动画主要包括Activity切换动画、窗口动画、转屏动画、窗口内部View动画，前三者在WindowManagerService(简称WMS)中完成，本篇文章重点分析Activity切换动画、窗口动画的设置，动画每一帧计算，及如何快速分析动画类型资源。阅读本文最好有一定的WindowManagerService基础，本文所有代码基于AndroidM。

    典型的Activity切换动画包括：activityOpenEnterAnimation，activityOpenExitAnimation，taskOpenEnterAnimation， taskCloseExitAnimation， wallpaperOpenEnterAnimation， wallpaperCloseEnterAnimation。典型的窗口动画包括：windowEnterAnimation，windowExitAnimation。

    我们知道每一个Activity在WMS中对应有一个APPWindowToken，APPWindowToken内部有一个AppWindowAnimator类型对象，Activity切换动画逻辑便是在AppTransition、AppWindowAnimator中完成。每个Activity一般情况下都有一个窗口，窗口是用WindowState来描述的，每个窗口有一个WindowStateAnimator类型对象，这个对象管理着窗口Surface和窗口动画。有了这些基本信息，下面就来分析Activity切换和窗口动画。

    文章会分为四个部分，分别为：Activity切换动画设 置，窗口动画设置，动画每一帧计算， 通过日志快速分析动画资源来自哪里。

第一部分：Activity切换动画设置

    Activity切换动画设置主要包含下面这些步骤，每个步骤按时序图中的顺序依次执行，对于重要的步骤我已标注并附上简单的解释，下面将仔细分析每一步。

第1步、WMS.prepareAppTransition()

    AMS调用 WMS. prepareAppTransition()设置Activity切换动画类型。比较常见的就是TRANSIT_ACTIVITY_OPEN、TRANSIT_ACTIVITY_CLOSE、TRANSIT_TASK_OPEN、TRANSIT_TASK_CLOSE、TRANSIT_TASK_TO_FRONT、TRANSIT_TASK_TO_BACK这几种Activity切换动画类型了。prepareAppTransition()函数做了两件事：①将动画类型设置到AppTransition中，后面将用到这个值；②发送一个APP_TRANSITION_TIMEOUT的5s超时消息。

第2步、WMS.setAppVisibility()

    AMS调用WMS.setAppVisibility()设置Activity可见性。一般情况下在一次Activity切换过程中会有两个Activity的可见性发生变化，pre Activity变为不可见，next Activity变为可见。这个函数有两条逻辑：①前面已经调用WMS.prepareAppTransition()设置了Activity切换动画类型，那么将可见Activity加入mOpeningApps，不可见Activity加入mClosingApps，同时调用AppWindowToken.sendAppVisibilityToClients()通知应用窗口可见性变化。mOpeningApps、mClosingApps这两个变量就是为Activity切换动画而存在的，将在后面用到；②没有调用过WMS.prepareAppTransition()，那么直接调用WMS.setTokenVisibilityLocked()，这个函数将在第11步中分析。

public void setAppVisibility(IBinder token, boolean visible) {
    ......
    synchronized(mWindowMap) {
        wtoken = findAppWindowToken(token);
        ......
        // If we are preparing an app transition, then delay changing
        // the visibility of this token until we execute that transition.
        if (okToDisplay() && mAppTransition.isTransitionSet()) {
            ......
            wtoken.inPendingTransaction = true;
            if (visible) {
                mOpeningApps.add(wtoken);          //将可见Activity加到mOpeningApps中；
                wtoken.startingMoved = false;
                wtoken.mEnteringAnimation = true;

                // If the token is currently hidden (should be the
                // common case), then we need to set up to wait for
                // its windows to be ready.
                if (wtoken.hidden) {
                    wtoken.allDrawn = false;
                    wtoken.deferClearAllDrawn = false;
                    wtoken.waitingToShow = true;

                    if (wtoken.clientHidden) {
                        // In the case where we are making an app visible
                        // but holding off for a transition, we still need
                        // to tell the client to make its windows visible so
                        // they get drawn.  Otherwise, we will wait on
                        // performing the transition until all windows have
                        // been drawn, they never will be, and we are sad.
                        wtoken.clientHidden = false;
                        wtoken.sendAppVisibilityToClients();        //这个调用就是通知应用窗口可见性变化；
                    }
                }
            } else {
                mClosingApps.add(wtoken);              //不可见Activity加到mClosingApps中；
                wtoken.mEnteringAnimation = false;
            }
            ......
            return;
        }
        ......
        setTokenVisibilityLocked(wtoken, null, visible, AppTransition.TRANSIT_UNSET,true, wtoken.voiceInteraction);
    }
}

第3、4步、AppWindowToken.sendAppVisibilityToClients()/dispatchAppVisibility()

    这个函数就是通知上层应用窗口可见性发生变化。如果next Activity是冷启动，那么该函数并不能通知next Activity的窗口变为可见，因为此时该函数调用时，next Activity的窗口还没add到WMS中来。

第5、6步、WMS.finishDrawingWindow()

    next Activity被Resume起来后，添加窗口、measure、layout、draw等一系列操作完成后便会调用WMS.finishDrawingWindow()来通知WMS，该窗口已经绘制好了，可以开始做动画了。WMS.finishDrawingWindow()会调用WindowStateAnimator.finishDrawingLocked()更新窗口状态mDrawState为COMMIT_DRAW_PENDING。同时还会调用requestTraversalLocked()来触发一次界面刷新函数performLayoutAndPlaceSurfacesLockedInner()调用。

第7步、performLayoutAndPlaceSurfacesLockedInner()

    该函数就是鼎鼎大名的界面刷新函数。该函数里面跟Activity切换动画相关的调用拆分到接下来的那些步骤中。

第8步、WindowStateAnimator.commitFinishDrawingLocked()

    performLayoutAndPlaceSurfacesLockedInner()函数中，对于窗口堆栈中有Surface的窗口均会调用WindowStateAnimator.commitFinishDrawingLocked()，该函数将窗口状态为COMMIT_DRAW_PENDING或READY_TO_SHOW的窗口，全部更新到READY_TO_SHOW状态。将状态从第五中中的COMMIT_DRAW_PENDING更新到READY_TO_SHOW，WindowState.isDrawnLw()便会返回true，代表窗口已经是绘制完成状态。w.isDrawnLw()返回为true，那么才有updateAllDrawn = true，接着才会触发调用第九步中的WMS.updateAllDrawnLocked()函数，将AppWindowToken.allDrawn置为true。

boolean commitFinishDrawingLocked() {
    if (DEBUG_STARTING_WINDOW &&
            mWin.mAttrs.type == WindowManager.LayoutParams.TYPE_APPLICATION_STARTING) {
        Slog.i(TAG, "commitFinishDrawingLocked: " + mWin + " cur mDrawState="
                + drawStateToString());
    }
    if (mDrawState != COMMIT_DRAW_PENDING && mDrawState != READY_TO_SHOW) {
        return false;
    }
    if (DEBUG_SURFACE_TRACE || DEBUG_ANIM) {
        Slog.i(TAG, "commitFinishDrawingLocked: mDrawState=READY_TO_SHOW " + mSurfaceControl);
    }
    mDrawState = READY_TO_SHOW;           //将窗口状态为COMMIT_DRAW_PENDING或READY_TO_SHOW更新到READY_TO_SHOW；
    final AppWindowToken atoken = mWin.mAppToken;
    if (atoken == null || atoken.allDrawn || mWin.mAttrs.type == TYPE_APPLICATION_STARTING) {
        return performShowLocked();         //对于Activity切换这种场景，此时该条件无法满足，故不会调用。
    }
    return false;
}

if (w != atoken.startingWindow) {
    if (!atoken.mAppAnimator.freezingScreen || !w.mAppFreezing) {
        atoken.numInterestingWindows++;      //计算属于该AppWindowToken的窗口总数；
        if (w.isDrawnLw()) {
            atoken.numDrawnWindows++;        //计算已经绘制完成的窗口总数；
            if (DEBUG_VISIBILITY || DEBUG_ORIENTATION) Slog.v(TAG,
                    "tokenMayBeDrawn: " + atoken
                    + " freezingScreen=" + atoken.mAppAnimator.freezingScreen
                    + " mAppFreezing=" + w.mAppFreezing);
            updateAllDrawn = true;
        }
    }

第9步、WMS.updateAllDrawnLocked()

    该函数更新AppWindowToken.allDrawn值。只有属于该AppWindowToken的所有窗口都是绘制完成状态（一般情况下只有一个窗口，有时候会有父窗口、子窗口，这时属于该AppWindowToken的窗口数量就不止一个了），AppWindowToken.allDrawn才会置为true。AppWindowToken.allDrawn为true才会使得第十步中的WMS.handleAppTransitionReadyLocked()完整的执行。

private void updateAllDrawnLocked(DisplayContent displayContent) {
    // See if any windows have been drawn, so they (and others
    // associated with them) can now be shown.
    ArrayList stacks = displayContent.getStacks();
    for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
        final ArrayList tasks = stacks.get(stackNdx).getTasks();
        for (int taskNdx = tasks.size() - 1; taskNdx >= 0; --taskNdx) {
            final AppTokenList tokens = tasks.get(taskNdx).mAppTokens;
            for (int tokenNdx = tokens.size() - 1; tokenNdx >= 0; --tokenNdx) {
                final AppWindowToken wtoken = tokens.get(tokenNdx);
                if (!wtoken.allDrawn) {
                    int numInteresting = wtoken.numInterestingWindows;
                    if (numInteresting > 0 && wtoken.numDrawnWindows >= numInteresting) {    //绘制完成窗口总数>=窗口总数，就代表属于该AppWindowToken的所有窗口均已绘制完成；
                        if (DEBUG_VISIBILITY) Slog.v(TAG,
                                "allDrawn: " + wtoken
                                + " interesting=" + numInteresting
                                + " drawn=" + wtoken.numDrawnWindows);
                        wtoken.allDrawn = true;                         //将allDrawn置为true；
                        // Force an additional layout pass where WindowStateAnimator#
                        // commitFinishDrawingLocked() will call performShowLocked().
                        displayContent.layoutNeeded = true;
                        mH.obtainMessage(H.NOTIFY_ACTIVITY_DRAWN, wtoken.token).sendToTarget();
                    }
                }
            }
        }
    }
}

第10步、WMS.handleAppTransitionReadyLocked()

    设置Activity切换动画选择逻辑就是在该函数中完成。该函数只有在调用了第一步后才会被调用，并且只有在wtoken.allDrawn=true时才会完整的执行完。这个函数接近300行，逻辑看起来非常复杂，下面将仔细分析这个函数。

public int handleAppTransitionReadyLocked(WindowList windows) {
    int changes = 0;
    int i;
    int appsCount = mOpeningApps.size();
    boolean goodToGo = true;
    if (DEBUG_APP_TRANSITIONS) Slog.v(TAG,
            "Checking " + appsCount + " opening apps (frozen="
            + mDisplayFrozen + " timeout="
            + mAppTransition.isTimeout() + ")...");
    if (!mAppTransition.isTimeout()) {
        for (i = 0; i < appsCount && goodToGo; i++) {
            AppWindowToken wtoken = mOpeningApps.valueAt(i);
            if (DEBUG_APP_TRANSITIONS) Slog.v(TAG,
                    "Check opening app=" + wtoken + ": allDrawn="
                    + wtoken.allDrawn + " startingDisplayed="
                    + wtoken.startingDisplayed + " startingMoved="
                    + wtoken.startingMoved);
            if (!wtoken.allDrawn && !wtoken.startingDisplayed
                    && !wtoken.startingMoved) {         //wtoken.allDrawn=true，goodToGo才不会被置为false，下面的逻辑才能继续执行；
                goodToGo = false;
            }
        }

        if (goodToGo && isWallpaperVisible(mWallpaperTarget)) {   //如果壁纸需要可见，但是壁纸此时是不可见状态，那么就需要等待壁纸绘制完成。。。才能继续执行下面的Activity切换动画选择逻辑；
            boolean wallpaperGoodToGo = true;
            for (int curTokenIndex = mWallpaperTokens.size() - 1;
                    curTokenIndex >= 0 && wallpaperGoodToGo; curTokenIndex--) {
                WindowToken token = mWallpaperTokens.get(curTokenIndex);
                for (int curWallpaperIndex = token.windows.size() - 1; curWallpaperIndex >= 0;
                        curWallpaperIndex--) {
                    WindowState wallpaper = token.windows.get(curWallpaperIndex);
                    if (wallpaper.mWallpaperVisible && !wallpaper.isDrawnLw()) {
                        // We've told this wallpaper to be visible, but it is not drawn yet
                        wallpaperGoodToGo = false;
                        if (mWallpaperDrawState != WALLPAPER_DRAW_TIMEOUT) {
                            // wait for this wallpaper until it is drawn or timeout
                            goodToGo = false;
                        }
                        if (mWallpaperDrawState == WALLPAPER_DRAW_NORMAL) {
                            mWallpaperDrawState = WALLPAPER_DRAW_PENDING;
                            mH.removeMessages(H.WALLPAPER_DRAW_PENDING_TIMEOUT);
                            mH.sendEmptyMessageDelayed(H.WALLPAPER_DRAW_PENDING_TIMEOUT,
                                    WALLPAPER_DRAW_PENDING_TIMEOUT_DURATION);
                        }
                        if (DEBUG_APP_TRANSITIONS || DEBUG_WALLPAPER) Slog.v(TAG,
                                "Wallpaper should be visible but has not been drawn yet. " +
                                "mWallpaperDrawState=" + mWallpaperDrawState);
                        break;
                    }
                }
            }
            if (wallpaperGoodToGo) {
                mWallpaperDrawState = WALLPAPER_DRAW_NORMAL;
                mH.removeMessages(H.WALLPAPER_DRAW_PENDING_TIMEOUT);
            }
        }
    }
    if (goodToGo) {
        if (DEBUG_APP_TRANSITIONS) Slog.v(TAG, "**** GOOD TO GO");
        int transit = mAppTransition.getAppTransition();        //取出第一步中设置的Activity切换动画类型；
        if (mSkipAppTransitionAnimation) {                      //如果设置了StartingWindow窗口，那么就忽略第一步中设置的Activity切换动画类型;
            transit = AppTransition.TRANSIT_UNSET;
        }
        mSkipAppTransitionAnimation = false;
        mNoAnimationNotifyOnTransitionFinished.clear();

        mH.removeMessages(H.APP_TRANSITION_TIMEOUT);           //移除超时；

        rebuildAppWindowListLocked();                          //窗口堆栈顺序重排，偶现Activity窗口显示在launcher图标之下就可能就是窗口堆栈顺序没有重排导致，Android4.4就有该问题。
        // if wallpaper is animating in or out set oldWallpaper to null else to wallpaper
        WindowState oldWallpaper =
                mWallpaperTarget != null && mWallpaperTarget.mWinAnimator.isAnimating()
                    && !mWallpaperTarget.mWinAnimator.isDummyAnimation()
                ? null : mWallpaperTarget;                   //oldWallpaper指向null或mWallpaperTarget

        mInnerFields.mWallpaperMayChange = false;

        // The top-most window will supply the layout params,
        // and we will determine it below.
        LayoutParams animLp = null;
        int bestAnimLayer = -1;
        boolean fullscreenAnim = false;
        boolean voiceInteraction = false;

        if (DEBUG_APP_TRANSITIONS) Slog.v(TAG,
                "New wallpaper target=" + mWallpaperTarget
                + ", oldWallpaper=" + oldWallpaper
                + ", lower target=" + mLowerWallpaperTarget
                + ", upper target=" + mUpperWallpaperTarget);

        boolean openingAppHasWallpaper = false;
        boolean closingAppHasWallpaper = false;
        final AppWindowToken lowerWallpaperAppToken;
        final AppWindowToken upperWallpaperAppToken;
        if (mLowerWallpaperTarget == null) {
            lowerWallpaperAppToken = upperWallpaperAppToken = null;
        } else {
            lowerWallpaperAppToken = mLowerWallpaperTarget.mAppToken;
            upperWallpaperAppToken = mUpperWallpaperTarget.mAppToken;
        }

        // Do a first pass through the tokens for two
        // things:
        // (1) Determine if both the closing and opening
        // app token sets are wallpaper targets, in which
        // case special animations are needed
        // (since the wallpaper needs to stay static
        // behind them).
        // (2) Find the layout params of the top-most
        // application window in the tokens, which is
        // what will control the animation theme.
        final int closingAppsCount = mClosingApps.size();
        appsCount = closingAppsCount + mOpeningApps.size();
        for (i = 0; i < appsCount; i++) {         //这个for循环主要干两件事情，第一事判断closing and opening APP token是否是壁纸目标窗口；第二件事是找到最顶部(全屏窗口)的Activity窗口，取得窗口属性mAttrs的值，其实这个地方有四种情况：全屏Activity-->全屏Activity、全屏Activity-->非全屏Activity、非全屏Activity-->全屏Activity、非全屏Activity-->非全屏Activity，这四种情况使得animLp值会有所差异；
            final AppWindowToken wtoken;
            if (i < closingAppsCount) {
                wtoken = mClosingApps.valueAt(i);
                if (wtoken == lowerWallpaperAppToken || wtoken == upperWallpaperAppToken) {
                    closingAppHasWallpaper = true;
                }
            } else {
                wtoken = mOpeningApps.valueAt(i - closingAppsCount);
                if (wtoken == lowerWallpaperAppToken || wtoken == upperWallpaperAppToken) {
                    openingAppHasWallpaper = true;
                }
            }

            voiceInteraction |= wtoken.voiceInteraction;

            if (wtoken.appFullscreen) {
                WindowState ws = wtoken.findMainWindow();
                if (ws != null) {
                    animLp = ws.mAttrs;
                    bestAnimLayer = ws.mLayer;
                    fullscreenAnim = true;
                }
            } else if (!fullscreenAnim) {
                WindowState ws = wtoken.findMainWindow();
                if (ws != null) {
                    if (ws.mLayer > bestAnimLayer) {
                        animLp = ws.mAttrs;
                        bestAnimLayer = ws.mLayer;
                    }
                }
            }
        }

        mAnimateWallpaperWithTarget = false;
        if (closingAppHasWallpaper && openingAppHasWallpaper) {      //下面这段逻辑都是根据壁纸目标窗口的各种情况重新设置指定的transit值；
            if (DEBUG_APP_TRANSITIONS) Slog.v(TAG, "Wallpaper animation!");
            switch (transit) {
                case AppTransition.TRANSIT_ACTIVITY_OPEN:
                case AppTransition.TRANSIT_TASK_OPEN:
                case AppTransition.TRANSIT_TASK_TO_FRONT:
                    transit = AppTransition.TRANSIT_WALLPAPER_INTRA_OPEN;
                    break;
                case AppTransition.TRANSIT_ACTIVITY_CLOSE:
                case AppTransition.TRANSIT_TASK_CLOSE:
                case AppTransition.TRANSIT_TASK_TO_BACK:
                    transit = AppTransition.TRANSIT_WALLPAPER_INTRA_CLOSE;
                    break;
            }
            if (DEBUG_APP_TRANSITIONS) Slog.v(TAG,
                    "New transit: " + AppTransition.appTransitionToString(transit));
        } else if ((oldWallpaper != null) && !mOpeningApps.isEmpty()
                && !mOpeningApps.contains(oldWallpaper.mAppToken)) {
            // We are transitioning from an activity with
            // a wallpaper to one without.
            transit = AppTransition.TRANSIT_WALLPAPER_CLOSE;
            if (DEBUG_APP_TRANSITIONS) Slog.v(TAG,
                    "New transit away from wallpaper: "
                    + AppTransition.appTransitionToString(transit));
        } else if (mWallpaperTarget != null && mWallpaperTarget.isVisibleLw()) {
            // We are transitioning from an activity without
            // a wallpaper to now showing the wallpaper
            transit = AppTransition.TRANSIT_WALLPAPER_OPEN;
            if (DEBUG_APP_TRANSITIONS) Slog.v(TAG,
                    "New transit into wallpaper: "
                    + AppTransition.appTransitionToString(transit));
        } else {
            mAnimateWallpaperWithTarget = true;
        }

        // If all closing windows are obscured, then there is
        // no need to do an animation.  This is the case, for
        // example, when this transition is being done behind
        // the lock screen.
        if (!mPolicy.allowAppAnimationsLw()) {
            if (DEBUG_APP_TRANSITIONS) Slog.v(TAG,
                    "Animations disallowed by keyguard or dream.");
            animLp = null;
        }

        AppWindowToken topOpeningApp = null;
        AppWindowToken topClosingApp = null;
        int topOpeningLayer = 0;
        int topClosingLayer = 0;

        // Process all applications animating in place
        if (transit == AppTransition.TRANSIT_TASK_IN_PLACE) {       //如果transit == AppTransition.TRANSIT_TASK_IN_PLACE，这段逻辑不知道是干啥的。。。
            // Find the focused window
            final WindowState win =
                    findFocusedWindowLocked(getDefaultDisplayContentLocked());
            if (win != null) {
                final AppWindowToken wtoken = win.mAppToken;
                final AppWindowAnimator appAnimator = wtoken.mAppAnimator;
                if (DEBUG_APP_TRANSITIONS) Slog.v(TAG, "Now animating app in place " + wtoken);
                appAnimator.clearThumbnail();
                appAnimator.animation = null;
                updateTokenInPlaceLocked(wtoken, transit);
                wtoken.updateReportedVisibilityLocked();

                appAnimator.mAllAppWinAnimators.clear();
                final int N = wtoken.allAppWindows.size();
                for (int j = 0; j < N; j++) {
                    appAnimator.mAllAppWinAnimators.add(wtoken.allAppWindows.get(j).mWinAnimator);
                }
                mAnimator.mAppWindowAnimating |= appAnimator.isAnimating();
                mAnimator.mAnimating |= appAnimator.showAllWindowsLocked();
            }
        }

        appsCount = mOpeningApps.size();
        for (i = 0; i < appsCount; i++) {           //这个for循环主要干两件事：①调用setTokenVisibilityLocked()设置Activity切换动画；②寻找topOpeningApp值；

            AppWindowToken wtoken = mOpeningApps.valueAt(i);
            final AppWindowAnimator appAnimator = wtoken.mAppAnimator;
            if (DEBUG_APP_TRANSITIONS) Slog.v(TAG, "Now opening app" + wtoken);

            if (!appAnimator.usingTransferredAnimation) {
                appAnimator.clearThumbnail();
                appAnimator.animation = null;
            }
            wtoken.inPendingTransaction = false;
            if (!setTokenVisibilityLocked(              //setTokenVisibilityLocked()函数主要依据第2,3,4,6个参数来决定加载哪个动画；
                    wtoken, animLp, true, transit, false, voiceInteraction)){
                // This token isn't going to be animating. Add it to the list of tokens to
                // be notified of app transition complete since the notification will not be
                // sent be the app window animator.
                mNoAnimationNotifyOnTransitionFinished.add(wtoken.token);
            }
            wtoken.updateReportedVisibilityLocked();
            wtoken.waitingToShow = false;

            appAnimator.mAllAppWinAnimators.clear();
            final int windowsCount = wtoken.allAppWindows.size();
            for (int j = 0; j < windowsCount; j++) {
                appAnimator.mAllAppWinAnimators.add(wtoken.allAppWindows.get(j).mWinAnimator);
            }
            mAnimator.mAnimating |= appAnimator.showAllWindowsLocked();        //将Activity窗口状态从READY_TO_SHOW更新到HAS_DRAWN.该函数会调用WindowStateAnimator.performShowLocked().可能有细心的人发现了WindowStateAnimator.performShowLocked()函数会调用WindowStateAnimator.applyEnterAnimationLocked()设置窗口动画，但实际上是无法加载出Animation的，读者可将日志开关打开，然后在日志中搜索关键字“applyAnimation: win=”,查看Activity窗口的“a=”是否为null。对于非Activity窗口，WindowStateAnimator.applyEnterAnimationLocked()是可以为其加载出一个Animation的，当然得系统或窗口指定资源样式才行。现在可以总结出：对于Activity窗口是不可能在WindowStateAnimator.applyEnterAnimationLocked()成功设置一个窗口动画的，非Activity窗口才可以，比如PopupWindow、startingWindow、StatusBar、输入法窗口等。
            mAnimator.mAppWindowAnimating |= appAnimator.isAnimating();

            if (animLp != null) {
                int layer = -1;
                for (int j = 0; j < wtoken.windows.size(); j++) {
                    WindowState win = wtoken.windows.get(j);
                    if (win.mWinAnimator.mAnimLayer > layer) {
                        layer = win.mWinAnimator.mAnimLayer;
                    }
                }
                if (topOpeningApp == null || layer > topOpeningLayer) {
                    topOpeningApp = wtoken;
                    topOpeningLayer = layer;
                }
            }
        }
        appsCount = mClosingApps.size();
        for (i = 0; i < appsCount; i++) {    //这个for循环主要干两件事：①调用setTokenVisibilityLocked()设置Activity切换动画；②寻找topClosingApp值；
            AppWindowToken wtoken = mClosingApps.valueAt(i);
            final AppWindowAnimator appAnimator = wtoken.mAppAnimator;
            if (DEBUG_APP_TRANSITIONS) Slog.v(TAG, "Now closing app " + wtoken);
            appAnimator.clearThumbnail();
            appAnimator.animation = null;
            wtoken.inPendingTransaction = false;
            setTokenVisibilityLocked(wtoken, animLp, false, transit, false, voiceInteraction);
            wtoken.updateReportedVisibilityLocked();
            // Force the allDrawn flag, because we want to start
            // this guy's animations regardless of whether it's
            // gotten drawn.
            wtoken.allDrawn = true;
            wtoken.deferClearAllDrawn = false;
            // Ensure that apps that are mid-starting are also scheduled to have their
            // starting windows removed after the animation is complete
            if (wtoken.startingWindow != null && !wtoken.startingWindow.mExiting) {
                scheduleRemoveStartingWindowLocked(wtoken);
            }
            mAnimator.mAppWindowAnimating |= appAnimator.isAnimating();

            if (animLp != null) {
                int layer = -1;
                for (int j = 0; j < wtoken.windows.size(); j++) {
                    WindowState win = wtoken.windows.get(j);
                    if (win.mWinAnimator.mAnimLayer > layer) {
                        layer = win.mWinAnimator.mAnimLayer;
                    }
                }
                if (topClosingApp == null || layer > topClosingLayer) {
                    topClosingApp = wtoken;
                    topClosingLayer = layer;
                }
            }
        }

        AppWindowAnimator openingAppAnimator = (topOpeningApp == null) ? null :
                topOpeningApp.mAppAnimator;
        AppWindowAnimator closingAppAnimator = (topClosingApp == null) ? null :
                topClosingApp.mAppAnimator;
        Bitmap nextAppTransitionThumbnail = mAppTransition.getNextAppTransitionThumbnail();      //上层应用调用了WMS.overridePendingAppTransitionAspectScaledThumb()或WMS.overridePendingAppTransitionThumb()进行覆盖Activity切换动画，下面这段代码就是这个覆盖动画逻辑处理；
        if (nextAppTransitionThumbnail != null
                && openingAppAnimator != null && openingAppAnimator.animation != null &&
                nextAppTransitionThumbnail.getConfig() != Config.ALPHA_8) {
            // This thumbnail animation is very special, we need to have
            // an extra surface with the thumbnail included with the animation.
            Rect dirty = new Rect(0, 0, nextAppTransitionThumbnail.getWidth(),
                    nextAppTransitionThumbnail.getHeight());
            try {
                // TODO(multi-display): support other displays
                final DisplayContent displayContent = getDefaultDisplayContentLocked();
                final Display display = displayContent.getDisplay();
                final DisplayInfo displayInfo = displayContent.getDisplayInfo();

                // Create a new surface for the thumbnail
                SurfaceControl surfaceControl = new SurfaceControl(mFxSession,
                        "thumbnail anim", dirty.width(), dirty.height(),
                        PixelFormat.TRANSLUCENT, SurfaceControl.HIDDEN);
                surfaceControl.setLayerStack(display.getLayerStack());
                if (SHOW_TRANSACTIONS) {
                    Slog.i(TAG, "  THUMBNAIL " + surfaceControl + ": CREATE");
                }

                // Draw the thumbnail onto the surface
                Surface drawSurface = new Surface();
                drawSurface.copyFrom(surfaceControl);
                Canvas c = drawSurface.lockCanvas(dirty);
                c.drawBitmap(nextAppTransitionThumbnail, 0, 0, null);
                drawSurface.unlockCanvasAndPost(c);
                drawSurface.release();

                // Get the thumbnail animation
                Animation anim;
                if (mAppTransition.isNextThumbnailTransitionAspectScaled()) {
                    // For the new aspect-scaled transition, we want it to always show
                    // above the animating opening/closing window, and we want to
                    // synchronize its thumbnail surface with the surface for the
                    // open/close animation (only on the way down)
                    anim = mAppTransition.createThumbnailAspectScaleAnimationLocked(
                            displayInfo.appWidth, displayInfo.appHeight,
                            displayInfo.logicalWidth, transit);
                    openingAppAnimator.thumbnailForceAboveLayer = Math.max(topOpeningLayer,
                            topClosingLayer);
                    openingAppAnimator.deferThumbnailDestruction =
                            !mAppTransition.isNextThumbnailTransitionScaleUp();
                } else {
                    anim = mAppTransition.createThumbnailScaleAnimationLocked(
                            displayInfo.appWidth, displayInfo.appHeight, transit);
                }
                anim.restrictDuration(MAX_ANIMATION_DURATION);
                anim.scaleCurrentDuration(getTransitionAnimationScaleLocked());

                openingAppAnimator.thumbnail = surfaceControl;
                openingAppAnimator.thumbnailLayer = topOpeningLayer;
                openingAppAnimator.thumbnailAnimation = anim;
                openingAppAnimator.thumbnailX = mAppTransition.getStartingX();
                openingAppAnimator.thumbnailY = mAppTransition.getStartingY();
            } catch (OutOfResourcesException e) {
                Slog.e(TAG, "Can't allocate thumbnail/Canvas surface w=" + dirty.width()
                        + " h=" + dirty.height(), e);
                openingAppAnimator.clearThumbnail();
            }
        }

        mAppTransition.goodToGo(openingAppAnimator, closingAppAnimator);
        mAppTransition.postAnimationCallback();
        mAppTransition.clear();

        mOpeningApps.clear();
        mClosingApps.clear();

        // This has changed the visibility of windows, so perform
        // a new layout to get them all up-to-date.
        changes |= WindowManagerPolicy.FINISH_LAYOUT_REDO_LAYOUT
                | WindowManagerPolicy.FINISH_LAYOUT_REDO_CONFIG;
        getDefaultDisplayContentLocked().layoutNeeded = true;

        // TODO(multidisplay): IMEs are only supported on the default display.
        if (windows == getDefaultWindowListLocked()
                && !moveInputMethodWindowsIfNeededLocked(true)) {
            assignLayersLocked(windows);
        }
        updateFocusedWindowLocked(UPDATE_FOCUS_PLACING_SURFACES, true /*updateInputWindows*/);
        mFocusMayChange = false;
        notifyActivityDrawnForKeyguard();
    }

    return changes;
}

    上面这个函数很长，但是逻辑思路很简单，初看起来确实复杂，仔细分析发现还是比较容易理解的。总结起来就是：确定壁纸目标窗口对transit值的影响、取得顶层窗口的mAttr值、两次调用setTokenVisibilityLocked()来设置APPWindowToken可见性及加载对应的动画。

第11步、WMS.setTokenVisibilityLocked()

    这个函数用来设置APPWindowToken.hidden的可见性、设置Activity切换动画（如果参数transit==AppTransition.TRANSIT_UNSET，那就是会设置窗口动画，否则就会设置Activity切换动画），如果存在Activity切换动画或属于该Activity的窗口正在做窗口动画，那么返回值为true。

boolean setTokenVisibilityLocked(AppWindowToken wtoken, WindowManager.LayoutParams lp,
        boolean visible, int transit, boolean performLayout, boolean isVoiceInteraction) {
    boolean delayed = false;

    if (wtoken.clientHidden == visible) {      //AppWindowToken.clientHidden保存着上层应用Activity窗口的可见性，通过AppWindowToken.sendAppVisibilityToClients()来通知上层应用窗口可见性。
        wtoken.clientHidden = !visible;
        wtoken.sendAppVisibilityToClients();
    }

    wtoken.willBeHidden = false;
    // Allow for state changes and animation to be applied if token is transitioning
    // visibility state or the token was marked as hidden and is exiting before we had a chance
    // to play the transition animation.
    if (wtoken.hidden == visible || (wtoken.hidden && wtoken.mIsExiting)) {       //只有APPWindowToken.hidden的可见性切换时才进行重置其值及设置Activity切换动画或设置窗口动画；
        boolean changed = false;
        if (DEBUG_APP_TRANSITIONS) Slog.v(
            TAG, "Changing app " + wtoken + " hidden=" + wtoken.hidden
            + " performLayout=" + performLayout);

        boolean runningAppAnimation = false;     //该变量用来确定是否设置了Activity切换动画，后面根据这个值来确定是否需要设置窗口动画；

        if (transit != AppTransition.TRANSIT_UNSET) {    //如果transit != AppTransition.TRANSIT_UNSET表示指定了Activity切换动画，那么调用WMS.applyAnimationLocked()来加载Activity切换动画，同时把runningAppAnimation置为true，这样下面遍历窗口的时候便不会设置窗口动画；
            if (wtoken.mAppAnimator.animation == AppWindowAnimator.sDummyAnimation) {
                wtoken.mAppAnimator.animation = null;
            }
            if (applyAnimationLocked(wtoken, lp, transit, visible, isVoiceInteraction)) {    //加载Activity切换动画，第十二步中会分析这个函数；
                delayed = runningAppAnimation = true;
            }
            WindowState window = wtoken.findMainWindow();
            //TODO (multidisplay): Magnification is supported only for the default display.
            if (window != null && mAccessibilityController != null
                    && window.getDisplayId() == Display.DEFAULT_DISPLAY) {
                mAccessibilityController.onAppWindowTransitionLocked(window, transit);
            }
            changed = true;
        }

        final int windowsCount = wtoken.allAppWindows.size();
        for (int i = 0; i < windowsCount; i++) {     //for循环遍历属于该APPWindowToken的所有窗口，一般情况下只有一个.
            WindowState win = wtoken.allAppWindows.get(i);
            if (win == wtoken.startingWindow) {      //过滤startingWindow；
                continue;
            }

            //Slog.i(TAG, "Window " + win + ": vis=" + win.isVisible());
            //win.dump("  ");
            if (visible) {            //如果该APPWindowToken要切换为可见，并且所属的窗口当前是不可见状态，并且没有设置Activity切换动画，才设置窗口进入动画；
                if (!win.isVisibleNow()) {
                    if (!runningAppAnimation) {
                        win.mWinAnimator.applyAnimationLocked(
                                WindowManagerPolicy.TRANSIT_ENTER, true);      //WindowStateAnimator.applyAnimationLocked()函数分析见第二部分；
                        //TODO (multidisplay): Magnification is supported only for the default
                        if (mAccessibilityController != null
                                && win.getDisplayId() == Display.DEFAULT_DISPLAY) {
                            mAccessibilityController.onWindowTransitionLocked(win,
                                    WindowManagerPolicy.TRANSIT_ENTER);
                        }
                    }
                    changed = true;
                    final DisplayContent displayContent = win.getDisplayContent();
                    if (displayContent != null) {
                        displayContent.layoutNeeded = true;
                    }
                }
            } else if (win.isVisibleNow()) {   //如果该APPWindowToken要切换为不可见，并且所属的窗口当前是可见状态，并且没有设置Activity切换动画，才设置窗口退出动画；
                if (!runningAppAnimation) {
                    win.mWinAnimator.applyAnimationLocked(
                            WindowManagerPolicy.TRANSIT_EXIT, false);
                    //TODO (multidisplay): Magnification is supported only for the default
                    if (mAccessibilityController != null
                            && win.getDisplayId() == Display.DEFAULT_DISPLAY) {
                        mAccessibilityController.onWindowTransitionLocked(win,
                                WindowManagerPolicy.TRANSIT_EXIT);
                    }
                }
                changed = true;
                final DisplayContent displayContent = win.getDisplayContent();
                if (displayContent != null) {
                    displayContent.layoutNeeded = true;
                }
            }
        }

        wtoken.hidden = wtoken.hiddenRequested = !visible;        //设置APPWindowToken.hidden值；
        if (!visible) {
            unsetAppFreezingScreenLocked(wtoken, true, true);
        } else {
            // If we are being set visible, and the starting window is
            // not yet displayed, then make sure it doesn't get displayed.
            WindowState swin = wtoken.startingWindow;
            if (swin != null && !swin.isDrawnLw()) {      //如果该APPWindowToken设为可见时，此时如果startingWindow还没显示，那么就无需显示startingWindow了，即将mPolicyVisibility置为false；
                swin.mPolicyVisibility = false;
                swin.mPolicyVisibilityAfterAnim = false;
             }
        }

        if (DEBUG_APP_TRANSITIONS) Slog.v(TAG, "setTokenVisibilityLocked: " + wtoken
                  + ": hidden=" + wtoken.hidden + " hiddenRequested="
                  + wtoken.hiddenRequested);

        if (changed) {           //changed=true代表上面有窗口可见性更改，那么就要更新输入法窗口在堆栈中的位置了；
            mInputMonitor.setUpdateInputWindowsNeededLw();
            if (performLayout) {
                updateFocusedWindowLocked(UPDATE_FOCUS_WILL_PLACE_SURFACES,
                        false /*updateInputWindows*/);
                performLayoutAndPlaceSurfacesLocked();
            }
            mInputMonitor.updateInputWindowsLw(false /*force*/);      //将窗口堆栈信息更新到Input中去；
        }
    }

    if (wtoken.mAppAnimator.animation != null) {
        delayed = true;
    }

    for (int i = wtoken.allAppWindows.size() - 1; i >= 0 && !delayed; i--) {
        if (wtoken.allAppWindows.get(i).mWinAnimator.isWindowAnimating()) {
            delayed = true;
        }
    }

    return delayed;
}

第12步、WMS.applyAnimationLocked()

    该函数首先会根据AppWindowToken所属窗口是否是全屏窗口来确定containingFrame、contentInsets、appFrame三个值，然后调用AppTransition.loadAnimation()取得一个Activity切换动画Animation，最后将这个Animation通过AppTransition.setAnimation()接口设置到AppTransition中去。

private boolean applyAnimationLocked(AppWindowToken atoken,
        WindowManager.LayoutParams lp, int transit, boolean enter, boolean isVoiceInteraction) {
    // Only apply an animation if the display isn't frozen.  If it is
    // frozen, there is no reason to animate and it can cause strange
    // artifacts when we unfreeze the display if some different animation
    // is running.
    if (okToDisplay()) {
        DisplayInfo displayInfo = getDefaultDisplayInfoLocked();
        final int width = displayInfo.appWidth;
        final int height = displayInfo.appHeight;
        if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) Slog.v(TAG,
                "applyAnimation: atoken=" + atoken);

        // Determine the visible rect to calculate the thumbnail clip
        WindowState win = atoken.findMainWindow();
        Rect containingFrame = new Rect(0, 0, width, height);
        Rect contentInsets = new Rect();
        Rect appFrame = new Rect(0, 0, width, height);
        if (win != null && win.isFullscreen(width, height)) {  //只有窗口大于等于屏幕时，才会使用窗口的mContainingFrame、mContentInsets、mFrame值，这三个值会作为AppTransition.loadAnimation()的参数；
            // For fullscreen windows use the window frames and insets to set the thumbnail
            // clip. For none-fullscreen windows we use the app display region so the clip
            // isn't affected by the window insets.
            containingFrame.set(win.mContainingFrame);
            contentInsets.set(win.mContentInsets);
            appFrame.set(win.mFrame);
        }

        if (atoken.mLaunchTaskBehind) {
            // Differentiate the two animations. This one which is briefly on the screen
            // gets the !enter animation, and the other activity which remains on the
            // screen gets the enter animation. Both appear in the mOpeningApps set.
            enter = false;
        }
        Animation a = mAppTransition.loadAnimation(lp, transit, enter, width, height,
                mCurConfiguration.orientation, containingFrame, contentInsets, appFrame,
                isVoiceInteraction);       //调用AppTransition.loadAnimation()，每个参数均会影响具体加载哪个动画，将在第十三步分析该函数；
        if (a != null) {
            if (DEBUG_ANIM) {
                RuntimeException e = null;
                if (!HIDE_STACK_CRAWLS) {
                    e = new RuntimeException();
                    e.fillInStackTrace();
                }
                Slog.v(TAG, "Loaded animation " + a + " for " + atoken, e);
            }
            atoken.mAppAnimator.setAnimation(a, width, height,      //将前面加载的Animation设置到AppTransition中去；
                    mAppTransition.canSkipFirstFrame());
        }
    } else {
        atoken.mAppAnimator.clearAnimation();
    }

    return atoken.mAppAnimator.animation != null;          //如果成功设置Activity切换动画，那么该函数返回true；
}

第13、14步、AppTransition.loadAnimation()/AppTransition.setAnimation()

    AppTransition.loadAnimation()函数就是根据mNextAppTransitionType、transit、enter、isVoiceInteraction来决定出一个animAttr值，然后调用loadAnimationRes()或loadAnimationAttr()或其他创建Animation接口来加载一个Animation出来。现在很多应用使用startActivity(Intent intent, Bundle options)时在options参数中携带了自定义动画来取代系统默认Activity切换动画，那究竟是如何做到替换系统默认Activity切换动画的呢？秘密在于startActivity时，AMS会主动根据options携带的动画类型type，调用WMS.overridePendingAppTransition()等接口来覆盖Activity默认切换动画，当然上层应用也可直接调用WMS.overridePendingAppTransition()来覆盖Activity默认切换动画，关于startActivity()携带自定义Activity切换动画这个流程在文章第四部分会简单分析。

Animation loadAnimation(WindowManager.LayoutParams lp, int transit, boolean enter,
        int appWidth, int appHeight, int orientation, Rect containingFrame, Rect contentInsets,
        Rect appFrame, boolean isVoiceInteraction) {
    Animation a;
    if (isVoiceInteraction && (transit == TRANSIT_ACTIVITY_OPEN
            || transit == TRANSIT_TASK_OPEN
            || transit == TRANSIT_TASK_TO_FRONT)) {                  //语音交互相关；
        a = loadAnimationRes(lp, enter
                ? com.android.internal.R.anim.voice_activity_open_enter
                : com.android.internal.R.anim.voice_activity_open_exit);
        if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) Slog.v(TAG,
                "applyAnimation voice:"
                + " anim=" + a + " transit=" + appTransitionToString(transit)
                + " isEntrance=" + enter + " Callers=" + Debug.getCallers(3));
    } else if (isVoiceInteraction && (transit == TRANSIT_ACTIVITY_CLOSE
            || transit == TRANSIT_TASK_CLOSE
            || transit == TRANSIT_TASK_TO_BACK)) {                      //语音交互相关；
        a = loadAnimationRes(lp, enter
                ? com.android.internal.R.anim.voice_activity_close_enter
                : com.android.internal.R.anim.voice_activity_close_exit);
        if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) Slog.v(TAG,
                "applyAnimation voice:"
                + " anim=" + a + " transit=" + appTransitionToString(transit)
                + " isEntrance=" + enter + " Callers=" + Debug.getCallers(3));
    } else if (mNextAppTransitionType == NEXT_TRANSIT_TYPE_CUSTOM) {          //调用过overridePendingAppTransition()接口设置动画。使用startActivity()携带ActivityOptions.ANIM_CUSTOM自定义Activity切换动画就是走这个逻辑的；
        a = loadAnimationRes(mNextAppTransitionPackage, enter ?
                mNextAppTransitionEnter : mNextAppTransitionExit);
        if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) Slog.v(TAG,
                "applyAnimation:"
                + " anim=" + a + " nextAppTransition=ANIM_CUSTOM"
                + " transit=" + appTransitionToString(transit) + " isEntrance=" + enter
                + " Callers=" + Debug.getCallers(3));
    } else if (mNextAppTransitionType == NEXT_TRANSIT_TYPE_CUSTOM_IN_PLACE) {   //调用过overrideInPlaceAppTransition()接口设置动画;
        a = loadAnimationRes(mNextAppTransitionPackage, mNextAppTransitionInPlace);
        if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) Slog.v(TAG,
                "applyAnimation:"
                + " anim=" + a + " nextAppTransition=ANIM_CUSTOM_IN_PLACE"
                + " transit=" + appTransitionToString(transit)
                + " Callers=" + Debug.getCallers(3));
    } else if (mNextAppTransitionType == NEXT_TRANSIT_TYPE_CLIP_REVEAL) {
        a = createClipRevealAnimationLocked(transit, enter, appFrame);
        if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) Slog.v(TAG,
                "applyAnimation:"
                        + " anim=" + a + " nextAppTransition=ANIM_CLIP_REVEAL"
                        + " Callers=" + Debug.getCallers(3));
    } else if (mNextAppTransitionType == NEXT_TRANSIT_TYPE_SCALE_UP) {           //调用过overridePendingAppTransitionScaleUp()接口设置动画;
        a = createScaleUpAnimationLocked(transit, enter, appWidth, appHeight);
        if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) Slog.v(TAG,
                "applyAnimation:"
                + " anim=" + a + " nextAppTransition=ANIM_SCALE_UP"
                + " transit=" + appTransitionToString(transit) + " isEntrance=" + enter
                + " Callers=" + Debug.getCallers(3));
    } else if (mNextAppTransitionType == NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_UP ||
            mNextAppTransitionType == NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_DOWN) {        //调用过overridePendingAppTransitionThumb()接口设置动画;
        mNextAppTransitionScaleUp =
                (mNextAppTransitionType == NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_UP);
        a = createThumbnailEnterExitAnimationLocked(getThumbnailTransitionState(enter),
                appWidth, appHeight, transit);
        if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) {
            String animName = mNextAppTransitionScaleUp ?
                    "ANIM_THUMBNAIL_SCALE_UP" : "ANIM_THUMBNAIL_SCALE_DOWN";
            Slog.v(TAG, "applyAnimation:"
                    + " anim=" + a + " nextAppTransition=" + animName
                    + " transit=" + appTransitionToString(transit) + " isEntrance=" + enter
                    + " Callers=" + Debug.getCallers(3));
        }
    } else if (mNextAppTransitionType == NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_UP ||
            mNextAppTransitionType == NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_DOWN) {       //调用过overridePendingAppTransitionAspectScaledThumb()接口设置动画;
        mNextAppTransitionScaleUp =
                (mNextAppTransitionType == NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_UP);
        a = createAspectScaledThumbnailEnterExitAnimationLocked(
                getThumbnailTransitionState(enter), appWidth, appHeight, orientation,
                transit, containingFrame, contentInsets);
        if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) {
            String animName = mNextAppTransitionScaleUp ?
                    "ANIM_THUMBNAIL_ASPECT_SCALE_UP" : "ANIM_THUMBNAIL_ASPECT_SCALE_DOWN";
            Slog.v(TAG, "applyAnimation:"
                    + " anim=" + a + " nextAppTransition=" + animName
                    + " transit=" + appTransitionToString(transit) + " isEntrance=" + enter
                    + " Callers=" + Debug.getCallers(3));
        }
    } else {                  //这个就是普通Activity切换动画选择逻辑啦，根据transit、enter组合计算出一个animAttr值；
        int animAttr = 0;
        switch (transit) {
            case TRANSIT_ACTIVITY_OPEN:
                animAttr = enter
                        ? WindowAnimation_activityOpenEnterAnimation
                        : WindowAnimation_activityOpenExitAnimation;
                break;
            case TRANSIT_ACTIVITY_CLOSE:
                animAttr = enter
                        ? WindowAnimation_activityCloseEnterAnimation
                        : WindowAnimation_activityCloseExitAnimation;
                break;
            case TRANSIT_TASK_OPEN:
                animAttr = enter
                        ? WindowAnimation_taskOpenEnterAnimation
                        : WindowAnimation_taskOpenExitAnimation;
                break;
            case TRANSIT_TASK_CLOSE:
                animAttr = enter
                        ? WindowAnimation_taskCloseEnterAnimation
                        : WindowAnimation_taskCloseExitAnimation;
                break;
            case TRANSIT_TASK_TO_FRONT:
                animAttr = enter
                        ? WindowAnimation_taskToFrontEnterAnimation
                        : WindowAnimation_taskToFrontExitAnimation;
                break;
            case TRANSIT_TASK_TO_BACK:
                animAttr = enter
                        ? WindowAnimation_taskToBackEnterAnimation
                        : WindowAnimation_taskToBackExitAnimation;
                break;
            case TRANSIT_WALLPAPER_OPEN:
                animAttr = enter
                        ? WindowAnimation_wallpaperOpenEnterAnimation
                        : WindowAnimation_wallpaperOpenExitAnimation;
                break;
            case TRANSIT_WALLPAPER_CLOSE:
                animAttr = enter
                        ? WindowAnimation_wallpaperCloseEnterAnimation
                        : WindowAnimation_wallpaperCloseExitAnimation;
                break;
            case TRANSIT_WALLPAPER_INTRA_OPEN:
                animAttr = enter
                        ? WindowAnimation_wallpaperIntraOpenEnterAnimation
                        : WindowAnimation_wallpaperIntraOpenExitAnimation;
                break;
            case TRANSIT_WALLPAPER_INTRA_CLOSE:
                animAttr = enter
                        ? WindowAnimation_wallpaperIntraCloseEnterAnimation
                        : WindowAnimation_wallpaperIntraCloseExitAnimation;
                break;
            case TRANSIT_TASK_OPEN_BEHIND:
                animAttr = enter
                        ? WindowAnimation_launchTaskBehindSourceAnimation
                        : WindowAnimation_launchTaskBehindTargetAnimation;
        }
        a = animAttr != 0 ? loadAnimationAttr(lp, animAttr) : null;       //调用loadAnimationAttr()加载动画；
        if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) Slog.v(TAG,
                "applyAnimation:"
                + " anim=" + a
                + " animAttr=0x" + Integer.toHexString(animAttr)
                + " transit=" + appTransitionToString(transit) + " isEntrance=" + enter
                + " Callers=" + Debug.getCallers(3));
    }
    return a;
}

    从上面可以看到对于普通Activity切换，会调用AppTransition.loadAnimationAttr()来加载一个动画。

Animation loadAnimationAttr(WindowManager.LayoutParams lp, int animAttr) {
    int anim = 0;
    Context context = mContext;
    if (animAttr >= 0) {
        AttributeCache.Entry ent = getCachedAnimations(lp);
        if (ent != null) {
            context = ent.context;
            anim = ent.array.getResourceId(animAttr, 0);
        }
    }
    if (anim != 0) {
        return AnimationUtils.loadAnimation(context, anim);
    }
    return null;
}

第15步、WMS.scheduleAnimationLocked()

    触发动画下一帧计算逻辑。Activity切换动画、窗口动画究竟是如何实现的？说直白点就是调用scheduleAnimationLocked()后，使得在下一个vsync信号来临时触发调用计算窗口透明度、尺寸、旋转角度等值，然后将这些值设置到SurfaceFlinger中去。如果这一帧动画计算完成发现动画仍未结束，便会再次调用scheduleAnimationLocked()使得下一个vsync信号来临时重复之前的计算工作，依次往复，便达实现了想要的动画效果。至于这个一帧动画计算逻辑是如何执行的，请看下面第三部分。

第二部分：窗口动画设置

    窗口动画的设置没那么复杂，我们就看一个比较常见的设置途径，流程如下。窗口动画设置关键函数在WindowStateAnimator.applyAnimationLocked()中，其他函数在第一部分已经分析过了，下面将重点分析这个函数。

    WindowStateAnimator.applyAnimationLocked()函数对于Activity窗口来说并不会为其设置一个窗口动画，而对于非Activity窗口来说其窗口动画设置就是在这个函数中完成的，关 于这一点已经在上面第一部分中的 第十步 WMS.handleAppTransitionReadyLocked()函数分析中讲的非常详细了，在此不多说 。而对于非Activity窗口，比如popupwindow，可通过 setAnimationStyle(int id) 方法设置一个指定的样式窗口动画，样式如下：

"popwin_anim_style">
     "android:windowEnterAnimation">@anim/menushow
     "android:windowExitAnimation">@anim/menuhide

    下面将详细分析WindowStateAnimator.applyAnimationLocked()函数。

boolean applyAnimationLocked(int transit, boolean isEntrance) {
    if ((mLocalAnimating && mAnimationIsEntrance == isEntrance)
            || mKeyguardGoingAwayAnimation) {          //mLocalAnimating=true表示该窗口正在做动画。如果该窗口将要设置的动画(进入或退出)当前已经正在做，那么直接返回。
        // If we are trying to apply an animation, but already running
        // an animation of the same type, then just leave that one alone.

        // If we are in a keyguard exit animation, and the window should animate away, modify
        // keyguard exit animation such that it also fades out.
        if (mAnimation != null && mKeyguardGoingAwayAnimation
                && transit == WindowManagerPolicy.TRANSIT_PREVIEW_DONE) {
            applyFadeoutDuringKeyguardExitAnimation();
        }
        return true;
    }

    // Only apply an animation if the display isn't frozen.  If it is
    // frozen, there is no reason to animate and it can cause strange
    // artifacts when we unfreeze the display if some different animation
    // is running.
    if (mService.okToDisplay()) {
        int anim = mPolicy.selectAnimationLw(mWin, transit);  //调用PhoneWindowManager.selectAnimationLw(),如果该窗口是StatusBar、NavigationBar或startingWindow，那么该函数会返回一个指定的动画资源id；
        int attr = -1;
        Animation a = null;
        if (anim != 0) {
            a = anim != -1 ? AnimationUtils.loadAnimation(mContext, anim) : null;
        } else {
            switch (transit) {                //根据transit值选择对应的样式id;
                case WindowManagerPolicy.TRANSIT_ENTER:
                    attr = com.android.internal.R.styleable.WindowAnimation_windowEnterAnimation;
                    break;
                case WindowManagerPolicy.TRANSIT_EXIT:
                    attr = com.android.internal.R.styleable.WindowAnimation_windowExitAnimation;
                    break;
                case WindowManagerPolicy.TRANSIT_SHOW:
                    attr = com.android.internal.R.styleable.WindowAnimation_windowShowAnimation;
                    break;
                case WindowManagerPolicy.TRANSIT_HIDE:
                    attr = com.android.internal.R.styleable.WindowAnimation_windowHideAnimation;
                    break;
            }
            if (attr >= 0) {
                a = mService.mAppTransition.loadAnimationAttr(mWin.mAttrs, attr);    //调用AppTransition.loadAnimationAttr()加载Animation；
            }
        }
        if (WindowManagerService.DEBUG_ANIM) Slog.v(TAG,
                "applyAnimation: win=" + this
                + " anim=" + anim + " attr=0x" + Integer.toHexString(attr)
                + " a=" + a
                + " transit=" + transit
                + " isEntrance=" + isEntrance + " Callers " + Debug.getCallers(3));
        if (a != null) {                     //对于Activity窗口，a=null，对于非Activity窗口，如果指定了窗口动画，那么a!=null；
            if (WindowManagerService.DEBUG_ANIM) {
                RuntimeException e = null;
                if (!WindowManagerService.HIDE_STACK_CRAWLS) {
                    e = new RuntimeException();
                    e.fillInStackTrace();
                }
                Slog.v(TAG, "Loaded animation " + a + " for " + this, e);
            }
            setAnimation(a);              //将Animation设置到WindowStateAnimator.mAnimation中；
            mAnimationIsEntrance = isEntrance;
        }
    } else {
        clearAnimation();
    }

    return mAnimation != null;
}

    如果Activity窗口调用此函数设置一个窗口动画，而从前面第一部分知道对于Activity会设置一个Activity切换动画，那这两个动画搅在一起岂不是乱套了。

    对于WindowStateAnimator.applyAnimationLocked()函数还有其他地方会调用，下面调用栈就是一个例子。

at com.android.server.wm.WindowStateAnimator.applyAnimationLocked(WindowStateAnimator.java:1947)
at com.android.server.wm.WindowManagerService.removeWindowLocked(WindowManagerService.java:3022)
at com.android.server.wm.WindowManagerService.removeWindow(WindowManagerService.java:2977)
at com.android.server.wm.Session.remove(Session.java:193)
at android.view.IWindowSession$Stub.onTransact(IWindowSession.java:233)
at com.android.server.wm.Session.onTransact(Session.java:136)

第三部分：动画每一帧计算

    动画每一帧计算本质上就是根据第一部分加载出来的Animation（可能是Activity切换动画或窗口动画），结合时间变量计算出Transformation值，然后将 Transformation值apply到窗口Surface的各个属性上，最后将窗口Surface属性设置到SurfaceFlinger中，完成动画一帧显示。下图就是动画一帧计算的时序图，下面将分析每一步调用。

第1、2步、WMS.performLayoutAndPlaceSurfacesLockedInner()

    该函数是界面刷新函数，是WMS最核心的函数，窗口堆栈管理、各种特殊窗口处理、窗口layout计算等等均在该函数中完成，该函数最后会调用scheduleAnimationLocked()触发下一帧动画计算。scheduleAnimationLocked()只是简单的往Choreographer添加一个callback回调，待下一个vsync信号来临时便可触发调用callback。

void scheduleAnimationLocked() {
    if (!mAnimationScheduled) {
        mAnimationScheduled = true;
        mChoreographer.postFrameCallback(mAnimator.mAnimationFrameCallback);      //mAnimationFrameCallback是一个Choreographer.FrameCallback对象，在WindowAnimator类构造函数中赋值；
    }
}

WindowAnimator(final WindowManagerService service) {
    mService = service;
    mContext = service.mContext;
    mPolicy = service.mPolicy;
    mAnimationFrameCallback = new Choreographer.FrameCallback() {
        public void doFrame(long frameTimeNs) {
            synchronized (mService.mWindowMap) {
                mService.mAnimationScheduled = false;
                animateLocked(frameTimeNs);                                        //调用父类animateLocked()函数；
            }
        }
    };
}

第3步、WindowAnimator.animateLocked()

    该函数掌管着Activity切换动画、窗口动画、转屏动画，乃动画执行核心函数。从前面的动画设置部分我们已经知道，WMS会综合选择一个动画进入退出类型，然后根据resId从xml资源中加载出一个Animation对象，对于Activity切换动画、窗口动画会分别保存在AppWindowAnimator.animation和WindowStateAnimator.mAnimation中。WindowAnimator.animateLocked()函数会首先会根据Animation与时间值计算出一个Transformation值，Transformation中记录动画每一帧的透明度、裁剪尺寸、3*3阶旋转和缩放矩阵，然后在遍历窗口堆栈中所有窗口，调用WindowStateAnimator.prepareSurfaceLocked()来将Transformation值落实到更具体的surface属性上面，并设置到SurfaceFlinger中去，完成一帧动画的显示。

private void animateLocked(long frameTimeNs) {
    if (!mInitialized) {               //对于默认显示设备准备好后，该mInitialized就会一直为true；
        return;
    }

    mCurrentTime = frameTimeNs / TimeUtils.NANOS_PER_MS;         //将时间从纳秒折算成毫秒；
    mBulkUpdateParams = SET_ORIENTATION_CHANGE_COMPLETE;
    boolean wasAnimating = mAnimating;
    mAnimating = false;                                      //将mAnimating和mAppWindowAnimating重置为false。mAnimating是理解动画框架的关键，如果这一帧动画执行完成发现仍需接着执行下一帧动画，那么mAnimating就会被置为true。mAppWindowAnimating是AndroidM新增的一个变量，用来完善handleAnimatingStoppedAndTransitionLocked()被调用逻辑，AndroidM之前的版本在窗口做完动画也会触发调用handleAnimatingStoppedAndTransitionLocked()，AndroidM变成了只有在Activity切换动画完成时才会触发调用handleAnimatingStoppedAndTransitionLocked()。mAppWindowAnimating会在handleAppTransitionReadyLocked()中设置Activity切换动画时就置为true。
    mAppWindowAnimating = false;
    if (WindowManagerService.DEBUG_WINDOW_TRACE) {
        Slog.i(TAG, "!!! animate: entry time=" + mCurrentTime);
    }

    if (WindowManagerService.SHOW_TRANSACTIONS) Slog.i(
            TAG, ">>> OPEN TRANSACTION animateLocked");
    SurfaceControl.openTransaction();          //打开一次跟SurfaceFlinger的事务传输，待后面调用SurfaceControl.closeTransaction()时，会将这中间所有对surface的设置一次性传递给SurfaceFlinger，这样达到减少频繁进程间通信带来的损耗。
    SurfaceControl.setAnimationTransaction();
    try {
        final int numDisplays = mDisplayContentsAnimators.size();
        for (int i = 0; i < numDisplays; i++) {        //所有动画的计算就在这个for循环中，实际上这个只会循环一次，除非有多个显示设备。
            final int displayId = mDisplayContentsAnimators.keyAt(i);
            updateAppWindowsLocked(displayId);          //计算Activity切换动画Transformation值；
            DisplayContentsAnimator displayAnimator = mDisplayContentsAnimators.valueAt(i);

            final ScreenRotationAnimation screenRotationAnimation =
                    displayAnimator.mScreenRotationAnimation;
            if (screenRotationAnimation != null && screenRotationAnimation.isAnimating()) {
                if (screenRotationAnimation.stepAnimationLocked(mCurrentTime)) {       //计算转屏动画Transformation值；
                    mAnimating = true;
                } else {
                    mBulkUpdateParams |= SET_UPDATE_ROTATION;
                    screenRotationAnimation.kill();
                    displayAnimator.mScreenRotationAnimation = null;

                    //TODO (multidisplay): Accessibility supported only for the default display.
                    if (mService.mAccessibilityController != null
                            && displayId == Display.DEFAULT_DISPLAY) {
                        // We just finished rotation animation which means we did not
                        // anounce the rotation and waited for it to end, announce now.
                        mService.mAccessibilityController.onRotationChangedLocked(
                                mService.getDefaultDisplayContentLocked(), mService.mRotation);
                    }
                }
            }

            // Update animations of all applications, including those
            // associated with exiting/removed apps
            updateWindowsLocked(displayId);                    //计算窗口动画Transformation值；
            updateWallpaperLocked(displayId);

            final WindowList windows = mService.getWindowListLocked(displayId);
            final int N = windows.size();
            for (int j = 0; j < N; j++) {//遍历所有窗口，根据Transformation值，计算更新窗口的surface属性；
                windows.get(j).mWinAnimator.prepareSurfaceLocked(true);
            }
        }

        for (int i = 0; i < numDisplays; i++) {
            final int displayId = mDisplayContentsAnimators.keyAt(i);

            testTokenMayBeDrawnLocked(displayId);

            final ScreenRotationAnimation screenRotationAnimation =
                    mDisplayContentsAnimators.valueAt(i).mScreenRotationAnimation;
            if (screenRotationAnimation != null) {
                screenRotationAnimation.updateSurfacesInTransaction();
            }

            mAnimating |= mService.getDisplayContentLocked(displayId).animateDimLayers();

            //TODO (multidisplay): Magnification is supported only for the default display.
            if (mService.mAccessibilityController != null
                    && displayId == Display.DEFAULT_DISPLAY) {
                mService.mAccessibilityController.drawMagnifiedRegionBorderIfNeededLocked();
            }
        }

        if (mAnimating) {                     //如果动画仍未结束，那么触发执行下一帧动画；
            mService.scheduleAnimationLocked();
        }

        mService.setFocusedStackLayer();

        if (mService.mWatermark != null) {
            mService.mWatermark.drawIfNeeded();         //如果打开了水印，重绘水印；
        }
    } catch (RuntimeException e) {
        Slog.wtf(TAG, "Unhandled exception in Window Manager", e);
    } finally {
        SurfaceControl.closeTransaction();
        if (WindowManagerService.SHOW_TRANSACTIONS) Slog.i(
                TAG, "<<< CLOSE TRANSACTION animateLocked");
    }

    boolean hasPendingLayoutChanges = false;
    final int numDisplays = mService.mDisplayContents.size();
    for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
        final DisplayContent displayContent = mService.mDisplayContents.valueAt(displayNdx);
        final int pendingChanges = getPendingLayoutChanges(displayContent.getDisplayId());
        if ((pendingChanges & WindowManagerPolicy.FINISH_LAYOUT_REDO_WALLPAPER) != 0) {
            mBulkUpdateParams |= SET_WALLPAPER_ACTION_PENDING;
        }
        if (pendingChanges != 0) {
            hasPendingLayoutChanges = true;
        }
    }

    boolean doRequest = false;
    if (mBulkUpdateParams != 0) {
        doRequest = mService.copyAnimToLayoutParamsLocked();
    }

    if (hasPendingLayoutChanges || doRequest) {
        mService.requestTraversalLocked();
    }

    if (!mAnimating && wasAnimating) {
        mService.requestTraversalLocked();
    }
    if (WindowManagerService.DEBUG_WINDOW_TRACE) {
        Slog.i(TAG, "!!! animate: exit mAnimating=" + mAnimating
            + " mBulkUpdateParams=" + Integer.toHexString(mBulkUpdateParams)
            + " mPendingLayoutChanges(DEFAULT_DISPLAY)="
            + Integer.toHexString(getPendingLayoutChanges(Display.DEFAULT_DISPLAY)));
    }
}

第4、5、6步、WindowAnimator.updateAppWindowsLocked()

    updateAppWindowsLocked()函数遍历所有AppWindowAnimator，调用AppWindowAnimator.stepAnimationLocked()函数，根据时间、Animation来更新AppWindowAnimator.transformation值。更具体的计算逻辑请自行分析Animation.getTransformation()函数，里面包含了插值器逻辑。

private void updateAppWindowsLocked(int displayId) {
    ArrayList stacks = mService.getDisplayContentLocked(displayId).getStacks();
    for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {       //for循环遍历所有Stack，我们知道在AMS中一个ActivityStack对应WMS中一个TaskStack，目前只有两个Stack；
        final TaskStack stack = stacks.get(stackNdx);
        final ArrayList tasks = stack.getTasks();
        for (int taskNdx = tasks.size() - 1; taskNdx >= 0; --taskNdx) {       //for循环遍历Stack中所有Task；
            final AppTokenList tokens = tasks.get(taskNdx).mAppTokens;
            for (int tokenNdx = tokens.size() - 1; tokenNdx >= 0; --tokenNdx) {
                final AppWindowAnimator appAnimator = tokens.get(tokenNdx).mAppAnimator;
                appAnimator.wasAnimating = appAnimator.animating;
                if (appAnimator.stepAnimationLocked(mCurrentTime, displayId)) {    //调用AppWindowAnimator.stepAnimationLocked()，如果还有下一帧动画，那么函数返回true，该函数根据时间和插值器计算并更新AppWindowAnimator.transformation值;
                    appAnimator.animating = true;
                    mAnimating = mAppWindowAnimating = true;
                } else if (appAnimator.wasAnimating) {
                    // stopped animating, do one more pass through the layout
                    setAppLayoutChanges(appAnimator,
                            WindowManagerPolicy.FINISH_LAYOUT_REDO_WALLPAPER,
                            "appToken " + appAnimator.mAppToken + " done", displayId);
                    if (WindowManagerService.DEBUG_ANIM) Slog.v(TAG,
                            "updateWindowsApps...: done animating " + appAnimator.mAppToken);
                }
            }
        }
        final AppTokenList exitingAppTokens = stack.mExitingAppTokens;       //mExitingAppTokens中保存着延迟remove的AppWindowToken，为啥要延迟remove，因为需要一个退出动画或已经设置了一个退出动画；
        final int exitingCount = exitingAppTokens.size();
        for (int i = 0; i < exitingCount; i++) {
            final AppWindowAnimator appAnimator = exitingAppTokens.get(i).mAppAnimator;
            appAnimator.wasAnimating = appAnimator.animating;
            if (appAnimator.stepAnimationLocked(mCurrentTime, displayId)) {      //调用AppWindowAnimator.stepAnimationLocked();
                mAnimating = mAppWindowAnimating = true;
            } else if (appAnimator.wasAnimating) {
                // stopped animating, do one more pass through the layout
                setAppLayoutChanges(appAnimator, WindowManagerPolicy.FINISH_LAYOUT_REDO_WALLPAPER,
                    "exiting appToken " + appAnimator.mAppToken + " done", displayId);
                if (WindowManagerService.DEBUG_ANIM) Slog.v(TAG,
                        "updateWindowsApps...: done animating exiting " + appAnimator.mAppToken);
            }
        }
    }
}

第7、8步、ScreenRotationAnimation.stepAnimationLocked()

    转屏动画计算便在ScreenRotationAnimation.stepAnimationLocked()中完成，主要计算更新ScreenRotationAnimation.mEnterTransformation值。转屏动画的本质就是截一张图单独做转屏旋转，其Surface名为"ScreenshotSurface"，也就是说转屏动画并不是通过控制应用窗口的surface属性来达到转屏效果的，而是单独创建了一个surface，该surface显示内容来自SurfaceControl.screenshot()接口，前面计算出来的mEnterTransformation等值通过控制这个单独surface的属性来达到转屏动画效果， 关于转屏动画在此不多说，有兴趣的可以自行研究。但是有一个疑问，为啥做转屏动画时，比如从竖屏应用启动一个默认横屏的应用，系统并不会设置Activity切换动画？这个问题后面有空再分析解答。

第9、10、11步、WindowAnimator.updateWindowsLocked()

    该函数会遍历所有窗口计算其窗口动画一帧值，即调用WindowStateAnimator.stepAnimationLocked()计算更新WindowStateAnimator.mTransformation值。其他逻辑主要涉及到keyguard显示后，某些窗口是否隐藏或显示，及keyguard退出动画等，在此不细细分析。

private void updateWindowsLocked(final int displayId) {
    ++mAnimTransactionSequence;

    final WindowList windows = mService.getWindowListLocked(displayId);

    if (mKeyguardGoingAway) {          //mKeyguardGoingAway=true表示keyguard正在退出，那么对于窗口privateFlags & PRIVATE_FLAG_KEYGUARD!= 0窗口设置一个退出动画；
        for (int i = windows.size() - 1; i >= 0; i--) {
            WindowState win = windows.get(i);
            if (!mPolicy.isKeyguardHostWindow(win.mAttrs)) {
                continue;
            }
            final WindowStateAnimator winAnimator = win.mWinAnimator;
            if ((win.mAttrs.privateFlags & PRIVATE_FLAG_KEYGUARD) != 0) {
                if (!winAnimator.mAnimating) {
                    if (DEBUG_KEYGUARD) Slog.d(TAG,
                            "updateWindowsLocked: creating delay animation");

                    // Create a new animation to delay until keyguard is gone on its own.
                    winAnimator.mAnimation = new AlphaAnimation(1.0f, 1.0f);
                    winAnimator.mAnimation.setDuration(KEYGUARD_ANIM_TIMEOUT_MS);
                    winAnimator.mAnimationIsEntrance = false;
                    winAnimator.mAnimationStartTime = -1;
                    winAnimator.mKeyguardGoingAwayAnimation = true;
                }
            } else {
                if (DEBUG_KEYGUARD) Slog.d(TAG,
                        "updateWindowsLocked: StatusBar is no longer keyguard");
                mKeyguardGoingAway = false;
                winAnimator.clearAnimation();
            }
            break;
        }
    }

    mForceHiding = KEYGUARD_NOT_SHOWN;

    boolean wallpaperInUnForceHiding = false;
    boolean startingInUnForceHiding = false;
    ArrayList unForceHiding = null;
    WindowState wallpaper = null;
    for (int i = windows.size() - 1; i >= 0; i--) {      //for循环遍历堆栈中所有窗口；
        WindowState win = windows.get(i);
        WindowStateAnimator winAnimator = win.mWinAnimator;
        final int flags = win.mAttrs.flags;
        boolean canBeForceHidden = mPolicy.canBeForceHidden(win, win.mAttrs);     //canBeForceHidden()对于TYPE_STATUS_BAR、TYPE_WALLPAPER等窗口返回false，对于其他类型窗口如位于TYPE_STATUS_BAR之下的，那么返回true；
        boolean shouldBeForceHidden = shouldForceHide(win);                       //shouldForceHide()返回true表示keyguard是显示状态，并且win必须被隐藏；
        if (winAnimator.mSurfaceControl != null) {
            final boolean wasAnimating = winAnimator.mWasAnimating;
            final boolean nowAnimating = winAnimator.stepAnimationLocked(mCurrentTime);     //根据时间计算窗口动画Transition值，返回值为true表示还有下一帧动画，按理说该函数到这里就行了，为毛还有下面这一堆逻辑，下面来看下这些是干嘛的；
            winAnimator.mWasAnimating = nowAnimating;
            mAnimating |= nowAnimating;

            boolean appWindowAnimating = winAnimator.mAppAnimator != null
                    && winAnimator.mAppAnimator.animating;
            boolean wasAppWindowAnimating = winAnimator.mAppAnimator != null
                    && winAnimator.mAppAnimator.wasAnimating;
            boolean anyAnimating = appWindowAnimating || nowAnimating;          //当前是否正在做Activity切换动画或窗口动画；
            boolean anyWasAnimating = wasAppWindowAnimating || wasAnimating;    //前一次动画逻辑计算时，该Activity或窗口是否在做动画；

            try {
                if (anyAnimating && !anyWasAnimating) {                          //根据anyAnimating和anyWasAnimating组合判断当前是动画开始还是动画结束，进而通知上层应用窗口，这个是AndroidM新增的接口，非常棒的接口，AndroidM终于把动画这一块逻辑理清楚了。
                    win.mClient.onAnimationStarted(winAnimator.mAnimatingMove ? -1
                            : winAnimator.mKeyguardGoingAwayAnimation ? 1
                            : 0);
                } else if (!anyAnimating && anyWasAnimating) {
                    win.mClient.onAnimationStopped();
                }
            } catch (RemoteException e) {
                Slog.w(TAG, "Failed to dispatch window animation state change.", e);
            }

            if (WindowManagerService.DEBUG_WALLPAPER) {
                Slog.v(TAG, win + ": wasAnimating=" + wasAnimating +
                        ", nowAnimating=" + nowAnimating);
            }

            if (wasAnimating && !winAnimator.mAnimating && mService.mWallpaperTarget == win) {   //对于窗口动画结束时，如果该窗口是壁纸目标窗口，那么给pendingLayoutChanges加上FINISH_LAYOUT_REDO_WALLPAPER；
                mBulkUpdateParams |= SET_WALLPAPER_MAY_CHANGE;
                setPendingLayoutChanges(Display.DEFAULT_DISPLAY,
                        WindowManagerPolicy.FINISH_LAYOUT_REDO_WALLPAPER);
                if (WindowManagerService.DEBUG_LAYOUT_REPEATS) {
                    mService.debugLayoutRepeats("updateWindowsAndWallpaperLocked 2",
                            getPendingLayoutChanges(Display.DEFAULT_DISPLAY));
                }
            }
            //下面这些逻辑主要计算在keyguard状态下各种窗口可见性逻辑，及设置keyguard退出动画之类的，在此不细分析，省略；

            ........

第12步、WindowStateAnimator.prepareSurfaceLocked()

    对窗口堆栈中所有窗口执行WindowStateAnimator.prepareSurfaceLocked()设置每个窗口的动画帧。在前面已经根据时间、Animation值将AppWindowAnimator.transformation和WindowStateAnimator.mTransformation计算出来，接着就该将这两个Transformation转换成Surface的属性并设置到SurfaceFlinger中去。

public void prepareSurfaceLocked(final boolean recoveringMemory) {
    final WindowState w = mWin;
    if (mSurfaceControl == null) {               //对于没有Surface的窗口直接return,也就是说下面那些计算窗口surface显示相关的逻辑只针对有Surface的窗口；
        if (w.mOrientationChanging) {
            if (DEBUG_ORIENTATION) {
                Slog.v(TAG, "Orientation change skips hidden " + w);
            }
            w.mOrientationChanging = false;
        }
        return;
    }

    boolean displayed = false;

    computeShownFrameLocked();    //调用computeShownFrameLocked()计算Surface的mShownAlpha、mShownFrame，及缩放矩阵[mDsDx,mDtDx,mDsDy,mDtDy]；

    setSurfaceBoundariesLocked(recoveringMemory);    //这个函数更新Surface的起始位置、大小、偏移缩放矩阵、clipRect区域。

    if (mIsWallpaper && !mWin.mWallpaperVisible) {
        // Wallpaper is no longer visible and there is no wp target => hide it.
        hide();
    } else if (w.mAttachedHidden || !w.isOnScreen()) {
        hide();
        mService.hideWallpapersLocked(w);

        // If we are waiting for this window to handle an
        // orientation change, well, it is hidden, so
        // doesn't really matter.  Note that this does
        // introduce a potential glitch if the window
        // becomes unhidden before it has drawn for the
        // new orientation.
        if (w.mOrientationChanging) {
            w.mOrientationChanging = false;
            if (DEBUG_ORIENTATION) Slog.v(TAG,
                    "Orientation change skips hidden " + w);
        }
    } else if (mLastLayer != mAnimLayer
            || mLastAlpha != mShownAlpha
            || mLastDsDx != mDsDx
            || mLastDtDx != mDtDx
            || mLastDsDy != mDsDy
            || mLastDtDy != mDtDy
            || w.mLastHScale != w.mHScale
            || w.mLastVScale != w.mVScale
            || mLastHidden) {
        displayed = true;
        mLastAlpha = mShownAlpha;
        mLastLayer = mAnimLayer;
        mLastDsDx = mDsDx;
        mLastDtDx = mDtDx;
        mLastDsDy = mDsDy;
        mLastDtDy = mDtDy;
        w.mLastHScale = w.mHScale;
        w.mLastVScale = w.mVScale;
        if (WindowManagerService.SHOW_TRANSACTIONS) WindowManagerService.logSurface(w,
                "alpha=" + mShownAlpha + " layer=" + mAnimLayer
                + " matrix=[" + mDsDx + "*" + w.mHScale
                + "," + mDtDx + "*" + w.mVScale
                + "][" + mDsDy + "*" + w.mHScale
                + "," + mDtDy + "*" + w.mVScale + "]", null);
        if (mSurfaceControl != null) {        //更新surface的Alpha、Layer高度、2阶偏移缩放矩阵；
            try {
                mSurfaceAlpha = mShownAlpha;
                mSurfaceControl.setAlpha(mShownAlpha);
                mSurfaceLayer = mAnimLayer;
                mSurfaceControl.setLayer(mAnimLayer);
                mSurfaceControl.setMatrix(
                        mDsDx * w.mHScale, mDtDx * w.mVScale,
                        mDsDy * w.mHScale, mDtDy * w.mVScale);

                if (mLastHidden && mDrawState == HAS_DRAWN) {        //前一次状态是隐藏，并且绘制状态是HAS_DRAWN绘制完成状态，那么调用showSurfaceRobustlyLocked()将窗口正真显示出来；
                    if (WindowManagerService.SHOW_TRANSACTIONS) WindowManagerService.logSurface(w,
                            "SHOW (performLayout)", null);
                    if (WindowManagerService.DEBUG_VISIBILITY) Slog.v(TAG, "Showing " + w
                            + " during relayout");
                    if (showSurfaceRobustlyLocked()) {
                        mLastHidden = false;
                        if (mIsWallpaper) {
                            mService.dispatchWallpaperVisibility(w, true);
                        }
                        // This draw means the difference between unique content and mirroring.
                        // Run another pass through performLayout to set mHasContent in the
                        // LogicalDisplay.
                        mAnimator.setPendingLayoutChanges(w.getDisplayId(),
                                WindowManagerPolicy.FINISH_LAYOUT_REDO_ANIM);
                    } else {
                        w.mOrientationChanging = false;
                    }
                }
                if (mSurfaceControl != null) {
                    w.mToken.hasVisible = true;
                }
            } catch (RuntimeException e) {
                Slog.w(TAG, "Error updating surface in " + w, e);
                if (!recoveringMemory) {
                    mService.reclaimSomeSurfaceMemoryLocked(this, "update", true);
                }
            }
        }
    } else {
        if (DEBUG_ANIM && isAnimating()) {
            Slog.v(TAG, "prepareSurface: No changes in animation for " + this);
        }
        displayed = true;
    }

    if (displayed) {
        if (w.mOrientationChanging) {
            if (!w.isDrawnLw()) {
                mAnimator.mBulkUpdateParams &= ~SET_ORIENTATION_CHANGE_COMPLETE;
                mAnimator.mLastWindowFreezeSource = w;
                if (DEBUG_ORIENTATION) Slog.v(TAG,
                        "Orientation continue waiting for draw in " + w);
            } else {
                w.mOrientationChanging = false;
                if (DEBUG_ORIENTATION) Slog.v(TAG, "Orientation change complete in " + w);
            }
        }
        w.mToken.hasVisible = true;
    }
}

第13步、WindowStateAnimator.computeShownFrameLocked()

    该函数 根据转屏动画、窗口动画、父窗口动画、Activity切换动画的 Transformation 计算出Matrix矩阵值，及 mShownFrame和 mShownAlpha值，当然这些计算只针对有surface的窗口。

void computeShownFrameLocked() {
    final boolean selfTransformation = mHasLocalTransformation;    //mHasLocalTransformation=true表示在准备或正在做窗口动画；
    Transformation attachedTransformation =
            (mAttachedWinAnimator != null && mAttachedWinAnimator.mHasLocalTransformation)
            ? mAttachedWinAnimator.mTransformation : null;          //如果该窗口有父窗口，那么取得父窗口的Transformation值；
    Transformation appTransformation = (mAppAnimator != null && mAppAnimator.hasTransformation)
            ? mAppAnimator.transformation : null;                    //hasTransformation=true表示在准备货正在做Activity切换动画；

    // Wallpapers are animated based on the "real" window they
    // are currently targeting.
    final WindowState wallpaperTarget = mService.mWallpaperTarget;
    if (mIsWallpaper && wallpaperTarget != null && mService.mAnimateWallpaperWithTarget) {   //这个逻辑基本上不会走，因为wallpaperTarget != null和mService.mAnimateWallpaperWithTarget基本不可能同时满足；
        final WindowStateAnimator wallpaperAnimator = wallpaperTarget.mWinAnimator;
        if (wallpaperAnimator.mHasLocalTransformation &&
                wallpaperAnimator.mAnimation != null &&
                !wallpaperAnimator.mAnimation.getDetachWallpaper()) {
            attachedTransformation = wallpaperAnimator.mTransformation;
            if (WindowManagerService.DEBUG_WALLPAPER && attachedTransformation != null) {
                Slog.v(TAG, "WP target attached xform: " + attachedTransformation);
            }
        }
        final AppWindowAnimator wpAppAnimator = wallpaperTarget.mAppToken == null ?
                null : wallpaperTarget.mAppToken.mAppAnimator;
            if (wpAppAnimator != null && wpAppAnimator.hasTransformation
                && wpAppAnimator.animation != null
                && !wpAppAnimator.animation.getDetachWallpaper()) {
            appTransformation = wpAppAnimator.transformation;
            if (WindowManagerService.DEBUG_WALLPAPER && appTransformation != null) {
                Slog.v(TAG, "WP target app xform: " + appTransformation);
            }
        }
    }

    final int displayId = mWin.getDisplayId();
    final ScreenRotationAnimation screenRotationAnimation =
            mAnimator.getScreenRotationAnimationLocked(displayId);
    final boolean screenAnimation =
            screenRotationAnimation != null && screenRotationAnimation.isAnimating();
    if (selfTransformation || attachedTransformation != null
            || appTransformation != null || screenAnimation) {      //如果正在做窗口动画、父窗口有窗口动画、Activity切换动画、转屏动画中一种，那么需更新Surface属性。这个地方有个坑，为毛执行转屏动画时，无关窗口的Surface也被强制改了。
        // cache often used attributes locally
        final Rect frame = mWin.mFrame;
        final float tmpFloats[] = mService.mTmpFloats;
        final Matrix tmpMatrix = mWin.mTmpMatrix;
        //下面这大段逻辑是根据转屏动画、窗口动画、父窗口动画、Activity切换动画计算一个tmpMatrix临时矩阵值；
        // Compute the desired transformation.
        if (screenAnimation && screenRotationAnimation.isRotating()) {
            // If we are doing a screen animation, the global rotation
            // applied to windows can result in windows that are carefully
            // aligned with each other to slightly separate, allowing you
            // to see what is behind them.  An unsightly mess.  This...
            // thing...  magically makes it call good: scale each window
            // slightly (two pixels larger in each dimension, from the
            // window's center).
            final float w = frame.width();
            final float h = frame.height();
            if (w>=1 && h>=1) {
                tmpMatrix.setScale(1 + 2/w, 1 + 2/h, w/2, h/2);
            } else {
                tmpMatrix.reset();
            }
        } else {
            tmpMatrix.reset();
        }
        tmpMatrix.postScale(mWin.mGlobalScale, mWin.mGlobalScale);
        if (selfTransformation) {
            tmpMatrix.postConcat(mTransformation.getMatrix());
        }
        tmpMatrix.postTranslate(frame.left + mWin.mXOffset, frame.top + mWin.mYOffset);
        if (attachedTransformation != null) {
            tmpMatrix.postConcat(attachedTransformation.getMatrix());
        }
        if (appTransformation != null) {
            tmpMatrix.postConcat(appTransformation.getMatrix());
        }
        if (screenAnimation) {
            tmpMatrix.postConcat(screenRotationAnimation.getEnterTransformation().getMatrix());
        }

        //TODO (multidisplay): Magnification is supported only for the default display.
        if (mService.mAccessibilityController != null && displayId == Display.DEFAULT_DISPLAY) {
            MagnificationSpec spec = mService.mAccessibilityController
                    .getMagnificationSpecForWindowLocked(mWin);
            if (spec != null && !spec.isNop()) {
                tmpMatrix.postScale(spec.scale, spec.scale);
                tmpMatrix.postTranslate(spec.offsetX, spec.offsetY);
            }
        }

        // "convert" it into SurfaceFlinger's format
        // (a 2x2 matrix + an offset)
        // Here we must not transform the position of the surface
        // since it is already included in the transformation.
        //Slog.i(TAG, "Transform: " + matrix);

        mHaveMatrix = true;
        tmpMatrix.getValues(tmpFloats);
        mDsDx = tmpFloats[Matrix.MSCALE_X];   //将tmpMatrix矩阵值分别保存在mDsDx、mDtDx、mDsDy、mDtDy中；
        mDtDx = tmpFloats[Matrix.MSKEW_Y];
        mDsDy = tmpFloats[Matrix.MSKEW_X];
        mDtDy = tmpFloats[Matrix.MSCALE_Y];
        float x = tmpFloats[Matrix.MTRANS_X];    //(x,y)表示窗口在X、Y轴起始位置；
        float y = tmpFloats[Matrix.MTRANS_Y];
        int w = frame.width();
        int h = frame.height();
        mWin.mShownFrame.set(x, y, x+w, y+h);

        // Now set the alpha...  but because our current hardware
        // can't do alpha transformation on a non-opaque surface,
        // turn it off if we are running an animation that is also
        // transforming since it is more important to have that
        // animation be smooth.
        mShownAlpha = mAlpha;
        mHasClipRect = false;
        if (!mService.mLimitedAlphaCompositing
                || (!PixelFormat.formatHasAlpha(mWin.mAttrs.format)
                || (mWin.isIdentityMatrix(mDsDx, mDtDx, mDsDy, mDtDy)
                        && x == frame.left && y == frame.top))) {       //将转屏动画、窗口动画、父窗口动画、Activity切换动画的Alpha值apply到mShownAlpha上；
            //Slog.i(TAG, "Applying alpha transform");
            if (selfTransformation) {
                mShownAlpha *= mTransformation.getAlpha();
            }
            if (attachedTransformation != null) {
                mShownAlpha *= attachedTransformation.getAlpha();
            }
            if (appTransformation != null) {
                mShownAlpha *= appTransformation.getAlpha();
                if (appTransformation.hasClipRect()) {
                    mClipRect.set(appTransformation.getClipRect());
                    if (mWin.mHScale > 0) {
                        mClipRect.left /= mWin.mHScale;
                        mClipRect.right /= mWin.mHScale;
                    }
                    if (mWin.mVScale > 0) {
                        mClipRect.top /= mWin.mVScale;
                        mClipRect.bottom /= mWin.mVScale;
                    }
                    mHasClipRect = true;
                }
            }
            if (screenAnimation) {
                mShownAlpha *= screenRotationAnimation.getEnterTransformation().getAlpha();
            }
        } else {
            //Slog.i(TAG, "Not applying alpha transform");
        }

        if ((DEBUG_SURFACE_TRACE || WindowManagerService.localLOGV)
                && (mShownAlpha == 1.0 || mShownAlpha == 0.0)) Slog.v(
                TAG, "computeShownFrameLocked: Animating " + this + " mAlpha=" + mAlpha
                + " self=" + (selfTransformation ? mTransformation.getAlpha() : "null")
                + " attached=" + (attachedTransformation == null ?
                        "null" : attachedTransformation.getAlpha())
                + " app=" + (appTransformation == null ? "null" : appTransformation.getAlpha())
                + " screen=" + (screenAnimation ?
                        screenRotationAnimation.getEnterTransformation().getAlpha() : "null"));
        return;              //注意这个return，有动画时在此返回；
    } else if (mIsWallpaper && mService.mInnerFields.mWallpaperActionPending) {
        return;
    }
    //下面这些逻辑都是无动画时会走的逻辑；
    if (WindowManagerService.localLOGV) Slog.v(
            TAG, "computeShownFrameLocked: " + this +
            " not attached, mAlpha=" + mAlpha);

    MagnificationSpec spec = null;
    //TODO (multidisplay): Magnification is supported only for the default display.
    if (mService.mAccessibilityController != null && displayId == Display.DEFAULT_DISPLAY) {
        spec = mService.mAccessibilityController.getMagnificationSpecForWindowLocked(mWin);
    }
    if (spec != null) {            //如果开启了系统访问控制，那么就会使用预设好的属性，一般情况这个是关闭的；
        final Rect frame = mWin.mFrame;
        final float tmpFloats[] = mService.mTmpFloats;
        final Matrix tmpMatrix = mWin.mTmpMatrix;

        tmpMatrix.setScale(mWin.mGlobalScale, mWin.mGlobalScale);
        tmpMatrix.postTranslate(frame.left + mWin.mXOffset, frame.top + mWin.mYOffset);

        if (spec != null && !spec.isNop()) {
            tmpMatrix.postScale(spec.scale, spec.scale);
            tmpMatrix.postTranslate(spec.offsetX, spec.offsetY);
        }

        tmpMatrix.getValues(tmpFloats);

        mHaveMatrix = true;
        mDsDx = tmpFloats[Matrix.MSCALE_X];
        mDtDx = tmpFloats[Matrix.MSKEW_Y];
        mDsDy = tmpFloats[Matrix.MSKEW_X];
        mDtDy = tmpFloats[Matrix.MSCALE_Y];
        float x = tmpFloats[Matrix.MTRANS_X];
        float y = tmpFloats[Matrix.MTRANS_Y];
        int w = frame.width();
        int h = frame.height();
        mWin.mShownFrame.set(x, y, x + w, y + h);

        mShownAlpha = mAlpha;
    } else {                       //没有动画，并且没有开启系统访问控制，那么就使用如下逻辑设定这些属性值；
        mWin.mShownFrame.set(mWin.mFrame);
        if (mWin.mXOffset != 0 || mWin.mYOffset != 0) {
            mWin.mShownFrame.offset(mWin.mXOffset, mWin.mYOffset);
        }
        mShownAlpha = mAlpha;
        mHaveMatrix = false;
        mDsDx = mWin.mGlobalScale;
        mDtDx = 0;
        mDsDy = 0;
        mDtDy = mWin.mGlobalScale;
    }
}

第14步、WindowStateAnimator.setSurfaceBoundariesLocked()

    这个函数更新Surface的起始位置、大小、偏 移缩放矩阵、 clipRect区域。

void setSurfaceBoundariesLocked(final boolean recoveringMemory) {
    final WindowState w = mWin;

    int width;
    int height;
    if ((w.mAttrs.flags & LayoutParams.FLAG_SCALED) != 0) {   //目前只有SurfaceView设了这个flag；
        // for a scaled surface, we always want the requested
        // size.
        width  = w.mRequestedWidth;
        height = w.mRequestedHeight;
    } else {
        width = w.mCompatFrame.width();
        height = w.mCompatFrame.height();
    }

    // Something is wrong and SurfaceFlinger will not like this,
    // try to revert to sane values
    if (width < 1) {
        width = 1;
    }
    if (height < 1) {
        height = 1;
    }

    float left = w.mShownFrame.left;
    float top = w.mShownFrame.top;

    // Adjust for surface insets.
    final LayoutParams attrs = w.getAttrs();
    final int displayId = w.getDisplayId();
    float scale = 1.0f;
    // Magnification is supported only for the default display.
    if (mService.mAccessibilityController != null && displayId == Display.DEFAULT_DISPLAY) {
        MagnificationSpec spec =
                mService.mAccessibilityController.getMagnificationSpecForWindowLocked(w);
        if (spec != null && !spec.isNop()) {
            scale = spec.scale;
        }
    }
    //mShownFrame的X、Y轴起始值和mCompatFrame的宽高还需加上一个LayoutParams.surfaceInsets矫正值；
    width += scale * (attrs.surfaceInsets.left + attrs.surfaceInsets.right);
    height += scale * (attrs.surfaceInsets.top + attrs.surfaceInsets.bottom);
    left -= scale * attrs.surfaceInsets.left;
    top -= scale * attrs.surfaceInsets.top;

    final boolean surfaceMoved = mSurfaceX != left || mSurfaceY != top;
    if (surfaceMoved) {        //起始位置有偏移；
        mSurfaceX = left;
        mSurfaceY = top;

        try {
            if (WindowManagerService.SHOW_TRANSACTIONS) WindowManagerService.logSurface(w,
                    "POS " + left + ", " + top, null);
            mSurfaceControl.setPosition(left, top);      //更新surface的起始位置；
        } catch (RuntimeException e) {
            Slog.w(TAG, "Error positioning surface of " + w
                    + " pos=(" + left + "," + top + ")", e);
            if (!recoveringMemory) {
                mService.reclaimSomeSurfaceMemoryLocked(this, "position", true);
            }
        }
    }

    final boolean surfaceResized = mSurfaceW != width || mSurfaceH != height;
    if (surfaceResized) {       //surface大小有更改；
        mSurfaceW = width;
        mSurfaceH = height;
        mSurfaceResized = true;

        try {
            if (WindowManagerService.SHOW_TRANSACTIONS) WindowManagerService.logSurface(w,
                    "SIZE " + width + "x" + height, null);
            mSurfaceControl.setSize(width, height);      //设置surface大小；
            mSurfaceControl.setMatrix(
                    mDsDx * w.mHScale, mDtDx * w.mVScale,
                    mDsDy * w.mHScale, mDtDy * w.mVScale);      //设置surface的2阶偏移缩放矩阵。这个矩阵是如何用的？就是用这个二阶矩阵乘以(x,y)这个一阶矩阵，得出的坐标位置就是最终显示的坐标位置；
            mAnimator.setPendingLayoutChanges(w.getDisplayId(),
                    WindowManagerPolicy.FINISH_LAYOUT_REDO_WALLPAPER);
            if ((w.mAttrs.flags & LayoutParams.FLAG_DIM_BEHIND) != 0) {
                final TaskStack stack = w.getStack();
                if (stack != null) {
                    stack.startDimmingIfNeeded(this);
                }
            }
        } catch (RuntimeException e) {
            // If something goes wrong with the surface (such
            // as running out of memory), don't take down the
            // entire system.
            Slog.e(TAG, "Error resizing surface of " + w
                    + " size=(" + width + "x" + height + ")", e);
            if (!recoveringMemory) {
                mService.reclaimSomeSurfaceMemoryLocked(this, "size", true);
            }
        }
    }

    updateSurfaceWindowCrop(recoveringMemory);       //调用updateSurfaceWindowCrop()设置surface的窗口切割区域，什么是窗口切割区域clipRect，比如图库中放大显示一张图片，这张图片大小大过屏幕尺寸，用户看到的区域就是切割区域大小，为啥要切割，因为用户看不到的区域没必要合成显示，SurfaceFlinger会根据这个clipRect区域进行合成；该函数调用SurfaceControl.setWindowCrop()来设置窗口clipRect区域。
}

第15、16步、SurfaceControl.setXXX()/showSurfaceRobustlyLocked()
    这两步已经在上面的prepareSurfaceLocked(）函数中分析过了，对showSurfaceRobustlyLocked()函数多说一句，该函数只有从不可见要变为可见状态时才会被调用，函数里面调用SurfaceControl.show()来通知SurfaceFlinger该窗口可以显示出来。

总结：

    上面主要对每一步的函数调用进行了分析，动画每一帧计算就是由这些函数组成。希望读者要明白每个函数是干什么的，理解动画计算大概流程，待出问题时走一遍流程，找到问题点。动画每一帧计算主要可以概括成三步：第一步，将Animation根据时间值求出Transformation。第二步、根据计算出的Transformation值计算窗口Surface各个属性值。第三步、将Surface属性值设置到SurfaceFlinger中。

第四部分：通过日志快速分析动画资源来自哪里

分析步骤：

    ①首先打开WMS中所有日志开关，对于MTK平台，使用“ adb shell dumpsys window -d enable a”便可打开WMS的日志开关。

    ②抓取日志，在日志中搜索“Setting animation in”关键字，定位到目标窗口日志行，再向上翻日志查到最近的“applyAnimation:”、“Loading animations: picked package=”和“Loading animations:”关键字；

    ③“Loading animations:”关键字

    如果关键字是“Loading animations: layout params pkg=”， 那么resId取自某个窗口的WindowManager.LayoutParams.windowAnimations值( 可通过“adb shell dumpsys window w”打印窗口的属性查看究竟是哪个窗口的LayoutParams.windowAnimations值）。如果((resId&0xFF000000) == 0x01000000)为true，那么资源取自系统自带，否则取自应用程序。

    如果关键字是"Loading animations: package=" ，那么该资源resId是应用程序调用overrideInPlaceAppTransition()或overridePendingAppTransition()接口传进来的，该resId自然取自应用程序。

    ③“Loading animations: picked package=”关键字

    关键字后面接的就是这个动画资源来自哪里。如果"package = android"那这个可能是不准的，需要自己用((resId&0xFF000000) == 0x01000000)公式来算比较靠谱；如果package = 应用包名，那么资源就取自应用程序。

    ④“applyAnimation:”关键字

    关键字可以判断出这个动画是什么类型的：如果后面接的是“win=”，那么就是窗口动画；如果后面接的是" anim="，那么就是Activity切换动画，对于Activity切换动画，这条日志可以推出更多的信息，比如transit值等；

    下面是三份日志，第一份是设置Activity切换动画，第二份是设置PopupWindow窗口动画，第三份是设置Activity切换动画。读者可尝试根据上面所说的自行分析动画资源究竟取自哪里。

10-16 08:40:27.149   825   917 V AppTransition: Loading animations: package=com.meizu.flyme.launcher resId=0xa040040
10-16 08:40:27.149   825   917 V AppTransition: Loading animations: picked package=com.meizu.flyme.launcher      //关键字“Loading animations: picked package=”
10-16 08:40:27.149   825   917 I AppTransition:  id = a040040 overlayId = 0
10-16 08:40:27.151   825   917 V AppTransition: applyAnimation: anim=android.view.animation.AnimationSet@11689517 nextAppTransition=ANIM_CUSTOM transit=12 isEntrance=true Callers=com.android.server.wm.WindowManagerService.applyAnimationLocked:3878 com.android.server.wm.WindowManagerService.setTokenVisibilityLocked:4991 com.android.server.wm.WindowManagerService.handleAppTransitionReadyLocked:10053
10-16 08:40:27.151   825   917 V WindowManager: Loaded animation android.view.animation.AnimationSet@11689517 for AppWindowToken{1281e4b token=Token{234d731a ActivityRecord{1c78edc5 u0 com.android.mms/.ui.ConversationList t106}}}
10-16 08:40:27.151   825   917 V WindowManager: java.lang.RuntimeException
10-16 08:40:27.151   825   917 V WindowManager:     at com.android.server.wm.WindowManagerService.applyAnimationLocked(WindowManagerService.java:3886)
10-16 08:40:27.151   825   917 V WindowManager:     at com.android.server.wm.WindowManagerService.setTokenVisibilityLocked(WindowManagerService.java:4991)
10-16 08:40:27.151   825   917 V WindowManager:     at com.android.server.wm.WindowManagerService.handleAppTransitionReadyLocked(WindowManagerService.java:10053)
10-16 08:40:27.151   825   917 V WindowManager:     at com.android.server.wm.WindowManagerService.performLayoutAndPlaceSurfacesLockedInner(WindowManagerService.java:10788)
10-16 08:40:27.151   825   917 V WindowManager:     at com.android.server.wm.WindowManagerService.performLayoutAndPlaceSurfacesLockedLoop(WindowManagerService.java:9601)
10-16 08:40:27.151   825   917 V WindowManager:     at com.android.server.wm.WindowManagerService.performLayoutAndPlaceSurfacesLocked(WindowManagerService.java:9543)
10-16 08:40:27.151   825   917 V WindowManager:     at com.android.server.wm.WindowManagerService.access$700(WindowManagerService.java:182)
10-16 08:40:27.151   825   917 V WindowManager:     at com.android.server.wm.WindowManagerService$H.handleMessage(WindowManagerService.java:8457)
10-16 08:40:27.151   825   917 V WindowManager:     at android.os.Handler.dispatchMessage(Handler.java:111)
10-16 08:40:27.151   825   917 V WindowManager:     at android.os.Looper.loop(Looper.java:192)
10-16 08:40:27.151   825   917 V WindowManager:     at android.os.HandlerThread.run(HandlerThread.java:61)
10-16 08:40:27.151   825   917 V WindowManager:     at com.android.server.ServiceThread.run(ServiceThread.java:46)        //“Setting animation in”关键字
10-16 08:40:27.151   825   917 V AppWindowAnimator: Setting animation in AppWindowToken{1281e4b token=Token{234d731a ActivityRecord{1c78edc5 u0 com.android.mms/.ui.ConversationList t106}}}: android.view.animation.AnimationSet@11689517 wxh=1080x1920 isVisible=true
10-16 08:40:27.151   825   917 V AppWindowAnimator: Updating layer Window{1e5b3c6c u0 Starting com.android.mms}: 22015

   上面这份日志表明动画资源取自com.meizu.flyme.launcher。

10-16 16:48:12.874   825  1863 V AppTransition: Loading animations: layout params pkg=com.android.mms resId=0x7f0e0087
10-16 16:48:12.874   825  1863 V AppTransition: Loading animations: picked package=com.android.mms
10-16 16:48:12.874   825  1863 I AppTransition:  id = 7f050018 overlayId = 0
10-16 16:48:12.875   825  1863 V WindowStateAnimator: applyAnimation: win=WindowStateAnimator{8c23690 PopupWindow:2d5ab621} anim=0 attr=0x1 a=android.view.animation.AnimationSet@8928a66 transit=2 isEntrance=false Callers com.android.server.wm.WindowManagerService.removeWindowLocked:3022 com.android.server.wm.WindowManagerService.removeWindow:2977 com.android.server.wm.Session.remove:193
10-16 16:48:12.875   825  1863 V WindowStateAnimator: Loaded animation android.view.animation.AnimationSet@8928a66 for WindowStateAnimator{8c23690 PopupWindow:2d5ab621}
10-16 16:48:12.875   825  1863 V WindowStateAnimator: java.lang.RuntimeException
10-16 16:48:12.875   825  1863 V WindowStateAnimator:   at com.android.server.wm.WindowStateAnimator.applyAnimationLocked(WindowStateAnimator.java:1947)
10-16 16:48:12.875   825  1863 V WindowStateAnimator:   at com.android.server.wm.WindowManagerService.removeWindowLocked(WindowManagerService.java:3022)
10-16 16:48:12.875   825  1863 V WindowStateAnimator:   at com.android.server.wm.WindowManagerService.removeWindow(WindowManagerService.java:2977)
10-16 16:48:12.875   825  1863 V WindowStateAnimator:   at com.android.server.wm.Session.remove(Session.java:193)
10-16 16:48:12.875   825  1863 V WindowStateAnimator:   at android.view.IWindowSession$Stub.onTransact(IWindowSession.java:233)
10-16 16:48:12.875   825  1863 V WindowStateAnimator:   at com.android.server.wm.Session.onTransact(Session.java:136)
10-16 16:48:12.875   825  1863 V WindowStateAnimator:   at android.os.Binder.execTransact(Binder.java:451)
10-16 16:48:12.875   825  1863 V WindowStateAnimator: Setting animation in WindowStateAnimator{8c23690 PopupWindow:2d5ab621}: android.view.animation.AnimationSet@8928a66

    上面这份日志表明动画资源取自com.android.mms。

10-16 16:58:18.414   825   917 V AppTransition: Loading animations: layout params pkg=android resId=0xa1000d4
10-16 16:58:18.414   825   917 V AppTransition: Loading animations: picked package=android
10-16 16:58:18.414   825   917 I AppTransition:  id = a04002d overlayId = 0
10-16 16:58:18.415   825   917 V AppTransition: applyAnimation: anim=android.view.animation.AnimationSet@185fc32b animAttr=0x4 transit=6 isEntrance=true Callers=com.android.server.wm.WindowManagerService.applyAnimationLocked:3878 com.android.server.wm.WindowManagerService.setTokenVisibilityLocked:4991 com.android.server.wm.WindowManagerService.handleAppTransitionReadyLocked:10053
10-16 16:58:18.416   825   917 V WindowManager: Loaded animation android.view.animation.AnimationSet@185fc32b for AppWindowToken{3583ca17 token=Token{987e96 ActivityRecord{233b49b1 u0 android/com.android.internal.app.MzResolverActivity t109}}}
10-16 16:58:18.416   825   917 V WindowManager: java.lang.RuntimeException
10-16 16:58:18.416   825   917 V WindowManager:     at com.android.server.wm.WindowManagerService.applyAnimationLocked(WindowManagerService.java:3886)
10-16 16:58:18.416   825   917 V WindowManager:     at com.android.server.wm.WindowManagerService.setTokenVisibilityLocked(WindowManagerService.java:4991)
10-16 16:58:18.416   825   917 V WindowManager:     at com.android.server.wm.WindowManagerService.handleAppTransitionReadyLocked(WindowManagerService.java:10053)
10-16 16:58:18.416   825   917 V WindowManager:     at com.android.server.wm.WindowManagerService.performLayoutAndPlaceSurfacesLockedInner(WindowManagerService.java:10788)
10-16 16:58:18.416   825   917 V WindowManager:     at com.android.server.wm.WindowManagerService.performLayoutAndPlaceSurfacesLockedLoop(WindowManagerService.java:9601)
10-16 16:58:18.416   825   917 V WindowManager:     at com.android.server.wm.WindowManagerService.performLayoutAndPlaceSurfacesLocked(WindowManagerService.java:9543)
10-16 16:58:18.416   825   917 V WindowManager:     at com.android.server.wm.WindowManagerService.access$700(WindowManagerService.java:182)
10-16 16:58:18.416   825   917 V WindowManager:     at com.android.server.wm.WindowManagerService$H.handleMessage(WindowManagerService.java:8457)
10-16 16:58:18.416   825   917 V WindowManager:     at android.os.Handler.dispatchMessage(Handler.java:111)
10-16 16:58:18.416   825   917 V WindowManager:     at android.os.Looper.loop(Looper.java:192)
10-16 16:58:18.416   825   917 V WindowManager:     at android.os.HandlerThread.run(HandlerThread.java:61)
10-16 16:58:18.416   825   917 V WindowManager:     at com.android.server.ServiceThread.run(ServiceThread.java:46)
10-16 16:58:18.416   825   917 V AppWindowAnimator: Setting animation in AppWindowToken{3583ca17 token=Token{987e96 ActivityRecord{233b49b1 u0 android/com.android.internal.app.MzResolverActivity t109}}}: android.view.animation.AnimationSet@185fc32b wxh=1080x1920 isVisible=true

    上面这份日志表明动画资源取自android/com.android.internal.app.MzResolverActivity窗口，说明MzResolverActivity这个Activity肯定是内部重新设了窗口的Activity切换动画资源，检查源码果然发现在onCreate()函数内部使用setTheme(com.flyme.internal.R.style.Theme_Flyme_Resolver)重置了Activity切换动画。

    最后总结一下： Activity切换动画可能来源包括系统默认、调用startActivity()或 overridePendingAppTransition()指定、应用Activity内部重置窗口LayoutParams.windowAnimations值（可通过setTheme()来重置），这三者取其一，互斥关系；窗口动画来源包括：系统默认、窗口指定的LayoutParams.windowAnimations。

原文地址
http://blog.csdn.net/guoqifa29/article/details/49273065