Jetpack —— Lifecycle 处理 Activity/Fragment 的生命周期

Activity 的生命周期就不多说了，从生到死 6 个方法贯穿全程，我们经常在特定的方法执行一些特定的任务，例如在获取到焦点之后才开始动画，在 onDestroy 中释放资源等等。

例如使用 MVP 模式：

class MyPresenter{
    public MyPresenter() {
    }

    void create() {
        //do something
    }

    void destroy() {
        //do something
    }
}

class MainActivity extends Activity {
    private MyPresenter presenter;

    public void onCreate(...) {
        presenter= new MyPresenter ();
        presenter.create();
    }

    public void onDestroy() {
        super.onDestroy();
        presenter.destory();
    }
}

假如说页面的业务逻辑很多，那么在生命周期的每个方法就会变得很臃肿。

Android 退出了 Lifecycles 组件来帮助我们管理 Activity 和 Fragment 的生命周期。

其实这个 Lifecycle 很简单，只需要理解下面几个概念：

• 观察者（Observer）：用来观察 Activity 或者 Fragment 的生命周期

• 持有者（Owner）：Activity 或者 Fragment 生命周期的持有者

• 登记处（Registry）：用于在持有者中登记观察者

• 事件（Event）：对应生命周期中的每个方法，有以下几种：

  • ON_CREATE
  • ON_START
  • ON_RESUME
  • ON_PAUSE
  • ON_STOP
  • ON_DESTROY
  • ON_ANY

  没啥好解释的，看名字就知道了，ON_ANY 对应每一个方法

• 状态（State）：对应 Activity 或者 Fragment 的状态，有以下几种：

  • DESTROYED
  • INITIALIZED
  • CREATED
  • STARTED
  • RESUMED

  状态也没啥好解释的，对应 Activity 和 Fragment 的几种状态嘛

事件和状态的关系如下图：

使用起来也很简单：

第一步，添加依赖

dependencies {
    def lifecycle_version = "2.0.0"

    // ViewModel and LiveData
    implementation "androidx.lifecycle:lifecycle-extensions:$lifecycle_version"
    // alternatively - just ViewModel
    implementation "androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version" // For Kotlin use lifecycle-viewmodel-ktx
    // alternatively - just LiveData
    implementation "androidx.lifecycle:lifecycle-livedata:$lifecycle_version"
    // alternatively - Lifecycles only (no ViewModel or LiveData). Some UI
    //     AndroidX libraries use this lightweight import for Lifecycle
    implementation "androidx.lifecycle:lifecycle-runtime:$lifecycle_version"
    // For Kotlin use kapt instead of annotationProcessor
    annotationProcessor "androidx.lifecycle:lifecycle-compiler:$lifecycle_version" 
    // alternately - if using Java8, use the following instead of lifecycle-compiler
    implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"

    // optional - ReactiveStreams support for LiveData
    implementation "androidx.lifecycle:lifecycle-reactivestreams:$lifecycle_version" // For Kotlin use lifecycle-reactivestreams-ktx

    // optional - Test helpers for LiveData
    testImplementation "androidx.arch.core:core-testing:$lifecycle_version"
}

第二步，创建 Observer

实现 LifecycleObserver 接口，然后在相应的方法上添加注解 @OnLifecycleEvent(Lifecycle.Event.XXX) 即可，XXX 就是上面七种事件。

public class ActivityObserver implements LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void onCreateObserver() {
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void onStartObserver() {
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void onResumeObserver() {
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void onPauseObserver() {
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void onStopObserver() {
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void onDestroyObserver() {
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    public void any() {
    }
}

上面的代码仅仅是 JDK 7 的时候创建 Observer 的方法，对于 JDK 8 的时候，需要这样声明：

public class ActivityObserver implements DefaultLifecycleObserver {

    @Override
    public void onCreate(@NonNull LifecycleOwner owner) {
    }

    @Override
    public void onStart(@NonNull LifecycleOwner owner) {
    }

    @Override
    public void onResume(@NonNull LifecycleOwner owner) {

    }

    @Override
    public void onPause(@NonNull LifecycleOwner owner) {
    }

    @Override
    public void onStop(@NonNull LifecycleOwner owner) {
    }

    @Override
    public void onDestroy(@NonNull LifecycleOwner owner) {
    }
}

第三部，创建 Owner

Owner 也就是我们的 Activity 或者 Fragment，实现 LifecycleOwner 接口即可，需要注意的是，AppCompatActivity 和 Fragment 已经实现了 LifecycleOwner 接口，无须开发者手动实现，普通 Activity 则需要我们手动实现：

public class LifeCyclesActivity extends Activity implements LifecycleOwner {
    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return registry;
    }
}

第四步，创建 Registry，并在 getLifecycle 方法中返回

getLifecycle 方法是 LifecycleOwner 接口中的方法，如果是 Fragment 或者是 AppCompatActivity ，则第三步可以省略

public class LifeCyclesActivity extends Activity implements LifecycleOwner {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_lifecycle);
        registry = new LifecycleRegistry(this);
    }

    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return registry;
    }
}

第五步，注册 Observer

getLifecycle().addObserver(new ActivityObserver());

这样就搞定了，当 Activity 或者 Fragment 执行到相应的方法时，都会执行 Observer 中对应的方法。

那么对于状态是如何监控的呢？

只需要在生命周期的方法中执行 registry.markState(Lifecycle.State.XXX); 即可标记组件当前状态，调用 Lifecycle 对象的 getCurrentState() 方法可以获取组件的当前状态，以便做相应的操作（我感觉这个功能没多大用，不过也有可能是我还没用到这个功能...）

需要注意的是，像 Activity 的 onRestart()，Fragment 的 onCreateView() 等等其他生命周期是无法感知的。

还需要注意的是，当 Activity 的 onSaveInstanceState 方法执行时，会触发 ON_STOP 事件

---

了解更多可以看这里：

• Android lifecycle-aware components codelab
• Android-Lifecycle超能解析-生命周期的那些事儿