Android架构组件---LifeCycle使用及源码解析

一、简介

在Android中很多组件都需要遵循生命周期变化来创建和释放资源，不当的代码可能会导致内存泄露。如果我们在Activity或Fragment中去管理生命周期，代码量很大时，会难以管理，所以Google提供了一个生命感知型组件Lifecycle来专门管理其他资源的创建和释放。

在使用Lifecycle组件，主要涉及到几个类。如下图所示：

上面的类分为三个部分：
（1）Lifecycle是一个抽象类，当一个类实现它时，代表这个类具有Android生命周期，Lifecycle中有两个枚举，分别是Event和State。LifecycleRegistry是它的实现类，它定义了如何改变生命周期组件的状态，如何处理以及向观察者（LifecycleObserver）分发生命周期事件。

（2）LifecycleOwner接口代表一个类拥有生命周期组件，即一个Lifecycle对象，它只有一个方法getLifecycle()，返回一个Lifecycle对象。在Android默认实现中，这个接口是由ComponentActivity来实现的，getLifecycle()返回一个LifecycleRegistry对象。

（3）LifecycleObserver接口代表一个需要响应生命周期的对象，它没有方法，使用OnLifecycleEvent来响应生命周期事件。通常我们的主要业务逻辑就写在这个接口的实现里面。

二、Lifecycle的使用

在build.gradle文件的dependencies中加入

implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.3.0"
kapt "androidx.lifecycle:lifecycle-compiler:2.3.0"

1.1 Lifecycle基本使用

由于Lifecycle和LifecycleOwner都有默认的实现，所以我们主要需要实现的是LifecycleObserver。分两步：

（1）实现LifecycleObserver

class TestObserver : LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun registerListener() {
        Log.d("======", "registerListener")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun initSomething() {
        Log.d("======", "initSomething")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun testStart() {
        Log.d("======", "testStart")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun setSomethingVisible() {
        Log.d("======", "setSomethingVisible")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun releaseSomething() {
        Log.d("======", "releaseSomething")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun unregisterListener() {
        Log.d("======", "unregisterListener")
    }
}

同一个事件可以注册多个方法。

（2）添加观察者

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

1.2 自定义Lifecycle

考虑到一些较老的代码或者因为其他原因而没有使用ComponentActivity时，可以自定义LifecycleOwner。

（1）继承Activity，实现LifecycleOwner

open class BaseActivity : Activity(), LifecycleOwner {
    private lateinit var registry: LifecycleRegistry

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

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

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

    override fun onResume() {
        super.onResume()
        registry.currentState = Lifecycle.State.RESUMED
    }

    override fun onDestroy() {
        super.onDestroy()
        registry.currentState = Lifecycle.State.DESTROYED
    }

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

（2） 实现LifecycleObserver

如1.1节一样。

（3）添加观察者

class CustomLifecycleActivity : BaseActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_custom_lifecycle)
        lifecycle.addObserver(TestObserver2())
    }
}

简单Demo下载

下面是枯燥的代码分析，没兴趣的不用看了。

三、Lifecycle原理简析

从代码中我们可以看到ComponentActivity实现了LifecycleOwner接口，在getLifecycle方法中返回LifecycleRegistry对象。

public Lifecycle getLifecycle() {
    return mLifecycleRegistry;
}

其中mLifecycleRegistry是一个LifecycleRegistry对象。
然后我们再看ComponentActivity中的onCreate方法。

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    ...
    ReportFragment.injectIfNeededIn(this);
    ...
}

在这里调用了ReportFragment的初始化方法，而ReportFragment就是Lifecycle和Activity生命周期关联起来的关键。

public static void injectIfNeededIn(Activity activity) {
        if (Build.VERSION.SDK_INT >= 29) {
            // On API 29+, we can register for the correct Lifecycle callbacks directly
            LifecycleCallbacks.registerIn(activity);
        }
        // Prior to API 29 and to maintain compatibility with older versions of
        // ProcessLifecycleOwner (which may not be updated when lifecycle-runtime is updated and
        // need to support activities that don't extend from FragmentActivity from support lib),
        // use a framework fragment to get the correct timing of Lifecycle events
        android.app.FragmentManager manager = activity.getFragmentManager();
        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
            manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
            // Hopefully, we are the first to make a transaction.
            manager.executePendingTransactions();
        }
    }

我们可以看到，在Activity中启动了一个Fragment，即ReportFragment。用它来响应Activity的生命周期。

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

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

然后我们再来看事件分发的方法dispatch。

private void dispatch(@NonNull Lifecycle.Event event) {
        if (Build.VERSION.SDK_INT < 29) {
            // Only dispatch events from ReportFragment on API levels prior
            // to API 29. On API 29+, this is handled by the ActivityLifecycleCallbacks
            // added in ReportFragment.injectIfNeededIn
            dispatch(getActivity(), event);
        }
    }

这里我们先不考虑API 29+的实现，这里我也没有深入地往下看。
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);
            }
        }
    }

在我们上面的例子中，使用的默认LifecycleOwner，所以在这个方法里面将会调用

((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);

继续看LifecycleRegistry.handleLifecycleEvent方法

    public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        enforceMainThreadIfNeeded("handleLifecycleEvent");
        moveToState(event.getTargetState());
    }

先获取当前Event的状态：

    @NonNull
    public State getTargetState() {
        switch (this) {
            case ON_CREATE:
            case ON_STOP:
                return State.CREATED;
            case ON_START:
            case ON_PAUSE:
                return State.STARTED;
            case ON_RESUME:
                return State.RESUMED;
            case ON_DESTROY:
                return State.DESTROYED;
            case ON_ANY:
                break;
        }
        throw new IllegalArgumentException(this + " has no target state");
    }

需要注意的是这里ON_CREATE和ON_STOP，ON_START和ON_PAUSE所返回的状态是一样的。
再往下看，是更新状态。

    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

private void sync() {
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        if (lifecycleOwner == null) {
            throw new IllegalStateException("LifecycleOwner 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);
            }
            Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
            if (!mNewEventOccurred && newest != null
                    && mState.compareTo(newest.getValue().mState) > 0) {
                forwardPass(lifecycleOwner);
            }
        }
        mNewEventOccurred = false;
    }

其中backwardPass(lifecycleOwner)和forwardPass(lifecycleOwner)两个方法查找对应的观察者，然后将事件分发出去。这里我就只贴一个方法的代码了。

    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);
                if (event == null) {
                    throw new IllegalStateException("no event down from " + observer.mState);
                }
                pushParentState(event.getTargetState());
                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;
        }

总结：Activity实现了LifecycleOwner接口，通过ReportFragment将Activity的生命周期与Lifecycle组件联系起来，然后通过LifecycleRegistry对象，将生命周期事件传递给注册的观察者。