Android Jetpack -- Lifecycles篇

Lifecycles其实从名字看肯定是与生命周期相关，那它与生命周期又有什么联系？
先参考一下官方文档：
Lifecycles是一个生命周期感知组件，当Activity或者Fragment的生命周期发生改变的时会，Lifecycles也会做出相应的生命周期状态的改变，它保存关于组件生命周期状态的信息(比如活动或片段)，并允许其他对象观察这种状态。
可以看出Lifecycles是一个组件，具有感知生命周期的功能，既然是个组件，那就说明可以嵌入到其他地方，比如VewModel便是其中之一。

 

当我们需要处理与生命周期相关的组件的时候，在没有Lifecycles提供的时候，需要设置各种回调，如下所示：

 1 package com.example.lifecycle;
 2 
 3 import androidx.appcompat.app.AppCompatActivity;
 4 
 5 import android.os.Bundle;
 6 import android.util.Log;
 7 
 8 public class MainActivity extends AppCompatActivity {
 9 
10     String TAG = "myTag";
11 
12     @Override
13     protected void onCreate(Bundle savedInstanceState) {
14         super.onCreate(savedInstanceState);
15         setContentView(R.layout.activity_main);
16         Log.d(TAG, "onCreate: ");
17     }
18 
19     @Override
20     protected void onStart() {
21         super.onStart();
22         Log.d(TAG, "onStart: ");
23     }
24 
25     @Override
26     protected void onResume() {
27         super.onResume();
28         Log.d(TAG, "onResume: ");
29     }
30 
31     @Override
32     protected void onPause() {
33         super.onPause();
34         Log.d(TAG, "onPause: ");
35     }
36 
37     @Override
38     protected void onStop() {
39         super.onStop();
40         Log.d(TAG, "onStop: ");
41     }
42 
43     @Override
44     protected void onRestart() {
45         super.onRestart();
46         Log.d(TAG, "onRestart: ");
47     }
48 
49     @Override
50     protected void onDestroy() {
51         super.onDestroy();
52         Log.d(TAG, "onDestroy: ");
53     }
54 }

当组件数目过多的时候，便会需要在生命周期回调中管理多个组件从而徒增代码量，使得项目难以维护，而且在生命周期中执行过多的耗时操作极易引起内存泄漏，而这些都可以通过Lifecycles来解决。

 

 

使用示例

以Chronometer为例子来示范生命周期监听

 1 public class MyChronometer extends Chronometer implements LifecycleObserver {
 2     private long time;
 3     public MyChronometer(Context context) {
 4         super(context);
 5     }
 6 
 7     public MyChronometer(Context context, AttributeSet attrs) {
 8         super(context, attrs);
 9     }
10 
11     public MyChronometer(Context context, AttributeSet attrs, int defStyleAttr) {
12         super(context, attrs, defStyleAttr);
13     }
14 
15     //以注解的形式完成监听
16     @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
17     private void stopMeter(){
18         time = SystemClock.elapsedRealtime() - getBase();
19         stop();
20     }
21 
22     @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
23     private void resumeMeter(){
24         setBase(SystemClock.elapsedRealtime() - time);
25         start();
26     }
27 }

然后Activity如下：只需要添加观察者即可

 1 public class LifecyclesActivity extends AppCompatActivity {
 2 
 3     MyChronometer chronometer;
 4 
 5     @Override
 6     protected void onCreate(Bundle savedInstanceState) {
 7         super.onCreate(savedInstanceState);
 8         setContentView(R.layout.activity_lifecycles);
 9 
10         chronometer = findViewById(R.id.meter);
11         getLifecycle().addObserver(chronometer);
12     }
13 
14 }

Activity与Chronometer之间解耦了，Chrononmeter自我实现了良好的封装，也方便了移植。
这也就是使用Lifecycles带来的好处。