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 事件


了解更多可以看这里: