1.Lifecycle
Lifecycle的意识是生命周期，它是Jetpack中的一个生命周期感知型组件 ，可执行操作来感知响应另一个组件（如 Activity 和 Fragment）的生命周期状态的变化。
activity 和fragment 是有生命周期的，有时候，我们的很多操作需要写在生命周期的方法中，比如下载文件操作等，这样很多情况下会导致在activity的生命周期方法中写越来越多的代码，activity或者fragment 越来越臃肿，代码维护越来越困难。 使用lifecycle就可以很好的解决这类问题。
Lifecycle的出现就是为了解耦系统组件的生命周期与自定义组件之间耦合，比如以前如果自定义的组件需要在Activity对应的生命周期做相应的处理的话，就需要重写Activity的生命周期然后在生命周期方法里做相应的处理，而现在可以通过Lifecycle省略掉重写生命周期方法这个步骤。
lifecycle通过实现LifecycleObserver接口来监听生命周期，然后在activity和fragment中去注册监听。
Lifecycle的实现使用了观察者模式，它通过Owner和Observer的配合来实现了生命周期的解耦。
Lifecycle需要在AndroidX的环境里才能使用。
?
几个重要的类和接口：
①Lifecycle：Lifecycle是一个持有组件（如Activity或Fragment）生命周期状态的信息的类，并允许其他对象观察此状态。
②Event ：从框架和Lifecycle类派发的生命周期事件。这些事件映射到Activity和Fragment中的回调事件中。
③State ：由Lifecycle对象跟踪的组件的当前状态。
④LifecycleOwner：Lifecycle持有者
实现该接口的类持有生命周期(Lifecycle对象)，该接口的生命周期(Lifecycle对象)的改变会被其注册的观察者LifecycleObserver观察到并触发其对应的事件。
⑤LifecycleObserver：Lifecycle观察者
实现该接口的类，通过注解的方式，可以通过被LifecycleOwner类的addObserver(LifecycleObserver o)方法注册，被注册后，LifecycleObserver便可以观察到LifecycleOwner的生命周期事件。
?
LifeCycle中有两个重要的接口LifeCycleOwner和LifecycleObserver：
①LifecycleOwner（生命周期持有者接口）
LifecycleOwner是一个单一的方法接口，表示该类有一个 Lifecycle。它有一个方法getLifecycle()，这个方法必须由这个类来实现。任何自定义应用程序类都可以实现LifecycleOwner接口。实现LifecycleObserver的组件与实现LifecycleOwner的组件无缝协作，因为所有者可以提供生命周期，观察者可以注册以观看。
简单来说，LifecycleOwner就是一个接口，谁继承了它，就持有了lifecycle对象。然后就可以调用getLifecycle()方法获取继承了抽象类Lifecycle的LifecycleRegistry，然后调用 addObserver(@NonNull LifecycleObserver observer) 方法来注册监听。
这样，该接口的生命周期(Lifecycle对象)的改变会被其注册的观察者LifecycleObserver观察到并触发其对应的事件。
注意：Support Library 26.1.0 及其以后的版本，Activity 和Fragment 已经实现了LifecycleOwner 接口，所以可以直接在Activity和Fragment中使用getLifecycle()方法来获取lifecycle对象，来添加观察者监听。
②LifecycleObserver（生命周期观察者接口）
LifecycleObserver是一个观察者接口，实现了它，可以通过注解或者继承的方式来管理声明周期的监听。只要在持有lifecycle的类中注册了它，当声明周期发生变化时，它就能收到，进行自定义的操作。
两种实现方式：
1)实现DefultLifecyceObserver接口，然后重写里面生命周期方法；
2)直接实现LifecycleObserver接口，然后通过注解的方式来接收生命周期的变化；
Lifecycle.java文档中建议使用第一种方式，因为文档中说明了，随着Java8成为主流，注解的方式会被弃用。DefaultLifecycleObserver需要另外声明的java8，比如GenericLifecycleObserver，FullLifecycleObserver，DefaultLifecycleObserver 三个接口都直接或间接继承的LifecycleObserver
?// 如果使用的是java 8要显示声明如下的
def lifecycle_version = "1.1.1"
implementation "android.arch.lifecycle:common-java8:$lifecycle_version"
?
2.LifeCycle用法
(1)Activity中使用
首先Activity需要继承自AppCompatActivity，因为它继承了FragmentActivity，而FragmentActivity继承自ComponentActivity，ComponentActivity实现了LifecycleOwner这个接口，LifecycleOwner接口就是实现生命周期解耦的关键。
然后需要在自定义组件中实现LifecycleObserver接口或DefultLifecyceObserver接口。
举例：
先写两个简单的Activity，FirstActivity 和SecondActivity，单纯的一个跳转。
先写一个需要拥有生命周期的类，正常自定义控件或者做其他逻辑的类，是没有生命周期的，现在有了LifecycleObserver，就可以让一个普通的类拥有感知声明周期变化的能力。比如，现在自定义一个MyObserver类。
public class MyObserver implements DefaultLifecycleObserver{
? ? private LifeCycle lifecycle;
? ? public MyObserver(LifeCycle lifecycle){
? ? ? ? this.lifecycle = lifecycle;
? ? }
? ? @Override
? ? public void onCreate(LifecycleOwner owner){
? ? ? ? Log.d(TAG,"onCreate()");
? ? ? ? Log.d(TAG,"当前生命周期状态="+lifecycle.getCurrentState().name());
? ? }
? ? @Override
? ? public void onStart(LifecycleOwner owner) {
? ? ? ? Log.d(TAG,"onStart()");
? ? ? ? Log.d(TAG,"当前生命周期状态="+lifecycle.getCurrentState().name());
? ? }
? ? @Override
? ? public void onResume(LifecycleOwner owner){
? ? ? ? Log.d(TAG,"onResume()");
? ? ? ? Log.d(TAG,"当前生命周期状态="+lifecycle.getCurrentState().name());
? ? }
? ? @Override
? ? public void onPause(LifecycleOwner owner) {
? ? ? ? Log.d(TAG,"onPause()");
? ? ? ? Log.d(TAG,"当前生命周期状态="+lifecycle.getCurrentState().name());
? ? }
? ? @Override
? ? public void onStop(LifecycleOwner owner) {
? ? ? ? Log.d(TAG,"onStop()");
? ? ? ? Log.d(TAG,"当前生命周期状态="+lifecycle.getCurrentState().name());
? ? }
? ? @Override
? ? public void onDestroy(LifecycleOwner owner) {
? ? ? ? Log.d(TAG,"onDestroy() ");
? ? ? ? Log.d(TAG,"当前生命周期状态="+lifecycle.getCurrentState().name());
? ? }
}
采取的是直接继承DefaultLifecycleObserver接口，然后实现它所有的方法。在每个方法里打了log来查看，是否这个类收到了activity生命周期的变化。
接下来，要做的就是注册监听：
在Activity的OnCreate方法中，调用getLifecycle()：
public class FirstActivity extends AppCompatActivity {
? ? private Button firstBtn;
? ? @Override
? ? protected void onCreate(Bundle savedInstanceState) {
? ? ? ? super.onCreate(savedInstanceState);
? ? ? ? setContentView( R.layout.first_activity_layout);
? ? ? ? initView();
? ? ? ? initListener();
? ? ? ? //添加了这一行代码
? ? ? ? getLifecycle().addObserver(new MyObserver());
? ? }
? ? private void initListener() {
? ? ? ? firstBtn.setOnClickListener(new View.OnClickListener() {
? ? ? ? ? ? @Override
? ? ? ? ? ? public void onClick(View v) {
? ? ? ? ? ? ? ? Intent intent = new Intent(FirstActivity.this, SecondActivity.class);
? ? ? ? ? ? ? ? startActivity(intent);
? ? ? ? ? ? }
? ? ? ? });
? ? }
}
api26.1以后，Activity中可以直接 getLifecycle().addObserver(new MyObserver()); 这样，就注册了生命周期观察者的监听。
运行，启动FirstActivity，查看log：
可以看到，启动FirstActivity后，MyObserver类就已经监听到了Activity的生命周期方法。并且，和图中表示一致，各个生命周期方法对应相应的节点。比如，onResume()方法执行后，Activity处于RESUME状态，就可以通过判断这个状态来做一些事情。
点击跳转到SecondActivity：
可以看到，FirstActivity声明周期走了onPause、onStop，MyObserver也成功监听到了，继续返回FirstActivity：
最后，点击返回键，退出FirstActivity：
通过这个例子，可以看到，自定义的类只要实现了LifecycleObserver接口，然后在Activity或者Fragment中通过getLifecycle().addObserver()方法，把这个类的对象传入，就可以实现生命周期的感应监听。
当然，可以在初始化这个类的时候，把Lifecycle对象传入，那自定义的类就可以自己去管理生命周期，而不依赖activity或者fragment。 这样，activity在使用此类的时候就不必关系生命周期的问题，因为，在这个类里面已经处理了。比如： 给MyObserver类添加一个构造方法，传入一个Lifecycle对象。
要注意：
①生命周期状态为RESUMED时，表示当前activity 在前台并且可交互，也就是onResume()执行后。
②生命周期状态为STARTED时，表示当前activity处于可见但是不可交互，也就是onStart()方法刚执行完或者onPause()方法刚执行完的状态。
③生命周期状态为CREATED，表示onCreate()方法刚刚执行完或者onStop()方法刚刚执行完，也就是当前activity不在前台，但是也没有处于销毁状态。
④生命周期状态为DESTORYED，表示当前Activity还不存在，没有被创建或者已经销毁，我们通常考虑比较多的就是，onDestory()方法执行后，当前Activity已经销毁。
所以，如果要保证在Activity或者Fragment的有效生命周期内进行的操作，必须判断当前lifecycle的状态是否至少是CREATED状态，避免Activity或者fragment销毁了以后，回调或者网络请求才回来，此时做一些操作会导致异常。
添加以下代码，就是把lifecycle对象传给观察者，让它自己去判断回调后的代码，保证至少是CREATED状态：
private Lifecycle lifecycle;
public MyObserver(Lifecycle lifecycle) {
? ? ?this.lifecycle = lifecycle;
}
//然后在相应的回调方法中使用下面代码判断，保证数据回调回来，当前activity是存在的
if(lifecycle.getCurrentState().isAtLeast(CREATED)) {
? ? ? ? ? ? //这里只是示例，不一定是CREATED
}
这里用到了Lifecycle类的方法，下面看一下Lifecycle的源码：
Lifecycle.java:
public abstract class Lifecycle {
? ? //添加将在LifecycleOwner更改状态时通知的LifecycleObserver
? ? @MainThread
? ? public abstract void addObserver(@NonNull LifecycleObserver observer);
? ? //从观察者列表中删除给定的观察者
? ? @MainThread
? ? public abstract void removeObserver( @NonNull LifecycleObserver observer);
? ? //返回生命周期的当前状态
? ? @MainThread
? ? public abstract State getCurrentState();
? ? @SuppressWarnings("WeakerAccess")
? ? public enum Event {
? ? ? ? ON_CREATE,//用于onCreate事件的常量LifecycleOwner
? ? ? ? ON_START,
? ? ? ? ON_RESUME,
? ? ? ? ON_PAUSE,
? ? ? ? ON_STOP,
? ? ? ? ON_DESTROY,
? ? ? ? ON_ANY //一个Event可以用来匹配所有事件的常数。?
? ? }
? ? @SuppressWarnings("WeakerAccess")
? ? public enum State {
? ? ? ? DESTROYED,
? ? ? ? INITIALIZED, //LifecycleOwner的初始化状态
? ? ? ? CREATED,?
? ? ? ? STARTED,
? ? ? ? RESUMED;
? ? ? ? //比较此状态是否大于或等于给定值state
? ? ? ? public boolean isAtLeast(@NonNull State state) {
? ? ? ? ? ? return compareTo(state) >= 0;
? ? ? ? }
? ? }
}
LifecycleObserver.java:
@SuppressWarnings("WeakerAccess")
public interface LifecycleObserver {
}
可见，Lifecycle就是一个抽象类。
(2)Fragment中使用
Fragment中的使用与在Activity中的使用没有太大差异。
(3)Service中使用
Service中使用需要先添加如下依赖库到项目：
implementation 'androidx.lifecycle:lifecycle-extensions:2.2.0'
然后新建的Service需要继承LifecycleService，因为LifecycleService实现了LifecycleOwner：
?然后自定义一个组件并且实现LifecycleObserver接口，代码如下：
public class LocationHelper implements LifecycleObserver {
? ? //开始定位? ? ?
?@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
? ? public void startLocation(){
? ? ? ? Log.e(TAG,"开始定位");
? ? }
? ? //?停止定位?
?@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
? ? public void stopLocation(){
? ? ? ? Log.e(TAG,"停止定位");
? ? }
}
然后在Service中添加监听：
public class MyService extends LifecycleService{
? ? public MyService() {
? ? ? ? LocationHelper locationHelper = new LocationHelper();
? ? ? ? getLifecycle().addObserver(locationHelper);
? ? }
}
然后在Activity中添加启动服务和停止服务的逻辑：
public class MainActivity extends AppCompatActivity {
? ? private Button bt_start,bt_stop;
? ? @Override
? ? protected void onCreate(Bundle savedInstanceState) {
? ? ? ? super.onCreate(savedInstanceState);
? ? ? ? setContentView(R.layout.activity_main);
? ? ? ? //开启和结束服务
? ? ? ? bt_start = findViewById(R.id.bt_start);
? ? ? ? bt_stop = findViewById(R.id.bt_stop);
? ? ? ? final Intent intent = new Intent(this, MyService.class);
? ? ? ? bt_start.setOnClickListener(v->{
? ? ? ? ? ? startService(intent);
? ? ? ? });
? ? ? ? bt_stop.setOnClickListener(v->{
? ? ? ? ? ? stopService(intent);
? ? ? ? });
? ? }
}
别忘了在manifest里注册service。
运行APP效果如下：
(4)Application中使用
在Application中使用可以监听到APP是在前台还是在后台，要想使用也需要添加如下依赖库（与Service一样）
implementation 'androidx.lifecycle:lifecycle-extensions:2.2.0'
先创建一个用于监听Application生命周期的观察者类：
public class MyApplicationObserver implements LifecycleObserver {??
??@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
? ? public void onCreate(){
? ? ? ? Log.e(TAG,"onCreate");
? ? }
? ? @OnLifecycleEvent(Lifecycle.Event.ON_START)
? ? public void onStart(){
? ? ? ? Log.e(TAG,"onStart");
? ? }
? ? @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
? ? public void onResume(){
? ? ? ? Log.e(TAG,"onResume");
? ? }
? ? @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
? ? public void onPause(){
? ? ? ? Log.e(TAG,"onPause");
? ? }
? ? @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
? ? public void onStop(){
? ? ? ? Log.e(TAG,"onStop");
? ? }
? ? @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
? ? public void onDestroy(){
? ? ? ? Log.e(TAG,"onDestroy");
? ? }
}
然后创建一个Application，在onCreate方法中添加监听，不过这里使用的ProcessLifecycleOwner来添加监听的，代码如下：
public class MyApplication extends Application {
? ? @Override
? ? public void onCreate() {
? ? ? ? super.onCreate();
? ? ? ? ProcessLifecycleOwner.get().getLifecycle(). addObserver(new MyApplicationObserver());
? ? }
}
然后运行APP，运行效果如下：
?可以发现APP刚启动的时候会执行onCreate方法，当APP切换到前台的时候会执行onStart和onResume方法，当APP切换到后台的时候会执行onPause和onStop方法，而onDestory方法永远不会执行。
?
3.LifeCycle原理
调用ComponentActivity的getLifecycle()方法，会返回了一个mLifecycleRegistry：
ComponentActivity.class
? ? @Override
? ? public Lifecycle getLifecycle() {
? ? ? ? return mLifecycleRegistry;
? ? }
}
那就从ComponentActivity入手，会发现它实现了LifecycleOwner接口，并且初始化了LifecycleRegistry：
public class?Component activity extends androidx.core.app.ComponentActivity implements LifeCycleOwner {
? ? private final LifecycleRegistry mLifecycleRegistry(this);
? ? ……
}
mLifecycleRegistry是一个LifecycleRegistry对象，首先看一下它的addObserver方法
@Override
public void addObserver(LifecycleObserver observer) {
? ? State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
? ??ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
? ? ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
? ??if (previous != null) {
? ? ? ? return;
? ??}
? ? LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
? ??if (lifecycleOwner == null) {
? ? ? ??// it is null we should be destroyed. Fallback quickly
? ? ?? ?return;
? ? }
? ? boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
? ??State targetState = calculateTargetState(observer);
? ??mAddingObserverCounter++;
? ? while ((statefulObserver.mState.compareTo( targetState) < 0 && mObserverMap.contains( observer))) {
? ? ? ? pushParentState(statefulObserver.mState);
? ? ? ?final Event event = Event.upFrom( statefulObserver.mState);
? ? ? ? if(event == null) {
? ? ? ? ? ? throw new IllegalStateException("no event up from" + statefulObserver.mState);
? ? ? ? }
? ? ? ? statefulObserver.dispatchEvent( lifecycleOwner, event);
? ? ?? ?popParentState();
? ? ? ??// mState / subling may have been changed recalculate
? ? ? ??targetState =calculateTargetState(observer);
?? ?}
? ? if (!isReentrance) {
? ? ?? ?// we do sync only on the top level.
? ? ?? ?sync();
? ? }
? ? mAddingObserverCounter--;
}
可以看到，addObserver()方法的参数传给了ObserverWithState。
static class ObserverWithState {
?? ?State mState;
?? ?LifecycleEventObserver mLifecycleObserver;
? ??ObserverWithState(LifecycleObserver observer, State initialState) {
? ?? ? ?mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
? ? ? ? mState = initialState;
? ??}
? ? void dispatchEvent(LifecycleOwner owner, Event event) {
? ? ? ? State newState = getStateAfter(event);
? ? ? ? mState = min(mState, newState);
? ? ? ??mLifecycleObserver.onStateChanged(owner, event);
? ? ? ? mState = newState;
? ? }
}
ObserverWithState会调用Lifecycling.lifecycleEventObserver方法，然后创建ReflectiveGenericLifecycleObserver对象,然后调用ClassesInfoCache.sInstance.getInfo,这个方法传入的是我们的MytViewModelLifecycle的对象,拿到他的class,然后通过反射拿到MytViewModelLifecycle方法和注解并且存入map?(在反射中一般都是通过map去存取提高性能)
?
?
