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，以下：

package com.scott.lifecycle;

import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;

public class LifeCycleActivity extends Activity {
    
    private static final String TAG = "LifeCycleActivity";
    private Context context = this;
    private int param = 1;
    
    //Activity建立時被調用
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.i(TAG, "onCreate called.");
        
        setContentView(R.layout.lifecycle);
        
        Button btn = (Button) findViewById(R.id.btn);
        btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent = new Intent(context, TargetActivity.class);
                startActivity(intent);
            }
        });
    }
    
    //Activity建立或者從後臺從新回到前臺時被調用
    @Override
    protected void onStart() {
        super.onStart();
        Log.i(TAG, "onStart called.");
    }
    
    //Activity從後臺從新回到前臺時被調用
    @Override
    protected void onRestart() {
        super.onRestart();
        Log.i(TAG, "onRestart called.");
    }
    
    //Activity建立或者從被覆蓋、後臺從新回到前臺時被調用
    @Override
    protected void onResume() {
        super.onResume();
        Log.i(TAG, "onResume called.");
    }
    
    //Activity窗口得到或失去焦點時被調用,在onResume以後或onPause以後
    /*@Override
    public void onWindowFocusChanged(boolean hasFocus) {
        super.onWindowFocusChanged(hasFocus);
        Log.i(TAG, "onWindowFocusChanged called.");
    }*/
    
    //Activity被覆蓋到下面或者鎖屏時被調用
    @Override
    protected void onPause() {
        super.onPause();
        Log.i(TAG, "onPause called.");
        //有可能在執行完onPause或onStop後,系統資源緊張將Activity殺死,因此有必要在此保存持久數據
    }
    
    //退出當前Activity或者跳轉到新Activity時被調用
    @Override
    protected void onStop() {
        super.onStop();
        Log.i(TAG, "onStop called.");    
    }
    
    //退出當前Activity時被調用,調用以後Activity就結束了
    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.i(TAG, "onDestory called.");
    }
    
    /**
     * Activity被系統殺死時被調用.
     * 例如:屏幕方向改變時,Activity被銷燬再重建;當前Activity處於後臺,系統資源緊張將其殺死.
     * 另外,當跳轉到其餘Activity或者按Home鍵回到主屏時該方法也會被調用,系統是爲了保存當前View組件的狀態.
     * 在onPause以前被調用.
     */
    @Override
    protected void onSaveInstanceState(Bundle outState) {
        outState.putInt("param", param);
        Log.i(TAG, "onSaveInstanceState called. put param: " + param);
        super.onSaveInstanceState(outState);
    }
    
    /**
     * Activity被系統殺死後再重建時被調用.
     * 例如:屏幕方向改變時,Activity被銷燬再重建;當前Activity處於後臺,系統資源緊張將其殺死,用戶又啓動該Activity.
     * 這兩種狀況下onRestoreInstanceState都會被調用,在onStart以後.
     */
    @Override
    protected void onRestoreInstanceState(Bundle savedInstanceState) {
        param = savedInstanceState.getInt("param");
        Log.i(TAG, "onRestoreInstanceState called. get param: " + param);
        super.onRestoreInstanceState(savedInstanceState);
    }
}

你們注意到，除了幾個常見的方法外，咱們還添加了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方法中指定：

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);    //豎屏

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

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);    //橫屏

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

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

package com.scott.lifecycle;

import android.app.Activity;
import android.content.res.Configuration;
import android.os.Bundle;
import android.util.Log;

public class OrientationActivity extends Activity {
    
    private static final String TAG = "OrientationActivity";
    private int param = 1;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.orientation_portrait);
        Log.i(TAG, "onCreate called.");
    }
    
    @Override
    protected void onStart() {
        super.onStart();
        Log.i(TAG, "onStart called.");
    }
    
    @Override
    protected void onRestart() {
        super.onRestart();
        Log.i(TAG, "onRestart called.");
    }
    
    @Override
    protected void onResume() {
        super.onResume();
        Log.i(TAG, "onResume called.");
    }
    
    @Override
    protected void onPause() {
        super.onPause();
        Log.i(TAG, "onPause called.");
    }
    
    @Override
    protected void onStop() {
        super.onStop();
        Log.i(TAG, "onStop called.");
    }
    
    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.i(TAG, "onDestory called.");
    }

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        outState.putInt("param", param);
        Log.i(TAG, "onSaveInstanceState called. put param: " + param);
        super.onSaveInstanceState(outState);
    }
    
    @Override
    protected void onRestoreInstanceState(Bundle savedInstanceState) {
        param = savedInstanceState.getInt("param");
        Log.i(TAG, "onRestoreInstanceState called. get param: " + param);
        super.onRestoreInstanceState(savedInstanceState);
    }
    
    //當指定了android:configChanges="orientation"後,方向改變時onConfigurationChanged被調用
    @Override
    public void onConfigurationChanged(Configuration newConfig) {
        super.onConfigurationChanged(newConfig);
        Log.i(TAG, "onConfigurationChanged called.");
        switch (newConfig.orientation) {
        case Configuration.ORIENTATION_PORTRAIT:
            setContentView(R.layout.orientation_portrait);
            break;
        case Configuration.ORIENTATION_LANDSCAPE:
            setContentView(R.layout.orientation_landscape);
            break;
        }
    }
}

首先咱們須要進入「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的生命週期與程序的健壯性有着密不可分的關係，但願朋友們可以認真體會、熟練應用。