我们知道Android动画主要包括Activity切换动画、窗口动画、转屏动画、窗口内部View动画,前三者在WindowManagerService(简称WMS)中完成,本篇文章重点分析Activity切换动画、窗口动画的设置,动画每一帧计算,及如何快速分析动画类型资源。阅读本文最好有一定的WindowManagerService基础,本文所有代码基于AndroidM。
Activity切换动画设置主要包含下面这些步骤,每个步骤按时序图中的顺序依次执行,对于重要的步骤我已标注并附上简单的解释,下面将仔细分析每一步。
从上面可以看到对于普通Activity切换,会调用AppTransition.loadAnimationAttr()来加载一个动画。
第7、8步、ScreenRotationAnimation.stepAnimationLocked()
第14步、WindowStateAnimator.setSurfaceBoundariesLocked()
第15、16步、SurfaceControl.setXXX()/showSurfaceRobustlyLocked()
这两步已经在上面的prepareSurfaceLocked()函数中分析过了,对showSurfaceRobustlyLocked()函数多说一句,该函数只有从不可见要变为可见状态时才会被调用,函数里面调用SurfaceControl.show()来通知SurfaceFlinger该窗口可以显示出来。
上面这份日志表明动画资源取自android/com.android.internal.app.MzResolverActivity窗口,说明MzResolverActivity这个Activity肯定是内部重新设了窗口的Activity切换动画资源,检查源码果然发现在onCreate()函数内部使用setTheme(com.flyme.internal.R.style.Theme_Flyme_Resolver)重置了Activity切换动画。
典型的Activity切换动画包括:activityOpenEnterAnimation,activityOpenExitAnimation,taskOpenEnterAnimation, taskCloseExitAnimation, wallpaperOpenEnterAnimation, wallpaperCloseEnterAnimation。典型的窗口动画包括:windowEnterAnimation,windowExitAnimation。
我们知道每一个Activity在WMS中对应有一个APPWindowToken,APPWindowToken内部有一个AppWindowAnimator类型对象,Activity切换动画逻辑便是在AppTransition、AppWindowAnimator中完成。每个Activity一般情况下都有一个窗口,窗口是用WindowState来描述的,每个窗口有一个WindowStateAnimator类型对象,这个对象管理着窗口Surface和窗口动画。有了这些基本信息,下面就来分析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<TaskStack> stacks = displayContent.getStacks();
- for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
- final ArrayList<Task> 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;
- }
- 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)
方法设置一个指定的样式窗口动画,样式如下:
- <style name="popwin_anim_style">
- <item name="android:windowEnterAnimation">@anim/menushow</item>
- <item name="android:windowExitAnimation">@anim/menuhide</item>
- </style>
下面将详细分析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<TaskStack> 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<Task> 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);
- }
- }
- }
- }
转屏动画计算便在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<WindowStateAnimator> 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;
- }
- }
这个函数更新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
最后总结一下:
Activity切换动画可能来源包括系统默认、调用startActivity()或
overridePendingAppTransition()指定、应用Activity内部重置窗口LayoutParams.windowAnimations值(可通过setTheme()来重置),这三者取其一,互斥关系;窗口动画来源包括:系统默认、窗口指定的LayoutParams.windowAnimations。
原文地址
http://blog.csdn.net/guoqifa29/article/details/49273065
原文地址
http://blog.csdn.net/guoqifa29/article/details/49273065