ViewModel具体怎么使用前面我们已经演示过了，这是链接：https://www.jianshu.com/p/5a7f36c7dd9e
下面分析一下,基于SDK 28：
第一步:根据 Activity 或者 Fragment 获得 ViewModelProvider
ViewModelProvider viewModelProvider = ViewModelProviders.of(MainActivity.this);
看看这个源码中是怎么实现的
/**
* 使用 ViewModelProvider.AndroidViewModelFactory 来实例化新的 ViewModels.
*/
@NonNull
@MainThread
public static ViewModelProvider of(@NonNull FragmentActivity activity) {
return of(activity, null);
}
/**
* 通过给定的工厂来实例化一个新的 ViewModels.
*/
@NonNull
@MainThread
public static ViewModelProvider of(@NonNull FragmentActivity activity, @Nullable Factory factory) {
Application application = checkApplication(activity);
if (factory == null) {
// 获取默认的单例 AndroidViewModelFactory，它内部是通过反射来创建具体的 ViewModel
factory = ViewModelProvider.AndroidViewModelFactory.getInstance(application);
}
return new ViewModelProvider(activity.getViewModelStore(), factory);
}
/**
* 通过Activity获取可用的Application或者检测Activity是否可用
*/
private static Application checkApplication(Activity activity) {
Application application = activity.getApplication();
if (application == null) {
throw new IllegalStateException("Your activity/fragment is not yet attached to "
+ "Application. You can't request ViewModel before onCreate call.");
}
return application;
}
/**
* 通过Fragment获取Activity或者检测Fragment是否可用
*/
private static Activity checkActivity(Fragment fragment) {
Activity activity = fragment.getActivity();
if (activity == null) {
throw new IllegalStateException("Can't create ViewModelProvider for detached fragment");
}
return activity;
}
在类 ViewModelProvider 有下面的方法
/**
* AndroidViewModelFactory 在正常情况下是全局单例只有一个，只是一个反射创建对象的工具类
*/
public static class AndroidViewModelFactory extends ViewModelProvider.NewInstanceFactory {
private static AndroidViewModelFactory sInstance;
// 获得 AndroidViewModelFactory 单例
@NonNull
public static AndroidViewModelFactory getInstance(@NonNull Application application) {
if (sInstance == null) {
sInstance = new AndroidViewModelFactory(application);
}
return sInstance;
}
private Application mApplication;
// 构造方式是 public 的，是可以 new 一个 AndroidViewModelFactory 出来的
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 {
// 创建ViewModel的关键地方，根据给出的Class反射创建需要的ViewModel
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);
}
}
下面的方法在ComponentActivity
// TODO 返回与此 activity 关联的 ViewModelStore
@NonNull
public ViewModelStore getViewModelStore() {
if (this.getApplication() == null) {
throw new IllegalStateException("Your activity is not yet attached to the Application instance. You can't request ViewModel before onCreate call.");
} else {
if (this.mViewModelStore == null) {
ComponentActivity.NonConfigurationInstances nc = (ComponentActivity.NonConfigurationInstances)this.getLastNonConfigurationInstance();
if (nc != null) {
// TODO 从非配置实例还原 ViewModelStore ，从这里可以实现 ViewModel 跨越 Activity/Fragment的 生命周期
this.mViewModelStore = nc.viewModelStore;
}
// 为空就新创建一个
if (this.mViewModelStore == null) {
this.mViewModelStore = new ViewModelStore();
}
}
return this.mViewModelStore;
}
}
获取对应的 ViewModelStore
// TODO 返回与此 activity 关联的 ViewModelStore
@NonNull
public ViewModelStore getViewModelStore() {
if (this.getApplication() == null) {
throw new IllegalStateException("Your activity is not yet attached to the Application instance. You can't request ViewModel before onCreate call.");
} else {
if (this.mViewModelStore == null) {
ComponentActivity.NonConfigurationInstances nc = (ComponentActivity.NonConfigurationInstances)this.getLastNonConfigurationInstance();
if (nc != null) {
// TODO 从非配置实例还原 ViewModelStore ，从这里可以实现 ViewModel 跨越 Activity/Fragment的 生命周期
this.mViewModelStore = nc.viewModelStore;
}
// 为空就新创建一个
if (this.mViewModelStore == null) {
this.mViewModelStore = new ViewModelStore();
}
}
return this.mViewModelStore;
}
}
PS：
1.从上面可以知道根据传入的 Activity 或者 fragment 获取到 Application 从而得到 AndroidViewModelFactory
2.在 Activity 的父类 ComponentActivity 中会有方法getViewModelStore() 获取 ViewModelStore
3.通过 AndroidViewModelFactory、ViewModelStore，创建出 ViewModelProvider 对象
第二步:使用 ViewModelProvider 反射创建需要的 ViewModel
MainViewModel mainViewModel = viewModelProvider.get(MainViewModel.class);
跟进源码中看是怎么实现 get 方法的
ViewModelProvider类中
/**
* 创建一个ViewModelProvider，使用 ViewModelProvider 内部的全局单例 AndroidViewModelFactory 来反射创建 ViewModel,并把创建的ViewModel存入传入的ViewModelStore中！
* @param modelClass ViewModel 的子类的 class
*/
@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");
}
// ViewModelStore 存储 ViewModel key 的获取： DEFAULT_KEY 和 类名组成一个key值
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)) { // 缓存有就直接返回，否则就用 Factory 从新创建
//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); // 创建对应的 viewModel
}
mViewModelStore.put(key, viewModel); // 把创建好的 viewModel 存储到 ViewModelStore 的 HashMap 的 put 方法中
//noinspection unchecked
return (T) viewModel;
}
总结：
从上面可以看出，会先根据 类的全名+默认值作为key,从Map 中获取缓存，如果没有缓存在根据第一步中获取到的 Factory 创建一个新的 viewModel
未命名文件.jpg
源码目录：
源码目录
可以看到源码相对来说很少
我贴出来，在源码中我都加了注释，就不详细讲解了
AndroidViewModel
package androidx.lifecycle;
import android.annotation.SuppressLint;
import android.app.Application;
import androidx.annotation.NonNull;
/**
* 感知应用程序的上下文
* <p>
* 子类必须有一个接受 application 作为唯一参数的构造函数。
* <p>
*/
public class AndroidViewModel extends ViewModel {
@SuppressLint("StaticFieldLeak")
private Application mApplication;
public AndroidViewModel(@NonNull Application application) {
mApplication = application;
}
/**
* 返回对应的 Application
*/
@SuppressWarnings("TypeParameterUnusedInFormals")
@NonNull
public <T extends Application> T getApplication() {
//noinspection unchecked
return (T) mApplication;
}
}
ViewModel
package androidx.lifecycle;
import androidx.annotation.MainThread;
import androidx.annotation.Nullable;
import java.io.Closeable;
import java.io.IOException;
import java.util.concurrent.ConcurrentHashMap;
/**
viewModel是一个类，负责为 activity 活动或 fragment 准备和管理数据。
它还处理 activity / fragment 与 application 其余部分的通信（例如，调用业务逻辑类）。
<P>
ViewModel 总是与作用域（activity 或 fragment）关联创建的，并且只要作用域是活动的，它就将被保留。例如，如果它是一个 activity，直到完成为止。
<P>
换句话说，这意味着，如果由于配置更改（例如旋转）而销毁了 ViewModel 的所有者，则该 ViewModel 将不会被销毁。所有者的新实例将重新连接到现有的 ViewModel。
<P>
ViewModel 的目的是获取和保存 Activity 或 Fragment 所需的信息。Activity 或 Fragment 应该能够观察到 ViewModel 中的更改。
ViewModels 通常通过 LiveData 或 Android 数据绑定公开此信息。您还可以使用您喜欢的框架中的任何可观察性构造。
<P>
ViewModel 的唯一职责是管理UI的数据。它不应访问视图层次结构或保留对 Activity 或 Fragment 的引用。
<P>
从 Activity 的角度来看，典型的用法是：
< PRE>
* public class UserActivity extends Activity {
*
* {@literal @}Override
* protected void onCreate(Bundle savedInstanceState) {
* super.onCreate(savedInstanceState);
* setContentView(R.layout.user_activity_layout);
*
* final UserModel viewModel = ViewModelProviders.of(this).get(UserModel.class);
*
* viewModel.getUser().observe(this, new Observer<User>() {
* {@literal @}Override
* public void onChanged(@Nullable User data) {
* // update ui.
* }
* });
*
* findViewById(R.id.button).setOnClickListener(new View.OnClickListener() {
* {@literal @}Override
* public void onClick(View v) {
* viewModel.doAction();
* }
* });
* }
* }
* </pre>
*
* ViewModel 将是:
* <pre>
* public class UserModel extends ViewModel {
* private final MutableLiveData<User> userLiveData = new MutableLiveData();
*
* public LiveData<User> getUser() {
* return userLiveData;
* }
*
* public UserModel() {
* // trigger user load. 触发用户加载
* }
*
* void doAction() {
* // depending on the action, do necessary business logic calls and update the userLiveData.
* // 根据操作，进行必要的业务逻辑调用并更新 userLiveData。
* }
* }
* </pre>
*
* <p>
* ViewModels 还可以用作 Activity 及不同 Fragment 之间的通信层。
* 每个 Fragment 可以通过其 Activity 使用相同的 key 来获取 ViewModel。
* 这允许 Fragment 之间以一种非耦合的方式进行通信，这样它们就不需要直接与另一个 Fragment 通信。
* <pre>
* public class MyFragment extends Fragment {
* public void onStart() {
* UserModel userModel = ViewModelProviders.of(getActivity()).get(UserModel.class);
* }
* }
* </pre>
* </>
*/
public abstract class ViewModel {
@Nullable
private final ConcurrentHashMap<String, Object> mBagOfTags = new ConcurrentHashMap<>();
private volatile boolean mCleared = false;
/**
* This method will be called when this ViewModel is no longer used and will be destroyed.
* 当不再使用此 ViewModel 时，将调用此方法并将其销毁。
* <p>
* It is useful when ViewModel observes some data and you need to clear this subscription to
* prevent a leak of this ViewModel.
* 当 ViewModel 观察到一些数据，并且您需要清除此订阅以防止此 ViewModel 泄漏时，它非常有用。
*/
@SuppressWarnings("WeakerAccess")
protected void onCleared() {
}
@MainThread
final void clear() {
mCleared = true;
// Since clear() is final, this method is still called on mock objects
// and in those cases, mBagOfTags is null. It'll always be empty though
// because setTagIfAbsent and getTag are not final so we can skip
// clearing it
// 由于clear（）是final，所以仍然对模拟对象调用此方法，在这些情况下，mBagOfTags 为空。
// 但它总是空的，因为 setTagIfAbsent 和 getTag 不是最终版本，所以我们可以跳过清除它。
if (mBagOfTags != null) {
for (Object value : mBagOfTags.values()) {
// see comment for the similar call in setTagIfAbsent 请参阅 setTagIfAbsent 中类似调用的注释
closeWithRuntimeException(value);
}
}
onCleared();
}
/**
* 设置与此ViewModel关联的标记和键。
* 如果给定的 newValue 是 Closeable，它将关闭一次 clear（）。
* < P>
* 如果已经为给定的键设置了值，则此调用不执行任何操作，并且返回当前关联的值，给定的 newValue 将被忽略
* < P>
* 如果 viewModel 已经清除，那么如果返回的对象实现了 Closeable，则会对该对象调用 close（）。同一对象可能会收到多个关闭调用，因此方法应该是等幂的。
*/
<T> T setTagIfAbsent(String key, T newValue) {
assert mBagOfTags != null;
@SuppressWarnings("unchecked")
T previous = (T) mBagOfTags.putIfAbsent(key, newValue);
T result = previous == null ? newValue : previous;
if (mCleared) {
// It is possible that we'll call close() multiple times on the same object, but
// Closeable interface requires close method to be idempotent:
// "if the stream is already closed then invoking this method has no effect." (c)
// 我们可能会在同一个对象上多次调用close（），但 Closeable 接口要求 close 方法为等幂：“如果流已经关闭，则调用此方法无效。”
closeWithRuntimeException(result);
}
return result;
}
/**
* Returns the tag associated with this viewmodel and the specified key.
* 返回与此ViewModel和指定键关联的标记。
*/
@SuppressWarnings("TypeParameterUnusedInFormals")
<T> T getTag(String key) {
//noinspection unchecked
return (T) mBagOfTags.get(key);
}
// 我们可能会在同一个对象上多次调用close（），但 Closeable 接口要求 close 方法为等幂：“如果流已经关闭，则调用此方法无效。”
private static void closeWithRuntimeException(Object obj) {
if (obj instanceof Closeable) {
try {
((Closeable) obj).close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
ViewModelProvider
package androidx.lifecycle;
import android.app.Application;
import androidx.annotation.MainThread;
import androidx.annotation.NonNull;
import java.lang.reflect.InvocationTargetException;
/**
* ViewModelProvider 是每次获取创建 ViewModel 的时候都会创建一个新的
*/
@SuppressWarnings("WeakerAccess")
public class ViewModelProvider {
private static final String DEFAULT_KEY = "androidx.lifecycle.ViewModelProvider.DefaultKey";
/**
* Factory 接口的实现负责实例化 ViewModels。
*/
public interface Factory {
/**
* 创建给定 @code Class 类的新实例
*
* @param modelClass 新实例的 class
* @param <T> ViewModel 类型的泛型参数.
* @return 返回新创建的 ViewModel
*/
@NonNull
<T extends ViewModel> T create(@NonNull Class<T> modelClass);
}
/**
* factory 接口的实现负责实例化 ViewModels。
* 这是 factory 的更高级版本，它接收为请求指定的密钥
*/
abstract static class KeyedFactory implements Factory {
/**
* @param key a key 在 ViewModelStore 存储的 ViewModel 的 key
* @return 实例化对应的 ViewModel
*/
@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;
/**
* @param owner ViewModelStore 用于保存 ViewModels
* @param factory Factory 用于创建新的 ViewModels
*/
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，使用 ViewModelProvider 内部的全局单例 AndroidViewModelFactory 来反射创建 ViewModel,并把创建的ViewModel存入传入的ViewModelStore中！
* @param modelClass ViewModel 的子类的 class
*/
@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");
}
// ViewModelStore 存储 ViewModel key 的获取： DEFAULT_KEY 和 类名组成一个key值
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)) { // 缓存有就直接返回，否则就用 Factory 从新创建
//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); // 创建对应的 viewModel
}
mViewModelStore.put(key, viewModel); // 把创建好的 viewModel 存储到 ViewModelStore 的 HashMap 的 put 方法中
//noinspection unchecked
return (T) viewModel;
}
/**
* Simple factory, which calls empty constructor on the give class. 简单工厂，它在给定类上调用空构造函数
*/
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);
}
}
}
/**
* AndroidViewModelFactory 在正常情况下是全局单例只有一个，只是一个反射创建对象的工具类
*/
public static class AndroidViewModelFactory extends ViewModelProvider.NewInstanceFactory {
private static AndroidViewModelFactory sInstance;
// 获得 AndroidViewModelFactory 单例
@NonNull
public static AndroidViewModelFactory getInstance(@NonNull Application application) {
if (sInstance == null) {
sInstance = new AndroidViewModelFactory(application);
}
return sInstance;
}
private Application mApplication;
// 构造方式是 public 的，是可以 new 一个 AndroidViewModelFactory 出来的
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 {
// 创建ViewModel的关键地方，根据给出的Class反射创建需要的ViewModel
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);
}
}
}
ViewModelProviders
package androidx.lifecycle;
import android.app.Activity;
import android.app.Application;
import androidx.annotation.MainThread;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.fragment.app.Fragment;
import androidx.fragment.app.FragmentActivity;
import androidx.lifecycle.ViewModelProvider.Factory;
/**
* ViewModel 的创建不可直接 new，需要使用这个 ViewModelProviders 才能与 Activity 或者 Fragment 的生命周期关联起来！
* ViewModel 的存在是依赖 Activity 或者 Fragment的，不管你在什么地方获取 ViewModel，
* 只要你用的是相同的 Activity 或者 Fragment，那么获取到的 ViewModel 将是同一个 (前提是key值是一样的)，所以 ViewModel 也具有数据共享的作用！
*/
public class ViewModelProviders {
/**
* @deprecated This class should not be directly instantiated 不应直接实例化此类
*/
@Deprecated
public ViewModelProviders() {
}
/**
* 通过Activity获取可用的Application或者检测Activity是否可用
*/
private static Application checkApplication(Activity activity) {
Application application = activity.getApplication();
if (application == null) {
throw new IllegalStateException("Your activity/fragment is not yet attached to "
+ "Application. You can't request ViewModel before onCreate call.");
}
return application;
}
/**
* 通过Fragment获取Activity或者检测Fragment是否可用
*/
private static Activity checkActivity(Fragment fragment) {
Activity activity = fragment.getActivity();
if (activity == null) {
throw new IllegalStateException("Can't create ViewModelProvider for detached fragment");
}
return activity;
}
/**
* 通过Fragment获得ViewModelProvider
* ViewModelProvider.AndroidViewModelFactory 来实例化新的 ViewModels
*/
@NonNull
@MainThread
public static ViewModelProvider of(@NonNull Fragment fragment) {
return of(fragment, null);
}
/**
* 使用 ViewModelProvider.AndroidViewModelFactory 来实例化新的 ViewModels.
*/
@NonNull
@MainThread
public static ViewModelProvider of(@NonNull FragmentActivity activity) {
return of(activity, null);
}
/**
* 通过给定的工厂来实例化一个新的 ViewModels.
*/
@NonNull
@MainThread
public static ViewModelProvider of(@NonNull Fragment fragment, @Nullable Factory factory) {
Application application = checkApplication(checkActivity(fragment));
if (factory == null) {
// 获取默认的单例 AndroidViewModelFactory，它内部是通过反射来创建具体的 ViewModel
factory = ViewModelProvider.AndroidViewModelFactory.getInstance(application);
}
return new ViewModelProvider(fragment.getViewModelStore(), factory);
}
/**
* 通过给定的工厂来实例化一个新的 ViewModels.
*/
@NonNull
@MainThread
public static ViewModelProvider of(@NonNull FragmentActivity activity, @Nullable Factory factory) {
Application application = checkApplication(activity);
if (factory == null) {
// 获取默认的单例 AndroidViewModelFactory，它内部是通过反射来创建具体的 ViewModel
factory = ViewModelProvider.AndroidViewModelFactory.getInstance(application);
}
return new ViewModelProvider(activity.getViewModelStore(), factory);
}
/**
* 工厂可创建 AndroidViewModel 和 ViewModel，具有空构造函数的.
* <p>
* 不推荐使用 ViewModelProvider.AndroidViewModelFactory
*/
@SuppressWarnings("WeakerAccess")
@Deprecated
public static class DefaultFactory extends ViewModelProvider.AndroidViewModelFactory {
/**
* 不推荐使用 ViewModelProvider.AndroidViewModelFactory 和
* ViewModelProvider.AndroidViewModelFactory.getInstance(Application)的方式创建 AndroidViewModelFactory
*/
@Deprecated
public DefaultFactory(@NonNull Application application) {
super(application);
}
}
}
ViewModelStore
package androidx.lifecycle;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;
/**
* 用来存储 ViewModel
* <p>
* 必须通过配置更改保留 ViewModelStore 的实例：
* <p>
* 如果此 ViewModelStore 的所有者由于配置而被销毁并重新创建
* 更改，所有者的新实例仍应具有相同的旧实例
* <p>
* 如果此 ViewModelStore 的所有者被销毁，并且不会被重新创建，
* 然后它应该在这个 viewModelStore 上调用 clear（），因此 ViewModels 通知他们不再使用。
* 当Activity或者Fragment销毁的时候就会调用clear方法
*
* TODO ViewModelStore 是每一个 Activity 或者 Fragment 都有一个
*/
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());
}
/**
* 清除内部存储并通知 ViewModel 它们不再使用
*/
public final void clear() {
for (ViewModel vm : mMap.values()) {
vm.clear();
}
mMap.clear();
}
}
ViewModelStoreOwner
package androidx.lifecycle;
import androidx.annotation.NonNull;
/**
* 此接口实现的职责是在配置更改期间保留所拥有的 ViewModelStore，并在要销毁此范围时调用 viewModelStore clear（）。
* SDK27+版本，都是V4包下的 FragmentActivity 和 Fragment 实现了这二个接口
*/
@SuppressWarnings("WeakerAccess")
public interface ViewModelStoreOwner {
@NonNull
ViewModelStore getViewModelStore();
}
ViewModelStores
package androidx.lifecycle;
import androidx.annotation.MainThread;
import androidx.annotation.NonNull;
import androidx.fragment.app.Fragment;
import androidx.fragment.app.FragmentActivity;
/**
* Factory methods for {@link ViewModelStore} class.
*/
@SuppressWarnings("WeakerAccess")
public class ViewModelStores {
private ViewModelStores() {
}
/**
* 如果你的 Activity 实现了 ViewModelStoreOwner 接口具备了提供 ViewModelStore 的功能就直接获取返回
* TODO 为 Activity 创建 ViewModelStore
*/
@Deprecated
@NonNull
@MainThread
public static ViewModelStore of(@NonNull FragmentActivity activity) {
return activity.getViewModelStore();
}
/**
* 如果你的 Fragment 实现了 ViewModelStoreOwner 接口具备了提供 ViewModelStore 的功能就直接获取返回
* TODO 为 Fragment 创建 ViewModelStore
*/
@Deprecated
@NonNull
@MainThread
public static ViewModelStore of(@NonNull Fragment fragment) {
return fragment.getViewModelStore();
}
}
这里特意说明一下 ViewModelStore ，通过源码大家可以知道 这个是存储和清除 ViewModel 的，存储的操作是在
ViewModelProvider.get()，方法中执行的，每新创建一个 ViewModel 就添加进去
image.png
清除是在 Activity 中执行的，代码如下：
image.png
