LifeCycle

明飞1987

已于 2024-08-29 22:11:26 修改

阅读量322

点赞数 4

分类专栏： jetpack 文章标签： android

于 2024-08-06 15:56:11 首次发布

本文链接：https://blog.csdn.net/qq_33552379/article/details/140954772

版权

jetpack 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

背景

在开始前，我们先聊聊关于 Lifecycle 的前世今生，从而便于我们更好的理解 Lifecycle 存在的意义。

在 Lifecycle 之前(不排除现在😂)，如果我们要在某个生命周期去执行一些操作时，经常会在Act或者Fragment写很多模版代码，如下两个示例：

1.比如，有一个定时器，我们需要在 Activity 关闭时将其关闭，从而避免因此导致的内存问题，所以我们自然会在 onDestory() 中去stop一下。这些事看起来似乎不麻烦，但如果是一个重复多处使用的代码，细心的开发者会将其单独抽离成为一个 case ,从而通过组合的方式降低我们主类中的逻辑，但不可避免我们依然还要存在好多模版代码，因为每次都需要 onStop() 清理或者其他操作(除非写到base,但不可接受☹️)。

2.在老版本的友盟中，我们经常甚至需要在基类的 Activity 中复写 onResume() 、onPause() 等方法，这些事情说麻烦也不麻烦，但总是感觉很不舒服。不过，有经验的开发者肯定会想喷，为什么一个三方库，你就自己不会通过application.registerActivityLifecycleCallbacks 监听吗🤌🏼。

3.可能存在不符预期的生命周期情况，比如onCreate()里发起一个异步回调，但因为回调比较耗时，等到回调时已经处于onStop()状态了，回调里的操作可能没意义了，所以需要拿到当前所处的生命周期状态。

4.现在有十个库，都要在生命周期里执行相关操作，按照原先的写法，得重写Activity生命周期回调，补上这是个库对应的代码调用，库对应的生命周期回调都不一致，比如：A库只关注onCreate()和onDestory()，B库只关注onDestory()，C库只关注onStop等。当要去掉、增加、修改某一个库时，你可得 打醒十二分精神，毕竟一个不小心改错了，就得在这种低级BUG上耗费宝贵的时间。那换成Lifecycle这种方案呢？它帮我们做到了：关注点分离。

每个库定义一个观察者，在其中按需重写生命周期回调，Activity无脑addObserve()即可。将原本又臭又长的代码隔离到单独类中。改的话直接改对应类，无需担心影响到其他库，增删改库无压力，妙啊！

class MainActivity: AppCompatActivity{
	/**网络监听器*/
	val mNet = NetListener()
	/**视频播放器*/
	val mPlayer = VideoPlayer()
	
	override fun onStart(){
		mNet.connect()// 网络开始连接
		mPlayer.startCache()// 视频开始缓冲
		耗时任务（）
		// 其他业务逻辑...
	}
	
	override fun onStop(){
		mNet.cancel()// 网络断开
		mPlayer.releaseCache()// 视频释放缓存
		// 其他业务逻辑...
	}
}

这是很常见的写法，我们在生命周期的回调方法中做了很多事情，一旦代码多了后，是很难维护的。
另外,在页面停止时，其他生命周期（如onStart）有耗时任务，这时有可能onStop先结束，而耗时的组件，还存在。
随着业务复杂，也容易出bug, 让本不富裕的家庭，雪上＋霜🥲，这就需要本文的主角Lifecycle来感知生命周期的变化，
解耦出去这些逻辑，并自动在适当的生命周期内执行。

题外话：如果不用这个库我们可以在onStart() onStop()回调方法中处理这些逻辑，也能达到同样的效果，但你有没有想过，一旦在这些方法中处理逻辑多了，耦合度也就严重了，我们开发中用的一些架构模式，从MVC, MVP到MVVM,再到现在的MVI,这一切的演变为了什么?它们都有一个共同的目的——解耦。随着APP越来越庞大，功能越来越多，业务逻辑也越来越复杂，我们需要让我们的程序结构更清晰，更简洁。最佳的做法就是，把逻辑抽离出来进行解耦，Activity，Fragment它们是界面控制器，只负责界面的变化，业务逻辑交给其他层来处理。

Lifecycle的概念与作用

Lifecycle 是Jetpack组件库中的一个重要组件，它可以帮助我们更好地管理Activity、Fragment等组件的生命周期，方便我们做一些跟生命周期相关的业务逻辑。从而避免内存泄漏和其他问题。

Lifecycle是Jetpack组件库中的一个生命周期感知型组件，它可以执行操作来响应另一个组件（如 Activity 和 Fragment）的生命周期状态的变化。

Lifecycle是一个存储生命周期状态信息的抽象类，并允许其它类对其进行观察，比如LifecycleObserver。

Lifecycle的核心功能是将组件(Activity/fragment)的生命周期状态通知给观察者(? 谁是观察者 )，观察者可以根据这些状态变化来执行相应的操作。

Lifecycle是个抽象类，里面有添加/移除观察者的方法:addObserver( LifecycleObserver observer);
removeObserver(LifecycleObserver observer);

还有两个枚举类Event和State：

Lifecycle.State生命周期状态，而Event是指进入一种状态的事件。 Event触发的时机：

INITIALIZED： Lifecycle 初始化完成，但 Activity 或 Fragment 还没有被创建。

CREATED： Activity 或 Fragment 已经被创建，但还没有显示出来。

STARTED： Activity 或 Fragment 已经显示出来，但还没有获得焦点。

RESUMED： Activity 或 Fragment 获得焦点，处于活动状态。

DESTROYED： Activity 或 Fragment 被销毁。

Lifecycle.Event 生命周期事件，这些事件对应Activity/Fragment生命周期方法。

ON_CREATE: 对应onCreate方法

ON_START: 对应onStart方法

ON_RESUME: 对应onResume方法

ON_PAUSE: 对应onPause方法

ON_STOP: 对应onStop方法

ON_DESTROY: 对应onDestroy方法

ON_ANY: 匹配任何事件

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();
    
   //生命周期事件，对应Activity生命周期方法 
 public enum Event {
    	ON_CREATE,
        ON_START,
        ON_RESUME,
        ON_PAUSE,
        ON_STOP,
        ON_DESTROY,
        ON_ANY; //可以响应任意一个事件
        
        public static Event downFrom(@NonNull State state) {}
        public static Event downTo(@NonNull State state) {}
        public static Event upFrom(@NonNull State state) {}
        public static Event upTo(@NonNull State state) {}
        public State getTargetState() {}
    }

 //生命周期状态. （Event是进入这种状态的事件）
	public enum State {
		DESTROYED,
        INITIALIZED,
        CREATED,
        STARTED,
        RESUMED;
       //判断至少是某一状态
		public boolean isAtLeast(@NonNull State state)
	}
}

Lifecycle 的实现原理

Lifecycle的实现原理是基于观察者模式，主要依赖于三个类：LifecycleOwner、LifecycleRegistry和LifecycleObserver。

观察者模式 → 对象间定义一对多的依赖，当一个对象状态发生改变，依赖对象都会自动收到通知；

1.LifecycleOwner接口(Lifecycle持有者/被观察者）：

在支持库 26.1.0 及更高版本中的 Fragment 和 Activity 已实现 LifecycleOwner 接口。所以在Activity /Fragment创建时 ,就可以直接通过getLifecycle()方法获取Lifecycle生命周期对象,所以LifecycleOwner(Activity /Fragment)是一个具有生命周期的组件。Activity /Fragment已经是一个拥有生命周期变化的被观察者了。

通过Lifecycle实例对象的addObserver( LifecycleObserver observer)方法直接注册一个自定义的观察者对象。所以Activity /Fragment 的生命周期的改变会被其注册的观察者对象BlackStateBarLifecycleObserver观察到并触发其对应的事件。

在Activity中调用getLifecycle()能获取到Lifecycle实例，那getLifecycle()是哪里定义的方法呢？是接口LifecycleOwner，顾明来思义，生命周期拥有者：

LifecycleOwner接口

/**
 * 生命周期拥有者
 * 生命周期事件可被 自定义的组件 用来 处理生命周期事件的变化，同时不会在Activity/Fragmen中写任何代码
 */

public interface LifecycleOwner {
    public val lifecycle: Lifecycle
}

ComponentActivity继承 LifecycleOwner

Activity实现了LifecycleOwner，所以才能直接使用getLifecycle()，具体是在androidx.activity.ComponentActivity中:

@RestrictTo(LIBRARY_GROUP_PREFIX)
public class ComponentActivity extends Activity implements LifecycleOwner{
 //LifecycleRegistry是Lifecycle具体实现
private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);// [1]

	@SuppressLint("RestrictedApi")
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ReportFragment.injectIfNeededIn(this);// [2] 使用ReportFragment分发生命周期事件
    }

	@CallSuper
    @Override
    protected void onSaveInstanceState(@NonNull Bundle outState) {
        Lifecycle lifecycle = getLifecycle();
        if (lifecycle instanceof LifecycleRegistry) {
            ((LifecycleRegistry) lifecycle).setCurrentState(Lifecycle.State.CREATED);
        }
        super.onSaveInstanceState(outState);
        mSavedStateRegistryController.performSave(outState);
    }
	@NonNull
    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;// [4] getLifecycle()返回了LifecycleRegistry实例
    }
}

生命周期事件分发——ReportFragment

首先injectIfNeededIn()内进行了版本区分：在API 29及以上直接使用activity的registerActivityLifecycleCallbacks 直接注册了生命周期回调，然后给当前activity添加了ReportFragment，注意这个fragment是没有布局的。

然后，无论LifecycleCallbacks、还是fragment的生命周期方法最后都走到了 dispatch(Activity activity, Lifecycle.Event event)方法，其内部使用LifecycleRegistry的handleLifecycleEvent方法处理事件。

而ReportFragment的作用就是获取生命周期而已，因为fragment生命周期是依附Activity的。好处就是把这部分逻辑抽离出来，实现activity的无侵入。如果你对图片加载库Glide比较熟，就会知道它也是使用透明Fragment获取生命周期的。

//专门用于分发生命周期事件的Fragment
public class ReportFragment extends Fragment {
    
    public static void injectIfNeededIn(Activity activity) {
        if (Build.VERSION.SDK_INT >= 29) {
            //在API 29及以上，可以直接注册回调 获取生命周期
            activity.registerActivityLifecycleCallbacks(
                    new LifecycleCallbacks());
        }
        //API29以前，使用fragment 获取生命周期
        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
            manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
            manager.executePendingTransactions();
        }
    }

    @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);//使用LifecycleRegistry的handleLifecycleEvent方法处理事件
            }
        }
    }

    @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 onResume() {
        super.onResume();
        dispatch(Lifecycle.Event.ON_RESUME);
    }
    @Override
    public void onPause() {
        super.onPause();
        dispatch(Lifecycle.Event.ON_PAUSE);
    }
    ...省略onStop、onDestroy
    
    private void dispatch(@NonNull Lifecycle.Event event) {
        if (Build.VERSION.SDK_INT < 29) {
            dispatch(getActivity(), event);
        }
    }
    
    //在API 29及以上，使用的生命周期回调
    static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {
        ...
        @Override
        public void onActivityPostCreated(@NonNull Activity activity,@Nullable Bundle savedInstanceState) {
            dispatch(activity, Lifecycle.Event.ON_CREATE);
        }
        @Override
        public void onActivityPostStarted(@NonNull Activity activity) {
            dispatch(activity, Lifecycle.Event.ON_START);
        }
        @Override
        public void onActivityPostResumed(@NonNull Activity activity) {
            dispatch(activity, Lifecycle.Event.ON_RESUME);
        }
        @Override
        public void onActivityPrePaused(@NonNull Activity activity) {
            dispatch(activity, Lifecycle.Event.ON_PAUSE);
        }
        ...省略onStop、onDestroy
    }
}

2.LifecycleRegistry 继承Lifecycle(存储生命周期状态/生命周期事件处理)：

LifecycleRegistry：是一个类，继承Lifecycle。它负责管理LifecycleOwner的生命周期状态，并将这些状态通知给已注册的观察者对象。每个LifecycleOwner都对应一个LifecycleRegistry。

所以我们在LifecycleOwner(Activity /Fragment)里获取的Lifecycle实例对象本质就是获取的LifecycleRegistry对象。它会将自己的状态变化通知给所有注册的自定义观察者对象(BlackStateBarLifecycleObserver)。

(1)LifecycleRegistry源码

使用getStateAfter()获取event发生之后的将要处于的状态（看前面那张图很好理解），moveToState()是移动到新状态，最后使用sync()把生命周期状态同步给所有观察者。

注意到sync()中有个while循环，很显然是在遍历观察者。并且很显然观察者是存放在mObserverMap中的，而mObserverMap对观察者的添加很显然就是 Activity中使用getLifecycle().addObserver()这里：

循环条件是!isSynced()，若最老的和最新的观察者的状态一致，且都是ower的当前状态，说明已经同步完了。

没有同步完就进入循环体：

mState比最老观察者状态小，走backwardPass(lifecycleOwner)：从新到老分发，循环使用downEvent()和observer.dispatchEvent()，连续分发事件；
mState比最新观察者状态大，走forwardPass(lifecycleOwner)：从老到新分发，循环使用upEvent()和observer.dispatchEvent()，连续分发事件。

open class LifecycleRegistry private constructor(
    provider: LifecycleOwner,
    private val enforceMainThread: Boolean
) : Lifecycle() {
...
    @MainThread
    @Deprecated("Override [currentState].")
    open fun markState(state: State) {
        enforceMainThreadIfNeeded("markState")
        currentState = state
    }


//LifecycleRegistry.java
   //系统自定义的保存Observer的map，可在遍历中增删
    private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap = new FastSafeIterableMap<>();
            
    public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        State next = getStateAfter(event);//获取event发生之后的将要处于的状态
        moveToState(next);//移动到这个状态
    }

    private void moveToState(State next) {
        if (mState == next) {
            return;//如果和当前状态一致，不处理
        }
        mState = next; //赋值新状态
        if (mHandlingEvent || mAddingObserverCounter != 0) {
            mNewEventOccurred = true;
            return;
        }
        mHandlingEvent = true;
        sync(); //把生命周期状态同步给所有观察者
        mHandlingEvent = false;
    }
    
        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()) {  //isSynced()意思是 所有观察者都同步完了
            mNewEventOccurred = false;
            //mObserverMap就是 在activity中添加observer后 用于存放observer的map
            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;
    }
    ...
    
     static State getStateAfter(Event event) {
        switch (event) {
            case ON_CREATE:
            case ON_STOP:
                return CREATED;
            case ON_START:
            case ON_PAUSE:
                return STARTED;
            case ON_RESUME:
                return RESUMED;
            case ON_DESTROY:
                return DESTROYED;
            case ON_ANY:
                break;
        }
        throw new IllegalArgumentException("Unexpected event value " + event);
    }




}

//LifecycleRegistry.java
    @Override
    public void addObserver(@NonNull LifecycleObserver observer) {
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        //带状态的观察者，这个状态的作用：新的事件触发后 遍历通知所有观察者时，判断是否已经通知这个观察者了
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
        //observer作为key，ObserverWithState作为value，存到mObserverMap

        if (previous != null) {
            return;//已经添加过，不处理
        }
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        if (lifecycleOwner == null) {
            return;//lifecycleOwner退出了，不处理
        }
	//下面代码的逻辑：通过while循环，把新的观察者的状态 连续地 同步到最新状态mState。
    //意思就是：虽然可能添加的晚，但把之前的事件一个个分发给你(upEvent方法)，即粘性
        boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
        State targetState = calculateTargetState(observer);//计算目标状态
        mAddingObserverCounter++;
        while ((statefulObserver.mState.compareTo(targetState) < 0
                && mObserverMap.contains(observer))) {
            pushParentState(statefulObserver.mState);
            statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
            popParentState();
            // mState / subling may have been changed recalculate
            targetState = calculateTargetState(observer);
        }

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

(2)我们继续看下 ObserverWithState:

mState的作用是：新的事件触发后遍历通知所有观察者时，判断是否已经通知这个观察者了，即防止重复通知。

mLifecycleObserver是使用Lifecycling.getCallback(observer)获取的GenericLifecycleObserver实例。GenericLifecycleObserver是接口，继承自LifecycleObserver：

    static class ObserverWithState {
        State mState;
        GenericLifecycleObserver mLifecycleObserver;

        ObserverWithState(LifecycleObserver observer, State initialState) {
     //mLifecycleObserver是使用Lifecycling.getCallback(observer)获取的GenericLifecycleObserver实例。GenericLifecycleObserver是接口，继承自LifecycleObserver：
            mLifecycleObserver = Lifecycling.getCallback(observer);
            mState = initialState;
        }

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

(3) LifecycleEventObserver

LifecycleEventObserver 给 LifecycleObserver 增加了感知生命周期状态变化的能力。

//接受生命周期改变并分发给真正的观察者
public interface LifecycleEventObserver extends LifecycleObserver {
    //生命周期状态变化
    void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);
}

3.LifecycleObserver空接口（ Lifecycle生命周期观察者）:

LifecycleObserver: 是一个接口，生命周期观察者。可以观察监听到LifecycleOwner(Activity /Fragment)生命周期状态变化。

开发人员可以创建一个自定义的观察者对象实现LifecycleObserver接口.来监听LifecycleOwner(Activity/Fragment)的生命周期状态变化.

在收到生命周期状态变化通知后，可以根据状态变化执行相应的操作。

怎么实现呢?LifecycleOwner(Activity/Fragment)生命周期被观察者,通过addObserver(LifecycleObserver o)去注册一个生命周期观察者对象BlackStateBarLifecycleObserver

public interface LifecycleObserver{
}

Lifecycle 的注意事项与优化技巧

1.LifecycleOwner(Activity被观察者)和LifecycleObserver(自定义观察者)之间的关系是单向的。LifecycleOwner可以注册多个观察者对象，但观察者只能注册一个LifecycleOwner被观察者。

坏蛋(LifecycleOwner(Activity)被观察者)同时会被多个不同警察(LifecycleObserver(自定义观察者))一起监控,

但是一个警察(LifecycleObserver(自定义观察者)) 只能同时监控一个坏蛋(LifecycleOwner(Activity)被观察者),忙不过来。

2.在使用自定义LifecycleObserver观察者时，需要在组件(Activity)的生命周期内注册和解除注册自定义LifecycleObserver观察者。否则，自定义LifecycleObserver观察者将无法收到组件(Activity)的生命周期状态变化的通知。

3.在Activity或Fragment的生命周期状态变化时，只通知已经注册了的自定义LifecycleObserver观察者。

4.在自定义LifecycleObserver观察者的方法中，尽量避免执行耗时操作。

Lifecycle应用场景

1.控制视频缓冲的开始与停止：启动App的时候可以更快的开始缓冲视频，App销毁时停止缓冲。

2.开始和停止网络连接：应用位于前台时可能需要实时传输数据，并在应用进入后台时自动暂停。

3.控制页面动画的启动与停止：动画在页面可见时进行播放，不可见时停止。

LifeCycle添加依赖

非androidX项目 引入:

implementation "android.arch.lifecycle:extensions:1.1.1"

androidX项目 引入:

那么我们就可以使用Lifecycle库了，因为appcompat依赖了androidx.fragment，而androidx.fragment下依赖了ViewModel和 LiveData，LiveData内部又依赖了Lifecycle。

implementation 'androidx.appcompat:appcompat:1.2.0'

如果想要单独引入依赖，关于lifecycle的依赖可以根据情况进行添加，不必全部添加。

除了Activity和Fragment外，还可以绑定Service和Application的生命周期。只要引入支持相关的可选库即可；官方提到最多的是Activity和Fragment，是因为平时主要用于这两个组件；其实只要有生命周期的组件都可以跟它绑定。而在Android中大多数的组件都是有生命周期的。

//app的build.gradle   
  dependencies {
        def lifecycle_version = "2.5.0-rc01"
        def arch_version = "2.1.0"

        // ViewModel
        // ViewModel模块（普通版），用在普通xml写的页面上的，以生命周期的方式管理界面相关的数据。
        implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version"
        // ViewModel utilities for Compose
        // 这个也是ViewModel模块（Compose版），只不过它是用在Compose页面的。
        implementation "androidx.lifecycle:lifecycle-viewmodel-compose:$lifecycle_version"
        // LiveData
        // livedata与lifecycle 有啥关系？
        // LiveData是在lifecycle基础上出来的，用于观察数据的变化，来及时更新UI界面，也就是“观察者模式”，它与“Observable”区别是，LiveData是会感知生命周期的；
        implementation "androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version"
        // Lifecycles only (without ViewModel or LiveData)
        // 只有Lifecycle,不包含VM 和 LiveData
        implementation "androidx.lifecycle:lifecycle-runtime-ktx:$lifecycle_version"

        // Saved state module for ViewModel
        // 使ViewModel支持保存状态。无论配置变化时，还是程序意外关闭时，当用到onSaveInstanceState()保存数据和恢复数据时，就可引入下面库，让这些操作在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
        // 替代——如果使用Java8，请使用以下替代生命周期编译器
        // 最新版的Android Studio 2021.2.1 默认是用Java 11了，这条可不用。
        implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"

        // optional - helpers for implementing LifecycleOwner in a Service
        // 可选-用于在Service中实现LifecycleOwner
        implementation "androidx.lifecycle:lifecycle-service:$lifecycle_version"

        // optional - ProcessLifecycleOwner provides a lifecycle for the whole application process
        // 可选-ProcessLifecycleOwner为整个应用程序进程提供生命周期
        implementation "androidx.lifecycle:lifecycle-process:$lifecycle_version"

        // optional - ReactiveStreams support for LiveData
        // 可选-使LiveData支持ReactiveStreams, ReactiveStreams是什么？？
        // ReactiveStreams(反应式流) 本质上是对数据流或某种变化所作出的反应，但是这个变化什么时候发生是未知的，所以他是一种基于异步、回调的方式在处理问题。
        implementation "androidx.lifecycle:lifecycle-reactivestreams-ktx:$lifecycle_version"

        // optional - Test helpers for LiveData
        // 可选-LiveData的测试帮助程序。
        testImplementation "androidx.arch.core:core-testing:$arch_version"
    }

LifeCycle使用示例

1.创建一个自定义的观察者类BlackStateBarLifecycleObserver,继承DefaultLifecycleObserver接口

BlackStateBarLifecycleObserver是如何使用生命周期的呢？看下BlackStateBarLifecycleObserver的实现：

public class BlackStateBarLifecycleObserver implements DefaultLifecycleObserver {

    private BaseActivity activity;

    public BlackStateBarLifecycle(BaseActivity activity) {
        this.activity = activity;
    }

     
    public void onCreate() {
        ImmersionBar.with(activity)
//                .statusBarColor(R.color.transparent)
//                .fullScreen(true)
                .transparentStatusBar()
                .statusBarDarkFont(true)
                .keyboardEnable(true)
                .init();
    }

override fun onResume(owner: LifecycleOwner) {
        // 执行业务逻辑
    }

    override fun onPause(owner: LifecycleOwner) {
       // 执行业务逻辑
    }



    
    public void onDestroy() {
        activity = null;
    }
}

2.在Activity里(可以直接获取lifeCycle对象),通过lifeCycle对象添加自定义的观察者BlackStateBarLifecycleObserver对象

Activity（或Fragment）是生命周期的拥有者，通过getLifecycle()方法获取到生命周期Lifecycle对象，Lifecycle对象使用addObserver方法给自己添加观察者对象，即BlackStateBarLifecycleObserver对象。当Lifecycle的生命周期发生变化时，BlackStateBarLifecycleObserver就可以感知到。

class MainActivity : AppCompatActivity(){
    val observer = BlackStateBarLifecycleObserver(this)
    override fun onCreate(savedInstanceState: Bundle?) {
        lifecycle.addObserver(observer)
    }
    override fun onDestroy() {
        lifecycle.removeObserver(observer) //需要注意的是这个不需要显示调用，写这里只是让知道有这么个函数
    }
}

自定义一个观察者对象 MyLifecycleOwner实现LifecycleOwner接口

除了Activity和Fragment组件已经默认实现了此接口LifecycleOwner外，我们也可以自定义一个MyLifecycleOwner类实现LifecycleOwner接口，让它具有生命周期，需要使用Lifecycle的实现类LifecycleRegistry来记录状态。

MyLifecycleOwner实现LifecycleOwner，getLifecycle()返回lifecycleRegistry实例。lifecycleRegistry实例则是在onCreate创建，并且在各个生命周期内调用markState()方法完成生命周期事件的传递。这就完成了LifecycleOwner的自定义，也即MyLifecycleOwner变成了LifecycleOwner，然后就可以和实现了LifecycleObserver的组件配合使用了。

class   MyLifecycleOwner: LifecycleOwner {

    private lateinit var lifecycleRegistry: LifecycleRegistry

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        lifecycleRegistry = LifecycleRegistry(this)
         // 设置此时状态
        lifecycleRegistry.markState(Lifecycle.State.CREATED)
    }

    public override fun onStart() {
        
         // 设置此时状态
        lifecycleRegistry.markState(Lifecycle.State.STARTED)
    }

/** 返回生命周期实例 */
    override fun getLifecycle(): Lifecycle {
        return lifecycleRegistry
    }
}

DefaultLifecycleObserver接口（具体观察者）

DefaultLifecycleObserver接口继承 FullLifecycleObserver,默认重写了回调方法，具体观察者 按需实现关注的回调方法即可。

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) { }
}

FullLifecycleObserver接口

FullLifecycleObserver继承LifecycleObserver接口

LifecycleEventObserver接口

LifecycleEventObserver接口继承LifecycleObserver，实现onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event)方法

其实到上述部分就结束了，这里是对其进行的拓展。上面知道了对生命周期的监听，除了该方式外还可以对生命周期的事件进行监听，如下:

      this.getLifecycle().addObserver(new LifecycleEventObserver() {
                public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Event event) {
                    if (event == Event.ON_DESTROY) {
                          // 页面销毁
                    }

                }
            });

Lifecycle的方法

getCurrentState()获取当前生命周期状态

isAtLeast(@NonNull State state)大于等于既定的状态

比如如果某段代码需要在页面存在期间更新，倘若页面销毁了再更新ui会崩溃，可以使用以下写法

 val isCreated = lifecycle.currentState.isAtLeast(Lifecycle.State.CREATED)
        if (!isCreated) return

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();
    
   //生命周期事件，对应Activity生命周期方法 
 public enum Event {
    	ON_CREATE,
        ON_START,
        ON_RESUME,
        ON_PAUSE,
        ON_STOP,
        ON_DESTROY,
        ON_ANY; //可以响应任意一个事件
        
        public static Event downFrom(@NonNull State state) {}
        public static Event downTo(@NonNull State state) {}
        public static Event upFrom(@NonNull State state) {}
        public static Event upTo(@NonNull State state) {}
        public State getTargetState() {}
    }

 //生命周期状态. （Event是进入这种状态的事件）
	public enum State {
		DESTROYED,
        INITIALIZED,
        CREATED,
        STARTED,
        RESUMED;
       //判断至少是某一状态
		public boolean isAtLeast(@NonNull State state)
	}
}