Lifecycle 源码解析（一）：预备知识

HSS
1,213 阅读7分钟

推荐阅读

Lifecycle 源码解析（二）：流程分析

Lifecycle 是什么？

Lifecycle 是 Jetpack 中一个库，能帮助开发者更好的处理一些组件的生命周期，包括我们平常用的 AppCompatActivity ，Fragment 。

Lifecycle 的意义

这个问题官方也给出了答案： developer.android.google.cn/topic/libra…

在 Android 框架中定义的大多数应用组件都存在生命周期。生命周期由操作系统或进程中运行的框架代码管理。它们是 Android 工作原理的核心，应用必须遵循它们。如果不这样做，可能会引发内存泄漏甚至应用崩溃。

假设我们有一个在屏幕上显示设备位置的 Activity。常见的实现可能如下所示：

class MyLocationListener {
    public MyLocationListener(Context context, Callback callback) {
        // ...
    }

    void start() {
        // 连接系统定位服务
    }

    void stop() {
        // 断开连接
    }
}

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();
        // 管理其他需要响应 activity 生命周期的组件
    }

    @Override
    public void onStop() {
        super.onStop();
        myLocationListener.stop();
        // 管理其他需要响应 activity 生命周期的组件
    }
}

虽然此示例看起来没问题，但在真实的应用中，最终会有太多管理界面和其他组件的调用，以响应生命周期的当前状态。管理多个组件会在生命周期方法（如 onStart() 和 onStop()）中放置大量的代码，这使得它们难以维护。

此外，无法保证组件会在 Activity 或 Fragment 停止之前启动。在我们需要执行长时间运行的操作（如 onStart() 中的某种配置检查）时尤其如此。这可能会导致出现一种竞态条件，在这种条件下，onStop() 方法会在 onStart() 之前结束，这使得组件留存的时间比所需的时间要长。

到这里你是否会有个问题：为什么用了 Lifecycle 就能轻松处理生命周期事件呢？难道它不需要 Activity 在 onStart() , onStop() 的时候通知其他组件吗？其实并没有这么神奇， Activity 内部已经将这些工作做好了，也就是在 onStart() , onStop() 的时候会向外发送生命周期事件，我们只需要使用 Lifecycle 就好了。具体实现原理后面会讲到

状态与事件

既然是帮助我们处理生命周期的，那 Lifecycle 是怎么表示生命周期的呢？实际上跟我们平常用的生命周期方法是差不多的，这里贴一张官方的图：

lifecycle-states.svg 可以看到，有6个边箭头：ON_CREATE,ON_START,ON_RESUME,ON_PAUSE,ON_STOP,ON_DESTROY,它们对应我们常用的 onCreate() , onStart() 等生命周期方法，而5条边/结点就是组件的状态。

它们的具体实现在 Lifecycle 类中：

public abstract class Lifecycle {
    ...
    public enum Event {
        ON_CREATE,
        ON_START,
        ON_RESUME,
        ON_PAUSE,
        ON_STOP,
        ON_DESTROY,
        ON_ANY
    }

    @SuppressWarnings("WeakerAccess")
    public enum State {
        /**
         * 刚要onDestroy()调用前的状态
         */
        DESTROYED,

        /**
         * Activity构造后，OnCreate()前
         */
        INITIALIZED,

        /**
         * 两种情况：1.调用onCreate()后
         * 2.刚要调用onStop()前
         */
        CREATED,

        /**
         * 两种情况：1.调用onStart()后
         * 2.刚要调用onPause()前
         */
        STARTED,

        /**
         * 调用onResume()之后
         */
        RESUMED;

        /**
         * Compares if this State is greater or equal to the given {@code state}.
         *
         * @param state State to compare with
         * @return true if this State is greater or equal to the given {@code state}
         */
        public boolean isAtLeast(@NonNull State state) {
            return compareTo(state) >= 0;
        }
    }
}

三大组成部分

Lifecycle 的实现主要是有三个部分实现：LifecycleOwner,LifecycleObserver,Lifecycle。下面让我们对这三个部分有个大致的了解

LifecycleOwner

顾名思义，生命周期拥有者。哪些组件有生命周期呢？我们很容易想到的有 Activity , Fragment , Service 这些。它们就是生命周期拥有者，但这跟这个 LifecycleOwner 有什么关系呢？我们来看看它的实现：

public interface LifecycleOwner {
    @NonNull
    Lifecycle getLifecycle();
}

LifecycleOwner 就是这么简单，本身是一个接口，只有一个方法：getLifecycle() , 看名字就知道这个方法是用来获取生命周期的。

接下来找找上面说的 Activity , Fragment , Service 这些类与 LifecycleOwner 之间联系：

我们常用的 AppCompatActivity 的超类 ComponentActivity 就实现了 LifecycleOwner 这个接口：

public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        ContextAware,
        LifecycleOwner,
        ViewModelStoreOwner,
        HasDefaultViewModelProviderFactory,
        SavedStateRegistryOwner,
        OnBackPressedDispatcherOwner,
        ActivityResultRegistryOwner,
        ActivityResultCaller {
        
        ...
      
}

Fragment 也是：

public class Fragment implements ComponentCallbacks, OnCreateContextMenuListener, LifecycleOwner,
        ViewModelStoreOwner, HasDefaultViewModelProviderFactory, SavedStateRegistryOwner,
        ActivityResultCaller {
            ...
}

这样看来，只要实现 LifecycleOwner 这个接口，就跟 Lifecycle 对接上了。

不知道你是否好奇还有哪些类实现 LifecycleOnwer 这个接口，这里官方也给出答案：developer.android.google.cn/reference/k…

LifecycleOwner 的直接实现类如下：

1661874828885.png

所以对于这些类，我们能够使用 Lifecycle 轻松处理生命周期事件。不过一些类可能需要我们引用一些库，比如 LifecycleService , ProcessLifecycleOwner 就需要引用：

implementation 'android.arch.lifecycle:extensions:1.1.1'

LifecycleObserver

观察者。观察 Activity , Fragment 这些组件的生命周期，接收它们发送的生命周期事件，然后作出响应。 LifecycleObserver 实现如下：

public interface LifecycleObserver {

}

可以看到 LifecycleObserver 就是一个空接口，那它的作用就是标记，实现这个接口的类就抽象为观察者，与 Lifecycle 对接上了。

Lifecycle

Lifecycle，翻译就是生命周期的意思，但是它并不管理 Activity 的生命周期，Activity 等组件的生命周期由操作系统或进程中运行的框架代码管理，那这个类的作用是什么呢？

实际上它相当于 LifecycleOwner （Activity等组件） 和 LifecycleObserver（观察者） 的中介，复杂接收 LifecycleOwner 的生命周期事件，然后把这些事件分发给 LifecycleObserver 。

来看看它的实现：

public abstract class Lifecycle {

    public abstract void addObserver(@NonNull LifecycleObserver observer);
    
    public abstract void removeObserver(@NonNull LifecycleObserver observer);
    
    public abstract State getCurrentState();
    
    public enum Event {
        ...
    }
    
    public enum State {
        ...
    }
    
}

可以看到 Lifecycle 是一个抽象类，有3个抽象方法，2个枚举类（上面提到了），这三个方法的意思看名字就知道分别是：添加观察者，移除观察者，获取当前状态。

使用方法

掌握使用方法才能更好地理解源码，Lifecycle 的使用方法可以分为两步：

写一个 LifecycleObserver 的实现类

直接实现 LifecycleObserver , 然后使用 OnLifecycleEvent 注解。

public class MyObserver implements LifecycleObserver {

    @OnLifecycleEvent(value = Lifecycle.Event.ON_START)
    public void onStart(){
        
    }

    @OnLifecycleEvent(value = Lifecycle.Event.ON_RESUME)
    public void onResume(LifecycleOwner owner){
       
    }

    @OnLifecycleEvent(value = Lifecycle.Event.ON_ANY)
    public void onAny(LifecycleOwner owner, Lifecycle.Event event){
        
    }

}

要求：

  1. OnLifecycleEvent 注解的参数 value 的取值就是 Lifecycle 中枚举类 Event 的值。
  2. 所注解的方法可以无参数，也可以有1个或2个参数，参数个数不能超过2个，且第一个参数类型为 LifecycleOwner ,表示观察者所观察的组件实例，第二个参数类型为 Event。
  3. 如果方法又两个参数，则注解的参数 value 只能取 Lifecycle.Event.ON_ANY 。

实际上 OnLifecycleEvent 注解已经被弃用，那让我们看看其他的写法：

DefaultLifecycleObserver

public class MyObserver implements DefaultLifecycleObserver {

    @Override
    public void onCreate(@NonNull LifecycleOwner owner) {
        DefaultLifecycleObserver.super.onCreate(owner);
    }

    @Override
    public void onStart(@NonNull LifecycleOwner owner) {
        DefaultLifecycleObserver.super.onStart(owner);
    }

    @Override
    public void onResume(@NonNull LifecycleOwner owner) {
        DefaultLifecycleObserver.super.onResume(owner);
    }
    
    
}

DefaultLifecycleObserver 实现如下：

public interface DefaultLifecycleObserver extends FullLifecycleObserver {

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


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

 
    @Override
    default void onResume(@NonNull LifecycleOwner owner) {
    }

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

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

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

我们用一个类实现 DefaultLifecycleObserver 这个接口时，只需要根据需要重写部分方法就好了。

APT

这种方法写法上和第一种方法一样，只不过使用了 APT 技术。添加依赖：

//java
annotationProcessor  'androidx.lifecycle:lifecycle-compiler:2.5.1'

//kotlin
kapt  'androidx.lifecycle:lifecycle-compiler:2.5.1'

然后在 rebulid 一下项目，这时就会自动生成一个类，如下：

public class MyObserver_LifecycleAdapter implements GeneratedAdapter {
  final MyObserver mReceiver;

  MyObserver_LifecycleAdapter(MyObserver receiver) {
    this.mReceiver = receiver;
  }

  @Override
  public void callMethods(LifecycleOwner owner, Lifecycle.Event event, boolean onAny,
      MethodCallsLogger logger) {
    boolean hasLogger = logger != null;
    if (onAny) {
      if (!hasLogger || logger.approveCall("onAny", 4)) {
        mReceiver.onAny(owner,event);
      }
      return;
    }
    if (event == Lifecycle.Event.ON_START) {
      if (!hasLogger || logger.approveCall("onStart", 1)) {
        mReceiver.onStart();
      }
      return;
    }
    if (event == Lifecycle.Event.ON_RESUME) {
      if (!hasLogger || logger.approveCall("onResume", 2)) {
        mReceiver.onResume(owner);
      }
      return;
    }
  }
}

该方法与第一种方法的区别是：在调用观察者的回调方法时，第一种方法是通过反射调用MyObserver的回调方法，而这种方法则是直接调用所生成类（MyObserver_LifecycleAdapter）的方法，运行时性能更好。

Activity等组件添加观察者

生命周期组件调用getLifecycle()获得与自己相关的 Lifecycle 实例， 再调用 Lifecycle 的 addObserver() 即可添加观察者。

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);
    
        MyObserver observer = new MyObserver();
        getLifecycle().addObserver(observer);
    
    }
    
}

感谢与参考：

处理生命周期

“终于懂了“系列：Jetpack AAC完整解析（一）Lifecycle 完全掌握！

avatar
文章
阅读
粉丝