如何使用

DefaultLifecycleObserver

注意：需要添加依赖才能生效，androidx.lifecycle:lifecycle-common-java8:xxx

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

        lifecycle.addObserver(DemoLifecycleObserver())
    }
}

class DemoLifecycleObserver : DefaultLifecycleObserver {

    override fun onCreate(owner: LifecycleOwner) {
        super.onCreate(owner)
        Log.d("xll", "onCreate: ")
    }
}

注解

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

        lifecycle.addObserver(DemoLifecycleObserver())
    }
}

class DemoLifecycleObserver : LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun onStart(){
        Log.d("xll", "onCreate: ")
    }
}

自定义

class MainActivity : AppCompatActivity() {

    private lateinit var mLifecycleRegistry: LifecycleRegistry

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_login)
        
        mLifecycleRegistry = LifecycleRegistry(this)
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE)

        lifecycle.addObserver(DemoLifecycleObserver())
    }

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

class DemoLifecycleObserver : xxx

源码分析

Event、State

Event： Lifecycle 发送对应的生命周期事件的枚举类，包含 onCreate、onStart 等生命周期事件
State： Lifecycle 处理的生命周期状态，与 Event 是映射关系

实现原理

拥有生命周期的组件有 Activity、Fragment，这里说一下 ComponentActivity，它的子类是 FragmentActivity，FragmentActivity 的子类是 MainActivity

LifecycleOwner 接口：拥有生命周期的组件实现，只有一个 getLifecycle 接口，用于获取 Lifecycle 对象
LifecycleObserver 接口：观察生命周期的接口，一般是开发者实现，它有两个子类：
- FullLifecycleObserver：回调具体的生命周期，例如：onCreate
- LifecycleEventObserver：回调具体的生命周期触发事件：Lifecycle.Event
Lifecycle 接口：定义一个类具有 Android 的生命周期
- getCurrentState：获取当前宿主的 State
- addObserver/removeObserver：添加、移除 LifecycleObserver
LifecycleRegistry 类：Lifecycle 接口实现者

Lifecycle

addObserver

public void addObserver(LifecycleObserver observer) {
    //...
    State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
    ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
    ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);

    //....
    boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
    State targetState = calculateTargetState(observer);
    mAddingObserverCounter++;
    while ((statefulObserver.mState.compareTo(targetState) < 0
            && mObserverMap.contains(observer))) {
        //...
        final Event event = Event.upFrom(statefulObserver.mState);
        //...
        statefulObserver.dispatchEvent(lifecycleOwner, event);
        //...
        targetState = calculateTargetState(observer);
    }

    if (!isReentrance) {
        sync();
    }
    //...
}

确定初始的 State，然后使用 ObserverWithState 将 LifecycleObserver 和 State 绑定
- 这里会调用 Lifecycling#lifecycleEventObserver 方法对 LifecycleObserver 做一层封装便于回调，最终会返回 LifecycleEventObserver 对象。
根据当前宿主的 State 等信息，然后给 LifecycleObserver 分发对应的 Lifecycle.Event，使得 LifecycleObserver 对应的生命周期可以回调到
- 这里存在嵌套事件，详情参考：Android架构组件(2)LifecycleRegistry 源码分析_安静的奥里维的博客-CSDN博客
如果当前存在其他的 LifecycleObserver，且正在发生事件回调，就会调用 sync 同步一下事件

sync

private void sync() {
    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
    //...
    while (!isSynced()) {
        mNewEventOccurred = false;
        // 
        if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
            backwardPass(lifecycleOwner);
        }
        Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
        if (!mNewEventOccurred && newest != null
                && mState.compareTo(newest.getValue().mState) > 0) {
            forwardPass(lifecycleOwner);
        }
    }
    mNewEventOccurred = false;
}

如果是生命周期往后走，就会调用 backwardPass 处理
如果是生命周期往前走，就会调用 forwardPass 处理

不管是 backwardPass 还是 forwardPass，最终通过 ObserverWithState#dispatchEvent 方法分发，它通过调用 LifecycleEventObserver#onStateChanged 方法分发

backwardPass

private void backwardPass(LifecycleOwner lifecycleOwner) {
    Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
            mObserverMap.descendingIterator();
    while (descendingIterator.hasNext() && !mNewEventOccurred) {
        Map.Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
        ObserverWithState observer = entry.getValue();
        while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
                && mObserverMap.contains(entry.getKey()))) {
            Event event = Event.downFrom(observer.mState);
            //...
            observer.dispatchEvent(lifecycleOwner, event);
            //...
        }
    }
}

forwardPass

private void forwardPass(LifecycleOwner lifecycleOwner) {
    Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
            mObserverMap.iteratorWithAdditions();
    while (ascendingIterator.hasNext() && !mNewEventOccurred) {
        Map.Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
        ObserverWithState observer = entry.getValue();
        while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
                && mObserverMap.contains(entry.getKey()))) {
            //...
            final Event event = Event.upFrom(observer.mState);
            //...
            observer.dispatchEvent(lifecycleOwner, event);
            //...
        }
    }
}

ReportFragment

injectIfNeededIn

ComponentActivity 对于生命周期的回调交给了 ReportFragment，ComponentActivity 在 onCreate 的时候会调用 ReportFragment#injectIfNeededIn 方法：

如果是 29 以上 Android SDK，使用 ActivityLifecycleCallbacks 接口
如果是 29 以下 Android SDK，会通过添加一个 Fragment 的方式感知

public static void injectIfNeededIn(Activity activity) {
    if (Build.VERSION.SDK_INT >= 29) {
        LifecycleCallbacks.registerIn(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();
    }
}

registerIn

static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {

    static void registerIn(Activity activity) {
        activity.registerActivityLifecycleCallbacks(new LifecycleCallbacks());
    }
    
    //...
    
    @Override
    public void onActivityPostCreated(Activity activity, Bundle savedInstanceState) {
        dispatch(activity, Lifecycle.Event.ON_CREATE);
    }

    //...
}

不管是 ActivityLifecycleCallbacks 生命周期回调了，还是添加的 ReportFragment 生命周期回调了，都会调用 dispatch 分发事件

dispatch

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

public void handleLifecycleEvent(Lifecycle.Event event) {
    //...
    moveToState(event.getTargetState());
}

private void moveToState(State next) {
    //...
    mState = next;
    //...
    mHandlingEvent = true;
    sync();
    mHandlingEvent = false;
}