Lifecycle是一个持有组件生命周期状态信息的类,并且允许其他对象观察该状态.
本文基于 Lifecycle 2.0.0版本，Android API 28.
首先我们先看一下如何使用Lifecycle实现生命周期的监听.
基础用法
public class HippoX implements LifecycleObserver {
private static final String TAG_LOG = "HippoX";
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
public void init() {
Log.e(TAG_LOG, "init exec");
}
}
public class MainActivity extends AppCompatActivity {
private static final String TAG_LOG = "HippoX";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
getLifecycle().addObserver(new HippoX());
}
@Override
protected void onResume() {
super.onResume();
Log.e(TAG_LOG, "onResumes execute");
}
}
Logcat日志:
E/HippoX: onResumes execute
E/HippoX: init exec
日志打印结果表明上述代码确实实现了观察生命周期的功能.
别问我为啥这样就监听成功了,往下看.
生命周期事件及状态
Lifecycle使用两个主要枚举来跟踪其关联组件的生命周期状态.
- Event 描述从框架和Lifecycle类中派发的生命周期事件.
- State 描述Lifecycle对象跟踪的组件的当前状态.
Lifecycle.Event
public enum Event {
ON_CREATE, //用于匹配生命周期所有者的onCreate事件.
ON_START, //用于匹配生命周期所有者的onStart事件.
ON_RESUME, //用于匹配生命周期所有者的onResume事件.
ON_PAUSE, //用于匹配生命周期所有者的onCreate事件.
ON_STOP, //用于匹配生命周期所有者的onStop事件.
ON_DESTROY, //用于匹配生命周期所有者的onDestroy事件.
ON_ANY //用于匹配生命周期所有者的所有事件.
}
Lifecycle.State
public enum State {
DESTROYED, //表示生命周期所有者创建的状态.对于Activity来说,在onCreate执行之后,onStop执行之前.
INITIALIZED, //表示生命周期所有者销毁的状态.
CREATED, //表示生命周期所有者初始化的状态.
STARTED, //表示生命周期所有者恢复的状态.
RESUMED; //表示生命周期所有者启动的状态.
public boolean isAtLeast(@NonNull State state) { //比较此状态是否大于或等于给定状态
return compareTo(state) >= 0;
}
}
Event与State的关系
lifecycle-states.png
生命周期所有者和观察者
LifecycleOwner 生命周期所有者
public interface LifecycleOwner {
@NonNull
Lifecycle getLifecycle(); //返回lifecycle
}
官方文档的描述是持有Android生命周期的类,通过实现该类可以在非Activity和Fragment中来处理生命周期事件.
注:Activity和Fragment都实现了该接口,并提供
LifecycleObserver 生命周期观察者
public interface LifecycleObserver {
}
官方文档的描述是将实现该接口的类标记为生命周期观察者,且依赖于通过OnLifecycleEvent注解实现的方法.
先了解到这里,我们开始正式的分析lifecycle是如何实现生命周期的监听的.
Activity和Fragment的实现过程基本相同,我们在这里就分析Activity.
首先我们由MainActivity的getLifecycle()方法往里跟,最终找到他的父父父类ComponentActivity实现了LifecycleOwner接口.
public class ComponentActivity extends Activity
implements LifecycleOwner, KeyEventDispatcher.Component {
private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
...
@Override
@SuppressWarnings("RestrictedApi")
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
ReportFragment.injectIfNeededIn(this);
}
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
}
其中比较重要的是LifecycleRegistry类和ReportFragment.我们再来继续分析.
LifecycleRegistry
LifecycleRegistry是Lifecycle的实现类,能够管理多个生命周期观察者.
提供的主要方法如下:
- void addObserver(LifecycleObserver observer) 添加一个生命周期观察者(下文简称观察者),当生命周期所有者状态改变时将会进行通知.
- Lifecycle.State getCurrentState() 获取生命周期的当前状态.
- int getObserverCount() 返回观察者的个数.
- void handleLifecycleEvent(Lifecycle.Event event) 设置当前状态并通知观察者.
- void removeObserver(LifecycleObserver observer) 从观察者列表中移除指定的观察者.
- void setCurrentState(Lifecycle.State state) 设置生命周期为指定的状态,并将事件分派给观察者.
ReportFragment
public class ReportFragment extends Fragment {
private static final String REPORT_FRAGMENT_TAG = "androidx.lifecycle"
+ ".LifecycleDispatcher.report_fragment_tag";
public static void injectIfNeededIn(Activity activity) {
// ProcessLifecycleOwner should always correctly work and some activities may not extend
// FragmentActivity from support lib, so we use framework fragments for activities
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();
}
}
static ReportFragment get(Activity activity) {
return (ReportFragment) activity.getFragmentManager().findFragmentByTag(
REPORT_FRAGMENT_TAG);
}
...
@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
dispatchCreate(mProcessListener);
dispatch(Lifecycle.Event.ON_CREATE);
}
@Override
public void onStart() {
super.onStart();
dispatchStart(mProcessListener);
dispatch(Lifecycle.Event.ON_START);
}
@Override
public void onResume() {
super.onResume();
dispatchResume(mProcessListener);
dispatch(Lifecycle.Event.ON_RESUME);
}
@Override
public void onPause() {
super.onPause();
dispatch(Lifecycle.Event.ON_PAUSE);
}
@Override
public void onStop() {
super.onStop();
dispatch(Lifecycle.Event.ON_STOP);
}
@Override
public void onDestroy() {
super.onDestroy();
dispatch(Lifecycle.Event.ON_DESTROY);
// just want to be sure that we won't leak reference to an activity
mProcessListener = null;
}
private void dispatch(Lifecycle.Event event) {
Activity activity = getActivity();
if (activity instanceof LifecycleRegistryOwner) {
((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
return;
}
if (activity instanceof LifecycleOwner) {
Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
if (lifecycle instanceof LifecycleRegistry) {
((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
}
}
}
...
}
查看源码可以发现,lifecycle是通过ReportFragment来实现生命周期的监听的,重写了生命周期的回调方法,在生命周期回调方法的内部调用dispatch的方法来派发生命周期事件.并且ComponentActivity的onCreate方法中通过injectIfNeededIn方法进行了注入.到这儿我们就已经清楚了Lifecycle实现生命周期的具体方式以及基本使用方式.
如果本文帮助到你了,麻烦您点个喜欢,如有错误欢迎指正,下篇文章将会怼Lifecycle进阶进行分析.
网友评论