Jetpack 组件 LiveData + viewModel 使用分析
1、LiveData 简介
LiveData 是一个可观察对象的持有者，与常规的可观察对象不同，liveData 是生命周期感知的，这意味着它尊重其他应该用程序组件（如 activity，fragment ，service）这种意识确保LiveData只更新处于活动生命周期状态的应用程序组件观察者
LiveData 认为一个观察者的生命周期处于启动或恢复状态，那么这个观察者（由观察类表示）就处于活动状态
LiveData 只向活动的观察者通知更新。注册来监听liveData对象的非活动观察者不会收到关于更改的通知
您可以注册一个与实现LifeCycleOwner 接口的对象配对的观察者。当相应的生命周期对象的状态更改为销毁时，这种关系允许删除观察者。这对于活动和片段特别有用，因为他们可以安全地观察LiveData对象，而不用担心内存泄漏——当activity 和fragment 的生命周期被破坏时，他们会立即取消订阅
2、使用LiveData 的优点
1、确保UI 和 数据状态匹配
LiveData 遵循观察者模式。当生命周期状态发生改变时，LiveData 通知观察者对象。您可以合并代码来更新这些观察者对象中的UI，你的观察者可以在每次应用数据改变时更新UI，而不是每次应用数据改变时都更新UI
2、没有内存泄漏
观察者绑定到生命周期对象，并在其关联的生命周期被销毁后进行清理
3、没有因为停止活动而导致的崩溃
如果观察者的生命周期是不活动的，例如在后台栈中的活动，那么它不会接收任何liveData事件
4、不需要手动的生命周期处理
UI 组件只观察相关数据，不停止或继续观察。LiveData 会自动管理所有这些，因为 他在观察的同时会知道相关的生命周期状态变化
5、总是最新的数据
如果一个生命周期变为不活动的，它将在再次激活时接收最新的数据。例如，位于后台的活动在返回到前台后立即接收最新的数据。
6、适当的配置更改
如果某个活动或片段由于配置更改(如设备旋转)而重新创建，它将立即接收最新的可用数据。
7、共享资源
你可以使用单例模式来扩展LiveData对象来包装系统服务，这样它们就可以在你的应用程序中被共享。LiveData对象连接到系统服务一次，然后任何需要该资源的观察者都可以观看LiveData对象。有关更多信息，请参见Extend LiveData。
3、使用LiveData 对象
按照以下步骤处理LiveData对象:
1、创建一个LiveData实例来保存特定类型的数据。这通常在ViewModel类中完成。
2、创建一个定义onChanged()方法的观察者对象，该方法控制LiveData对象持有的数据更改时发生的情况。您通常在UI控制器中创建一个观察者对象，例如一个activity或fragment。
3、使用observe()方法将观察者对象附加到LiveData对象。方法获取一个LifecycleOwner对象。这订阅了LiveData对象的观察者对象，以便在发生更改时通知它。通常将观察者对象附加到UI控制器中，如 Activity或Fragment。
注意：您可以使用observeForever(observer)方法注册一个没有关联LifecycleOwner对象的观察者。在这种情况下，观察者被认为总是处于活动状态，因此总是被通知修改。您可以删除这些调用removeObserver(观察者)方法的观察者。
当您更新LiveData对象中存储的值时，只要附加的LifecycleOwner处于活动状态，它就会触发所有注册的观察者。
LiveData允许UI控制器观察者订阅更新。当LiveData对象持有的数据发生更改时，UI将自动更新。
1、创建LiveData 对象
LiveData是一个可以与任何数据(包括实现集合的对象，如List)一起使用的包装器。LiveData对象通常存储在ViewModel对象中，并通过getter方法进行访问，如下面的示例所示:
public class NameViewModel extends ViewModel{
//create a LiveData with a String
private MutableLiveData<String> currentName;
public MutableLiveData<String> getCurrentName(){
if(currentName == null){
currentName = new MutableLiveData<String>();
}
return currentName;
}
}
最初，并不设置LiveData对象中的数据。
注意:确保在ViewModel对象中存储更新UI的LiveData对象，而不是activity或fragment，原因如下:
以避免膨胀的活动和碎片。现在这些UI控制器负责显示数据而不是保存数据状态。
将LiveData实例与特定的活动或片段实例解耦，并允许LiveData对象在配置更改后仍然存在。
您可以在ViewModel指南中了解更多关于ViewModel类的好处和用法。
2、观察LiveData 数据
在大多数情况下，应用程序组件的onCreate()方法是开始观察LiveData对象的合适位置，原因如下:
以确保系统不会从活动或fragment的onResume()方法发出冗余调用。
以确保活动或片段具有数据，可以在活动开始时立即显示这些数据。只要应用程序组件处于启动状态，它就会从它所观察的LiveData对象接收最新的值。只有在设置了要观察的LiveData对象时才会发生这种情况。
通常，LiveData只在数据发生更改时才提交更新，并且只向活动的观察者提交更新。这种行为的一个例外是，当观察者从非活动状态更改为活动状态时，他们也会收到更新。而且，如果观察者第二次从非活动状态变为活动状态，那么它只会在上一次活动之后值发生变化时才会收到更新。
下面的示例代码演示了如何开始观察LiveData对象:
public class NameActivity extends AppCompatActivity{
private NameViewModel model;
@Override
protected void onCreate(Bundle savedInstanceState){
super.onCreate(saveInstanceState);
//Get the ViewModel
model = ViewModelProviders.of(this).get(NameViewModel.class);
final Observer<String> nameObserver = new Observer<String>{
@Override
public void onChanged(@NUllable final String newName){
nameTextView.setText(newName);
}
}
model.getCurrentName().observe(this,nameObserver);
}
}
使用作为参数传递的nameObserver调用了observe()之后，立即调用onChanged()，提供存储在mCurrentName中的最新值。如果LiveData对象没有在mCurrentName中设置值，则不会调用onChanged()。
3、更新LiveData对象
LiveData没有公开可用的方法来更新存储的数据。MutableLiveData类公开setValue(T)和postValue(T)方法，如果需要编辑存储在LiveData对象中的值，则必须使用这些方法。通常在ViewModel中使用MutableLiveData，然后ViewModel只向观察者公开不可变的LiveData对象。
建立观察者关系之后，可以更新LiveData对象的值，如下面的示例所示，当用户点击按钮时，将触发所有观察者:
button.setOnClickListener(new OnClickListener(){
@Override
public void onClick(View v){
String anotherName = "John Doe";
model.getCurrentName.setValue(anotherName);
}
})
在示例中调用setValue(T)会导致观察者使用值John Doe调用它们的onChanged()方法。该示例显示一个按钮按下，但是可以调用setValue()或postValue()来更新mName，原因有很多，包括响应网络请求或完成数据库加载;在所有情况下，对setValue()或postValue()的调用都会触发观察者并更新UI。
注意:您必须调用setValue(T)方法来从主线程更新LiveData对象。如果代码在工作线程中执行，您可以使用postValue(T)方法来更新LiveData对象。
4、LiveData 和 Room 一起使用
Room 持久性库支持返回LiveData对象的可见查询。可观察查询是作为数据库访问对象(DAO)的一部分编写的。
当数据库更新时，Room生成更新LiveData对象所需的所有代码。生成的代码在需要时在后台线程上异步运行查询。此模式对于保持UI中显示的数据与数据库中存储的数据同步非常有用。您可以在Room persistent library指南中阅读关于Room和DAOs的更多信息。
与LiveData一起使用协同程序
LiveData包括对Kotlin协同程序的支持。有关更多信息，请参见使用带有Android体系结构组件的Kotlin协程。## 扩展LiveData
如果观察者的生命周期处于启动或恢复状态，LiveData认为观察者处于活动状态，下面的示例代码演示了如何扩展LiveData类:
public class StockLiveData extends LiveData<BigDecimal> {
private StockManager stockManager;
private SimplePriceListener listener = new SimplePriceListener() {
@Override
public void onPriceChanged(BigDecimal price) {
setValue(price);
}
};
public StockLiveData(String symbol) {
stockManager = new StockManager(symbol);
}
@Override
protected void onActive() {
stockManager.requestPriceUpdates(listener);
}
@Override
protected void onInactive() {
stockManager.removeUpdates(listener);
}
}
当LiveData对象有一个活动的观察者时，将调用onActive()方法。这意味着您需要开始观察来自此方法的股票价格更新。
当LiveData对象没有任何活动的观察者时，将调用onInactive()方法。因为没有观察者在听，所以没有理由保持与StockManager服务的连接。
setValue(T)方法更新LiveData实例的值，并将更改通知任何活动的观察者。
你可以使用StockLiveData类如下:
public class MyFragment extends Fragment {
@Override
public void onActivityCreated(Bundle savedInstanceState)
{
super.onActivityCreated(savedInstanceState);
LiveData<BigDecimal> myPriceListener = ...;
myPriceListener.observe(this, price -> {
// Update the UI.
});
}
}
方法observe()将fragment(它是LifecycleOwner的一个实例)作为第一个参数传递。这样做表示这个观察者被绑定到与所有者相关联的生命周期对象，意思是:
如果生命周期对象没有处于活动状态，那么即使值发生变化也不会调用观察者。
在生命周期对象被销毁后，观察者被自动删除。
LiveData对象是生命周期感知的，这意味着您可以在多个活动、片段和服务之间共享它们。为了保持示例的简单性，可以将LiveData类实现为单例，如下所示:
public class StockLiveData extends LiveData<BigDecimal> {
private static StockLiveData sInstance;
private StockManager stockManager;
private SimplePriceListener listener = new SimplePriceListener() {
@Override
public void onPriceChanged(BigDecimal price) {
setValue(price);
}
};
@MainThread
public static StockLiveData get(String symbol) {
if (sInstance == null) {
sInstance = new StockLiveData(symbol);
} return sInstance;
}
private StockLiveData(String symbol) {
stockManager = new StockManager(symbol);
}
@Override
protected void onActive() {
stockManager.requestPriceUpdates(listener);
}
@Override
protected void onInactive() {
stockManager.removeUpdates(listener);
}
}
你可以在fragment 使用它:
public class MyFragment extends Fragment {
@Override
public void onActivityCreated(Bundle savedInstanceState) {
StockLiveData.get(symbol).observe(this, price -> {
// Update the UI.
});
}
}
多个Fragment和actvity 可以观察MyPriceListener实例。LiveData仅在其中一个或多个服务可见且处于活动状态时才连接到系统服务。
5、变换LiveData
您可能希望在将LiveData对象发送给观察者之前对其存储的值进行更改，或者您可能需要根据另一个LiveData实例的值返回另一个LiveData实例。生命周期包提供转换类，该类包含支持这些场景的辅助方法。
[Transformations.map()](https://developer.android.google.cn/reference/androidx/lifecycle/Transformations.html#map(android.arch.lifecycle.LiveData, android.arch.core.util.Function))
将函数应用于存储在LiveData对象中的值，并将结果向下传播
LiveData<User> userLiveData = ...;
LiveData<String> userName = Transformations.map(userLiveData, user -> { user.name + " " + user.lastName});
[Transformations.switchMap()](https://developer.android.google.cn/reference/androidx/lifecycle/Transformations.html#switchMap(android.arch.lifecycle.LiveData, android.arch.core.util.Function>))
与map()类似，将函数应用于LiveData对象中存储的值，并将结果解包并分发到下游。传递给switchMap()的函数必须返回LiveData对象，如下例所示:
private LiveData<User> getUser(String id) {
...;
}
LiveData<String> userId = ...;
LiveData<User> user = Transformations.switchMap(userId, id -> getUser(id) );
您可以使用转换方法来在观察者的生命周期中传递信息。除非观察者正在查看返回的LiveData对象，否则不会计算转换。因为转换是延迟计算的，所以与生命周期相关的行为是隐式传递的，不需要额外的显式调用或依赖关系。
如果您认为在ViewModel对象中需要一个生命周期对象，那么转换可能是更好的解决方案。例如，假设您有一个UI组件，它接受一个地址并返回该地址的邮政编码。你可以为这个组件实现朴素的ViewModel，如下面的示例代码所示:
class MyViewModel extends ViewModel{
private final PostalCodeRepository repository;
public MyViewModel(PostalCodeRepository respository){
this.repository = respository;
}
private ListData<String> getPostalCode(String address){
//don't do this
return repository.getPostCode(address);
}
}
然后，UI组件需要从先前的LiveData对象注销，并在每次调用getPostalCode()时注册到新实例。此外，如果重新创建了UI组件，它将触发对储存库. getpostcode()方法的另一个调用，而不是使用前一个调用的结果。
相反，您可以将邮政编码查找实现为地址输入的转换，如下面的示例所示:
class MyViewModel extends ViewModel{
private final PostalCodeRepository repository;
private final MutableLiveData<String> addressInput = new MutableLiveData();
public final LiveData<String> postalCode = Transformations.switchMap(addressInput,(address) -> {
return repository.getPostCode(address);
})
public MyViewModel(PostalCodeRepository repository){
this.repository = repository;
}
private void setInput(String address){
addressInput.setValue(address);
}
}
在本例中，postalCode字段被定义为addressInput的转换。只要您的应用程序有一个与postalCode字段关联的活动观察者，每当addressInput发生更改时，就会重新计算和检索字段的值。
这种机制允许应用程序的低层创建按需延迟计算的LiveData对象。ViewModel对象可以很容易地获得对LiveData对象的引用，然后在其上定义转换规则。
4、创建新的转换
在你的应用程序中有许多不同的转换可能是有用的，但它们不是默认提供的。要实现自己的转换，可以使用MediatorLiveData类，它侦听其他LiveData对象并处理它们发出的事件。MediatorLiveData正确地将其状态传播到源LiveData对象。要了解关于此模式的更多信息，请参阅转换类的参考文档。
5、合并多个LiveData 源
MediatorLiveData是LiveData的一个子类，它允许您合并多个LiveData源。当任何原始LiveData源对象发生更改时，就会触发MediatorLiveData对象的观察者。
例如，如果您的UI中有一个可以从本地数据库或网络更新的LiveData对象，那么您可以将以下源添加到MediatorLiveData对象:
与数据库中存储的数据相关联的LiveData对象。
与从网络访问的数据相关联的LiveData对象。
您的活动只需要观察MediatorLiveData对象就可以接收来自两个源的更新。有关详细示例，请参见App架构指南的附录:暴露网络状态部分。
6、LiveData 源码分析
6.1、jar 包结构
androidx.lifecycle:lifecycle-livedata-core:
- LiveData
- MutableLiveData
- Observer
androidx.lifecycle:lifecycle-livedata:
- ComputableLiveData
- MediatorLiveData
- Transformations
6.1.1、具体类分析
LiveData：
LiveData是一个数据持有者类，可以在给定的生命周期内被观察到 包含了两种 注册方法 observe 方法以及 observeForever 方法
observe ：
在生命周期内 进行监听 如果生命周期 为 STARTED 时一直进行监听，该监听在生命周期结束时自动取消监听，不需要remove 监听
@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
assertMainThread("observe");
if (owner.getLifecycle().getCurrentState() == DESTROYED) {
//如果 lifeRecycle destory 直接返回不做任何处理
return;
}
//绑定了 LifeRecycle 组件
LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
// 用 SafeIterableMap 来维护 observer 用来进行状态分发
ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
if (existing != null && !existing.isAttachedTo(owner)) {
throw new IllegalArgumentException("Cannot add the same observer"
+ " with different lifecycles");
}
if (existing != null) {
return;
}
owner.getLifecycle().addObserver(wrapper);
}
LifecycleBoundObserver 实际上是一个 LifecycleObserver ：
class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver {
@NonNull
final LifecycleOwner mOwner;
LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<? super T> observer) {
super(observer);
mOwner = owner;
}
@Override
boolean shouldBeActive() {
//生命为STARTED 时 监听liveData 对象的数据变化
return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
}
@Override
public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
//当生命周期为 DESTROYED 自动取消监听
if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
removeObserver(mObserver);
return;
}
activeStateChanged(shouldBeActive());
}
@Override
boolean isAttachedTo(LifecycleOwner owner) {
return mOwner == owner;
}
@Override
void detachObserver() {
mOwner.getLifecycle().removeObserver(this);
}
}
observeForever ：在生命周期内 一直进行监听，该监听在生命周期结束时需要手动 removeObserver
@MainThread
public void observeForever(@NonNull Observer<? super T> observer) {
assertMainThread("observeForever");
//和 observe 不同在于 此处的观察者 为 AlwaysActiveObserver
AlwaysActiveObserver wrapper = new AlwaysActiveObserver(observer);
ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
if (existing != null && existing instanceof LiveData.LifecycleBoundObserver) {
throw new IllegalArgumentException("Cannot add the same observer"
+ " with different lifecycles");
}
if (existing != null) {
return;
}
wrapper.activeStateChanged(true);
}
AlwaysActiveObserver：
private class AlwaysActiveObserver extends ObserverWrapper {
AlwaysActiveObserver(Observer<? super T> observer) {
super(observer);
}
@Override
boolean shouldBeActive() {
return true; //一直返回的是true
}
}
当注册监听之后通过 setValue 进行触发（observe）：
@MainThread
protected void setValue(T value) {
assertMainThread("setValue");
mVersion++;
mData = value;
//分发状态变化
dispatchingValue(null);
}
@SuppressWarnings("WeakerAccess") /* synthetic access */
void dispatchingValue(@Nullable ObserverWrapper initiator) {
if (mDispatchingValue) {
mDispatchInvalidated = true;
return;
}
mDispatchingValue = true;
do {
mDispatchInvalidated = false;
if (initiator != null) {
considerNotify(initiator);
initiator = null;
} else {
for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
//通知
considerNotify(iterator.next().getValue());
if (mDispatchInvalidated) {
break;
}
}
}
} while (mDispatchInvalidated);
mDispatchingValue = false;
}
private void considerNotify(ObserverWrapper observer) {
if (!observer.mActive) {
return;
}
//对应 LifecycleBoundObserver.shouldBeActive() 方法
if (!observer.shouldBeActive()) {
observer.activeStateChanged(false);
return;
}
// mVersion 在 setValue 方法中进行了 ++ （mVersion++;）
if (observer.mLastVersion >= mVersion) {
return;
}
observer.mLastVersion = mVersion;
//触发onChage 方法
observer.mObserver.onChanged((T) mData);
}
通过observeForever注册 Observer 方法内部和 observe 类似 observeForever 没有添加到LifeRecycle 中，故生命周期状态需要手动去 处理
MutableLiveData：
ComputableLiveData：
MediatorLiveData:
Transformations:
这几个类的解析以及综合流程我们下一章节 进行分析
7、LiveData 与 ViewModel 结合使用
7.1、 ViewModel 简介
ViewModel类被设计成以生命周期的方式存储和管理ui相关的数据。ViewModel类允许数据在配置更改(如屏幕旋转)后仍然存在。Android框架管理UI控制器的生命周期，比如acitivity和fragment。框架可能决定销毁或重新创建一个UI控制器，以响应某些用户操作或设备事件，这些操作或事件完全超出了您的控制。
如果系统破坏或重新创建一个UI控制器，那么您存储在其中的任何与UI相关的临时数据都将丢失。例如，您的应用程序可能在其某个活动中包含一个用户列表。当为配置更改重新创建活动时，新活动必须重新获取用户列表。对于简单数据,activity可以使用仅有()方法并恢复其包的数据在onCreate(),但这种方法只适用于少量的数据可以序列化反序列化,而不是潜在的大量数据的用户列表或位图。
另一个问题是UI控制器经常需要进行异步调用，这可能需要一些时间才能返回。UI控制器需要管理这些调用，并确保系统在销毁后对其进行清理，以避免潜在的内存泄漏。这种管理需要大量的维护，并且在为了配置更改而重新创建对象的情况下，这是对资源的浪费，因为对象可能不得不重新发出它已经发出的调用。
activikty和fragment等UI控制器主要用于显示UI数据、响应用户操作或处理操作系统通信(如权限请求)。要求UI控制器也负责从数据库或网络加载数据会使类膨胀。将过多的责任分配给UI控制器可能会导致单个类试图自己处理应用程序的所有工作，而不是将工作委托给其他类。以这种方式将过多的责任分配给UI控制器也会使测试变得更加困难。
将视图数据所有权从UI控制器逻辑中分离出来更简单、更有效。
7.2、ViewModel的生命周期
7.3、ViewModel 的用途
-
在fragment 间共享数据
-
用ViewModel 替换加载器
- 在使用加载器的一种常见方法中，应用程序可能使用一个指针加载器来观察数据库的内容。当数据库中的一个值发生变化时，加载器会自动触发数据的重新加载，并更新用户界面:
-
使用liveData
ViewModel与Room和LiveData一起工作，以取代加载器。ViewModel确保数据在设备配置更改后仍然存在。当数据库发生更改时，Room会通知LiveData，而LiveData又会用修改后的数据更新您的UI。
- 在ViewModel中使用协同程序
7.3、ViewModel 源码分析
7.3.1、ViewModelProviders：
ViewModelProviders ：一个工具类，封装了 ViewModelStore 的一些方法 ，该类提供的方法创建了一个 ViewModelProvider 对象
@NonNull
@MainThread
public static ViewModelProvider of(@NonNull FragmentActivity activity) {
return of(activity, null);
}
@NonNull
@MainThread
public static ViewModelProvider of(@NonNull Fragment fragment) {
return of(fragment, null);
}
创建一个ViewModelProvider 对象
7.3.2、ViewModelProvider：
interface Factory:
-
create(@NonNull Class modelClass)
用来创建一个ViewModel 对象
KeyedFactory implements Factory
- Factory 的实现类 为生成的每一个 modelView 指定了一个key 值，生成的对象必须是 modelView 的子类
get(@NonNull Class modelClass) ：
-
获取viewModle 的核心方法，在activity 或者 fragemnt 中创建一个viewModel 或者返回一个存在的viewModel,该viewModel 作用于整个生命周期，所有viewModel 是通过一个 hashMap 进行维护
@NonNull @MainThread public <T extends ViewModel> T get(@NonNull String key, @NonNull Class<T> modelClass) { ViewModel viewModel = mViewModelStore.get(key); // 一个对象是本身类的一个对象 if (modelClass.isInstance(viewModel)) { //如果该viewModel存在 返回 return (T) viewModel; } else { if (viewModel != null) { // TODO: log a warning. } } //如果没有指定Factory 使用默认的 AndroidViewModelFactory 来创建ViewModel if (mFactory instanceof KeyedFactory) { viewModel = ((KeyedFactory) (mFactory)).create(key, modelClass); } else { viewModel = (mFactory).create(modelClass); } mViewModelStore.put(key, viewModel); //noinspection unchecked return (T) viewModel; }vviewModelProvider 和 viewModelProviders 这两个类代码很简单功能也很简单 仅仅是创建了一个 通过了Factory 创建了viewModel 放到一个Map 中进行维护，有没有注意到 维护 viewModel 中的map 没有被创建，那么它是在哪被创建的呢？ 在 lifecycle-viewmodel 包中还有一个接口呢 ViewModelStoreOwner
7.3.4、ViewModelStoreOwner ：
该接口只有一个 getViewModelStore 方法，该接口在 ComponentActivity 中实现了，创建了一个viewModel 对象，该对象在该类的 构造方法中使用到了
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.");
}
if (mViewModelStore == null) {
NonConfigurationInstances nc =
(NonConfigurationInstances) getLastNonConfigurationInstance();
if (nc != null) {
// Restore the ViewModelStore from NonConfigurationInstances
mViewModelStore = nc.viewModelStore;
}
if (mViewModelStore == null) {
//创建了一个ViewModelStore
mViewModelStore = new ViewModelStore();
}
}
return mViewModelStore;
}
getLifecycle().addObserver(new LifecycleEventObserver() {
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
if (event == Lifecycle.Event.ON_DESTROY) {
if (!isChangingConfigurations()) {
//清楚viewModelStore
getViewModelStore().clear();
}
}
}
});
当 生命周期结束是 viewModelStore 中的 viewModel 被清空，这里有一个问题，viewModel对象放进 viewModelStore 中如何被监听数据的变化呢 ？ 这里就需要jetPack 另外一个组件了 LiveData 也可以自定义实现 、结合RxJava 进行处理
448
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
