一、概念
Lifecycle是JetPack提供的生命周期感知型组件。这也是JetPack系列架构的一个主要基础组件。LiveData、ViewModel都与之相关。
Lifecycle常用于感知Activity、Fragment的生命周期。通过它可以编写与生命周期相关的解耦的代码。将Lifecycle传入某个类中，可以让该类与外部组件的生命周期关联。
二、使用示例
2-0：添加依赖
参照官网提示，添加具体依赖（点击查看）
2-1：定义一个观察者
//定义一个观察者
public class MyObserver implements LifecycleObserver {
private static final String TAG = "MyObserver";
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
public void whenOnCreated(){
Log.d(TAG, "生命周期OnCreated");
}
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
public void whenOnResumed(){
Log.d(TAG, "生命周期OnResumed");
}
}2-2：在Activity的onCreate中添加观察者
//添加观察者
getLifecycle().addObserver(new MyObserver());以上操作后，自定义的观察者MyObserver即可在activity的生命周期变换时，感知具体变换，并打印日志。
三、Lifecycle相关类
Lifecycle的机制，本质上是观察者模式，包含被观察者LifecycleOwner，观察者LifecycleObserver。
（1）LifecycleObserver:是一个空方法接口，用于标识观察者。
（2）LifecycleOwner: 是一个接口，持有方法Lifecycle getLifecycle()。
2-1：Lifecycle 是一个抽象类，该类含有addObserver、removeObserver等方法，以及生命周期的定义。
2-2：LifecycleRegistry 是Lifecycle的具体实现类，含有mObserverMap这样存储LifecycleObserver的集合。
四、源码分析
以前面的示例为例，在Activity中为何可以直接使用getLifecycle()方法并添加观察者-addObserver。
4-1：被观察者的定义与实现
ComponentActivity实现了LifecycleOwner接口以及该接口下的getLifecycle()方法。
//（1）ComponentActivity 实现LifecycleOwner接口
public class ComponentActivity extends Activity implements LifecycleOwner ...
//（2）getLifecycle()方法实现，返回Lifecycle类型对象
@NonNull
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
//--------以下备注mLifecycleRegistry的实现------------
//（3）中的mLifecycleRegistry实例。其中LifecycleRegistry的构造方法，传入了ComponentActivity的
// 实例（也即是LifecycleOwner的实例）
private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
//（4）构造参数中传入的LifecycleOwner对象，会用于生命周期变动时的通知。
public class LifecycleRegistry extends Lifecycle {
....
public LifecycleRegistry(@NonNull LifecycleOwner provider) {
mLifecycleOwner = new WeakReference<>(provider);
mState = INITIALIZED;
}
...
}假设前面创建的Activity名为MainActivity。因MainActivity都是默认继承AppCompatActivity，而AppCompatActivity继承至ComponentActivity。则MainActivity默认实现了LifecycleOwner接口，是一个被观察者对象。
4-2：观察者的添加
此时通过getLifecycle().addObserver(new MyObserver());添加具体观察者对象，内部流程如下：
在4-1中，有说明getLifecycle()的具体实现，返回了Lifecycle的实现对象mLifecycleRegistry。因此，getLifecycle().addObserver实际会在mLifecycleRegistry中，进行添加观察者。
//mObserverMap 是LifecycleRegistry中定义的一个Map集合，用于存储观察者
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
....
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
....
}至此，被观察者与观察者已被定义与添加完成。具体什么时候触发观察者的回调？见4-3
4-3：观察者回调触发时机
还是接着看ComponentActivity的onCreate方法。
//(1)ComponentActivity的onCreate中，ReportFragment.injectIfNeededIn(this)。将本activity的实
//例传入到了ReportFragment中
public class ComponentActivity extends Activity implements
LifecycleOwner,
KeyEventDispatcher.Component {
....
@SuppressLint("RestrictedApi")
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
//此处是重点。
ReportFragment.injectIfNeededIn(this);
}
....
}
//(2)injectIfNeededIn该方法是ReportFragment中的静态方法
public class ReportFragment extends Fragment {
public static void injectIfNeededIn(Activity activity) {
//此处创建了一个新的Fragment（ReportFragment）
//如果FragmentManager中已有该Fragment，则不会重复创建
// use a framework fragment to get the correct timing of Lifecycle events
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();
}
}
}
//（3）因ReportFragment绑定了ComponentActivity。ReportFragment的生命周期可通过下面方式对外通知
@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
//onCreate事件
dispatch(Lifecycle.Event.ON_CREATE);
}
@Override
public void onStart() {
super.onStart();
//onStart事件
dispatch(Lifecycle.Event.ON_START);
}
@Override
public void onResume() {
super.onResume();
//onResume事件
dispatch(Lifecycle.Event.ON_RESUME);
}
@Override
public void onPause() {
//onPause事件
dispatch(Lifecycle.Event.ON_PAUSE);
}
@Override
public void onStop() {
//onStop事件
dispatch(Lifecycle.Event.ON_STOP);
}
@Override
public void onDestroy() {
super.onDestroy();
//onDestroy事件
dispatch(Lifecycle.Event.ON_DESTROY);
// just want to be sure that we won't leak reference to an activity
mProcessListener = null;
}
//（4）dispatch的具体实现如下
private void dispatch(@NonNull Lifecycle.Event event) {
if (Build.VERSION.SDK_INT < 29) {
//该注释说明以上路线只针对SDK_INT < 29的情况，大于29的情况，会从另一条路线走，暂不
//分析，原理类似
// Only dispatch events from ReportFragment on API levels prior
// to API 29. On API 29+, this is handled by the ActivityLifecycleCallbacks
// added in ReportFragment.injectIfNeededIn
dispatch(getActivity(), event);
}
}
//(5)dispatch(getActivity(), event)具体内容
static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
...
//此时会走到该逻辑
if (activity instanceof LifecycleOwner) {
Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
if (lifecycle instanceof LifecycleRegistry) {
//最终还是会到LifecycleRegistry中，执行handleLifecycleEvent方法
((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
}
}
}
//（6）LifecycleRegistry中handleLifecycleEvent
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
//获取下一步状态
State next = getStateAfter(event);
//移动至下一步
moveToState(next);
}
private void moveToState(State next) {
if (mState == next) {
return;
}
mState = next;
if (mHandlingEvent || mAddingObserverCounter != 0) {
mNewEventOccurred = true;
// we will figure out what to do on upper level.
return;
}
mHandlingEvent = true;
//同步观察者与被观察者
sync();
mHandlingEvent = false;
}
static State getStateAfter(Event event) {
switch (event) {
case ON_CREATE:
case ON_STOP:
return CREATED;
case ON_START:
case ON_PAUSE:
return STARTED;
case ON_RESUME:
return RESUMED;
case ON_DESTROY:
return DESTROYED;
case ON_ANY:
break;
}
throw new IllegalArgumentException("Unexpected event value " + event);
}
//（7）同步观察者与被观察者sync()
private void sync() {
while (!isSynced()) {
if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
//后退
backwardPass(lifecycleOwner);
}
Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
if (!mNewEventOccurred && newest != null
&& mState.compareTo(newest.getValue().mState) > 0) {
//前进
forwardPass(lifecycleOwner);
}
}
}
//(8)无论是backwardPass或者forwardPass方法，最终都调用：observer.dispatchEvent(...),用于回调
// 观察者
observer.dispatchEvent(lifecycleOwner, event);
//以上的observer是经过ObserverWithState封装的，是ObserverWithState中LifecycleEventObserver的
//实例。
static class ObserverWithState {
State mState;
LifecycleEventObserver mLifecycleObserver;
ObserverWithState(LifecycleObserver observer, State initialState) {
mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
mState = initialState;
}
void dispatchEvent(LifecycleOwner owner, Event event) {
State newState = getStateAfter(event);
mState = min(mState, newState);
//最终触发观察者回调的地方
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}
//（9）-----------以下备注（8）中LifecycleEventObserver对象mLifecycleObserver的定义----------
9-1：mLifecycleObserver实例
mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
9-2：lifecycleEventObserver(Object object)
static LifecycleEventObserver lifecycleEventObserver(Object object) {
boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
if (isLifecycleEventObserver && isFullLifecycleObserver) {
return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
(LifecycleEventObserver) object);
}
....
}
9-3:FullLifecycleObserverAdapter
class FullLifecycleObserverAdapter implements LifecycleEventObserver {
private final FullLifecycleObserver mFullLifecycleObserver;
private final LifecycleEventObserver mLifecycleEventObserver;
FullLifecycleObserverAdapter(FullLifecycleObserver fullLifecycleObserver,
LifecycleEventObserver lifecycleEventObserver) {
mFullLifecycleObserver = fullLifecycleObserver;
mLifecycleEventObserver = lifecycleEventObserver;
}
@Override
public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
....
//回调onStateChanged
if (mLifecycleEventObserver != null) {
mLifecycleEventObserver.onStateChanged(source, event);
}
}
}
以上是Lifecycle的源码流程梳理。
Lifecycle做为一个android提供的生命周期组件，除了以上介绍的用法外，还可以用于传入你需要生命周期的自定义组件中。管理组件的资源释放、数据处理、UI是否刷新等，有助于整体的稳定性、减少内存泄漏、代码简洁化等。