從源碼看Activity的生命週期

一、寫在前面

前面寫了《從源碼看Application的啓動流程》，接下來該看看Activity的生命週期了。ActivityManagerService在attachApplicationLocked()方法裏面調用thread.bindApplication()啓動Application之後，會繼續往下走，繼續啓動Activity。

二、大致流程

三、源碼分析(基於API28)

• 注：說明基本上都寫在代碼註釋裏面了。

先看ActivityManagerService的attachApplicationLocked()方法裏面，通知ActivityThread創建並啓動了Application，接下來也該創建Activity了。

1. AMS進程

// 類：ActivityManagerService
private final boolean attachApplicationLocked(IApplicationThread thread,
        int pid, int callingUid, long startSeq) {
    // ...
    // 通知ActivityThread創建並啓動Application
    // Application的啓動不在此文討論，跳過。
    thread.bindApplication(...);
	// ...
    // normalMode就是是否有Activity正在等待着運行
    // 此文討論的是從桌面點擊圖標啓動應用，就是需要啓動Activity。
    if (normalMode) {
        try {
            if (mStackSupervisor.attachApplicationLocked(app)) {...}
        }
    }
	// ...
}

// 類：ActivityStackSupervisor
// Supervisor是管理者的意思，我們用的比較多的單詞是Manager，意思應該是差不多，就是Activity堆棧的管理。
boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {
	// ...
	// ActivityRecord主要是保存Activity的運行狀態信息，有了ActivityRecord才能啓動Activity
    final ActivityRecord top = stack.topRunningActivityLocked();
    // ...
    // 啓動Activity
    if (realStartActivityLocked(...)
    // ...
}

// 類：ActivityStackSupervisor
final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
        boolean andResume, boolean checkConfig) throws RemoteException {
	// ...
    // 創建Activity的啓動事務。
    // 把Activity的啓動和生命週期等信息放到一個事務裏面，然後把事務丟給應用進程ActivityThread去自己玩耍。
    final ClientTransaction clientTransaction = ClientTransaction.obtain(app.thread, r.appToken);
    // 添加callback，其實就是添加一個ClientTransactionItem，這裏item就是callback吧，有點彆扭。
    // ActivityThread拿到ClientTransaction去執行的時候，會把這些item也全部執行一遍。
    // 這裏添加的是LaunchActivityItem，繼承於ClientTransactionItem。
    clientTransaction.addCallback(LaunchActivityItem.obtain(...));

    // 設置Activity啓動之後的最終狀態。
    final ActivityLifecycleItem lifecycleItem;
    if (andResume) {
    	// 本文討論的是從桌面點擊打開應用的情況，最終狀態也就是onResume了，自然對應ResumeActivityItem。
        lifecycleItem = ResumeActivityItem.obtain(mService.isNextTransitionForward());
    } else {
        lifecycleItem = PauseActivityItem.obtain();
    }
    // 把ResumeActivityItem設置進去事務裏面，後面應用進程會拿出來處理的。
    clientTransaction.setLifecycleStateRequest(lifecycleItem);

    // 通知應用經常執行事務
    // mService是ActivityManagerService
    // getLifecycleManager()返回是ClientLifecycleManager
    mService.getLifecycleManager().scheduleTransaction(clientTransaction);
	// ...
}

// 類：ClientLifecycleManager
void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
    // ...
    transaction.schedule();
    // ...
}

// 類：ClientTransaction
public void schedule() throws RemoteException {
	// 這裏的mClient就是IApplicationThread，也就是回到應用進程了。
    mClient.scheduleTransaction(this);
}

2. 應用進程

以下回到應用進程自己玩耍了：

// 類：ActivityThread.ApplicationThread
// 這是IApplicationThread的代理類，應用進程和AMS之間就是通過這個類通訊的。
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
    ActivityThread.this.scheduleTransaction(transaction);
}

// 類：ClientTransactionHandler
// 這是ActivityThread的父類，事務的handler
// 前面AMS創建了用於啓動Activity的事務，通過IApplicationThread丟給了應用進程，最終會交給這個類去執行事務
void scheduleTransaction(ClientTransaction transaction) {
    // ...
    // 丟給主線程去執行
    sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}

// 類：ActivityThread.H
public void handleMessage(Message msg) {
        switch (msg.what) {
            case EXECUTE_TRANSACTION:
            	// 類似於把任務丟給線程池去執行吧，這裏把ClientTransaction丟給TransactionExecutor去執行。
                final ClientTransaction transaction = (ClientTransaction) msg.obj;
                mTransactionExecutor.execute(transaction);
                // ...
                break;
        }
    }
}

// 類：TransactionExecutor
public void execute(ClientTransaction transaction) {
    // ...
	// 執行callback列表，就是剛纔在AMS添加的LaunchActivityItem。
    executeCallbacks(transaction);
	// 執行生命週期
    executeLifecycleState(transaction);
    // ...
}

這裏有兩個主要的方法，onCreate()方法是在executeCallbacks()裏面的，onStart()和onResume()則在executeLifecycleState()裏面。這裏先看executeCallbacks()。

分支1：executeCallbacks(transaction)

// 類：TransactionExecutor
public void executeCallbacks(ClientTransaction transaction) {
	// 拿到item列表，其實也就是隻有一個，前面在AMS只添加了一個。
    final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
	// ...
    final int size = callbacks.size();
    for (int i = 0; i < size; ++i) {
    	// 這個item就是前面AMS添加的LaunchActivityItem
        final ClientTransactionItem item = callbacks.get(i);
        // ...
        item.execute(mTransactionHandler, token, mPendingActions);
		// ...
    }
}

// 類：LaunchActivityItem
public void execute(ClientTransactionHandler client, IBinder token, PendingTransactionActions pendingActions) {
    // ...
    // ClientTransactionHandler是ActivityThread的父類，執行事務的handler。
    // handleLaunchActivity是個虛擬方法，具體實現在ActivityThread類裏面。
    client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
    // ...
}

// 類：ActivityThread
public Activity handleLaunchActivity(ActivityClientRecord r,
        PendingTransactionActions pendingActions, Intent customIntent) {
    // ...
	// 熟悉的perform
    final Activity a = performLaunchActivity(r, customIntent);
	// ...
}

// 類：ActivityThread
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
	// ...
	// 通過反射創建Activity，和創建Application一樣一樣的。
    ContextImpl appContext = createBaseContextForActivity(r);
    Activity activity = null;
    try {
        java.lang.ClassLoader cl = appContext.getClassLoader();
        activity = mInstrumentation.newActivity(
                cl, component.getClassName(), r.intent);
    }
    // ...
    // 調用onCreate方法。
	mInstrumentation.callActivityOnCreate(activity, r.state);
	// ...
	// 上面調用完onCreate方法之後，把狀態設置爲ON_CREATE。
    r.setState(ON_CREATE);
	// ...
}

// 類：Instrumentation
public void callActivityOnCreate(Activity activity, Bundle icicle) {
    // ...
    // 熟悉的perform
    activity.performCreate(icicle);
    // ...
}

// 類：Activity 
final void performCreate(Bundle icicle, PersistableBundle persistentState) {
    // ...
    // onCreate方法就在這裏調用啦啦啦
    onCreate(icicle);
    // ...
}

分支2：executeLifecycleState(transaction)

分析完onCreate()之後，接着上面的上面繼續看onStart()和onResume()，也就是executeLifecycleState()方法。

// 類：TransactionExecutor
private void executeLifecycleState(ClientTransaction transaction) {
	// ...
	// 前面AMS裏面把ResumeActivityItem設置到事務裏面了，意思是最終狀態是resume，現在拿出來處理。
	// 所以這個lifecycleItem就是ResumeActivityItem。
	// 前面的代碼：clientTransaction.setLifecycleStateRequest(lifecycleItem);
    final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
	// ...
	// 先循環判斷一下這個開始狀態和最終狀態之間有沒有其它狀態，有的話處理一下。
	// 這裏我們知道我們的開始狀態是onCreate，最終狀態是onResume，這中間還有一個onStart等着回調呢。
	// 注意第二個參數叫finish，傳入的是ON_RESUME，也就是最有一個狀態是ON_RESUME。
	// 注意第三個參數叫excludeLastState，意思是是否排除最後一個狀態，傳入了true，也就是排除了ON_RESUME。
    cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */);
	// 上面排除了ON_RESUME狀態，所以最終在這裏執行了。
    lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
    // ...
}

這裏又有分支了，onStart()在cycleToPath()裏面，onResume在lifecycleItem.execute()裏面。我們先看cycleToPath()，後面再看lifecycleItem.execute()。

分支2-1：cycleToPath()

// 類：TransactionExecutor
private void cycleToPath(ActivityClientRecord r, int finish,
        boolean excludeLastState) {
    // ActivityClientRecord保存這Activity的狀態信息，之前已經設置爲了ON_CREATE了還記得麼麼麼
    // 所以start就是ON_CREATE
    final int start = r.getLifecycleState();
    // 拿到start和finish之間的狀態列表
    final IntArray path = mHelper.getLifecyclePath(start, finish, excludeLastState);
    // 執行start和finish之間的狀態列表
    performLifecycleSequence(r, path);
}

// 類：TransactionExecutorHelper
// 由前面可以知道start是ON_CREATE，finish是ON_RESUME
public static final int ON_CREATE = 1;
public static final int ON_START = 2;
public static final int ON_RESUME = 3;
public IntArray getLifecyclePath(int start, int finish, boolean excludeLastState) {
    // ...
    mLifecycleSequence.clear();
    if (finish >= start) {
        // 我們的start=1，finish=3，所以這個列表添加了兩個狀態，ON_START和ON_RESUME
        for (int i = start + 1; i <= finish; i++) {
            mLifecycleSequence.add(i);
        }
    }
    // ...
	// excludeLastState傳入的是true，所以去掉最後一個，剩下的就只有ON_START了。
    if (excludeLastState && mLifecycleSequence.size() != 0) {
        mLifecycleSequence.remove(mLifecycleSequence.size() - 1);
    }
    return mLifecycleSequence;
}

// 類：TransactionExecutor
// 前面計算出了要執行的狀態列表，這裏就去執行吧。
private void performLifecycleSequence(ActivityClientRecord r, IntArray path) {
    final int size = path.size();
    for (int i = 0, state; i < size; i++) {
        state = path.get(i);
        switch (state) {
            case ON_START:
            	// mTransactionHandler和前面一樣，是ActivityThread的父類
            	// handleStartActivity()的具體實現在ActivityThread類中
                mTransactionHandler.handleStartActivity(r, mPendingActions);
                break;
            // ...
        }
    }
}

// 類：ActivityThread
public void handleStartActivity(ActivityClientRecord r,
        PendingTransactionActions pendingActions) {
    final Activity activity = r.activity;
	// ...
    activity.performStart("handleStartActivity");
    // 設置當前狀態爲ON_START
    r.setState(ON_START);
	// ...
}

// 類：Activity
final void performStart(String reason) {
    // ...
    mInstrumentation.callActivityOnStart(this);
    // ...
}

// 類：Instrumentation
public void callActivityOnStart(Activity activity) {
	// 又走完一個生命週期
    activity.onStart();
}

分支2-2：lifecycleItem.execute()

回調完了開始狀態和最終狀態之間的狀態(也就是onStart)之後，也該回調最終狀態onResume了，也就是前面留下來的lifecycleItem.execute(mTransactionHandler, token, mPendingActions);，lifecycleItem就是ResumeActivityItem。

// 類：ResumeActivityItem
public void execute(ClientTransactionHandler client, IBinder token, PendingTransactionActions pendingActions) {
	// 同樣的配方，還是回到ActivityThread裏面去
    client.handleResumeActivity(token, true /* finalStateRequest */, mIsForward, "RESUME_ACTIVITY");
}

// 類：ActivityThread
public void handleResumeActivity(IBinder token, boolean finalStateRequest, boolean isForward, String reason) {
    // ...
    final ActivityClientRecord r = performResumeActivity(token, finalStateRequest, reason);
    // ...
}

// 類：ActivityThread
public ActivityClientRecord performResumeActivity(IBinder token, boolean finalStateRequest, String reason) {
    final ActivityClientRecord r = mActivities.get(token);
    // ...
    try {
        // ...
        r.activity.performResume(r.startsNotResumed, reason);
		// ...
		// 設置當前狀態爲ON_RESUME
        r.setState(ON_RESUME);
    }
    // ...
}

// 類：Activity
final void performResume(boolean followedByPause, String reason) {
    // ...
    mInstrumentation.callActivityOnResume(this);
    // ...
}

// 類：Instrumentation
public void callActivityOnResume(Activity activity) {
	// 這裏設了個mResumed變量，但是我們調用不到哈哈哈
	// 我們應該用lifecycle.currentState.isAtLeast(xxx)來判斷生命週期。
    activity.mResumed = true;
    // 至此，Activity的onCreate、onStart和onResume都回調完了
    activity.onResume();
	// ...
}

四、寫在最後

上次畫時序圖畫得很爽，但是現在看來好像沒多大的用處，就不畫詳細的時序圖了，畫個大概的流程就行了。
以上都是通過其它人的博客、視頻教程等等途徑去學習，然後加入自己粗糙的理解，不免有錯，具體還要靠自己的去分析。
源碼太多了，不可能每一行都去讀懂它的意思，只能有針對性的去找你想要看的那部分代碼，大致瞭解清楚整個主流程就可以了。然後多看幾遍，多捋幾遍，慢慢的就越來越熟悉了，等熟悉之後再一個點一個點的細看，不出一百年，必懂，還搞不懂你儘管從棺材了爬出來找我。