JetPack-Lifecycle 原理分析

本文是基于api30 的源码进行分析

Lifecycle 的作用

对activity和fragment的生命周期进行统一的管理和监听

使用场景

如果一个业务需要依赖生命周期的控制，你可以重写生命周期方法写到activity或者fragment中，但这样耦合太严重。业务多的话代码会很不优雅。耦合严重。比如mvp模式在页面destory时需要取消一些操作。
所以lifecycle的主要目的就是解耦

使用方法

lifecycle.addObserver(object : LifecycleEventObserver{
            override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
                when (event) {
                    Lifecycle.Event.ON_CREATE -> {}
                    Lifecycle.Event.ON_RESUME -> {}
                    Lifecycle.Event.ON_DESTROY -> {}
                }
            }
        })

源码解析

看源码就先从使用的地方入手吧。找到addObserver的调用地方。

-> LifecycleRegistry

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

        ...

        if (!isReentrance) {
            // we do sync only on the top level.
            sync();
        }
        mAddingObserverCounter--;
    }

这里做的主要的事情就是把观察者添加到一个Map中，以便后续统一处理。

这里注意到enforceMainThreadIfNeeded("addObserver")这个方法，这个就是默认要求添加必须在主线程里面，不然会抛异常。

既然已经有个Map那就找循环调用的地方，肯定会有触发的

-> 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()))) {
                pushParentState(observer.mState);
                final Event event = Event.upFrom(observer.mState);
                if (event == null) {
                    throw new IllegalStateException("no event up from " + observer.mState);
                }
                observer.dispatchEvent(lifecycleOwner, event);
                popParentState();
            }
        }
    }

这里我们看到了observer.dispatchEvent(lifecycleOwner, event);
点开看下

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

没错了，这个就是分配状态的方法了。
继续查看forwardPass方法的调用方法

-> sync() -> moveToState(State next) -> handleLifecycleEvent

继续查看handleLifecycleEvent的调用的话发现有

• Fragment
• FragmentActivity
• ReportFragment
  调用了。

由于framgnet 和 fragmentActivity中已经实现了lifecycle，会在生命周期方法里直接调用handleLifecycleEvent。所以这个方法会被调用多次，但是moveToState(State next)这个方法判断相同的状态的话就return了。所以相同状态不会多次分发。

既然 framgnet 和 fragmentActivity已经实现了对生命周期的分发了，那么ReportFragment有什么作用呢？看下它的源码。

调用handleLifecycleEvent的是dispatch方法

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

这里面就是针对不同的接口实现做了时间分发

调用的地方为LifecycleCallbacks 和 这个fragment的生命周期里面

因为在api29和之后activity才有registerActivityLifecycleCallbacks这个方法。所以在上面的injectIfNeededIn方法里面只有Build.VERSION.SDK_INT >= 29时才会注册。

这个ReportFragment的初始化的地方是在ComponentActivity里面。所以只要继承了ComponentActivity那就默认初始化了ReportFragment

ReportFragment 的作用难道是让没继承FragmentActivity，只继承了ComponentActivity的使用的吗？
或者说是让直接继承了Activity的使用的？
网上搜了一下，好像是Application的生命周期有关

在ReportFragment中 看到了

void setProcessListener(ActivityInitializationListener processListener) {
        mProcessListener = processListener;
    }

    interface ActivityInitializationListener {
        void onCreate();

        void onStart();

        void onResume();
    }

这里会通知application onStart、onCrtate、onResume

没有其他生命周期是因为application->activity 和 activity->application 方向不同

此文章知识简单介绍下原理和流程，这个介绍比较详细https://blog.kyleduo.com/2019/01/17/lifecycle-source-code/