Android arch components 源码分析（1）—— ViewModel

63 阅读 0 评论 42 点赞

我是靠谱客的博主疯狂红酒，最近开发中收集的这篇文章主要介绍Android arch components 源码分析（1）—— ViewModel，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

本篇主要关注 ViewModel 的实现而非其用法，关于他的用法，可以参考这里。

ViewModel 主要用于在 activity/fragment 被自动销毁时保存一些数据。从实现原理上讲，主要就是利用了 fragment.setRetainInstance(true)。如此一来，这个 fragment 就能够跨越 activity 的生命周期。

以下源码使用 2.2.0 版本

总览

ViewModel：这个是我们的主角。我们定义的 model 类需要继承它。
ViewModelProvider：用于生成 ViewModel 实例
ViewModelStore：跟他的名字一样，主要用来存储 ViewModel 的实例。
HolderFragment：这个就是我们上面提到的调用了 setRetainInstance(true) 的那个 fragment。ViewModelStore 实例存储会在这里。

下面是 Google 给出的示例 step2 中的一段代码：

ChronometerViewModel chronometerViewModel
= ViewModelProviders.of(this).get(ChronometerViewModel.class);

下面我们就根据这个调用来学习 ViewModel 的源码。

ViewModel

前面我们说过，自己定义的 model 类需要继承它。这里借花献佛，我们直接看 Google 的 sample：

public class ChronometerViewModel extends ViewModel {
// 不用关心它的内容
}

ViewModel 虽然是主角，但他非常的简单：

public abstract class ViewModel {
protected void onCleared() {
}
}

就这样，他只是定义了一个空方法 onCleared()。当对应的 model 实例被销毁时，onCleared() 将会执行。通过让他成为 abstract class 并给予 onCleared 一个默认实现，让 ViewModel 有了 tag interface 的效果。

所谓的 tag interface 是指不带任何方法的 interface。

接下来是男二号 AndroidViewModel：

public class AndroidViewModel extends ViewModel {
private Application mApplication;
public AndroidViewModel(@NonNull Application application) {
mApplication = application;
}
@NonNull
public <T extends Application> T getApplication() {
return (T) mApplication;
}
}

没有太多可圈可点的东西，我们继续看下一个。

ViewModelProvider

ChronometerViewModel chronometerViewModel
= ViewModelProviders.of(this).get(ChronometerViewModel.class);

我们继续从这个调用往下看。

ViewModelProviders 可以看成是 ViewModelProvider 的工厂或相关工具类的合集。他的命名跟 JDK 里的 Collections/Arrays 类似。这里的 this 是 FragmentActivity，所以接下来执行的是：

public class ViewModelProviders {
@NonNull
@MainThread
public static ViewModelProvider of(@NonNull FragmentActivity activity) {
return of(activity, null);
}
@NonNull
@MainThread
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(ViewModelStores.of(activity), factory);
}
}

可以看到，最终 ViewModelProviders 会创建一个 ViewModelProvider 实例并返回。

Factory 是用于创建 model 实例的工厂：

public interface Factory {
@NonNull
<T extends ViewModel> T create(@NonNull Class<T> modelClass);
}

默认的实现是 AndroidViewModelFactory：

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;
}
@NonNull
@Override
public <T extends ViewModel> T create(@NonNull Class<T> modelClass) {
if (AndroidViewModel.class.isAssignableFrom(modelClass)) {
// model 类继承了 AndroidViewModel
//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);
}
}
// 否则，由父类 `NewInstanceFactory` 处理
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) {
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 实现时，如果 model 类继承 ViewModel，需要有一个默认构造函数；如果继承 AndroidViewModel，必须有一个以 Application 为唯一参数构造函数。否则，我们需要自己实现一个 Factory。

我们先把 ViewModelStore 放一放，先假设成功拿到了他的实例，于是，我们创建 ViewModelProvider 实例：

public static ViewModelProvider of(@NonNull FragmentActivity activity,
@Nullable Factory factory) {
// ...
return new ViewModelProvider(ViewModelStores.of(activity), factory);
}
public class ViewModelProvider {
public ViewModelProvider(@NonNull ViewModelStore store, @NonNull Factory factory) {
mFactory = factory;
mViewModelStore = store;
}
// ...
}

通过 ViewModelProvider 获取 model 实例时，使用的是他的 get 方法：

public class ViewModelProvider {
private static final String DEFAULT_KEY =
"android.arch.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);
// 当使用不同的类加载器加载同一个类的时候，这里会是 false
if (modelClass.isInstance(viewModel)) {
//noinspection unchecked
return (T) viewModel;
} else {
//noinspection StatementWithEmptyBody
if (viewModel != null) {
// TODO: log a warning.
}
}
viewModel = mFactory.create(modelClass);
mViewModelStore.put(key, viewModel);
//noinspection unchecked
return (T) viewModel;
}
}

ViewModelProvider 他的职责就是从 ViewModelStore 里取出对象，如果对象不存在，就新创建一个，并把新创建的这个对象放到 ViewModelStore。

ViewModelStore

和 ViewModelProvider 一样，ViewModelStore 也有一个工厂类叫 ViewModelStores。

public class ViewModelStores {
@NonNull
@MainThread
public static ViewModelStore of(@NonNull FragmentActivity activity) {
// 我们的 activity 可以自己实现 ViewModelStoreOwner
// 默认情况下，这里的判断为 false，ViewModelStoreOwner 由 HolderFragment 实现
if (activity instanceof ViewModelStoreOwner) {
return ((ViewModelStoreOwner) activity).getViewModelStore();
}
// holderFragmentFor 在 HolderFragment 中实现，我们留到下一节再看
return holderFragmentFor(activity).getViewModelStore();
}
}
public interface ViewModelStoreOwner {
@NonNull
ViewModelStore getViewModelStore();
}

HolderFragment 实现了 ViewModelStoreOwner 接口，holderFragmentFor(activity) 返回 activity 对应的 holderFragment 后，即可以拿到 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);
}
/**
*
Clears internal storage and notifies ViewModels that they are no longer used.
*/
public final void clear() {
for (ViewModel vm : mMap.values()) {
vm.onCleared();
}
mMap.clear();
}
}

HolderFragment

HolderFragment 是整个实现的核心。

public class HolderFragment extends Fragment implements ViewModelStoreOwner {
// ...
public HolderFragment() {
// 如此一来，当 activity 由于屏幕旋转等被系统销毁时，这个 fragment 实例也不会被销毁
setRetainInstance(true);
}
@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// 把 activity 从 mNotCommittedActivityHolders 中移除
sHolderFragmentManager.holderFragmentCreated(this);
}
public static HolderFragment holderFragmentFor(FragmentActivity activity) {
return sHolderFragmentManager.holderFragmentFor(activity);
}
static class HolderFragmentManager {
private Map<Activity, HolderFragment> mNotCommittedActivityHolders = new HashMap<>();
private ActivityLifecycleCallbacks mActivityCallbacks =
new EmptyActivityLifecycleCallbacks() {
@Override
public void onActivityDestroyed(Activity activity) {
HolderFragment fragment = mNotCommittedActivityHolders.remove(activity);
// fragment 创建成功后，会把 activity 从 mNotCommittedActivityHolders 中
// 移除。如果 fragment != null，说明 fragment 没有创建完 activity 就跪了
if (fragment != null) {
Log.e(LOG_TAG, "Failed to save a ViewModel for " + activity);
}
}
};
private boolean mActivityCallbacksIsAdded = false;
HolderFragment holderFragmentFor(FragmentActivity activity) {
FragmentManager fm = activity.getSupportFragmentManager();
// 通过 fragmentManager 获取 fragment 实例
HolderFragment holder = findHolderFragment(fm);
if (holder != null) {
return holder;
}
holder = mNotCommittedActivityHolders.get(activity);
if (holder != null) {
return holder;
}
if (!mActivityCallbacksIsAdded) {
mActivityCallbacksIsAdded = true;
activity.getApplication().registerActivityLifecycleCallbacks(mActivityCallbacks);
}
holder = createHolderFragment(fm);
// 我们 add 进去的 fragment 并不会马上就执行完（也就是说，这个方法执行完成后，马上再
// 调用一次，上面的 findHolderFragment 会返回 null。但是这没有关系，因为接下来我们还可
// 从 mNotCommittedActivityHolders 获取到对应的实例），所以我们这里先把他放在
// mNotCommittedActivityHolders 中。Not Committed 表示 fragment 的 commit 还没有完成
mNotCommittedActivityHolders.put(activity, holder);
return holder;
}
private static HolderFragment createHolderFragment(FragmentManager fragmentManager) {
HolderFragment holder = new HolderFragment();
// 这个 fragment 只是用来存数据，允许他的状态丢失可以让用户在更多情景下使用我们的API
// 例如，onStop() 中也可以使用（当然，onDestroy 就不行了，因为我们需要往 activity 悄悄
// 添加一个 fragment）
fragmentManager.beginTransaction().add(holder, HOLDER_TAG).commitAllowingStateLoss();
return holder;
}
}
}

HolderFragment 对 ViewModelStoreOwner 实现是相当直接的：

public class HolderFragment extends Fragment implements ViewModelStoreOwner {
private ViewModelStore mViewModelStore = new ViewModelStore();
@Override
public void onDestroy() {
super.onDestroy();
mViewModelStore.clear();
}
@NonNull
@Override
public ViewModelStore getViewModelStore() {
return mViewModelStore;
}
}