在Activity被回收之前，系统会调用Activity#onSaveInstanceState(Bundle outState)来保存View的状态到传入的outState对象中。
在Activity被重新创建时，Activity#onCreate(Bundle savedInstanceState)和Activity#onRestoreInstanceState(Bundle savedInstanceState)会传入保存的状态信息并恢复View的状态。
用户也可以重载Activity#onSaveInstanceState()方法来保存额外的Activity状态，并在Activity.onCreate()或者Activity#onRestoreInstanceState()获取这些状态。
这里主要看View的状态是怎么保存和重新获取的。
先说一下Bundle类，在Android代码里的注释是：
A mapping from String values to various Parcelable types.
可以简单把Bundle看成一个Map，其中Object都实现了Parcelable接口。Bundle类有一系列的set和get方法用来操作Map中的值。
protected void onSaveInstanceState(Bundle outState) {
outState.putBundle(WINDOW_HIERARCHY_TAG, mWindow.saveHierarchyState());
Parcelable p = mFragments.saveAllState();
if (p != null) {
outState.putParcelable(FRAGMENTS_TAG, p);
}
getApplication().dispatchActivitySaveInstanceState(this, outState);
}
这个方法做了三件事，1.保存Activity对应的Window的State信息，并存放在outState中，2.保存所有Fragements的信息，如果不为零，也存放在outState中，3.调用外部注册的一些回调方法。保存Fragments的信息是通过保存Fragment的根View的状态实现的，这和保存Window的State信息类似。所以看mWindow.saveHierarchyState()方法，这里mWindow是一个PhoneWindow对象，找到PhoneWindow#saveHierarchyState()方法：
public Bundle saveHierarchyState() {
//step 1:
Bundle outState = new Bundle();
if (mContentParent == null) {
return outState;
}
// step 2: save View states
SparseArray states = new SparseArray();
mContentParent.saveHierarchyState(states);
outState.putSparseParcelableArray(VIEWS_TAG, states);
// step 3: save the focused view id
View focusedView = mContentParent.findFocus();
if (focusedView != null) {
if (focusedView.getId() != View.NO_ID) {
outState.putInt(FOCUSED_ID_TAG, focusedView.getId());
} else {
if (false) {
Log.d(TAG, "couldn't save which view has focus because the focused view "
+ focusedView + " has no id.");
}
}
}
// step 4: save the panels state
SparseArray panelStates = new SparseArray();
savePanelState(panelStates);
if (panelStates.size() > 0) {
outState.putSparseParcelableArray(PANELS_TAG, panelStates);
}
// step 5: save actionBar state
if (mDecorContentParent != null) {
SparseArray actionBarStates = new SparseArray();
mDecorContentParent.saveToolbarHierarchyState(actionBarStates);
outState.putSparseParcelableArray(ACTION_BAR_TAG, actionBarStates);
}
return outState;
}
这个方法依次做了这些事情：
1.创建Bundle对象用来返回，判断Window是否有对应的mContentParent这个View对象，如果没有直接返回
2.保存View的信息
3.保存当前View焦点的信息
4.保存抽屉信息
5.保存ActionBar信息。
我们关注第二步保存View信息: mContentParent.saveHierarchyState(states);.这里states是一个SparseArray对象，所有View信息都会保存在states中。SparseArray可以理解为Map,是Android系统为了优化内存创建的类。
看一下View#saveHierarchyState(SparseArray container):
public void saveHierarchyState(SparseArray container) {
dispatchSaveInstanceState(container);
}
直接调用了View#dispatchSaveInstanceState(SparseArray container):
protected void dispatchSaveInstanceState(SparseArray container) {
if (mID != NO_ID && (mViewFlags & SAVE_DISABLED_MASK) == 0) {
mPrivateFlags &= ~PFLAG_SAVE_STATE_CALLED;
Parcelable state = onSaveInstanceState();
if ((mPrivateFlags & PFLAG_SAVE_STATE_CALLED) == 0) {
throw new IllegalStateException(
"Derived class did not call super.onSaveInstanceState()");
}
if (state != null) {
// Log.i("View", "Freezing #" + Integer.toHexString(mID)
// + ": " + state);
container.put(mID, state);
}
}
}
检查一下View是否设置了ID，如果没有id直接返回。这里我们可以看到，如果View没有设置id，是不会保存它的状态的。设置了ID之后，获取状态，并将状态以ID为key存储在SparseArray中。这里可以看出，如果View树中两个View的id相同，那么后一个View的SavedState会覆盖前一个SavedState。当然这种情况下findViewById()也会出问题。
保存View状态是在onSaveInstanceState()中实现的：
protected Parcelable onSaveInstanceState() {
mPrivateFlags |= PFLAG_SAVE_STATE_CALLED;
if (mStartActivityRequestWho != null) {
BaseSavedState state = new BaseSavedState(AbsSavedState.EMPTY_STATE);
state.mStartActivityRequestWhoSaved = mStartActivityRequestWho;
return state;
}
return BaseSavedState.EMPTY_STATE;
}
这个方法检查了一下mStartActivityRequestWho这个String对象是否为null，mStartActivityRequestWho这个对象只有在调用了View#startActivityForResult时才会设置，这时标记一下state中的状态，为null时，直接返回一个空状态。
在View类中保存状态里用了三个方法，其中saveHierachyState()方法直接传递给了dispatchSaveInstanceState()方法。dispatchSaveInstanceState()用来分发保存状态的行为，这个方法的默认行为是在有ID的情况下保存自身的state，没有id的情况下什么都不做。所以ViewGroup可以选择重写这个方法，将保存状态的行为分发到子类中。onSaveInstanceState()方法用来具体地保存当前View的状态，自定义View可以选择重写这个方法。
看一下ViewGroup#dispatchSaveInstanceState()方法
protected void dispatchSaveInstanceState(SparseArray container) {
super.dispatchSaveInstanceState(container);
final int count = mChildrenCount;
final View[] children = mChildren;
for (int i = 0; i < count; i++) {
View c = children[i];
if ((c.mViewFlags & PARENT_SAVE_DISABLED_MASK) != PARENT_SAVE_DISABLED) {
c.dispatchSaveInstanceState(container);
}
}
}
首先调用View#dispatchSaveInstanceState()保存自身的状态，然后遍历子View，调用对应的dispatchSaveInstanceState()方法，这里实现的View树的遍历。
看一下TextView#onSaveInstanceState()是怎么保存状态的：
public Parcelable onSaveInstanceState() {
Parcelable superState = super.onSaveInstanceState();
// Save state if we are forced to
boolean save = mFreezesText;
int start = 0;
int end = 0;
if (mText != null) {
start = getSelectionStart();
end = getSelectionEnd();
if (start >= 0 || end >= 0) {
// Or save state if there is a selection
save = true;
}
}
if (save) {
SavedState ss = new SavedState(superState);
// XXX Should also save the current scroll position!
ss.selStart = start;
ss.selEnd = end;
if (mText instanceof Spanned) {
Spannable sp = new SpannableStringBuilder(mText);
if (mEditor != null) {
removeMisspelledSpans(sp);
sp.removeSpan(mEditor.mSuggestionRangeSpan);
}
ss.text = sp;
} else {
ss.text = mText.toString();
}
if (isFocused() && start >= 0 && end >= 0) {
ss.frozenWithFocus = true;
}
ss.error = getError();
if (mEditor != null) {
ss.editorState = mEditor.saveInstanceState();
}
return ss;
}
return superState;
}
首先判断TextView是否需要保存状态，如果mFreezesText设置为true，或者TextView处于被选中的状态，那么需要保存状态。不许要保存保存状态的话直接返回super.onSaveInstanceState().
TextView中有个内部类SavedState用来表示状态，将对应的状态设置好之后直接返回即可。
至此，整个保存状态的过程已经走完，总结一下：
1.在Activity被回收时，会触发一个SaveState的事件。
2.跟其他的事件一样，SaveState事件从Activity->Window->View传递到最大的View，然后遍历View树保存状态
3.状态保存在一个SparseArray中，以View的ID作为key。
4.自定义View可以重载onSaveInstanceState()来保存自己的状态，参考TextView的实现方法。
Restore的过程：Activity#onRestoreInstanceState()方法：
protected void onRestoreInstanceState(Bundle savedInstanceState) {
if (mWindow != null) {
Bundle windowState = savedInstanceState.getBundle(WINDOW_HIERARCHY_TAG);
if (windowState != null) {
mWindow.restoreHierarchyState(windowState);
}
}
}
跟保存的过程一样，传递到Window#restoreHierarchyState()方法中：
public void restoreHierarchyState(Bundle savedInstanceState) {
// step 1.
if (mContentParent == null) {
return;
}
// step 2.
SparseArray savedStates
= savedInstanceState.getSparseParcelableArray(VIEWS_TAG);
if (savedStates != null) {
mContentParent.restoreHierarchyState(savedStates);
}
// step 3. restore the focused view
int focusedViewId = savedInstanceState.getInt(FOCUSED_ID_TAG, View.NO_ID);
if (focusedViewId != View.NO_ID) {
View needsFocus = mContentParent.findViewById(focusedViewId);
if (needsFocus != null) {
needsFocus.requestFocus();
} else {
Log.w(TAG,
"Previously focused view reported id " + focusedViewId
+ " during save, but can't be found during restore.");
}
}
// step 4. restore the panels
SparseArray panelStates = savedInstanceState.getSparseParcelableArray(PANELS_TAG);
if (panelStates != null) {
restorePanelState(panelStates);
}
// step 5.
if (mDecorContentParent != null) {
SparseArray actionBarStates =
savedInstanceState.getSparseParcelableArray(ACTION_BAR_TAG);
if (actionBarStates != null) {
doPendingInvalidatePanelMenu();
mDecorContentParent.restoreToolbarHierarchyState(actionBarStates);
} else {
Log.w(TAG, "Missing saved instance states for action bar views! " +
"State will not be restored.");
}
}
}
跟保存的过程完全一致，分五步。我们只看第三步：mContentParent.restoreHierarchyState(savedStates),这里调用View#restoreHierarchyState(savedStates)方法：
public void restoreHierarchyState(SparseArray container) {
dispatchRestoreInstanceState(container);
}
一样直接传递到View#dispatchRestoreInstanceState()方法：
protected void dispatchRestoreInstanceState(SparseArray container) {
if (mID != NO_ID) {
Parcelable state = container.get(mID);
if (state != null) {
// Log.i("View", "Restoreing #" + Integer.toHexString(mID)
// + ": " + state);
mPrivateFlags &= ~PFLAG_SAVE_STATE_CALLED;
onRestoreInstanceState(state);
if ((mPrivateFlags & PFLAG_SAVE_STATE_CALLED) == 0) {
throw new IllegalStateException(
"Derived class did not call super.onRestoreInstanceState()");
}
}
}
}
对于View的这个方法，从SparseArray中用mID获取到state，然后调用View#onRestoreInstanceState()方法。看一下ViewGroup对应的方法：
protected void dispatchRestoreInstanceState(SparseArray container) {
super.dispatchRestoreInstanceState(container);
final int count = mChildrenCount;
final View[] children = mChildren;
for (int i = 0; i < count; i++) {
View c = children[i];
if ((c.mViewFlags & PARENT_SAVE_DISABLED_MASK) != PARENT_SAVE_DISABLED) {
c.dispatchRestoreInstanceState(container);
}
}
}
先调用View版本的dispatchRestoreInstanceState()方法，然后遍历childView,调用对应的dispatchRestoreInstanceState()方法。
最后看一下View#onRestoreInstanceState()方法:
protected void onRestoreInstanceState(Parcelable state) {
mPrivateFlags |= PFLAG_SAVE_STATE_CALLED;
if (state != null && !(state instanceof AbsSavedState)) {
throw new IllegalArgumentException("Wrong state class, expecting View State ");
}
if (state != null && state instanceof BaseSavedState) {
mStartActivityRequestWho = ((BaseSavedState) state).mStartActivityRequestWhoSaved;
}
}
这个方法很简单，直接获取mStartActivityRequestWho对象，对于自定义View，需要重写这个方法，获取自己的状态。同样看一下TextView#onRestoreInstanceState()方法:
public void onRestoreInstanceState(Parcelable state) {
if (!(state instanceof SavedState)) {
super.onRestoreInstanceState(state);
return;
}
SavedState ss = (SavedState)state;
super.onRestoreInstanceState(ss.getSuperState());
// XXX restore buffer type too, as well as lots of other stuff
if (ss.text != null) {
setText(ss.text);
}
if (ss.selStart >= 0 && ss.selEnd >= 0) {
if (mText instanceof Spannable) {
int len = mText.length();
if (ss.selStart > len || ss.selEnd > len) {
String restored = "";
if (ss.text != null) {
restored = "(restored) ";
}
Log.e(LOG_TAG, "Saved cursor position " + ss.selStart +
"/" + ss.selEnd + " out of range for " + restored +
"text " + mText);
} else {
Selection.setSelection((Spannable) mText, ss.selStart, ss.selEnd);
if (ss.frozenWithFocus) {
createEditorIfNeeded();
mEditor.mFrozenWithFocus = true;
}
}
}
}
if (ss.error != null) {
final CharSequence error = ss.error;
// Display the error later, after the first layout pass
post(new Runnable() {
public void run() {
if (mEditor == null || !mEditor.mErrorWasChanged) {
setError(error);
}
}
});
}
if (ss.editorState != null) {
createEditorIfNeeded();
mEditor.restoreInstanceState(ss.editorState);
}
}
首先判断state是否为TextView保存的状态，如果不是，直接调用super，然后获取对应的状态设置给TextView。
可以看出Restore过程和Save过程完全相同。