生命周期感知型组件

解耦很大程度上表现为系统组件的生命周期与普通组件之间的解耦。普通组件在使用过程中通常需要依赖于系统组件的生命周期。因为普通组件无法主动获知系统组件的生命周期事件。

生命周期感知型组件可执行响应另一个组件（如Activity和Fragment）的生命周期状态的变化。

原来常规的做法是在Activity和Fragment的生命周期方法中实现依赖组件的操作。但这种模式会导致代码条理性很差而且会扩展错误。

生命周期感知型组件可将依赖的代码从生命周期方法中移入到组件本身中。

andoridx.lifecycle软件包提供了可用于构建生命周期感知型组件的类和接口-这些组件可根据Activity或Fragment的当前生命周期状态自动调整期行为。

Lifecycle

Lifecycle原理：

LifecycleOwner（被观察者）；LifecycleObserver（观察者）。

通过观察者模式，实现对页面生命周期的监听。

使用 Lifecycle 进行开发之前需要先在 build.gradle 中添加如下依赖代码

dependencies {
    def lifecycle_version = "2.2.0"
    def arch_version = "2.1.0"

    // 包含ViewModel和LiveData
    implementation "android.arch.lifecycle:extensions:$lifecycle_version"
    // 仅仅包含 ViewModel
    implementation "androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version" // For Kotlin use viewmodel-ktx
    // 仅仅包含 LiveData
    implementation "androidx.lifecycle:lifecycle-livedata:$lifecycle_version"
    // 仅仅包含 Lifecycles (without ViewModel or LiveData)
    implementation "androidx.lifecycle:lifecycle-runtime:$lifecycle_version"

    // Saved state module for ViewModel
    implementation "androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version"

    // Annotation processor
    annotationProcessor "androidx.lifecycle:lifecycle-compiler:$lifecycle_version" // For Kotlin use kapt instead of annotationProcessor
    // alternately - if using Java8, use the following instead of lifecycle-compiler (如果用Java8, 用于替代compiler)
    implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"

    // optional - helpers for implementing LifecycleOwner in a Service
    implementation "androidx.lifecycle:lifecycle-service:$lifecycle_version"

    // optional - ProcessLifecycleOwner provides a lifecycle for the whole application process
    implementation "androidx.lifecycle:lifecycle-process:$lifecycle_version"

    // optional - ReactiveStreams support for LiveData (可选，ReactiveStreams对LiveData的支持)
    implementation "androidx.lifecycle:lifecycle-reactivestreams:$lifecycle_version"

    // optional - Test helpers for LiveData (可选，LiveData的测试)
    testImplementation "androidx.arch.core:core-testing:$arch_version"
}

Lifecycle是一个类，用于存储有关组件（如Activity或Fragment）的生命周期状态的信息，并允许其他对象观察此状态。

Lifecycle使用两种主要枚举跟踪其关联组件的生命周期状态：

事件

从框架和 Lifecycle 类分派的生命周期事件。这些事件映射到 Activity 和 Fragment 中的回调事件。

状态

由 Lifecycle 对象跟踪的组件的当前状态。

构成 Android Activity 生命周期的状态和事件

可将状态看做图中的节点，事件看做这些节点之间的边。

类可通过向其方法添加注解来监控组件的生命周期状态。然后，通过调用 Lifecycle 类的 addObserver()方法并传递观察者的实例来添加观察者

public class MyObserver implements LifecycleObserver{
    @OnLifecleEvent(Lifecycle.Event.ON_RESUME)
    public void connectListener(){
        ...
    }
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void disconnectListener(){
        ...
    }
}
myLifecleOwner.getLifecycle().addObserver(new MyObserver());

例子：

没有用生命周期感知组件的代码，可能是这样

class MyLocationListener{
    public MyLocationListener(Context context, Callback callback){
        //...
    }
    void start(){
        //connect to system location service
    }
    void stop(){
        //disconnect from system location service
    }
}

class MyActivity extends AppCompatActivity{
    private MyLocationListener myLocationListener;
    
    @Override
    public void onCreate(...){
        myLocationListener = new MyLocationListener(this, (location) -> {
            // update UI
        })
    }
    
    @Override
    public void onStart(){
        super.onStart();
        myLocationListener.start();
        // manage other components that need to respond
        // to the activity lifecycle
    }
    
    @Override
    public void onStop() {
        super.onStop();
        myLocationListener.stop();
        // manage other components that need to respond
        // to the activity lifecycle
    }
}

使用lifecycle组件的例子：

让需要感知生命周期的组件实现LifecycleObserver接口

import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleObserver;
import androidx.lifecycle.OnLifecycleEvent;

public class MyLocationListener implements LifecycleObserver {

    private Context context;

    public MyLocationListener(Context context) {
        this.context = context;
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    void onCreate() {
        showLog("onCreate");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    void onDestroy() {
        showLog("onDestroy");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    void onStart() {
        showLog("onStart");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    void onStop() {
        showLog("onStop");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    void onResume() {
        showLog("onResume");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    void onPause() {
        showLog("onPause");
    }

    private void showLog(String msg) {
        Log.e("===MyLocationListener", msg);
    }
}

对应 Activity 或 Fragment 实现 LifecycleOwner，并调用 getLifecycle().addObserverLifecycle().addObserver 添加观察者

import androidx.appcompat.app.AppCompatActivity;
import androidx.lifecycle.LifecycleOwner;

public class MainActivity extends AppCompatActivity implements LifecycleOwner{
    @Override
    protected void onCreate(Bundle savedInstanceState){
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        getLifecycle().addObserver(new MyLocationListener(this));
        
    }
}

自定义生命周期组件

有一个自定义类想让它成为 LifecycleOwner，可以使用 LifecycleRegistry 类，但需要将事件转发到自己的类中

import androidx.annotation.NonNull;
import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleOwner;
import androidx.lifecycle.LifecycleRegistry;

public class MyCommpont implements LifecycleOwner{
    private LifecycleRegistry lifecycleRegistry;
    
    public MyCommpont(){
        lifecycleRegistry = new LifecycleRegistry(this);
    }
    public void onCreate(){
        lifecycleRegistry.markState(Lifecycle.State.CREATED);
    }
    public void onStart(){
        lifecycleRegistry.markState(Lifecycle.State.STARTED);
    }
    public void onKillApp(){
        lifecycleRegistry.markState(Lifecycle.State.DESTROYED);
    }
    
    @NonNull
    @Override
    public Lifecycle getLifecycle(){
        return lifecycleRegistry;
    }
}


//调用
public class MainActivity extends AppCompatActivity{
    @Override
    protected void onCreate(Bundle savedInstanceState){
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        MyCommpont myCommpont = new MyCommpont();
        myCommpont.onCreate();
        myCommpont.onStart();
        myCommpont.getLifecycle().addObserver(new LocationListener(this));
    }
}

LifecycleOwner

LifecycleOwner 是单一方法接口，表示类具有 Lifecycle。它具有一种方法（即 getLifecycle()），该方法必须由类实现。如果您尝试管理整个应用进程的生命周期，请参阅 ProcessLifecycleOwner。

此接口从各个类（如 Fragment 和 AppCompatActivity）抽象化 Lifecycle 的所有权，并允许编写与这些类搭配使用的组件。任何自定义应用类均可实现 LifecycleOwner 接口

实现 LifecycleObserver 的组件可与实现 LifecycleOwner 的组件完美配合，因为所有者可以提供生命周期，而观察者可以注册以观察生命周期。