Android Arch LifeCycle用法详解与源码解析

自从Google IO 大会提出 Android Architecture Components，越来越多的使用组件加入其中。其中 
Handling lifecycles with lifecycle-aware components 这篇文章就向我介绍了LifeCycle这个超实用组件。

二.LifeCycle简介

2.1为什么我们要使用LifeCycle？

我们写代码的时候难免会写写一些Presenter或者Mananger或者一些业务性很强的View。来把很一些业务逻辑从Activity中分解掉。但是不免遇到的问题就是。上述这些辅助类不像Activity和Fragment一样拥有比较完善的生命周期。

当然我们我们也可以这样写：

public interface IPresenter {
    void onCreate();

    void onStart();

    void onResume();

    void onPause();

    void onStop();

    void onDestroy();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
public class MainPresenter implements IPresenter {

    public MainPresenter(Context context){

    }

    @Override
    public void onCreate() {

    }

    @Override
    public void onStart() {

    }

    @Override
    public void onResume() {

    }

    @Override
    public void onPause() {

    }

    @Override
    public void onStop() {

    }

    @Override
    public void onDestroy() {

    }
}
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
public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";
    private IPresenter mPresenter;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.d(TAG, "onCreate: ");
        setContentView(R.layout.activity_main);
        mPresenter = new MainPresenter(this);
        mPresenter.onCreate();
    }

    @Override
    protected void onStart() {
        super.onStart();
        Log.d(TAG, "onStart: ");
        mPresenter.onStart();
    }

    @Override
    protected void onResume() {
        super.onResume();
        Log.d(TAG, "onResume: ");
        mPresenter.onResume();
    }

    @Override
    protected void onPause() {
        super.onPause();
        Log.d(TAG, "onPause: ");
        mPresenter.onPause();
    }

    @Override
    protected void onStop() {
        super.onStop();
        Log.d(TAG, "onStop: ");
        mPresenter.onStop();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.d(TAG, "onDestroy: ");
        mPresenter.onDestroy();
    }
}
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
这个例子很简单。我们当然可以这么写。但是如果对于一个复杂Activity和Fragment来说。可能绑定了多个Presenter，Manager，或者View。那这个代码写起来就会很复杂。尤其是当这些东西被其他人复用的时候，很难让别人也注意到这些细节。（就是在他们的Activity中的对应生命周期要调用这些）

2.2 隆重推出LifeCycle

Google也发现了这样的问题。所以在support包 26.1.0版本后 ，android.support.v4.app中的FragmentActivity和Fragment中已经集成了Lifecycle相关的功能。

简单说一下LifeCycle的原理吧：

假定一个需要观察生命周期的Presenter实例

首先通过Fragment或者FragmentActivity中getLifeCycle方法返回的LifecycleRegistry实例的addObserver()方法，加入到FastSafeIterableMap中。
然后将Presenter的生命周期快进到现在的节点:例如现在LifecycleOwner的状态是STARTED。Presenter将会连续收到ON_CREATE，ON_START两事件。
剩下的交给LifeCycle，自此之后Presenter的生命周期将和宿主保持一致。
关键类介绍：

FastSafeIterableMap 管理观察者的数据结构，对于在迭代的时候进行修改做了一些优化。
LifecycleRegistry LifeCycle业务核心类，完成观察者增减，观察者STATE切换等核心逻辑
LifecycleOwner 宿主Activity实现这个接口，android.support.v4.app 中的Fragment，FragmentActivity已经实现这个接口了。我们也可以给我们自己的Activity实现这个，详情请看3.2章节。
ClassesInfoCache 通过运行时注解的方式找到Presenter中想观测的生命周期。
三.简单用法

3.1 Presenter实现LifecycleObserver

public class MainPresenter implements LifecycleObserver {

  public static final String TAG = "MainActivity";
  public String name;

  public MainPresenter(String name) {
    this.name = name;
  }
  //通过运行时注解的方式实现生命周期，是不是很像EventBus
  @OnLifecycleEvent(Lifecycle.Event.ON_CREATE) public void onCreate() {
    Log.d(TAG, name + "onCreate");
  }

  @OnLifecycleEvent(Lifecycle.Event.ON_START) public void onStart() {
    Log.d(TAG, name + "onStart");
  }

  @OnLifecycleEvent(Lifecycle.Event.ON_RESUME) public void onResume() {
    Log.d(TAG, name + "onResume");
  }

  @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE) public void onPause() {
    Log.d(TAG, name + "onPause");
  }

  @OnLifecycleEvent(Lifecycle.Event.ON_STOP) public void onStop() {
    Log.d(TAG, name + "onStop");
  }
  //比较特殊的一个回调会在任何生命周期回调的时候都回调这里
  //@OnLifecycleEvent(Lifecycle.Event.ON_ANY) public void onDestroy() {
  //  Log.d(TAG, "ON_ANY");
  //}
}
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
Activity只需要把实现了LifecycleObserver的MainPresenter交给LifeCycle管理即可

public class MainActivity extends AppCompatActivity {

  public static final String TAG = "MainActivity";

  @Override protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    Log.d(TAG, "onCreate");
    setContentView(R.layout.activity_main);
    MainPresenter mainPresenter = new MainPresenter(TAG);
    //把MainPresenter交给LifeCycle管理就OK了
    getLifecycle().addObserver(mainPresenter);
  }
  @Override protected void onStart() {
    super.onStart();
    Log.d(TAG, "onStart");
  }

  @Override protected void onRestart() {
    super.onRestart();
    Log.d(TAG, "onRestart");
  }

  @Override protected void onResume() {
    super.onResume();
    Log.d(TAG, "onResume");
  }

  @Override protected void onPause() {
    super.onPause();
    Log.d(TAG, "onPause");
  }

  @Override protected void onStop() {
    super.onStop();
    Log.d(TAG, "onStop");
  }

  @Override protected void onDestroy() {
    super.onDestroy();
    Log.d(TAG, "onDestroy");
  }
}
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
输出结果如下

当然值得注意的

启动阶段 先回调Activity的生命周期再回调LifeCycle的生命周期
结束阶段 先回调LifeCycle的生命周期再回调Activity的生命周期
发挥一下想象力，只要是附着在Activity或者Fragment上的任何实例都可以采用这样的管理方式，让其达到一个自生自灭的问题。是不是就少去了很多内存泄漏的问题。

3.2当然也可以这样用

创建一个自定义的LifeCycle

public class MainActivity1 extends Activity implements LifecycleOwner {
 private LifecycleRegistry mLifecycleRegistry;

  @Override protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    Log.d(TAG, "Activity->onCreate");
    setContentView(R.layout.activity_main);
    mLifecycleRegistry = new LifecycleRegistry(this);
  }
 @NonNull @Override public Lifecycle getLifecycle() {
    return mLifecycleRegistry;
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
附上一张LifeCycle的SATE状态流转图

四.最佳实践

当然这么好用的东西已经和Arch中的其他组件，例如DataBinding以及ViewModel可以有一些配合。以后有机会会尝试一下。