Jetpack成员表之Lifecycle应用及源码解析

Jetpack里面的内容还是相当丰富了，有兴趣的可以去官网了解一番。

Jetpack成员图.jpeg

这里讲到的是 Lifecycle，中文意思就是生命周期。如果说你想让某一个类能够观察
Activity 或 Fragment 的生命周期，那 Lifecycle 可以很轻松的帮你实现。有用过 MVP模式的话，你应该经常需要 Presenter 感知 View（Activity/Frament 统称 View） 的生命周期，以便处理业务逻辑。当你没接触 Lifecycle 的时候，获取会通过接口的方式通知 Presenter，例如以下代码：
1.定义一个接口：

public interface ILifecycleView {
    void onCreate();

    void onStart();

    void onPause();

    void onResume();

    void onDestroy();
}

2.Presenter 代码块：

public class MainPresenter implements ILifecycleView {

    private static final String TAG = "MainPresenter";

    @Override
    public void onCreate() {
        Log.d(TAG, "onCreate");
    }

    @Override
    public void onStart() {
        Log.d(TAG, "onStart");
    }

    @Override
    public void onPause() {
        Log.d(TAG, "onPause");
    }

    @Override
    public void onResume() {
        Log.d(TAG, "onResume");
    }

    @Override
    public void onDestroy() {
        Log.d(TAG, "onDestroy");
    }
}

3.View 代码块：

public class MainActivity extends AppCompatActivity {

    private MainPresenter mainPresenter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mainPresenter = new MainPresenter();
        mainPresenter.onCreate();
    }

    @Override
    protected void onStart() {
        super.onStart();
        mainPresenter.onStart();
    }

    @Override
    protected void onPause() {
        super.onPause();
        mainPresenter.onPause();
    }

    @Override
    protected void onResume() {
        super.onResume();
        mainPresenter.onResume();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mainPresenter.onDestroy();
    }
}

这样 Presenter 也能轻监听到View的生命周期，其实这并不是那么轻松，当 Presenter 有很多的时候你就会有感觉了，所以 Lifecycle 就能派上用场了。还是看代码

1.Lifrcycle简单应用

public class MainPresenter implements DefaultLifecycleObserver {

    private final static String TAG = "MainPresenter";

    @Override
    public void onCreate(@NonNull LifecycleOwner owner) {
        Log.d(TAG, "onCreate");
    }

    @Override
    public void onStart(@NonNull LifecycleOwner owner) {
        Log.d(TAG, "onStart");
    }

    @Override
    public void onPause(@NonNull LifecycleOwner owner) {
        Log.d(TAG, "onPause");
    }

    @Override
    public void onResume(@NonNull LifecycleOwner owner) {
        Log.d(TAG, "onResume");
    }

    @Override
    public void onStop(@NonNull LifecycleOwner owner) {
        Log.d(TAG, "onStop");
    }

    @Override
    public void onDestroy(@NonNull LifecycleOwner owner) {
        Log.d(TAG, "onDestroy");
    }
}

public class MainActivity extends AppCompatActivity {

    private MainPresenter mainPresenter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mainPresenter = new MainPresenter();
        getLifecycle().addObserver(mainPresenter);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        getLifecycle().removeObserver(mainPresenter);
    }
}

运行结果GIF：

20190818_174058.gif

让 Presenter 具有感知生命周期的能力变得更加简单了，只需要两步：

1.Presenter 实现 DefaultLifecycleObserver（DefaultLifecycleObserver 是 LifecycleObserver 的一个实现接口，稍后会讲解到）
2.在 Activity 中调用 getLifecycle().addObserver(mainPresenter) 将 mainPresenter 传到 Lifecycle 中。

总体来说比前面的方式简单不少，说了这么多，操作起来是方便，但是不懂的人会就会有疑惑，为啥这么写就能让 Presenter 感知View的生命周期呢？看看源码就能解开当中的疑惑了。

2.Lifecycle 源码分析

Lifecycle 内部实现原理就是观察者模式，上面的例子 MainPresenter 就是一个观察者，Lifecycle 或者说 View 是被观察者。所以你会看到 MainPresenter 实现了 DefaultLifecycleObserver，该类是 LifecycleObserver 的实现类。

/**
 * Callback interface for listening to {@link LifecycleOwner} state changes.
 * <p>
 * If you use Java 8 language, <b>always</b> prefer it over annotations.
 */
@SuppressWarnings("unused")
public interface DefaultLifecycleObserver extends FullLifecycleObserver {

    /**
     * Notifies that {@code ON_CREATE} event occurred.
     * <p>
     * This method will be called after the {@link LifecycleOwner}'s {@code onCreate}
     * method returns.
     *
     * @param owner the component, whose state was changed
     */
    @Override
    default void onCreate(@NonNull LifecycleOwner owner) {
    }

    /**
     * Notifies that {@code ON_START} event occurred.
     * <p>
     * This method will be called after the {@link LifecycleOwner}'s {@code onStart} method returns.
     *
     * @param owner the component, whose state was changed
     */
    @Override
    default void onStart(@NonNull LifecycleOwner owner) {
    }
//省略部分源码
}

interface FullLifecycleObserver extends LifecycleObserver {

    void onCreate(LifecycleOwner owner);

    void onStart(LifecycleOwner owner);

    void onResume(LifecycleOwner owner);

    void onPause(LifecycleOwner owner);

    void onStop(LifecycleOwner owner);

    void onDestroy(LifecycleOwner owner);
}

/**
 * Marks a class as a LifecycleObserver. It does not have any methods, instead, relies on
 * {@link OnLifecycleEvent} annotated methods.
 * <p>
 * @see Lifecycle Lifecycle - for samples and usage patterns.
 */
@SuppressWarnings("WeakerAccess")
public interface LifecycleObserver {

}

从源码可以看出 DefaultLifecycleObserver 只是一个很简单的接口类，每个方法的参数都是 LifecycleOwner ，而这个 LifecycleOwner 的源码也很简单 里面只有一个方法用于提供 Lifecycle。

/**
 * A class that has an Android lifecycle. These events can be used by custom components to
 * handle lifecycle changes without implementing any code inside the Activity or the Fragment.
 *
 * @see Lifecycle
 */
@SuppressWarnings({"WeakerAccess", "unused"})
public interface LifecycleOwner {
    /**
     * Returns the Lifecycle of the provider.
     *
     * @return The lifecycle of the provider.
     */
    @NonNull
    Lifecycle getLifecycle();
}

接着看 MainActivity 的 getLifecycle().addObserver(mainPresenter) 这行代码，
getLifecycle() 提供一个 LifecycleRegistry ，具体源码就不贴出来了，这个比较简单。看看 LifecycleRegistry 源码：

/**
 * An implementation of {@link Lifecycle} that can handle multiple observers.
 * <p>
 * It is used by Fragments and Support Library Activities. You can also directly use it if you have
 * a custom LifecycleOwner.
 */
public class LifecycleRegistry extends Lifecycle {

LifecycleRegistry 是 Lifecycle 的实现类，在看看 Lifecycle 源码：

public abstract class Lifecycle {

Lifecycle 是一个抽象类，包含 了两个主要的抽象方法方法

  @MainThread
    public abstract void addObserver(@NonNull LifecycleObserver observer);

 @MainThread
    public abstract void removeObserver(@NonNull LifecycleObserver observer);

这两个就是前面用到的两个方法，添加观察者与移除观察者（防止内存泄漏）。
看看 LifecycleRegistry 对 addObserver（） 的实现逻辑

1.png

162行可以看到通过 LifecycleObserver 和 State 生成了一个 ObserverWithState， LifecycleObserver 就是我们的MainPresenter，而 State 是 Lifecycle 里面的枚举

image.png

State 代表当前 View 的生命周期状态， ObserverWithState 是 LifecycleRegistry 的一个静态内部类

image.png

从源码可以看出 View 的生命周期就是通过这个内部类的 dispatchEvent(LifecycleOwner owner, Event event) 方法来通知观察者。整个回调流程如下截图：

image.png
image.png
image.png
image.png

然后到了 ReportFragment 这里

image.png
每个生命周期的函数都会调用 dispatch（）方法。
最后终于到了 SupportActivity 了，看截图
image.png

是在这里将 SupportActivity 注入到了 ReportFragment 里。整个通知回调就是这样子了。稍微细心一点你会发现 LifecycleRegistry 是在 SupportActivity 的28行创建的，也就是说如果我们的 MainActivity 是继承 Activity 而不是它的子类的话，是找不到getLifecycle() 这个方法的。