Android lifecycle 使用详解

Posted 2021-04-27 程序员徐公

说在前面

1. android lifecycle 使用详解

2. Android LiveData 使用详解

3. Android lifecyle 源码解剖

4. Android livedata 源码解剖

简介

Architecture Components  

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

---

为什么要引进 lifecycle

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

 1class MyPresenter{
 2    public MyPresenter() {
 3    }
 4
 5    void create() {
 6        //do something
 7    }
 8
 9    void destroy() {
10        //do something
11    }
12}
13
14class MyActivity extends AppCompatActivity {
15    private MyPresenter presenter;
16
17    public void onCreate(...) {
18        presenter= new MyPresenter ();
19        presenter.create();
20    }
21
22    public void onDestroy() {
23        super.onDestroy();
24        presenter.destory();
25    }
26}

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

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

---

Lifycycle 的基本使用

第一步：引入相关的依赖包

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

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

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

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

第二步：在代码中使用

这里同样分为几种情况

第一种情况：support library 26.1.0  之后，且继承 FragmentActivity，那么我们直接调用  getLifecycle().addObserver 方法即可，当 Activity 的生命周期变化的时候，将会回调 onStateChanged 的方法，状态分别是一一对应的

 1public class MainActivity extends AppCompatActivity {
 2
 3    private static final String TAG = "MainActivity";
 4
 5    @Override
 6    protected void onCreate(Bundle savedInstanceState) {
 7        super.onCreate(savedInstanceState);
 8        setContentView(R.layout.activity_main);
 9
10        getLifecycle().addObserver(new GenericLifecycleObserver() {
11
12            @Override
13            public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
14                Log.d(TAG, "onStateChanged: event =" + event);
15            }
16        });
17    }
18
19}

第二种情况：support library 26.1.0 之后，不是继承 FragmentActivity，只是简单地继承 Actiivty

 1public class SimpleLifecycleActivity extends Activity implements LifecycleOwner {
 2
 3    private static final String TAG = "SimpleLifecycleActivity";
 4    private LifecycleRegistry mLifecycleRegistry;
 5
 6    @Override
 7    protected void onCreate(Bundle savedInstanceState) {
 8        super.onCreate(savedInstanceState);
 9        setContentView(R.layout.activity_simple_lifecycle);
10        mLifecycleRegistry = new LifecycleRegistry(this);
11        mLifecycleRegistry.markState(Lifecycle.State.CREATED);
12        getLifecycle().addObserver(new GenericLifecycleObserver() {
13
14            @Override
15            public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
16                Log.d(TAG, "onStateChanged: event =" + event);
17            }
18        });
19    }
20
21    @Override
22    protected void onStart() {
23        super.onStart();
24        mLifecycleRegistry.markState(Lifecycle.State.STARTED);
25    }
26
27    @NonNull
28    @Override
29    public Lifecycle getLifecycle() {
30        return mLifecycleRegistry;
31    }
32
33}

第三种情况：support library 26.1.0  之前

（现在的 support library 基本都在 26.1.0 之后了，这个可以忽略）

第一步：实现 LifecycleOwner 接口，并返回响应的  Lifecycle

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

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

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

代码如下

 1public class MainActivity extends AppCompatActivity implements LifecycleOwner {
 2
 3    private LifecycleRegistry mRegistry;
 4
 5    private static final String TAG = "MainActivity";
 6
 7    @Override
 8    protected void onCreate(Bundle savedInstanceState) {
 9        super.onCreate(savedInstanceState);
10        setContentView(R.layout.activity_main);
11        mRegistry = new LifecycleRegistry(this);
12        mRegistry.markState(Lifecycle.State.CREATED);
13        getLifecycle().addObserver(new GenericLifecycleObserver() {
14            @Override
15            public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
16                Log.d(TAG, "onStateChanged:event =" + event);
17            }
18
19            @Override
20            public Object getReceiver() {
21                return null;
22            }
23        });
24
25    }
26
27    @Override
28    protected void onStart() {
29        super.onStart();
30        mRegistry.markState(Lifecycle.State.STARTED);
31        mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
32    }
33
34    @Override
35    protected void onResume() {
36        super.onResume();
37        mRegistry.markState(Lifecycle.State.RESUMED);
38        mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
39    }
40
41    @Override
42    protected void onPause() {
43        super.onPause();
44        mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
45    }
46
47    @Override
48    protected void onStop() {
49        super.onStop();
50        mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
51    }
52
53    @Override
54    protected void onDestroy() {
55        super.onDestroy();
56        mRegistry.markState(Lifecycle.State.DESTROYED);
57        mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);
58    }
59
60    @Override
61    public Lifecycle getLifecycle() {
62        return mRegistry;
63    }
64}

---

总结

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

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

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

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

 1public class MediaCompoment {
 2    private static final String TAG = "MediaCompoment";
 3
 4    private final LifecycleOwner mLifecycleOwner;
 5
 6    public MediaCompoment(LifecycleOwner lifecycleOwner) {
 7        mLifecycleOwner = lifecycleOwner;
 8        mLifecycleOwner.getLifecycle().addObserver(new GenericLifecycleObserver() {
 9            @Override
10            public void onStateChanged(LifecycleOwner source, final Lifecycle.Event event) {
11                if (event == Lifecycle.Event.ON_CREATE) {
12                    onCreate();
13                } else if (event == Lifecycle.Event.ON_START) {
14                    onStart();
15                } else if (event == Lifecycle.Event.ON_RESUME) {
16                    onResume();
17                } else if (event == Lifecycle.Event.ON_PAUSE) {
18                    onPause();
19                } else if (event == Lifecycle.Event.ON_STOP) {
20                    onStop();
21                } else if (event == Lifecycle.Event.ON_DESTROY) {
22                    onDestroy();
23                }
24            }
25        });
26    }
27
28    public void onCreate() {
29        Log.d(TAG, "onCreate:");
30    }
31
32    public void onStart() {
33        Log.d(TAG, "onStart:");
34    }
35
36    public void onResume() {
37        Log.d(TAG, "onResume:");
38    }
39
40    public void onPause() {
41        Log.d(TAG, "onPause:");
42    }
43
44    public void onStop() {
45        Log.d(TAG, "onStop:");
46    }
47
48    public void onDestroy() {
49        Log.d(TAG, "onDestroy:");
50    }
51}

小结：

1. lifycycle 其实是用观察者模式实现的，当 Activity 生命周期变化的时候，通知相应的 Observers 即观察者。

2. 使用 lifecycle，我们可以将释放资源的动作内聚在自身，减少与调用者之间的耦合。

https://github.com/gdutxiaoxu/ArchiteComponentsSample

下一篇博客：Android LiveData 使用详解，敬请期待。

Android 技术人

---