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

• Android Jetpack 架构组件之 Lifecycle （一）起源
• Android Jetpack 架构组件之 Lifecycle （二）使用
• 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 想成是图中链接这些点的边。

也就是这一张图： 至于这张图的箭头和状态是怎么来的，能够在源码中（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)
    }
复制代码

答案是：能够。因此你们放心使用