Lifecycle Activity和Fragment生命周期感知组件 LifecycleObserver

2022-11-23 23:01:32 michael007js 521

为什么要引进 Lifecycle

我们在处理Activity或者Fragment组件的生命周期相关时，不可避免会遇到这样的问题：

我们在Activity的onCreate()中初始化某些成员，比如MVP架构中的Presenter，或者AudioManager、MediaPlayer等，然后在onStop中对这些成员进行对应处理，并在onDestroy中释放这些资源。

这是很常见的情形，按照通常的做法，我们需要在Activity或者Fragment中的每个生命周期方法中都要调用一次IPresenter等成员中定义的相应的方法。我们可能觉得这没什么，但是其实这些完全就是模板代码，其本身往往没有任何意义，这不仅浪费我们的时间，更让我们的代码臃肿了很多，于是Lifecycle组件就诞生了。

以下内容是对官方文档的翻译：

生命周期感知组件[Lifecycle-aware components]执行操作[perform actions]以响应另一个组件(例如 Activity 或 Fragment)的生命周期状态的更改。这些组件可帮助您生成更易于组织[better-organized]且通常更轻量级[lighter-weight]的代码，并且这些代码更易于维护。
一种常见的模式是，在 Activity 或 Fragment 的生命周期方法中实现依赖组件的操作[the actions of the dependent components]。但是，这种模式导致代码组织不良[poor organization]以及错误的增加。通过使用生命周期感知组件，您可以将依赖组件的代码移出生命周期方法、并移入组件本身。
android.arch.lifecycle 包提供了类和接口，使您可以构建生命周期感知组件，这些组件可以根据 Activity 或 Fragment 的当前生命周期状态自动调整其行为。
Android框架中定义的大多数应用程序组件都附加了生命周期。生命周期由操作系统或流程中运行的框架代码所管理。它们是Android工作原理的核心，您的应用程序必须尊重它们。不这样做可能会触发内存泄漏甚至应用程序崩溃。
android.arch.lifecycle 包提供了类和接口，可帮助您以弹性和隔离的方式[resilient and isolated way]解决这些问题。

使用案例

LifecycleObserver 的几种实现方式

如果使用Java 8，建议使用DefaultLifecycleObserver观察事件。要使用含它需添加 common-java8 依赖：

implementation 'android.arch.lifecycle:common-java8:1.1.1'

如果使用Java 7，则可以使用注解观察生命周期事件。

注意：一旦Java 8语言成为Android的主流，针对Java 7提供的注解方式将会被弃用，因此在DefaultLifecycleObserver和注解之间，您应该始终优先选择DefaultLifecycleObserver。

实际使用中，我们通常是将所有要观察的生命周期事件都封装到 BasePresenter 等实现类中，这样每一个 BasePresenter 的子类都能感知到 Activity 对应的生命周期事件，并在子类重写的方法中实现相应的行为。

实现 LifecycleObserver 接口

使用Observer注解的方法可以接收零个或一个参数。如果使用，则第一个参数必须是LifecycleOwner类型。
使用Lifecycle.Event.ON_ANY注解的方法可以接收第二个参数，该参数必须是Lifecycle.Event类型。
提供这些附加参数是为了方便您观察多个providers和events而无需手动tracking它们。

public class BaseLifecycleObserver implements LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void onCreate() {
        Log.i("bqt", "Observer【onCreate】");
    }
 
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void onStart() {
        Log.i("bqt", "Observer【onStart】");
    }
 
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void onResume(LifecycleOwner source) {
        Log.i("bqt", "Observer【onResume】" + source.getLifecycle().getClass().getSimpleName());
    }
 
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void onPause() {
        Log.i("bqt", "Observer【onPause】");
    }
 
    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void onStop() {
        Log.i("bqt", "Observer【onStop】");
    }
 
    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void onDestroy() {
        Log.i("bqt", "Observer【onDestroy】");
    }
 
    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    public void onAny(LifecycleOwner source, Lifecycle.Event event) {
        Log.i("bqt", "Observer onAny：" + event.name());
    }
}

实现 GenericLifecycleObserver 接口

public class BaseGenericLifecycleObserver implements GenericLifecycleObserver {
 
    @Override
    public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
        switch (event) {
            case ON_CREATE:
                Log.i("bqt", "Observer【onCreate】");
                break;
            case ON_START:
                Log.i("bqt", "Observer【onStart】");
                break;
            case ON_RESUME:
                Log.i("bqt", "Observer【onResume】" + source.getLifecycle().getClass().getSimpleName());
                break;
            case ON_PAUSE:
                Log.i("bqt", "Observer【onPause】");
                break;
            case ON_STOP:
                Log.i("bqt", "Observer【onStop】");
                break;
            case ON_DESTROY:
                Log.i("bqt", "Observer【onDestroy】");
                break;
            case ON_ANY:
                Log.i("bqt", "Observer onAny");
                break;
            default:
                Log.i("bqt", "Observer【不存在的事件】");
                break;
        }
    }
}

实现 DefaultLifecycleObserver 接口

FullLifecycleObserver 接口继承自 LifecycleObserver，并声明了与 Activity 声明周期一致的6个方法：

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);
}

DefaultLifecycleObserver 接口继承自 FullLifecycleObserver 接口，并利用 Java 8 的特性为每一个方法提供了空实现：

public interface DefaultLifecycleObserver extends FullLifecycleObserver {
   @Override
   default void onCreate(@NonNull LifecycleOwner owner) {}
   //...其他几个方法类似
}

这样我们就不必重写接口中的每一个方法了，只需重写我们关心的方法即可。

public class MyDefaultLifecycleObserver implements DefaultLifecycleObserver {
    @Override
    public void onCreate(@NonNull LifecycleOwner source) {
        Log.i("bqt", "Observer【onCreate】");
    }
 
    @Override
    public void onStart(@NonNull LifecycleOwner source) {
        Log.i("bqt", "Observer【onStart】");
    }
 
    @Override
    public void onResume(@NonNull LifecycleOwner source) {
        Log.i("bqt", "Observer【onResume】" + source.getLifecycle().getClass().getSimpleName());
    }
 
    @Override
    public void onPause(@NonNull LifecycleOwner source) {
        Log.i("bqt", "Observer【onPause】");
    }
 
    @Override
    public void onStop(@NonNull LifecycleOwner source) {
        Log.i("bqt", "Observer【onStop】");
    }
 
    @Override
    public void onDestroy(@NonNull LifecycleOwner source) {
        Log.i("bqt", "Observer【onDestroy】");
    }
}

在 Activity 中使用

public class LifecycleTestActivity extends AppCompatActivity {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        getLifecycle().addObserver(new BaseLifecycleObserver()); //在onCreate方法中注册，以上三种使用任何一种效果都一样
        ImageView imageView = new ImageView(this);
        imageView.setImageResource(R.drawable.icon);
        setContentView(imageView);
    }
}

打印日志

Activity【onCreate】
    Observer【onCreate】
Activity【onStart】
    Observer【onStart】
Activity【onResume】
    Observer【onResume】
------------------------------
    Observer【onPause】
Activity【onPause】
    Observer【onStop】
Activity【onStop】
    Observer【onDestroy】
Activity【onDestroy】

注意

Lifecycle.Event.ON_CREATE, Lifecycle.Event.ON_START, Lifecycle.Event.ON_RESUME events in this class are dispatched after the LifecycleOwner's related method returns.
Lifecycle.Event.ON_PAUSE, Lifecycle.Event.ON_STOP, Lifecycle.Event.ON_DESTROY events in this class are dispatched before the LifecycleOwner's related method is called.
This gives you certain guarantees某些保证 on which state the owner is in.

这种结果的实现方式是通过：

Activity 或 Fragment 中的 performCreate()、performStart()、performResume() 方法会先调用自身的 onXXX() 方法，然后再调用 LifecycleRegistry 的 handleLifecycleEvent() 方法；
而Activity 或 Fragment 中的 performPause()、performStop()、performDestroy() 方法则会先调用 LifecycleRegistry 的 handleLifecycleEvent() 方法，然后再调用自身的 onXXX() 方法。

在 Fragment 中使用

public class LifecycleTestFragment extends Fragment {
    public LifecycleTestFragment() {
        getLifecycle().addObserver(new BaseGenericLifecycleObserver()); //不是在onCreate等生命周期方法中注册，而是在构造方法中就注册
    }
 
    @Nullable
    @Override
    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        ImageView imageView = new ImageView(getContext());
        imageView.setImageResource(R.drawable.icon);
        return imageView;
    }
}

打印日志

Fragment【onAttach】
Fragment【onCreate】
    Observer【onCreate】
Fragment【onViewCreated】
Fragment【onActivityCreated】
Fragment【onStart】
    Observer【onStart】
Fragment【onResume】
    Observer【onResume】
------------------------------
    Observer【onPause】
Fragment【onPause】
    Observer【onStop】
Fragment【onStop】
Fragment【onDestroyView】
    Observer【onDestroy】
Fragment【onDestroy】
Fragment【onDetach】