基礎總結篇之一：Activity生命週期

子曰：溫故而知新，能夠為師矣。《論語》

學習技術也同樣，對於技術文檔或者經典的技術書籍來講，期望看一遍就徹底掌握，那基本不大可能，因此咱們須要常常回過頭再仔細研讀幾遍，以領悟到做者的思想精髓。

近來回顧了一下關於Activity的生命週期，參看了相關書籍和官方文檔，也有了不小的收穫，對於之前的認知有了很大程度上的改善，在這裏和你們分享一下。

熟悉javaEE的朋友們都瞭解servlet技術，咱們想要實現一個本身的servlet，須要繼承相應的基類，重寫它的方法，這些方法會在合適的時間被servlet容器調用。其實android中的Activity運行機制跟servlet有些類似之處，Android系統至關於servlet容器，Activity至關於一個servlet，咱們的Activity處在這個容器中，一切建立實例、初始化、銷燬實例等過程都是容器來調用的，這也就是所謂的「Don't call me, I'll call you.」機制。

咱們來看一下這一張經典的生命週期流程圖：

相信很多朋友也已經看過這個流程圖了，也基本瞭解了Activity生命週期的幾個過程，咱們就來講一說這幾個過程。

1.啓動Activity：系統會先調用onCreate方法，而後調用onStart方法，最後調用onResume，Activity進入運行狀態。

2.當前Activity被其餘Activity覆蓋其上或被鎖屏：系統會調用onPause方法，暫停當前Activity的執行。

3.當前Activity由被覆蓋狀態回到前臺或解鎖屏：系統會調用onResume方法，再次進入運行狀態。

4.當前Activity轉到新的Activity界面或按Home鍵回到主屏，自身退居後臺：系統會先調用onPause方法，而後調用onStop方法，進入停滯狀態。

5.用戶後退回到此Activity：系統會先調用onRestart方法，而後調用onStart方法，最後調用onResume方法，再次進入運行狀態。

6.當前Activity處於被覆蓋狀態或者後臺不可見狀態，即第2步和第4步，系統內存不足，殺死當前Activity，然後用戶退回當前Activity：再次調用onCreate方法、onStart方法、onResume方法，進入運行狀態。

7.用戶退出當前Activity：系統先調用onPause方法，而後調用onStop方法，最後調用onDestory方法，結束當前Activity。

可是知道這些還不夠，咱們必須親自試驗一下才能深入體會，融會貫通。

下面咱們就結合實例，來演示一下生命週期的幾個過程的詳細狀況。咱們新建一個名爲lifecycle的項目，建立一個名爲LifeCycleActivity的Activity，以下：

[java] view plaincopy

1. package com.scott.lifecycle;  

2.   

3. import android.app.Activity;  

4. import android.content.Context;  

5. import android.content.Intent;  

6. import android.os.Bundle;  

7. import android.util.Log;  

8. import android.view.View;  

9. import android.widget.Button;  

10.   

11. public class LifeCycleActivity extends Activity {  

12.       

13.     private static final String TAG = "LifeCycleActivity";  

14.     private Context context = this;  

15.     private int param = 1;  

16.       

17.     //Activity建立時被調用  

18.     @Override  

19.     public void onCreate(Bundle savedInstanceState) {  

20.         super.onCreate(savedInstanceState);  

21.         Log.i(TAG, "onCreate called.");  

22.           

23.         setContentView(R.layout.lifecycle);  

24.           

25.         Button btn = (Button) findViewById(R.id.btn);  

26.         btn.setOnClickListener(new View.OnClickListener() {  

27.             @Override  

28.             public void onClick(View v) {  

29.                 Intent intent = new Intent(context, TargetActivity.class);  

30.                 startActivity(intent);  

31.             }  

32.         });  

33.     }  

34.       

35.     //Activity建立或者從後臺從新回到前臺時被調用  

36.     @Override  

37.     protected void onStart() {  

38.         super.onStart();  

39.         Log.i(TAG, "onStart called.");  

40.     }  

41.       

42.     //Activity從後臺從新回到前臺時被調用  

43.     @Override  

44.     protected void onRestart() {  

45.         super.onRestart();  

46.         Log.i(TAG, "onRestart called.");  

47.     }  

48.       

49.     //Activity建立或者從被覆蓋、後臺從新回到前臺時被調用  

50.     @Override  

51.     protected void onResume() {  

52.         super.onResume();  

53.         Log.i(TAG, "onResume called.");  

54.     }  

55.       

56.     //Activity窗口得到或失去焦點時被調用,在onResume以後或onPause以後  

57.     /*@Override 

58.     public void onWindowFocusChanged(boolean hasFocus) { 

59.         super.onWindowFocusChanged(hasFocus); 

60.         Log.i(TAG, "onWindowFocusChanged called."); 

61.     }*/  

62.       

63.     //Activity被覆蓋到下面或者鎖屏時被調用  

64.     @Override  

65.     protected void onPause() {  

66.         super.onPause();  

67.         Log.i(TAG, "onPause called.");  

68.         //有可能在執行完onPause或onStop後,系統資源緊張將Activity殺死,因此有必要在此保存持久數據  

69.     }  

70.       

71.     //退出當前Activity或者跳轉到新Activity時被調用  

72.     @Override  

73.     protected void onStop() {  

74.         super.onStop();  

75.         Log.i(TAG, "onStop called.");     

76.     }  

77.       

78.     //退出當前Activity時被調用,調用以後Activity就結束了  

79.     @Override  

80.     protected void onDestroy() {  

81.         super.onDestroy();  

82.         Log.i(TAG, "onDestory called.");  

83.     }  

84.       

85.     /** 

86.      * Activity被系統殺死時被調用. 

87.      * 例如:屏幕方向改變時,Activity被銷燬再重建;當前Activity處於後臺,系統資源緊張將其殺死. 

88.      * 另外,當跳轉到其餘Activity或者按Home鍵回到主屏時該方法也會被調用,系統是爲了保存當前View組件的狀態. 

89.      * 在onPause以前被調用. 

90.      */  

91.     @Override  

92.     protected void onSaveInstanceState(Bundle outState) {  

93.         outState.putInt("param", param);  

94.         Log.i(TAG, "onSaveInstanceState called. put param: " + param);  

95.         super.onSaveInstanceState(outState);  

96.     }  

97.       

98.     /** 

99.      * Activity被系統殺死後再重建時被調用. 

100.      * 例如:屏幕方向改變時,Activity被銷燬再重建;當前Activity處於後臺,系統資源緊張將其殺死,用戶又啓動該Activity. 

101.      * 這兩種狀況下onRestoreInstanceState都會被調用,在onStart以後. 

102.      */  

103.     @Override  

104.     protected void onRestoreInstanceState(Bundle savedInstanceState) {  

105.         param = savedInstanceState.getInt("param");  

106.         Log.i(TAG, "onRestoreInstanceState called. get param: " + param);  

107.         super.onRestoreInstanceState(savedInstanceState);  

108.     }  

109. }  

你們注意到，除了幾個常見的方法外，咱們還添加了onWindowFocusChanged、onSaveInstanceState、onRestoreInstanceState方法：

1.onWindowFocusChanged方法：在Activity窗口得到或失去焦點時被調用，例如建立時首次呈如今用戶面前；當前Activity被其餘Activity覆蓋；當前Activity轉到其餘Activity或按Home鍵回到主屏，自身退居後臺；用戶退出當前Activity。以上幾種狀況都會調用onWindowFocusChanged，而且當Activity被建立時是在onResume以後被調用，當Activity被覆蓋或者退居後臺或者當前Activity退出時，它是在onPause以後被調用，如圖所示：

這個方法在某種場合下仍是頗有用的，例如程序啓動時想要獲取視特定視圖組件的尺寸大小，在onCreate中可能沒法取到，由於窗口Window對象還沒建立完成，這個時候咱們就須要在onWindowFocusChanged裏獲取；若是你們已經看過我寫的Android動畫之Frame Animation這篇文章就會知道，當時試圖在onCreate里加載frame動畫失敗的緣由就是由於窗口Window對象沒有初始化完成，因此最後我將加載動畫的代碼放到了onWindowFocusChanged中，問題迎刃而解。不過你們也許會有疑惑，爲何我在代碼裏將它註釋掉了，由於對當前Activity每個操做都有它的執行log，我擔憂這會影響到整個流程的清晰度，因此將它注掉，你們只要瞭解它應用的場合和執行的順序就能夠了。

2.onSaveInstanceState：(1)在Activity被覆蓋或退居後臺以後，系統資源不足將其殺死，此方法會被調用；(2)在用戶改變屏幕方向時，此方法會被調用；(3)在當前Activity跳轉到其餘Activity或者按Home鍵回到主屏，自身退居後臺時，此方法會被調用。第一種狀況咱們沒法保證何時發生，系統根據資源緊張程度去調度；第二種是屏幕翻轉方向時，系統先銷燬當前的Activity，而後再重建一個新的，調用此方法時，咱們能夠保存一些臨時數據；第三種狀況系統調用此方法是爲了保存當前窗口各個View組件的狀態。onSaveInstanceState的調用順序是在onPause以前。

3.onRestoreInstanceState：(1)在Activity被覆蓋或退居後臺以後，系統資源不足將其殺死，而後用戶又回到了此Activity，此方法會被調用；(2)在用戶改變屏幕方向時，重建的過程當中，此方法會被調用。咱們能夠重寫此方法，以即可以恢復一些臨時數據。onRestoreInstanceState的調用順序是在onStart以後。

以上着重介紹了三個相對陌生方法以後，下面咱們就來操做一下這個Activity，看看它的生命週期究竟是個什麼樣的過程：

1.啓動Activity：

在系統調用了onCreate和onStart以後，調用了onResume，自此，Activity進入了運行狀態。

2.跳轉到其餘Activity，或按下Home鍵回到主屏：

咱們看到，此時onSaveInstanceState方法在onPause以前被調用了，而且注意，退居後臺時，onPause後onStop相繼被調用。

3.從後臺回到前臺：

當從後臺會到前臺時，系統先調用onRestart方法，而後調用onStart方法，最後調用onResume方法，Activity又進入了運行狀態。

4.修改TargetActivity在AndroidManifest.xml中的配置，將android:theme屬性設置爲@android:style/Theme.Dialog，而後再點擊LifeCycleActivity中的按鈕，跳轉行爲就變爲了TargetActivity覆蓋到LifeCycleActivity之上了，此時調用的方法爲：

注意還有一種狀況就是，咱們點擊按鈕，只是按下鎖屏鍵，執行的效果也是如上。

咱們注意到，此時LifeCycleActivity的OnPause方法被調用，並無調用onStop方法，由於此時的LifeCycleActivity沒有退居後臺，只是被覆蓋或被鎖屏；onSaveInstanceState會在onPause以前被調用。

5.按回退鍵使LifeCycleActivity從被覆蓋回到前面，或者按解鎖鍵解鎖屏幕：

此時只有onResume方法被調用，直接再次進入運行狀態。

6.退出：

最後onDestory方法被調用，標誌着LifeCycleActivity的終結。

你們彷佛注意到，在全部的過程當中，並無onRestoreInstanceState的出現，這個並不奇怪，由於以前咱們就說過，onRestoreInstanceState只有在殺死不在前臺的Activity以後用戶回到此Activity，或者用戶改變屏幕方向的這兩個重建過程當中被調用。咱們要演示第一種狀況比較困難，咱們能夠結合第二種狀況演示一下具體過程。順便也向你們講解一下屏幕方向改變的應對策略。

首先介紹一下關於Activity屏幕方向的相關知識。

咱們能夠爲一個Activity指定一個特定的方向，指定以後即便轉動屏幕方向，顯示方向也不會跟着改變：

1.指定爲豎屏：在AndroidManifest.xml中對指定的Activity設置android:screenOrientation="portrait"，或者在onCreate方法中指定：

[java] view plaincopy

1. setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);  //豎屏  

2.指定爲橫屏：在AndroidManifest.xml中對指定的Activity設置android:screenOrientation="landscape"，或者在onCreate方法中指定：

[java] view plaincopy

1. setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE); //橫屏  

爲應用中的Activity設置特定的方向是常常用到的辦法，能夠爲咱們省去很多沒必要要的麻煩。不過，咱們今天講的是屏幕方向改變時的生命週期，因此咱們並不採用固定屏幕方向這種辦法。

下面咱們就結合實例講解一下屏幕轉換的生命週期，咱們新建一個Activity命名爲OrientationActivity，以下：

[java] view plaincopy

1. package com.scott.lifecycle;  

2.   

3. import android.app.Activity;  

4. import android.content.res.Configuration;  

5. import android.os.Bundle;  

6. import android.util.Log;  

7.   

8. public class OrientationActivity extends Activity {  

9.       

10.     private static final String TAG = "OrientationActivity";  

11.     private int param = 1;  

12.       

13.     @Override  

14.     protected void onCreate(Bundle savedInstanceState) {  

15.         super.onCreate(savedInstanceState);  

16.         setContentView(R.layout.orientation_portrait);  

17.         Log.i(TAG, "onCreate called.");  

18.     }  

19.       

20.     @Override  

21.     protected void onStart() {  

22.         super.onStart();  

23.         Log.i(TAG, "onStart called.");  

24.     }  

25.       

26.     @Override  

27.     protected void onRestart() {  

28.         super.onRestart();  

29.         Log.i(TAG, "onRestart called.");  

30.     }  

31.       

32.     @Override  

33.     protected void onResume() {  

34.         super.onResume();  

35.         Log.i(TAG, "onResume called.");  

36.     }  

37.       

38.     @Override  

39.     protected void onPause() {  

40.         super.onPause();  

41.         Log.i(TAG, "onPause called.");  

42.     }  

43.       

44.     @Override  

45.     protected void onStop() {  

46.         super.onStop();  

47.         Log.i(TAG, "onStop called.");  

48.     }  

49.       

50.     @Override  

51.     protected void onDestroy() {  

52.         super.onDestroy();  

53.         Log.i(TAG, "onDestory called.");  

54.     }  

55.   

56.     @Override  

57.     protected void onSaveInstanceState(Bundle outState) {  

58.         outState.putInt("param", param);  

59.         Log.i(TAG, "onSaveInstanceState called. put param: " + param);  

60.         super.onSaveInstanceState(outState);  

61.     }  

62.       

63.     @Override  

64.     protected void onRestoreInstanceState(Bundle savedInstanceState) {  

65.         param = savedInstanceState.getInt("param");  

66.         Log.i(TAG, "onRestoreInstanceState called. get param: " + param);  

67.         super.onRestoreInstanceState(savedInstanceState);  

68.     }  

69.       

70.     //當指定了android:configChanges="orientation"後,方向改變時onConfigurationChanged被調用  

71.     @Override  

72.     public void onConfigurationChanged(Configuration newConfig) {  

73.         super.onConfigurationChanged(newConfig);  

74.         Log.i(TAG, "onConfigurationChanged called.");  

75.         switch (newConfig.orientation) {  

76.         case Configuration.ORIENTATION_PORTRAIT:  

77.             setContentView(R.layout.orientation_portrait);  

78.             break;  

79.         case Configuration.ORIENTATION_LANDSCAPE:  

80.             setContentView(R.layout.orientation_landscape);  

81.             break;  

82.         }  

83.     }  

84. }  

首先咱們須要進入「Settings->Display」中，將「Auto-rotate Screen」一項選中，代表能夠自動根據方向旋轉屏幕，而後咱們就能夠測試流程了，當咱們旋轉屏幕時，咱們發現系統會先將當前Activity銷燬，而後重建一個新的：

系統先是調用onSaveInstanceState方法，咱們保存了一個臨時參數到Bundle對象裏面，而後當Activity重建以後咱們又成功的取出了這個參數。

爲了不這樣銷燬重建的過程，咱們須要在AndroidMainfest.xml中對OrientationActivity對應的<activity>配置android:configChanges="orientation"，而後咱們再測試一下，我試着作了四次的旋轉，打印以下：

能夠看到，每次旋轉方向時，只有onConfigurationChanged方法被調用，沒有了銷燬重建的過程。

如下是須要注意的幾點：

1.若是<activity>配置了android:screenOrientation屬性，則會使android:configChanges="orientation"失效。

2.模擬器與真機差異很大：模擬器中若是不配置android:configChanges屬性或配置值爲orientation，切到橫屏執行一次銷燬->重建，切到豎屏執行兩次。真機均爲一次。模擬器中若是配置android:configChanges="orientation|keyboardHidden"（若是是Android4.0，則是"orientation|keyboardHidden|screenSize"），切豎屏執行一次onConfigurationChanged，切橫屏執行兩次。真機均爲一次。

Activity的生命週期與程序的健壯性有着密不可分的關係，但願朋友們可以認真體會、熟練應用。