前些天，有位小伙伴兴匆匆地跑过来给我展示一个现象：Activity 里有个EditText，点击该EditText 输入一些文字。此时，转动手机方向，Activity 变成横屏了，而EditText 上的文字依然保留。

问我：为啥EditText上文字能够恢复？

我说：你Activity 配置了横竖屏切换时不重建Activity。

他立马给我展示了：Activity 重建的日志。

我说：系统会在重建Activity 的时候恢复整个ViewTree吧。

他又给我展示了：ImageView 横竖屏时没有恢复之前的图像。

我：...

不服输的我开始了默默地研究，于是有了这篇总结以解心中困惑。

通过本篇文章，你将了解到:

1、onSaveInstanceState/onRestoreInstanceState 作用。

2、onSaveInstanceState/onRestoreInstanceState 原理分析

3、onSaveInstanceState/onRestoreInstanceState 触发场景。

4、onSaveInstanceState/onRestoreInstanceState 为啥不能存放大数据？

5、与Jetpack ViewModel 区别。

1、onSaveInstanceState/onRestoreInstanceState 作用

EditText/ImageView 横竖屏地表现

#View.java

    protected Parcelable onSaveInstanceState() {...}


    protected void onRestoreInstanceState(Parcelable state){...}

官方注释上写的比较清楚了：

1、onSaveInstanceState 是个钩子方法，View.java 的子类可以重写该方法，在方法里面存储一些子类的内部状态，用以下次重建时恢复。

2、onRestoreInstanceState 也是个钩子方法，用以恢复在onSaveInstanceState 里保存的状态。

既然是View的方法，分别查看EditText 与ImageView 对它们的重写情况：

#TextView.java

    public Parcelable onSaveInstanceState() {

        Parcelable superState = super.onSaveInstanceState();

        ...

        if (freezesText || hasSelection) {

            SavedState ss = new SavedState(superState);


            if (freezesText) {

                if (mText instanceof Spanned) {

                    final Spannable sp = new SpannableStringBuilder(mText);

                    ...

                    ss.text = sp;

                } else {

                    //将TextView 内容存储在SavedState里

                    ss.text = mText.toString();

                }

            }

            ...

            return ss;

        }


        //返回存储的对象

        return superState;

    }


    public void onRestoreInstanceState(Parcelable state) {

        if (!(state instanceof SavedState)) {

            super.onRestoreInstanceState(state);

            return;

        }


        SavedState ss = (SavedState) state;

        super.onRestoreInstanceState(ss.getSuperState());


        if (ss.text != null) {

            //取出TextView 内容，并设置

            setText(ss.text);

        }

        ...

    }

由此可见，TextView 重写这俩方法，先是在onSaveInstanceState 里存储文本内容，再在onRestoreInstanceState 里恢复文本内容。

而通过查看ImageView 发现它并没有重写这俩方法，当然就不能恢复了。其实这也比较容易理解，毕竟对于ImageView，Bitmap 是它的内容，暂存这个Bitmap 很耗内存。

需要注意的是：想要onSaveInstanceState 被调用，则需要给该控件设置id。因为系统是根据View id将状态存储在SparseArray 里

Activity 横竖屏的处理

现在的问题是：谁调用了View 的onSaveInstanceState/onRestoreInstanceState ? 在前一篇分析过Activity 和View的关系：Android Activity 与View 的互动思考

可知，Activity 通过Window 控制View，我们子类继承自EditText，并重写 onSaveInstanceState/onRestoreInstanceState，然后在横竖屏切换时查看这俩方法的调用栈：

#Activity.java

    protected void onSaveInstanceState(@NonNull Bundle outState) {

        //saveHierarchyState 调用整个ViewTree 的onSaveInstanceState 方法

        outState.putBundle(WINDOW_HIERARCHY_TAG, mWindow.saveHierarchyState());

        ...

        //告知生命周期回调方法状态已保存

        dispatchActivitySaveInstanceState(outState);

    }

同样的对于onRestoreInstanceState：

#Activity.java

    protected void onRestoreInstanceState(@NonNull Bundle savedInstanceState) {

        if (mWindow != null) {

            Bundle windowState = savedInstanceState.getBundle(WINDOW_HIERARCHY_TAG);

            if (windowState != null) {

                //恢复整个ViewTree 状态

                mWindow.restoreHierarchyState(windowState);

            }

        }

    }

当横竖屏切换时，会调用到Activity onSaveInstanceState/onRestoreInstanceState 方法，进而会调用整个ViewTree onSaveInstanceState/onRestoreInstanceState 方法来保存与恢复必要的状态。

Activity 数据保存与恢复

Activity 的onSaveInstanceState/onRestoreInstanceState 方法 除了触发View 的状态保存与恢复外，还可以将Activity 用到的一些重要的数据保存下来，待下次Activity 重建时恢复。

重写两者：

    @Override

    protected void onSaveInstanceState(Bundle outState) {

        super.onSaveInstanceState(outState);

        outState.putString("say", "hello world");

    }


    @Override

    protected void onRestoreInstanceState(Bundle savedInstanceState) {

        super.onRestoreInstanceState(savedInstanceState);

        String restore = savedInstanceState.getString("say");

        Log.d("fish", restore);

    }

此时我们注意到onSaveInstanceState 的入参是Bundle 类型，往outState 写入数据，在onRestoreInstanceState 将数据取出，outState/savedInstanceState 必然不为空。

总结 onSaveInstanceState/onRestoreInstanceState 作用

1、保存与恢复View 的状态。

2、保存与恢复Activity 自定义数据。

2、onSaveInstanceState/onRestoreInstanceState 原理分析。

onSaveInstanceState 调用时机

之前 Android Activity 生命周期详解及监听 有详细分析了Activity 各个阶段的调用情况，现在结合生命周期来分析onSaveInstanceState(xx)在生命周期中的哪个阶段被调用的。

调用栈如下：

看看上图标黄色的方法，这方法很眼熟，在Activity 生命周期中分析过，它是Activity.onStop()方法的调用者：

#ActivityThread.java

    private void callActivityOnStop(ActivityClientRecord r, boolean saveState, String reason) {

        // Before P onSaveInstanceState was called before onStop, starting with P it's

        // called after. Before Honeycomb state was always saved before onPause.

        //这句话翻译过来：

        //如果目标设备是Android 9之前，那么onSaveInstanceState 在onStop 之前调用

        //如果在Android 9 之后，那么onSaveInstanceState 在onStop 之后调用

        //Honeycomb 指的是Android 3.0 现在基本可以忽略了。

        //r.activity.mFinished 表示Activity 是否即将被销毁

        final boolean shouldSaveState = saveState && !r.activity.mFinished && r.state == null

                && !r.isPreHoneycomb();

        final boolean isPreP = r.isPreP();

        //Android p 之前先于onStop 之前执行

        if (shouldSaveState && isPreP) {

            callActivityOnSaveInstanceState(r);

        }

        try {

            //最终执行到Activity.onStop()方法

            r.activity.performStop(r.mPreserveWindow, reason);

        } catch (SuperNotCalledException e) {

            ...

        }

        //标记Stop状态

        r.setState(ON_STOP);


        if (shouldSaveState && !isPreP) {

            //调用onSave 保存

            callActivityOnSaveInstanceState(r);

        }

    }

以上注释比较详细了，小结一下：

1、在Android 9之前，onSaveInstanceState 在onStop 之前调用（至于在onPause 之前还是之后调用，这个时机不确定)；在Android 9(包含)之后，onSaveInstanceState 在onStop 之后调用。

2、如果Activity 即将被销毁，则onSaveInstanceState 不会被调用。

对于第二句的理解，举个简单例子：

Activity 在前台时，此时按Home键回到桌面，会执行onSaveInstanceState；若是按back键/主动finish，此时虽然会执行到onStop，但是不会执行onSaveInstanceState。

onRestoreInstanceState 调用时机

现在已经弄清楚onSaveInstanceState 调用时机，接着来分析 onRestoreInstanceState 什么时候执行。

调用栈如下：

    public void handleStartActivity(ActivityClientRecord r,

                                    PendingTransactionActions pendingActions) {

        final Activity activity = r.activity;

        ...

        //最终执行到Activity.onStart()

        activity.performStart("handleStartActivity");

        r.setState(ON_START);

        ...

        if (pendingActions.shouldRestoreInstanceState()) {

            if (r.isPersistable()) {

                //从持久化存储里恢复数据

                if (r.state != null || r.persistentState != null) {

                    mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state,

                            r.persistentState);

                }

            } else if (r.state != null) {

                //从内存里恢复数据

                mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);

            }

        }

        ...

    }

小结：

1、onRestoreInstanceState 在onStart()方法之后执行。

2、pendingActions.shouldRestoreInstanceState() 返回值是执行 onRestoreInstanceState()方法的关键，它是在哪赋值的呢？接下来会分析。

3、r.state 不能为空，毕竟没数据无法恢复。

通过以上分析，结合Activity生命周期，onSaveInstanceState /onRestoreInstanceState 调用时机如下：

onRestoreInstanceState 与onCreate 参数差异

onCreate参数也是Bundle类型，实际上这个参数就是onSaveInstanceState里保存的Bundle，这个Bundle分别传递给了onCreate和onRestoreInstanceState，而onCreate里的Bundle可能为空(新建非重建的情况下)，onRestoreInstanceState 里的Bundle必然不为空。

官方注释也说了在onRestoreInstanceState里处理数据的恢复更灵活。

3、onSaveInstanceState/onRestoreInstanceState 触发场景

横竖屏触发的场景

在前面的分析中，与Activity 生命周期关联可能会让人有种印象：

onSaveInstanceState 调用之后onRestoreInstanceState 就会被调用。

而事实并非如此，举个简单例子：

Activity 处在前台时，此时退回到桌面，onSaveInstanceState 会被执行。而后再让Activity 回到前台，onStart()方法执行后，发现onRestoreInstanceState 并没有被调用。

也就是说onSaveInstanceState/onRestoreInstanceState 的调用不一定是成对出现的。

还记得在分析onRestoreInstanceState 遗留了个问题： pendingActions.shouldRestoreInstanceState() 返回值如何确定的 ？

在横竖屏切换时，onRestoreInstanceState 被调用了，说明 pendingActions.shouldRestoreInstanceState() 在横竖屏切换时返回了true，接着来看看其来龙去脉：

#PendingTransactionActions.java

    //判断是否需要执行onRestoreInstanceState 方法

    public boolean shouldRestoreInstanceState() {

        return mRestoreInstanceState;

    }


    //设置标记

    public void setRestoreInstanceState(boolean restoreInstanceState) {

        mRestoreInstanceState = restoreInstanceState;

    }

只需要找到setRestoreInstanceState()在何处调用即可。

直接说结论：

ActivityThread.handleLaunchActivity() 里设置了setRestoreInstanceState(true)

而handleLaunchActivity()在两种情况下被调用：

横竖屏时属于重建 Activity，因此onRestoreInstanceState 能被调用。

而从后台返回到前台，并没有新建Activity也没有重建Activity，因此onRestoreInstanceState 不会被调用。

又引申出另一个问题：为啥新建Activity 时onRestoreInstanceState 没被调用？

答案：因为新建Activity 时，ActivityClientRecord 是全新的对象，它所持有的Bundle state 对象为空，因此不会调用到onRestoreInstanceState。

其它配置项更改的场景

除了横竖屏切换时会重建Activity，还有以下配置项更改会重建Activity：

重建Activity 的细节

当需要重建Activity 时，AMS 发出指令，会执行到 ActivityThread.handleRelaunchActivity()方法。

#ActivityThread.java

    public void handleRelaunchActivity(ActivityClientRecord tmp,

                                       PendingTransactionActions pendingActions) {

        ...

        //从Map 里获取缓存的ActivityClientRecord

        ActivityClientRecord r = mActivities.get(tmp.token);

        ...

        //将ActivityClientRecord 传递下去

        handleRelaunchActivityInner(r, configChanges, tmp.pendingResults, tmp.pendingIntents,

                pendingActions, tmp.startsNotResumed, tmp.overrideConfig, "handleRelaunchActivity");

        ...

    }

mActivities 定义如下：

final ArrayMap<IBinder, ActivityClientRecord> mActivities = new ArrayMap<>();

以IBinder 为key，存储ActivityClientRecord。

当新建Activity 时，存入ActivityClientRecord，当销毁Activity 时，移除 ActivityClientRecord。

再来分析handleRelaunchActivityInner()：

#ActivityThread.java

    private void handleRelaunchActivityInner(...) {

        ...

        if (!r.paused) {

            //最终执行到onPause

            performPauseActivity(r, false, reason, null /* pendingActions */);

        }

        if (!r.stopped) {

            //最终执行到onStop

            callActivityOnStop(r, true /* saveState */, reason);

        }

        //最终执行到onDestroy

        handleDestroyActivity(r.token, false, configChanges, true, reason);

        //创建新的Activity 实例

        handleLaunchActivity(r, pendingActions, customIntent);

    }

通过分析Activity 重建的细节，有以下结论：

1、Activity 重建过程中，先将原来的Activity 进行销毁（从onResume--onStop-->onDestroy 的生命周期)。

2、虽然是不同的Activity 对象，但重建时使用的ActivityClientRecord 却是相同的，而ActivityClientRecord 最终是被ActivityThread 持有，它是全局的。这也是 onSaveInstanceState/onRestoreInstanceState 能够存储与恢复数据的本质原因。

当然也可以通过配置告诉系统在配置项变更时不重建Activity：

<activity android:name=".viewmodel.ViewModelActivity" android:configChanges="orientation|screenSize"></activity>

比如以上配置，当横竖屏切换时，不会重建Activity，而配置项的变更会通过 Activity.onConfigurationChanged()方法回调。

4、onSaveInstanceState/onRestoreInstanceState 为啥不能存放大数据？

onSaveInstanceState/onRestoreInstanceState 的参数都是Bundle 类型，思考一下为什么需要定义为Bundle类型呢？

在 Android IPC 精讲系列 中有提到过，Android 进程间通信方式大多时候使用的是Binder，而要想自定义数据能够通过Binder传输则需要实现Parcelable 接口，Bundle 实现了Parcelable 接口。

由此我们推测，onSaveInstanceState/onRestoreInstanceState 可能涉及到进程间通信，才会用Bundle 来修饰形参。但之前说的ActivityClientRecord是存储在当前进程的啊，貌似和其它进程没有关联呢？

要分析这个问题，实际上只需要在onSaveInstanceState 存储一个比较大的数据，看看报错时的堆栈。

    protected void onSaveInstanceState(Bundle outState) {

        super.onSaveInstanceState(outState);

        outState.putString("say", "hello world");

        //存储2M 数据

        outState.putByteArray("big", new byte[1024*1024*2]);

    }

保存2M 的数据，通常来说这是超出了Binder的限制，当调用onSaveInstanceState 时会有报错信息：

#PendingTransactionActions.java

    public void run() {

        try {

            //提交给ActivityTaskManagerService 处理，属于进程间通信

            //mState 即是onSaveInstanceState 保存的数据

            ActivityTaskManager.getService().activityStopped(

                    mActivity.token, mState, mPersistentState, mDescription);

        } catch (RemoteException ex) {

            ...

        }

    }

而在ActivityThread.java 里有个方法：

    public void reportStop(PendingTransactionActions pendingActions) {

        mH.post(pendingActions.getStopInfo());

    }

该方法用于告知系统，咱们的Activity 已经变为Stop状态了，最终会执行到PendingTransactionActions.run()方法。

小结一下：

onSaveInstanceState 存储的数据，在onStop执行后，当前进程需要将Stop状态传递给ATM(ActivityTaskManagerService 运行在system_server进程)，因为跨进程传递(Binder)有大小限制，因此onSaveInstanceState 不能传递大量数据。

5、与Jetpack ViewModel 区别

onSaveInstanceState 与 ViewModel 都是将数据放在ActivityClientRecord 的不同字段里。

1、onSaveInstanceState 用Bundle存储数据便于跨进程传递，而ViewModel 是Object存储数据，不需要跨进程，因此它没有大小限制。

2、onSaveInstanceState 在onStop 之后调用，比较频繁。而ViewModel 存储数据是onDestroy 之后。

3、onSaveInstanceState 可以选择是否持久化数据到文件里（该功能由ATM 实现，存储到xml里），而ViewModel 没有这功能。

更多的区别后续分析 ViewModel 时会提到。

本文基于Android 10.0。