前言

本篇从Lifecycle开始将正式进入Jetpack 各个组件的分析。

通过本篇文章你将了解到:


1、为什么需要Lifecycle?
2、Lifecycle 如何使用?
3、Lifecycle 如何感知生命周期
4、Lifecycle 内存泄漏?
5、总结


1、为什么需要Lifecycle?

生命周期的起始

Android 中常见的拥有生命周期的组件如Activity、Fragment、Service等,其中Activity、Fragment最为常见,而Fragment的生命周期依托于Activity,因此掌握了Activity的生命周期,其它不在话下。

生命周期的运用

青铜选手

举个简单的例子:当进入Activity 时(获取焦点)需要网络请求,当Activity 退出时(失去焦点)停止网络请求,最简单的做法如下:

@Override
protected void onResume() {
super.onResume();
NetRequest.startRequest();
}

@Override
protected void onPause() {
super.onPause();
NetRequest.stopRequest();
}

重写onResume()方法,当该方法被调用时,说明Activity获取了焦点,页面即将展示,此时可以进行网络请求拉取数据。

重写onPause()方法,当该方法被调用时,说明Activity 失去了焦点,此时没必要再请求网络了。

看似没啥问题,但仔细想想:比如在播放视频的时候,也需要在onResume()方法里播放,在onPause()方法里暂停,再比如数据库操作等,这个时候onResume()、onPause()里就叠放了许多代码,使得Activity 变得很臃肿。

白银选手

你说没关系,我有MVP 架构,可以用Presenter 来封装这些业务逻辑。

声明Presenter类:LifecyclePresenter。

public class LifecyclePresenter implements ILifecycle{
@Override
public void onResume() {
NetRequest.startRequest();
}

@Override
public void onPause() {
NetRequest.stopRequest();
}
}

该类实现了接口:ILifecycle,而此接口声明的方法与Activity 生命周期契合:

interface ILifecycle {
void onCreate();
void onStart();
void onResume();
void onPause();
void onStop();
void onDestroy();
}

好了,最后在Activity 里监听生命周期的变化,进而调用LifecyclePresenter 不同方法:

@Override
protected void onResume() {
super.onResume();
lifecyclePresenter.onResume();
}

@Override
protected void onPause() {
super.onPause();
lifecyclePresenter.onPause();
}

如此一来,以后有其它的业务逻辑,只需要在LifecyclePresenter 对应的方法里添加即可,达成了给Activity 减负的效果。

黄金选手

虽然Activity 生命周期各个方法里只新增了一行代码,但是考虑到UI 和逻辑的分离,最好是两者不产生耦合。比如在分工的时候,有些同学负责UI,那么他可能就不会关心什么时候开始/结束网络请求,这些由负责具体业务逻辑的同学来编写。该怎么来实现呢?

还记得在分析Activity生命周期时有说过:

Activity 提供了registerActivityLifecycleCallbacks(callback)方法,当Activity生命周期发生变动时就会调用该方法。因此咱们可以在此监听生命周期的变动,然后调用相应的业务代码:

public class LifecycleHelper {
@RequiresApi(api = Build.VERSION_CODES.Q)
public static void bindLifecycle(Activity activity, ILifecycle iLifecycle) {
if (activity == null)
return;
activity.registerActivityLifecycleCallbacks(new Application.ActivityLifecycleCallbacks() {
@Override
public void onActivityResumed(@NonNull Activity activity) {
if (iLifecycle != null)
iLifecycle.onResume();
}

@Override
public void onActivityPaused(@NonNull Activity activity) {
if (iLifecycle != null)
iLifecycle.onPause();
}
});
}
}

传入的Activity 即为想要监听生命周期的Activity。

public class LifecyclePresenterV2 {
@RequiresApi(api = Build.VERSION_CODES.Q)
public LifecyclePresenterV2(Activity activity) {
LifecycleHelper.bindLifecycle(activity, new ILifecycle() {
@Override
public void onResume() {
NetRequest.startRequest();
}

@Override
public void onPause() {
NetRequest.stopRequest();
}
});
}
}

改造Presenter为:LifecyclePresenterV2。

此时,Activity 里只需要调用:

//this 表示当前需要监听的Activity
LifecyclePresenterV2 lifecyclePresenterV2 = new LifecyclePresenterV2(this);

可以看出:


Activity 里无需再重写各个生命周期的回调方法,仅仅只需要一行代码,即可将这些逻辑放到单独的业务层处理,生命周期和具体业务绑定,看业务的需求想怎么和生命周期联动就怎么来。


后续若是换了Activity,那么逻辑层的业务也无需变动。

似乎万事大吉了?非也,仔细看registerActivityLifecycleCallbacks()方法调用有版本限制:@RequiresApi(api = Build.VERSION_CODES.Q)

意思就是该API 必须是Android 10(29)以上才能调用,这局限性可大了。

Lifecycle 的引入

从上面的分析我们可以感知到,生命周期和业务的联动场景挺丰富的,也着实需要一套工具来帮助我们简化联动过程。

Google说要有Lifecycle,于是便有了Lifecycle。

开宗明义:Lifecycle 源码并不复杂,主要就是做了三件事:


1、提供给外界监听感兴趣的生命周期里的某个阶段(onResume、onPause、onDestroy等)的接口,外界此时化身为观察者。
2、在某个地方监听Activity生命周期,此时Activity为被观察者。
3、将生命周期告知给观察者。


2、Lifecycle 如何使用?

添加观察者

从Lifecycle 三件事可知,外界想要监听生命周期变化,仅仅只需要添加观察接口,在接口的回调方法里处理对应生命周期即可。

有两种不同的方式:

1、注解方式处理观察结果

Lifecycle 以前的版本为了少重写接口里的方法,使用了注解来简化观察者。

//注解的实现方式
class MyObserver7 implements LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
void onPause() {
Log.d(TAG, "onPause");
}
}

此处只关注onPause,若是还想监测其它状态变化,只需要添加对应状态的注解即可。

而后在Activity 里监听:

protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_lifecycle);

getLifecycle().addObserver(new MyObserver7());
}

当Activity 失去焦点后就会调用MyObserver7里的onPause()方法。

可以看出,在Activity里只需要添加观察者即可。

2、接口方式处理观察结果

Lifecycle 新版本废弃了注解观察方式,使用了接口来代替,若是你使用了Java8或者开启了Java8 特性,建议使用接口方式。

//Java8 方式
class MyObserver8 implements DefaultLifecycleObserver {
@Override
public void onPause(LifecycleOwner owner) {
Log.d(TAG, "pause");
}
}

protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_lifecycle);
getLifecycle().addObserver(new MyObserver8());
}

可以看出,实现了DefaultLifecycleObserver 接口,该接口继承了FullLifecycleObserver 接口。

interface FullLifecycleObserver extends LifecycleObserver {
void onCreate(LifecycleOwner owner);
void onStart(LifecycleOwner owner);
void onResume(LifecycleOwner owner);
void onPause(LifecycleOwner owner);
void onStop(LifecycleOwner owner);
void onDestroy(LifecycleOwner owner);
}

而DefaultLifecycleObserver 接口默认实现了FullLifecycleObserver全部的方法

@Override
default void onCreate(@NonNull LifecycleOwner owner) {
}
....

可以看出使用了Java8 的新特性:default 修饰接口方法。

因此当我们实现了DefaultLifecycleObserver接口时,仅仅只需要重写关注的状态对应的接口即可。

3、Lifecycle 如何感知生命周期

综上所述,通过Lifecycle 可以很方便地感知Activity生命周期的变化,前面部分咱们也是一步步分析该怎么封装生命周期,很遗憾遇到了registerActivityLifecycleCallbacks 版本限制的问题,接下来探究Lifecycle究竟是怎么做到绕开限制的。

第一步:注册观察者

LifecycleRegistry

不管是接口还是注解方式都使用了getLifecycle(),该方法返回Lifecycle 对象,而Lifecycle是抽象类,getLifecycle()返回的是Lifecycle 的子类:LifecycleRegistry 的对象。

#ComponentActivity.java
private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}

当自定义的Activity 继承自AppCompatActivity时,而ComponentActivity 是 AppCompatActivity 的父类,因此自定义的Activity 调用getLifecycle()时返回的即是mLifecycleRegistry 对象。

而LifecycleRegistry里的mLifecycleOwner对象即是自定义的Activity 本身(弱引用)。

addObserver()

#LifecycleRegistry.java
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
Lifecycle.State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
//传入observer,构造ObserverWithState
LifecycleRegistry.ObserverWithState statefulObserver = new LifecycleRegistry.ObserverWithState(observer, initialState);
//将ObserverWithState 加入到map 里
LifecycleRegistry.ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
...
}

关键之处在于ObserverWithState:

#LifecycleRegistry.java
static class ObserverWithState {
//生命周期状态
Lifecycle.State mState;
//观察者
LifecycleEventObserver mLifecycleObserver;

ObserverWithState(LifecycleObserver observer, Lifecycle.State initialState) {
//封装观察者
mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
mState = initialState;
}

void dispatchEvent(LifecycleOwner owner, Lifecycle.Event event) {
//分发事件,将event转为state
Lifecycle.State newState = event.getTargetState();
mState = min(mState, newState);
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}

再看Lifecycling.lifecycleEventObserver:

#Lifecycling.java
static LifecycleEventObserver lifecycleEventObserver(Object object) {
//接口方式
boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
...
if (isFullLifecycleObserver) {
//如果观察者是接口方式,直接返回
return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
}

//处理注解,将注解记录下来,下次直接从map里取
final Class<?> klass = object.getClass();
int type = getObserverConstructorType(klass);
...
return new ReflectiveGenericLifecycleObserver(object);
}


addObserver()的重点是将Observer经过一些列封装后添加到Map里。


明显地我们会想到:当生命周期变更后,将会从Map里取出观察者,并通知它。

第二步:生命周期变更-通知观察者

Android10(含) 以上处理方式

了解Lifecycle 如何通知观察者,最好的方法莫过于通过断点查看其调用堆栈。

以接口处理方式为例,当观察者被调用时,其调用栈如下:

Jetpack Lifecycle 该怎么看?_移动开发

注意到Activity. dispatchActivityPostStarted()方法:

#Activity.java
private void dispatchActivityPostStarted() {
//找到监听者
Object[] callbacks = collectActivityLifecycleCallbacks();
if (callbacks != null) {
for (int i = 0; i < callbacks.length; i++) {
//调用回调方法
((Application.ActivityLifecycleCallbacks) callbacks[i])
.onActivityPostStarted(this);
}
}
...
}

而此处的监听者即为通过Activity.registerActivityLifecycleCallbacks(callback)注册的。 而callback 即为:ReportFragment.LifecycleCallbacks 对象,该对象的注册在:

#ReportFragment.java
public static void injectIfNeededIn(Activity activity) {
if (Build.VERSION.SDK_INT >= 29) {
//如果是Android10以上,则直接注册ActivityLifecycleCallbacks
ReportFragment.LifecycleCallbacks.registerIn(activity);
}
//将一个空的Fragment添加到Activity里
android.app.FragmentManager manager = activity.getFragmentManager();
if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
// Hopefully, we are the first to make a transaction.
manager.executePendingTransactions();
}
}

而injectIfNeededIn的调用时机是在Activity.onCreate()里。

好了,现在我们已经了解了:


在Activity 创建时,通过ReportFragment 监听Activity 状态变化。


而ReportFragment 依据系统版本的不同,分两种监听方式:


1、在Android 10以上(含)的设备是通过registerActivityLifecycleCallbacks()监听的。
2、在Android 10以下是通过Fragment 监听的。


行文至此,Lifecycle仅仅只是监听了Activity 的状态,还需要将状态分发下去。

还是以Android10处理方式为例:

#ReportFragment.java
static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
...
if (activity instanceof LifecycleOwner) {
//获取Lifecycle,也即是LifecycleRegistry
Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
if (lifecycle instanceof LifecycleRegistry) {
//分发事件
((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
}
}
}

最终事件还是交由LifecycleRegistry 处理,而LifecycleRegistry 里依据Event和State 转换,最后从Map 里找到对应的封装Observer,最终通知Activity里注册的observer,至此就完成了一次生命周期状态变化的通知。

Android 10以下处理方式

我们知道,当Fragment关联上Activity时,那么它的生命周期就与Activity 联动了。

因此当Activity 生命周期变化时,会调用Fragment某个方法,以onStart()状态为例:

#ReportFragment.java
@Override
public void onStart() {
super.onStart();
dispatchStart(mProcessListener);
//分发事件
dispatch(Lifecycle.Event.ON_START);
}

private void dispatch(@NonNull Lifecycle.Event event) {
if (Build.VERSION.SDK_INT < 29) {
//Android 10 以下才处理
dispatch(getActivity(), event);
}
}


此时,我们知道了Lifecycle 如何处理registerActivityLifecycleCallbacks()版本限制问题:即是通过ReportFragment 对上层调用者屏蔽监听Activity生命周期变化的细节。在Android 10(含)以上使用registerActivityLifecycleCallbacks(),在其之下使用空的Fragment 添加到Activity。


Lifecycle 感知生命周期总结

用图表示如下:

Jetpack Lifecycle 该怎么看?_android_02

绿色部分:


Lifecycle 监听Activity生命周期变化。


蓝色部分:


外界通过Lifecycle 注册观察者。


红色部分:


Lifecycle 监听到生命周期发生变化,通知观察者。


4、Lifecycle 内存泄漏?

在Activity(假设自定义为LifeActivity) onCreate()里添加如下代码,监测Activity 生命周期:

getLifecycle().addObserver(new DefaultLifecycleObserver() {
@Override
public void onCreate(@NonNull @org.jetbrains.annotations.NotNull LifecycleOwner owner) {

}
});

问题来了:​是否需要在Activity.onDestroy()里移除观察者呢?

我们知道,匿名内部类持有外部类引用,addObserver(xx),这个xx 对象持有了Activity,通常来说看到这样的写法我们立马就关联到了:若是xx没有被释放,那么当Activity 销毁时,Activity 对象是无法被释放的,因为它被xx持有。

因此大部分时候我们需要在Activity.onDestroy() 里removeObserver(xx)。

接着来看看getLifecycle().addObserver(xx)此种情况是否需要主动移除observer。问题的关键是xx被谁持有了。

通过前面的分析可知,xx 被封装为ObserverWithState 对象,最后存储到Map里。而这个Map为:

#LifecycleRegistry.java
private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =
new FastSafeIterableMap<>();

它是LifecycleRegistry 的成员变量,而LifecycleRegistry 对象是ComponentActivity 的成员变量,最终结果:Map 是LifeActivity 的成员变量。

当Activity 销毁时,Map将会被销毁,而Map 将不会再持有Observer。

因此,得出的结论是:


无需调用getLifecycle().removeObserver(observer);


内存泄漏的本质是:​长生命周期的对象持有短生命周期对象的引用,导致短生命周期对象无法释放。

5、总结

本篇文章并没有将侧重点放在Lifecycle.State 与Lifecycle.Event 之间的转换,而是着眼于为什么需要Lifecycle以及Lifecycle 如何感知生命周期,希望能够自然而然地引入Lifecycle,并了解其设计原理。

Lifecycle 是LiveData的基础,接下来将会分析LiveData的妙用。