我们都知道ViewModel在配置更改的时候，可以保存数据而不被销毁，这是怎么做到的呢？今天我们来见证一下。
我们可以想一下，如果我们要自己实现数据在配置更改后，不会销毁，我们会怎么做，那首先我们肯定要知道配置更改的时机，然后把数据存储起来，然后重建后在把数据取出来。那我们如何知道配置更改了呢？系统已经提供了，在Activity中重写以下两个方法即可。
//配置更改时会调用该方法
override fun onRetainCustomNonConfigurationInstance(): Any? {
return super.onRetainCustomNonConfigurationInstance()
}
//获取配置
override fun getLastNonConfigurationInstance(): Any? {
return super.getLastNonConfigurationInstance()
}
明确了上面这个信息后，我们继续往下看，看源码最直接一种方式就是通过使用的api进行查看，我们先看下ViewModel的使用
//这是我们常用获取ViewModel的方式
ViewModelProvider(this).get(TestViewModel :: class.java)
public ViewModelProvider(@NonNull ViewModelStoreOwner owner) {
this(owner.getViewModelStore(), owner instanceof HasDefaultViewModelProviderFactory
? ((HasDefaultViewModelProviderFactory) owner).getDefaultViewModelProviderFactory()
: NewInstanceFactory.getInstance());
}
//最终调用到
public ViewModelProvider(@NonNull ViewModelStore store, @NonNull Factory factory) {
mFactory = factory;
//记住这个ViewModelStore类型变量
mViewModelStore = store;
}
//然后我们看get方法做了什么
public <T extends ViewModel> T get(@NonNull Class<T> modelClass) {
String canonicalName = modelClass.getCanonicalName();
if (canonicalName == null) {
throw new IllegalArgumentException("Local and anonymous classes can not be ViewModels");
}
//以name+DEFAULT_KEY和class对象作为参数，调用重载方法
return get(DEFAULT_KEY + ":" + canonicalName, modelClass);
}
public <T extends ViewModel> T get(@NonNull String key, @NonNull Class<T> modelClass) {
//这里先通过mViewModelStore去获取ViewModel对象
ViewModel viewModel = mViewModelStore.get(key);
//如果取到并且是同一类型对象直接返回
if (modelClass.isInstance(viewModel)) {
if (mFactory instanceof OnRequeryFactory) {
((OnRequeryFactory) mFactory).onRequery(viewModel);
}
return (T) viewModel;
} else {
//noinspection StatementWithEmptyBody
if (viewModel != null) {
// TODO: log a warning.
}
}
//这里通过反射创建ViewModel对象 具体细节就不看了
if (mFactory instanceof KeyedFactory) {
viewModel = ((KeyedFactory) mFactory).create(key, modelClass);
} else {
viewModel = mFactory.create(modelClass);
}
//存储到mViewModelStore
mViewModelStore.put(key, viewModel);
return (T) viewModel;
}
在上面的代码中，我们发现了ViewModel在创建后会被存储到mViewModelStore对象中，那么是不是数据可以恢复的秘密就在这里呢？答案是确实如此，下面我们看看具体是怎么恢复的。
首先我们看下ViewModelStore是个什么东东
public class ViewModelStore {
private final HashMap<String, ViewModel> mMap = new HashMap<>();
final void put(String key, ViewModel viewModel) {
ViewModel oldViewModel = mMap.put(key, viewModel);
if (oldViewModel != null) {
oldViewModel.onCleared();
}
}
final ViewModel get(String key) {
return mMap.get(key);
}
Set<String> keys() {
return new HashSet<>(mMap.keySet());
}
/**
* Clears internal storage and notifies ViewModels that they are no longer used.
*/
public final void clear() {
//循环遍历调用ViewModel的clear()
for (ViewModel vm : mMap.values()) {
vm.clear();
}
mMap.clear();
}
}
我们发现ViewModelStore其实就是HashMap，下面我们看下mViewModelStore是怎么获取到的。在上面的代码我们可以知道是mViewModelStore通过owner.getViewModelStore()获取的，而getViewModelStore其实调用的就是ComponentActivity的getViewModelStore()方法，下面我们看下代码
public ViewModelStore getViewModelStore() {
if (getApplication() == null) {
throw new IllegalStateException("Your activity is not yet attached to the "
+ "Application instance. You can't request ViewModel before onCreate call.");
}
ensureViewModelStore();
return mViewModelStore;
}
void ensureViewModelStore() {
if (mViewModelStore == null) {
//上面我们说过getLastNonConfigurationInstance是获取配置的方法
NonConfigurationInstances nc =
(NonConfigurationInstances) getLastNonConfigurationInstance();
//如果配置不为空，那么通过NonConfigurationInstances获取viewModelStore
if (nc != null) {
// Restore the ViewModelStore from NonConfigurationInstances
mViewModelStore = nc.viewModelStore;
}
//第一次的时候没有配置过肯定会走这里 直接进行创建
if (mViewModelStore == null) {
mViewModelStore = new ViewModelStore();
}
}
}
下面我们看下NonConfigurationInstances这个对象是个什么东东。
//ComponentActivity中声明的
static final class NonConfigurationInstances {
//我们自己在配置更改时存储数据使用
Object custom;
//找到你了吧
ViewModelStore viewModelStore;
}
我们已经找到了数据恢复的时机了，那么我们下面就要看看数据是何时存储的了，我们直接看onRetainCustomNonConfigurationInstance()方法，上面说过了这里是配置更改会调用的地方。
//ComponentActivity
public final Object onRetainNonConfigurationInstance() {
// 我们可以重写这个方法，在配置更改时，存储我们需要存储的数据
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对象，保存了viewModelStore
*通过getLastNonConfigurationInstance就可以获取到了
*/
NonConfigurationInstances nci = new NonConfigurationInstances();
nci.custom = custom;
nci.viewModelStore = viewModelStore;
return nci;
}
这里其实就已经保存好数据了，只不过时AMS通过binder调用保存的，这里不看具体的保存流程了，我们在看下getLastNonConfigurationInstance方法
//Activity中
@Nullable
public Object getLastNonConfigurationInstance() {
return mLastNonConfigurationInstances != null
? mLastNonConfigurationInstances.activity : null;
}
上面保存的时候其实就是保存到mLastNonConfigurationInstances这个对象中了
最后我们总结下整体的流程和思想：
主要是通过onRetainNonConfigurationInstance方法在配置更改时，保存viewModelStore到mLastNonConfigurationInstances对象，然后ViewModelProvider初始化的时候通过getLastNonConfigurationInstance()方法获取到了之前保存的mLastNonConfigurationInstances对象，mLastNonConfigurationInstances又持有着ViewModelStore，ViewModel又存储在ViewModelStore中，这样就达到了恢复数据的目的。
在上面我们看ViewModelStore的源码的时候有一个clear()方法，用来循环遍历调用ViewModel的clear()方法，在Activity销毁的时候，可以触发，我们可以在里面做一些回收资源的操作，那么clear()又是怎么被触发的呢？直接上代码
public ComponentActivity() {
...
getLifecycle().addObserver(new LifecycleEventObserver() {
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
if (event == Lifecycle.Event.ON_DESTROY) {
// Clear out the available context
mContextAwareHelper.clearAvailableContext();
// 如果不是配置更改，那么调用ViewModelStore的clear()
if (!isChangingConfigurations()) {
getViewModelStore().clear();
}
}
}
});
...
}
