Jetpack-ViewModel
Jetpack-Lifecycle
Jetpack-LiveData
ViewModel
ViewModel是以能感知生命周期的方式存储和管理界面相关数据的组件。感知生命周期是说当Activity或Fragment创建第一个实例的时候，它开始创建，当Activity销毁或者Fragment分离的时候，它自动清理。比如：当屏幕旋转时，它不会被重新创建，数据能够被恢复。
当Activity配置发生变化时，我们也可以通过onSaveInstanceState() 方法保存数据，从 onCreate()或onRestoreInstanceState方法中恢复其数据，但这种方式仅适合可以序列化再反序列化的少量数据，而不适合较大数量的数据，如用户列表；而ViewModel可以。
Activity或Fragment主要用于界面的展示，如果数据存储和恢复的相关逻辑放在其中，会使Activity或Fragment变得臃肿。使用ViewModel可以将它们分离开来。
使用
class MyViewModel : ViewModel() {
private val users: MutableLiveData<List<User>> by lazy {
MutableLiveData().also {
it.value = loadUsers()
}
}
fun getUsers(): LiveData<List<User>> {
return users
}
private fun loadUsers()：List<User> {
//todo
}
}
class MyActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
//通过ViewModelProviders获取ViewModel实例
val model = ViewModelProviders.of(this)[MyViewModel::class.java]
model.getUsers().observe(this, Observer<List<User>>{ users ->
//todo
})
}
}
ViewModel还存在一个子类：AndroidViewModel，它的构造方法接收一个Application类型的参数，方便在ViewModel中使用Context。
//定义
class MyViewModel(application:Application) : AndroidViewModel(application) {}
//获取实例
mViewModel = ViewModelProviders.of(this,ViewModelProvider.AndroidViewModelFactory(application)).get(MyViewModel::class.java)
从上面看到当ViewModel的构造方法中有参数时，在获取实例的时候，传入了一个参数：ViewModelProvider.factory，那么这个Factory的作用是什么呢？当我们调用ViewModelProviders.of(activity)获取ViewModel实例的时候，它内部会默认调用ViewModel无参构造方法来创建实例；但是当ViewModel的构造方法有依赖时，这时候就需要我们自定义Factory来实例化ViewModel。比如：ViewModel的构造方法含有一个Int类型的参数，Factory的实现如下：
class MyViewModel(id: Int) : ViewModel() {}
//自定义Factory
class MyViewModelFactory(private val arg: Int) : ViewModelProvider.Factory {
override fun <T : ViewModel?> create(modelClass: Class<T>): T {
return modelClass.getConstructor(Int::class.java).newInstance(arg)
}
}
生命周期
ViewModel的存在是从第一次获取ViewModel实例一直到Activity完全销毁或者Fragment分离，Activity因配置发生变化而重新创建时，ViewModel是不会重新创建的。
当ViewModel销毁的时候，它会调用onCleared()方法，来清理相关的资源。
因为ViewModel比Activity的生命周期要长，所以ViewMode一定不能持有View的引用。
实现原理
我们要使用ViewModel，首先调用ViewModelProviders.of(this).get(MyViewModel::class.java)来获取实例。我们就以此为分析的入口，看一下该方法的实现：
public static ViewModelProvider of(@NonNull FragmentActivity activity) {
return of(activity, null);
}
public static ViewModelProvider of(@NonNull FragmentActivity activity,@Nullable Factory factory) {
Application application = checkApplication(activity);
if (factory == null) {
factory = ViewModelProvider.AndroidViewModelFactory.getInstance(application);
}
return new ViewModelProvider(activity.getViewModelStore(), factory);
}
从上面可以看出最终都会调用两个参数的方法，new ViewModelProvider(activity.getViewModelStore(), factory);，第一个参数通过Activity获取一个ViewModelStore对象，该方法是在ComponentActivity中实现的：
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;
}
Activity在配置发生变化时，如横竖屏切换会触发onSaveInstanceState()方法来保存状态，除此之外Activity还提供了一个方法onRetainNonConfigurationInstance来保存状态，最大的不同在于这个方法可以返回一个包含有状态信息的Object。该方法是在onSaveInstanceState()方法之后调用，该方法不允许重写。
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;
}
Activity在配置发生变化的时候保存了viewModelStore，放到了NonConfigurationInstances中。上面的操作都围绕着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());
}
public final void clear() {
for (ViewModel vm : mMap.values()) {
vm.clear();
}
mMap.clear();
}
}
ViewModelStore的代码很简单，就是用一个HashMap来存储ViewModel。那么ViewModel又是从什么时候存进去的呢？那就要从ViewModel的创建说起，我们获取ViewModel的实例调用的是ViewModelProvider的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");
}
return get(DEFAULT_KEY + ":" + canonicalName, modelClass);
}
public <T extends ViewModel> T get(@NonNull String key, @NonNull Class<T> modelClass) {
ViewModel viewModel = mViewModelStore.get(key);
if (modelClass.isInstance(viewModel)) {
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);
return (T) viewModel;
}
get()方法的实现也比较简单：先判断缓存中是否存在ViewModel，如果不存在就使用Factory创建一个实例，然后加入到缓存中。
ViewModel存储在ViewModelStore中，而ViewModelStore在Activity配置变化的时候会在onRetainNonConfigurationInstance()方法中保存起来，也就是说ViewModelStore不会因为Activity配置发生变化而重新创建。所以ViewModel也不会重新创建。
那么ViewModel是在什么时候销毁的呢？ViewModel存储在ViewModelStore里面的mMap中，它中有一个clear()方法,用来清除这个mMap，也就是清除ViewModel，那么我们就看一下这个方法是在哪里调用的？
public 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();
}
}
}
});
...
}
在Activity创建的时候会通过Lifecycle添加一个观察者，观察Activity的ON_DESTROY状态。当处于该状态时，判断是否是配置变化触发的，如果不是则调用ViewModelStore的clear()方法。从这里也可以看出，当Activity配置变化的时候并不会清理ViewModel。在Jetpack-Lifecycle中我们知道，当Activity调用onDestroy()时，状态会变为ON_DESTROY。
public final void clear() {
for (ViewModel vm : mMap.values()) {
vm.clear();
}
mMap.clear();
}
在clear()方法中会调用ViewModel的clear()方法
final void clear() {
mCleared = true;
if (mBagOfTags != null) {
synchronized (mBagOfTags) {
for (Object value : mBagOfTags.values()) {
// see comment for the similar call in setTagIfAbsent
closeWithRuntimeException(value);
}
}
}
onCleared();
}
protected void onCleared() {
}
所以在ViewModel即将销毁的时候会回调它的onCleared()方法，我们可以在该方法中做一些清理的工作。
