Architecture Components之Lifecycles初探

关于Android Jetpack

Android Jetpack是在Google I/O 2018中推出的新一代组件、工具和架构指导,旨在加快您的Android应用开发速度。Jetpack组件将现有的支持库与架构组件联系起来,并将它们分成四个类别:
jetpack

关于Architecture Components

Architecture Components其实早在Google I/O 2017就推出了,是Jetpack中的架构库,可帮助你设计健壮,可测试和可维护的应用程序。主要用于实现管理UI组件生命周期和处理数据持久性相关的功能。
architecture-components

Lifecycles简介

生命周期感知(Lifecycle-aware)组件作为Architecture Components中最重要且最基本的组件,可以在诸如ActivityFragment中生命周期变化的时候自动调整它的行为。这些组件能让我们写出更好组织,更轻量且更好维护的代码。

导入依赖

导入依赖只需要以下两行就好了,包含了LifecyclesViewModelLiveData

1
2
3
// Lifecycles, ViewModel and LiveData
implementation "android.arch.lifecycle:extensions:1.1.1"
annotationProcessor "android.arch.lifecycle:compiler:1.1.1"

可以通过gradle dependencies查看依赖树,我们可以看到extensions模块里面已经包含了livedataviewmodel模块,我们也可以按需单独implementation某个模块。

1
2
3
4
5
6
7
8
9
10
11
+--- android.arch.lifecycle:extensions:1.1.1
| +--- android.arch.lifecycle:runtime:1.1.1 (*)
| +--- android.arch.core:common:1.1.1 (*)
| +--- android.arch.core:runtime:1.1.1 (*)
| +--- com.android.support:support-fragment:26.1.0 -> 28.0.0-alpha3 (*)
| +--- android.arch.lifecycle:common:1.1.1 (*)
| +--- android.arch.lifecycle:livedata:1.1.1
| | +--- android.arch.core:runtime:1.1.1 (*)
| | +--- android.arch.lifecycle:livedata-core:1.1.1 (*)
| | \--- android.arch.core:common:1.1.1 (*)
| \--- android.arch.lifecycle:viewmodel:1.1.1 (*)

Support Library 26.1.0及之后的版本中,默认已经添加了lifecycle的支持,诸如AppCompatActivityFragmentLifecycleService等都实现了LifecycleOwner这个接口。

1
2
3
4
+--- com.android.support:appcompat-v7:28.0.0-alpha3
| +--- com.android.support:support-compat:28.0.0-alpha3
| | +--- android.arch.lifecycle:runtime:1.1.1
| | | +--- android.arch.lifecycle:common:1.1.1

Lifecycle

上面提到了support包里面的ActivityFragment都已经实现了LifecycleOwner这个接口,我们来看下接口的声明,非常简单,只有一个返回Lifecycle的方法:

1
2
3
4
5
6
public interface LifecycleOwner {
/**
* Returns the Lifecycle of the provider.
*/
Lifecycle getLifecycle();
}

Lifecycle又是什么鬼呢?简单来说,它持有了诸如Activity或者Fragment组件的生命周期状态信息,并且允许其他对象来观察这些状态,比较典型的观察者模式。

Lifecycle里面主要用到了EventState两组枚举常量来追踪关联组件的生命周期状态,可以用下面的时序图来直观的展示Event是怎样引起当前State的变化。
lifecycle-states

LifecycleObserver

那么如何监听Lifecycle中状态的变化呢?我们可以实现LifecycleObserver接口并通过Lifecycle().addObserver(observer)来实现监控生命周期状态的变化,当组件发出具体Event的时候,Observer即可收到相应回调。为了避免在回调中组件的生命周期出现异常,Lifecycle还提供了getCurrentState()获取当前的状态。

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
class LocationListener implements LifecycleObserver {
private boolean enabled = false;
public LocationListener(Context context, Lifecycle lifecycle, Callback callback) {
...
}
@OnLifecycleEvent(Lifecycle.Event.ON_START)
void start() {
if (enabled) {
// connect
}
}
public void enable() {
enabled = true;
if (lifecycle.getCurrentState().isAtLeast(STARTED)) {
// connect if not connected
}
}
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
void stop() {
// disconnect if connected
}
}
mLifecycleOwner.getLifecycle().addObserver(new LocationListener());

通过上面的方式,我们的LocationListener已经能自动感知生命周期的变化并做相应的处理,并且能把相关的逻辑从Activity或者Fragment中解耦出来,我们的依赖也只有Lifecycle这个抽象类。

实现自定义的LifecycleOwner

上面我们提到在Support Library 26.1.0及之后的版本中ActivityFragment都已经实现了LifecycleOwner这个接口,如果我们自己的某些类需要实现Lifecycle的机制,可以实现LifecycleOwner接口并使用LifecycleRegistry来完成生命周期事件的转发,如下代码所示:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class CustomActivity extends Activity implements LifecycleOwner {
private LifecycleRegistry mLifecycleRegistry;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mLifecycleRegistry = new LifecycleRegistry(this);
mLifecycleRegistry.markState(Lifecycle.State.CREATED);
}
@Override
public void onStart() {
super.onStart();
mLifecycleRegistry.markState(Lifecycle.State.STARTED);
}
@NonNull
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
}

LifecycleRegistry是什么鬼?

从源码上来看,它是Lifecycle的实现类,主要用于处理多个observers的添加/删除,以及新增了handleLifecycleEvent()markState()方法以实现生命周期事件发送及状态转换。

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
public class LifecycleRegistry extends Lifecycle {
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
...
}
@NonNull
@Override
public State getCurrentState() {
return mState;
}
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
State next = getStateAfter(event);
moveToState(next);
}
public void markState(@NonNull State state) {
moveToState(state);
}
@Override
public void removeObserver(@NonNull LifecycleObserver observer) {
...
}
}