public class ComponentActivity extends androidx.core.app.ComponentActivity implements
LifecycleOwner,
ViewModelStoreOwner,
SavedStateRegistryOwner {
}
可以看到实现了 LifeCycleOwner 接口。
// 只有一个方法, 返回 保存有 Android 生命周期事件的 Lifecycle。
public interface LifecycleOwner {
/**
* Returns the Lifecycle of the provider.
*
* @return The lifecycle of the provider.
*/
@NonNull
Lifecycle getLifecycle();
}
// LifeCycle
public abstract class Lifecycle {
// 对 生命周期对象进行观察
@MainThread
public abstract void addObserver(@NonNull LifecycleObserver observer);
public abstract void removeObserver(@NonNull LifecycleObserver observer);
// 获得当前生命周期事件对应的状态
@MainThread
@NonNull
public abstract State getCurrentState();
// LifecycleOwner 对应的生命周期事件
public enum Event {
ON_CREATE,
ON_START,
ON_RESUME,
ON_PAUSE,
ON_STOP,
ON_DESTROY,
ON_ANY
}
// 上述事件分别对应的状态
public
enum State {
// 销毁状态,之后 LifeCycle 不再分发事件。在 Activity onDestory() 结束之后
DESTROYED,
// 初始状态:在 Actiivty 创建成功,onCreate() 方法调用之前
INITIALIZED,
// 创建状态,在 onCreate() 之后,onStop() 调用之前
CREATED,
// 开始状态:在 onStart() 之后,在 onPause() 之前
STARTED,
// 活跃状态,在 onResume() 之后。
RESUMED;
public boolean isAtLeast(@NonNull State state) {
return compareTo(state) >= 0;
}
}
// 接口,标记一个类能感知生命周期,使用注解 OnLifecycleEvent 调用相关方法。
@SuppressWarnings("WeakerAccess")
public interface LifecycleObserver {
}
在上面的基本类中,对其 LifeCycler 有一个基本的了解。下面开始来一个最简单的 demo。
val TAG = "MainActivity"
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
bindData()
initView()
}
private fun bindData() {
Log.d(TAG, "MainActivity on create, ${lifecycle.currentState}")
lifecycle.addObserver(LifeCycleObject())
}
private fun initView() {
lifecycle
}
override fun onResume() {
super.onResume()
Log.d(TAG, "MainActivity on resume, ${lifecycle.currentState}")
}
}
class LifeCycleObject: LifecycleObserver {
// 添加回调生命周期事件的注解
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
fun onResume() {
Log.d(TAG, "LifeCycleObject on resume")
}
}
运行程序,输入日志如下:
D/MainActivity: MainActivity on create, INITIALIZED
D/MainActivity: MainActivity on resume, STARTED
D/MainActivity: LifeCycleObject on resume
public class ReportFragment extends Fragment {
private static final String REPORT_FRAGMENT_TAG = "androidx.lifecycle"
+ ".LifecycleDispatcher.report_fragment_tag";
// 使用 无页面 Fragment 进行生命周期管理和分发
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();
}
}
...
// onResume 状态
@Override
public void onResume() {
super.onResume();
dispatchResume(mProcessListener);
dispatch(Lifecycle.Event.ON_RESUME);
}
...
// 分发事件
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);
}
}
}
}
AAC: LifeCycle
[TOC]
这篇文章对 Android Architecture Component 中的 LifeCycle 进行源码分析,看其怎么对 Activity 的生命周期进行处理。
LifeCycle 基本认识
这里先从 ComponentActivity 开始看起,作为比较基础的类,google 在推出 AAC 框架时就慢慢对基础类做了修改:
可以看到实现了 LifeCycleOwner 接口。
在上面的基本类中,对其 LifeCycler 有一个基本的了解。下面开始来一个最简单的 demo。
运行程序,输入日志如下:
通过以上程序演示的 LifeCycle 的作用,可以让自定义对象感知生命周期方法。
并调用 OnLifecycleEvent 注解的相关方法。
注意:Debug 查看堆栈是阅读源码手段中最常用最简单最好用最亲民的方法,没有之一,每个人都应该熟练掌握。
下面就从源码角度来分析其是怎么做的。
如何感知生命周期
由于 Activity 中实现了接口,所以这里可以拿到 lifeCycle 对象。
下面是如何对一个对象进行观察:
代码到这里就结束了,下面来看一下当注解的生命周期回调式,堆栈的情况。
在堆栈的调用关系上,可以看到 Zygote 和 ActivityThread 的身影。
在 lifecycle 相关的包下面,看到 ReportFragment 的方法,onResume 和 dipatch。
可以猜测就是这里进行的事件分发。
其中注入方法在两个地方调用。
下面来看一下后一个调用在哪发生。
上述方法使用的 Provider 初始化模块的方法,第三方模块可以利用进行初始化操作
如何调用注解生命周期的方法
在上述的堆栈调用中,在 Fragment 的 onResume 中进行处理。
最终代码来到了分发的地方:
通过反射解析注解得到对应注解的相关信息,最后通过方法的相关信息调用 invoke 实现对注解方法的调用。
我们在 Observer 用注解修饰的方法,会被通过反射的方式获取,并保存下来,然后在生命周期发生改变的时候再找到对应 Event 的方法,通过反射来调用方法。
总结
Lifecycle 是一个专门用来处理生命周期的库,它能够帮助我们将 Acitivity、Framgent 的生命周期处理与业务逻辑处理进行完全解耦,让我们能够更加专注于业务;通过解耦让 Activity、Fragment 的代码更加可读可维护。
可以这么说 Lifecycle 的出现彻底解决了 Android 开发遇到的生命周期处理难题,并且还给开发者带来了新的架构姿势,让我们可以设计出更加合理的架构。