说起老生常谈的Android四大组件之一Activity以及Fragment，想必最头疼的就是手动分发宿主的生命周期了。而在jetpack之前，开发者经历过从最开始的继承基类Activity，到后来registerActivityLifecycleCallbacks应用全局监听生命周期，谷歌一直都在尝试解耦这一块内容，可以看到，在此之前的所有思想都是基于命令式编程思想，但是依旧避免不了在生命周期结束实现手动反注册。那能不能借助FRP反应式编程，动态感知组件的生命周期呢？是可以的。

简介

Jetpack中的Lifecycle架构组件就是具备宿主生命周期感知能力的一款组件。只要组件（Activity/Fragment）的生命周期状态发生变化，就能被Lifecycle感知到，同时允许其他继承的观察者监听宿主的状态，因此这也是Jetpack的核心基础组件库，包括后面的LiveData、ViewModel均是基于它来实现的。有了这套架构组件，麻麻再也不用担心内存泄露了。

如何使用Lifecycle观察宿主状态


// 官方注解：通过注解生命周期事件进行回调触发
class LocationObserver : LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun onCreate(): Unit {
        // 初始化属性
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun onStart(owner: LifecycleOwner): Unit {
        // 开启定位
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun onStop(owner: LifecycleOwner): Unit {
        // 暂停定位
    }
}

// FullLifecycleObserver 默认修饰符，default只对包可见，拿不到，但是这是对宿主所有生命周期事件的观察者
//class LocationObserver2 : FullLifecycleObserver {
//
//}

// 对宿主生命周期事件封装，只透传事件给回调使用
class LocationObserver3 : LifecycleEventObserver {
    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
        // 自行分发事件
    }
}

基本上 Lifecycle 使用只有上述两种写法（撇开一种客户端无法继承，当然其余两种也能达到第二种写法的目的），说说第一种，基于注解完成宿主生命周期事件的监听，一般都是通过运行时反射获取的，如果不添加相应注解处理器（lifecycle-compiler）的话。

Activity/Fragment 实现注册监听Lifecycle


class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        
        val observer = LocationObserver3()
        lifecycle.addObserver(observer)
    }
}

class MyFragment : Fragment()  {
    override fun onActivityCreated(savedInstanceState: Bundle?) {
        super.onActivityCreated(savedInstanceState)

        val observer = LocationObserver3()
        lifecycle.addObserver(observer)
    }
}

Fragment 是如何实现注册监听Lifecycle

【源码略多，只截取核心的代码】

public class Fragment implements ComponentCallbacks, OnCreateContextMenuListener, LifecycleOwner,
        ViewModelStoreOwner, SavedStateRegistryOwner {
    // An implementation of {@link Lifecycle} that can handle multiple observers.
    // Lifecycle接口是一个空实现，一般空实现的接口功能类似于标识，这个标识功能现在被 生命周期注册表所实现，用来处理多个观察者的管理
    LifecycleRegistry mLifecycleRegistry;       


    // 从生命周期组件获取，一般创建初期这个注册表对象就已实例化
    @Override
    @NonNull
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    } 

    public Fragment() {
        initLifecycle();
    }

    private void initLifecycle() {
        mLifecycleRegistry = new LifecycleRegistry(this);
        mSavedStateRegistryController = SavedStateRegistryController.create(this);
        if (Build.VERSION.SDK_INT >= 19) {
            mLifecycleRegistry.addObserver(new LifecycleEventObserver() {
                @Override
                public void onStateChanged(@NonNull LifecycleOwner source,
                        @NonNull Lifecycle.Event event) {
                    if (event == Lifecycle.Event.ON_STOP) {
                        if (mView != null) {
                            mView.cancelPendingInputEvents();
                        }
                    }
                }
            });
        }
    }

    void performCreate(Bundle savedInstanceState) {
        ... ...
        onCreate(savedInstanceState);
        ... ...

        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
    }

    void performStart() {
        ... ...
        onStart();
        ... ...

        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
    }

    ...
}

可以看出，Fragment的每一个生命周期事件的执行均通过 mLifecycleRegistry 进行相关事件分发，从而提供了生命周期的观察能力给子类使用。