Jetpack:Lifecycle组件

最新推荐文章于 2023-06-12 13:12:16 发布

Air Field

最新推荐文章于 2023-06-12 13:12:16 发布

阅读量215

点赞数

分类专栏： Android Jetpack 文章标签： Jetpack Lifecycle

本文链接：https://blog.csdn.net/prisonjoker/article/details/114487952

版权

Android Jetpack 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

1. Lifecycle简介

Lifecycle是Android Jetpack框架提供的能够感知组件(宿主)生命周期变化的组件，它能持有宿主(如Activity或Fragment)生命周期状态的信息，并且允许其他观察者注册监听宿主的生命周期状态变化，这就使得我们不用主动去获取宿主的状态，有利于降低代码耦合度并更容易维护。Lifecycle是JetPack组件库的核心基础，很多其他的Jetpack组件，比如LiveData、ViewMoedel等，都是基于它实现的。

1.1 Lifecycle基本使用

（1）添加依赖

    def lifecycle_version = "2.3.0"
    def arch_version = "2.1.0"

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

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

    // Annotation processor
    annotationProcessor "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:$lifecycle_version"

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

（2）实现一个观察者

创建一个观察者Observer主要有三种实现方式，即LifecycleObserver、LifecycleEventObserver和DefaultLifecycleObserver，其中，后两者均继承于LifecycleObserver，它是一个空的接口，如果直接继承这个接口，将通过注解的方式实现监听回调。但相比注解方式，官方更推荐使用DefaultLifecycleObserver，该接口也允许我们选择性的实现对应的回调方法。注意，它需要Java8支持。

public class MyLifecycleObserver implements DefaultLifecycleObserver {

    String TAG= "MyLifecycleObserver";

    @Override
    public void onCreate(@NonNull LifecycleOwner owner) {
        Log.i(TAG,"onCreate");
    }

    @Override
    public void onStart(@NonNull LifecycleOwner owner) {
        Log.i(TAG,"onStart");
    }

    @Override
    public void onResume(@NonNull LifecycleOwner owner) {
        Log.i(TAG,"onResume");
    }

    @Override
    public void onPause(@NonNull LifecycleOwner owner) {
        Log.i(TAG,"onPause");
    }

    @Override
    public void onStop(@NonNull LifecycleOwner owner) {
        Log.i(TAG,"onStop");
    }

    @Override
    public void onDestroy(@NonNull LifecycleOwner owner) {
        Log.i(TAG,"onDestroy");
    }
}

（3）注册观察者

为了实现对宿主生命周期状态的监听，我们需要将一个观察者对象注册到宿主中，这个过程主要是通过获取宿主的Lifecycle对象，并调用它的addObserver()方法实现的，该方法的具体实现在LifecycleRegister中，这个类是Lifecycle的唯一实现类。

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        addLifecycleObserver();
    }

    public void addLifecycleObserver(){
        getLifecycle().addObserver(new MyLifecycleObserver());
    }

1.2自定义LifecycleOwner

如果我们的Activity由于各种原因继承的不是AppcompatActivity而是Activity呢

我们可以看到这个时候，就不能直接使用getLifecycle，而要自定义一个LifecycleOwner了，我们让Activity继承自LifecycleOwner

public class MainActivity extends Activity implements LifecycleOwner {

    LifecycleRegistry LifecycleRegistry;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        LifecycleRegistry = new LifecycleRegistry(this);
        addLifecycleObserver();
    }

    public void addLifecycleObserver(){
        getLifecycle().addObserver(new MyLifecycleObserver());
    }

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

这样我们就实现了自定义LifecycleOwner了

2. Lifecycle实现原理

2.1 Lifecycle框架模型

Lifecycle框架类图如下

在这里插入图片描述

从Lifecycle框架模型可知，该框架感知一个组件的生命周期状态变化原理为：
首先，让一个组件(如Activity或Fragment)继承LifecycleOwner接口，用以表明自己是一个拥有生命周期变化的组件(宿主)，
同时重写lifecycleOwner接口的getLifecycle()方法，该方法会返回一个Lifecycle对象；
然后，通过继承LifecycleObserver接口实现一个观察者，并调用Lifecycle对象的addObserver()方法进行注册监听，
当宿主生命周期发生变化时宿主内部就会通过Lifecycle的唯一实现类LifecycleRegister将生命周期事件分发给所有观察者；
最后，观察者与生命周期事件对应的方法将会被自动回调。

LifecycleOwner

LifecycleOwner是一个接口，它用于表明一个类是能够提供生命周期事件的宿主。Activity和Fragment均实现了LifecycleOwner，并重写了LifecycleOwner的getLifecycle()方法，该方法返回一个Lifecycle对象。当然，任何类均可以实现LifecycleOwner，表示该类是一个能够提供生命周期事件的宿主。自Android Support Library26后Activity(FragmentActivity)与Fragment默认实现了LifecycleOwner接口，androidx依赖库中的Activity与Fragment同样也实现了该接口。

LifecycleOwner源码如下

public interface LifecycleOwner {
    /**
     * Returns the Lifecycle of the provider.
     *
     * @return The lifecycle of the provider.
     */
    @NonNull
    Lifecycle getLifecycle();
}

Lifecycle

Lifecycle是一个抽象类，用于存储有关组件(或称宿主，比如Activity/Fragment)的生命周期状态的信息，并允许其他对象观察此状态。Lifecycle使用两种主要枚举跟踪其关联宿主的生命周期状态，即事件和状态，其中，事件为宿主的生命周期事件，而状态为Lifecycle对象跟踪的宿主的当前状态，不同的事件可能对应相同的状态。Lifecycle源码如下：

public abstract class Lifecycle {

    // 注册生命周期事件观察者
    // 所有的观察者为LifecycleObserver或其子类
    @MainThread
    public abstract void addObserver(@NonNull LifecycleObserver observer);
    
    // 移除生命周期事件观察者
    @MainThread
    public abstract void removeObserver(@NonNull LifecycleObserver observer);
    
    // 获取Lifecycle当前的状态
    @MainThread
    @NonNull
    public abstract State getCurrentState();
    
    // 宿主生命周期
    // 比如ON_CREATE即为生命周期onCreate
    public enum Event {
        ON_CREATE,
        ON_START,
        ON_RESUME,
        ON_PAUSE,
        ON_STOP,
        ON_DESTROY,
        ON_ANY
    }

    // 宿主的状态类型
    // 比如CREATED状态对应于宿主生命周期为onCreate/onStop
    @SuppressWarnings("WeakerAccess")
    public enum State {
        DESTROYED,
        INITIALIZED,
        CREATED,
        STARTED,
        RESUMED;
        
        public boolean isAtLeast(@NonNull State state) {
            return compareTo(state) >= 0;
        }
    }
}

LifecycleRegister

LifecycleRegister是Lifecycle的唯一实现类，主要用来负责注册Observer(观察者)，以及分发宿主状态事件给这些观察者。在Fragment、Activity中，通过Lifecycle的实现类——LifecycleRegistry，在Fragment不同的生命周期方法中调用handleLifecycleEvent方法，将Lifecycle中的event标记为对应生命周期状态。

LifecycleRegister维护着一个Map集合，该集合存储了已注册的观察者以及它们当前的状态，同时维护一个State对象表示当前宿主的状态，从LifecycleRegister的构造方法可以看出，宿主的初始状态为INITIALIZED。LifecycleRegister源码如下

public class LifecycleRegistry extends Lifecycle {

    // Observer列表
    // ObserverWithState包装了要注册的Observer及其当前状态
    private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =
        new FastSafeIterableMap<>();
    
    // 宿主当前状态
    private State mState
    
    public LifecycleRegistry(@NonNull LifecycleOwner provider) {
        mLifecycleOwner = new WeakReference<>(provider);
        // 初始状态INITIALIZED
        mState = INITIALIZED;
    }
    
    // 注册Observer
    @Override
    public void addObserver(@NonNull LifecycleObserver observer) {
        ...
    }
    
    // 移除Observer
    @Override
    public void removeObserver(@NonNull LifecycleObserver observer) {
        mObserverMap.remove(observer);
    }
    
    ...
}

LifecycleObserver

LifecycleObserver是一个接口，用于声明一个类为Lifecycle的观察者。LifecycleObserver是一个空的接口，通常我们使用注解或它的实现类，比如LifecycleEventObserver、DefaultLifecycleObserver等，来监听宿主lifecycle的变化。源码如下

// LifecycleObserver类
public interface LifecycleObserver {
}

// LifecycleEventObserver类
public interface LifecycleEventObserver extends LifecycleObserver {
    /**
     * 当宿主生命周期事件变化时，该方法被回调
     *
     * @param 宿主，即被观察的对象
     * @param event 生命周期事件
     */
    void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);
}

// DefaultLifecycleObserver类
// 当使用Java 8时，推荐使用它
public interface DefaultLifecycleObserver extends FullLifecycleObserver {

   /**
     * 当宿主的生命周期事件为ON_CREATE时
     * 该方法被回调
     *
     * @param owner 宿主，即被观察的对象
     */
    @Override
    default void onCreate(@NonNull LifecycleOwner owner) {
    }

    ...
}

2.2 Lifecycle状态模型

Lifecycle状态模型描述了宿主生命周期与宿主状态之间的关系，简单来说，就是指当宿主的生命周期变化时，它处于哪一种状态，总共有五种状态：INITIALIZED、CREATED、STARTED、RESUMED、DESTROYED，LifecycleRegistry在分发事件时依赖这两种之间的关系。宿主生命周期与宿主状态模型图如下

2.3 源码分析

2.3.1 Fragment实现Lifecycle原理

// androidx.fragment.app.Fragment
public class Fragment implements LifecycleOwner,.. 
{
    LifecycleRegistry mLifecycleRegistry;
    
    @Override
    @NonNull
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
    
    private void initLifecycle() {
        mLifecycleRegistry = new LifecycleRegistry(this);
        mSavedStateRegistryController = SavedStateRegistryController.create(this);
    }
    
    void performCreate(Bundle savedInstanceState) {
        // 设置Fragment当前状态为CREATED
        mState = CREATED;
        onCreate(savedInstanceState);
        ...
        // 分发Fragment的生命周期onCreate
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
    }
    
    void performActivityCreated(Bundle savedInstanceState) {
        // 设置Fragment当前状为ACTIVITY_CREATED
        // 没有分发生命周期
        mState = ACTIVITY_CREATED;
        ...
        onActivityCreated(savedInstanceState);
    }
    
    void performStart() {
        mState = STARTED;
        onStart();
        ...
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
    }
    
    void performResume() {
        mState = RESUMED;
        onResume();
        ...
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
    }
    
    void performPause() {
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
        mState = STARTED;
        ...
        onPause();
    }
    
    void performStop() {
        mState = ACTIVITY_CREATED;
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
        ...
        onStop();
    }
    
     void performDestroyView() {
        // 设置Fragment当前状为CREATED
        // 没有分发生命周期
        mState = CREATED;
        ...
        onDestroyView();
    }
    
    void performDestroy() {
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);
        mState = INITIALIZING;
        ...
        onDestroy();
    }
}

从Fragment源码可知，它通过继承于LifecycleOwner接口，表明自己是一个拥有生命周期变化的组件，并实现该接口的getLifecycle()方法，该方法返回一个Lifecycle对象，实际上返回的是Lifecycle的唯一子类LifecycleRegistry。当Fragment的生命周期状态变化时，Fragment会更新自己的状态State，并通过LifecycleRegistry向外界(所有观察者)分发对应的生命周期事件。

2.3.2 Activity实现Lifecycle原理

// AppcompatActivity父类
public class ComponentActivity implements LifecycleOwner...{
    private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
    
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mSavedStateRegistryController.performRestore(savedInstanceState);
        // 将ReportFragment添加到Activity中
        ReportFragment.injectIfNeededIn(this);
        if (mContentLayoutId != 0) {
            setContentView(mContentLayoutId);
        }
    }
    
    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
    
    ...
}

// ReportFragment
public class ReportFragment extends Fragment {

    public static void injectIfNeededIn(Activity activity) {
        android.app.FragmentManager manager = activity.getFragmentManager();
        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
            manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
            manager.executePendingTransactions();
        }
    }
    
    @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);
    }

    @Override
    public void onResume() {
        super.onResume();
        dispatchResume(mProcessListener);
        dispatch(Lifecycle.Event.ON_RESUME);
    }
    
    ...
    
    private void dispatch(Lifecycle.Event event) {
        Activity activity = getActivity();
        // 调用LifecycleRegistry的handleLifecycleEvent方法
        // 向外分发生命周期变化事件
        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);
            }
        }
    }
}

从上述源码可知，Activity实现Lifecycle需要借助于ReportFragment往Activity上添加一个 fragment 用以报告生命周期的变化。目的是为了兼顾不是继承自 AppCompactActivity的场景，同时也支持我们自定义LifecycleOwner的场景。

2.3.3 事件分发过程

Lifecycle事件分发时序图

在这里插入图片描述

从Fragment和Activity实现Lifecycle原理可知，当宿主的生命周期发生变化时，就会通过调用LifecycleRegistry的handleLifecycleEvent()方法向外分发生命周期变化事件

2.3.4 观察者注册过程

在这里插入图片描述

从上述时序图可知，Lifecycle的观察者注册是从调用LifecycleRegistry的addObserver()方法开始的，该方法首先会根据宿主当前的状态为新添加的观察者设定一个初始状态，只要不是在onDestory方法中注册，那么观察者的初始状态为INITIALIZED；然后将observer包装成ObserverWithState，并添加到mObserverMap集合中；最后就是一个while循环，即不断拿观察者的状态与宿主当前状态作比较以判断是否对齐，如果没有则向观察者分发对应的事件，同时更新观察者的状态，直到两者的状态一致

Air Field

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Jetpack:Lifecycle组件

1. Lifecycle简介Lifecycle是Android Jetpack框架提供的能够感知组件(宿主)生命周期变化的组件，它能持有宿主(如Activity或Fragment)生命周期状态的信息，并且允许其他观察者注册监听宿主的生命周期状态变化，这就使得我们不用主动去获取宿主的状态，有利于降低代码耦合度并更容易维护。Lifecycle是JetPack组件库的核心基础，很多其他的Jetpack组件，比如LiveData、ViewMoedel等，都是基于它实现的。1.1 Lifecycle基本使用
复制链接

扫一扫