看完这篇文章，LiveData的用法竟然还可以这样用？

- 日理万妓 2023-07-13 04:06 30阅读 0赞

本文主要内容：

1.  作用介绍
2.  核心类介绍
3.  基本使用
4.  源码分析  
    – 横竖屏切换恢复  
    – 后台销毁恢复

--------------------

### ViewModel的主要工作： ###

本身主要是一个数据维护工具  
将数据维护的工作从`Activity`上剥离，提供一个储存数据环境，自身机制可以解决开发中，数据受`Activity`生命周期影响产生数据丢失的问题 (主要为横竖屏切换以及在后台被销毁)。  
通常结合`LiveData`使用。

![format_png][]

作为一个纯数据维护工具，可以加入到`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`的储存容器是参数提供的。

1.  **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;
    }

1.  **Fragment 实现：**

要看懂该部分源码，需要对FragmentManager有基础了解，参考：[深入理解FragmentManager][FragmentManager]

`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);
        }
    }

但从源码注释可以了解到，第三种情况已废弃，理想情况下并不支持。

![format_png 1][]

所以基本上，出现的应该为第一、第二种情况。

`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`作为保存数据的容器。

![format_png 2][]

而事实上，在旧版的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()`对数据进行操作。

![image][]

*  链接：[https://developer.android.google.cn/jetpack/androidx/releases/savedstate?hl=zh-cn][https_developer.android.google.cn_jetpack_androidx_releases_savedstate_hl_zh-cn]

我后面有空会另行写一篇文章去讨论系统对该组件的实现。

--------------------

`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()`取出保存的数据。

![image][image 1]

`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`读写。

先看`SavedStateHandle`：

*  前文提到，最终该机制的实现，实际为`SaveInstanceState`机制，则反映`VM`并不会对数据进行自动存取。  
    事实上`VM`确实需要手动将后台销毁前保存的数据放到`SaveInstanceState`中，`SavedStateHandle`确实是这么用的，所以提供了一系列的`get`/`set`操作，而最终还要编写`SavedStateProvider`的`Bundle`转换操作。
 *  同时可以看出，`SavedStateHandle`提供了对`LiveData`的存取支持。  
    `SavedStateHandle`对`LiveData`的支持，来自对`LiveData`的内部的静态包装类`SavingStateLiveData`。  
    `SavingStateLiveData`包装了`setValue()`，传入的参数会被优先储存到`mRegular`中。

![format_png 3][]

*  链接 ：[https://developer.android.google.cn/reference/androidx/lifecycle/SavedStateHandle?hl=zh-cn][https_developer.android.google.cn_reference_androidx_lifecycle_SavedStateHandle_hl_zh-cn]

用于提取数据的`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`)，最后总结：

*  ## 简化称呼以缩短阅读量： ##
    
    ## VM组：   `ViewModel` = `VM`   `SavedStateViewModelFactory` = `Factory` ##
    
    ## Registry组：   `SavedStateRegistryController` = `RegistryController`   `SavedStateRegistry` = `Registry` ##
    
    ## Handle组：   `SavedStateHandleController` = `HandleController`   `SavedStateHandle` = `Handle` ##
    
    ## Provider组：   `SavedStateProvider` = `Provider` ##
 *  初始化阶段：  
    `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`中  
    ***在此处`Registry`已把数据保存***

作者：七零八落问号  
链接：https://www.jianshu.com/p/4a65ee05e6a1

[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy8yMDcyMjUzLTMzYzlmMTkwMTQxM2JkNDEucG5nP2ltYWdlTW9ncjIvYXV0by1vcmllbnQvc3RyaXB8aW1hZ2VWaWV3Mi8yL3cvNTIyL2Zvcm1hdC93ZWJw?x-oss-process=image/format,png
[FragmentManager]: https://links.jianshu.com/go?to=https%3A%2F%2Fblog.csdn.net%2Fazurelaker%2Farticle%2Fdetails%2F84310053
[format_png 1]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy8yMDcyMjUzLTczMzUxNmFkZjY4NWM0MjEucG5nP2ltYWdlTW9ncjIvYXV0by1vcmllbnQvc3RyaXB8aW1hZ2VWaWV3Mi8yL3cvNjAxL2Zvcm1hdC93ZWJw?x-oss-process=image/format,png
[format_png 2]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy8yMDcyMjUzLTNiZDU0NzhlZmExNTFmNzQucG5nP2ltYWdlTW9ncjIvYXV0by1vcmllbnQvc3RyaXB8aW1hZ2VWaWV3Mi8yL3cvNTU1L2Zvcm1hdC93ZWJw?x-oss-process=image/format,png
[image]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy8yMDcyMjUzLThhZTBjMzEwNTFmZTJkNjAucG5nP2ltYWdlTW9ncjIvYXV0by1vcmllbnQvc3RyaXB8aW1hZ2VWaWV3Mi8yL3cvOTA3L2Zvcm1hdC93ZWJw?x-oss-process=image/format,png
[https_developer.android.google.cn_jetpack_androidx_releases_savedstate_hl_zh-cn]: https://links.jianshu.com/go?to=https%3A%2F%2Fdeveloper.android.google.cn%2Fjetpack%2Fandroidx%2Freleases%2Fsavedstate%3Fhl%3Dzh-cn
[image 1]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy8yMDcyMjUzLTUwZmI2YjJmZDE3OTU5NGUucG5nP2ltYWdlTW9ncjIvYXV0by1vcmllbnQvc3RyaXB8aW1hZ2VWaWV3Mi8yL3cvNTY3L2Zvcm1hdC93ZWJw?x-oss-process=image/format,png
[format_png 3]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy8yMDcyMjUzLWYwMDkwOGU2NTdiMjUxZDAucG5nP2ltYWdlTW9ncjIvYXV0by1vcmllbnQvc3RyaXB8aW1hZ2VWaWV3Mi8yL3cvODk1L2Zvcm1hdC93ZWJw?x-oss-process=image/format,png
[https_developer.android.google.cn_reference_androidx_lifecycle_SavedStateHandle_hl_zh-cn]: https://links.jianshu.com/go?to=https%3A%2F%2Fdeveloper.android.google.cn%2Freference%2Fandroidx%2Flifecycle%2FSavedStateHandle%3Fhl%3Dzh-cn