一、ViewModel简介
ViewModel：是以感知生命周期的形式来存储和管理视图相关的数据。
ViewModel主要有以下的特点：
- 当Activity被销毁时，我们可以使用onSaveInstanceState()方法恢复其数据，这种方法仅适用于恢复少量的支持序列化、反序列化的数据，不适用于大量数据，如用户列表或位图。而ViewModel不仅支持大量数据，还不需要序列化、反序列化操作。
- Activity/Fragment（视图控制器）主要用于显示视图数据，如果它们也负责数据库或者网络加载数据等操作，那么一旦逻辑过多，会导致视图控制器臃肿，ViewModel可以更容易，更有效的将视图数据相关逻辑和视图控制器分离开来。
-
视图控制器经常需要一些时间才可能返回的异步调用，视图控制器需要管理这些调用，在合适的时候清理它们，以确保它们的生命周期不会大于自身，避免内存泄漏。而ViewModel恰恰可以避免内存泄漏的发生。
生命周期
Activity的生命周期不断变化，经历了被销毁重新创建，而ViewModel的生命周期没有发生变化。只有当Activity真正Finished了，ViewModel才会执行onCleared()方法销毁。
二、ViewModel的使用
1、自定义ViewModel
继承ViewMode，实现自定义ViewModel。
import android.arch.lifecycle.LiveData;
import android.arch.lifecycle.MutableLiveData;
import android.arch.lifecycle.ViewModel;
public class UserModel extends ViewModel {
private final MutableLiveData<User> userLiveData = new MutableLiveData<>();
public LiveData<User> getUser() {
return userLiveData;
}
public UserModel() {
}
public void doAction() {
userLiveData.setValue(new User())
}
}
2、使用ViewModel
在Activity中使用LoginViewModel
import android.arch.lifecycle.Observer;
import android.arch.lifecycle.ViewModelProviders;
import android.support.annotation.Nullable;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
public class UserActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_user);
final UserModel viewModel = new ViewModelProvider(this).get(UserModel.class);
viewModel.getUser().observe(this, new Observer<User>() {
@Override
public void onChanged(@Nullable User data) {
// 更新UI
}
});
findViewById(R.id.button).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
viewModel.doAction();
}
});
}
}
三、ViewModel的原理
首先查看ViewModel源码
public abstract class ViewModel {
@Nullable
private final Map<String, Object> mBagOfTags = new HashMap<>();
private volatile boolean mCleared = false;
/**
* 当不再使用此 ViewModel 并将被销毁时，将调用此方法。当 ViewModel 观察到一些数据并且您需要清除此订阅以防止此 ViewModel 泄漏时，它很有用。
*/
@SuppressWarnings("WeakerAccess")
protected void onCleared() {
}
@MainThread
final void clear() {
mCleared = true;
// 由于 clear() 是最终的，因此仍然会在模拟对象上调用此方法，在这些情况下，mBagOfTags 为空。它总是空的，因为 setTagIfAbsent 和 getTag 不是最终的，所以我们可以跳过清除它
if (mBagOfTags != null) {
synchronized (mBagOfTags) {
for (Object value : mBagOfTags.values()) {
// see comment for the similar call in setTagIfAbsent
closeWithRuntimeException(value);
}
}
}
onCleared();
}
/**
* 设置与此视图模型关联的标签和键。如果给定的 newValue 是可关闭的，它将在 clear() 后关闭。如果已经为给定键设置了值，则此调用不执行任何操作并返回当前关联的值，则将忽略给定的 newValue 如果 ViewModel 已被清除，则如果它实现 Closeable，则将对返回的对象调用 close()。同一个对象可能会收到多个关闭调用，因此方法应该是幂等的。
*/
@SuppressWarnings("unchecked")
<T> T setTagIfAbsent(String key, T newValue) {
T previous;
synchronized (mBagOfTags) {
previous = (T) mBagOfTags.get(key);
if (previous == null) {
mBagOfTags.put(key, newValue);
}
}
T result = previous == null ? newValue : previous;
if (mCleared) {
// 我们可能会在同一个对象上多次调用 close()，但 Closeable 接口要求 close 方法是幂等的：“如果流已经关闭，则调用此方法无效。”
closeWithRuntimeException(result);
}
return result;
}
/**
* 返回与此视图模型关联的标签和指定的键。
*/
@SuppressWarnings({"TypeParameterUnusedInFormals", "unchecked"})
<T> T getTag(String key) {
if (mBagOfTags == null) {
return null;
}
synchronized (mBagOfTags) {
return (T) mBagOfTags.get(key);
}
}
private static void closeWithRuntimeException(Object obj) {
if (obj instanceof Closeable) {
try {
((Closeable) obj).close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
1、ViewModel初始化
final UserModel viewModel = new ViewModelProvider(this).get(UserModel.class);
可以看到，我们并没有手动调用 ViewModel 的构造函数来创建 ViewModel 实例，而是由 ViewModelProvider 来获取，其实ViewModel 初始化是在ViewModelProvider内部自己通过反射来构建出 ViewModel 实例。
ViewModelProvider源码
public class ViewModelProvider {
private static final String DEFAULT_KEY =
"androidx.lifecycle.ViewModelProvider.DefaultKey";
public interface Factory {
@NonNull
<T extends ViewModel> T create(@NonNull Class<T> modelClass);
}
static class OnRequeryFactory {
void onRequery(@NonNull ViewModel viewModel) {
}
}
abstract static class KeyedFactory extends OnRequeryFactory implements Factory {
@NonNull
public abstract <T extends ViewModel> T create(@NonNull String key,
@NonNull Class<T> modelClass);
@NonNull
@Override
public <T extends ViewModel> T create(@NonNull Class<T> modelClass) {
throw new UnsupportedOperationException("create(String, Class<?>) must be called on "
+ "implementaions of KeyedFactory");
}
}
private final Factory mFactory;
private final ViewModelStore mViewModelStore;
public ViewModelProvider(@NonNull ViewModelStoreOwner owner) {
this(owner.getViewModelStore(), owner instanceof HasDefaultViewModelProviderFactory
? ((HasDefaultViewModelProviderFactory) owner).getDefaultViewModelProviderFactory()
: NewInstanceFactory.getInstance());
}
public ViewModelProvider(@NonNull ViewModelStoreOwner owner, @NonNull Factory factory) {
this(owner.getViewModelStore(), factory);
}
public ViewModelProvider(@NonNull ViewModelStore store, @NonNull Factory factory) {
mFactory = factory;
mViewModelStore = store;
}
@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);
}
@SuppressWarnings("unchecked")
@NonNull
@MainThread
public <T extends ViewModel> T get(@NonNull String key, @NonNull Class<T> modelClass) {
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.
}
}
if (mFactory instanceof KeyedFactory) {
viewModel = ((KeyedFactory) mFactory).create(key, modelClass);
} else {
viewModel = mFactory.create(modelClass);
}
mViewModelStore.put(key, viewModel);
return (T) viewModel;
}
public static class NewInstanceFactory implements Factory {
private static NewInstanceFactory sInstance;
@NonNull
static NewInstanceFactory getInstance() {
if (sInstance == null) {
sInstance = new NewInstanceFactory();
}
return sInstance;
}
@SuppressWarnings("ClassNewInstance")
@NonNull
@Override
public <T extends ViewModel> T create(@NonNull Class<T> modelClass) {
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);
}
}
}
public static class AndroidViewModelFactory extends ViewModelProvider.NewInstanceFactory {
private static AndroidViewModelFactory sInstance;
@NonNull
public static AndroidViewModelFactory getInstance(@NonNull Application application) {
if (sInstance == null) {
sInstance = new AndroidViewModelFactory(application);
}
return sInstance;
}
private Application mApplication;
public AndroidViewModelFactory(@NonNull Application application) {
mApplication = application;
}
@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);
}
}
}
1. ViewModelProvider 构造函数
ViewModelProvider 一共包含三个构造函数，可以看到，不管是哪种方式，最终都是要拿到两个构造参数：ViewModelStore 和 Factory，且都不能为 null。
public ViewModelProvider(@NonNull ViewModelStoreOwner owner) {
this(owner.getViewModelStore(), owner instanceof HasDefaultViewModelProviderFactory
? ((HasDefaultViewModelProviderFactory) owner).getDefaultViewModelProviderFactory()
: NewInstanceFactory.getInstance());
}
public ViewModelProvider(@NonNull ViewModelStoreOwner owner, @NonNull Factory factory) {
this(owner.getViewModelStore(), factory);
}
public ViewModelProvider(@NonNull ViewModelStore store, @NonNull Factory factory) {
mFactory = factory;
mViewModelStore = store;
}
- 三个构造函数，其中最终都会调用第三个构造函数；
- 第一个构造函数是我们在Activity和Fragment中用的；因为AppCompatActivity 的父类 androidx.activity.ComponentActivity和Fragment 都已经实现了 ViewModelStoreOwner 和 HasDefaultViewModelProviderFactory 两个接口，所以我们可以直接使用只包含一个参数的构造函数；
- 而如果传入的 ViewModelStoreOwner 实例没有继承 HasDefaultViewModelProviderFactory 接口的话，mFactory 就使用 NewInstanceFactory 来初始化；
2. ViewModelStore 和 Factory的获取
Activity和Fragment实现了ViewModelStoreOwner和HasDefaultViewModelProviderFactory接口，这两个接口分别提供了ViewModelStore 和 Factory；
1. ViewModelStore通过ViewModelStoreOwner接口获取，用于存储ViewModel实例；
2. Factory 是 ViewModelProvider 的内部接口，用于实现初始化 ViewModel 的逻辑。
- Activity和Fragment中通过getDefaultViewModelProviderFactory() 方法返回的是 SavedStateViewModelFactory；
- 其他方式创建的话使用NewInstanceFactory ，通过反射来实例化 ViewModel 实例，但是也只适用于不包含构造参数的情况，如果是有参构造函数的话就需要我们来主动实现 Factory 接口，毕竟构造参数也需要我们来主动传入。
public class ComponentActivity extends androidx.core.app.ComponentActivity implements
ContextAware,
LifecycleOwner,
ViewModelStoreOwner,
HasDefaultViewModelProviderFactory,
SavedStateRegistryOwner,
OnBackPressedDispatcherOwner,
ActivityResultRegistryOwner,
ActivityResultCaller,
MenuHost {
@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.");
}
ensureViewModelStore();
return mViewModelStore;
}
@SuppressWarnings("WeakerAccess")
void ensureViewModelStore() {
if (mViewModelStore == null) {
NonConfigurationInstances nc =
(NonConfigurationInstances) getLastNonConfigurationInstance();
if (nc != null) {
// Restore the ViewModelStore from NonConfigurationInstances
mViewModelStore = nc.viewModelStore;
}
if (mViewModelStore == null) {
mViewModelStore = new ViewModelStore();
}
}
}
@NonNull
@Override
public ViewModelProvider.Factory getDefaultViewModelProviderFactory() {
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 (mDefaultFactory == null) {
mDefaultFactory = new SavedStateViewModelFactory(
getApplication(),
this,
getIntent() != null ? getIntent().getExtras() : null);
}
return mDefaultFactory;
}
}
3. ViewModelProvider(this).get()方法
既然 Factory 实例也有了，下一步就是来调用 ViewModelProvider(this).get() 方法了。get() 方法需要我们传入 Class 对象，ViewModelProvider 需要拿到 Class 才能完成反射操作。在此方法里主要是通过 modelClass 来自动生成一个字符串 Key，并将参数转发给另外一个 get() 方法。
ViewModelProvider中
@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);
}
@SuppressWarnings("unchecked")
@NonNull
@MainThread
public <T extends ViewModel> T get(@NonNull String key, @NonNull Class<T> modelClass) {
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.
}
}
if (mFactory instanceof KeyedFactory) {
viewModel = ((KeyedFactory) mFactory).create(key, modelClass);
} else {
viewModel = mFactory.create(modelClass);
}
mViewModelStore.put(key, viewModel);
return (T) viewModel;
}
该方法会通过 key 从 ViewModelStore 里取 ViewModel 实例，如果取不到值或者是取出来的值类型不符，则会通过 mFactory.create(modelClass) 方法来反射初始化 ViewModel，并在返回初始化结果前将它存到 mViewModelStore 中，这样就完成了 ViewModel 的初始化流程了。
2、ViewModel保持不变
结论：ViewModel保持不变是因为ViewModelStore没有变化。
原因：Activity 每次获取 ViewModel 实例都会先尝试从 mViewModelStore 中取值，只有在取不到值的时候才会去重新构建一个新的 ViewModel 实例，且构建后的 ViewModel 实例也会被保存在mViewModelStore 中。那既然 Activity 可以在页面销毁重建的情况下获取到之前的 ViewModel 实例，那么不也就间接说明了在这种情况下 ViewModelStore 也是一直被保留着而没有被回收。
ViewModelStore 本身实现的逻辑挺简单的，通过一个 HashMap 来缓存每一个 ViewModel 实例，并提供了存取 ViewModel 的方法。
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();
}
}
ComponentActivity
@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.");
}
ensureViewModelStore();
return mViewModelStore;
}
@SuppressWarnings("WeakerAccess")
void ensureViewModelStore() {
if (mViewModelStore == null) {
NonConfigurationInstances nc =
(NonConfigurationInstances) getLastNonConfigurationInstance();
if (nc != null) {
// Restore the ViewModelStore from NonConfigurationInstances
mViewModelStore = nc.viewModelStore;
}
if (mViewModelStore == null) {
mViewModelStore = new ViewModelStore();
}
}
}
ComponentActivity 的 getViewModelStore() 方法获取 ViewModelStore 实例的来源有两种：
- 如果 NonConfigurationInstances 不为 null 则通过它获取。对应 Activity 由于配置更改导致重建的情况，NonConfigurationInstances 当中就保留了页面重建过程中被保留下来的数据，此时就可以获取到上一个 Activity 保存的 ViewModelStore 实例了
- 直接初始化 ViewModelStore 实例返回。对应 Activity 正常被启动的情况。
这里只要看第一种情况
1. NonConfigurationInstances源码
NonConfigurationInstances 是 ComponentActivity 的一个静态内部类，其内部就包含了一个 ViewModelStore 成员变量，在 Activity 被重建时，其对应的 ViewModelStore 就被保存在了这。
ComponentActivity源码中
static final class NonConfigurationInstances {
Object custom;
ViewModelStore viewModelStore;
}
2. NonConfigurationInstances.viewModelStore 变量的赋值
通过查找引用，可以找到 ComponentActivity 就是在 onRetainNonConfigurationInstance() 方法里来完成 NonConfigurationInstances.viewModelStore 变量的赋值。从该方法名可以猜出，该方法就用于获取非配置项实例，以便在后续重建 Activity 时恢复数据。
ComponentActivity源码中
@Override
@Nullable
@SuppressWarnings("deprecation")
public final Object onRetainNonConfigurationInstance() {
Object custom = onRetainCustomNonConfigurationInstance();
ViewModelStore viewModelStore = mViewModelStore;
if (viewModelStore == null) {
// 没有人调用 getViewModelStore()，所以看看我们最后的 NonConfigurationInstance 是否存在一个现有的 ViewModelStore
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;
}
3. onRetainNonConfigurationInstance()方法调用时机
通过查找方法引用，可以知道 onRetainNonConfigurationInstance() 又是被父类 android.app.Activity 的以下方法所调用，由父类去负责保留 NonConfigurationInstances 对象。
NonConfigurationInstances retainNonConfigurationInstances() {
Object activity = onRetainNonConfigurationInstance();
HashMap<String, Object> children = onRetainNonConfigurationChildInstances();
FragmentManagerNonConfig fragments = mFragments.retainNestedNonConfig();
mFragments.doLoaderStart();
mFragments.doLoaderStop(true);
ArrayMap<String, LoaderManager> loaders = mFragments.retainLoaderNonConfig();
if (activity == null && children == null && fragments == null && loaders == null
&& mVoiceInteractor == null) {
return null;
}
NonConfigurationInstances nci = new NonConfigurationInstances();
nci.activity = activity;
nci.children = children;
nci.fragments = fragments;
nci.loaders = loaders;
if (mVoiceInteractor != null) {
mVoiceInteractor.retainInstance();
nci.voiceInteractor = mVoiceInteractor;
}
return nci;
}
从以上流程可以看出 Activity 的一些设计思路。由于 android.app.Activity 的逻辑是和特定的系统版本 SDK 关联的，我们无法决定用户手中的手机系统版本。而我们日常开发中都是选择直接继承于androidx.appcompat.app.AppCompatActivity，它又是作为一个依赖库来存在的，开发者可以自行决定要使用哪个版本号，Google 官方也可能随时推出新版本。所以，android.app.Activity 就将非配置项实例数据均当做一个 Object 实例来处理，由子类通过实现onRetainNonConfigurationInstance() 方法来返回，父类 Activity 不限制方法返回值需要特定类型，不同的子类可以返回不同的类型，父类只负责在需要的时候将实例保存起来，然后在重建时返回给子类即可，由子类自己来进行数据的拆解和重建。这样，不管用户使用的手机是哪个系统版本，都可以保证三方依赖库有最大的发挥余地。
4. retainNonConfigurationInstances() 方法调用时机
在 ActivityThread 类的以下方法存在调用，该方法用于回调 Activity 的 onDestroy 方法，在回调前会先将数据保存到 ActivityClientRecord 的 lastNonConfigurationInstances 字段中。
ActivityThread源码中
/** Core implementation of activity destroy call. */
ActivityClientRecord performDestroyActivity(IBinder token, boolean finishing,
int configChanges, boolean getNonConfigInstance, String reason) {
ActivityClientRecord r = mActivities.get(token);
···
if (getNonConfigInstance) {
try {
//保存 Activity 返回的 NonConfigurationInstances
r.lastNonConfigurationInstances
= r.activity.retainNonConfigurationInstances();
} catch (Exception e) {
if (!mInstrumentation.onException(r.activity, e)) {
throw new RuntimeException(
"Unable to retain activity "
+ r.intent.getComponent().toShortString()
+ ": " + e.toString(), e);
}
}
}
···
//调用 Activity 的 onDestroy 方法
mInstrumentation.callActivityOnDestroy(r.activity);
···
return r;
}
5. 从ActivityClientRecord中恢复NonConfigurationInstances到重启的Activity中
在重新启动 Activity 时，又会将数据 attach 到新的 Activity 实例上，将其作为 getLastNonConfigurationInstance() 方法的返回值。通过这种数据交接，重建前的 ViewModelStore 实例就会被重建后的 Activity 拿到，当中就保留了重建前 Activity 初始化的所有 ViewModel 实例，从而保障了 ViewModel 实例的不变性。
ActivityThread源码中
/** Core implementation of activity launch. */
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
···
Activity activity = null;
try {
java.lang.ClassLoader cl = appContext.getClassLoader();
activity = mInstrumentation.newActivity(
cl, component.getClassName(), r.intent);
StrictMode.incrementExpectedActivityCount(activity.getClass());
r.intent.setExtrasClassLoader(cl);
r.intent.prepareToEnterProcess();
if (r.state != null) {
r.state.setClassLoader(cl);
}
} catch (Exception e) {
if (!mInstrumentation.onException(activity, e)) {
throw new RuntimeException(
"Unable to instantiate activity " + component
+ ": " + e.toString(), e);
}
}
···
//将 r.lastNonConfigurationInstances 传递进去
activity.attach(appContext, this, getInstrumentation(), r.token,
r.ident, app, r.intent, r.activityInfo, title, r.parent,
r.embeddedID, r.lastNonConfigurationInstances, config,
r.referrer, r.voiceInteractor, window, r.configCallback,
r.assistToken);
···
return activity;
}
3、ViewModel构造函数有值
ViewModelProvider 提供的 Factory 接口实现类有两个：
- NewInstanceFactory：通过反射来实例化 ViewModel，适用于包含无参构造函数的情况
- AndroidViewModelFactory：通过反射来实例化 ViewModel，适用于构造参数只有一个，且参数类型为 Application 的情况
如果想要通过其它类型的构造函数来初始化 ViewModel 的话，就需要我们自己来实现 ViewModelProvider.Factory 接口声明初始化逻辑了：
class MainActivity : AppCompatActivity() {
private val myViewModelA by lazy {
ViewModelProvider(this, object : ViewModelProvider.Factory {
override fun <T : ViewModel> create(modelClass: Class<T>): T {
return MyViewModel("Mary") as T
}
}).get(
MyViewModel::class.java
).apply {
ld_name.observe(this@MainActivity, {
})
}
}
private val myViewModelB by lazy {
ViewModelProvider(this, object : ViewModelProvider.Factory {
override fun <T : ViewModel> create(modelClass: Class<T>): T {
return MyViewModel("Lily") as T
}
}).get(
MyViewModel::class.java
).apply {
ld_name.observe(this@MainActivity, {
})
}
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
Log.e("myViewModelA", myViewModelA.toString() + " name: " + myViewModelA.name)
Log.e("myViewModelB", myViewModelB.toString() + " name: " + myViewModelB.name)
}
}
class MyViewModel(val name: String) : ViewModel() {
val ld_name = MutableLiveData<String>()
}
注意：需要注意的是，虽然 myViewModelA 和 myViewModelB 都有各自不同的入参参数，但它们其实是同一个对象，即最先初始化的那个 ViewModel 实例会被缓存下来重复使用。是因为在初始化 myViewModelA 和 myViewModelB 的时候它们默认对应的都是同个 Key，ViewModelProvider 默认情况下是以 DEFAULT_KEY + ":" + canonicalName 作为 key 值来从 mViewModelStore 中取值，所以在初始化 myViewModelB 的时候就直接把之前已经初始化好的 myViewModelA 给返回了。
如果想使用同一个ViewModel类对应不同的实例对象，那么就需要在初始化的时候主动为它们指定不同的 Key，这样它们就可以一起被存到 ViewModelStore 的 HashMap 中了。
ViewModelProvider(this, object : ViewModelProvider.Factory {
override fun <T : ViewModel> create(modelClass: Class<T>): T {
return MyViewModel("Mary") as T
}
}).get(
"keyA", MyViewModel::class.java
).apply {
ld_name.observe(this@MainActivity, {
})
}
4、ViewModel回收
ViewModel回收是由于ViewModelStore清空 HashMap。
在 ComponentActivity 中通过监听Lifecycle状态，在Activity 在收到 ON_DESTROY 事件时，如果判断到是由于配置项更改导致了 Activity 被销毁，那么就不会调用 getViewModelStore().clear() 。如果是正常退出 Activity，那就会调用 getViewModelStore().clear() 方法，这样就会清空掉所有缓存的 ViewModel 实例了，ViewModel 的 clear() 方法也同时会被调用。
ComponentActivity源码中
public class ComponentActivity extends androidx.core.app.ComponentActivity implements
ContextAware,
LifecycleOwner,
ViewModelStoreOwner,
HasDefaultViewModelProviderFactory,
SavedStateRegistryOwner,
OnBackPressedDispatcherOwner,
ActivityResultRegistryOwner,
ActivityResultCaller,
MenuHost {
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();
// And clear the ViewModelStore
if (!isChangingConfigurations()) {
getViewModelStore().clear();
}
}
}
});
}
}
ViewModelStore源码中
public class ViewModelStore {
private final HashMap<String, ViewModel> mMap = new HashMap<>();
···
public final void clear() {
for (ViewModel vm : mMap.values()) {
vm.clear();
}
mMap.clear();
}
}
参考：从源码看Jetpack
