一、前言
关于Android Jetpack是什么不在赘述，不了解的同学可以看看Android架构木木的这篇文章Android Jetpack让Android一飞冲天。
此文章为Android Jetpack系列文章，内容如下：
Android Jetpack之ViewModel使用及源码分析
Android Jetpack之Lifecycle使用及源码分析
未完待续。。。。。。
二、使用ViewModel意义
使用ViewModel的意义在于，当我们在Activity中创建ViewModel对象时，即使Activity销毁了，ViewModel对象还是存在的，这样就能在页面恢复时拿到ViewModel对象中之前的数据重新渲染页面。所以我们通常会将ViewModel和LiveData结合起来使用，LiveData在本文暂时不做介绍。
我们来看看以下两个场景。
场景一：当用户正在界面输入表单时，因为某种原因导致界面重建了，用户输入的信息全都没有了，需要再次输入。当然了有些原生控件其实已经自己实现了通过onSaveInstanceState恢复数据，如果内部没有实现，则需要考虑使用onSaveInstanceState，但是onSaveInstanceState通常用来恢复可以序列化的少量数据。
场景二：应用首页有一个列表，某种原因导致界面重建了，界面可能一片空白。通常我们会做一些处理，比如重新调用接口或者加载本地缓存。
针对以上两个场景，如果将数据保存在ViewModel中，我们可以直接获取到来重新渲染页面。
三、使用方法
1、首先创建一个ViewModel类
package com.example.viewmoel;
import androidx.lifecycle.MutableLiveData;
import androidx.lifecycle.ViewModel;
public class TestViewModel extends ViewModel {
//存储一个字符串
private MutableLiveData<String> liveData = new MutableLiveData<>();
public MutableLiveData<String> getLiveData() {
return liveData;
}
//改变字符串的值
public void setLiveData(String arg){
liveData.setValue(arg);
}
}
2、在实际要使用的界面使用
package com.example.test;
import androidx.appcompat.app.AppCompatActivity;
import androidx.lifecycle.Observer;
import androidx.lifecycle.ViewModelProvider;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import com.example.test.databinding.ActivityMainBinding;
import com.example.viewmoel.TestViewModel;
public class MainActivity extends AppCompatActivity {
private TestViewModel viewModel;
private ActivityMainBinding viewBinding;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
viewBinding = ActivityMainBinding.inflate(LayoutInflater.from(this));
setContentView(viewBinding.getRoot());
initViewModel();
updateUI();
}
//初始化TestViewModel
private void initViewModel() {
ViewModelProvider provider = new ViewModelProvider(
this,
ViewModelProvider.AndroidViewModelFactory.getInstance(getApplication())
);
viewModel = provider.get(TestViewModel.class);
}
private void updateUI() {
//点击按钮改变TestViewModel中存储的字符串的值
viewBinding.button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
viewModel.setLiveData("测试改变文字");
}
});
//观察到字符串的值发生变化后更新UI
viewModel.getLiveData().observe(this, new Observer<String>() {
@Override
public void onChanged(String s) {
viewBinding.textView.setText(s);
}
});
}
}
可以发现代码很简单，大致逻辑如下：
1、创建一个ViewModel保存数据，并提供相应的改变数据的方法，这里还使用了LiveData,暂时不对其做介绍，可以简单理解为一个String对象即可。
2、在使用界面创建一个ViewModelProvider对象，用它来获取ViewModel对象。
3、点击按钮改变了ViewModel对象中String的值，观察到字符串的值发生变化后更新UI，这个观察值的变化使用了LiveData，暂时不对其做介绍。
四、源码分析
看完以上的使用介绍，大家可能会有如下问题：
1、为什么Activity销毁了，ViewModel对象还在？
2、如何保证重新创建Activity时，获取到的还是原来的ViewModel对象？
3、这个创建ViewModel对象的过程和Activity有关联，会不会产生内存泄漏？
4、ViewModel对象什么时机清除，难道一直存在内存？
我们带着问题来一步步看源码，首先分析ViewModelProvider，看他的名字和使用方法，感觉他是一个内容提供者，用来提供我们想要的ViewModel对象，来看看构造方法。
public ViewModelProvider(@NonNull ViewModelStoreOwner owner, @NonNull Factory factory) {
this(owner.getViewModelStore(), factory);
}
//最终调用下面方法
public ViewModelProvider(@NonNull ViewModelStore store, @NonNull Factory factory) {
mFactory = factory;
mViewModelStore = store;
}
到这里感觉ViewModelProvider好像是一个工具类，接收两个参数，ViewModelStore好像是用来存储ViewModel的，Factory好像是一个创建对象的工厂。另外我们使用的时候第一个参数传递的是this，是不是AppCompatActivity实现或者继承了ViewModelStoreOwner ？点击AppCompatActivity一层层往上找，在ComponentActivity中我们看到了如下代码，原来ViewModelStoreOwner是一个接口。
public class ComponentActivity extends androidx.core.app.ComponentActivity implements
LifecycleOwner,
ViewModelStoreOwner,
SavedStateRegistryOwner,
OnBackPressedDispatcherOwner {
// Lazily recreated from NonConfigurationInstances by getViewModelStore()
private ViewModelStore mViewModelStore;
static final class NonConfigurationInstances {
Object custom;
ViewModelStore viewModelStore;
}
@Override
@Nullable
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 nci = new NonConfigurationInstances();
nci.custom = custom;
nci.viewModelStore = viewModelStore;
return nci;
}
@NonNull
@Override
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.");
}
if (mViewModelStore == null) {
NonConfigurationInstances nc =
(NonConfigurationInstances) getLastNonConfigurationInstance();
if (nc != null) {
// Restore the ViewModelStore from NonConfigurationInstances
mViewModelStore = nc.viewModelStore;
}
if (mViewModelStore == null) {
mViewModelStore = new ViewModelStore();
}
}
return mViewModelStore;
}
｝
分析上面代码，可以得出以下结论：
1、ViewModelProvider拿到的是当前Activity的ViewModelStore。
2、当页面销毁重建时，会根据onRetainNonConfigurationInstance和getLastNonConfigurationInstance来恢复获取到原来的ViewModelStore对象，并且是从NonConfigurationInstances 这个静态内部类恢复的。
3、ViewModelStore是懒加载创建的。
再来看看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() {
for (ViewModel vm : mMap.values()) {
vm.clear();
}
mMap.clear();
}
}
搜索一下clear方法在哪里调用，可以在ComponentActivity中找到下面一段代码：
getLifecycle().addObserver(new LifecycleEventObserver() {
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
if (event == Lifecycle.Event.ON_DESTROY) {
if (!isChangingConfigurations()) {
getViewModelStore().clear();
}
}
}
});
很明显如果destory的时候不是配置发生变化，就要清除掉。这里抛出一个问题，在Fragment中时机是如何的了？
接下来分析第二个参数AndroidViewModelFactory，还是从使用入手，可以看到如下代码：
public static class AndroidViewModelFactory extends ViewModelProvider.NewInstanceFactory {
@NonNull
@Override
public <T extends ViewModel> T create(@NonNull Class<T> modelClass) {
if (AndroidViewModel.class.isAssignableFrom(modelClass)) {
//noinspection TryWithIdenticalCatches
try {
return modelClass.getConstructor(Application.class).newInstance(mApplication);
} catch (NoSuchMethodException e) {
throw new RuntimeException("Cannot create an instance of " + modelClass, e);
} catch (IllegalAccessException e) {
throw new RuntimeException("Cannot create an instance of " + modelClass, e);
} catch (InstantiationException e) {
throw new RuntimeException("Cannot create an instance of " + modelClass, e);
} catch (InvocationTargetException e) {
throw new RuntimeException("Cannot create an instance of " + modelClass, e);
}
}
return super.create(modelClass);
}
}
//继承自NewInstanceFactory
public static class NewInstanceFactory implements Factory {
@SuppressWarnings("ClassNewInstance")
@NonNull
@Override
public <T extends ViewModel> T create(@NonNull Class<T> modelClass) {
//noinspection TryWithIdenticalCatches
try {
return modelClass.newInstance();
} catch (InstantiationException e) {
throw new RuntimeException("Cannot create an instance of " + modelClass, e);
} catch (IllegalAccessException e) {
throw new RuntimeException("Cannot create an instance of " + modelClass, e);
}
}
}
证实了我们刚刚的想法，这个Factory就是用来创建ViewModel的，如果传进来的class是继承自AndroidViewModel，则通过反射传递一个Application类型的参数来生成对象，否则直接newInstance()生成对象。这样我们就不需要关联Acticity来获取上下文了，所以在合适的场景可以将自己的ViewModel从AndroidViewModel继承。
那么我们的ViewModel是在何时创建，又是怎么取出来的了，同样从使用入手，查看ViewModelProvider的get方法，代码如下：
private static final String DEFAULT_KEY =
"androidx.lifecycle.ViewModelProvider.DefaultKey";
@NonNull
@MainThread
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");
}
return get(DEFAULT_KEY + ":" + canonicalName, modelClass);
}
//最终调用到这个方法
@NonNull
@MainThread
public <T extends ViewModel> T get(@NonNull String key, @NonNull Class<T> modelClass) {
ViewModel viewModel = mViewModelStore.get(key);
if (modelClass.isInstance(viewModel)) {
//noinspection unchecked
return (T) viewModel;
} else {
//noinspection StatementWithEmptyBody
if (viewModel != null) {
// TODO: log a warning.
}
}
if (mFactory instanceof KeyedFactory) {
viewModel = ((KeyedFactory) (mFactory)).create(key, modelClass);
} else {
viewModel = (mFactory).create(modelClass);
}
mViewModelStore.put(key, viewModel);
//noinspection unchecked
return (T) viewModel;
}
这里其实就已经很清楚了，过程如下：
1、通过ViewModelProvider工具类从ViewModelStore中的HashMap里面获取ViewModel。
2、获取的key为DEFAULT_KEY+ViewModel类的完整路径名称字符串。
3、如果没有就调用Factory创建一个，并且保存在ViewModelStore中。
至此，整个源码分析过程结束。
