#### 1.1.1 典型情況下的生命周期分析 在正常情況下，Activity會經歷如下生命周期。 * （1）onCreate：表示**Activity正在被創建**，這是生命周期的第一個方法。在這個方法中，我們可以做一些**初始化工作**，比如調用setContentView去加載界面布局資源、初始化Activity所需數據等。 * （2）onRestart：表示Activity正在重新啟動。**一般情況下，當當前Activity從不可見重新變為可見狀態時，onRestart就會被調用**。這種情形一般是用戶行為所導致的，比如用戶按Home鍵切換到桌面或者用戶打開了一個新的Activity，這時當前的Activity就會暫停，也就是onPause和onStop被執行了，接著用戶又回到了這個Activity，就會出現這種情況。 * （3）onStart：表示Activity正在被啟動，即將開始，這時**Activity已經可見了，但是還沒有出現在前臺，還無法和用戶交互**。這個時候其實可以理解**為Activity已經顯示出來了，但是我們還看不到**。 * **可見，但是不可交互，可見，但只是沒有出現在前臺，比如Activity中彈出了一個對話框，導致Activity可見但是位于后臺無法和用戶直接交互**。 * （4）onResume：表示Activity已經**可見**了，并**且出現在前臺并開始活動**。要注意這個和onStart的對比，onStart和onResume都表示Activity已經可見，但是**onStart的時候Activity還在后臺，onResume的時候Activity才顯示到前臺**。 * （5）onPause：表示Activity正在停止，正常情況下，緊接著onStop就會被調用。**在特殊情況下，如果這個時候快速地再回到當前Activity，那么onResume會被調用。筆者的理解是，這種情況屬于極端情況，用戶操作很難重現這一場景**。此時可以做一些**存儲數據、停止動畫等工作，但是注意不能太耗時，因為這會影響到新Activity的顯示，onPause必須先執行完，新Activity的onResume才會執行**。 * **可見，但不可交互，不在前臺** * （6）onStop：表示Activity即將停止，可以**做一些稍微重量級的回收工作，同樣不能太耗時**。 * （7）onDestroy：表示Activity即將被銷毀，這是Activity生命周期中的最后一個回調，在這里，我們可以**做一些回收工作和最終的資源釋放**。 正常情況下，Activity的常用生命周期就只有上面7個，圖1-1更詳細地描述了Activity各種生命周期的切換過程。 :-:  圖1-1 Activity生命周期的切換過程 針對圖1-1，這里再附加一下具體說明，分如下幾種情況。 * （1）針對一個特定的Activity，第一次啟動，回調如下：onCreate -> onStart -> onResume。 * （2）當用戶打開新的Activity或者切換到桌面的時候，回調如下：onPause -> onStop。這里有一種特殊情況，如果新Activity采用了透明主題（仍然可見），那么當前Activity不會回調onStop。 * （3）當用戶再次回到原Activity時，回調如下：onRestart -> onStart -> onResume。 * （4）當用戶按back鍵回退時，回調如下：onPause -> onStop -> onDestroy。 * （5）**當Activity被系統回收后再次打開，生命周期方法回調過程和（1）一樣，注意只是生命周期方法一樣，不代表所有過程都一樣**，這個問題在下一節會詳細說明。 * （6）從整個生命周期來說，**onCreate和onDestroy是配對的**，分別標識著Activity的創建和銷毀，并**且只可能有一次調用**。從**Activity是否可見**來說，**onStart和onStop是配對的**，隨著用戶的操作或者設備屏幕的點亮和熄滅，**這兩個方法可能被調用多次**；從**Activity是否在前臺**來說，**onResume和onPause是配對的**，隨著用戶操作或者設備屏幕的點亮和熄滅，這兩個方法**可能被調用多次**。 這里提出2個問題，不知道大家是否清楚。 * 問題1:onStart和onResume、onPause和onStop從描述上來看差不多，對我們來說有什么實質的不同呢？ * 問題2：假設當前Activity為A，如果這時用戶打開一個新Activity B，那么B的onResume和A的onPause哪個先執行呢？ * onPause(A)——>onCreate(B) ——> onStart(B) ——> onResume(B)——> onStop(A) 先說第一個問題，從實際使用過程來說，onStart和onResume、onPause和onStop看起來的確差不多，甚至我們可以只保留其中一對，比如只保留onStart和onStop。既然如此，那為什么Android系統還要提供看起來重復的接口呢？根據上面的分析，我們知道，這兩個配對的回調分別表示不同的意義，**onStart和onStop是從Activity是否可見這個角度來回調的，而onResume和onPause是從Activity是否位于前臺這個角度來回調的**，除了這種區別，在實際使用中沒有其他明顯區別。 第二個問題可以從Android源碼里得到解釋。關于Activity的工作原理在本書后續章節會進行介紹，這里我們先大概了解即可。從Activity的啟動過程來看，我們來看一下系統源碼。**Activity的啟動過程的源碼相當復雜**，涉及Instrumentation、ActivityThread和ActivityManagerServic（e下面簡稱AMS）。這里不詳細分析這一過程，**簡單理解，啟動Activity的請求會由Instrumentation來處理，然后它通過Binder向AMS發請求，AMS內部維護著一個ActivityStack并負責棧內的Activity的狀態同步，AMS通過ActivityThread去同步Activity的狀態從而完成生命周期方法的調用**。在ActivityStack中的resumeTopActivity-InnerLocked方法中，有這么一段代碼： ``` // We need to start pausing the current activity so the top one // can be resumed... boolean dontWaitForPause = (next.info.flags&ActivityInfo.FLAG_RESUME_ WHILE_PAUSING) ! = 0; boolean pausing = mStackSupervisor.pauseBackStacks(userLeaving, true, dontWaitForPause); if (mResumedActivity ! = null) { pausing |= startPausingLocked(userLeaving, false, true, dontWait- ForPause); if (DEBUG_STATES) Slog.d(TAG, "resumeTopActivityLocked: Pausing " + mResumedActivity); } ``` 從上述代碼可以看出，**在新Activity啟動之前，桟頂的Activity需要先onPause后，新Activity才能啟動**。最終，在ActivityStackSupervisor中的realStartActivityLocked方法會調用如下代碼。 ``` app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken, System.identityHashCode(r), r.info, new Configuration(mService. mConfiguration), r.compat, r.task.voiceInteractor, app.repProcState, r.icicle, r.persistentState, results, newIntents, ! andResume, mService.isNextTransition- Forward(), profilerInfo); ``` 我們知道，這個app.thread的類型是IApplicationThread，而IApplicationThread的具體實現是ActivityThread中的ApplicationThread。所以，這段代碼實際上調到了ActivityThread的中，即ApplicationThread的scheduleLaunchActivity方法，而scheduleLaunchActivity方法最終會完成新Activity的onCreate、onStart、onResume的調用過程。因此，可以得出結論，是**舊Activity先onPause，然后新Activity再啟動**。 至于ApplicationThread的scheduleLaunchActivity方法為什么會完成新Activity的onCreate、onStart、onResume的調用過程，請看下面的代碼。scheduleLaunchActivity最終會調用如下方法，而如下方法的確會完成onCreate、onStart、onResume的調用過程。 源碼：[ActivityThread](https://www.androidos.net.cn/android/7.1.1_r28/xref/frameworks/base/core/java/android/app/ActivityThread.java)# handleLaunchActivity ``` private void handleLaunchActivity(ActivityClientRecord r, Intent custom- Intent) { // If we are getting ready to gc after going to the background, well // we are back active so skip it. unscheduleGcIdler(); mSomeActivitiesChanged = true; if (r.profilerInfo ! = null) { mProfiler.setProfiler(r.profilerInfo); mProfiler.startProfiling(); } // Make sure we are running with the most recent config. handleConfigurationChanged(null, null); if (localLOGV) Slog.v( TAG, "Handling launch of " + r); //這里新Activity被創建出來，其onCreate和onStart會被調用 Activity a = performLaunchActivity(r, customIntent); if (a ! = null) { r.createdConfig = new Configuration(mConfiguration); Bundle oldState = r.state; //這里新Activity的onResume會被調用 handleResumeActivity(r.token, false, r.isForward, !r.activity.mFinished && ! r.startsNotResumed); //省略 } ``` 從上面的分析可以看出，當**新啟動一個Activity的時候，舊Activity的onPause會先執行，然后才會啟動新的Activity。到底是不是這樣呢**？我們寫個例子驗證一下，如下是2個Activity的代碼，在MainActivity中單擊按鈕可以跳轉到SecondActivity，同時為了分析我們的問題，在生命周期方法中打印出了日志，通過日志我們就能看出它們的調用順序。 代碼：MainActivity.java ``` public class MainActivity extends Activity { private static final String TAG = "MainActivity"; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); if (savedInstanceState != null) { String test = savedInstanceState.getString("extra_test"); Log.d(TAG, "[onCreate]restore extra_test:" + test); } findViewById(R.id.button1).setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { Intent intent = new Intent("com.ryg.charpter_1.c"); //intent.setClass(MainActivity.this, SecondActivity.class); intent.putExtra("time", System.currentTimeMillis()); intent.addCategory("com.ryg.category.c"); intent.setDataAndType(Uri.parse("file://abc"), "text/plain"); startActivity(intent); } }); } @Override protected void onNewIntent(Intent intent) { super.onNewIntent(intent); Log.d(TAG, "onNewIntent, time=" + intent.getLongExtra("time", 0)); } @Override protected void onStart() { Log.d(TAG, "onStart"); super.onStart(); } @Override protected void onResume() { Log.d(TAG, "onResume"); super.onStart(); } @Override public void onConfigurationChanged(Configuration newConfig) { super.onConfigurationChanged(newConfig); Log.d(TAG, "onConfigurationChanged, newOrientation:" + newConfig.orientation); } @Override protected void onSaveInstanceState(Bundle outState) { super.onSaveInstanceState(outState); Log.d(TAG, "onSaveInstanceState"); outState.putString("extra_test", "test"); } @Override protected void onRestoreInstanceState(Bundle savedInstanceState) { super.onRestoreInstanceState(savedInstanceState); //Log.d(TAG, "onRestoreInstanceState"); String test = savedInstanceState.getString("extra_test"); Log.d(TAG, "[onRestoreInstanceState]restore extra_test:" + test); } @Override protected void onPause() { Log.d(TAG, "onPause"); super.onPause(); } @Override protected void onStop() { Log.d(TAG, "onStop"); super.onStop(); } @Override protected void onDestroy() { Log.d(TAG, "onDestroy"); super.onDestroy(); } } ``` 代碼：SecondActivity.java ``` public class SecondActivity extends Activity { private static final String TAG = "SecondActivity"; @Override protected void onCreate(Bundle savedInstanceState) { // TODO Auto-generated method stub super.onCreate(savedInstanceState); setContentView(R.layout.activity_second); findViewById(R.id.button1).setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { Intent intent = new Intent(); intent.setClass(SecondActivity.this, ThirdActivity.class); intent.putExtra("time", System.currentTimeMillis()); startActivity(intent); } }); Log.d(TAG, "onCreate"); } @Override protected void onStart() { // TODO Auto-generated method stub super.onStart(); Log.d(TAG, "onStart"); } @Override protected void onResume() { // TODO Auto-generated method stub super.onResume(); Log.d(TAG, "onResume"); } @Override protected void onSaveInstanceState(Bundle outState) { super.onSaveInstanceState(outState); Log.d(TAG, "onSaveInstanceState"); } @Override protected void onRestoreInstanceState(Bundle savedInstanceState) { super.onRestoreInstanceState(savedInstanceState); Log.d(TAG, "onRestoreInstanceState"); } } ``` 我們來看一下log，是不是和我們上面分析的一樣，如圖1-2所示。 :-:  圖1-2 Activity生命周期方法的回調順序 通過圖1-2可以發現，舊Activity的onPause先調用，然后新Activity才啟動，這也證實了我們上面的分析過程。也許有人會問，你只是分析了Android5.0的源碼，你怎么知道所有版本的源碼都是相同邏輯呢？關于這個問題，我們的確不大可能把所有版本的源碼都分析一遍，但是作為Android運行過程的基本機制，隨著版本的更新并不會有大的調整，因為Android系統也需要兼容性，不能說在不同版本上同一個運行機制有著截然不同的表現。關于這一點我們需要把握一個度，就是對于Android運行的基本機制在不同Android版本上具有延續性。從另一個角度來說，**Android官方文檔對onPause的解釋有這么一句：不能在onPause中做重量級的操作，因為必須onPause執行完成以后新Activity才能Resume**，從這一點也能間接證明我們的結論。通過分析這個問題，我們知道**onPause和onStop都不能執行耗時的操作，尤其是onPause，這也意味著，我們應當盡量在onStop中做操作，從而使得新Activity盡快顯示出來并切換到前臺**。