生命周期感知组件-LifeCycle
1、LifeCycle能够做什么
支持生命周期的组件执行操作以响应另一个组件（例如Activity和Fragment）的生命周期状态更改。
这些组件可帮助你生成组织性更好，并且通常重量更轻的代码，这些代码更易于维护。
2、为什么需要Lifecycle组件
常见的模式是在Activity和Fragment的生命周期方法中实现依赖组件的操作。
但是，这种模式导致代码的组织不良以及错误泛滥，一堆看不懂的代码。
通过使用生命周期感知组件，你可以将相关组件的代码从生命周期方法中移出并移入组件本身。
下面来看个例子：
假如需要在生命周期中处理某些事情，可能会有两种方式，一、直接在Activity或者Fragment中的生命周期方法中写代码逻辑；二、写一个接口，定义类似生命周期的方法，在Activity或Fragment中调用相应的方法将逻辑剥离，不过也离不开Activity或Fragment。
/** * Main Presenter */public class MainPresenter implements IPresenter { public MainPresenter(Context context){ } @Override public void onResume() { } @Override public void onStop() { } }
public interface IPresenter { void onResume(); void onStop();}
public class MainActivity extends AppCompatActivity { private static final String TAG = "MainActivity"; private IPresenter mPresenter; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); Log.d(TAG, "onCreate: "); setContentView(R.layout.activity_main); mPresenter = new MainPresenter(this); } @Override protected void onResume() { super.onResume(); Log.d(TAG, "onResume: "); mPresenter.onResume(); } @Override protected void onStop() { super.onStop(); Log.d(TAG, "onStop: "); mPresenter.onStop(); }}
IPresenter中定义和生命周期相关的几个方法，然后在MainActivity中调用对应的方法。这样做会有个问题：在MainActivity中的每个生命周期方法中都要调用一次IPresenter中的接口。那有没有更好的办法呢，这时候LifeCycle就该上场了：
public class MainPresenter implements IPresenter { private static final String TAG = "MainPresenter"; public MainPresenter(Context context){ } @Override public void onCreate(LifecycleOwner owner) { Log.d(TAG, "onCreate: "); } @Override public void onStart(LifecycleOwner owner) { Log.d(TAG, "onStart: "); } @Override public void onResume(LifecycleOwner owner) { Log.d(TAG, "onResume: "); } @Override public void onPause(LifecycleOwner owner) { Log.d(TAG, "onPause: "); } @Override public void onStop(LifecycleOwner owner) { Log.d(TAG, "onStop: "); } @Override public void onDestroy(LifecycleOwner owner) { Log.d(TAG, "onDestroy: "); }}
public interface IPresenter extends DefaultLifecycleObserver{}
public class MainActivity extends AppCompatActivity { private static final String TAG = "MainActivity"; private IPresenter mPresenter; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); Log.d(TAG, "onCreate: "); setContentView(R.layout.activity_main); mPresenter = new MainPresenter(this); getLifecycle().addObserver(mPresenter); }}
代码是不是很简单，尤其是Activity。
IPrestener 接口继承 DefaultLifecycleObserver 接口，然后 MainPresenter 实现 IPresenter 接口，在 MainPresenter 中，可以把 DefaultLifecycleObserver 中生命周期的方法全实现，也可以选择实现其中几个，比如你只关心 MainActivity 的 onCreate() 和 onDestroy() ，那么你就可以在 MainPresenter 中实现 onCreate() 和 onDestroy() 方法。借助实现 DefaultLifecycleObserver 接口可以让我们少写很多代码。
到这里大家可能就非常想知道Lifecycle组件实现的原理是什么？那么接着向下看。
3、LifeCycle实现原理
先来看一张图：
我们以V4包中的 Fragment（AppCompatActivity类似）为例，看下 Fragment 和 LifecycleOwner、LifecycleObserver、Lifecycle 之间的类关系图。
Lifecycle 组件成员Lifecycle被定义成了抽象类，LifecycleOwner、LifecycleObserver 被定义成了接口；
Fragment 实现了 LifecycleOwner 接口，该只有一个返回 Lifecycle 对象的方法 getLifecyle()；
Fragment 中 getLifecycle() 方法返回的是继承了抽象类 Lifecycle 的 LifecycleRegistry。
LifecycleRegistry 中定义嵌套类 ObserverWithState，该类持有 GenericLifecycleObserver 对象，而 GenericLifecycleObserver 是继承了 LifecycleObserver 的接口。
再来看一张时序图：
我们在 Fragment（AppCompatActivity也一样）中调用 getLifecycle() 方法得到 LifecycleRegistry 对象，然后调用 addObserver() 方法并将实现了 LifecycleObserver 接口的对象作为参数传进去。这样一个过程就完成了注册监听的过程。
后续就是 Fragment 生命周期变化时，通知 LifecycleObserver 的过程： Fragment的performXXX()、onXXX() 方法； LifecycleRegistry 的 handleLifecycleEvent() 方法； LifecycleObserver 的 onXXX() 方法。
如果你细心点看上面的时序图，你会发现 Fragment 中 performCreate()、performStart()、performResume() 会先调用自身的 onXXX() 方法，然后再调用 LifecycleRegistry 的 handleLifecycleEvent() 方法；而在 performPause()、performStop()、performDestroy() 中会先 LifecycleRegistry 的handleLifecycleEvent() 方法 ，然后调用自身的 onXXX() 方法。
可以看看Fragment源码
4、细节
我们要做的内容主要是实现 LifecycleObserver 接口，然后通过实现了 LifecycleOwner 接口的对象进行注册，以监听其生命周期，后续就是坐等通知了。
5、实现LifecycleObserver接口
从上面的类关系图，我们可以看到有三个接口 GenericLifecycleObserver、FullLifecycleObserver、DefaultLifecycleObserver 都直接或者间接继承了 LifecycleObserver。然而 GenericLifecycleObserver 是隐藏的，我们用不了。那我们该怎么实现 LifecycleObserver 接口呢，有两种方式：
实现 DefaultLifecycleObserver 接口，然后重写里面生命周期方法(如上)；
直接实现 LifecycleObserver 接口，然后通过注解的方式来接收生命周期的变化；
class MyLocationListener implements LifecycleObserver { private boolean enabled = false; public MyLocationListener(Context context, Lifecycle lifecycle, Callback callback) { ... } @OnLifecycleEvent(Lifecycle.Event.ON_START) void start() { } @OnLifecycleEvent(Lifecycle.Event.ON_STOP) void stop() { }}
对于这两种形式，Lifecycle.java 文档中是建议使用第一种方式，因为文档中说明了，随着Java8成为主流，注解的方式会被弃用。
6、添加观察者
实现 LifecycleOwner 后，最后一步，我们直接看添加观察者（ addObserver(实现 LifecycleObserver 的观察者class) ）
生命周期感知组件的最佳实践
尽可能保持你的UI控制器（Activity或Fragment）尽可能精简。他们不应该试图获取他们自己的数据;相反，使用
ViewModel来做到这一点，并观察一个LiveData对象，以反映到视图的变化。尝试编写数据驱动的用户界面，其中你的用户界面控制器的职责是在数据更改时更新视图，或将用户操作通知给用户
ViewModel。把你的数据逻辑放在你的
ViewModelclass 上。ViewModel应该充当你的UI控制器和其他应用程序之间的连接器。但要小心，ViewModel不是用来获取数据的（例如，从网络）。相反，ViewModel应该调用适当的组件来获取数据，然后将结果提供给UI控制器。使用 Data Binding 在视图和UI控制器之间保持干净的界面。这使你可以使你的视图更具说明性，并最大限度地减少需要在 Activity 和 Fragment 中编写的更新代码。如果你喜欢用 Java 编程语言来做到这一点，可以使用像 Butter Knife 这样的库来避免样板代码并且有更好的抽象。
如果你的UI很复杂，请考虑创建一个 presenter 类来处理UI修改。这可能是一项艰巨的任务，但它可以使你的UI组件更易于测试。
避免在你的 ViewModel 中引用一个 View 或 Activity 上下文。如果 ViewModel比 Activity 活的更长（在配置更改的情况下），Activity 就会发生泄漏并且垃圾收集器无法妥善处理。
LiveData
1、LiveData是什么？
LiveData是一个可观察的数据持有者类。
与常规可观察性不同，LiveData具有生命周期感知能力，这意味着它尊重其他应用程序组件（例如Activities，Fragments或Services）的生命周期。这种意识确保LiveData只更新处于活动生命周期状态的应用程序组件观察者。
如果LiveData的Observer生命周期处于STARTED或RESUMED状态，LiveData将认为由该类表示的观察者处于活动状态。LiveData仅通知活跃的观察员关于更新。LiveData未注册观察对象的
非活动观察者不会收到有关更改的通知。
总结为以下三点：
数据可以被观察者订阅；
能够感知组件（Fragment、Activity、Service）的生命周期；
只有在组件出于激活状态（STARTED、RESUMED）才会通知观察者有数据更新；
2、LiveData的优点
- 保证数据和UI统一
LiveData遵循观察者模式。Observer当生命周期状态改变时，LiveData会通知对象。 你可以合并代码以更新这些Observer对象中的UI 。 每次应用程序数据更改时，你的观察者都可以在每次更改时更新UI，而不是每次更新UI。
- 减少内存泄漏
这是因为LiveData能够感知到组件的生命周期，当组件处于DESTROYED状态时，观察者对象会被清除掉。
- Activity停止时不会发生崩溃
如果观察者的生命周期处于非活动状态，例如在后退堆栈中的Activity，不会收到任何LiveData事件。
- 不需要额外的手动处理来响应生命周期的变化
UI组件只是观察相关数据，不会停止或重复观察。
LiveData自动管理所有这些，因为它在观察时意识到相关的生命周期状态更改。
- 始终保持最新的数据
如果生命周期变为非活动状态，它将在再次变为活动状态时收到最新数据。
例如，在请求数据时应用退到后台，此时不会向控件中加载数据，当应用回到前台时，控件会立即收到最新数据。
- 针对configuration change时，不需要额外的处理来保存数据
我们知道，当你把数据存储在组件中时，当configuration change（比如语言、屏幕方向变化）时，组件会被recreate，然而系统并不能保证你的数据能够被恢复的。当我们采用LiveData保存数据时，因为数据和组件分离了。当组件被recreate，数据还是存在LiveData中，并不会被销毁。
- 资源共享
通过继承LiveData类，然后将该类定义成单例模式，在该类封装监听一些系统属性变化，然后通知LiveData的观察者。任何需要该资源的观察者都可以观察该LiveData对象。这个在继承LiveData中会看到具体的例子。
3、LiveData的使用
在了解LiveData定义和优点后，那它到底怎么应用呢？LiveData有几种使用方式：
使用LiveData
继承LiveData
转换LiveData
1）使用LiveData
使用LiveData对象主要有三个步骤：
创建LiveData对象
观察LiveData对象
更新LiveData对象
创建LiveData
Android文档中建议LiveData配合ViewModel使用。LiveData是一个包装器，可用于任何数据，包括实现的对象Collections，例如List。一个 LiveData对象通常存储在一个ViewModel 对象中，并通过getter方法访问。
public class NameViewModel extends ViewModel {// Create a LiveData with a Stringprivate MutableLiveData<String> mCurrentName; public MutableLiveData<String> getCurrentName() { if (mCurrentName == null) { mCurrentName = new MutableLiveData<String>(); } return mCurrentName; }// Rest of the ViewModel...}
观察LiveData
大多数情况下，Activity或Fragment的onCreate方法是观察LiveData的正确位置，原因有以下两点：
确保系统不会从Activity或Fragment的onResume()方法进行多余的调用。
确保Activity或Fragment具有一旦它变为活动状态即可显示的数据。只要应用程序组件处于该 STARTED 状态，它就会从LiveData它所观察的对象中接收最新的值。只有当LiveData要观察的对象已被设置时才会发生这种情况。
通常，LiveData仅在数据更改时传递更新，并且仅传递给活动观察者。
此行为的一个例外是，观察者在从非活动状态变为活动状态时也会收到更新。
此外，如果观察者第二次从非激活状态变为激活状态，则只有在自上一次变为活动状态以来该值发生变化时才会收到更新。
public class NameActivity extends AppCompatActivity { private NameViewModel mModel; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); // Other code to setup the activity... // Get the ViewModel. mModel = ViewModelProviders.of(this).get(NameViewModel.class); // Create the observer which updates the UI. final Observer<String> nameObserver = new Observer<String>() { @Override public void onChanged(@Nullable final String newName) { // Update the UI, in this case, a TextView. mNameTextView.setText(newName); } }; // Observe the LiveData, passing in this activity as the LifecycleOwner and the observer. mModel.getCurrentName().observe(this, nameObserver); }}
更新LiveData
LiveData没有公开可用的方法来更新存储的数据。MutableLiveData 类公开 setValue(T) 和 postValue(T) 方法，如果你需要编辑存储在LiveData对象中的值，你必须使用这些方法。
mButton.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { String anotherName = "Google"; mModel.getCurrentName().setValue(anotherName); }});
LiveData提供了两种改变数据的方法：setValue()和postValue()。区别是setValue()要在主线程中调用，而postValue()既可在主线程也可在子线程中调用。
2）继承LiveData
除了直接使用LiveDatad对象外，我们还可以通过继承LiveData类来定义适合特定需求的LiveData。下面继承LiveData类的例子，验证下LiveData的其中一个优点——资源共享。
public class MyLiveData extends LiveData<Integer> { private static final String TAG = "MyLiveData"; private static MyLiveData sData; private WeakReference<Context> mContextWeakReference; public static MyLiveData getInstance(Context context){ if (sData == null){ sData = new MyLiveData(context); } return sData; } private MyLiveData(Context context){ mContextWeakReference = new WeakReference<>(context); } @Override protected void onActive() { super.onActive(); registerReceiver(); } @Override protected void onInactive() { super.onInactive(); unregisterReceiver(); } private void registerReceiver() { IntentFilter intentFilter = new IntentFilter(); intentFilter.addAction(WifiManager.RSSI_CHANGED_ACTION); mContextWeakReference.get().registerReceiver(mReceiver, intentFilter); } private void unregisterReceiver() { mContextWeakReference.get().unregisterReceiver(mReceiver); } private BroadcastReceiver mReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { String action = intent.getAction(); Log.d(TAG, "action = " + action); if (WifiManager.RSSI_CHANGED_ACTION.equals(action)) { int wifiRssi = intent.getIntExtra(WifiManager.EXTRA_NEW_RSSI, -200); int wifiLevel = WifiManager.calculateSignalLevel( wifiRssi, 4); sData.setValue(wifiLevel); } } };}
MyLiveData是个继承了LiveData的单例类，在onActive()和onInactive()方法中分别注册和反注册Wifi信号强度的广播。然后在广播接收器中更新MyLiveData对象。在使用的时候就可以通过MyLiveData.getInstance()方法，然后通过调用observe()方法来添加观察者对象，订阅Wifi信息强度变化。
3）转换LiveData
LiveData 还支持简单的数据变换。目前在 Transformations 类中有 map 和 switchMap 两个变换函数，如果属性 RxJava 则对这两个函数应该不陌生：
map 是把一个数据类型变换为另外一个数据类型。
switchMap 是把一个数据变化为另外一个 LiveData 。
public class LiveDataActivity extends LifecycleActivity { private TextView mTextView; private TextView mCountryTV; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); mTextView = (TextView) findViewById(R.id.text); mCountryTV = (TextView) findViewById(R.id.country); demoTransformation(); } private void demoTransformation() { LocationLiveData data = LocationLiveData.getsIns(this); LiveData<String> stringLatLon = Transformations.map(data, location -> location.getLatitude() + ", " + location.getLongitude()); stringLatLon.observe(this, latLon -> { mTextView.setText(latLon); }); Transformations.switchMap(data, location -> getCountryName(location)) .observe(this, country -> mCountryTV.setText(country)); } // 返回当前位置所在的国家名字 private LiveData<String> getCountryName(Location loc) { // 只是为了演示，实际中需要把转换的逻辑封装到自定义的 LiveData 中， // 和 LocationLiveData 类似 MutableLiveData<String> ld = new MutableLiveData<>(); ld.postValue("中国"); return ld; }}
使用 Transformation 的好处是可以共享 Lifecycle。如果 Lifecycle 处于未激活状态，则转换函数不会执行。
当你在 ViewModel 中需要一个 Lifecycle 的时候，则可能这个时候就需要使用 Transformation 了。
例如，你现在有个让用户输入地址的界面，当用户输入地址后，去获取对应的邮编，下面是一种天真的 ViewModel 实现方式：
class MyViewModel extends ViewModel { private final PostalCodeRepository repository; public MyViewModel(PostalCodeRepository repository) { this.repository = repository; } private LiveData<String> getPostalCode(String address) { // 不要这样干！！！ return repository.getPostCode(address); }}
上面实现的问题是，当每次调用 getPostalCode() 函数的时候， UI 都需要从前一个 LiveData 中取消注册然后重新注册到 getPostalCode() 函数返回的 LiveData 中。如果 UI 重新创建了，甚至会导致 repository.getPostCode() 重新被调用而不是使用之前缓存的值。
可以使用 Transformation 的 switchMap 来解决上面的问题，把输入的地址当做一个 LiveData，然后根据地址的变化去获取邮编：
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 变量由于无需变化，所以声明为 final 的。postalCode 定义了一个 Transformation 把 addressInput 转换为 邮编。当地址发生变化的时候，如果有活动的 Observer 则会触发 repository.getPostCode() 函数去请求邮编，如果没有活动的 Observer ，则该函数不会执行，当有活动的 Observer 后会继续执行。
有十几种不同的特定转换可能在你的应用中很有用，但它们不是默认提供的。为了实现你自己的转换，你可以使用这个MediatorLiveData 类来监听其他 LiveData对象并处理它们发出的事件。MediatorLiveData正确地将其状态传播到源LiveData对象。要了解更多关于这种模式的信息，请参阅Transformations 该类的参考文档
ViewModel
1、ViewModel是什么
ViewModel，从字面上理解的话，我们也能想到它肯定是跟视图(View)以及数据(Model)相关的。正像它字面意思一样，它是负责准备和管理和UI组件(Fragment/Activity)相关的数据类，也就是说ViewModel是用来管理UI相关的数据的。同时ViewModel还可以用来负责UI组件间的通信，这一点后面我们会有例子说明。
2、ViewModel能够做什么
- 保存（获取）数据
当Activity因为配置更改重新创建时，Activity必须重新获取数据。对于简单的数据，Activity可以使用 onSaveInstanceState()方法并从数据包中恢复其数据 ，但是此方法仅适用于可以序列化然后反序列化的少量数据，而不适用于潜在的大量数据，如用户列表或位图，而由于ViewModel贯穿了Activity的整个生命周期，且recreate时仍然存在，则可以用于保存/获取数据
- 异步获取数据
UI控制器经常需要进行异步调用，这可能需要一些时间才能返回。UI控制器需要管理这些调用，并确保系统在销毁后清理它们以避免潜在的内存泄漏或崩溃。而通过ViewModel，可以拥有跟随Activity或Fragment的生命周期，无需关心内存泄漏和崩溃。
- UI组件（Fragment）之间的通信
public class SharedViewModel extends ViewModel { private final MutableLiveData<Item> selected = new MutableLiveData<Item>(); public void select(Item item) { selected.setValue(item); } public LiveData<Item> getSelected() { return selected; }}public class MasterFragment extends Fragment { private SharedViewModel model; public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); model = ViewModelProviders.of(getActivity()).get(SharedViewModel.class); itemSelector.setOnClickListener(item -> { model.select(item); }); }}public class DetailFragment extends Fragment { public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); SharedViewModel model = ViewModelProviders.of(getActivity()).get(SharedViewModel.class); model.getSelected().observe(this, item -> { // Update the UI. }); }}
3、ViewModel的基本使用
在LiveData中已经使用了ViewModel，大家不记得的可以回头去看 LiveData
4、ViewModel生命周期
先来看下官网的一张图
上图是用Activity作为例子，左侧表示Activity的生命周期状态，右侧绿色部分表示ViewModel的生命周期范围。当屏幕旋转的时候，Activity会被recreate，Activity会经过几个生命周期方法，但是这个时候ViewModel还是之前的对象，并没有被重新创建，只有当Activity的finish()方法被调用时，ViewModel.onCleared()方法会被调用，对象才会被销毁。这张图很好的描述了是当Activity被recreate时，ViewModel的生命周期。
另外，有个注意的地方：在ViewModel中不要持有Activity的引用。为什么要注意这一点呢？从上面的图我们看到，当Activity被recreate时，ViewModel对象并没有被销毁，如果Model持有Activity的引用时就可能会导致内存泄漏。那如果你要使用到Context对象怎么办呢，那就使用ViewModel的子类 AndroidViewModel吧。
5、实现原理
类图
ViewModelProviders是ViewModel工具类，该类提供了通过Fragment和Activity得到ViewModel的方法，而具体实现又是有ViewModelProvider实现的。ViewModelProvider是实现ViewModel创建、获取的工具类。在ViewModelProvider中定义了一个创建ViewModel的接口类——Factory。ViewModelProvider中有个ViewModelStore对象，用于存储ViewModel对象。
ViewModelStore是存储ViewModel的类，具体实现是通过HashMap来保存ViewModle对象。
ViewModel是个抽象类，里面只定义了一个onCleared()方法，该方法在ViewModel不在被使用时调用。ViewModel有一个子类AndroidViewModel，这个类是便于要在ViewModel中使用Context对象，因为我们前面提到是不能在ViewModel中持有Activity的引用。
ViewModelStores是ViewModelStore的工厂方法类，它会关联HolderFragment，HolderFragment有个嵌套类——HolderFragmentManager。
时序图
在使用ViewModel的例子中，也许你会察觉得到一个ViewModel对象需要的步骤有点多啊，怎么不直接new一个出来呢？在你看到ViewModel的类图关系后，你应该就能明白了，因为是会缓存ViewModel对象的。下面以在Fragment中得到ViewModel对象为例看下整个过程的时序图。
时序图看起来比较复杂，但是它只描述了两个过程：
得到ViewModel对象。
HolderFragment被销毁时，ViewModel收到onCleared()通知。
大家也可以结合时序图分析一下源码！
