一、为什么使用Lifecycle

应用开发中，处理Activity或Fragment组件的生命周期相关代码不可避免。因为在Android框架中定义的大多数应用组件都存在生命周期。

生命周期由操作系统或进程中运行的框架代码管理。它们是 Android 工作原理的核心，应用必须遵循它们。如果不这样做，可能会引发内存泄漏甚至应用崩溃。

在Activity中写一个监听，在Activity的不同生命周期方法中调用这个监听

class MainActivity : AppCompatActivity() {

    private lateinit var myListener: MyListener
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        myListener = MyListener(this)
    }

    override fun onStart() {
        super.onStart()
        myListener.start()
    }

    override fun onResume() {
        super.onResume()
        myListener.resume()
    }

    class MyListener(content: Context){
        fun start(){}
        fun resume(){}
    }
}

实际开发中，可能会有多个组件在Activity的生命周期中进行回调，这样Activity的生命周期的方法中可能就需要放大量的代码，使得它们难以维护。

除了上述问题，实际开发中一般需要保证组件在Activity或Fragment停止之前启动，如果在组件中做了耗时操作，可能就无法保证。

Lifecycle则可以帮助解决上述问题

二、基本使用

Lifecycle依赖引入

dependencies {
    def lifecycle_version = "xxx"
    def arch_version = "xxx"

    // ViewModel
    implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version"
    // ViewModel utilities for Compose
    implementation "androidx.lifecycle:lifecycle-viewmodel-compose:$lifecycle_version"
    // LiveData
    implementation "androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version"
    // Lifecycles only (without ViewModel or LiveData)
    implementation "androidx.lifecycle:lifecycle-runtime-ktx:$lifecycle_version"

    // Saved state module for ViewModel
    implementation "androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version"

    // Annotation processor
    kapt "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"
    // alternately - if using Java8, use the following instead of lifecycle-compiler
    implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"

    // optional - helpers for implementing LifecycleOwner in a Service
    implementation "androidx.lifecycle:lifecycle-service:$lifecycle_version"

    // optional - ProcessLifecycleOwner provides a lifecycle for the whole application process
    implementation "androidx.lifecycle:lifecycle-process:$lifecycle_version"

    // optional - ReactiveStreams support for LiveData
    implementation "androidx.lifecycle:lifecycle-reactivestreams-ktx:$lifecycle_version"

    // optional - Test helpers for LiveData
    testImplementation "androidx.arch.core:core-testing:$arch_version"
}

Lifecycle 是一个类，用于存储有关组件（如 Activity 或 Fragment）的生命周期状态的信息，并允许其他对象观察此状态。

Lifecycle 使用两种主要枚举跟踪其关联组件的生命周期状态：

1. 事件：从框架和 Lifecycle 类分派的生命周期事件。

   这些事件映射到 Activity 和 Fragment 中的回调事件

2. 状态：由 Lifecycle 对象跟踪的组件的当前状态。

简单归纳总结就是：

类可以通过向其方法添加注解来监控组件的生命周期状态，然后通过调用Lifecycle类的addObserver()方法并传递观察者的实例来添加观察者

2.1 Lifecycle简单使用

创建生命周期观察者

class MyObserver: LifecycleObserver {

    companion object{
        const val TAG = "MyObserver"
    }

    //使用注解表明该方法需要监听指定的生命周期事件
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun onCreate(){
        Log.d(TAG,"onCreate")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun connectListener() {
        Log.d(TAG,"resume")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun disconnectListener() {
        Log.d(TAG,"onPause")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun destroy(){
        Log.d(TAG,"onDestroy")
    }
}

• 首先创建一个类，实现了LifecycleObserver接口
• 在方法上使用@OnLifecycleEvent 注解使得该方法具备生命周期感知能力，括号内参数表明需要监听的生命周期事件

Lifecycle 主要就是通过 Event 和 State 这两个枚举类来跟踪所关联组件的生命周期状态。

Lifecycle 2.4.0版本移除了通过注解实现生命周期感知的方式，移除原因后面再详述。

观察生命周期

在Activity中完成Lifecycle和LifecycleObserver的绑定

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        lifecycle.addObserver(MyObserver())
    }
}

1. Activity继承了AppCompatActivity，其父类ComponentActivity默认实现了LifecycleOwner接口
2. 通过getLifecycle()方法直接返回一个Lifecycle对象，可通过该对象的addObserver()方法将Lifecycle与指定的LifecycleObserver进行绑定

如果是继承自普通的Activity，则无法直接使用getLifecycl()方法获取Lifecycle，需要自己实现LifecycleOwner接口。

2.2 自定义LifecycleOwner

如果继承自普通Activity，需要自定义LifecycleOwner接口。

LifecycleOwner是单一方法接口，表示类具有Lifecycle。

public interface LifecycleOwner {
    @NonNull
    Lifecycle getLifecycle();
}

LifecycleObserver实现组件与LifecycleOwner实现类可以无缝协同，其所有者可提供生命周期，而观察者可以注册以观察生命周期。

自定义LifecycleOwner实现

class FirstActivity:Activity(),LifecycleOwner {

    private lateinit var mLifecycleRegistry: LifecycleRegistry

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        mLifecycleRegistry = LifecycleRegistry(this)
        lifecycle.addObserver(MyObserver())
        mLifecycleRegistry.currentState = Lifecycle.State.CREATED
    }

    override fun onStart() {
        super.onStart()
        mLifecycleRegistry.currentState = Lifecycle.State.STARTED

    }

    override fun onDestroy() {
        super.onDestroy()
        mLifecycleRegistry.currentState = Lifecycle.State.DESTROYED
    }

    override fun onPause() {
        super.onPause()
        mLifecycleRegistry.currentState = Lifecycle.State.STARTED
    }

    override fun getLifecycle(): Lifecycle {
        return mLifecycleRegistry
    }
}

2.3 ProcessLifecycleOwner

使用ProcessLifecycleOwner可以直接获取应用前后台切换状态（记得引入lifecycle-process依赖）

implementation "androidx.lifecycle:lifecycle-process:$lifecycle_version"

使用方式与Activity中类似

class MyApplication : Application() {
    fun onCreate() {
        super.onCreate()
        //注册App生命周期观察者
        ProcessLifecycleOwner.get().lifecycle.addObserver(ApplicationLifecycleObserver())
    }

    /**
     * Application生命周期观察，提供整个应用进程的生命周期
     * 作用：监听应用程序进入前台或后台
     */
    private class ApplicationLifecycleObserver : LifecycleObserver {
        @OnLifecycleEvent(Lifecycle.Event.ON_START)
        private fun onAppForeground() {
            Log.w(TAG, "ApplicationObserver: app moved to foreground")
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
        private fun onAppBackground() {
            Log.w(TAG, "ApplicationObserver: app moved to background")
        }
    }
}

1. Lifecycle.Event.ON_CREATE只会分发一次，Lifecycle.Event.ON_DESTROY不会被分发。
2. 第一个Activity进入时，ProcessLifecycleOwner将分派Lifecycle.Event.ON_START, Lifecycle.Event.ON_RESUME。
3. Lifecycle.Event.ON_PAUSE, Lifecycle.Event.ON_STOP，将在最后一个Activit退出后后延迟分发。
4. 如果由于配置更改而销毁并重新创建活动，则此延迟足以保证ProcessLifecycleOwner不会发送任何事件。

Lifecycle 2.4.0版本移除了通过注解实现生命周期感知的方式

三、原理解析

本文基于Lifecycle 2.4.0版本源码，程序demo基于sdk 31

学习Lifecycle核心原理前，需要简单了解下几个核心角色：

• Lifecycle

  持有组件生命周期状态（如Activity或Fragment）的信息的类，并允许其他对象观察此状态。

• LifecycleOwner

  Lifecycle持有者；实现该接口的类持有生命周期（Lifecycle对象），该接口的生命周期(Lifecycle对象)的改变会被其注册的观察者LifecycleObserver观察到并触发其对应的事件

• LifecycleObserver

  Lifecycle观察者；实现该接口的类，可以通过被LifecycleOwner类的addObserver()方法注册,被注册后，LifecycleObserver便可以观察到LifecycleOwner的生命周期事件。

• LifycycleRegistry

  Lifecycle是一个抽象类，其唯一实现类是LifecycleRegistry。

• ......

Lifecycle的原理实现机制图大致如下：

其主要实现类如下图所示：

关于**Lifecycle的原理，简单总结为**：

1. AppCompatActivity实现了 LifecycleOwner 接口，其 getLifecycle() 方法返回的 Lifecycle 对象为 LifecycleRegistry
2. AppCompatActivity 默认挂载了一个无 UI 界面的 Fragment，该Fragment 会根据用户手机的系统版本号高低，用不同的方式获取到 AppCompatActivity 的事件变化通知，最终调用 LifecycleRegistry 的 handleLifecycleEvent() 方法将 Lifecycle.Event 传递出去。此时，LifecycleRegistry 就拿到了 Lifecycle.Event
3. LifecycleRegistry 会将外部通过 addObserver 传进来的 LifecycleObserver 对象都给包装成 ObserverWithState 类内部的 LifecycleEventObserver 对象，屏蔽了外部传进来的 LifecycleObserver 的差异性（可能是接口，也可能是注解）
4. LifecycleRegistry 通过直接调用 ObserverWithState 类内部的 LifecycleEventObserver 对象的 onStateChanged 方法来完成最终的事件回调。至此整个流程就完成了

3.1 ReportFragment

一般 Activity 都是继承于AppCompatActivity。

//继承了AppCompatActivity的Activity类文件

lifecycle.addObserver(MyObserver())

getLifecycle()方法点进去是ComponentActivity，返回了一个LifecycleRegistry对象

public class ComponentActivity extends androidx.core.app.ComponentActivity implements
    LifecycleOwner,
ViewModelStoreOwner,
SavedStateRegistryOwner,
OnBackPressedDispatcherOwner {

    private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

    ......
        
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
}

ComponentActivity实现了LifecycleOwner接口。getLifecycle()返回了一个LifecycleRegister对象实例。

LifecycleRegistry是Lifecycle的唯一实现类，而LifycycleOwner是Lifecycle的持有者。

先看一下LifecycleOwner类

public interface LifecycleOwner {
    @NonNull
    Lifecycle getLifecycle();
}

Lifecycle是一个抽象类，里面有3个方法（添加观察者、移除观察者、获取当前的状态），还有一些状态的枚举定义

public abstract class Lifecycle {
    @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
    @NonNull
    AtomicReference<Object> mInternalScopeRef = new AtomicReference<>();
    
    @MainThread
    public abstract void addObserver(@NonNull LifecycleObserver observer);
    
    @MainThread
    public abstract void removeObserver(@NonNull LifecycleObserver observer);
    
    @MainThread
    @NonNull
    public abstract State getCurrentState();
    
    @SuppressWarnings("WeakerAccess")
     public enum Event {
        ON_CREATE,
        ON_START,
        ON_RESUME,
        ON_PAUSE,
        ON_STOP,
        ON_DESTROY,
        ON_ANY
     }
    
     @SuppressWarnings("WeakerAccess")
    public enum State {
        DESTROYED,
        INITIALIZED,
        CREATED,
        STARTED,
        RESUMED;
        public boolean isAtLeast(@NonNull State state) {
            return compareTo(state) >= 0;
        }
        
    }
    
    ......
    
}

其中Event与State的关系如下图：

下面着重介绍一下ReportFragment的妙用。

看一下ComponentActivity的onCreate()方法

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    ......
    ReportFragment.injectIfNeededIn(this);
    if (mContentLayoutId != 0) {
        setContentView(mContentLayoutId);
    }
}

ComponentActivity的onCreate()中通过injectIfNeededIn()静态方法注入了一个ReportFragment。如果知道了ReportFragment的生命周期，就可以知道Activity的生命周期，接着通知相关的观察者。

看下ReportFragment实现

public class ReportFragment extends android.app.Fragment {
    public static void injectIfNeededIn(Activity activity) {
        //如果是Android 10及以上，通过registerActivityLifecycleCallbacks 的方式来实现生命周期的回调
        if (Build.VERSION.SDK_INT >= 29) {
            LifecycleCallbacks.registerIn(activity);
        }
        //在API29之前，向Activity添加一个不可见的framework中的Fragment，以此来获取Activity的生命周期事件正确回调
        android.app.FragmentManager manager = activity.getFragmentManager();
        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
            //将Fragment添加到Activity
            manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
            // Hopefully, we are the first to make a transaction.
            manager.executePendingTransactions();
        }
    }
}

ReportFragment 的 injectIfNeededIn() 函数会根据两种情况来进行事件分发

• 运行设备的系统版本号小于 29。

  此情况会通过向 Activity 添加一个无 UI 界面的 Fragment（即 ReportFragment），间接获得 Activity 的各个生命周期事件的回调通知

• 运行设备的系统版本号大于或等于29。

  此情况会向 Activity 注册一个 LifecycleCallbacks ，以此来直接获得各个生命周期事件的回调通知。此时也会同时执行第一种情况的操作

injectIfNeededIn()根据两种情况来进行事件分发，这是因为registerActivityLifecycleCallbacks 是 SDK 29 时 android.app.Activity 新添加的方法，从这个版本开始支持直接在 LifecycleCallbacks 中取得事件通知。

SDK>=29的情况

通过LifeCycleCallbacks进行事件分发。就是在Activity类的 onCreate、onStart、onResume 等方法被调用后通过 dispatch() 方法发送相应的 Event 值，并在 onPause、onStop、onDestroy 等方法被调用前发送相应的 Event 值

@RequiresApi(29)
static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {

    static void registerIn(Activity activity) {
        activity.registerActivityLifecycleCallbacks(new LifecycleCallbacks());
    }

    @Override
    public void onActivityCreated(@NonNull Activity activity,
                                  @Nullable Bundle bundle) {
    }

    @Override
    public void onActivityPostCreated(@NonNull Activity activity,
                                      @Nullable Bundle savedInstanceState) {
        dispatch(activity, Lifecycle.Event.ON_CREATE);
    }

    //省略部分相似代码
    ···

    @Override
    public void onActivityPreDestroyed(@NonNull Activity activity) {
        dispatch(activity, Lifecycle.Event.ON_DESTROY);
    }

    @Override
    public void onActivityDestroyed(@NonNull Activity activity) {
    }
}

static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
    if (activity instanceof LifecycleRegistryOwner) {
        ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
        return;
    }

    if (activity instanceof LifecycleOwner) {
        Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
        if (lifecycle instanceof LifecycleRegistry) {
            ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
        }
    }
}

dispatch() 方法拿到 Event 值后，通过 activity 拿到 Lifecycle 对象。之后再通过类型判断拿到LifecycleRegistry 对象，最终通过调用handleLifecycleEvent() 方法将 Event 值传递出去，使外部得到各生命周期事件通知。

SDK<29的情况

ReportFragment本身生命周期和所在的Activity是相关联的。通过在 ReportFragment 相应的生命周期函数里调用 dispatch() 函数发送相应的 Event 值，以此来间接获得 Activity 的各个生命周期事件的回调通知

@Override
public void onActivityCreated(Bundle savedInstanceState) {
    super.onActivityCreated(savedInstanceState);
    //......
    dispatch(Lifecycle.Event.ON_CREATE);
}

@Override
public void onStart() {
    super.onStart();
    //......
    dispatch(Lifecycle.Event.ON_START);
}

@Override
public void onDestroy() {
    super.onDestroy();
    dispatch(Lifecycle.Event.ON_DESTROY);
    //......
}

private void dispatch(@NonNull Lifecycle.Event event) {
    if (Build.VERSION.SDK_INT < 29) {
        dispatch(getActivity(), event);
    }
}

dispatch()函数内部会判断目标设备版本号来决定是否真的分发Event值，避免当 SDK 版本号大于 29 时和 LifecycleCallbacks 重复发送

就这样，ReportFragment通过前述逻辑完成了向外转发Activity发生的Event值

ProcessLifecycleOwner实现

到这里关于外部如何得到Activity的生命周期事件就基本理清楚了。不过关于ProcessLife生命周期感知还不清楚。这里将目光前移到ReportFragment的生命周期相关方法

@Override
public void onActivityCreated(Bundle savedInstanceState) {
    super.onActivityCreated(savedInstanceState);
    dispatchCreate(mProcessListener);
    dispatch(Lifecycle.Event.ON_CREATE);
}

@Override
public void onStart() {
    super.onStart();
    dispatchStart(mProcessListener);
    dispatch(Lifecycle.Event.ON_START);
}

private void dispatchCreate(ActivityInitializationListener listener) {
    if (listener != null) {
        listener.onCreate();
    }
}
......

ReportFragment在生命周期方法调用了dispatchCreate()等方法和dispatch()方法。

看一下mProcessListener在哪里设置的

public class ReportFragment extends android.app.Fragment {
    interface ActivityInitializationListener {
        void onCreate();
        void onStart();
        void onResume();
    }
}

public class ProcessLifecycleOwner implements LifecycleOwner {
    private final LifecycleRegistry mRegistry = new LifecycleRegistry(this);

    //Activity监听器
    ActivityInitializationListener mInitializationListener =
        new ActivityInitializationListener() {
        @Override
        public void onCreate() {}

        @Override
        public void onStart() {
            activityStarted();
        }

        @Override
        public void onResume() {
            activityResumed();
        }
    };

    //单例实现ProcessLifecycleOwner对象
    private static final ProcessLifecycleOwner sInstance = new ProcessLifecycleOwner();

    void attach(Context context) {
        mHandler = new Handler();
        //分发ON_CREATE事件
        mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
        Application app = (Application) context.getApplicationContext();
        app.registerActivityLifecycleCallbacks(new EmptyActivityLifecycleCallbacks() {
            @RequiresApi(29)
            @Override
            public void onActivityPreCreated(@NonNull Activity activity,
                                             @Nullable Bundle savedInstanceState) {
                activity.registerActivityLifecycleCallbacks(new EmptyActivityLifecycleCallbacks() {
                    @Override
                    public void onActivityPostStarted(@NonNull Activity activity) {
                        activityStarted();
                    }

                    @Override
                    public void onActivityPostResumed(@NonNull Activity activity) {
                        activityResumed();
                    }
                });
            }

            @Override
            public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
                if (Build.VERSION.SDK_INT < 29) {
                    ReportFragment.get(activity).setProcessListener(mInitializationListener);
                }
            }

            @Override
            public void onActivityPaused(Activity activity) {
                activityPaused();
            }

            @Override
            public void onActivityStopped(Activity activity) {
                activityStopped();
            }
        });
    }


    //第一个Activity创建时，分发Lifecycle.Event.ON_START事件
    void activityStarted() {
        mStartedCounter++;
        if (mStartedCounter == 1 && mStopSent) {
            mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
            mStopSent = false;
        }
    }

}

1. ProcessLifecycleOwner给整个App提供lifecycle，通过其我们可以观察到整个应用程序的生命周期
2. 在attach()中的registerActivityLifecycleCallbacks()注册了一个监听器，一旦有Activity创建就给它设置一个Listener，保证了每个ReportFragment中都有一个Listener。
3. ProcessLifecycleOwner是一个全局单例，并且可以监听整个应用程序的生命周期，需要一开始就初始化，肯定在ContentProvider里面初始化的

跟着ProcessLifecycleOwner的init()方法的调用处,来到了ProcessLifecycleOwnerInitializer

public final class ProcessLifecycleInitializer implements Initializer<LifecycleOwner> {

    @NonNull
    @Override
    public LifecycleOwner create(@NonNull Context context) {
        LifecycleDispatcher.init(context);
        ProcessLifecycleOwner.init(context);
        return ProcessLifecycleOwner.get();
    }
	......
}

这里发现了LifecycleDispatcher的初始化方法，我们来细看一下整个方法

class LifecycleDispatcher {

    private static AtomicBoolean sInitialized = new AtomicBoolean(false);

    static void init(Context context) {
        if (sInitialized.getAndSet(true)) {
            return;
        }
        //注册一个监听器
        ((Application) context.getApplicationContext())
                .registerActivityLifecycleCallbacks(new DispatcherActivityCallback());
    }

    @SuppressWarnings("WeakerAccess")
    @VisibleForTesting
    static class DispatcherActivityCallback extends EmptyActivityLifecycleCallbacks {

        @Override
        public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
            //注入一个ReportFragment
            ReportFragment.injectIfNeededIn(activity);
        }

        @Override
        public void onActivityStopped(Activity activity) {
        }

        @Override
        public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
        }
    }

    private LifecycleDispatcher() {
    }
}

所以，应用程序中任何一个Activity都会被注入一个ReportFragment

小结：

1. AppCompatActivity实现了 LifecycleOwner 接口，其 getLifecycle() 方法返回的 Lifecycle 对象为 LifecycleRegistry。LifecycleRegistry是Lifecycle的唯一实现类
2. ComponentActivity的onCreate()中注入了一个ReportFragment，如果知道了ReportFragment的生命周期，就可以知道Activity的生命周期，接着通知相关的观察者。这里会根据版本做相应不同的通知操作。
3. ProcessLifecycleOwner实现了LifecycleOwner，用于观察整个应用程序的生命周期。其是一个全局单例，在ContentProvider的onCreate()中初始化

3.2 LifecycleRegister

由前述的ReportFragment逻辑可知，向外传递Lifecycle.Event值时，调用的都是 LifecycleRegistry 对象的 handleLifecycleEvent() 方法。那么其是如何将Event值转发给LifecycleObserver的？

LifecycleRegistry是Lifecycle的唯一实现类，用来实现具体的事件回调和状态管理。

看一下LifecycleRegistry内部实现。

public class LifecycleRegistry extends Lifecycle {
    // Current state
    private State mState;
     //持有对 LifecycleOwner 的弱引用，避免内存泄露
    private final WeakReference<LifecycleOwner> mLifecycleOwner;
    
    public LifecycleRegistry(@NonNull LifecycleOwner provider) {
        this(provider, true);
    }

    private LifecycleRegistry(@NonNull LifecycleOwner provider, boolean enforceMainThread) {
        mLifecycleOwner = new WeakReference<>(provider);
        mState = INITIALIZED;
        mEnforceMainThread = enforceMainThread;
    }
    
    ......  
}

LifecycleRegistry内部持有了对LifecycleOwner的弱引用。外部可以通过addObserver() 方法向LifecycleRegistry 添加 Observer。Observer内部可能会执行一些耗时操作，耗时操作完成前Activity可能已经Destroy。所以LifecycleRegistry 持有LifcycleOwner的弱引用而不是强引用，避免内存泄漏。

addObserver内部实现

我们一般都是通过addObserver()添加观察者，看一下内部实现

//Lifecycle 类中对 addObserver 方法添加了 @MainThread 注解，此处无需考虑多线程情况
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
    enforceMainThreadIfNeeded("addObserver");
    //计算初始状态，如果当前Lifecycle状态不为DESTROYED，我们就设置为初始状态
    State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
    //构造ObserverWithState，即带状态的观察者，这个状态的作用：新的事件触发后 遍历通知所有观察者时，判断是否已经通知这个观察者了
    ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
    //将observer对象和statefulObserver对象添加到FastSafeIterableMap数据结构中
    ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);

    if (previous != null) {
        //一个observer不能多次加入到同一个Lifecycle中。如果 observer 之前已经传进来过了，则不重复添加，直接返回
        return;
    }
    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
    if (lifecycleOwner == null) {
        //如果 LifecycleOwner 对象已经被回收了，则直接返回
        return;
    }

    //判断该添加是否可重入，正常情况该标志永远为false
    //mAddingObserverCounter != 0。会出现这种情况，是由于开发者先添加了一个 LifecycleObserver ，当还在向其回调事件的过程中，在回调方法里又再次调用了 addObserver 方法添加了一个新的 LifecycleObserver
    boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
    //计算当前Lifecycle的状态
    State targetState = calculateTargetState(observer);
    //递增加一，标记当前正处于向新添加的 LifecycleObserver 回调 Event 值的过程
    mAddingObserverCounter++;
    //新添加的观察者的状态小于当前状态，将它迁移到当前状态，例如当前状态为RESUMED,则Observer将收到ONCREATE ONSTART ONRESUME事件
    while ((statefulObserver.mState.compareTo(targetState) < 0
            && mObserverMap.contains(observer))) {
        //将 observer 已经遍历到的当前的状态值 mState 保存下来
        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);
        //移除 mState
        popParentState();
        targetState = calculateTargetState(observer);
    }

    if (!isReentrance) {
        sync();
    }
    mAddingObserverCounter--;
}

addObserver()函数的主要逻辑是：

1. 计算初始状态，如果当前Lifecycle状态不为DESTROYED，我们就设置为初始状态
2. 将传入的observer对象包装为ObserverWithState，判断observer是否已添加到map数据中
3. 若未添加到map中，计算当前Lifecycle的State，通过循环检查方式向ObserverWithState逐步下发Event值

看一下ObserverWithState类

static class ObserverWithState {
    State mState;
    LifecycleEventObserver mLifecycleObserver;

    ObserverWithState(LifecycleObserver observer, State initialState) {
        //将Observer传给Lifycycling进行类型包装
        mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
        mState = initialState;
    }

    void dispatchEvent(LifecycleOwner owner, Event event) {
        State newState = event.getTargetState();
        mState = min(mState, newState);
        mLifecycleObserver.onStateChanged(owner, event);
        mState = newState;
    }
}

ObserverWithState 将外界传入的 LifecycleObserver 对象传给 Lifecycling 进行类型包装。

Lifecycling的类型包装处理是为了将反射逻辑和接口回调逻辑都给汇总综合成一个新的 LifecycleEventObserver 对象，从而使得 Event 分发过程都统一为一个入口。

3.3 事件分发

ReportFragment 最终在向外传出 Lifecycle.Event 值时，调用的都是 LifecycleRegistry 对象的 handleLifecycleEvent(Lifecycle.Event) 方法，该方法会根据接收到的 Event 值换算出对应的 State 值，然后更新本地的 mState，再向所有 Observer 进行事件通知，最终还是会调用到 ObserverWithState 的 dispatchEvent 方法。

@SuppressWarnings("deprecation")
static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
    if (activity instanceof LifecycleRegistryOwner) {
        ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
        return;
    }

    if (activity instanceof LifecycleOwner) {
        Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
        if (lifecycle instanceof LifecycleRegistry) {
            ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
        }
    }
}

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
    enforceMainThreadIfNeeded("handleLifecycleEvent");
    moveToState(event.getTargetState());
}

private void moveToState(State next) {
    if (mState == next) {
        return;
    }
    mState = next;
    if (mHandlingEvent || mAddingObserverCounter != 0) {
        mNewEventOccurred = true;
        // we will figure out what to do on upper level.
        return;
    }
    mHandlingEvent = true;
    sync();
    mHandlingEvent = false;
}

LifecycleRegistry最终调用了sync()将生命周期同步给所有观察者。

private void sync() {
    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
    if (lifecycleOwner == null) {
        throw new IllegalStateException("LifecycleOwner of this LifecycleRegistry is already"
                                        + "garbage collected. It is too late to change lifecycle state.");
    }
    //循环遍历所有观察者
    while (!isSynced()) {	//判断所有的观察者是否都同步完了？
        mNewEventOccurred = false;
        //根据当前状态和mObserverMap中的eldest(最老的观察者)和newest（最新的观察者）的状态做对比 ，判断当前状态是向前还是向后，比如由STARTED到RESUMED是状态向前，反过来就是状态向后
        if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
            //向后分发事件
            backwardPass(lifecycleOwner);
        }
        Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
        if (!mNewEventOccurred && newest != null
            && mState.compareTo(newest.getValue().mState) > 0) {
            //向前分发事件
            forwardPass(lifecycleOwner);
        }
    }
    mNewEventOccurred = false;
}

Sync方法主要内容为：

1. 首先判断所有的观察者是否都已状态同步；如果未同步，则进行状态比较
2. 将当前Lifecycle的State和所有Observer的State比较，判断执行backwardpass还是forwardPass方法。

看一下isSynced()和forwardPass()方法

private boolean isSynced() {
    if (mObserverMap.size() == 0) {
        return true;
    }
    State eldestObserverState = mObserverMap.eldest().getValue().mState;
    State newestObserverState = mObserverMap.newest().getValue().mState;
    return eldestObserverState == newestObserverState && mState == newestObserverState;
}

private void forwardPass(LifecycleOwner lifecycleOwner) {
    //获取一个按添加Observer顺序的迭代器
    Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
        mObserverMap.iteratorWithAdditions();
    //遍历所有Observer
    while (ascendingIterator.hasNext() && !mNewEventOccurred) {
        Map.Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
        ObserverWithState observer = entry.getValue();
        //如果当前Observer的State小于mState,则递增当前状态
        while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
                && mObserverMap.contains(entry.getKey()))) {
            pushParentState(observer.mState);
            //递增当前状态
            final Event event = Event.upFrom(observer.mState);
            if (event == null) {
                throw new IllegalStateException("no event up from " + observer.mState);
            }
            //分发事件
            observer.dispatchEvent(lifecycleOwner, event);
            popParentState();
        }
    }
}

forwardPass()方法：

1. 首先获取一个按添加Observer顺序的迭代器，然后遍历所有的Observer
2. 对每一个Observer，递增其状态并通过dispatchEvent分发生命周期事件，直到其状态递增到Lifecycle的mState为止。

通过这种方式完成了所有Observer的状态同步和事件分发。

前述的observer是一个ObserverWithState对象

static class ObserverWithState {
    State mState;
    LifecycleEventObserver mLifecycleObserver;

    ObserverWithState(LifecycleObserver observer, State initialState) {
        //将Observer传给Lifycycling进行类型包装
        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;
    }
}

public interface LifecycleEventObserver extends LifecycleObserver {
    
    void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);
}

LifecycleRegistry 会将外部传入的所有 LifecycleObserver 根据 Lifecycling 包装成 LifecycleEventObserver 对象，为什么需要这层包装呢？

• LifecycleEventObserver 和 FullLifecycleObserver 都是继承于 LifecycleObserver 的接口，开发者自己实现的自定义 Observer 可能同时实现了这两个接口或者实现了任一接口，LifecycleRegistry 必须在有事件触发的时候回调存在的所有接口方法
• 除了通过接口方法来实现回调外，Google 也提供了通过注解来实现回调的方式，此时就需要通过反射来实现回调

基于以上要求，如果在 LifecycleRegistry 中直接对外部传入的 Observer 来进行类型判断、接口回调、反射调用等一系列操作的话，会使得 LifecycleRegistry 整个类非常的臃肿。

所以 Lifecycling 的作用就是来将这一系列的逻辑给封装起来，仅仅开放一个 onStateChanged 方法即可让 LifecycleRegistry 完成整个事件分发，从而使得整个流程会更加清晰明了且职责分明

看一下Lifecycling的lifecycleEventObserver()方法

static LifecycleEventObserver lifecycleEventObserver(Object object) {
    boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
    boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
    //如果 object 对象同时继承了 LifecycleEventObserver 和 FullLifecycleObserver,则将其包装为FullLifecycleObserverAdapter对象来进行事件转发
    if (isLifecycleEventObserver && isFullLifecycleObserver) {
        return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
                                                (LifecycleEventObserver) object);
    }
    if (isFullLifecycleObserver) {
        return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
    }

    if (isLifecycleEventObserver) {
        //object 已经是需要的目标类型了（LifecycleEventObserver），直接原样返回即可
        return (LifecycleEventObserver) object;
    }

    //通过APT产生的类
    final Class<?> klass = object.getClass();
    // 判断 sClassToAdapters Map 中是否存在 XXX_LifecycleAdapter
    int type = getObserverConstructorType(klass);
    if (type == GENERATED_CALLBACK) {
        // 从 Map 中获取 klass 相关集合
        List<Constructor<? extends GeneratedAdapter>> constructors =
            sClassToAdapters.get(klass);
        if (constructors.size() == 1) {
            // 根据 XXX_LifecycleAdapter 构造方法创建对象
            GeneratedAdapter generatedAdapter = createGeneratedAdapter(
                constructors.get(0), object);
            // 然后将创建的对象封装在 SingleGeneratedAdapterObserver 对象中
            return new SingleGeneratedAdapterObserver(generatedAdapter);
        }
        GeneratedAdapter[] adapters = new GeneratedAdapter[constructors.size()];
        for (int i = 0; i < constructors.size(); i++) {
            adapters[i] = createGeneratedAdapter(constructors.get(i), object);
        }
        return new CompositeGeneratedAdaptersObserver(adapters);
    }
    return new ReflectiveGenericLifecycleObserver(object);
}

lifecycleEventObserver()方法主要内容是：判断传入的Object对象类型，并根据对应的类型构建对应的Adapter对象返回。

若传入的LifecycleObserver同时实现了LifecycleEventObserver接口和FullLifecycleObserver接口，将它构造成一个FullLifecycleObserverAdapter对象并返回

若传入的LifecycleObserver同时实现了LifecycleEventObserver接口和FullLifecycleObserver接口，将它构造成一个FullLifecycleObserverAdapter对象并返回

若传入的LifecycleObserver只实现了FullLifecycleObserver接口，将它构造成一个FullLifecycleObserverAdapter对象并返回

以上3点都不满足，解析该类的的构造器的Type，如果是通过注解处理器生成的类来调用回调函数，就返回一个SingleGeneratedAdapterObserver / CompositeGeneratedAdaptersObserver 对象（两者都实现了LifecycleEventObserver接口，区别就是Observer的数量，在生命周期状态变化时发送事件给Observer）

如果以上条件都不满足，就通过反射来调用各回调函数。返回一个ReflectiveGenericLifecycleObserver 对象

通过注解的方式来自定义LifecycleObserver 的时候，按照传统方式，必定要通过反射来对注解进行解析，这样就会对性能造成影响。一方面，我们通过缓存，来避免每次都通过反射获取构造器。另一方面，又通过注解处理器，在编译时对那些被@OnLifecycleEvent注解标注的普通方法，进行预处理，生成以“类名_LifecycleAdapter”命名的类，将各种回调方法直接进行逻辑转换，避免反射，进而来提高性能。

3.4 依赖注入

在引入lifecycle时添加了语句annotationProcessor "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"，这个是注解处理器的依赖

引入这个，会自动生成xxx_LifecycleAdapter的文件，最前述的demo生成的是MyObserver_LifecycleAdapter文件，大致内容如下：

public class MyObserver_LifecycleAdapter implements GeneratedAdapter {
  final MyObserver mReceiver;

  MyObserver_LifecycleAdapter(MyObserver receiver) {
    this.mReceiver = receiver;
  }

  @Override
  public void callMethods(LifecycleOwner owner, Lifecycle.Event event, boolean onAny,
      MethodCallsLogger logger) {
    boolean hasLogger = logger != null;
    if (onAny) {
      return;
    }
    if (event == Lifecycle.Event.ON_CREATE) {
      if (!hasLogger || logger.approveCall("onCreate", 1)) {
        mReceiver.onCreate();
      }
      return;
    }
    if (event == Lifecycle.Event.ON_START) {
      if (!hasLogger || logger.approveCall("onStart", 1)) {
        mReceiver.onStart();
      }
      return;
    }
    if (event == Lifecycle.Event.ON_RESUME) {
      if (!hasLogger || logger.approveCall("onResume", 1)) {
        mReceiver.onResume();
      }
      return;
    }
    if (event == Lifecycle.Event.ON_PAUSE) {
      if (!hasLogger || logger.approveCall("onPause", 1)) {
        mReceiver.onPause();
      }
      return;
    }
    if (event == Lifecycle.Event.ON_STOP) {
      if (!hasLogger || logger.approveCall("onStop", 1)) {
        mReceiver.onStop();
      }
      return;
    }
    if (event == Lifecycle.Event.ON_DESTROY) {
      if (!hasLogger || logger.approveCall("onDestroy", 1)) {
        mReceiver.onDestroy();
      }
      return;
    }
  }
}

因为我们的事件是声明在MyObserver的方法注解上面的,每次去反射取这些东西,比较耗性能.那么我们通过该依赖库,把这些标注了的方法进行预处理,然后直接回调这些方法,避免反射,进行提高性能

分析前述的lifecycleEventObserver方法发现，因为MyObserver_LifecycleAdapter只有一个构造方法,那么就会构造出SingleGeneratedAdapterObserver，而SingleGeneratedAdapterObserver内部其实就是调用一下方法而已

class SingleGeneratedAdapterObserver implements LifecycleEventObserver {

    private final GeneratedAdapter mGeneratedAdapter;

    SingleGeneratedAdapterObserver(GeneratedAdapter generatedAdapter) {
        mGeneratedAdapter = generatedAdapter;
    }

    @Override
    public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
        mGeneratedAdapter.callMethods(source, event, false, null);
        mGeneratedAdapter.callMethods(source, event, true, null);
    }
}

上述的mGeneratedAdapter其实就是我们的MyObserver_LifecycleAdapter.

生命周期从Activity开始，然后到ReportFragment出来，最终到了我们定义的观察者。

3.5 总结

关于Lifecycle的使用和解析如前述所示，但是在使用时有几点需要注意：

1. Lifecycle有状态倒灌过程，也就是在任意生命周期中注册LifecycleObserver，这个LifecycleObserver会把前面的生命周期回调都执行一遍，直到和注册时的生命周期状态同步。
2. 在Activity/Fragment重写生命周期方法时，必须调用父类的相应方法，因为Lifecycle的生命周期分发在父类的相应生命周期方法中
3. LifecycleObserver是使用的一个Map来存的，虽然LifecycleObserver是Map的Key，但其实也是当成一个List<Pair<LifecycleObserver,xxx>>来存在的，也就是说从根本上来说还是一个List，但同一个Observer只能存一份，如果一个LifecycleObserver被add了两次，那么生命周期方法也只会回调一次。

四、常见问题

4.1 @OnLifecycleEvent废弃

在Lifecycle的2.4.0版本，将@OnLifecycleEvent注解废弃了，官方建议用LifecycleEventObserver 或者 DefaultLifecycleObserver 替代。

在前述进行Lifecycle使用时用的就是注解的方式。为什么要使用注解？为什么又要废弃？

生命周期Event的种类很多，不使用注解，需要实现所有方法，导致代码臃肿

interface FullLifecycleObserver extends LifecycleObserver {

    void onCreate(LifecycleOwner owner);

    void onStart(LifecycleOwner owner);

    void onResume(LifecycleOwner owner);

    void onPause(LifecycleOwner owner);

    void onStop(LifecycleOwner owner);

    void onDestroy(LifecycleOwner owner);
}

注解可以很好的解决上述问题。不过注解要么依赖反射，会降低运行时性能；要么依靠APT，降低编译速度。

Java8开始，可以为接口添加default方法，该接口实现类可以继承default方法，而不必须重写该方法。Java8现在几乎是Android工程的默认配置，可以直接为接口添加default方法，替代原先注解的作用。

例如官方推荐的DefaultLifecycleObserver

public interface DefaultLifecycleObserver extends FullLifecycleObserver {
    @Override
    default void onCreate(@NonNull LifecycleOwner owner) {
    }
    @Override
    default void onStart(@NonNull LifecycleOwner owner) {
    }
    @Override
    default void onResume(@NonNull LifecycleOwner owner) {
    }
    @Override
    default void onPause(@NonNull LifecycleOwner owner) {
    }
    @Override
    default void onStop(@NonNull LifecycleOwner owner) {
    }
    @Override
    default void onDestroy(@NonNull LifecycleOwner owner) {
    }
}