Android狀態保存與恢復

Android狀態保存與恢復

• Activity的狀態保存與恢復
• Fragment的狀態保存與恢復
• View的狀態保存與恢復

Activity的狀態保存與恢復

　　有很多種正常的狀態導致Activity的銷燬，例如用戶點擊返回鍵或直接調用finish()方法。當Activity處於stopped狀態且長時間不用時或前臺Activity需要更多資源導致系統必須殺死後臺進程回收內存時，系統會銷燬你的Activity。當activity被銷燬是因爲用戶點擊返回鍵或調用finish()方法時，這時該Activity的實例將永久的消失，因爲這些行爲表示該Activity不再被需要。然而，如果由於系統限制導致系統銷燬了Activity，則儘管實際上Activity的實例是消失了，但系統會記錄它的存在，這是如果用戶回到它，系統會使用該Activity銷燬時保存的狀態數據重建一個新的Activity實例。這個系統保存的用來恢復到之前狀態的數據叫做“實例狀態”，它以鍵值對的形式保存在Bundle對象中。
　　用戶每次旋轉屏幕時，Activity都會被銷燬後重建。這是因爲當屏幕方向改變時，Activity可能需要加載不同的資源文件layout，所以前臺的Activity會被銷燬並重建。
默認情況下，系統會使用Bundle保存在Activity佈局中定義的每一個View對象的信息（例如ListView的滾動位置）。所以，如果你的Activity被銷燬後重建，佈局狀態的恢復不需要你編寫任何的代碼。然而，你的Activity可能有更多需要恢復的狀態信息，例如保存用戶狀態的變量。
　　爲了讓系統能恢復你Activity中views的狀態，每一個view需要有唯一的id，其通過android:id屬性提供。
爲了保存關於activity狀態的附加數據，你必須重寫onSaveInstanceState()回調方法。當用戶離開該Activity時（不管是不是意外退出），該方法被回調，系統傳遞保存該Activity意外銷燬時的視圖狀態的Bundle到該方法。如果系統稍後需要重建該Activity，它傳遞這個相同的Bundle對象到onCreate()和onRestoreInstanceState()方法。
　　注意使用Bundle保存狀態並不總是有效的，這是因爲Bundle中保存的數據必須是經過序列化的（實現了Parcelable或Serializable接口）且Bundle中只能保存1M以下的數據。
　　下圖顯示了Activity意外銷燬時，狀態的保存和恢復的回調過程：
　　

Activity狀態保存與恢復的示例

public class StateSaveAndRestoreActivity extends AppCompatActivity {

    private static final String TAG = StateSaveAndRestoreActivity.class.getSimpleName();
    private static final String SXD = "sxd";

    private static final String STATE_KEY = "state_key";

    private EditText mEditText;//EditText中的值，系統默認就會恢復
    private String mEditTextStr;//狀態變量的值，需要自己保存和恢復

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.state_save_and_restore_activity);
        if (savedInstanceState == null) {
            Log.i(SXD, TAG + "--onCreate++savedInstanceState:" + savedInstanceState);
        } else {
            Log.i(SXD, TAG + "--onCreate++savedInstanceState++mEditTextStr:" + savedInstanceState.getString(STATE_KEY));
        }
        initView();
    }

    private void initView() {
        mEditText = (EditText) this.findViewById(R.id.edit_text);
        mEditText.addTextChangedListener(new TextWatcher() {
            @Override
            public void beforeTextChanged(CharSequence s, int start, int count, int after) {

            }

            @Override
            public void onTextChanged(CharSequence s, int start, int before, int count) {

            }

            @Override
            public void afterTextChanged(Editable s) {
                mEditTextStr = mEditText.getText().toString();
            }
        });
    }

    @Override
    protected void onStart() {
        super.onStart();
        Log.i(SXD, TAG + "--onStart");
    }

    @Override
    protected void onRestoreInstanceState(Bundle savedInstanceState) {
        super.onRestoreInstanceState(savedInstanceState);
        mEditTextStr = savedInstanceState.getString(STATE_KEY);
        Log.i(SXD, TAG + "--onRestoreInstanceState++savedInstanceState++mEditTextStr:" + mEditTextStr);
    }

    @Override
    protected void onResume() {
        super.onResume();
        Log.i(SXD, TAG + "--onResume");
    }

    @Override
    protected void onPause() {
        super.onPause();
        Log.i(SXD, TAG + "--onPause");
    }

    @Override
    protected void onStop() {
        super.onStop();
        Log.i(SXD, TAG + "--onStop");
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.i(SXD, TAG + "--onDestroy");
    }

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        outState.putString(STATE_KEY, mEditTextStr);
        Log.i(SXD, TAG + "--onSaveInstanceState++outState++mEditTextStr:" + outState.getString(STATE_KEY));
    }

}

以上程序輸入“哈哈哈”後，執行屏幕翻轉

執行完屏幕翻轉後的Log輸出：

　　因爲onCreate()方法不管是創建新的Activity還是重建老的Activity都會被調用，所以使用onCreate()方法中的Bundle恢復狀態時，必須判斷Bundle是否爲null，如果爲null，則創建新的Activity，否則重建老的Activity。
如果使用onRestoreInstanceState()方法恢復狀態，則不再需要對其中的Bundle進行判null，因爲僅當有狀態需要被恢復時，該方法纔會被回調，且該方法在onStart()方法之後調用。
注意：

1. 要一直調用onSaveInstanceState()方法超類的實現，因爲默認實現能保存views的狀態。
2. 要一直調用onRestoreInstanceState()方法超類的實現，因爲默認實現能夠恢復views的狀態。

Fragment的狀態保存與恢復

　　當系統因爲配置變化關閉Activity時，該Activity中的fragments會被保持而不被銷燬。
　　當Fragment的宿主Activity意外銷燬時，系統會將Fragment的當時狀態保存到Bundle對象中，以便當該Activity重建時，可以將Fragment恢復到之前的狀態。
　　同Activity一樣，默認情況下，系統會使用Bundle保存在Fragment佈局中定義的每一個View對象的信息（例如ListView的滾動位置）。所以，如果你的Fragment被銷燬後重建，佈局狀態的恢復不需要你編寫任何的代碼。然而，你的Fragment可能有更多需要恢復的狀態信息，例如保存用戶狀態的變量。
　　爲了讓系統能恢復你Fragment中views的狀態，每一個view需要有唯一的id，其通過android:id屬性提供。
　　爲了保存關於Fragment狀態的附加數據，必須重寫onSaveInstanceState()回調方法。當用戶離開該Fragment的宿主Activity時（不管是不是意外退出），該方法被回調，系統傳遞保存該Fragment當前的視圖狀態的Bundle到該方法。如果系統稍後需要重建該Fragment的宿主Activity，它傳遞這個相同的Bundle對象到onCreate()（當調用setRetainInstance(true)後，在恢復狀態時不再回調該方法）、onCreateView()、onViewCreated()、onActivityCreated()和onViewStateRestored()方法。
　　相對Activity，Fragment有一種很容易保存狀態的方法，就是調用setRetainInstance(true)方法，將該Fragment轉變爲“持久化Fragment”，這意味着只有該Fragment的GUI（從onViewCreated()方法返回的View）會被銷燬重建，而所有其他的引用變量仍然保持。這就不需要額外的將狀態變量保存在Bundle中了，從而簡化了很多操作。
　　注意在Fragment的宿主Activity重建時，使用FragmentManager取回該Fragment，而不要新建一個這樣的Fragment。

Fragment狀態保存與恢復的示例

Fragment宿主Activity中的代碼

public class FragmentStateDealActivity extends AppCompatActivity {

    private static final String TAG = FragmentStateDealActivity.class.getSimpleName();
    private static final String SXD = "sxd";

    public static final String STR_STATE_KEY = "str_state_key";

    private StateSaveAndRestoreFragment mStateSaveAndRestoreFragment;
    private FragmentManager mFm;

    private String mString;//狀態變量的值，需要自己保存和恢復

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.fragment_state_deal_activity);
        mFm = getSupportFragmentManager();
        mStateSaveAndRestoreFragment = (StateSaveAndRestoreFragment) mFm.findFragmentByTag(StateSaveAndRestoreFragment.TAG);
        Log.i(SXD, TAG + "--onCreate++mStateSaveAndRestoreFragment:" + mStateSaveAndRestoreFragment);
        if (mStateSaveAndRestoreFragment == null) {
            mStateSaveAndRestoreFragment = StateSaveAndRestoreFragment.newInstance();
            mFm.beginTransaction().add(R.id.content_layout, mStateSaveAndRestoreFragment, StateSaveAndRestoreFragment.TAG).commit();
        }
        if (savedInstanceState == null) {
            Log.i(SXD, TAG + "--onCreate++savedInstanceState:" + savedInstanceState);
        } else {
            Log.i(SXD, TAG + "--onCreate++savedInstanceState++mString:" + savedInstanceState.getString(STR_STATE_KEY));
        }
    }

    @Override
    protected void onRestoreInstanceState(Bundle savedInstanceState) {
        super.onRestoreInstanceState(savedInstanceState);
        Log.i(SXD, TAG + "--onRestoreInstanceState++onRestoreInstanceState++mString:" + savedInstanceState.getString(STR_STATE_KEY));
    }

    @Override
    protected void onResume() {
        super.onResume();
        mString = "Fragment宿主中的變量";
        Log.i(SXD, TAG + "--onResume++mString:" + mString);
    }

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        outState.putString(STR_STATE_KEY, mString);
        Log.i(SXD, TAG + "--onSaveInstanceState++outState++mString:" + outState.getString(STR_STATE_KEY));
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.i(SXD, TAG + "--onDestroy");
    }

}

　　從示例代碼中可以看到，在onCreate()中，先通過FragmentManager取回StateSaveAndRestoreFragment，如果之前向FragmentManager中添加過StateSaveAndRestoreFragment，則取出之前添加的StateSaveAndRestoreFragment，以便能夠恢復到銷燬前的狀態，如果之前沒有添加過，則新建StateSaveAndRestoreFragment對象並將其添加進FragmentManager中。

調用setRetainInstance(true)的示例

/**
 * 通過setRetainInstance(true)將該Fragment設置爲“保持Fragment“
 */
public class StateSaveAndRestoreFragment extends Fragment {

    public static final String TAG = StateSaveAndRestoreFragment.class.getSimpleName();
    private static final String SXD = "sxd";

    private EditText mEditText;//EditText中的值，系統默認就會恢復
    private String mEditTextStr;//狀態變量的值，當通過setRetainInstance(true)將該Fragment設置爲“保持Fragment“,則該變量在宿主Activity銷燬重建時，會一直保持

    public static StateSaveAndRestoreFragment newInstance() {
        StateSaveAndRestoreFragment stateSaveAndRestoreFragment = new StateSaveAndRestoreFragment();
        return stateSaveAndRestoreFragment;
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setRetainInstance(true);
        Log.i(SXD, TAG + "--onCreate");
    }

    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        View rootView = inflater.inflate(R.layout.state_save_and_restore_fragment, container, false);
        Log.i(SXD, TAG + "--onCreateView++mEditTextStr:" + mEditTextStr);
        initView(rootView);
        return rootView;
    }

    private void initView(View rootView) {
        mEditText = (EditText) rootView.findViewById(R.id.edit_text);
        mEditText.addTextChangedListener(new TextWatcher() {
            @Override
            public void beforeTextChanged(CharSequence s, int start, int count, int after) {

            }

            @Override
            public void onTextChanged(CharSequence s, int start, int before, int count) {

            }

            @Override
            public void afterTextChanged(Editable s) {
                mEditTextStr = mEditText.getText().toString();
            }
        });
    }

    @Override
    public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        Log.i(SXD, TAG + "--onViewCreated");
    }

    @Override
    public void onActivityCreated(@Nullable Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        Log.i(SXD, TAG + "--onActivityCreated");
    }

    @Override
    public void onViewStateRestored(@Nullable Bundle savedInstanceState) {
        super.onViewStateRestored(savedInstanceState);
        Log.i(SXD, TAG + "--onViewStateRestored");
    }

    @Override
    public void onStart() {
        super.onStart();
        Log.i(SXD, TAG + "--onStart");
    }

    @Override
    public void onResume() {
        super.onResume();
        Log.i(SXD, TAG + "--onResume");
    }

    @Override
    public void onHiddenChanged(boolean hidden) {
        super.onHiddenChanged(hidden);
        Log.i(SXD, TAG + "--onHiddenChanged++hidden:" + hidden);
    }

    @Override
    public void onPause() {
        super.onPause();
        Log.i(SXD, TAG + "--onPause");
    }

    @Override
    public void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        Log.i(SXD, TAG + "--onSaveInstanceState++mEditTextStr:" + mEditTextStr);
    }

    @Override
    public void onStop() {
        super.onStop();
        Log.i(SXD, TAG + "--onStop");
    }

    @Override
    public void onDestroyView() {
        super.onDestroyView();
        Log.i(SXD, TAG + "--onDestroyView");
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.i(SXD, TAG + "--onDestroy");
    }

}

同Activity的狀態保存與恢復示例一樣的輸入“哈哈哈”，並旋轉屏幕後的Log輸出：

從輸出結果可以得到：

• 調用setRetainInstance(true)將該Fragment設置爲“保持Fragment“後，則其中的狀態變量在宿主Activity銷燬重建時，會一直保持，不會銷燬。
• 調用setRetainInstance(true)將該Fragment設置爲“保持Fragment“後，當宿主Activity銷燬重建時，不會回調該Fragment的onDestroy()和onCreate()方法，即這時只銷毀重建View，並不會銷燬狀態變量。

未調用setRetainInstance(true)的示例

public class StateSaveAndRestoreFragment extends Fragment {

    public static final String TAG = StateSaveAndRestoreFragment.class.getSimpleName();
    private static final String SXD = "sxd";

    private static final String STATE_KEY = "state_key";

    private EditText mEditText;//EditText中的值，系統默認就會恢復
    private String mEditTextStr;//狀態變量的值，需要自己保存和恢復

    public static StateSaveAndRestoreFragment newInstance() {
        StateSaveAndRestoreFragment stateSaveAndRestoreFragment = new StateSaveAndRestoreFragment();
        return stateSaveAndRestoreFragment;
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.i(SXD, TAG + "--onCreate++savedInstanceState++mEditTextStr:" + mEditTextStr);
        if (savedInstanceState == null) {
            Log.i(SXD, TAG + "--onCreate++savedInstanceState:" + savedInstanceState);
        } else {
            mEditTextStr = savedInstanceState.getString(STATE_KEY);
            Log.i(SXD, TAG + "--onCreate++savedInstanceState++mEditTextStr:" + mEditTextStr);
            Log.i(SXD, TAG + "--onCreate++savedInstanceState++mString:" + savedInstanceState.getString(FragmentStateDealActivity.STR_STATE_KEY));
        }
    }

    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        View rootView = inflater.inflate(R.layout.state_save_and_restore_fragment, container, false);
        if (savedInstanceState == null) {
            Log.i(SXD, TAG + "--onCreateView++savedInstanceState:" + savedInstanceState);
        } else {
            Log.i(SXD, TAG + "--onCreateView++savedInstanceState++mEditTextStr:" + savedInstanceState.getString(STATE_KEY));
            Log.i(SXD, TAG + "--onCreateView++savedInstanceState++mString:" + savedInstanceState.getString(FragmentStateDealActivity.STR_STATE_KEY));
        }
        initView(rootView);
        return rootView;
    }

    private void initView(View rootView) {
        mEditText = (EditText) rootView.findViewById(R.id.edit_text);
        mEditText.addTextChangedListener(new TextWatcher() {
            @Override
            public void beforeTextChanged(CharSequence s, int start, int count, int after) {

            }

            @Override
            public void onTextChanged(CharSequence s, int start, int before, int count) {

            }

            @Override
            public void afterTextChanged(Editable s) {
                mEditTextStr = mEditText.getText().toString();
            }
        });
    }

    @Override
    public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        if (savedInstanceState == null) {
            Log.i(SXD, TAG + "--onViewCreated++savedInstanceState:" + savedInstanceState);
        } else {
            Log.i(SXD, TAG + "--onViewCreated++savedInstanceState++mEditTextStr:" + savedInstanceState.getString(STATE_KEY));
            Log.i(SXD, TAG + "--onViewCreated++savedInstanceState++mString:" + savedInstanceState.getString(FragmentStateDealActivity.STR_STATE_KEY));
        }
    }

    @Override
    public void onActivityCreated(@Nullable Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        if (savedInstanceState == null) {
            Log.i(SXD, TAG + "--onActivityCreated++savedInstanceState:" + savedInstanceState);
        } else {
            Log.i(SXD, TAG + "--onActivityCreated++savedInstanceState++mEditTextStr:" + savedInstanceState.getString(STATE_KEY));
            Log.i(SXD, TAG + "--onActivityCreated++savedInstanceState++mString:" + savedInstanceState.getString(FragmentStateDealActivity.STR_STATE_KEY));
        }
    }

    @Override
    public void onViewStateRestored(@Nullable Bundle savedInstanceState) {
        super.onViewStateRestored(savedInstanceState);
        if (savedInstanceState == null) {
            Log.i(SXD, TAG + "--onViewStateRestored++savedInstanceState:" + savedInstanceState);
        } else {
            Log.i(SXD, TAG + "--onViewStateRestored++savedInstanceState++mEditTextStr:" + savedInstanceState.getString(STATE_KEY));
            Log.i(SXD, TAG + "--onViewStateRestored++savedInstanceState++mString:" + savedInstanceState.getString(FragmentStateDealActivity.STR_STATE_KEY));
        }
    }

    @Override
    public void onStart() {
        super.onStart();
        Log.i(SXD, TAG + "--onStart");
    }

    @Override
    public void onResume() {
        super.onResume();
        Log.i(SXD, TAG + "--onResume");
    }

    @Override
    public void onHiddenChanged(boolean hidden) {
        super.onHiddenChanged(hidden);
        Log.i(SXD, TAG + "--onHiddenChanged++hidden:" + hidden);
    }

    @Override
    public void onPause() {
        super.onPause();
        Log.i(SXD, TAG + "--onPause");
    }

    @Override
    public void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        outState.putString(STATE_KEY, mEditTextStr);
        Log.i(SXD, TAG + "--onSaveInstanceState++outState++mEditTextStr:" + outState.getString(STATE_KEY));
    }

    @Override
    public void onStop() {
        super.onStop();
        Log.i(SXD, TAG + "--onStop");
    }

    @Override
    public void onDestroyView() {
        super.onDestroyView();
        Log.i(SXD, TAG + "--onDestroyView");
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.i(SXD, TAG + "--onDestroy");
    }

}

同Activity的狀態保存與恢復示例一樣的輸入“哈哈哈”，並旋轉屏幕後的Log輸出：

從輸出結果可以看出以下幾點：

• Fragment恢復時，回調的onCreate()、onCreateView()、onViewCreated()、onActivityCreated()和onViewStateRestored()方法中的Bundle和Framgent調用onSaveInstanceState()方法保存狀態的中的Bundle是一樣的。
• 不同於Activity的onRestoreInstanceState()方法只在狀態需要被恢復時調用，Framgent的onViewStateRestored()方法有沒有狀態需要被恢復時都會被調用。
• 未使用setRetainInstance(true)方法將Fragment設置爲“保持的Fragment”，則當Fragment的宿主Activity銷燬時，該Fragment會將狀態變量一同銷燬，所以示例中mEditTextStr的值在屏幕旋轉後變爲null。
• Fragment中的onCreate()、onCreateView()、onViewCreated()、onActivityCreated()和onViewStateRestored()這些回調方法中的Bundle對象和其宿主Activity沒有任何關係，不能從中獲取到其宿主Activity保存到Bundle對象中的數據。

View的狀態保存與恢復

　　View沒有像Fragment一樣讓其變成“保持”狀態的方法，所以當包含狀態變量的自定義View需要銷燬重建時，需要在View銷燬時回調protected Parcelable onSaveInstanceState()方法中，將需要保存的狀態變量保存在實現了Parcelable接口的數據對象中，並在View重建調用protected void onRestoreInstanceState(Parcelable state)時，從state（其爲onSaveInstanceState()方法返回的數據對象）中將這些狀態變量恢復。

View狀態保存與恢復的示例

view_state_deal_activity.xml文件

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <com.example.sunxiaodong.statesaveandrestore.StateSaveAndRestoreLinearLayout
        android:id="@+id/linear_layout"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerInParent="true">

        <EditText
            android:id="@+id/edit_text"
            android:layout_width="80dp"
            android:layout_height="40dp"
            android:layout_centerInParent="true" />

    </com.example.sunxiaodong.statesaveandrestore.StateSaveAndRestoreLinearLayout>

</RelativeLayout>

ViewStateDealActivity.java文件

public class ViewStateDealActivity extends AppCompatActivity {

    private static final String TAG = ViewStateDealActivity.class.getSimpleName();
    private static final String SXD = "sxd";

    private StateSaveAndRestoreLinearLayout mLinearLayout;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.view_state_deal_activity);
        initView();
    }

    private void initView() {
        mLinearLayout = (StateSaveAndRestoreLinearLayout) this.findViewById(R.id.linear_layout);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
    }

}

StateSaveAndRestoreLinearLayout.java文件

public class StateSaveAndRestoreLinearLayout extends LinearLayout {

    private static final String TAG = StateSaveAndRestoreLinearLayout.class.getSimpleName();
    private static final String SXD = "sxd";

    private Integer mStateVar;//狀態變量，當該View銷燬時，其會被銷燬

    public StateSaveAndRestoreLinearLayout(Context context) {
        super(context);
        Log.i(SXD, TAG + "--StateSaveAndRestoreLinearLayout++1");
    }

    public StateSaveAndRestoreLinearLayout(Context context, AttributeSet attrs) {
        super(context, attrs);
        Log.i(SXD, TAG + "--StateSaveAndRestoreLinearLayout++beforeRandom++mStateVar:" + mStateVar);
        mStateVar = new Random().nextInt(10);
        Log.i(SXD, TAG + "--StateSaveAndRestoreLinearLayout++afterRandom++mStateVar:" + mStateVar);
    }

    public StateSaveAndRestoreLinearLayout(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        Log.i(SXD, TAG + "--StateSaveAndRestoreLinearLayout++3");
    }

    @Override
    protected void onRestoreInstanceState(Parcelable state) {
        SaveState savedState = (SaveState) state;
        super.onRestoreInstanceState(savedState.getParcelable());
        mStateVar = savedState.getSavedState();
        Log.i(SXD, TAG + "--onRestoreInstanceState++mStateVar:" + mStateVar);
    }

    @Override
    protected Parcelable onSaveInstanceState() {
        Log.i(SXD, TAG + "--onSaveInstanceState++mStateVar:" + mStateVar);
        SaveState state = new SaveState(super.onSaveInstanceState());
        state.setSavedState(mStateVar);
        return state;
    }

    /**
     * 保存View狀態數據體
     */
    static class SaveState implements Parcelable {

        private Integer mSavedState;//保存View中的狀態變量
        private Parcelable mParcelable;//保存View的默認狀態

        SaveState(Parcelable parcelable) {
            mParcelable = parcelable;
        }

        protected SaveState(Parcel in) {
            mSavedState = in.readInt();
        }

        public static final Creator<SaveState> CREATOR = new Creator<SaveState>() {
            @Override
            public SaveState createFromParcel(Parcel in) {
                return new SaveState(in);
            }

            @Override
            public SaveState[] newArray(int size) {
                return new SaveState[size];
            }
        };

        @Override
        public int describeContents() {
            return 0;
        }

        @Override
        public void writeToParcel(Parcel dest, int flags) {
            dest.writeInt(mSavedState);
        }

        public Integer getSavedState() {
            return mSavedState;
        }

        public void setSavedState(Integer mSavedState) {
            this.mSavedState = mSavedState;
        }

        public Parcelable getParcelable() {
            return mParcelable;
        }

        public void setParcelable(Parcelable mParcelable) {
            this.mParcelable = mParcelable;
        }
    }

}

將屏幕旋轉後的Log輸出：

從輸出可以得到：

• protected void onRestoreInstanceState(Parcelable state)只在View重建時回調。
• protected Parcelable onSaveInstanceState()和protected void onRestoreInstanceState(Parcelable state)中使用新的數據對象保存和恢復狀態時，一定要將默認的View狀態保存和恢復，即在onSaveInstanceState()方法中，保存super.onSaveInstanceState()，並在onRestoreInstanceState(Parcelable state)中使用super.onRestoreInstanceState(savedState.getParcelable())對之前保存的狀態進行恢復。

源碼地址