Android Architecture Components Part3:Lifecycle

上期文章咱们讲解了LiveData，知道它是一个可观察容器同时具有生命感知能力。那么它的生命感知能力又是如何实现呢？在使用LiveData进行注册observer时，是否记得其中的两个参数。其一是Observer的回调，另外一个就是LifecycleOwner。它就属于Lifecycle中的一部分。

Activity/Fragment就是具备生命状态的组件，并且他们的生命状态都是由操做系统或者framework来控制的，因此咱们在App中是很难来经过代码来管理他们的生命周期。若是不遵循他们的生命周期，将会很容易致使内存泄露问题。因此若是咱们可以实现生命感知能力的话，将会帮助咱们更好的管理与生命周期有关的逻辑，而Lifecycle就是这样一个组件。

Lifecycle

Lifecycle能够为界面/非界面组件添加生命周期状态感知，容许观察者去监听这些生命状态。Lifecycle主要经过两个枚举来追踪生命状态。

1. Event：表明生命事件，是由framework层分发过来的，这些事件与Activity/Fragment中的生命回调相匹配。
2. State：表明当前追踪的组件所处的生命状态。

Event与State的联系咱们能够经过下面的图来进一步了解。

依赖

在使用Lifecycle以前，咱们须要在App或者Module的build.gradle中添加以下代码

dependencies {
    def lifecycle_version = "1.1.1"
 
    // ViewModel and LiveData
    implementation "android.arch.lifecycle:extensions:$lifecycle_version"   
    annotationProcessor "android.arch.lifecycle:compiler:$lifecycle_version"
}

LifecycleObserver

LifecycleObserver是一个接口，它没有任何方法，做为标志做用，同时经过注释来生成方法。咱们来看下它的使用方式，首先来自定义MyLifeCycleObserver

class MyLifeCycleObserver(private val lifecycle: Lifecycle) : LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun create() {
        if (lifecycle.currentState.isAtLeast(Lifecycle.State.CREATED)) {
           //todo ...
        }
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun start() {
        //todo ...
    }
}

这里须要在自定义的方法上使用@OnLifecycleEvent注释来标明这是一个与生命周期状态相关的方法回调；同时经过Lifecycle.Event，即Event枚举，来精肯定位到某一个生命周期的回调方法。

上面代码分别定位到了ON_CREATE与ON_START，即Activity/Fragment的onCreate()与onStart()方法。同时Lifecycle提供getCurrentState()方法，能够时刻查询当前的生命状态；而isAtLeast()方法则能够比较当前的生命状态是否大于等于某一个生命周期。经过这些方法可以更好的辅助咱们来管理界面的生命状态。

LifecycleOwner

如今自定义的观察者MyLifeCycleObserver已经有了，接下来要作的就是对观察者进行注册监听。

class ContactsActivity : AppCompatActivity() {
 
   override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_contacts_layout)
        lifecycle.addObserver(MyLifeCycleObserver(lifecycle))
    }
}

经过获取Lifecycle对象来添加观察者，将咱们上面自定义的MyLifeCycleObserver加入观察队列。而getLifecycle()是LifecycleOwner接口中惟一的方法。AppCompatActivity/Fragment默认实现了LifecycleOwner接口。内部经过LifecycleRegistry来注册了生命周期状态。

这样一旦界面的生命状态发生了改变，就会通知咱们自定义的观察者MyLifeCycleObserver，即回调MyLifeCycleObserver中所匹配的注释方法。

不知不觉中经过Lifecycle咱们已经将与生命状态相关的代码抽离到了MyLifeCycleObserver中，实现了对Activity/Fragemnt生命状态相关的解耦。

自定义LifecycleOwner

Activity/Fragment默认实现了LifecycleOwner接口，但必须是在Support Library 26.1.0以后才支持。因此若是咱们想要在它以前的版本使用，须要本身实现LifecycleOwner接口。

class LifecycleActivity : Activity(), LifecycleOwner {
    private lateinit var mMyLifecycle: LifecycleRegistry
 
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_contacts_layout)
        mMyLifecycle = LifecycleRegistry(this)
        mMyLifecycle.markState(Lifecycle.State.CREATED)
        lifecycle.addObserver(MyLifeCycleObserver(lifecycle))
    }
 
    override fun onStart() {
        super.onStart()
        mMyLifecycle.markState(Lifecycle.State.STARTED)
    }
 
    override fun getLifecycle(): Lifecycle = mMyLifecycle
}

首先让咱们的class实现LifecycleOwner接口，而后借助LifecycleRegistry来生成一个实现Lifecycle接口的对象。若是要让咱们添加的Observer可以与以前同样匹配生命周期方法，咱们还需为生成的Lifecycle在生命周期方法中添加标记状态。

如上代码，在onCreate()方法中使用makeState()来绑定Lifecycle.State.CREATED状态。如此，在Activity的onCreate调用的时候，咱们的MyLifeCycleObserver中的注释onCreate方法也会相应的回调。

因此结合LifecycleObserver、LifecycleOwner与LifecycleRegistry，咱们能够为任意非生命感知的组件实现生命感知能力，这样一来就能更好的帮助咱们对组件的生命周期进行管理。减小逻辑处理与没必要要的异常发生。

Lifecycle & LiveData

那么再回到文章最初所说的LiveData，咱们来分析LiveData是如何借助Lifecycle来实现生命感知能力。

在这以前，假设你已经对LiveData有必定的了解，或者你能够查看 Android Architecture Components Part2:LiveData进一步了解LiveData

首先咱们来看下LiveData的observer方法源码

@MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            // ignore
            return;
        }
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
        if (existing != null && !existing.isAttachedTo(owner)) {
            throw new IllegalArgumentException("Cannot add the same observer"
                    + " with different lifecycles");
        }
        if (existing != null) {
            return;
        }
        owner.getLifecycle().addObserver(wrapper);
    }

在上面代码中咱们看到了许多熟悉的代码，显而易见它也是经过自定义一个LifecycleBoundObserver，而后将其添加到Lifecycle的监听队列中。一旦生命周期发生变化就会回调LifecycleBoundObserver中的方法。而LifecycleBoundObserver实现了GenericLifecycleObserver接口。

public interface GenericLifecycleObserver extends LifecycleObserver {
    /**
     * Called when a state transition event happens.
     *
     * @param source The source of the event
     * @param event The event
     */
    void onStateChanged(LifecycleOwner source, Lifecycle.Event event);
}

在GenericLifecycleObserver咱们看到了熟悉的LifecycleObserver。本质与文章以前咱们本身自定义的MyLifeCycleObserver相同。不一样的是它提供了onStateChanged()方法。该方法就是Lifecycle观察到生命周期改变时通知Observer的回调方法。

Observer明白了，如今再来看下最初的Lifecycle究竟是什么？如今咱们知道的是它来自于Activity/Fragment，咱们到Activity中寻找(Fragment也是同样)。最后在继承的SupportActivity中找到了咱们所须要的。

public class SupportActivity extends Activity implements LifecycleOwner {

    private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
    ...
    ...
    ...
     
    @CallSuper
    @Override
    protected void onSaveInstanceState(Bundle outState) {
        mLifecycleRegistry.markState(Lifecycle.State.CREATED);
        super.onSaveInstanceState(outState);
    }
     
    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
 
   ...
   ...
}

咱们再一次看到了LifecycleRegistry与LifecycleOwner，它的用法也与上面说起的自定义LifecycleOwner一模一样，这里就很少作说明。咱们再来看下它与Observer的链接。

如上所示当Activity的onSaveInstanceState回调时会调用markState()方法，而在其方法调用内部，最终会来到ObserverWithState。

static class ObserverWithState {
        State mState;
        GenericLifecycleObserver mLifecycleObserver;
 
        ObserverWithState(LifecycleObserver observer, State initialState) {
            mLifecycleObserver = Lifecycling.getCallback(observer);
            mState = initialState;
        }
 
        void dispatchEvent(LifecycleOwner owner, Event event) {
            State newState = getStateAfter(event);
            mState = min(mState, newState);
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
        }
    }

经过dispatchEvent()的方法来调用mLifecycleObserver，仔细看这个Observer就是GenericLifecycleObserver，因此它会调用onStateChanged()方法。

到这里LifecycleObserver与LifecycleOwner就完美结合在一块儿了，为LiveData实现了生命状态的感知能力。经过LiveData与Lifecycle的运用，咱们看到了Lifecycle的灵活性与它的强大生命感知能力，这样咱们就能够为任意一个自定义组件或者其余的数据容器来实现生命感知能力。Lifecycle的强大毋庸置疑。

其次要说明的是LiveData与Lifecycle的运用不只如此，这只是它的注册监听，而咱们真正使用的是它的postValue()与setValue()。因为本篇文章主要是分析Lifecycle，因此这里就很少作分析。

文章中的代码均可以在 Github中获取到。使用时请将分支切换到feat_architecture_components

最后作个预告，接下来咱们要了解的是AAC中的ViewModel，相信你也会立刻喜欢上它。

相关文章

Android Architecture Components Part1:Room
Android Architecture Components Part2:LiveData
Android Architecture Components Part4:ViewModel

关注

私人博客