Lifecycle

源码是查看的Android 28
官方文档：https://developer.android.google.cn/jetpack/androidx/releases/lifecycle
先说明一点，生命周期可以在Activity/Fragment中，在Service和Application也是存在的。当我们在Service和Application中使用Lifecycle时，需要引入另外的库，如下：

implementation 'androidx.lifecycle:lifecycle-extensions:2.2.0'
implementation 'androidx.lifecycle:lifecycle-process:2.2.0'

使用lifecycle库

涉及到的概念简介

  首先我们要引入接耦这个软件概念，也就需要了解耦合这个概念，以及涉及到的观察者模式来进行接耦。
  耦合：在软件工程中，对象之间的耦合度就是对象之间的依赖性。对象之间的耦合度越高，维护成本越高，因此对象的设计应使类和构件之间的耦合最小。耦合性是程序结构中各个模块之间相互关联的度量。它取决于各个模块之间的接口的复杂程度、调用模块的方式以及哪些信息通过接口。

  接耦：在软件工程中，降低耦合度即可以理解为接耦，模块间有依赖关系必然存在耦合，理论上的绝对零耦合是做不到的，但可以通过一些现有的方法将耦合度降至最低。

  设计思想：我们应该尽可能地减少代码耦合，如果发现代码耦合，就采取接耦技术。让数据类型、业务逻辑和视图显示三层之间彼此降低耦合，把关联依赖降到最低，而不至于牵一发而动全身。原则就是A功能的代码不要写在B的功能代码中，如果两者之间需要交互，可以通过接口，通过消息，甚至可以引入框架，但总之就是不要直接交叉写。

  观察者模式：观察者模式存在的意义就是「解耦」，它使观察者和被观察者的逻辑不再搅在一起，而是彼此独立、互不依赖。

项目中引入

  建立项目时，只要版本在26以上，使用androidx，就会自动地引入进来就几个lifecycle的库。在项目面板中的目录External Libraries中如下：

androidx.lifecycle:lifecycle-common:2.1.0
androidx.lifecycle:lifecycle-livedata:2.0.0@aar
androidx.lifecycle:lifecycle-livedata-core:2.0.0@aar
androidx.lifecycle:lifecycle-runtime:2.1.0@aar
androidx.lifecycle:lifecycle-viewmodel:2.1.0@aar

注意：以上是我个人的Android Studio中显示的数据，Android Studio版本是4.1.3，compileSdkVersion是29，targetSdkVersion是29

lifecycle库的依赖项

  查看lifecycle库的最新版本及说明，在如下网址：

https://developer.android.google.cn/jetpack/androidx/releases/lifecycle

如下是lifecycle库的依赖在build.gradle文件中如何引用
  lifecycle-extensions中的API已弃用。您可以为特定 Lifecycle 工件添加所需的依赖项。
  对于Android Studio自动引入的lifecycle依赖库就不需要在build.gradle文件中再引入了。

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

    // ViewModel
    implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version"
    // LiveData
    implementation "androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version"
    // Lifecycles only (without ViewModel or LiveData)
    implementation "androidx.lifecycle:lifecycle-runtime-ktx:$lifecycle_version"

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

    // Jetpack Compose Integration for ViewModel
    implementation "androidx.lifecycle:lifecycle-viewmodel-compose:1.0.0-alpha02"

    // Annotation processor
    kapt "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 - 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
    implementation "androidx.lifecycle:lifecycle-reactivestreams-ktx:$lifecycle_version"

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

基本使用

  1. 我们写一个类（比如TestDataModel），实现LifecycleObserver接口，然后在TestDataModel类的方法声明时添加注解（比如@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)，表明绑定onCreate生命周期）；
  2. 在Activity中初始化TestDataModel，并绑定生命周期(lifecycle.addObserver(testDataModel))，TestDataModel类就会自动跟随Activity的生命周期了；
class TestDataModel : LifecycleObserver{

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    private fun startOnCreate(){
        Log.e("===TestDataModel===","execute onCreate Data")
    }
    
}

class LifecycleFirstActivity : AppCompatActivity() {

    private lateinit var testDataModel: TestDataModel
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_lifecycle_first)
        testDataModel = TestDataModel()
        lifecycle.addObserver(testDataModel)
    }   
}

过程跟踪分析

  我们在Activity中是以lifecycle.addObserver()方法来开始使用Lifecycle的，那我们就先分析下lifecycle.addObserver()；
  lifecycle这个变量，我们可以往上追溯，发现是在androidx.activity.ComponentActivity类中声明的；

public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        LifecycleOwner,
        ViewModelStoreOwner,
        SavedStateRegistryOwner,
        OnBackPressedDispatcherOwner {

    private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
    
}

  注意：在androidx.core.app.ComponentActivity中，也实现了LifecycleOwner和声明了LifecycleRegistry；

  在这里我们可以引入几个类来深入了解Lifecycle了，并且需要知道一个设计模式--观察者模式。

  1. LifecycleOwner;
  2. LifecycleObserver;
  3. Lifecycle;
  4. LifecycleRegistry;

  在androidx.activity.ComponentActivity类中，我们看到实现了LifecycleOwner，并且声明了LifecycleRegistry。只是使用这两个类，好像就把Lifecycle的功能使用讲明了，并不是这样子的，我们深入了解一下这几个类的关系；

Lifecycle和其子类关系

涉及的类：

  • ObserverWithState
  • LifecycleOwner
  • LifecycleObserver
  • Lifecycling
//被观察者;
public abstract class Lifecycle{

    AtomicReference<Object> mInternalScopeRef = new AtomicReference<>();
    
    public abstract void addObserver(@NonNull LifecycleObserver observer);
    
    public abstract void removeObserver(@NonNull LifecycleObserver observer);
    
    public abstract State getCurrentState();
    
    public enum Event {
        ON_CREATE,
        ON_START,
        ON_RESUME,
        ON_PAUSE,
        ON_STOP,
        ON_DESTROY,
        ON_ANY
    }
    
    public enum State {
        DESTROYED,
        INITIALIZED,
        CREATED,
        STARTED,
        RESUMED;
        public boolean isAtLeast(@NonNull State state) {
            return compareTo(state) >= 0;
        }
    }
}

LifecycleOwner与LifecycleObserver

简单介绍

//在我的项目，androidx.lifecycle:lifecycle-common:2.2.0库中，androidx.lifecycle文件夹下；

//观察者;
public interface LifecycleObserver{

}

//被观察者;
public interface LifecycleOwner{
    
    Lifecycle getLifecycle();
    
}

LifecycleObserver及其子类

注意：该图没有完全地写完整个继承关系，只是挑选了在Lifecycle中使用的；

FullLifecycleObserver

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

LifecycleEventObserver

public interface LifecycleEventObserver extends LifecycleObserver {
    void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);
}

GenericLifecycleObserver

public interface GenericLifecycleObserver extends LifecycleEventObserver {

}

总结

  所有具有生命周期的组件都能够使用Lifecycle，这包括Activity、Fragment、Service、Application。Lifecycle组件存在的主要意义是帮助我们解耦，让自定义组件也能感受到生命周期的变化。有了Lifecycle之后，在自定义组件内部便可以管理好其生命周期，不再需要担心组件的内存泄漏等问题了，组件使用起来也更加方便和安全。

  Lifecycle组件通过在Activity/Fragmen中注入空的Fragment（ReportFragment），实现了对生命周期的感知。使用反射把使用了@OnLifecycleEvent注解的方法信息保存下来，基于观察者模式，在Activity/Fragment生命周期改变的时候同步状态到观察者。

-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
------------------last line for now-----------------



« 简单工厂模式
序 »

Copyright © 2015 Powered by MWeb,  Theme used GitHub CSS.

TOP