Android Jetpack 架构组件之 Lifecycle (二) 使用

Lifecycle 使用

在 上篇文章 Lifecycle(一) 起源中已经通过一个例子让大家简单的认识到:

将依赖于生命周期的代码直接写在Activity 或 Fragment 会导致代码条理性很差并且会扩散错误。

通过Lifecycle可以将依赖组件的代码从生命周期方法移入组件本身中。
也就是说，组件内部可以感知到Activity 或者Fragment的生命周期

这篇文章具体展开说一下Lifecycle 的用法

预备知识

Lifecycle 中的事件和状态

Lifecycle 通过两个枚举类型：Event 和 State 来 对应 Android 视图组件的生命周期：

    // 事件
    public enum Event {
            ON_CREATE,
            ON_START,
            ON_RESUME,
            ON_PAUSE,
            ON_STOP,
            ON_DESTROY,
            ON_ANY
        }
    //状态
    /**
     * Lifecycle states. You can consider the states as the nodes in a graph and
     * {@link Event}s as the edges between these nodes.
     */
    public enum State {
        DESTROYED,
        INITIALIZED,
        CREATED,
        STARTED,
        RESUMED;

        public boolean isAtLeast(@NonNull State state) {
            return compareTo(state) >= 0;
        }
    }

官方注释告诉我们

你可以将 States 想成一张图中的点，将 Event 想成是图中连接这些点的边。

也就是这一张图：

image

至于这张图的箭头和状态是怎么来的，可以在源码中（LifecycleRegister）找到答案：

static State getStateAfter(Event event) {
        switch (event) {
            case ON_CREATE:
            case ON_STOP:
                return CREATED;
            case ON_START:
            case ON_PAUSE:
                return STARTED;
            case ON_RESUME:
                return RESUMED;
            case ON_DESTROY:
                return DESTROYED;
            case ON_ANY:
                break;
        }
        throw new IllegalArgumentException("Unexpected event value " + event);
    }

逻辑很清楚的可以对应到图中的状态与事件的转换，另外还有两个方法：downEvent(State state) upEvent(State state)也说明了上图中的关系，读者有兴趣的话可以自己查看源码

• 每一个 Event 映射到Activity或者Fragmnet的其中一个生命周期的回调
• 每一个 State 反应了由 Lifecycle 跟踪组件的当前状态

⚠️ 不要把Lifecycle想得很神奇，其实质就是简单的观察者模式，首先在视图控制器中注册观察者，Android源码会在生命周期变化后去分发对应生命周期的事件，由LifecycleRegister去调用自己实现的LifecycleEventObserver（上面通过注解方法实现的LifecycleObserve最终也会被解析成LifecycleEventObserver）中的onStateChanged方法。具体原理会在Lifecycle第三篇说到

LifecycleOwner

public interface LifecycleOwner {
    
    @NonNull
    Lifecycle getLifecycle();
}

单一方法的接口，顾名思义：可以将实现了这个接口的类理解为 具有Lifecycle的组件。可以很容易的想到Activity 和 Fragment 已经实现了这个接口:

public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        LifecycleOwner,
        ViewModelStoreOwner,
       ...

public class Fragment implements 
        LifecycleOwner,
        ViewModelStoreOwner
        ...

所以在使用Lifecycle时可以在Activity或Fragment中直接调用接口方法getLifecycle()

lifecycle.addObserver(NetStateManager)

添加观察者

除此之外，我们也可以通过实现LifecycleOwner来自定义，在Lifecycle系列文章的最后会实现一个自定义LifeOwner帮助大家更好理解

LifecycleObserver

使用Lifecycle的第一步就是要实现LifecycleObserver：

object ContentPlayer : LifecycleObserver{

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun prepare(context: Context) {
        //播放器的准备工作
    }
    
    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun unAttach() {
        //释放当前持有的Activity资源
    }
    
    //  开始播放
    fun Play(content: String) {
        ...
    }
    ...
}

通过方法注释，明确指定该方法被调用的时机。在上面的例子中，如果在Acitivity中添加ContentPlayer观察者，那么perpare()方法会在Activity创建时调用，unAttach()会在Activity销毁时调用。

实现LifecycleObserver不是只有这一种方法。已经提供了几种内置实现供我们选择：比如官方已经内置实现了LifecycleObserver的 LifecycleEventObservser

object ContentPlayer : LifecycleEventObserver {
    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
        when (event) {
            Lifecycle.Event.ON_CREATE -> TODO()
            Lifecycle.Event.ON_START -> TODO()
            Lifecycle.Event.ON_RESUME -> TODO()
            Lifecycle.Event.ON_PAUSE -> TODO()
            Lifecycle.Event.ON_STOP -> TODO()
            Lifecycle.Event.ON_DESTROY -> TODO()
            Lifecycle.Event.ON_ANY -> TODO()
        }
    }
}

每当视图控制器的状态发生改变，都会将事件回调给onStateChanged()，在不同的事件分支中实现自己想要实现的逻辑。

实际上在使用第一种使用注解的方法的情况下，在运行时LifecycleRegister这个类会通过反射或者apt来将LifecycleObserver转化成LifecycleEventObservser，所以有些情况下为了避免反射带来的消耗，可以优先考虑实现LifecycleEventObservser

添加观察者

最后只需要在Activity的onCreated方法完成最后一步：

override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        ...
        lifecycle.addObserver(ContentPlayer)
    }

最后需要考虑一种情况：如果在Observser中观察了ON_CREATE事件，而我们在Activity的onResume才注册观察者，还能收到发生在onResume()之前的ON_CREATE事件吗？

object Observer : LifecycleObserver{

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun onCreate(context: Context) {
        
        Log.d(TAG, "观察onCreate 事件")
        
    }
    
    @OnLifecycleEvent(Lifecycle.Event.ON_Start)
    fun onStart(context: Context) {
        
        Log.d(TAG, "观察onStart 事件")
        
    }
    
    ...
}

然后在Activity的onResume时才注册观察者

override fun onResume(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        ...
        lifecycle.addObserver(Observser)
    }

答案是：可以。所以大家放心使用

image