程序员徐公

微信公众号:【徐公】

0%

Android lifecycle 使用详解

说在前面

本次推出 Android Architecture Components 系列文章,目前写好了四篇,主要是关于 lifecycle,livedata 的使用和源码分析,其余的 Navigation, Paging library,Room,WorkMannager 等春节结束之后会更新,欢迎关注我的公众号,有更新的话会第一时间会在公众号上面通知。

Android lifecycle 使用详解

Android LiveData 使用详解

Android lifecyle 源码解剖

Android livedata 源码解剖

github sample 地址: ArchiteComponentsSample

在这里插入图片描述

Architecture Components

lifecycle 是 2107 年 google 大会推出来的,它属于 architecture compoment 里面的一个组件,它可以干什么用呢? 简单得来说,它可以用来检查 Activity 的生命周期,而不必强依赖 Activity。


为什么要引进 lifecycle

举一下我们最常用的 MVP 例子,没引进 lifecycle 之前,我们需要在 Activity 或者 Fragment 销毁的时候,即 onDestroy 的时候手动调用 onDestroy 方法,这里会带来一些问题,每一次在 Activity 或者 Fragment 销毁的烧开后都要调用 presenter.destory() 方法,这样的代码枯燥,毫无意义。

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 MyPresenter{
public MyPresenter() {
}

void create() {
//do something
}

void destroy() {
//do something
}
}

class MyActivity extends AppCompatActivity {
private MyPresenter presenter;

public void onCreate(...) {
presenter= new MyPresenter ();
presenter.create();
}

public void onDestroy() {
super.onDestroy();
presenter.destory();
}
}

当然我们也可以定义一些 IBasePresenter 的接口,在 BaseActivity 的时候调用 IBasePresenter 的 onDestroy 方法,这样也确实能做到。只不过稍微繁琐一点。

那如果是别的类的呢,比如 MediaCompoment,在 Activity 的时候,我们需要销毁一些资源,按照传统的方法,我们还是需要在 Activity onDestroy 的时候手动调用 onDestroy 方法。那有没有更好的方法呢?当然是有的,lifecycle 就可以解决这个问题。接下来,我们先来看一下 Lifycycle 的基本使用。


Lifycycle 的基本使用

  1. 引入相关的依赖包

Lifecycle 已经是稳定版,它包含在 support library 26.1.0 及之后的依赖包中,如果我们的项目基于这些依赖包,那么不需要额外的引用。

1
2
3
4
5
6
// ViewModel and LiveData
implementation "android.arch.lifecycle:extensions:1.1.0"
// alternatively, just ViewModel
implementation "android.arch.lifecycle:viewmodel:1.1.0"
// alternatively, just LiveData
implementation "android.arch.lifecycle:livedata:1.1.0"

support library在26.1.0 之前,lifecycle 并没有集成进去,需要我们引入另外的包。

1
implementation "android.arch.lifecycle:extensions:1.0.0-alpha4"
  1. 使用

这里同样分为几种情况

  1. support library 26.1.0 之后,且继承 FragmentActivity,那么我们直接调用 getLifecycle().addObserver 方法即可,当 Activity 的生命周期变化的时候,将会回调 onStateChanged 的方法,状态分别是一一对应的
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class MainActivity extends AppCompatActivity {

private static final String TAG = "MainActivity";

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

getLifecycle().addObserver(new GenericLifecycleObserver() {

@Override
public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
Log.d(TAG, "onStateChanged: event =" + event);
}
});
}

}
  1. support library 26.1.0 之后,不是继承 FragmentActivity,只是简单地继承 Actiivty
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
public class SimpleLifecycleActivity extends Activity implements LifecycleOwner {

private static final String TAG = "SimpleLifecycleActivity";
private LifecycleRegistry mLifecycleRegistry;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_simple_lifecycle);
mLifecycleRegistry = new LifecycleRegistry(this);
mLifecycleRegistry.markState(Lifecycle.State.CREATED);
getLifecycle().addObserver(new GenericLifecycleObserver() {

@Override
public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
Log.d(TAG, "onStateChanged: event =" + event);
}
});
}

@Override
protected void onStart() {
super.onStart();
mLifecycleRegistry.markState(Lifecycle.State.STARTED);
}

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

}

  1. support library 26.1.0 之前

(现在的 support library 基本都在 26.1.0 之后了,这个可以忽略)

第一步:实现 LifecycleOwner 接口,并返回响应的 Lifecycle

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

第二步:在 Activity 生命周期变化的时候,调用 mLifecycleRegistry.handleLifecycleEvent 方法,分发相应的生命周期。

第三步:调用 Lifecycle 的 addObserver 方法添加相应的 Observer。

代码如下

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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
public class MainActivity extends AppCompatActivity implements LifecycleOwner {

private LifecycleRegistry mRegistry;

private static final String TAG = "MainActivity";

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mRegistry = new LifecycleRegistry(this);
mRegistry.markState(Lifecycle.State.CREATED);
getLifecycle().addObserver(new GenericLifecycleObserver() {
@Override
public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
Log.d(TAG, "onStateChanged:event =" + event);
}

@Override
public Object getReceiver() {
return null;
}
});

}

@Override
protected void onStart() {
super.onStart();
mRegistry.markState(Lifecycle.State.STARTED);
mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
}

@Override
protected void onResume() {
super.onResume();
mRegistry.markState(Lifecycle.State.RESUMED);
mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
}

@Override
protected void onPause() {
super.onPause();
mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
}

@Override
protected void onStop() {
super.onStop();
mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
}

@Override
protected void onDestroy() {
super.onDestroy();
mRegistry.markState(Lifecycle.State.DESTROYED);
mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);
}

@Override
public Lifecycle getLifecycle() {
return mRegistry;
}
}


总结

我们回过头来看一下我们上面提出的问题?

MediaCompoment 在 Activity ondestroy 的时候,我们需要销毁一些资源,用传统的方法,我们需要在 Activity onDestroy 的时候手动调用 onDestroy 方法。这样会存在一个问题,调用者必须知道比较清楚得知道 MediaCompoment 的设计,否则可能会忘记调用 onDestroy 的方法。

那有没有一种方法, 当 Activity 生命周期变化的时候,MediaCompoment 自身能够检测到 Activity 的 生命周期变化,从而做相应的处理。

答案当然是有的,使用 lifycycle。

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 class MediaCompoment {
private static final String TAG = "MediaCompoment";

private final LifecycleOwner mLifecycleOwner;

public MediaCompoment(LifecycleOwner lifecycleOwner) {
mLifecycleOwner = lifecycleOwner;
mLifecycleOwner.getLifecycle().addObserver(new GenericLifecycleObserver() {
@Override
public void onStateChanged(LifecycleOwner source, final Lifecycle.Event event) {
if (event == Lifecycle.Event.ON_CREATE) {
onCreate();
} else if (event == Lifecycle.Event.ON_START) {
onStart();
} else if (event == Lifecycle.Event.ON_RESUME) {
onResume();
} else if (event == Lifecycle.Event.ON_PAUSE) {
onPause();
} else if (event == Lifecycle.Event.ON_STOP) {
onStop();
} else if (event == Lifecycle.Event.ON_DESTROY) {
onDestroy();
}
}
});
}

public void onCreate() {
Log.d(TAG, "onCreate:");
}

public void onStart() {
Log.d(TAG, "onStart:");
}

public void onResume() {
Log.d(TAG, "onResume:");
}

public void onPause() {
Log.d(TAG, "onPause:");
}

public void onStop() {
Log.d(TAG, "onStop:");
}

public void onDestroy() {
Log.d(TAG, "onDestroy:");
}
}

小结:

  1. lifycycle 其实是用观察者模式实现的,当 Activity 生命周期变化的时候,通知相应的 Observers 即观察者。
  2. 使用 lifecycle,我们可以将释放资源的动作内聚在自身,减少与调用者之间的耦合。

下一篇博客:Android LiveData 使用详解

推荐阅读

Android 启动优化(一) - 有向无环图

Android 启动优化(二) - 拓扑排序的原理以及解题思路

Android 启动优化(三)- AnchorTask 开源了

Android 启动优化(四)- AnchorTask 是怎么实现的

Android 启动优化(五)- AnchorTask 1.0.0 版本正式发布了

Android 启动优化(六)- 深入理解布局优化

这几篇文章从 0 到 1,讲解 DAG 有向无环图是怎么实现的,以及在 Android 启动优化的应用。

推荐理由:现在挺多文章一谈到启动优化,动不动就聊拓扑结构,这篇文章从数据结构到算法、到设计都给大家说清楚了,开源项目也有非常强的借鉴意义。

在这里插入图片描述