Android6.0 WMS（八） 顯示Activity的啓動窗口



在Android系統中，Activity組件在啓動之後，並且在它的窗口顯示出來之前，可以顯示一個啓動窗口。這個啓動窗口可以看作是Activity組件的預覽窗口，是由WindowManagerService服務統一管理的，即由WindowManagerService服務負責啓動和結束。在本文中，我們就詳細分析WindowManagerService服務啓動和結束Activity組件的啓動窗口的過程。

Activity組件的啓動窗口是由ActivityManagerService服務來決定是否要顯示的。如果需要顯示，那麼ActivityManagerService服務就會通知WindowManagerService服務來爲正在啓動的Activity組件顯示一個啓動窗口，而WindowManagerService服務又是通過窗口管理策略類PhoneWindowManager來創建這個啓動窗口的。

注意，Activity組件的啓動窗口是由ActivityManagerService服務來控制是否顯示的，也就是說，Android應用程序是無法決定是否要要Activity組件顯示啓動窗口的。接下來，我們就分別分析Activity組件的啓動窗口的顯示和結束過程。

一. Activity組件的啓動窗口的顯示過程

        從前面Android應用程序啓動過程源代碼分析一文可以知道，Activity組件在啓動的過程中，會調用ActivityStack類的成員函數startActivityLocked。注意，在調用ActivityStack類的成員函數startActivityLocked的時候，Actvitiy組件還處於啓動的過程，即它的窗口尚未顯示出來，不過這時候ActivityManagerService服務會檢查是否需要爲正在啓動的Activity組件顯示一個啓動窗口。如果需要的話，那麼ActivityManagerService服務就會請求WindowManagerService服務爲正在啓動的Activity組件設置一個啓動窗口。這個過程如圖所示。

圖 Activity組件的啓動窗口的顯示過程

這個過程可以分爲6個步驟，接下來我們就詳細分析每一個步驟。

1.1 ActivityStack的startActivityLocked

    final void startActivityLocked(ActivityRecord r, boolean newTask,
            boolean doResume, boolean keepCurTransition, Bundle options) {
        ......
        
        if (!isHomeStack() || numActivities() > 0) {
            // We want to show the starting preview window if we are
            // switching to a new task, or the next activity's process is
            // not currently running.
            boolean showStartingIcon = newTask;
            ProcessRecord proc = r.app;
            if (proc == null) {
                proc = mService.mProcessNames.get(r.processName, r.info.applicationInfo.uid);
            }
            .....
            
            if ((r.intent.getFlags() & Intent.FLAG_ACTIVITY_NO_ANIMATION) != 0) {
                mWindowManager.prepareAppTransition(AppTransition.TRANSIT_NONE, keepCurTransition);//設置app變化相關
                mNoAnimActivities.add(r);
            } else {
                mWindowManager.prepareAppTransition(newTask
                        ? r.mLaunchTaskBehind
                                ? AppTransition.TRANSIT_TASK_OPEN_BEHIND
                                : AppTransition.TRANSIT_TASK_OPEN
                        : AppTransition.TRANSIT_ACTIVITY_OPEN, keepCurTransition);
                mNoAnimActivities.remove(r);
            }
            mWindowManager.addAppToken(task.mActivities.indexOf(r),//調用WMS增加AppToken
                    r.appToken, r.task.taskId, mStackId, r.info.screenOrientation, r.fullscreen,
                    (r.info.flags & ActivityInfo.FLAG_SHOW_FOR_ALL_USERS) != 0, r.userId,
                    r.info.configChanges, task.voiceSession != null, r.mLaunchTaskBehind);
            boolean doShow = true;
            if (newTask) {
                if ((r.intent.getFlags() & Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED) != 0) {
                    resetTaskIfNeededLocked(r, r);
                    doShow = topRunningNonDelayedActivityLocked(null) == r;
                }
            } else if (options != null && new ActivityOptions(options).getAnimationType()
                    == ActivityOptions.ANIM_SCENE_TRANSITION) {
                doShow = false;
            }
            if (r.mLaunchTaskBehind) {
                mWindowManager.setAppVisibility(r.appToken, true);
                ensureActivitiesVisibleLocked(null, 0);
            } else if (SHOW_APP_STARTING_PREVIEW && doShow) {
                ActivityRecord prev = mResumedActivity;
                if (prev != null) {
                    // We don't want to reuse the previous starting preview if:
                    // (1) The current activity is in a different task.
                    if (prev.task != r.task) {
                        prev = null;
                    }
                    // (2) The current activity is already displayed.
                    else if (prev.nowVisible) {
                        prev = null;
                    }
                }
                mWindowManager.setAppStartingWindow(
                        r.appToken, r.packageName, r.theme,
                        mService.compatibilityInfoForPackageLocked(
                                r.info.applicationInfo), r.nonLocalizedLabel,
                        r.labelRes, r.icon, r.logo, r.windowFlags,
                        prev != null ? prev.appToken : null, showStartingIcon);
                r.mStartingWindowShown = true;
            }
        } else {
            mWindowManager.addAppToken(task.mActivities.indexOf(r), r.appToken,
                    r.task.taskId, mStackId, r.info.screenOrientation, r.fullscreen,
                    (r.info.flags & ActivityInfo.FLAG_SHOW_FOR_ALL_USERS) != 0, r.userId,
                    r.info.configChanges, task.voiceSession != null, r.mLaunchTaskBehind);
            ActivityOptions.abort(options);
            options = null;
        }
        ......
        if (doResume) {
            mStackSupervisor.resumeTopActivitiesLocked(this, r, options);
        }
    }

 上面這個函數先調用了WMS的addAppToken函數增加一個AppToken。

ActivityStack類的靜態成員變量SHOW_APP_STARTING_PREVIEW是用描述系統是否可以爲正在啓動的Activity組件顯示啓動窗口，只有在它的值等於true，以及正在啓動的Activity組件的窗口接下來是要顯示出來的情況下，即變量doShow的值等於true，ActivityManagerService服務纔會請求WindowManagerService服務爲正在啓動的Activity組件設置啓動窗口。

1.2 WindowManagerService.setAppStartingWindow

setAppStartingWindow函數比較長我們來分段解析：

            AppWindowToken wtoken = findAppWindowToken(token);
            if (wtoken == null) {
                Slog.w(TAG, "Attempted to set icon of non-existing app token: " + token);
                return;
            }
 
            // If the display is frozen, we won't do anything until the
            // actual window is displayed so there is no reason to put in
            // the starting window.
            if (!okToDisplay()) {
                return;
            }
 
            if (wtoken.startingData != null) {
                return;
            }

參數token描述的是要設置啓動窗口的Activity組件，而參數transferFrom描述的是要將啓動窗口轉移給Activity組件token的Activity組件。這兩個Activity組件是運行在同一個任務中的，並且參數token描述的Activity組件Activity組件是正在啓動的Activity組件，而參數transferFrom描述的Activity組件是系統當前激活的Activity組件。
        這段代碼首先調用WindowManagerService類的成員函數findAppWindowToken來獲得與參數token對應的一個類型爲AppWindowToken的窗口令牌wtoken。如果這個AppWindowToken對象的成員變量startingData的值不等於null，那麼就說明參數token所描述的Activity組件已經設置過啓動窗口了，因此，WindowManagerService類的成員函數setAppStartingWindow就不用往下處理了。

函數okToDisplay如下：

    boolean okToDisplay() {
        return !mDisplayFrozen && mDisplayEnabled && mPolicy.isScreenOn();
    }

        這段代碼還會檢查系統屏幕當前是否處於凍結狀態，即WindowManagerService類的成員變量mDisplayFrozen的值是否等於true，或者系統屏幕當前是否處於黑屏狀態，即indowManagerService類的成員變量mPolicy所指向的一個PhoneWindowManager對象的成員函數isScreenOn的返回值是否等於false。以及mDisplayEnabled是否被允許顯示。如果是處於上述三種狀態的話，那麼WindowManagerService類的成員函數setAppStartingWindow就不用往下處理的。因爲在這幾種種狀態下，爲token所描述的Activity組件設置的啓動窗口是無法顯示的。

繼續分析：

            if (transferFrom != null) {
                AppWindowToken ttoken = findAppWindowToken(transferFrom);
                if (ttoken != null) {
                    WindowState startingWindow = ttoken.startingWindow;
                    if (startingWindow != null) {//有啓動窗口
                        // In this case, the starting icon has already been displayed, so start
                        // letting windows get shown immediately without any more transitions.
                        mSkipAppTransitionAnimation = true;
 
                        if (DEBUG_STARTING_WINDOW) Slog.v(TAG,
                                "Moving existing starting " + startingWindow + " from " + ttoken
                                + " to " + wtoken);
                        final long origId = Binder.clearCallingIdentity();
 
                        // Transfer the starting window over to the new token.
                        wtoken.startingData = ttoken.startingData;
                        wtoken.startingView = ttoken.startingView;
                        wtoken.startingDisplayed = ttoken.startingDisplayed;
                        ttoken.startingDisplayed = false;
                        wtoken.startingWindow = startingWindow;
                        wtoken.reportedVisible = ttoken.reportedVisible;
                        ttoken.startingData = null;
                        ttoken.startingView = null;
                        ttoken.startingWindow = null;
                        ttoken.startingMoved = true;
                        startingWindow.mToken = wtoken;
                        startingWindow.mRootToken = wtoken;
                        startingWindow.mAppToken = wtoken;
 
                        startingWindow.getWindowList().remove(startingWindow);
                        mWindowsChanged = true;
 
                        ttoken.windows.remove(startingWindow);
                        ttoken.allAppWindows.remove(startingWindow);
                        addWindowToListInOrderLocked(startingWindow, true);
 
                        if (ttoken.allDrawn) {
                            wtoken.allDrawn = true;
                            wtoken.deferClearAllDrawn = ttoken.deferClearAllDrawn;
                        }
                        if (ttoken.firstWindowDrawn) {
                            wtoken.firstWindowDrawn = true;
                        }
                        if (!ttoken.hidden) {
                            wtoken.hidden = false;
                            wtoken.hiddenRequested = false;
                            wtoken.willBeHidden = false;
                        }
                        if (wtoken.clientHidden != ttoken.clientHidden) {
                            wtoken.clientHidden = ttoken.clientHidden;
                            wtoken.sendAppVisibilityToClients();
                        }
                        ttoken.mAppAnimator.transferCurrentAnimation(
                                wtoken.mAppAnimator, startingWindow.mWinAnimator);
 
                        updateFocusedWindowLocked(UPDATE_FOCUS_WILL_PLACE_SURFACES,
                                true /*updateInputWindows*/);
                        getDefaultDisplayContentLocked().layoutNeeded = true;
                        performLayoutAndPlaceSurfacesLocked();//刷新系統
                        Binder.restoreCallingIdentity(origId);
                        return;//結束
                    } else if (ttoken.startingData != null) {//沒有啓動窗口，但有啓動數據
                        wtoken.startingData = ttoken.startingData;
                        ttoken.startingData = null;
                        ttoken.startingMoved = true;
                        Message m = mH.obtainMessage(H.ADD_STARTING, wtoken);
                        mH.sendMessageAtFrontOfQueue(m);
                        return;//結束
                    }
                    final AppWindowAnimator tAppAnimator = ttoken.mAppAnimator;
                    final AppWindowAnimator wAppAnimator = wtoken.mAppAnimator;
                    if (tAppAnimator.thumbnail != null) {
                        if (wAppAnimator.thumbnail != null) {
                            wAppAnimator.thumbnail.destroy();
                        }
                        wAppAnimator.thumbnail = tAppAnimator.thumbnail;
                        wAppAnimator.thumbnailX = tAppAnimator.thumbnailX;
                        wAppAnimator.thumbnailY = tAppAnimator.thumbnailY;
                        wAppAnimator.thumbnailLayer = tAppAnimator.thumbnailLayer;
                        wAppAnimator.thumbnailAnimation = tAppAnimator.thumbnailAnimation;
                        tAppAnimator.thumbnail = null;
                    }
                }
            }
 
            if (!createIfNeeded) {
                return;
            }
 
            if (theme != 0) {
                AttributeCache.Entry ent = AttributeCache.instance().get(pkg, theme,
                        com.android.internal.R.styleable.Window, mCurrentUserId);
                if (ent == null) {
                    return;
                }
 
                final boolean windowIsTranslucentDefined = ent.array.hasValue(
                        com.android.internal.R.styleable.Window_windowIsTranslucent);
                final boolean windowIsTranslucent = ent.array.getBoolean(
                        com.android.internal.R.styleable.Window_windowIsTranslucent, false);
                final boolean windowSwipeToDismiss = ent.array.getBoolean(
                        com.android.internal.R.styleable.Window_windowSwipeToDismiss, false);
                if (windowIsTranslucent || (!windowIsTranslucentDefined && windowSwipeToDismiss)) {
                    return;
                }
                if (ent.array.getBoolean(
                        com.android.internal.R.styleable.Window_windowIsFloating, false)) {
                    return;
                }
                if (ent.array.getBoolean(
                        com.android.internal.R.styleable.Window_windowShowWallpaper, false)) {
                    if (mWallpaperTarget == null) {
                        windowFlags |= FLAG_SHOW_WALLPAPER;
                    } else {
                        return;
                    }
                }
            }
 
            wtoken.startingData = new StartingData(pkg, theme, compatInfo, nonLocalizedLabel,
                    labelRes, icon, logo, windowFlags);
            Message m = mH.obtainMessage(H.ADD_STARTING, wtoken);
            mH.sendMessageAtFrontOfQueue(m);
        }

如果參數transferFrom的值不等於null，那麼就需要檢查它所描述的Activity組件是否設置有啓動窗口。如果設置有的話，那麼就需要將它的啓動窗口設置爲參數token所描述的Activity組件的啓動窗口。
        參數transferFrom所描述的Activity組件所設置的啓動窗口保存在與它所對應的一個類型爲AppWindowToken的窗口令牌的成員變量startingWindow或者startingData中，因此，這段代碼首先調用WindowManagerService類的成員函數findAppWindowToken來獲得與參數transferFrom對應的一個AppWindowToken對象ttoken。如果AppWindowToken對象ttoken的成員變量startingWindow的值不等於null，那麼就說明參數transferFrom所描述的Activity組件的啓動窗口已經創建出來了。另一方面，如果AppWindowToken對象ttoken的成員變量startingData的值不等於null，那麼就說明用來描述參數transferFrom所描述的Activity組件的啓動窗口的相關數據已經準備好了，但是這個啓動窗口還未創建出來。接下來我們就分別分析這兩種情況。

       我們首先分析AppWindowToken對象ttoken的成員變量startingWindow的值不等於null的情況。

       這時候如果WindowManagerService類的成員變量mStartingIconInTransition的值等於true，那麼就說明參數transferFrom所描述的Activity組件所設置的啓動窗口已經在啓動的過程中了。在這種情況下，就需要跳過參數token所描述的Activity組件和參數transferFrom所描述的Activity組件的切換過程，即將WindowManagerService類的成員變量mSkipAppTransitionAnimation的值設置爲true，這是因爲接下來除了要將參數transferFrom所描述的Activity組件的啓動窗口轉移給參數token所描述的Activity組件之外，還需要將參數transferFrom所描述的Activity組件的窗口狀態轉移給參數token所描述的Activity組件的窗口。

       將參數transferFrom所描述的Activity組件的啓動窗口轉移給參數token所描述的Activity組件需要執行以下幾個操作：

       1. 將AppWindowToken對象ttoken的成員變量startingData、startingView和startingWindow的值設置到AppWindowToken對象wtoken的對應成員變量中去，其中，成員變量startingData指向的是一個StartingData對象，它描述的是用來創建啓動窗口的相關數據，成員變量startingView指向的是一個View對象，它描述的是啓動窗口的頂層視圖，成員變量startingWindow指向的是一個WindowState對象，它描述的就是啓動窗口。

        2. 將AppWindowToken對象ttoken的成員變量startingData、startingView和startingWindow的值設置爲null，這是因爲參數transferFrom所描述的Activity組件的啓動窗口已經轉移給參數token所描述的Activity組件了。

        3. 將原來屬於參數transferFrom所描述的Activity組件的啓動窗口startingWindow的成員變量mToken、mRootToken和mAppToken的值設置爲wtoken，因爲這個啓動窗口現在已經屬於參數token所描述的Activity組件了。

        將參數transferFrom所描述的Activity組件的窗口狀態轉移給參數token所描述的Activity組件的窗口需要執下幾個操作：

        1. 將啓動窗口startingWindow從窗口堆棧中刪除，即從WindowManagerService類的成員變量mWindows所描述的一個ArrayList中刪除。

        2. 將啓動窗口startingWindow從屬於窗口令牌ttoken的窗口列表中刪除，即從AppWindowToken對象ttoken的成員變量windows和allAppWindows所描述的兩個ArrayList中刪除。

        3. 調用WindowManagerService類的成員函數addWindowToListInOrderLocked重新將啓動窗口startingWindow插入到窗口堆棧中去。注意，因爲這時候啓動窗口startingWindow已經被設置爲參數token所描述的Activity組件了，因此，在重新將它插入到窗口堆棧中去的時候，它就會位於參數token所描述的Activity組件的窗口的上面，這一點可以參考前面Android窗口管理服務WindowManagerService對窗口的組織方式分析一文。

        4. 如果AppWindowToken對象ttoken的成員變量allDrawn和firstWindowDrawn的值等於true，那麼就說明與AppWindowToken對象ttoken對應的所有窗口或者第一個窗口已經繪製好了，這時候也需要分別將AppWindowToken對象wtoken的成員變量allDrawn和firstWindowDrawn的值設置爲true，以便可以迫使那些與AppWindowToken對象wtoken對應的窗口接下來可以馬上顯示出來。

        5. 如果AppWindowToken對象ttoken的成員變量hidden的值等於false，那麼就說明參數transferFrom所描述的Activity組件是處於可見狀態的，這時候就需要將AppWindowToken對象wtoken的成員變量hidden、hiddenRequested和willBeHidden的值也設置爲false，以便表示參數token所描述的Activity組件也是處於可見狀態的。

        6. AppWindowToken類的成員變量clientHidden描述的是對應的Activity組件在應用程序進程這一側的可見狀態。如果AppWindowToken對象wtoken和ttoken的成員變量clientHidden的值不相等，那麼就需要將AppWindowToken對象ttoken的成員變量clientHidden的值設置給AppWindowToken對象wtoken的成員變量clientHidden，並且調用AppWindowToken對象wtoken的成員函數sendAppVisibilityToClients來通知相應的應用程序進程，運行在它裏面的參數token所描述的Activity組件的可見狀態。

        7. 如果AppWindowToken對象ttoken的成員變量animation的值不等於null，那麼就說明參數transferFrom所描述的Activity組件的窗口正在顯示動畫，那麼就需要將該動畫轉移給參數token所描述的Activity組件的窗口，即將AppWindowToken對象ttoken的成員變量animation、animating和animLayerAdjustment的值設置到AppWindowToken對象wtoken的對應成員變量，並且將AppWindowToken對象ttoken的成員變量animation和animLayerAdjustment的值設置爲null和0。最後還需要重新計算與AppWindowToken對象ttoken和wtoken所對應的窗口的Z軸位置。

       8. 由於前面的操作導致窗口堆棧的窗口發生了變化，因此就需要調用WindowManagerService類的成員函數updateFocusedWindowLocked來重新計算系統當前可獲得焦點的窗口，以及調用WindowManagerService類的成員函數performLayoutAndPlaceSurfacesLocked來刷新系統的UI。

       我們接着分析AppWindowToken對象ttoken的成員變量startingData的值不等於null的情況。

       這時候由於WindowManagerService服務還沒有參數transferFrom所描述的Activity組件創建啓動窗口，因此，這段代碼只需要將用創建這個啓動窗口的相關數據轉移給參數token所描述的Activity組件就可以了，即將AppWindowToken對象ttoken的成員變量startingData的值設置給AppWindowToken對象wtoken的成員變量startingData，並且將AppWindowToken對象ttoken的成員變量startingData的值設置爲null。

       由於這時候參數token所描述的Activity組件的啓動窗口還沒有創建出來，因此，接下來就會向WindowManagerService服務所運行在的線程的消息隊列的頭部插入一個類型ADD_STARTING的消息。當這個消息被處理的時候，WindowManagerService服務就會爲參數token所描述的Activity組件創建一個啓動窗口。

       WindowManagerService類的成員變量mH指向的是一個類型爲H的對象。H是WindowManagerService的一個內部類，它是從Handler類繼承下來的，因此，調用它的成員函數sendMessageAtFrontOfQueue就可以往一個線程的消息隊列的頭部插入一個消息。又由於 WindowManagerService類的成員變量mH所指向的一個H對象是在WindowManagerService服務所運行在的線程中創建的，因此，調用它的成員函數sendMessageAtFrontOfQueue發送的消息是保存在WindowManagerService服務所運行在的線程的消息隊列中的。

       如果參數transferFrom所描述的Activity組件沒有啓動窗口或者啓動窗口數據轉移給參數token所描述的Activity組件，那麼接下來就可能需要爲參數token所描述的Activity組件創建一個新的啓動窗口。

       但是如果啓動窗口和啓動數據都沒有，我們就要新建StartingData（啓動數據），然後發送ADD_STARTING消息。

我們再來看這個消息的處理：

1.3 ADD_STARTING消息處理

ADD_STARTING消息處理肯定是時啓動窗口沒有，所以需要窗口啓動窗口的。

                case ADD_STARTING: {
                    final AppWindowToken wtoken = (AppWindowToken)msg.obj;
                    final StartingData sd = wtoken.startingData;
 
                    if (sd == null) {
                        // Animation has been canceled... do nothing.
                        return;
                    }
 
                    View view = null;
                    try {
                        view = mPolicy.addStartingWindow(
                            wtoken.token, sd.pkg, sd.theme, sd.compatInfo,
                            sd.nonLocalizedLabel, sd.labelRes, sd.icon, sd.logo, sd.windowFlags);
                    } catch (Exception e) {
                        Slog.w(TAG, "Exception when adding starting window", e);
                    }
 
                    if (view != null) {
                        boolean abort = false;
 
                        synchronized(mWindowMap) {
                            if (wtoken.removed || wtoken.startingData == null) {
                                // If the window was successfully added, then
                                // we need to remove it.
                                if (wtoken.startingWindow != null) {
                                    wtoken.startingWindow = null;
                                    wtoken.startingData = null;
                                    abort = true;
                                }
                            } else {
                                wtoken.startingView = view;
                            }
                        }
 
                        if (abort) {
                            try {
                                mPolicy.removeStartingWindow(wtoken.token, view);
                            } catch (Exception e) {
                                Slog.w(TAG, "Exception when removing starting window", e);
                            }
                        }
                    }
                } break;

參數msg指向一個Message對象，從前面的Step 2可以知道，它的成員變量what的值等於ADD_STARTING，而成員變量obj指向的是一個AppWindowToken對象。這個AppWindowToken對象描述的就是要創建啓動窗口的Activity組件。H類的成員函數handleMessage首先獲得該AppWindowToken對象，並且保存在變量wtoken中。

        有了AppWindowToken對象wtoken，H類的成員函數handleMessage就可以通過它的成員變量startingData來獲得一個StartingData對象，並且保存在變量sd中。StartingData對象sd裏面保存了創建啓動窗口所需要的參數，因此，H類的成員函數handleMessage就可以通過這些參數來調用外部類WindowManagerService的成員變量mPolicy所指向的一個PhoneWindowManager對象的成員函數addStartingWindow來爲AppWindowToken對象wtoken所描述的Activity組件創建啓動窗口。

        如果能夠成功地爲AppWindowToken對象wtoken所描述的Activity組件創建啓動窗口，那麼PhoneWindowManager類的成員函數addStartingWindow就返回該Activity組件的啓動窗口的頂層視圖。H類的成員函數handleMessage獲得這個視圖之後，就會將它保存在變量view中。

        由於在創建這個啓動窗口的過程中，AppWindowToken對象wtoken所描述的Activity組件可能已經被移除，即AppWindowToken對象wtoken的成員變量removed的值等於true，或者它的啓動窗口已經被轉移給另外一個Activity組件了，即AppWindowToken對象wtoken的成員變量startingData的值等於null。在這兩種情況下，如果AppWindowToken對象wtoken的成員變量startingWindow的值不等於null，那麼就說明前面不僅成功地爲AppWindowToken對象wtoken所描述的Activity組件創建了啓動窗口，並且這個啓動窗口也已經成功地增加到WindowManagerService服務中去了，因此，就需要將該啓動窗口從WindowManagerService服務中刪除，這是通過調用外部類WindowManagerService的成員變量mPolicy所指向的一個PhoneWindowManager對象的成員函數removeStartingWindow來實現的。注意，在刪除之前，還會將AppWindowToken對象wtoken的成員變量startingWindow和startingData的值均設置爲null，以表示它所描述的Activity組件沒有一個關聯的啓動窗口。

        另一方面，如果AppWindowToken對象wtoken所描述的Activity組件沒有被移除，並且它的啓動窗口了沒有轉移給另外一個Activity組件，那麼H類的成員函數handleMessage就會將前面得到的啓動窗口的頂層視圖保存在AppWindowToken對象wtoken的成員變量startingView中。注意，這時候AppWindowToken對象wtoken的成員變量startingWindow會指向一個WindowState對象，這個WindowState對象是由PhoneWindowManager類的成員函數addStartingWindow請求WindowManagerService服務創建的。

        接下來，我們就繼續分析PhoneWindowManager類的成員函數addStartingWindow的實現，以便可以瞭解它是如何爲一個Activity組件創建一個啓動窗口，並且將這個啓動窗口增加到WindowManagerService服務中去的。

1.4 PhoneWindowManager的addStartingWindow函數

我們再來看看PhoneWindowManager的addStartingWindow函數

    public View addStartingWindow(IBinder appToken, String packageName, int theme,
            CompatibilityInfo compatInfo, CharSequence nonLocalizedLabel, int labelRes,
            int icon, int logo, int windowFlags) {
        if (!SHOW_STARTING_ANIMATIONS) {
            return null;
        }
        if (packageName == null) {
            return null;
        }
 
        WindowManager wm = null;
        View view = null;
 
        try {
            Context context = mContext;
            if (theme != context.getThemeResId() || labelRes != 0) {
                try {
                    context = context.createPackageContext(packageName, 0);
                    context.setTheme(theme);
                } catch (PackageManager.NameNotFoundException e) {
                    // Ignore
                }
            }
 
            PhoneWindow win = new PhoneWindow(context);
            win.setIsStartingWindow(true);
            final TypedArray ta = win.getWindowStyle();
            if (ta.getBoolean(
                        com.android.internal.R.styleable.Window_windowDisablePreview, false)
                || ta.getBoolean(
                        com.android.internal.R.styleable.Window_windowShowWallpaper,false)) {
                return null;
            }
 
            Resources r = context.getResources();
            win.setTitle(r.getText(labelRes, nonLocalizedLabel));
 
            win.setType(
                WindowManager.LayoutParams.TYPE_APPLICATION_STARTING);//注意這個，type是TYPE_APPLICATION_STARTING
 
            synchronized (mWindowManagerFuncs.getWindowManagerLock()) {
                // Assumes it's safe to show starting windows of launched apps while
                // the keyguard is being hidden. This is okay because starting windows never show
                // secret information.
                if (mKeyguardHidden) {
                    windowFlags |= FLAG_SHOW_WHEN_LOCKED;
                }
            }
            win.setFlags(
                windowFlags|
                WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE|
                WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE|
                WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM,
                windowFlags|
                WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE|
                WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE|
                WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);
 
            win.setDefaultIcon(icon);
            win.setDefaultLogo(logo);
 
            win.setLayout(WindowManager.LayoutParams.MATCH_PARENT,
                    WindowManager.LayoutParams.MATCH_PARENT);
 
            final WindowManager.LayoutParams params = win.getAttributes();
            params.token = appToken;
            params.packageName = packageName;
            params.windowAnimations = win.getWindowStyle().getResourceId(
                    com.android.internal.R.styleable.Window_windowAnimationStyle, 0);
            params.privateFlags |=
                    WindowManager.LayoutParams.PRIVATE_FLAG_FAKE_HARDWARE_ACCELERATED;
            params.privateFlags |= WindowManager.LayoutParams.PRIVATE_FLAG_SHOW_FOR_ALL_USERS;
 
            if (!compatInfo.supportsScreen()) {
                params.privateFlags |= WindowManager.LayoutParams.PRIVATE_FLAG_COMPATIBLE_WINDOW;
            }
 
            params.setTitle("Starting " + packageName);
 
            wm = (WindowManager)context.getSystemService(Context.WINDOW_SERVICE);
            view = win.getDecorView();
 
            if (win.isFloating()) {
                return null;
            }
 
            wm.addView(view, params);
            return view.getParent() != null ? view : null;

PhoneWindowManager這個函數就是創建了一個窗口，然後設置type（我們注意上面的type是TYPE_APPLICATION_STARTING代表應用剛啓動） flag layout，最後把這個窗口通過WMS的addWindow函數（這個我們之前的博客分析過）加入WMS中管理。

二. Activity組件的啓動窗口的結束過程

  Activity組件啓動完成之後，它的窗口就會顯示出來，這時候WindowManagerService服務就需要將它的啓動窗口結束掉。我們知道，在WindowManagerService服務中，每一個窗口都對應有一個WindowState對象。每當WindowManagerService服務需要顯示一個窗口的時候，就會調用一個對應的WindowState對象的成員函數performShowLocked。WindowState類的成員函數performShowLocked在執行的過程中，就會檢查當前正在處理的WindowState對象所描述的窗口是否設置有啓動窗口。如果有的話，那麼就會將它結束掉。這個過程如圖所示。

在commitFinishDrawingLocked函數中，而當mAttrs.type == TYPE_APPLICATION_STARTING就會調用performShowLocked函數，前面當我們啓動一個應用的啓動窗口會在PhoneWindowManager的addStartingWindow函數中新建一個窗口，並且type設置爲這個類型。

    boolean commitFinishDrawingLocked() {
        if (mDrawState != COMMIT_DRAW_PENDING && mDrawState != READY_TO_SHOW) {
            return false;
        }
 
        mDrawState = READY_TO_SHOW;
        final AppWindowToken atoken = mWin.mAppToken;
        if (atoken == null || atoken.allDrawn || mWin.mAttrs.type == TYPE_APPLICATION_STARTING) {
            return performShowLocked();
        }
        return false;
    }

然後commitFinishDrawingLocked又在performLayoutAndPlaceSurfacesLockedInner函數中調用（這個就是WMS刷新的核心函數）。

2.1 WindowStateAnimator的performShowLocked函數

    boolean performShowLocked() {
        if (mWin.isHiddenFromUserLocked()) {
            if (DEBUG_VISIBILITY) Slog.w(TAG, "hiding " + mWin + ", belonging to " + mWin.mOwnerUid);
            mWin.hideLw(false);
            return false;
        }
 
        if (mDrawState == READY_TO_SHOW && mWin.isReadyForDisplayIgnoringKeyguard()) {
            if (SHOW_TRANSACTIONS || DEBUG_ORIENTATION)
                WindowManagerService.logSurface(mWin, "SHOW (performShowLocked)", null);
 
            mService.enableScreenIfNeededLocked();
 
            applyEnterAnimationLocked();
 
            // Force the show in the next prepareSurfaceLocked() call.
            mLastAlpha = -1;
            if (DEBUG_SURFACE_TRACE || DEBUG_ANIM)
                Slog.v(TAG, "performShowLocked: mDrawState=HAS_DRAWN in " + this);
            mDrawState = HAS_DRAWN;
            mService.scheduleAnimationLocked();
 
            int i = mWin.mChildWindows.size();
            while (i > 0) {
                i--;
                WindowState c = mWin.mChildWindows.get(i);
                if (c.mAttachedHidden) {
                    c.mAttachedHidden = false;
                    if (c.mWinAnimator.mSurfaceControl != null) {
                        c.mWinAnimator.performShowLocked();
                        // It hadn't been shown, which means layout not
                        // performed on it, so now we want to make sure to
                        // do a layout.  If called from within the transaction
                        // loop, this will cause it to restart with a new
                        // layout.
                        final DisplayContent displayContent = c.getDisplayContent();
                        if (displayContent != null) {
                            displayContent.layoutNeeded = true;
                        }
                    }
                }
            }
 
            if (mWin.mAttrs.type != TYPE_APPLICATION_STARTING
                    && mWin.mAppToken != null) {
                mWin.mAppToken.firstWindowDrawn = true;
 
                if (mWin.mAppToken.startingData != null) {
                    // If this initial window is animating, stop it -- we
                    // will do an animation to reveal it from behind the
                    // starting window, so there is no need for it to also
                    // be doing its own stuff.
                    clearAnimation();
                    mService.mFinishedStarting.add(mWin.mAppToken);
                    mService.mH.sendEmptyMessage(H.FINISHED_STARTING);
                }
                mWin.mAppToken.updateReportedVisibilityLocked();
            }
 
            return true;
        }
 
        return false;
    }

對當前正在正在處理的窗口執行以下操作：

        1. 將對應的WindowState對象的成員變量mLastAlpha的值設置爲-1，以便以後在顯示窗口之前，都可以更新窗口的Alpha通道值。

        2. 將對應的WindowState對象的成員變量mHasDrawn的值設置爲true，以便可以表示窗口的UI繪製出來了。

        3. 確保屏幕對WindowManagerService服務是可用的，這是通過調用WindowManagerService類的成員函數enableScreenIfNeededLocked來實現的。系統在啓動完成之前，屏幕是用來顯示開機動畫的，這時候屏幕是被開機動畫佔用的。等到系統啓動完成之後，屏幕就應該是被WindowManagerService服務佔用的，這時候就需要停止顯示開機動畫。WindowManagerService類的成員函數enableScreenIfNeededLocked就是確保開機動畫已經停止顯示。

        4. 給窗口設置一個進入動畫或者顯示動畫，這是通過調用WindowManagerService類的成員函數applyEnterAnimationLocked來實現的。默認是設置爲顯示動畫，但是如果窗口之前是不可見的，那麼就會設置爲進入動畫。

        5. 子窗口處理

    由於當前正在處理的窗口可能有子窗口，因此就需要在顯示完成當前正在處理的窗口之後，繼續將它的子窗口顯示出來。如果一個窗口具有子窗口，那麼這些子窗口就會保存在一個對應的WindowState對象的成員變量mChildWindows所描述的一個ArrayList中。注意，只有那些父窗口上一次是不可見的，並且具有繪圖表面的子窗口才需要顯示。顯示子窗口是通過遞歸調用WindowState類的成員函數performShowLocked來實現的。

        6. 啓動窗口處理

       最後，如果當前正在處理的窗口是一個Acitivy組件相關的窗口，並且不是Acitivy組件的啓動窗口，即當前正在處理的WindowState對象的成員變量mAppToken的值不等於null，並且成員變量mAttrs所指向的一個WindowManager.LayoutParams對象的成員變量type的值不等於TYPE_APPLICATION_STARTING，那麼就需要檢查該Acitivy組件是否設置有啓動窗口。如果設置有啓動窗口的話，那麼就需要結束顯示該啓動窗口，因爲與該Acitivy組件相關的其它窗口已經顯示出來了。

       只要當前正在處理的WindowState對象的成員變量mAppToken不等於null，並且它所指向的一個AppWindowToken對象的成員變量startingData的值也不等於null，那麼就說明當前正在處理的窗口是一個Acitivy組件相關的窗口，並且這個Acitivy組件設置有一個啓動窗口。在這種情況下，WindowState類的成員函數performShowLocked就會調用WindowManagerService類的成員變量mH所指向的一個H對象的成員函數sendEmptyMessage來向WindowManagerService服務所運行在的線程發送一個類型爲FINISHED_STARTING的消息，表示要結束顯示一個Acitivy組件的啓動窗口。在發送這個消息之前，WindowState類的成員函數performShowLocked還會將用來描述要結束顯示啓動窗口的Activity組件的一個AppWindowToken對象增加到WindowManagerService類的成員變量mFinishedStarting所描述的一個ArrayList中去。

        注意，如果這時候當前正在處理的窗口還在顯示動畫，即當前正在處理的WindowState對象的成員變量mAnimation的值不等於null，那麼WindowState類的成員函數performShowLocked就會同時將該動畫結束掉，就會調用clearAnimation即將當前正在處理的WindowState對象的成員變量mAnimation的值設置爲null，但是會將另外一個成員變量mAnimating的值設置爲true，以便可以在其它地方對當前正在處理的窗口的動畫進行清理。

    public void clearAnimation() {
        if (mAnimation != null) {
            mAnimating = true;
            mLocalAnimating = false;
            mAnimation.cancel();
            mAnimation = null;
            mKeyguardGoingAwayAnimation = false;
        }
    }

        還有一個地方需要注意的是，如果當前正在處理的窗口是一個Acitivy組件相關的窗口，那麼WindowState類的成員函數performShowLocked還會調用當前正在處理的WindowState對象的成員變量mAppToken所指向的一個AppWindowToken對象的成員函數updateReportedVisibilityLocked來向ActivityManagerService服務報告該Acitivy組件的可見性。

        接下來，我們就繼續分析在WindowManagerService類內部定義的H類的成員函數sendEmptyMessage的實現，以便可以瞭解Acitivy組件的啓動窗口的結束過程。

2.2 FINISHED_STARTING消息處理

消息的處理是在WMS中：

                case FINISHED_STARTING: {
                    IBinder token = null;
                    View view = null;
                    while (true) {
                        synchronized (mWindowMap) {
                            final int N = mFinishedStarting.size();
                            if (N <= 0) {
                                break;
                            }
                            AppWindowToken wtoken = mFinishedStarting.remove(N-1);
 
                            if (wtoken.startingWindow == null) {
                                continue;
                            }
 
                            view = wtoken.startingView;
                            token = wtoken.token;
                            wtoken.startingData = null;
                            wtoken.startingView = null;
                            wtoken.startingWindow = null;
                            wtoken.startingDisplayed = false;
                        }
 
                        try {
                            mPolicy.removeStartingWindow(token, view);
                        } catch (Exception e) {
                            Slog.w(TAG, "Exception when removing starting window", e);
                        }
                    }
                } break;

之前在performShowLocked中會把啓動窗口加入mFinishedStarting隊列，這裏先檢查下mFinishedStarting隊列是否爲空，如果爲空直接退出。不爲空一個一個去除其中的窗口。將啓動窗口的各項數據清空，然後調用PhoneWindowManager的removeStartingWindow函數。

2.3 PhoneWindowManager的removeStartingWindow函數

PhoneWindowManager的removeStartingWindow函數直接到WindowManagerImpl的removeView中了。

    public void removeStartingWindow(IBinder appToken, View window) {
        if (window != null) {
            WindowManager wm = (WindowManager)mContext.getSystemService(Context.WINDOW_SERVICE);
            wm.removeView(window);
        }
    }

WindowManagerImpl的removeView函數直接調用了WindowManagerGlobal的removeView函數了

    @Override
    public void removeView(View view) {
        mGlobal.removeView(view, false);
    }

WindowManagerGlobal的removeView函數調用了removeViewLocked函數。

    public void removeView(View view, boolean immediate) {
        if (view == null) {
            throw new IllegalArgumentException("view must not be null");
        }
 
        synchronized (mLock) {
            int index = findViewLocked(view, true);
            View curView = mRoots.get(index).getView();
            removeViewLocked(index, immediate);
            if (curView == view) {
                return;
            }
 
            throw new IllegalStateException("Calling with view " + view
                    + " but the ViewAncestor is attached to " + curView);
        }
    }

這個函數主要是調用了ViewRootImpl的die函數。

    private void removeViewLocked(int index, boolean immediate) {
        ViewRootImpl root = mRoots.get(index);
        View view = root.getView();
 
        if (view != null) {
            InputMethodManager imm = InputMethodManager.getInstance();
            if (imm != null) {
                imm.windowDismissed(mViews.get(index).getWindowToken());
            }
        }
        boolean deferred = root.die(immediate);
        if (view != null) {
            view.assignParent(null);
            if (deferred) {
                mDyingViews.add(view);
            }
        }
    }

2.4 ViewRootImpl的die函數

這裏傳入的參數immediate是false，所以直接發送了MSG_DIE信號。

    boolean die(boolean immediate) {
        // Make sure we do execute immediately if we are in the middle of a traversal or the damage
        // done by dispatchDetachedFromWindow will cause havoc on return.
        if (immediate && !mIsInTraversal) {
            doDie();
            return false;
        }
 
        if (!mIsDrawing) {
            destroyHardwareRenderer();
        } else {
            Log.e(TAG, "Attempting to destroy the window while drawing!\n" +
                    "  window=" + this + ", title=" + mWindowAttributes.getTitle());
        }
        mHandler.sendEmptyMessage(MSG_DIE);
        return true;
    }

MSG_DIE信號的處理直接是調用了doDie函數。

            case MSG_DIE:
                doDie();
                break;

我們來看下ViewRootImpl的doDie函數

    void doDie() {
        synchronized (this) {
            if (mRemoved) {
                return;
            }
            mRemoved = true;
            if (mAdded) {
                dispatchDetachedFromWindow();
            }
 
            if (mAdded && !mFirst) {
                destroyHardwareRenderer();
 
                if (mView != null) {
                    int viewVisibility = mView.getVisibility();
                    boolean viewVisibilityChanged = mViewVisibility != viewVisibility;
                    if (mWindowAttributesChanged || viewVisibilityChanged) {
                        // If layout params have been changed, first give them
                        // to the window manager to make sure it has the correct
                        // animation info.
                        try {
                            if ((relayoutWindow(mWindowAttributes, viewVisibility, false)
                                    & WindowManagerGlobal.RELAYOUT_RES_FIRST_TIME) != 0) {
                                mWindowSession.finishDrawing(mWindow);
                            }
                        } catch (RemoteException e) {
                        }
                    }
 
                    mSurface.release();
                }
            }
 
            mAdded = false;
        }
        WindowManagerGlobal.getInstance().doRemoveView(this);
    }

我們先看WindowManagerGlobal的doRemoveView函數只是去除一些變量而已

    void doRemoveView(ViewRootImpl root) {
        synchronized (mLock) {
            final int index = mRoots.indexOf(root);
            if (index >= 0) {
                mRoots.remove(index);
                mParams.remove(index);
                final View view = mViews.remove(index);
                mDyingViews.remove(view);
            }
        }
        if (HardwareRenderer.sTrimForeground && HardwareRenderer.isAvailable()) {
            doTrimForeground();
        }
    }

 ViewRootImpl類有一個成員變量mAdded，當它的值等於true的時候，就表示當前正在處理的ViewRoot對象有一個關聯的View對象，因此，這時候就可以調用另外一個成員函數dispatchDetachedFromWindow來刪除這個View對象。由於刪除了這個View對象之後，當前正在處理的ViewRootImpl對象就不再關聯有View對象了，因此，ViewRootImpl類的成員函數doDie在調用另外一個成員函數dispatchDetachedFromWindow之前，還會將成員變量mAdded的值設置爲false。

    void dispatchDetachedFromWindow() {
        ......
        try {
            mWindowSession.remove(mWindow);
        } catch (RemoteException e) {
        }
        ......
    }

每一個與UI相關的應用程序進程，都與WindowManagerService服務建立有一個連接，這個連接是通過一個實現了IWindowSession接口的Binder代理對象來描述的，並且這個Binder代理對象就保存在ViewRoot類的靜態成員變量sWindowSession中，它引用了運行在WindowManagerService服務這一側的一個類型爲Session的Binder本地對象。

        注意，由於當前進程即爲WindowManagerService服務所運行在的進程，因此，這時候ViewRootImpl類的靜態成員變量sWindowSession保存的其實不是一個實現了IWindowSession接口的Binder代理對象，而是一個實現了IWindowSession接口的類型爲Session的Binder本地對象。這是因爲Binder驅動發現Client和Service是位於同一個進程的時候，就會將Service的本地接口直接返回給Client，而不會將Service的代理對象返回給Client，這樣就可以避免在同一進程中執行Binder進程間調用也會經過Binder驅動來中轉。

進程中的每一個窗口都有一個對應的W對象，這個W對象就保存在ViewRootImpl類的成員變量mWindow中。有了這個W對象之後，ViewRootImpl類的成員函數dispatchDetachedFromWindow就可以調用靜態成員變量sWindowSession所描述的一個Session對象的成員函數remove來通知WindowManagerService服務刪除一個對應的WindowState對象。從前面的調用過程可以知道，這個WindowState對象描述的是一個Activity組件的啓動窗口，因此，WindowManagerService服務刪除了這個WindowState對象之後，就相當於是將一個Activity組件的啓動窗口結束掉了。

        接下來，我們就繼續分析Session類的成員函數remove的實現，以便可以瞭解Activity組件的啓動窗口的結束過程。

final class Session extends IWindowSession.Stub
        implements IBinder.DeathRecipient {
    ......
 
    public void remove(IWindow window) {
        mService.removeWindow(this, window);
    }

2.5 WMS的removeWindow函數

最後到了WMS的removeWindow中。找到其相關的windowState，然後調用removeWindowLocked函數。

    public void removeWindow(Session session, IWindow client) {
        synchronized(mWindowMap) {
            WindowState win = windowForClientLocked(session, client, false);
            if (win == null) {
                return;
            }
            removeWindowLocked(win);
        }
    }

removeWindowLocked函數

    void removeWindowLocked(WindowState win) {
        final boolean startingWindow = win.mAttrs.type == TYPE_APPLICATION_STARTING;
        final long origId = Binder.clearCallingIdentity();
 
        win.disposeInputChannel();
        boolean wasVisible = false;
 
        if (win.mHasSurface && okToDisplay()) {
            // If we are not currently running the exit animation, we
            // need to see about starting one.
            wasVisible = win.isWinVisibleLw();
            if (wasVisible) {
 
                final int transit = (!startingWindow)
                        ? WindowManagerPolicy.TRANSIT_EXIT
                        : WindowManagerPolicy.TRANSIT_PREVIEW_DONE;
 
                // Try starting an animation.
                if (win.mWinAnimator.applyAnimationLocked(transit, false)) {
                    win.mExiting = true;
                }
 
                if (mAccessibilityController != null
                        && win.getDisplayId() == Display.DEFAULT_DISPLAY) {
                    mAccessibilityController.onWindowTransitionLocked(win, transit);
                }
            }
            final AppWindowToken appToken = win.mAppToken;
            final boolean isAnimating = win.mWinAnimator.isAnimating();
            final boolean lastWinStartingNotAnimating = startingWindow && appToken!= null
                    && appToken.allAppWindows.size() == 1 && !isAnimating;
            if (!lastWinStartingNotAnimating && (win.mExiting || isAnimating)) {
                // The exit animation is running... wait for it!
                win.mExiting = true;
                win.mRemoveOnExit = true;
                final DisplayContent displayContent = win.getDisplayContent();
                if (displayContent != null) {
                    displayContent.layoutNeeded = true;
                }
                final boolean focusChanged = updateFocusedWindowLocked(
                        UPDATE_FOCUS_WILL_PLACE_SURFACES, false /*updateInputWindows*/);
                performLayoutAndPlaceSurfacesLocked();
                if (appToken != null) {
                    appToken.updateReportedVisibilityLocked();
                }
                if (focusChanged) {
                    mInputMonitor.updateInputWindowsLw(false /*force*/);
                }
                Binder.restoreCallingIdentity(origId);
                return;
            }
        }
 
        removeWindowInnerLocked(win);
        ......
        updateFocusedWindowLocked(UPDATE_FOCUS_NORMAL, true /*updateInputWindows*/);
        ......
    }

WindowManagerService類的成員函數removeWindowLocked在刪除參數win所描述的一個窗口之前，首先檢查是否需要對該窗口設置一個退出動畫。只要滿足以下四個條件，那麼就需要對參數win所描述的一個窗口設置退出動畫：

        1. 參數win所描述的一個窗口具有繪圖表面，即它的成員變量mSurface的值不等於null；

        2. 系統屏幕當前沒有被凍結，即WindowManagerService類的成員變量mDisplayFrozen的值等於false；

        3. 系統屏幕當前是點亮的，即WindowManagerService類的成員變量mPolicy所指向的一個PhoneWindowManager對象的成員函數isScreenOn的返回值爲true；

        4. 參數win所描述的一個窗口當前是可見的，即它的成員函數isWinVisibleLw的返回值等於true。

        對參數win所描述的一個窗口設置退出動畫是通過調用WindowManagerService類的成員函數applyAnimationLocked來實現的。注意，如果參數win描述的是一個啓動窗口，那麼退出動畫的類型就爲WindowManagerPolicy.TRANSIT_PREVIEW_DONE，否則的話，退出動畫的類型就爲WindowManagerPolicy.TRANSIT_EXIT。

        一旦參數win所描述的一個窗口正處於退出動畫或者其它動畫狀態，即它的成員變量mExiting的值等於true或者成員函數isAnimating的返回值等於true，那麼WindowManagerService服務就要等它的動畫顯示完成之後，再刪除它，這是通過將它的成員變量mExiting和mRemoveOnExit的值設置爲true來完成的。由於這時候還需要顯示參數win所描述的一個窗口的退出動畫或者其它動畫，因此，WindowManagerService類的成員函數removeWindowLocked在返回之前，還需要執行以下操作：

        1. 調用WindowManagerService類的成員函數updateFocusedWindowLocked來重新計算系統當前需要獲得焦點的窗口；

        2. 調用WindowManagerService類的成員函數performLayoutAndPlaceSurfacesLocked來重新佈局和刷新系統的UI；

        3. 如果參數win所描述的一個與Activity組件相關的窗口，即它的成員變量mAppToken的值不等於null，那麼就會調用這個成員變量所指向的一個AppWindowToken對象的成員函數updateReportedVisibilityLocked來向ActivityManagerService服務報告該Activity組件的可見性。

        如果不需要對參數win所描述的一個窗口設置退出動畫，那麼WindowManagerService類的成員函數removeWindowLocked就會直接調用成員函數removeWindowInnerLocked來刪除該窗口，並且在刪除了該窗口之後，調用成員函數updateFocusedWindowLocked來重新計算系統當前需要獲得焦點的窗口以及重新佈局和刷新系統的UI。

        接下來，我們就繼續分析WindowManagerService類的成員函數removeWindowLocked的實現，以便可以瞭解Activity組件的啓動窗口的結束過程。

最後我們來看下WMS的removeWindowInnerLocked函數

    void removeWindowInnerLocked(WindowState win, boolean performLayout) {
        if (win.mRemoved) {
            // Nothing to do.
            return;
        }
 
        for (int i=win.mChildWindows.size()-1; i>=0; i--) {//處理子窗口
            WindowState cwin = win.mChildWindows.get(i);
            Slog.w(TAG, "Force-removing child win " + cwin + " from container "
                    + win);
            removeWindowInnerLocked(cwin);
        }
 
        win.mRemoved = true;//設置變量
 
        if (mInputMethodTarget == win) {
            moveInputMethodWindowsIfNeededLocked(false);
        }
 
        if (false) {
            RuntimeException e = new RuntimeException("here");
            e.fillInStackTrace();
            Slog.w(TAG, "Removing window " + win, e);
        }
 
        mPolicy.removeWindowLw(win);
        win.removeLocked();
 
        mWindowMap.remove(win.mClient.asBinder());
        if (win.mAppOp != AppOpsManager.OP_NONE) {
            mAppOps.finishOp(win.mAppOp, win.getOwningUid(), win.getOwningPackage());
        }
 
        mPendingRemove.remove(win);
        mResizingWindows.remove(win);
        mWindowsChanged = true;
        if (DEBUG_WINDOW_MOVEMENT) Slog.v(TAG, "Final remove of window: " + win);
 
        if (mInputMethodWindow == win) {
            mInputMethodWindow = null;
        } else if (win.mAttrs.type == TYPE_INPUT_METHOD_DIALOG) {
            mInputMethodDialogs.remove(win);
        }
 
        final WindowToken token = win.mToken;
        final AppWindowToken atoken = win.mAppToken;
        if (DEBUG_ADD_REMOVE) Slog.v(TAG, "Removing " + win + " from " + token);
        token.windows.remove(win);
        if (atoken != null) {
            atoken.allAppWindows.remove(win);
        }
        if (localLOGV) Slog.v(
                TAG, "**** Removing window " + win + ": count="
                + token.windows.size());
        if (token.windows.size() == 0) {
            if (!token.explicit) {
                mTokenMap.remove(token.token);
            } else if (atoken != null) {
                atoken.firstWindowDrawn = false;
            }
        }
 
        if (atoken != null) {
            if (atoken.startingWindow == win) {
                if (DEBUG_STARTING_WINDOW) Slog.v(TAG, "Notify removed startingWindow " + win);
                scheduleRemoveStartingWindowLocked(atoken);
            } else
            if (atoken.allAppWindows.size() == 0 && atoken.startingData != null) {
                // If this is the last window and we had requested a starting
                // transition window, well there is no point now.
                if (DEBUG_STARTING_WINDOW) Slog.v(TAG, "Nulling last startingWindow");
                atoken.startingData = null;
            } else if (atoken.allAppWindows.size() == 1 && atoken.startingView != null) {
                // If this is the last window except for a starting transition
                // window, we need to get rid of the starting transition.
                scheduleRemoveStartingWindowLocked(atoken);
            }
        }
 
        if (win.mAttrs.type == TYPE_WALLPAPER) {
            mLastWallpaperTimeoutTime = 0;
            getDefaultDisplayContentLocked().pendingLayoutChanges |=
                    WindowManagerPolicy.FINISH_LAYOUT_REDO_WALLPAPER;
        } else if ((win.mAttrs.flags&FLAG_SHOW_WALLPAPER) != 0) {
            getDefaultDisplayContentLocked().pendingLayoutChanges |=
                    WindowManagerPolicy.FINISH_LAYOUT_REDO_WALLPAPER;
        }
 
        final WindowList windows = win.getWindowList();
        if (windows != null) {
            windows.remove(win);
            if (!mInLayout) {
                assignLayersLocked(windows);
                final DisplayContent displayContent = win.getDisplayContent();
                if (displayContent != null) {
                    displayContent.layoutNeeded = true;
                }
                if (performLayout) {
                    performLayoutAndPlaceSurfacesLocked();
                }
                if (win.mAppToken != null) {
                    win.mAppToken.updateReportedVisibilityLocked();
                }
            }
        }
 
        mInputMonitor.updateInputWindowsLw(true /*force*/);
    }

由於參數win所描述的一個窗口馬上就要被刪除了，因此，WindowManagerService類的成員函數removeWindowLocked首先就將它的成員變量mRemoved的值設置爲true。此外，如果參數win所描述的窗口是系統輸入法的目標窗口，那麼還需要調用WindowManagerService類的成員函數moveInputMethodWindowsIfNeededLocked來重新移動動系統輸入法窗口到其它可能需要輸入法的窗口的上面去。

        執行完成以上兩個操作之後，WindowManagerService類的成員函數removeWindowLocked接下來就可以對參數win所描述的一個窗口進行清理了，包括：

        1. 調用WindowManagerService類的成員變量mPolicy的成員函數removeWindowLw來通知窗口管理策略類PhoneWindowManager，參數win所描述的一個窗口被刪除了；

        2. 調用參數win所指向的一個WindowState對象的成員函數removeLocked來執行自身的清理工作；

        3. 將參數win所指向的一個WindowState對象從WindowManagerService類的成員變量mWindowMap和mWindows中刪除，即將參數win所描述的一個窗口從窗口堆棧中刪除。

        執行完成以上三個清理工作之後，窗口堆棧就發生變化了，因此，就需要將WindowManagerService類的成員變量mWindowsChanged的值設置爲true。

        接下來，WindowManagerService類的成員函數removeWindowLocked還會檢查前面被刪除的窗口是否是一個輸入法窗口或者一個輸入法對話框。如果是一個輸入法窗口，那麼就會將WindowManagerService類的成員變量mInputMethodWindow的值設置爲true；如果是一個輸入法對話框，那麼就會它從WindowManagerService類的成員變量mInputMethodDialogs所描述的一個輸入法對話框列表中刪除。

        WindowManagerService類的成員函數removeWindowLocked的任務還沒有完成，它還需要繼續從參數win所描述的一個窗口從它的窗口令牌的窗口列表中刪除。參數win所描述的一個窗口的窗口令牌保存在它的成員變量mToken中，這個成員變量指向的是一個WindowToken對象。這個WindowToken對象有一個成員變量windows，它指向的是一個ArrayList中。這個ArrayList即爲參數win所描述的一個窗口從它的窗口令牌的窗口列表，因此，將參數win所描述的一個窗口從這個窗口列表中刪除即可。

        如果參數win描述的一個是與Activity組件有關的窗口，那麼它的成員變量mAppToken就會指向一個AppWindowToken對象。這個AppWindowToken對象的成員變量allAppWindows所指向的一個ArrayList也會保存有參數win所描述的窗口。因此，這時候也需要將參數win所描述的一個窗口從這個ArrayList中刪除。

        參數win所描述的一個窗口被刪除了以後，與它所對應的窗口令牌的窗口數量就會減少1。如果一個窗口令牌的窗口數量減少1之後變成0，那麼就需要考慮將這個窗口令牌從WindowManagerService服務的窗口令牌列表中刪除了，即從WindowManagerService類的成員變量mTokenMap和mTokenList中刪除，前提是這個窗口令牌不是顯式地被增加到WindowManagerService服務中去的，即用來描述這個窗口令牌的一個WindowToken對象的成員變量explicit的值等於false。

        另一方面，如果參數win描述的一個是與Activity組件有關的窗口，並且當它被刪除之後，與該Activity組件有關的窗口的數量變爲0，那麼就需要將用來描述該Activity組件的一個AppWindowToken對象的成員變量firstWindowDrawn的值設置爲false，以表示該Activity組件的第一個窗口還沒有被顯示出來，事實上也是表示目前沒有窗口與該Activity組件對應。

        當參數win描述的一個是與Activity組件有關的窗口的時候，WindowManagerService類的成員函數removeWindowLocked還需要檢查該Activity組件是否設置有啓動窗口。如果該Activity組件設置有啓動窗口的話，那麼就需要對它的相應成員變量進行清理。這些檢查以及清理工作包括：

        1. 如果參數win所描述的窗口即爲一個Activity組件的窗口，即它的值等於用來描述與它的宿主Activity組件的一個AppWindowToken對象的成員變量startingWindow的值，那麼就需要將AppWindowToken對象的成員變量startingWindow的值設置爲null，以便可以表示它所描述的Activity組件的啓動窗口已經結束了；

        2. 如果刪除了參數win所描述的窗口之後，它的宿主Activity組件的窗品數量爲0，但是該Activity組件又正在準備顯示啓動窗口，即用來描述該Activity組件的一個AppWindowToken對象的成員變量startingData的值不等於null，那麼就說明這個啓動窗口接下來也沒有必要顯示了，因此，就需要將該AppWindowToken對象的成員變量startingData的值設置爲null；

        3. 如果刪除了參數win所描述的窗口之後，它的宿主Activity組件的窗品數量爲1，並且用來描述該Activity組件的一個AppWindowToken對象的成員變量startingView的值不等於null，那麼就說明該Activity組件剩下的最後一個窗口即爲它的啓動窗口，這時候就需要請求WindowManagerService服務結束掉這個啓動窗口，因爲已經沒有必要顯示了。

        當一個Activity組件剩下的窗口只有一個，並且用來描述該Activity組件的一個AppWindowToken對象的成員變量startingView的值不等於null時，我們是如何知道這個剩下的窗口就是該Activity組件的啓動窗口的呢？從前面第一個部分的內容可以知道，當一個Activity組件的啓動窗口被創建出來之後，它的頂層視圖就會保存在用來描述該Activity組件的一個AppWindowToken對象的成員變量startingView中。因此，如果Activity組件滿足上述兩個條件，我們就可以判斷出它所剩下的一個窗口即爲它的啓動窗口。注意，在這種情況下，WindowManagerService類的成員函數removeWindowLocked不是馬上刪除這個啓動窗口的，而是通過向WindowManagerService服務所運行在的線程發送一個類型爲REMOVE_STARTING的消息，等到該消息被處理時再來刪除這個啓動窗口。

        清理了窗口win的宿主Activity組件的啓動窗口相關的數據之後，WindowManagerService類的成員函數removeWindowLocked又繼續檢查窗口win是否是一個壁紙窗口或者一個顯示壁紙的窗口。如果是的話，那麼就需要調用WindowManagerService類的成員函數adjustWallpaperWindowsLocked來重新調整系統中的壁紙窗口在窗口堆棧中的位置，即將它們移動到下一個可能需要顯示壁紙窗口的其它窗口的下面去。

        WindowManagerService類的成員函數removeWindowLocked的最後一個任務是檢查WindowManagerService服務當前是否正處於重新佈局窗口的狀態，即判斷WindowManagerService類的成員變量mInLayout的值是否等於true。如果不等於true的話，那麼就需要調用WindowManagerService類的成員函數performLayoutAndPlaceSurfacesLocked來重新佈局窗口，實際上就是刷新系統的UI。

        注意，WindowManagerService類的成員函數removeWindowLocked在重新佈局系統中的窗口之前，還需要調用另外一個成員函數assignLayersLocked來重新計算系統中的所有窗口的Z軸位置了。此外，WindowManagerService類的成員函數removeWindowLocked在重新佈局了系統中的窗口之後，如果發現前面被刪除的窗口win是一個與Activity組件相關的窗口，即它的成員變量mAppToken的值不等於null，那麼還會調用這個成員變量所指向的一個AppWindowToken對象的成員函數updateReportedVisibilityLocked來向ActivityManagerService服務報告該Activity組件的可見性。

        這一步執行完成之後，一個的Activity組件的啓動窗口結束掉了。至此，我們就分析完成Activity組件的啓動窗口的啓動過程和結束過程了。