一点点入坑JetPack：Lifecycle篇

时间 2019-11-17

标签一点点 jetpack lifecycle 繁體版

原文原文链接

前言 java

由于业务的缘由，本身也开始了JetPack之旅。不得不认可，用上以后：真香。 JetPack以官方的方案，解决了不少咱们头疼的问题。JetPack做为一整套的解决方案，不是一篇文章很够解释清楚的。正如官方所说：android

Android Jetpack 组件是库的集合，这些库是为协同工做而构建的，不过也能够单独采用，同时利用 Kotlin 语言功能帮助您提升工做效率。可所有使用，也可混合搭配！面试

因此这将是一个系列文章，一点点的展开我在JatPack应用中的所学所想。（目前公司项目已将全面用Kotlin，JetPack进行了重构，所以不少代码的设计会和咱们的业务相结合，因此仁者见仁智者见智啦~）app

一点点入坑JetPack：ViewModel篇框架

一点点入坑JetPack：Lifecycle篇ide

一点点入坑JetPack：LiveData篇post

一点点入坑JetPack：实战前戏NetworkBoundResource篇学习

一点点入坑JetPack（终章）：实战MVVMui

文章重点部分将聚焦：this

正文

不想看我瞎比比的，也能够直接跳转至官网：developer.android.google.cn/topic/libra…

一、如何管理生命周期

Lifecycle的出现帮咱们解决生命周期管理的问题。这一块对于咱们平常开发来讲的确是比较坑的一点，生命周期处理不当，很容易形成内存泄漏。为了能让咱们业务代码可以感知到生命周期，咱们可能会写大量的代码。好比在让Presenter拥有感知生命周期的能力，咱们可能会这么作：

public interface IPresenter {
    void onCreate();

    void onStart();

    void onResume();

    void onPause();

    void onStop();

    void onDestroy();
}
复制代码

而后实现接口，在Activity/Fragment的生命周期中调用这个接口，完成工做。

这种方式彻底ojbk。通俗易懂，这里我不评价它的好坏，毕竟没有任何一种解决方案是完美的。因此接下来我们来看一看官方的Lifecycle是怎样的一种思路。

二、Lifecycle

说破天，这里须要解决的问题是生命周期管理。那么终究仍是逃脱不掉一些套路成分在其中。Lifecycle也是如此，从官方的解释中，可见一斑：

Lifecycle is a class that holds the information about the lifecycle state of a component (like an activity or a fragment) and allows other objects to observe this state.

短短一段话，咱们能够猜想到这里经过观察者模式的思路去对外响应生命周期变化。闲话少说，直接从代码感觉一下。

2.一、使用

从使用上来讲，仍是比较简单的。实现LifecycleObserver接口：

// 官方demo
class MyObserver : LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun connectListener() {
        // TODO
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun disconnectListener() {
        // TODO
    }
}

复制代码

这俩个注解则标志着，当监听组件的onResume()方法被调用，这里咱们被注解的方法也会被调用。（固然前提是addObserver了）

有了观察者了，那咱们就去找被观察者。很明显，咱们想要观察的对象是拥有生命周期的家伙，好比咱们经常使用的Activity/Fragment。此时咱们只须要在onResume()以前的某个实际，把这个Observer，add进去便可，好比在onCreate()中：

override fun onCreate(savedInstanceState: Bundle?) {
   lifecycle.addObserver(MyObserver())
}
复制代码

OK，这样以后咱们的MyObserver既能够正常在响应对应生命周期注解下的方法了。

不过，我相信这样写的朋友，回过来喷我！根本就调不到lifecycle！！

没错，咱们常规的Activitiy/Fragment就是调不到...它压根就没这这个方法。

2.二、androidx

这里解释一下，上文中lifecyle其实就是调用Activity/Fragment中的这个方法：

@Override
public Lifecycle getLifecycle() {
    return mLifecycleRegistry;
}
复制代码

有朋友应该提着刀过来了，我tm没有这个方法！兄die，把刀放下，不是没有是import不同。接下来让咱们慢慢来。我使用的这个Fragment的package是这样的：androidx.fragment.app;。看到端倪了吧？androidx，没错，这是为了完美支持JatPack所从新规划出来的包。

固然，也不必定非要用androidx。

Fragments and Activities in Support Library 26.1.0 and later already implement the LifecycleOwner interface.

因此，升库就ok了。这时有小伙伴可能会说了：我不想升库怎么办。这个问题问得好，不想升库，不想升库..就不升呗。

固然我相信，必定有小伙伴注意到一个问题，那就是getLifecycle()是一个接口，那么也就是说咱们能够本身实现？没错是这样...(这tm不废话么)

这就是咱们自定义的关键。

2.三、LifecycleOwner

假设咱们的Activity不支持getLifecycle()咋整？这里直接上官方的代码：

class MyActivity : Activity(), LifecycleOwner {
    private lateinit var mLifecycleRegistry: LifecycleRegistry

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

        mLifecycleRegistry = LifecycleRegistry(this)
        mLifecycleRegistry.markState(Lifecycle.State.CREATED)
        
        mLifecycleRegistry.addObserver(MyObserver())
    }

    public override fun onStart() {
        super.onStart()
        mLifecycleRegistry.markState(Lifecycle.State.STARTED)
    }

    override fun getLifecycle(): Lifecycle {
        return mLifecycleRegistry
    }
}
复制代码

就这样，结束了。说实话，到这就这的没有什么好讲的了。

经过代码，咱们能够看出来，LifecycleRegistry是咱们的被观察者，它被初始化在拥有生命周期的Activity中，而咱们的Observer也被add()到其中，此外还有诸如markState(Lifecycle.State.CREATED)的方法调用。

所以，到这无需多言，各位小伙伴恐怕已经明白了Lifecycle是如何帮咱们管理生命周期的了。

2.四、小总结

这几段代码下来，我相信有的朋友已经差很少了解Lifecycle的思路了。一个很标准的观察者模式：这里的LifecycleRegistry（系统帮咱们实现的Lifecycle的实现类），持有想要监听这个LifecycleOwner的Observer。而后经过markState()，去遍历全部Observer，通知其生命周期发生变化。

三、原理

聊完了普通用法，我们来看一下原理。不得不说，Lifecycle实现的原理仍是比较骚的，各类骚操做简直是乱花渐欲迷人眼。

我们在上述的MyObserver中加了注解，因此先看看注解为咱们带来了什么。经过注解生成器，咱们能够看到在build中获得了下边这个class：

public class MyObserver_LifecycleAdapter implements GenericLifecycleObserver {
    final MyObserver mReceiver;

    LifecycleObserverDemo_LifecycleAdapter(MyObserver receiver) {
        this.mReceiver = receiver;
    }

    @Override
    public void onStateChanged(LifecycleOwner owner, Lifecycle.Event event) {
        mReceiver.onAny(owner,event);
        if (event == Lifecycle.Event.ON_RESUME) {
            mReceiver.connectListener();
        }

        if (event == Lifecycle.Event.ON_PAUSE) {
            mReceiver.disconnectListener();
        }
    }

    public Object getReceiver() {
        return mReceiver;
    }
}
复制代码

很清晰，咱们可以看到，在onStateChanged(LifecycleOwner owner, Lifecycle.Event event)中经过对应的Event就能够调用到咱们MyObserver中注解的方法。

那么问题来了：onStateChanged被谁调用的呢？经过上边的例子，咱们知道想要Observer可以感应生命周期要么使用内置好的Lifecycle（getLifecycle()），要么本身去实现（LifecycleOwner）。接下来我们就分这俩种状况来看一看具体的实现原理。

3.一、自定义LifecycleOwner

这一步的源码仍是比较的简单直接的，咱们能够直接在LifecycleRegistry中的markState(Lifecycle.State.STARTED)一探究竟，一层层的调用下来，咱们抛弃一些逻辑判断以后，能够看到一些关键的内容：

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;
    }
}
复制代码

能够看到，这部分会很直白的调用到注解生成class中的onStateChanged()，完成生命周期的感知。

3.二、getLifecycle()

getLifecycle()的方式，一样是返回了一个LifecycleRegistry。所以，最开始我认为系统所以在对应的生命周期完成对上3.1同样的调用。不过看把发现本身仍是太年轻。

在SupportActivity中，的onCreate方法中，咱们能够看到这样的调用：

protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    ReportFragment.injectIfNeededIn(this);
}
复制代码

是否是感受到一丝丝熟悉？使用Fragment作生命周期分离管理在不少框架中都出现。接下来咱们就好好看看这个ReportFragment。

@Override
public void onResume() {
    super.onResume();
    dispatchResume(mProcessListener);
    dispatch(Lifecycle.Event.ON_RESUME);
}

private void dispatch(Lifecycle.Event event) {
    Activity activity = getActivity();
    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);
        }
    }
}
复制代码

到此就从新回调到了LifecycleRegistry中的方法了。

尾声

固然仅凭这些，对于咱们来讲还远远不够，所以Google还拿出了ViewModel、LiveData等相辅相成的有趣模块。下边的文章将走进：ViewModel篇。

许久没有写文章了，一来是最近的确很忙；二来本身也刚开始搞JetPack这一套。学的过程当中渐渐发现JatPack属实比较有意思。因此决定好好的把JetPack研究一翻。

这篇文章就算是本身回归写文章的先导篇吧~