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())对之前保存的状态进行恢复。

源码地址