JetPack--Lifecycle

郑子

已于 2024-04-23 10:08:42 修改

阅读量900

点赞数 13

分类专栏： Android：源码篇文章标签： android

于 2024-01-19 16:59:19 首次发布

本文链接：https://blog.csdn.net/weixin_42277946/article/details/135692976

版权

Android：源码篇专栏收录该内容

16 篇文章 2 订阅

订阅专栏

本文详细介绍了AndroidLifecycle库如何帮助管理Activity和Fragment的生命周期，包括添加依赖、基本使用方法（如在Activity和MVP中的应用）、自定义LifecycleOwner以及原理和实现。还涵盖了面试中可能涉及的问题，如Activity的事件分发机制和观察者接收到完整生命周期事件的情况。

摘要由CSDN通过智能技术生成

一、前言

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

如果在组件中做了耗时操作，比如在onStart方法，这样就无法保证组件在Activity或者Fragment停止之前完成启动。

因此需要一个能管理Activity和Fragment的生命周期的库，这个库就是Lifecycle。

二、定义

具备生命周期后期感知能力的组件，它能持有组件（如Activity、Fragment）生命周期状态的信息，并且允许其他观察者监听宿主的状态

三、使用

1.添加依赖

    dependencies {
        def lifecycle_version = "2.7.0"
        def arch_version = "2.2.0"

        // 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"
        // Lifecycle utilities for Compose
        implementation "androidx.lifecycle:lifecycle-runtime-compose:$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"

        // optional - Test helpers for Lifecycle runtime
        testImplementation "androidx.lifecycle:lifecycle-runtime-testing:$lifecycle_version"
    }

2.基本用法

public class MyObserver implements LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void connectListener() {
        ...
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void disconnectListener() {
        ...
    }
}

myLifecycleOwner.getLifecycle().addObserver(new MyObserver());

新建一个MyObserver类，实现LifecycleObserver接口，MyObserver成为了一个Lifecycle的观察者
然后将MyObserver添加到LifecycleOwner中

LifecycleOwner是一个接口，其内部只有一个方法getLifecycle()，用于获取Lifecycle，当Lifecycle的生命周期发生变化时，MyObserver就会感知到

3.Activity中使用

public class MainActivity extends AppCompatActivity {

    private static final String TAG = "MainActivity";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        getLifecycle().addObserver(new MyObserver());
    }

    public class MyObserver implements LifecycleObserver{

        @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
        void onResume(){
            Log.d(TAG, "Lifecycle call onResume");
        }
        @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
        void onPause(){
            Log.d(TAG, "Lifecycle call onPause");
        }
    }

    @Override
    protected void onResume() {
        super.onResume();
        Log.d(TAG, "onResume");
    }

    @Override
    protected void onPause() {
        super.onPause();
        Log.d(TAG, "onPause");
    }
}

先实现MyObserver，对ON_CREATE和ON_RESUME事件进行监听

Android 26.1.0 及其之后的版本中Activity和Fragment已经默认实现了LifecycleOwner接口，所以可以直接使用getLifecycle方法获取Lifecycle对象

4.MVP中使用

public class MyPresenter implements IPresenter {
    private static final String TAG = "test";

    @Override
    public void onResume() {
        Log.d(TAG, "Lifecycle call onResume");
    }

    @Override
    public void onPause() {
        Log.d(TAG, "Lifecycle call onPause");
    }
}

interface IPresenter extends LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    void onResume();

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    void onPause();
}

IPresenter接口继承自LifecycleObserver接口，MyPresenter又实现了IPresenter接口，这样MyPresenter成为了一个观察者

public class MainActivity extends AppCompatActivity {

    private static final String TAG = "MainActivity";
    private IPresenter mPresenter;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mPresenter = new MyPresenter();
        getLifecycle().addObserver(mPresenter);
    }

    @Override
    protected void onResume() {
        super.onResume();
        Log.d(TAG, "onResume");
    }

    @Override
    protected void onPause() {
        super.onPause();
        Log.d(TAG, "onPause");

    }
}

MainActivity成为了被观察者，当它的生命周期发生变化时，MyPresenter就可以观察到，这样就不需要在MainActivity的多个生命周期方法中调用MyPresenter的方法了

5.自定义LifecycleOwner

使用LifecycleRegistry，它是Lifecycle的实现类

public class MyActivity extends AppCompatActivity {
    private LifecycleRegistry lifecycleRegistry;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        lifecycleRegistry = new LifecycleRegistry(this);
        lifecycleRegistry.markState(Lifecycle.State.CREATED);
    }

    @Override
    public void onStart() {
        super.onStart();
        lifecycleRegistry.markState(Lifecycle.State.STARTED);
    }

    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return lifecycleRegistry;
    }
}

通过新建LifecycleRegistry，为LifecycleRegistry设置Lifecycle的各种状态，并通过getLifecycle方法返回该LifecycleRegistry

四、原理

1.Lifecycle的生命周期状态事件和状态

Lifecycle使用两个枚举来跟踪其关联组件的生命周期状态，这两个枚举分别是Event和State。

State指的是Lifecycle的生命周期所处的状态
Event代表Lifecycle生命周期对应的事件，这些事件会映射到Activity和Fragment中的回调事件中

public abstract class Lifecycle {
   
    @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;
        }
    }
}

Lifecycle是一个抽象类，包括了添加和移除观察者的方法，还包括Event和State枚举。Event中的事件和Activity的生命周期几乎是对应的，除了ON_ANY，它可用于匹配所有事件

2.Lifecycle如何观察Activity和Fragment的生命周期

Fragment实现Lifecycle的相关代码

//实现自LifecycleOwner  生命周期宿主的意思
public class Fragment implements LifecycleOwner {
    //注册接口时都会被注册到LifecycleRegistry这个类中
    LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

    //Lifecycle是LifecycleRegistry的父类 面向接口编程思想
    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        //复写自LifecycleOwner 所以必须new LifecycleRegistry返回
        return mLifecycleRegistry;
    }

    //分发每一个状态到每一个观察者，从而实现观察生命周期变化的能力
    void performCreate() {
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
    }

    void performStart() {
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
    }

    void performStop() {
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
    }
}

Activity实现Lifecycle的相关代码

public class ComponentActivity extends Activity implements LifecycleOwner {
    LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //往自己上面添加一个不可见的fragment ReportFragment，专门用于报告当前状态分发给每一个观察者
        //目的是为了兼顾继承来自AppCompactActivity的场景
        ReportFragment.injectIfNeededIn(this);
    }
}

ReportFragment相关代码：

    public static void injectIfNeededIn(Activity activity) {
        if (VERSION.SDK_INT >= 29) {
            ReportFragment.LifecycleCallbacks.registerIn(activity);
        }

        FragmentManager manager = activity.getFragmentManager();
        if (manager.findFragmentByTag("androidx.lifecycle.LifecycleDispatcher.report_fragment_tag") == null) {
            manager.beginTransaction().add(new ReportFragment(), "androidx.lifecycle.LifecycleDispatcher.report_fragment_tag").commit();
            manager.executePendingTransactions();
        }

    }

 public void onStart() {
        super.onStart();
        this.dispatchStart(this.mProcessListener);
        this.dispatch(Event.ON_START);
    }

    public void onResume() {
        super.onResume();
        this.dispatchResume(this.mProcessListener);
        this.dispatch(Event.ON_RESUME);
    }

    public void onPause() {
        super.onPause();
        this.dispatch(Event.ON_PAUSE);
    }

    public void onStop() {
        super.onStop();
        this.dispatch(Event.ON_STOP);
    }

    public void onDestroy() {
        super.onDestroy();
        this.dispatch(Event.ON_DESTROY);
        this.mProcessListener = null;
    }

    static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
        if (activity instanceof LifecycleRegistryOwner) {
            ((LifecycleRegistryOwner)activity).getLifecycle().handleLifecycleEvent(event);
        } else {
            if (activity instanceof LifecycleOwner) {
                Lifecycle lifecycle = ((LifecycleOwner)activity).getLifecycle();
                if (lifecycle instanceof LifecycleRegistry) {
                    ((LifecycleRegistry)lifecycle).handleLifecycleEvent(event);
                }
            }

        }
    }

往自己上面添加一个不可见的fragment ReportFragment，专门用于报告当前状态分发给每一个观察者

在ReportFragment中将自己添加到Activity里，在它的各个生命周期中都调用dispatch方法，在dispatch方法中拿到Lifecycle对象，然后把当前事件分发给每一个观察者

总结：

Activity的事件分发是通过ReportFragment来完成的
目的：为了兼顾不是继承自AppCompactActivity的场景，比如直接继承Activity，只要继承LifecycleOwner接口，也会具备生命周期分发的能力

3.Lifecycle的三种方式

LifecycleObserver

用注解的形式标记在方法上来观察宿主的生命周期变化的事件

//1.自定义的LifecycleObserver观察者，用注解声明每个方法观察的宿主的状态
public class TestObserver implements LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    void onStart(LifecycleOwner owner){
       
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    void onStop(LifecycleOwner owner){
      
    }
}

//2.注册观察者，观察宿主生命周期状态的变化 不需要在宿主销毁的时候进行反注册
public class MyFragment extends Fragment {
    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
       
        TestObserver observer = new TestObserver();
        getLifecycle().addObserver(observer);
    }
}

FullLifecycleObserver

LifecycleEventObserver

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

public class LocationObserver implements LifecycleEventObserver {
    @Override
    public void onStateChanged(@NonNull LifecycleOwner lifecycleOwner, @NonNull Lifecycle.Event event) {
        //自行判断life-event 是onStart 还是onStop
    }
}

4.LifecycleOwner、Lifecycle、LifecycleRegistry的关系

LifecycleOwner：宿主，代表着Activity、Fragment，都实现了这个接口，也可以自定义一个类，是现在这个接口，让它成为生命周期的宿主，从而让其他的观察者来观察变化

Lifecycle：只要实现了LifecycleOwner接口，就必须实现getLifecycle()方法，返回一个Lifecycle对象

LifecycleRegistry：这个Lifecycle对象也就是LifecycleRegistry，采用了面向接口的编程方式，向LifecycleRegistry注册接口时可以是LifecycleObserver、FullLifecycleObserver、LifecycleEventObserver

总结：宿主在自己的各个生命周期的方法里让这个LifecycleRegistry去分发自己的生命周期事件给每一个观察者

五、源码分析

1.添加观察者生命周期事件分发流程

在LifecycleRegistry的addObserver方法中得到initState对象，然把传递进来的observer封装成了ObserverWithState对象没并且把initState状态传递了进去，然后添加到mObserverMap集合中

@0verride
public void addObserver(@NonNull Lifecycle0bserver observer){
    State initialState = mState == DESTR?YED ? DESTROYED : INITIALIZED;
    ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
    ObserverWithState previous = mobserverMap.putIfAbsent(observer, statefulObserver);

}

State：当前宿主的状态，一个枚举，定义了DESTROYED, INITIALIZED, CREATED, STARTED, RESUMED

initState：只要不是在onDestory中创建的，初始状态都为INITIALIZED状态

ObserverWithState：拥有宿主状态的观察者

for循环中，让当前观察者，也就是statefulObserver，把它的状态INITIALIZED状态，让它前进到宿主当前的状态

State targetState = calculateTargetState(observer);

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);

先通过calculateTargetState去计算出observe应该到达的状态，也就是当前宿主的状态，接下来把观察者的状态和target状态做一个比较，如果小于0，就说明观察者的状态还没有达到target状态，就让生命周期前进，通过dispatchEvent，upEvent 。直到观察者状态达到target状态，退出for循环

如果宿主的onResume生命周期中注册一个observer，需要把宿主的onCreate、onStart、onResume都分发给observer，直到观察者的状态和宿主的状态对齐为止

2.宿主在生命周期变化之后分发流程

在每一个生命周期的方法中调用LifecycleRegistry的handleLifecycleEvent 方法，并且传递一个事件

首先通过getStateAfter根据当前事件推导出每一个观察者应该到达的生命周期的状态

然后调用moveToState，在这个方法中做一些条件判断，状态同步在sync方法中

private void sync(){

    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
    if (lifecycleOwner == null){
        throw new IllegalStateException("Lifecycle0wner of this LifecycleRegistry is already " + "garbage collected, It is too late to change lifecycle state.");

    while(!isSynced()){
        mNewEventOccurred = false;
        // no need to check eldest for nullability, because isSynced does it for us.
        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;
}

backwardPass：让集合中所有观察者都倒退到和宿主一样的状态，并且分发相应的事件给它们，根据观察者当前的状态计算出应该分发哪一种事件，由于是生命周期的倒退，调用downEvent

forwardPass：生命周期前进，调用upEvent

直到观察者的状态和宿主的状态都一致，才退出循环

总结：每一个生命周期变化时都会分发相应事件，并且根据事件推导出宿主的状态，然后遍历所有的观察者，让它们的状态随之升级，或者降级，并且把本次事件分发给观察者

3.事件在分发时是区分具体类型

如何区分LifecycleObserver、FullLifecycleObserver还是LifecycleEventObserver

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;
    }
}

分发事件时调用了onStateChanged方法

Lifecycling一个工具类，通过适配器，把observer转化成LifecycleEventObserver对象，

@NonNull
static LifecycleEventObserver lifecycleEventObserver(Object object){
    boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
    boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
    if (isLifecycleEventObserver && isFullLifecycleObserver)
        return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,(LifecycleEventObserver)object);
    }

    if (isFullLifecycle0bserver){
        return new FullLifecycle0bserverAdapter((FullLifecycle0bserver) object,  null);
    }
    if(isLifecycleEventobserver){
        return(LifecycleEvent0bserver)obiect;
    }

    final class<?> klass = obiect.getclass();
    int type = getObserverConstructorType(klass);
    
    if(type == GENERATED_CALLBACK){
        List<Constructor<? extends GeneratedAdapter>> constructors =
sClassToAdapters.get(klass);
        if(constructors.size() = 1){
            GeneratedAdapter generatedAdapter = createGeneratedAdapter(
constructors.get(0)，obiect);
            return new SingleGeneratedAdapterObserver(generatedAdapter);
        }
        GeneratedAdapterl] adapters = new GeneratedAdapter[constructors.size()];
        for(int i = 0;i < constructors.size(); i++){
            adapters[i]= createGeneratedAdapter(constructors.get(i), object);
        }
        return new compositeGeneratedAdapters0bserver(adapters);
    }
    return new ReflectiveGenericLifecycle0bserver(object);
}