七零八落问号的博客地址：
https://www.jianshu.com/p/4a65ee05e6a1
/ ViewModel的主要工作 /
ViewModel本身主要是一个数据维护工具。
将数据维护的工作从Activity上剥离，提供一个储存数据环境，自身机制可以解决开发中，数据受Activity生命周期影响产生数据丢失的问题 (主要为横竖屏切换以及在后台被销毁)。
通常结合LiveData使用。
作为一个纯数据维护工具，可以加入到MVP架构中负责数据保存。而官方推选作为AAC架构MVVM中的VM层。
/ ViewModel的主要类 /
ViewModel (下称VM)
数据储存类，架构的核心类。使用时，直接继承该类，根据需求选择重写onCleared()方法。如需在Activity被系统销毁后依然保存数据，定义一个参数为(SavedStateHandle)的构造方法，并将数据保存SavedStateHandle中。实际上通过SavedInstanceState存取。
AndroidViewModel
VM子类，维护了Application的引用，由架构中的SavedStateViewModelFactory创建时传入。同样，需要接收SavedStateHandle时，需要定义参数为 (Application, SavedStateHandle)的构造方法。
ViewModelStore
用于保存VM，内部维护了一个用于储存VM的HashMap。一般情况下，直接使用本类创建实例。
ViewModelStoreOwner
接口，实现该接口的类，表示自身能够向外提供VM。androidx 的AppCompatActivity/Fragment实现了该接口。
ViewModelProvider
VM的提供者，获取VM的基本入口。实际依赖ViewModelStore存取VM，Factory生成/恢复VM。
Factory
接口，实现该接口的类主要用于创建VM实例。不建议直接实现该接口，除非你清楚框架内容和自己的需求。一般情况下，如果无需SavedStateHandle机制，可以使用AndroidViewModelFactory。否则应该使用或继承SavedStateViewModelFactory。
/ ViewModel的基本使用 /
一般使用。
// VM
class ViewModelA : ViewModel()
// AVM
class ViewModelB(app: Application) : AndroidViewModel(app)
// Activity/Fragment .onCreate中
override fun onCreate() {
...
val provider = ViewModelProvider(this)
val vmA = provider.get(ViewModelA::class.java)
val vmB = provider.get(ViewModelB::class.java)
...
}
接受SavedStateHandle。
// VM
class ViewModelC(
val handle: SavedStateHandle
) : ViewModel()
// AVM
class ViewModelD(
app: Application,
val handle: SavedStateHandle
) : AndroidViewModel(app)
跨Fragment共享数据
Fragment中直接以Activity作为ViewModel的Key。
...
val provider = ViewModelProvider(requireActivity())
val vmA = provider.get(ViewModelA::class.java)
通过Application创建全局共享的VM。
class App : Application(), ViewModelStoreOwner {
private lateinit var mAppViewModelStore: ViewModelStore
private lateinit var mFactory: ViewModelProvider.Factory
override fun onCreate() {
super.onCreate()
mAppViewModelStore = ViewModelStore()
mFactory = ViewModelProvider
.AndroidViewModelFactory
.getInstance(this)
}
override fun getViewModelStore(): ViewModelStore {
return mAppViewModelStore
}
private fun getAppFactory(): ViewModelProvider.Factory {
return mFactory
}
fun getAppViewModelProvider(activity: Activity): ViewModelProvider {
val app = checkApplication(activity) as App
return ViewModelProvider(app, app.getAppFactory())
}
fun getAppViewModelProvider(fragment: Fragment): ViewModelProvider {
return getAppViewModelProvider(fragment.requireActivity())
}
private fun checkApplication(activity: Activity): Application {
return activity.application
?: throw IllegalStateException(
"Your activity is not yet attached to the Application instance." +
"You can't request ViewModel before onCreate call.")
}
}
/ ViewModel关键源码分析 /
以下源码分析将会去除非相关代码以简化。
ViewModelProvider实现相关
前面提到，ViewModelProvider的工作完全依赖传入的ViewModelStore和Factory，可以直接从构造方法得知。
ViewModelProvider.java
----------------------
private final Factory mFactory;
private final ViewModelStore mViewModelStore;
public ViewModelProvider(ViewModelStoreOwner owner) {
this(owner.getViewModelStore(),
owner instanceof HasDefaultViewModelProviderFactory
? ((HasDefaultViewModelProviderFactory) owner)
.getDefaultViewModelProviderFactory()
: NewInstanceFactory.getInstance());
}
public ViewModelProvider(ViewModelStoreOwner owner, Factory factory) {
this(owner.getViewModelStore(), factory);
}
public ViewModelProvider(ViewModelStore store, Factory factory) {
mFactory = factory;
mViewModelStore = store;
}
// 简单的反射创建实例的工厂
public static class NewInstanceFactory implements Factory {
public <T extends ViewModel> T create(Class<T> modelClass) {
return modelClass.newInstance()
}
}
而androidx.activity.ComponentActivity，androidx.fragment.app.Fragment都实现了ViewModelStoreOwner，HasDefaultViewModelProviderFactory接口。
public class AppCompatActivity extends FragmentActivity...{}
public class FragmentActivity extends ComponentActivity...{}
public class ComponentActivity extends ... implements
ViewModelStoreOwner,
HasDefaultViewModelProviderFactory,
SavedStateRegistryOwner ... {}
public class Fragment implements
ViewModelStoreOwner,
HasDefaultViewModelProviderFactory,
SavedStateRegistryOwner ... {}
ViewModelProvider的get()方法中返回VM实例，其中mFactory为SavedStateViewModelFactory。
ViewModelProvider.java
----------------------
private static final String DEFAULT_KEY
= "androidx.lifecycle.ViewModelProvider.DefaultKey";
public <T extends ViewModel> T get(@NonNull Class<T> modelClass) {
String canonicalName = modelClass.getCanonicalName();
return get(DEFAULT_KEY + ":" + canonicalName, modelClass);
}
public <T extends ViewModel> T get(String key, Class<T> modelClass) {
ViewModel viewModel = mViewModelStore.get(key);
// 一个确保机制
if (modelClass.isInstance(viewModel)) {
if (mFactory instanceof OnRequeryFactory) {
((OnRequeryFactory) mFactory).onRequery(viewModel);
}
return (T) viewModel;
}
// 正常以及基本的逻辑
if (mFactory instanceof KeyedFactory) {
viewModel = ((KeyedFactory) (mFactory)).create(key, modelClass);
} else {
viewModel = (mFactory).create(modelClass);
}
mViewModelStore.put(key, viewModel);
return (T) viewModel;
}
SavedStateViewModelFactory在后面解析。
ViewModel 的屏幕横竖屏切换恢复机制
前面说到，创建VM是通过ViewModelProvider实现的，而ViewModelProvider又是依赖ViewModelStore进行VM的保存。当使用ComponentActivity/Fragment作为ViewModelProvider的初始化参数时，实际VM的储存容器是参数提供的。
ComponentActivity 实现
从源码中，可以看出横竖屏切换是直接通过NonConfigurationInstances进行恢复的。ComponentActivity包含一个NonConfigurationInstances类，其中持有ViewModelStore的引用。
ComponentActivity.java
----------------------
static final class NonConfigurationInstances {
Object custom;
ViewModelStore viewModelStore;
}
保存ViewModelStore
通过onRetainNonConfigurationInstance()在横竖屏切换中保存ViewModelStore。
ComponentActivity.java
----------------------
public final Object onRetainNonConfigurationInstance() {
Object custom = onRetainCustomNonConfigurationInstance();
// 从上一个 NonConfigurationInstances 中恢复 ViewModelStore
ViewModelStore viewModelStore = mViewModelStore;
if (viewModelStore == null) {
NonConfigurationInstances nc =
(NonConfigurationInstances) getLastNonConfigurationInstance();
if (nc != null) {
viewModelStore = nc.viewModelStore;
}
}
if (viewModelStore == null && custom == null) {
return null;
}
// 保存当前 ViewModelStore
NonConfigurationInstances nci = new NonConfigurationInstances();
nci.custom = custom;
nci.viewModelStore = viewModelStore;
return nci;
}
在使用时尝试通过getLastNonConfigurationInstance()恢复ViewModelStore。
ComponentActivity.java
----------------------
public ViewModelStore getViewModelStore() {
if (mViewModelStore == null) {
NonConfigurationInstances nc =
(NonConfigurationInstances) getLastNonConfigurationInstance();
if (nc != null) {
// 通过 NonConfigurationInstances 对象直接恢复 ViewModelStore
mViewModelStore = nc.viewModelStore;
}
if (mViewModelStore == null) {
mViewModelStore = new ViewModelStore();
}
}
return mViewModelStore;
}
Fragment 实现
Fragment的ViewModelStore由FragmentManager维护的FragmentManagerViewModel管理。注意这里使用了一个VM来维护一个ViewModelStore。
Fragment.java
-------------
public ViewModelStore getViewModelStore() {
return mFragmentManager.getViewModelStore(this);
}
FragmentManager.java
--------------------
private FragmentManagerViewModel mNonConfig;
ViewModelStore getViewModelStore(Fragment f) {
return mNonConfig.getViewModelStore(f);
}
处理FragmentManagerViewModel的实例化。
FragmentManager.java
--------------------
void attachController(FragmentHostCallback<?> host,
FragmentContainer container,
final Fragment parent) {
mHost = host;
mParent = parent;
if (parent != null) {
// 从父类的FM中获取
mNonConfig = parent.mFragmentManager.getChildNonConfig(parent);
} else if (host instanceof ViewModelStoreOwner) {
// 假如 host 对象是实现了 ViewModelStoreOwner
// 则使用这个ViewModelStoreOwner的viewModelStore创建一个 FragmentManagerViewModel
ViewModelStore viewModelStore =
((ViewModelStoreOwner) host).getViewModelStore();
mNonConfig = FragmentManagerViewModel.getInstance(viewModelStore);
} else {
// 生成一个不支持自动保存ViewModel的 FragmentManagerViewModel
mNonConfig = new FragmentManagerViewModel(false);
}
}
但从源码注释可以了解到，第三种情况已废弃，理想情况下并不支持。
所以基本上，出现的应该为第一、第二种情况。host对象实际是实现的ViewModelStoreOwner接口的FragmentActivity$HostCallbacks：
FragmentActivity.java
---------------------
class HostCallbacks
extends FragmentHostCallback<FragmentActivity>
implements ViewModelStoreOwner ... {...}
第二种情况，attachController()传入参数为null，可以理解为直接附着在FragmentActivity上的Fragment:
FragmentActivity.java
---------------------
protected void onCreate(@Nullable Bundle savedInstanceState) {
mFragments.attachHost(null /*parent*/);
}
FragmentController.java
-----------------------
public void attachHost(Fragment parent) {
mHost.mFragmentManager.attachController(mHost, mHost, parent);
}
而第一种情况，attachController()传入参数为Fragment，在Fragment的performAttach()中调用：
Fragment.java
-------------
void performAttach() {
mChildFragmentManager.attachController(mHost, new FragmentContainer(), this)
}
解决了FragmentManagerViewModel的来源，下面看看它的作用。上文提到，FragmentManagerViewModel是一个VM，实际上可以联想到可能是通过Activity的ViewModelStore，使用相同的NonConfigurationInstances机制实现的恢复。先看第二种情况：
FragmentManager.java
--------------------
ViewModelStore viewModelStore = ((ViewModelStoreOwner) host).getViewModelStore();
mNonConfig = FragmentManagerViewModel.getInstance(viewModelStore);
其中的host为FragmentActivity$HostCallbacks，而getViewModelStore()返回的实际上是FragmentActivity的ViewModelStore：
FragmentActivity$HostCallbacks.java
-----------------------------------
public ViewModelStore getViewModelStore() {
return FragmentActivity.this.getViewModelStore();
}
而FragmentManagerViewModel.getInstance()内部实际上是通过ViewModelProvider返回一个本类VM实例：
FragmentManagerViewModel .java
------------------------------
static FragmentManagerViewModel getInstance(ViewModelStore viewModelStore) {
ViewModelProvider viewModelProvider =
new ViewModelProvider(viewModelStore, FACTORY);
return viewModelProvider.get(FragmentManagerViewModel.class);
}
由于VM在创建时，会被储存到对应的ViewModelStore，所以该VM会存放到FragmentActivity的ViewModelStore中。
第一种情况：
实际上是顶级FragmentManager的FragmentManagerViewModel中，维护一个子级的FragmentManagerViewModel仓库，然后通过顶级FragmentManagerViewModel直接维护所有子级FragmentManagerViewModel。
FragmentManagerViewModel .java
------------------------------
private final HashMap<String, FragmentManagerViewModel> mChildNonConfigs = new HashMap<>();
FragmentManagerViewModel getChildNonConfig(@NonNull Fragment f) {
FragmentManagerViewModel childNonConfig = mChildNonConfigs.get(f.mWho);
if (childNonConfig == null) {
childNonConfig = new FragmentManagerViewModel(mStateAutomaticallySaved);
mChildNonConfigs.put(f.mWho, childNonConfig);
}
return childNonConfig;
}
从以上源码中可以看出，Fragment的横竖屏切换恢复机制实际上是。通过一个持有自身ViewModelStore引用的VM，依附到Activity的ViewModelStore中，通过Activity的机制进行恢复。
其实这里引申一点的是，源码中提及到，NonConfigurationInstances机制有可能在调用getLastNonConfigurationInstance时返回null，如需确保横竖屏切换时的数据保存，可以使用Fragment的onSaveInstanceState(true)，以Fragment作为保存数据的容器。
而事实上，在旧版的ViewModel中，确实是通过Fragment的onSaveInstanceState(true)进行的。
ViewModel 的后台销毁恢复机制
前文提到，SavedStateViewModelFactory是实现该机制的一部分，由SavedStateViewModelFactory生成的VM才具有在后台销毁前后通过SavedStateHandle存取数据的特性。先看SavedStateViewModelFactory的构造方法。
SavedStateViewModelFactory.java
-------------------------------
public SavedStateViewModelFactory(Application application,
SavedStateRegistryOwner owner,
Bundle defaultArgs) {
mSavedStateRegistry = owner.getSavedStateRegistry();
mLifecycle = owner.getLifecycle();
mDefaultArgs = defaultArgs;
mApplication = application;
mFactory = ViewModelProvider.AndroidViewModelFactory.getInstance(application);
}
SavedStateViewModelFactory在ComponentActivity中实例化传入的参数。
ComponentActivity.java
----------------------
mDefaultFactory = new SavedStateViewModelFactory(
getApplication(),
this,
getIntent() != null ? getIntent().getExtras() : null);
ComponentActivity实现了SavedStateRegistryOwner接口，该接口的实现类可以提供SavedStateRegistry实例。SavedStateRegistry即是流程的关键对象之一。
这里涉及到androidx提供的一个新的组件androidx.savedstate：”该组件允许以插件方式，将组件添加到SaveInstanceState过程中”。
个人理解
这是一套针对SavedState操作Bundle的封装工具，但仅适用于系统实现。
因为流程繁琐，系统源码在实现的过程中还包含了自动重建，自动还原数据，生命周期确保等一系列操作。而且当你实现关键的SavedStateProvider接口时，同样要编写Bundle，这和传统的onSaveInstanceState()区别不大。
因为系统实现了对VM提供的存取操作，建议直接使用VM，或者直接在onSaveInstanceState()对数据进行操作。ComponentActivity实例化时，创建成员SavedStateRegistryController，后者实例化时，创建成员SavedStateRegistry。
ComponentActivity.java
----------------------
private final SavedStateRegistryController mSavedStateRegistryController =
SavedStateRegistryController.create(this);
SavedStateRegistryController.java
---------------------------------
public static SavedStateRegistryController create(SavedStateRegistryOwner owner) {
return new SavedStateRegistryController(owner);
}
private SavedStateRegistryController(SavedStateRegistryOwner owner) {
mOwner = owner;
mRegistry = new SavedStateRegistry();
}
ComponentActivity在onSaveInstanceState()中调用SavedStateRegistryController.performSave()，内部实际调用SavedStateRegistry.performSave()。
ComponentActivity.java
----------------------
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
mSavedStateRegistryController.performSave(outState);
}
SavedStateRegistryController.java
---------------------------------
public void performSave(Bundle outBundle) {
mRegistry.performSave(outBundle);
}
SavedStateRegistry会把所有注册到自身的SavedStateProvider，通过saveState()提取数据，并保存到一个Bundle中。
SavedStateRegistry.java
-----------------------
void performSave(@NonNull Bundle outBundle) {
Bundle components = new Bundle();
for (Iterator<Map.Entry<String, SavedStateProvider>> it =
mComponents.iteratorWithAdditions(); it.hasNext(); ) {
Map.Entry<String, SavedStateProvider> entry1 = it.next();
components.putBundle(entry1.getKey(), entry1.getValue().saveState());
}
outBundle.putBundle(SAVED_COMPONENTS_KEY, components);
}
至此，说明数据保存的发起，最终通知到SavedStateRegistry。
先看SavedStateProvider接口。注册到SavedStateRegistry中实现类，会在SavedStateRegistry保存过程将会调用saveState()获取数据。而稍后(在恢复数据时)，将会通过SavedStateRegistry.consumeRestoredStateForKey()取出保存的数据。
SavedStateProvider通过SavedStateRegistry.registerSavedStateProvider()注册到SavedStateRegistry。
SavedStateRegistry.java
-----------------------
public void registerSavedStateProvider(String key, SavedStateProvider provider) {
SavedStateProvider previous = mComponents.putIfAbsent(key, provider);
if (previous != null) {
throw new IllegalArgumentException(
"SavedStateProvider with the given key is already registered");
}
}
到此，说明储存数据的提供者，是注册到SavedStateRegistry中的SavedStateProvider。前文提及，VM的存取核心是SavedStateHandle，那么说明SavedStateProvider和SavedStateHandle存在必然的关联。
实际上，SavedStateHandle实例中，维护一个SavedStateProvider匿名内部类实例，而SavedStateHandle的读写和SavedStateProvider实例的数据读取操作，都是对实际数据容器mRegular读写。
前文提到，最终该机制的实现，实际为SaveInstanceState机制，则反映VM并不会对数据进行自动存取。事实上VM确实需要手动将后台销毁前保存的数据放到SaveInstanceState中，SavedStateHandle确实是这么用的，所以提供了一系列的get/set操作，而最终还要编写SavedStateProvider的Bundle转换操作。同时可以看出，SavedStateHandle提供了对LiveData的存取支持。
SavedStateHandle对LiveData的支持，来自对LiveData的内部的静态包装类SavingStateLiveData。SavingStateLiveData包装了setValue()，传入的参数会被优先储存到mRegular中。
用于提取数据的SavedStateProvider。需要编写SavedStateProvider数据的Bundle转换操作。所以如无必要，无需自定义该组件，建议在onSaveInstanceState()中直接操作。
SavedStateHandle.java
---------------------
// 最终的数据容器主体
// initialState为构造时参入的上次SavedInstanceState产生的旧数据
// 既 SavedStateHandle.createHandle 时传入的参数，下面会说明
final Map<String, Object> mRegular = new HashMap<>(initialState);
// SavedStateProvider 对数据主体 mRegular 进行处理并生成一个Bundle
private final SavedStateProvider mSavedStateProvider = new SavedStateProvider() {
public Bundle saveState() {
Set<String> keySet = mRegular.keySet();
ArrayList keys = new ArrayList(keySet.size());
ArrayList value = new ArrayList(keys.size());
for (String key : keySet) {
keys.add(key);
value.add(mRegular.get(key));
}
Bundle res = new Bundle();
// "parcelable" arraylists - lol
res.putParcelableArrayList("keys", keys);
res.putParcelableArrayList("values", value);
return res;
}
};
至此，SavedStateHandle和SavedStateProvider实现关联。
前文提及，SavedStateProvider通过SavedStateRegistry.registerSavedStateProvider()注册到SavedStateRegistry。而该方法的调用，则是通过SavedStateHandleController进行的。SavedStateHandleController的实例化则是通过SavedStateViewModelFactory进行的，最终回到了SavedStateViewModelFactory。
先看SavedStateViewModelFactory，通过调用SavedStateHandleController.create()返回SavedStateHandleController实例。同时，VM在创建时，传入了SavedStateHandleController的SavedStateHandle实例作为参数，即VM和SavedStateHandle进行了绑定。
SavedStateViewModelFactory.java
-------------------------------
public <T extends ViewModel> T create(String key, Class<T> modelClass) {
// 判断是否是AVM
boolean isAndroidViewModel = AndroidViewModel.class.isAssignableFrom(modelClass);
Constructor<T> constructor;
if (isAndroidViewModel) {
constructor = findMatchingConstructor(modelClass, ANDROID_VIEWMODEL_SIGNATURE);
} else {
constructor = findMatchingConstructor(modelClass, VIEWMODEL_SIGNATURE);
}
// 如果不需要SavedStateHandle，则直接创建一个普通的VM/AVM
if (constructor == null) {
return mFactory.create(modelClass);
}
// 创建了 SavedStateHandleController
SavedStateHandleController controller = SavedStateHandleController.create(
mSavedStateRegistry, mLifecycle, key, mDefaultArgs);
// VM 在创建的时候持有了SavedStateHandleController内维护的SavedStateHandle对象
try {
T viewmodel;
if (isAndroidViewModel) {
viewmodel = constructor.newInstance(mApplication, controller.getHandle());
} else {
viewmodel = constructor.newInstance(controller.getHandle());
}
viewmodel.setTagIfAbsent(TAG_SAVED_STATE_HANDLE_CONTROLLER, controller);
return viewmodel;
...
}
再看SavedStateHandleController .create()：
SavedStateHandle在实例化时，通过consumeRestoredStateForKey()传入上次保存的数据，此时SavedStateHandle数据已完成恢复。
SavedStateHandleController创建后，通过attachToLifecycle()方法，在方法内部将SavedStateHandle维护的SavedStateProvider注册到SavedStateRegistry。
前面说到SavedStateViewModelFactory是框架骨架之一，实际就是通过这个过程，最终允许VM能够把数据的存取加入到SaveInstanceState流程。
SavedStateHandleController.java
-------------------------------
static SavedStateHandleController create(SavedStateRegistry registry,
Lifecycle lifecycle, String key, Bundle defaultArgs) {
// 通过consumeRestoredStateForKey获取前次状态
Bundle restoredState = registry.consumeRestoredStateForKey(key);
// 创建一个Handle
SavedStateHandle handle =
SavedStateHandle.createHandle(restoredState, defaultArgs);
// 生成SavedStateHandleController实例
SavedStateHandleController controller =
new SavedStateHandleController(key, handle);
// 这里进行了绑定
controller.attachToLifecycle(registry, lifecycle);
tryToAddRecreator(registry, lifecycle);
return controller;
}
void attachToLifecycle(SavedStateRegistry registry, Lifecycle lifecycle) {
registry.registerSavedStateProvider(mKey, mHandle.savedStateProvider());
}
至此，SavedStateProvider和SavedStateRegistry实现关联。
以上就是整个保存流程的概况，而还原流程差距不大，只是在onCreate()中调用SavedStateRegistryController.performRestore()，最终通知SavedStateRegistry在Bundle中恢复设置的数据。
/ 总结 /
忽略SavedStateHandleController对VM的确保机制 (包含Recreator)，最后总结：
初始化阶段
ComponentActivity创建了RegistryController实例；RegistryController创建了内部的Registry实例；ComponentActivity创建了Factory，并传入RegistryController维护的Registry。
恢复阶段
ComponentActivity在onCreate调用RegistryController的performRestore；RegistryController的performRestore中，调用Registry的performRestore；Registry的performRestore中，把数据从savedInstanceState (Bundle)取出，并储存到mRestoredState中。在此处Registry已把数据恢复。
VM生成阶段
VM需要通过Factory创建，创建VM对应的HandleController实例，通过Registry的consumeRestoredStateForKey把数据取出生成Handle。Handle内部维护一个Provider实例，共享数据容器mRegular；HandleController被注入Handle；Provider绑定到Registry，在此处实现了 (RegistryController-Registry-Provider-Handle) 绑定。VM被Factory注入Handle，在此处实现了 (RegistryController-Registry-Provider-Handle-VM) 绑定。VM数据最终通过Registry恢复。
写数据阶段
VM读写的数据最终存放到Handle的mRegular中。VM数据最终通过Registry保存。
保存阶段
ComponentActivity在onSaveInstanceState调用RegistryController的performSave，RegistryController的performSave中，调用Registry的performSave。Registry的performSave中，将所有注册的Provider数据打包成一个Bundle保存到onSaveInstanceState的Bundle中。
喜欢 就关注吧，欢迎投稿！
本网站文章均为原创内容，并可随意转载，但请标明本文链接
如有任何疑问可在文章底部留言。为了防止恶意评论，本博客现已开启留言审核功能。但是博主会在后台第一时间看到您的留言，并会在第一时间对您的留言进行回复！欢迎交流！
本文链接: https://leetcode.jp/深入aac架构，彻底理解viewmodel的用法/