Jetpack Lifecycle

发表于 更新于 分类于 ， Waline： 阅读次数： 本文字数： 8.2k 阅读时长 ≈ 7 分钟

Lifecycle是Jetpack架构组件中用来感知生命周期的组件，使用Lifecycle可以帮助开发者写出与生命周期相关且更简洁、更易维护的代码。

项目中添加Lifecycle组件的依赖项：

build.gradle(:app)
1
2
3
4
5
6
dependencies {
    ...
    def lifecycle_version = "2.5.0"
    implementation "androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version"
    ...
}

Lifecycle

Lifecycle 组件可以让任何一个类都能轻松感知到 Activity 的生命周期，同时又不需要在 Activity 中编写大量的逻辑处理。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/**
 * 实现 LifecycleObserver 接口
 * LifecycleObserver 是一个空接口，不需要实现额外的方法
 *
 * 通过构造函数的 Lifecycle 对象，可以主动获知当前的生命周期状态，
 * 通过调用 lifecycle.currentState，它返回的生命周期状态是一个枚举类型。
 */
class MyObserver(val lifecycle: Lifecycle):LifecycleObserver {

    /**
     * 通过OnLifecycleEvent注解将方法与生命周期绑定
     * 通过注解来感知 Activity 的生命周期
     * 类型一共七种，其中 ON_ANY 表示可以匹配 Activity 任意生命周期回调。
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun activityStart(){
        Log.e("MyObserver","activityStart")
        Log.e("MyObserver",lifecycle.currentState.toString())
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun activityStop(){
        Log.e("MyObserver","activityStop")
    }
}

OnLifecycleEvent注解方法中，Lifecycle.Event的枚举如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public enum Event {
    /**
     * Constant for onCreate event of the {@link LifecycleOwner}.
     */
    ON_CREATE,
    /**
     * Constant for onStart event of the {@link LifecycleOwner}.
     */
    ON_START,
    /**
     * Constant for onResume event of the {@link LifecycleOwner}.
     */
    ON_RESUME,
    /**
     * Constant for onPause event of the {@link LifecycleOwner}.
     */
    ON_PAUSE,
    /**
     * Constant for onStop event of the {@link LifecycleOwner}.
     */
    ON_STOP,
    /**
     * Constant for onDestroy event of the {@link LifecycleOwner}.
     */
    ON_DESTROY,
    /**
     * An {@link Event Event} constant that can be used to match all events.
     */
    ON_ANY;
    
    ...
}

几个状态分别对应Activity的生命周期，最后一个状态则表示可对应Activity的任意生命周期。

在Activity中注册MyObserver：

1
2
3
4
5
6
7
8
9
10
11
12
13
class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // 首先调用 LifecycleOwner 的 getLifecycle()，得到一个 Lifecycle 对象，
        // 然后调用它的 addObserver() 来观察 LifecycleOwner 的生命周期，
        // 再把 MyObserver 的实例传进去。
        // 在 AndroidX 库中已经自动帮我们完成这些了，不需要自己实现一个 LifecycleOwner。
        lifecycle.addObserver(MyObserver(lifecycle))
    }
}

追溯源码，AppCompatActivity 继承自androidx.core.app.ComponentActivity，而ComponentActivity实现了LifecycleOwner接口，所以可以直接调用getLifecycle()。

ComponentActivity源码如下：

1
2
3
4
5
public class ComponentActivity extends Activity implements
        LifecycleOwner,
        KeyEventDispatcher.Component {
    ...      
 }

LifecycleOwner源码如下：

1
2
3
4
5
6
7
8
9
public interface LifecycleOwner {
    /**
     * Returns the Lifecycle of the provider.
     *
     * @return The lifecycle of the provider.
     */
    @NonNull
    Lifecycle getLifecycle();
}

除了ComponentActivity外，其子类如androidx.fragment.app.FragmentActivity、androidx.appcompat.app.AppCompatActivity、androidx.fragment.app.Fragment中都是可以直接使用Lifecycle的。

自定义LifecycleOwner

如果当前父类未实现LifecycleOwner接口，比如android.app.Activity，则需要自定义LifecycleOwner。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class MyActivity : Activity(), LifecycleOwner {

    private lateinit var lifecycleRegistry: LifecycleRegistry

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        lifecycleRegistry = LifecycleRegistry(this)
        lifecycleRegistry.markState(Lifecycle.State.CREATED)
    }

    public override fun onStart() {
        super.onStart()
        lifecycleRegistry.markState(Lifecycle.State.STARTED)
    }

    override fun getLifecycle(): Lifecycle {
        return lifecycleRegistry
    }
}

还可以通过Lifecycle的getCurrentState方法主动获取当前Activity的生命周期状态，getCurrentState会返回如下种类的State：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
public enum State {
    /**
     * 生命周期所有者的销毁状态。
     * 在此事件之后，此生命周期将不再分派任何事件。
     * 例如，对于android.app.Activity，
     * 这个状态是在Activity的onDestroy调用之前到达的。
     */
    DESTROYED,

    /**
     * 为LifecycleOwner初始化状态
     * android.app.Activity
     * 这是当它被构造但还没有收到onCreate时的状态。
     */
    INITIALIZED,

    /**
     * 为LifecycleOwner创建的状态。
     * android.app.Activity，在两种情况下会达到这种状态:: 
     * onCreate后调用
     * onStop之前调用
     */
    CREATED,

    /**
     * LifecycleOwner的启动状态
     * For an android.app.Activity
     * 在两种情况下会达到这种状态:
     * onStart 后调用
     * onPause 之前调用
     */
    STARTED,

    /**
     * 生命周期所有者的恢复状态
     * For an android.app.Activity
     * 调用onResume后会达到这种状态
     */
    RESUMED;

    /**
     * 比较该状态是否大于或等于给定状态
     * Params (参数个数):
     * state—要比较的状态
     * Returns (返回):
     * 如果这个状态大于或等于给定状态，则为真
     */
    public boolean isAtLeast(@NonNull State state) {
        return compareTo(state) >= 0;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
class MainActivity : BaseActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        Log.d("TAG","onCreate: "+lifecycle.currentState)
    }

    override fun onStart() {
        super.onStart()
        Log.d("TAG","onStart: "+lifecycle.currentState)
    }

    override fun onResume() {
        super.onResume()
        Log.d("TAG","onResume: "+lifecycle.currentState)
    }

    override fun onPause() {
        super.onPause()
        Log.d("TAG","onPause: "+lifecycle.currentState)
    }
    
    override fun onStop() {
        super.onStop()
        Log.d("TAG","onStop: "+lifecycle.currentState)
    }

    override fun onDestroy() {
        super.onDestroy()
        Log.d("TAG","onDestroy: "+lifecycle.currentState)
    }

//    日志打印：
//    D/TAG: onCreate: INITIALIZED
//    D/TAG: onStart: CREATED
//    D/TAG: onResume: STARTED
//    D/TAG: onPause: STARTED
//    D/TAG: onStop: CREATED
//    D/TAG: onDestroy: DESTROYED
}

State返回值与Activity生命周期的对应关系如下：

源码分析

androidx.core.app.ComponentActivity 中默认实现了LifecycleOwner接口，getLifecycle返回的实际是一个LifecycleRegistry对象

ComponentActivity
1
2
3
4
5
6
7
8
private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);


@NonNull
@Override
public Lifecycle getLifecycle() {
    return mLifecycleRegistry;
}

LifecycleRegistry是Lifecycle的唯一实现类

LifecycleRegistry
1
public class LifecycleRegistry extends Lifecycle {}

Lifecycle抽象类中定义了添加观察者（addObserver）、移除观察者（removeObserver）、以及获取当前状态（getCurrentState）的方法，可见这是典型的观察者模式。

查看androidx.core.app.ComponentActivity 

1
2
3
4
5
6
7
@SuppressLint("RestrictedApi")
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
  // ReportFragment是一个无页面的Fragment，用来协助Activity处理任务，兼容那些并不是直接继承自FragmentActivity的页面，使他们可以正常使用Lifecycle。
    ReportFragment.injectIfNeededIn(this);
}

查看ReportFragment的injectIfNeededIn方法

1
2
3
4
5
6
7
8
9
10
11
12
13
public static void injectIfNeededIn(Activity activity) {
    if (Build.VERSION.SDK_INT >= 29) {
        // On API 29+, we can register for the correct Lifecycle callbacks directly
        LifecycleCallbacks.registerIn(activity);
    }
    // 使用Fragment兼容处理不是继承自FragmentActivity的视图，确保ProcessLifecycleOwner可以正常工作。
    android.app.FragmentManager manager = activity.getFragmentManager();
    if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
        manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
        // 希望立即执行
        manager.executePendingTransactions();
    }
}

在ReportFragment的生命周期方法中都会执行dispatch方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
@Override
public void onActivityCreated(Bundle savedInstanceState) {
    super.onActivityCreated(savedInstanceState);
    dispatchCreate(mProcessListener);
    dispatch(Lifecycle.Event.ON_CREATE);
}

@Override
public void onStart() {
    super.onStart();
    dispatchStart(mProcessListener);
    dispatch(Lifecycle.Event.ON_START);
}

@Override
public void onResume() {
    super.onResume();
    dispatchResume(mProcessListener);
    dispatch(Lifecycle.Event.ON_RESUME);
}

@Override
public void onPause() {
    super.onPause();
    dispatch(Lifecycle.Event.ON_PAUSE);
}

@Override
public void onStop() {
    super.onStop();
    dispatch(Lifecycle.Event.ON_STOP);
}

@Override
public void onDestroy() {
    super.onDestroy();
    dispatch(Lifecycle.Event.ON_DESTROY);
    // 赋值为空，确保不会导致内存泄漏。
    mProcessListener = null;
}

查看dispatch方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@SuppressWarnings("deprecation")
static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
    if (activity instanceof LifecycleRegistryOwner) {
        ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
        return;
    }

    if (activity instanceof LifecycleOwner) {
        Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
        if (lifecycle instanceof LifecycleRegistry) {
            ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
        }
    }
}

dispatch方法最终都会进入到LifecycleRegistry的handleLifecycleEvent方法中，通过handleLifecycleEvent设置状态并通知观察者，Activity便能监听到生命周期的变化了。

备注

参考资料：

使用生命周期感知型组件处理生命周期

第一行代码(第3版)

《Android Jetpack开发 原理解析与应用实战》