Jetpack Lifecycle源码分析

Android JetPack组件 专栏收录该内容
4 篇文章 0 订阅

jetpack系列之Lifecycle

jetpack系列之LiveData

jetpack系列之Databinding

jetpack系列之Workmanager

一、Lifecycle

Lifecycle是Jetpack中生命周期感知型组件,用于存储如Activity 或 Fragment的生命周期状态的信息,并允许其他对象观察此状态。

Lifecycle使用状态和事件两种枚举来跟踪其关联组件的生命周期状态。

二、基本使用 

使用Lifecycle观察整个Activity生命周期变化,只需通过Lifecycle类的addObserver方法将Lifecycle和观察器关联即可,每当 Activity 的生命周期方法被调用,DefaultLifecycleObserver接口的相应同名方法也会被触发。

class MainActivity : AppCompatActivity() {

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

        // 观察者与被观察者关联
        lifecycle.addObserver(MyObserver())
    }
    
    class MyObserver : DefaultLifecycleObserver {
        override fun onResume(owner: LifecycleOwner) {

        }

        override fun onPause(owner: LifecycleOwner) {

        }
    }

}

因为 26.1.0 及更高版本的AppCompatActivity父类中实现了LifecycleOwner接口,所以以上代码可以直接获取lifecycle。如果有自定义类想自己实现LifecycleOwner接口,可以使用LifecycleRegistry类。

class MainActivity : Activity(), LifecycleOwner {

    private lateinit var lifecycleRegistry: LifecycleRegistry

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

        lifecycleRegistry = LifecycleRegistry(this)
        lifecycleRegistry.currentState = Lifecycle.State.CREATED
    }

    public override fun onStart() {
        super.onStart()
        lifecycleRegistry.currentState = Lifecycle.State.STARTED
    }

    override fun getLifecycle(): Lifecycle {
        return lifecycleRegistry
    }

}

三、源码

Lifecycle类

Lifecycle是一个抽象类,实现类是LifecycleRegistry,内部包含三个抽象方法、事件和状态两个枚举类.

Even类:Lifecycle类分派的生命周期事件,这些事件映射到 Activity 和 Fragment 中的回调事件。比如Activity的onCreate方法映射为ON_CREATE事件。

State类:由Lifecycle跟踪的组件的当前生命周期状态。

public abstract class Lifecycle {

    @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
    AtomicReference<Object> mInternalScopeRef = new AtomicReference<>();

    @MainThread
    public abstract void addObserver(@NonNull LifecycleObserver observer);

    @MainThread
    public abstract void removeObserver(@NonNull LifecycleObserver observer);

    @MainThread
    public abstract State getCurrentState();

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

ReportFragment类

ReportFragment是一个无UI的Fragment,在AppCompatActivity继承的ComponentActivity的onCreate方法中被添加,ReportFragment的生命周期和绑定的Activity的生命周期完全对应,以下代码中每个生命周期方法都会执行dispatch方法,将对应事件传递出去,也就是处理Activiti的生命周期事件。

ReportFragment的dispatch方法会判断Activity是否实现了LifecycleOwner接口或LifecycleRegistryOwner(已被废弃),最后会调用LifecycleRegister的handleLifecycleEvent方法,并将Event传递到LifecycleRegistry类。

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

    @Override
    public void onPause() {
        super.onPause();
        dispatch(Lifecycle.Event.ON_PAUSE);
    }

    @Override
    public void onStop() {
        super.onStop();
        dispatch(Lifecycle.Event.ON_STOP);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        dispatch(Lifecycle.Event.ON_DESTROY);
        // just want to be sure that we won't leak reference to an activity
        mProcessListener = null;
    }

LifecycleRegistry类

LifecycleRegistry类是Lifecycle的实现类,实现了具体的事件回调和状态管理,addObserver方法接收到观察者(LifecycleObserver)后,通过ObserverWithState传给Lifecycling包装为LifecycleEventObserver对像,最后统一通过LifecycleEventObserver.onStateChanged分发,其中通过反射获取到LifecycleObserver的所有信息。

    @Override
    public void addObserver(@NonNull LifecycleObserver observer) {
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        ...
        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);
        }
        ...
    }
    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;
        }
    }

另一方面,LifecycleRegistry收到ReportFragment的Event后,会根据Event转换为对应的State,然后更新本地的 mState,如果状态不同会执行sync方法同步宿主和Lifecycle的生命周期。

    public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        State next = getStateAfter(event);
        moveToState(next);
    }

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

事件与状态转换以及生命周期同步如下图,借助官方提供的图更易理解。

从左往右的箭头为前进事件,从右往左为倒退事件,在sync方法中会比较枚举值的大小来决定执行前进或倒退,即forwardPass方法和backwardPass方法。

假设当前Lifecycle的mState为STATRTED状态,当ReportFragment传递过来的事件为ON_RESUME,这时事件前进mState就转变为RESUMED;当ReportFragment传递过来的事件为ON_STOP,这时事件倒退mState就转变为CREATED。

本地mState状态更新后,会调用ObserverWithState.dispatchEvent方法进行事件通知。

    private void sync() {
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        ...
        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);
            }
        }
    }

四、总结

1、26.1.0 及更高版本的AppCompatActivity和Fragment都实现了LifecycleOwner 接口,所以可以直接获取getLifecycle

2、ComponentActivity类onCreate方法中绑定了一个无 UI 的ReportFragment,ReportFragment生命周期与Activity完全一致,内部对29以上或以下的系统获取生命周期事件方式做了区分;

3、LifecycleRegistry 会将外部addObserver传进来的LifecycleObserver对象包装成 LifecycleEventObserver对象,通过调用 LifecycleEventObserver的onStateChanged方法来完成事件回调。

  • 0
    点赞
  • 0
    评论
  • 0
    收藏
  • 打赏
    打赏
  • 扫一扫,分享海报

©️2022 CSDN 皮肤主题:Age of Ai 设计师:meimeiellie 返回首页

打赏作者

永琪-

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值