一.Lifecycle是什么?
生命周期感知型组件可执行操作来响应另一个组件（如 Activity 和 Fragment）的生命周期状态的变化。这些组件有助于您编写出更有条理且往往更精简的代码，此类代码更易于维护。一种常见的模式是在 activity 和 fragment 的生命周期方法中实现依赖组件的操作。但是，这种模式会导致代码条理性很差而且会扩散错误。通过使用生命周期感知型组件，您可以将依赖组件的代码从生命周期方法移入组件本身中。LifeCycle是用于存储有关组件（如 activity 或 fragment）的生命周期状态的信息，并允许其他对象观察此状态。使用两种主要枚举跟踪其关联组件的生命周期状态：跟着官网来学习
二.Lifecycle能解决什么问题？
让业务逻辑感知view的生命周期，避免内存泄漏，并且做到统一管理，防止代码臃肿。
三.LifeCycle怎么用？
要了解怎么用，先要搞清楚一些类的作用!!!
1.LifeCycleOwner
LifecycleOwner 是单一方法接口，表示类具有 Lifecycle。它具有一种方法（即 getLifecycle()），该方法必须由类实现。
public interface LifecycleOwner {
/**
* Returns the Lifecycle of the provider.
*
* @return The lifecycle of the provider.
*/
public val lifecycle: Lifecycle
}
2.Lifecycle
存储相关组件（Activity或Fragment)生命周期的类，并容许其他对象观察,所以你可以把它理解成被观察者，用来存储发布相关组件的声明
3.LifecycleObserver
相关组件的生命周期的观察者，只要想被观察者（组件生命周期）加入到观察者集合中，就可以观察到组件的生命周期做相应的操作了。
不难看出，它是个妥妥的观察者模式，我们只需要拿到将观察者注册到被观察者的中的观察者集合中，只要被观察者的状态改变，通过调用观察者的方法来通知观察者即可。用到这里就是lifecycleower.getLifecycle().addLifecycleObserver(observer)即可。
四.写一份自己的Lifecycle
先来一个抽象观察者LifeCycle
abstract fun addObserver(observer: MyLifeCycleObserver)
abstract fun removeObserver(observer: MyLifeCycleObserver)
abstract fun makeNotice(activityState: ActivityEvent)
abstract fun getCurrentEvent(): ActivityEvent
//生命周期转化
enum class ActivityEvent {
DESTROY, STOP, PAUSE, CREATE, START, RESUME
}
open fun isAtLeast(state: ActivityEvent): Boolean {
return getCurrentEvent() > state
}
我们也搞一个Lifecycleowner 工厂方法 ，owner是生命周期的提供者 也就是被观察者 SevenLifeCycle作为抽象观察者
interface MyLifeCycleOwner {
fun getLifeCycle(): MyLifeCycle
}
抽象观察者LifeCycle的实现类，它才是真正干活的那个家伙，包括添加观察者，通知观察者被观察者的状态
class MyLifeCycleRegistry (lifeCycle: MyLifeCycleOwner): MyLifeCycle() {
/**
* 提供生命周期的provider 如果为空了 就不让其他人感知了，所以要持有owner的引用
*/
private val sevenLifeCycleOwner: MyLifeCycleOwner = lifeCycle
private val sevenLifeCycleObservers= mutableListOf<MyLifeCycleObserver>()
private var activityState = ActivityEvent.DESTROY
override fun addObserver(observer: MyLifeCycleObserver) {
if (!sevenLifeCycleObservers.contains(observer)) {
sevenLifeCycleObservers+=observer
}
}
override fun removeObserver(observer: MyLifeCycleObserver) {
sevenLifeCycleObservers-=observer
}
override fun makeNotice(activityState: ActivityEvent) {
this.activityState = activityState
for (i in sevenLifeCycleObservers.indices) {
sevenLifeCycleObservers[i].onStateChange(activityState)
}
}
override fun getCurrentEvent(): ActivityEvent {
return activityState
}
}
生命周期观察者，没什么好说的，如果你不理解观察者，你想想你玩微信时，你订阅别人的公众号，你就是观察者。
interface MyLifeCycleObserver {
fun onStateChange(activityState: MyLifeCycle.ActivityEvent)
}
最后最重要的，被观察者的提供者，也就是Activity或Fragment
class MyLifeActivity : AppCompatActivity(), MyLifeCycleOwner {
//真正干活的
private val registry = MyLifeCycleRegistry(this)
override fun getLifeCycle(): MyLifeCycle {
return registry
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
registry.makeNotice(MyLifeCycle.ActivityState.CREATE)
}
override fun onStart() {
super.onStart()
registry.makeNotice(MyLifeCycle.ActivityState.START)
}
override fun onResume() {
super.onResume()
registry.makeNotice(MyLifeCycle.ActivityState.RESUME)
}
override fun onPause() {
super.onPause()
registry.makeNotice(MyLifeCycle.ActivityState.PAUSE)
}
override fun onStop() {
super.onStop()
registry.makeNotice(MyLifeCycle.ActivityState.STOP)
}
override fun onDestroy() {
super.onDestroy()
registry.makeNotice(MyLifeCycle.ActivityState.DESTROY)
}
}
我们搞个类测试测试
public class TestLifeCycle implements SevenLifeCycleObserver {
public TestLifeCycle(SevenLifeCycleOwner sevenLifeCycleOwner) {
sevenLifeCycleOwner.getLifeCycle().addObserver(this);
}
@Override
public void onStateChange(SevenLifeCycle.ActivityState activityState) {
System.out.println(activityState);
}
}
这样一看，是不是Lifecycle很简单，Activity或Fragment生命周期的作为被观察者，当它们的生命周期发生改变时，它通过真正干活的人也就是抽象被观察者的实现类LifeCycleRegistry发布出去，这样，只要你在LifeCycleRegistry中注册过，就可以收到它的生命周期，当然，我这里是个比较简单的实现，但是基本上是这样的原理。最后，借用网上的图，对整个Lifecycle中的类做个概括。
