Jetpack之SavedState的使用和源码解析

2021-05-01

SavedState组件是用于保存和恢复数据，替换onSaveInstanceState方法。我们的数据会因为Activity/Fragment被系统回收，屏幕旋转等导致丢失，除了常规的onSaveInstanceState中去保存以外，我们可以使用savedstate组件，他可以结合ViewModel，LiveData一起使用，比较的灵活简便。

使用

在Activity的ViewModel中，他是可以在屏幕旋转的时候自行恢复数据的，代码在ComponentActivity中，当屏幕旋转的时候会调用下面方法

public final Object onRetainNonConfigurationInstance() {
        // Maintain backward compatibility.
        Object custom = onRetainCustomNonConfigurationInstance();
        ViewModelStore viewModelStore = mViewModelStore;
        if (viewModelStore == null) {
            // No one called getViewModelStore(), so see if there was an existing
            // ViewModelStore from our last NonConfigurationInstance
            NonConfigurationInstances nc =
                    (NonConfigurationInstances) getLastNonConfigurationInstance();
            if (nc != null) {
                viewModelStore = nc.viewModelStore;
            }
        }
        if (viewModelStore == null && custom == null) {
            return null;
        }
        NonConfigurationInstances nci = new NonConfigurationInstances();
        nci.custom = custom;
        nci.viewModelStore = viewModelStore;
        return nci;
    }

就是配置发生了更改，viewModelStore会被保留下来。我们从ensureViewModelStore()方法判断ViewModelStore是否为空也可以看得出来，所以我们不需要处理这种情况。
对于系统资源限制导致Activity被销毁而言，假如是继承了HasDefaultViewModelProviderFactory的Activity或者是Fragment，我们可以直接使用ViewModelProvider(@NonNull ViewModelStoreOwner owner)构造方法获取ViewModelProvider对象即可，因为这类Activity/Fragment实现了getDefaultViewModelProviderFactory()方法，提供了SavedStateViewModelFactory实例的获取，他是SavedState组件的用于创建ViewModel的Factory。
对于需要使用SavedState组件的ViewModel的构造函数，它是有要求的：

要么是只有一个参数类型为SavedStateHandle
要么是由两个参数，第一个参数是Application类型，第二个是SavedStateHandle

二者的的区别就类似ViewModelProvider中的NewInstanceFactory和AndroidViewModelFactory，例如

class MyVM(val handle:SavedStateHandle) : ViewModel(){
}
//或者是
class MyVM(val app:Application,val handle:SavedStateHandle) : ViewModel(){
}

然后创建ViewModel

private var provider: ViewModelProvider? = null
  override fun onCreate(savedInstanceState: Bundle?) {
      super.onCreate(savedInstanceState)
      setContentView(R.layout.activity_aidl)
      provider = ViewModelProvider(this)
      val vm = provider?.get(MyVM::class.java)
  }

对于Activity而言，需要保存的数据是自身产生的数据，对于传递过来的Bundle则不需要另外通过SavedStateHandle进行保存而会自动的保存。可以看下面例子

class TestVM(val handle: SavedStateHandle) : ViewModel() {
    fun setData(msg: String) {
        //设置值，到时候假如该值被系统回收，那么他可以被恢复
        handle.set("MyDataKey", msg)
    }
    fun getData(): MutableLiveData<String> {
        //正常没有被回收则返回上一次设置的值，假如是被回收了则在没有调用上面方法的时候返回被回收前设置的最后一次值
        return handle.getLiveData("MyDataKey")
    }
}

class MainActivity3 : AppCompatActivity() {
    private var provider: ViewModelProvider? = null
    private lateinit var msg: String
    private lateinit var mVM: TestVM
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_aidl)
        //不用自动保存
        msg = intent.getStringExtra("msg") ?: ""
        provider = ViewModelProvider(this)
        mVM = provider?.get(TestVM::class.java)!!
    }
    fun save(v: View) {
        mVM.setData("testData")
    }
    fun get(v: View) {
        val data = mVM.getData().value
    }

}

关于MutableLiveData这个后续再说，先知道他是一个可以观测生命周期的组件，用于异步通知而又不会造成内存泄漏。

流程分析

以我们的ComponentActivity为例子

首先，我们的ComponentActivity提供了SavedStateRegistryController对象的获取，该对象会在onCreate和onSaveInstanceState被调用

public class ComponentActivity implement SavedStateRegistryOwner{
    //默认为成员变量
 final SavedStateRegistryController mSavedStateRegistryController =
            SavedStateRegistryController.create(this);
//
@Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        ...
        mSavedStateRegistryController.performRestore(savedInstanceState);
        ...
    }

@CallSuper
    @Override
    protected void onSaveInstanceState(@NonNull Bundle outState) {
       ...
        mSavedStateRegistryController.performSave(outState);
       ...
    }
    //还提供了获取SavedStateRegistry对象的方法，通过该方法可以调用他的registerSavedStateProvider(@NonNull String key,@NonNull SavedStateProvider provider)方法定义需要避免丢失的数据，ViewModel也是如此的。
public final SavedStateRegistry getSavedStateRegistry() {
        return mSavedStateRegistryController.getSavedStateRegistry();
    }
    ...
}

我们就先从数据如何保存开始看源码，当我们的Activity被系统杀死回收的时候，调用了performSave(outState)

//SavedStateRegistryController的保存数据方法
@MainThread
    public void performSave(@NonNull Bundle outBundle) {
        mRegistry.performSave(outBundle);
    }

可以看他调用了自己本身的变量mRegistry的performSave，mRegistry是SavedStateRegistry类对象，我们继续看下去

    //SavedStateRegistry的方法
@MainThread
    void performSave(@NonNull Bundle outBundle) {
        Bundle components = new Bundle();
        //假如存在上一次恢复的数据，则把上一次恢复的存在的添加进去
        //mRestoredState的值如何来后面再说
        if (mRestoredState != null) {
            components.putAll(mRestoredState);
        }
        //把所有注册到了SavedStateRegistry的SavedStateProvider的saveState()调用一次
        //即把所有需要保存的Bundle通过outBundle保存起来
        for (Iterator<Map.Entry<String, SavedStateProvider>> it =
                mComponents.iteratorWithAdditions(); it.hasNext(); ) {
            Map.Entry<String, SavedStateProvider> entry1 = it.next();
            components.putBundle(entry1.getKey(), entry1.getValue().saveState());
        }
        //把所有需要存储的数据存放到SAVED_COMPONENTS_KEY作为key的bundle里面
        outBundle.putBundle(SAVED_COMPONENTS_KEY, components);
    }

经过这样就完成了数据保存，也就是把所有注册到SavedStateRegistry的SavedStateProvider返回的Bundle进行保存，同时假如存在上一次恢复的数据，那么也保存。

接下来我们看看数据的恢复操作

    //SavedStateRegistryController中的方法
public void performRestore(@Nullable Bundle savedState) {
        //mOwner为构造函数传入的SavedStateRegistryOwner对象
        Lifecycle lifecycle = mOwner.getLifecycle();
        if (lifecycle.getCurrentState() != Lifecycle.State.INITIALIZED) {
            throw new IllegalStateException("Restarter must be created only during "
                    + "owner's initialization stage");
        }
         //添加一个Recreator对象到生命周期观测中
        lifecycle.addObserver(new Recreator(mOwner));
        //然后对数据进行恢复
        mRegistry.performRestore(lifecycle, savedState);
    }

然后我们看看Recreator在在观测到的生命周期干了什么

   //Recreator.java
@Override
   public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
       if (event != Lifecycle.Event.ON_CREATE) {
           throw new AssertionError("Next event must be ON_CREATE");
       }
         //只观测oncreate，即只会被调用一次
       source.getLifecycle().removeObserver(this);
       //获取COMPONENT_KEY作为key对应的缓存数据
       Bundle bundle = mOwner.getSavedStateRegistry()
               .consumeRestoredStateForKey(COMPONENT_KEY);
       if (bundle == null) {
           return;
       }
       ArrayList<String> classes = bundle.getStringArrayList(CLASSES_KEY);
         ...
       for (String className : classes) {
          //主要的逻辑是通过发生生成className对象的对象
          //这个类应该是AutoRecreated，然后会调用他的onRecreated方法，这个方法后续再说
           reflectiveNew(className);
       }
   }

其中，Recreator的SavedStateProvider(即需要缓存那些类)的定义是

static final class SavedStateProvider implements SavedStateRegistry.SavedStateProvider {
        final Set<String> mClasses = new HashSet<>();
        SavedStateProvider(final SavedStateRegistry registry) {
            registry.registerSavedStateProvider(COMPONENT_KEY, this);
        }
        public Bundle saveState() {
            //Activity被系统回收之前会先调用这里把这个Bundle也缓存起来
            //他缓存的是类的全名称，
            Bundle bundle = new Bundle();
            bundle.putStringArrayList(CLASSES_KEY, new ArrayList<>(mClasses));
            return bundle;
        }
        //通过调用这个方法存入mClasses，当恢复数据的时候回通过反射实例化这个类并调用他的onRecreated方法
        //这个类是必须实现了接口AutoRecreated的，并且它有一个空构造函数
        void add(String className) {
            mClasses.add(className);
        }
    }

在performRestore中执行完了lifecycle.addObserver(new Recreator(mOwner));之后，他会调用mRegistry.performRestore(lifecycle, savedState);，我们看下他的具体处理逻辑

@MainThread
    void performRestore(@NonNull Lifecycle lifecycle, @Nullable Bundle savedState) {
        if (mRestored) {
            //已经恢复过了
            throw new IllegalStateException("SavedStateRegistry was already restored.");
        }
        //如果待恢复的数据不为空，则取出SAVED_COMPONENTS_KEY作为key的bundle
        if (savedState != null) {
            mRestoredState = savedState.getBundle(SAVED_COMPONENTS_KEY);
        }
        lifecycle.addObserver(new GenericLifecycleObserver() {
            @Override
            public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
                if (event == Lifecycle.Event.ON_START) {
                    //它的作用后续在手
                    mAllowingSavingState = true;
                } else if (event == Lifecycle.Event.ON_STOP) {
                    mAllowingSavingState = false;
                }
            }
        });
        //表示恢复过了
        mRestored = true;
    }

SavedStateRegistry还有一个比较重要的方法，就是数据恢复以后外部如何获取，它提供了一个consumeRestoredStateForKey方法

@MainThread
    @Nullable
    public Bundle consumeRestoredStateForKey(@NonNull String key) {
        if (!mRestored) {
            throw new IllegalStateException("You can consumeRestoredStateForKey "
                    + "only after super.onCreate of corresponding component");
        }
        //假如存在数据则看下key对应的Bundle是否存在
        if (mRestoredState != null) {
            Bundle result = mRestoredState.getBundle(key);
            mRestoredState.remove(key);
            if (mRestoredState.isEmpty()) {
                mRestoredState = null;
            }
            return result;
        }
        return null;
    }

上面就是一个大概的数据保存和恢复的过程，接下来我们看ViewModel如何利用这套实现数据的保存和恢复的，我们先看SavedStateViewModelFactory的create方法，看看他如何创建的ViewModel

public <T extends ViewModel> T create(@NonNull String key, @NonNull Class<T> modelClass) {
        //判断是否是AndroidViewModel的子类
        boolean isAndroidViewModel = AndroidViewModel.class.isAssignableFrom(modelClass);
        Constructor<T> constructor;
        if (isAndroidViewModel) {
            //他的构造函数是否是(application,SavedStateHandle)
            constructor = findMatchingConstructor(modelClass, ANDROID_VIEWMODEL_SIGNATURE);
        } else {
           //他的构造函数是否是(SavedStateHandle)
            constructor = findMatchingConstructor(modelClass, VIEWMODEL_SIGNATURE);
        }
        //当他的构造方法都不适配的时候，使用默认的mFactory去创建该ViewModel对象
        if (constructor == null) {
            return mFactory.create(modelClass);
        }
        //创建SavedStateHandleController，并且把生命周期组件获取而来的mSavedStateRegistry对象存入进去
        //调用SavedStateHandleController的create方法，同时把自己的key值，bundle参数传入
        SavedStateHandleController controller = SavedStateHandleController.create(
                mSavedStateRegistry, mLifecycle, key, mDefaultArgs);
        try {
            T viewmodel;
            if (isAndroidViewModel) {
                viewmodel = constructor.newInstance(mApplication, controller.getHandle());
            } else {
                viewmodel = constructor.newInstance(controller.getHandle());
            }
            //把SavedStateHandleController存入到ViewModel的mBagOfTags中
            viewmodel.setTagIfAbsent(TAG_SAVED_STATE_HANDLE_CONTROLLER, controller);
            return viewmodel;
        } 
        ...
    }

然后我们看SavedStateHandleController的create方法

    //SavedStateHandleController
static SavedStateHandleController create(SavedStateRegistry registry, Lifecycle lifecycle,
            String key, Bundle defaultArgs) {
        //假如之前存在缓存，则从registry里面获取，关于如何存我们后面再说
        Bundle restoredState = registry.consumeRestoredStateForKey(key);
        //生成SavedStateHandle类，并且把SavedStateRegistry对象放到SavedStateHandle中
        //把恢复的数据和默认的数据存入
        SavedStateHandle handle = SavedStateHandle.createHandle(restoredState, defaultArgs);
        //创建SavedStateHandleController并且调用attachToLifecycle
        SavedStateHandleController controller = new SavedStateHandleController(key, handle);
        controller.attachToLifecycle(registry, lifecycle);
        tryToAddRecreator(registry, lifecycle);
        return controller;
    }

在SavedStateHandleController的attachToLifecycle中，把SavedStateHandle的需要保存的数据注册到了SavedStateRegistry中

void attachToLifecycle(SavedStateRegistry registry, Lifecycle lifecycle) {
        if (mIsAttached) {
            throw new IllegalStateException("Already attached to lifecycleOwner");
        }
        mIsAttached = true;
        lifecycle.addObserver(this);
        //也就是这一句
        registry.registerSavedStateProvider(mKey, mHandle.savedStateProvider());
    }

最后，我们看我们会在ViewModel中使用到的类SavedStateHandle，他的作用是我们可以在ViewModel中取出数据，假如该数据被系统回收了，他能去到最后一次设置的值。他的成员变量有下面这些：

mRegular，存储数据的键值对，包括设置进来的数据还是恢复回来的数据都会存入这个集合，同时该集合会在被系统回收的时候存入outBundle中
mLiveDatas，一个用于缓存LiveData的键值对，只是缓存内存数据
mSavedStateProvider，定义了mRegular在被系统回收的时候如何生成一个Bundle被保存下来

接下来看SavedStateHandle的具体解析，他是通过自身的create创建的对象

static SavedStateHandle createHandle(@Nullable Bundle restoredState,
            @Nullable Bundle defaultState) {
        //假如没有默认数据，则mRegular
        if (restoredState == null && defaultState == null) {
            return new SavedStateHandle();
        }
        Map<String, Object> state = new HashMap<>();
        if (defaultState != null) {
            //把默认的值存入
            for (String key : defaultState.keySet()) {
                state.put(key, defaultState.get(key));
            }
        }

        if (restoredState == null) {
            return new SavedStateHandle(state);
        }
        //把缓存的KEYS和VALUES取出
        ArrayList keys = restoredState.getParcelableArrayList(KEYS);
        ArrayList values = restoredState.getParcelableArrayList(VALUES);
        if (keys == null || values == null || keys.size() != values.size()) {
            throw new IllegalStateException("Invalid bundle passed as restored state");
        }
        for (int i = 0; i < keys.size(); i++) {
            state.put((String) keys.get(i), values.get(i));
        }
        return new SavedStateHandle(state);
    }

从上面看出，在生成SavedStateHandle的同时也会把无论是默认数据还是恢复的数据存入mRegular之中，其中被系统回收的时候，mRegular被存入的方式是

private final SavedStateProvider mSavedStateProvider = new SavedStateProvider() {
       @NonNull
       @Override
       public Bundle saveState() {
          //读取键值对的keys和values
           Set<String> keySet = mRegular.keySet();
           ArrayList keys = new ArrayList(keySet.size());
           ArrayList value = new ArrayList(keys.size());
           for (String key : keySet) {
               keys.add(key);
               value.add(mRegular.get(key));
           }
            //生成一个bundle
           Bundle res = new Bundle();
           // "parcelable" arraylists - lol
           res.putParcelableArrayList("keys", keys);
           res.putParcelableArrayList("values", value);
           return res;
       }
   };

上面就是SavedStateHandle的数据的存入和恢复的过程，他还会被ViewModel使用和写入的过程，我们看下他是如何做的

MutableLiveData<T> getLiveData(@NonNull String key)// 他间距调用了getLiveDataInternal
MutableLiveData<T> getLiveData(@NonNull String key, T initialValue)// 他间距调用了getLiveDataInternal
//获取key对应的value，同时把value包装成一个LiveData
private <T> MutableLiveData<T> getLiveDataInternal(
            @NonNull String key,
            boolean hasInitialValue,
            @Nullable T initialValue) {
        MutableLiveData<T> liveData = (MutableLiveData<T>) mLiveDatas.get(key);
        if (liveData != null) {
            //先读取缓存
            return liveData;
        }
        //SavingStateLiveData比较简单，他只是对MultiLiveData包装了一下
        SavingStateLiveData<T> mutableLd;
        // double hashing but null is valid value
        if (mRegular.containsKey(key)) {
            mutableLd = new SavingStateLiveData<>(this, key, (T) mRegular.get(key));
        } else if (hasInitialValue) {
            mutableLd = new SavingStateLiveData<>(this, key, initialValue);
        } else {
            mutableLd = new SavingStateLiveData<>(this, key);
        }
        //缓存起来
        mLiveDatas.put(key, mutableLd);
        return mutableLd;
    }

当然，假如我们不想要包裹着Value的LiveData，可以直接他的 <T> T get(String key)方法，假如需要移除则使用他的<T> T remove(String key)方法，判断是否存在则使用boolean contains(String key)方法，更新数据则使用<T> void set(@NonNull String key, @Nullable T value)

到这里，与SavedState组件结合ViewModel的整个过程基本就结束了。

整体总结

其实经过上面的流程，我们可以发现，lifecycle-viewmodel-savedstate组件和savedstate组件是两个不同的作用。后者实现了一套无侵入式存储和恢复数据的方式，而前者则是利用这一套实现了ViewModel中的数据的恢复和存储。

经过上面的流程分析，我们也大概知道了整体的实现过程，我们先列举各个类的大概作用
savedstate组件的：

SavedStateRegistryController，负责提供SavedStateRegistry对象和间接调用SavedStateRegistry的方法
SavedStateRegistryOwner，负责外部获取SavedStateRegistry对象，同时，他自己也是继承了LifecycleOwner的
SavedStateRegistry，负责数据的保存和恢复
AutoRecreated，提供了一个接口调用他的onRecreated(SavedStateRegistryOwner owner)，他只会在生命周期的onCreate被执行，OnRecreation继承它用于判断SavedStateHandleController时候需要重新attached
SavedStateProvider，是SavedStateRegistry定义的内部接口，试下该接口并把该接口注入到SavedStateRegistry中即可实现数据保存和恢复

lifecycle-viewmodel-savedstate组件的

SaveStateViewModelFactory，定义生成ViewModel对象的规则，同时创建SavedStateHandleController对象
SavedStateHandleController，负责管理SavedHandle对象
SavedStateHandle，他负责与ViewModel进行交互，存储和恢复ViewModel中使用该Handle存取的数据
OnRecreation，用于判断SavedStateHandleController是否需要重新attached，同时假如ViewModelProvider存在key数据则把他注入到可恢复数据中。

关于key值的问题：我们通过SavedStateProvider缓存的Bundle，它本身也是存储在Bundle中的，多个SavedStateProvider中的Bundle假如他们内部的Key一致，但是存入到总的Bundle的key不一致是没有冲突的。比如Recreator中存入SavedStateRegistry的总Bundle，即mComponents对象的key值是androidx.savedstate.Restarter，其他存入总Bundle的单个Bundle，他的key值不是androidx.savedstate.Restarter即可，它内部的key值不会与外部的冲突。

关于ViewModel的创建的的问题：SavedStateViewModelFactor是继承自KeyedFactory的，它的create()方法会多一个key参数，key的值是我们调用ViewModelProvider的get()方法传入的，不传则是DEFAULT_KEY + ":" + canonicalName，同时，改key值是作为存入总Bundle的key值，标识着ViewModel被保存的Bundle。

OnRequeryFactory的问题，首先它是定义在ViewModelProvider中的一个接口，在调用ViewModelProvider的get方法获取ViewModel的时候，假如已经存在了该ViewModel对象同时如果该Factory是实现了OnRequeryFactory接口，则会调用它的onRequery方法。我们的SavedStateViewModelFactory就实现了OnRequeryFactory接口，在onRequery方法中，做了如下的处理

void onRequery(@NonNull ViewModel viewModel) {
        attachHandleIfNeeded(viewModel, mSavedStateRegistry, mLifecycle);
    }
 static void attachHandleIfNeeded(ViewModel viewModel, SavedStateRegistry registry,
            Lifecycle lifecycle) {
        //controller是在ViewModel创建的时候就存入了ViewModel的mBagOfTags中了
        SavedStateHandleController controller = viewModel.getTag(
                TAG_SAVED_STATE_HANDLE_CONTROLLER);
        if (controller != null && !controller.isAttached()) {
            //判断时候是否绑定过，没有则重新绑定
            controller.attachToLifecycle(registry, lifecycle);
            tryToAddRecreator(registry, lifecycle);
        }
    }

他针对的情况是比如屏幕旋转，Activity的生命周期重新走了一次，ViewModel并没有被销毁，获取ViewModel的时候SavedStateViewModelFactory的create方法不会被调用，只会执行onRequery，这时候我们需要把SavedStateHandleController重新attached到生命周期组件中，这就是他的作用。