Lifecycle是什么
简单来说，Lifecycle是官方提供以方便管理声明周期事件的方式，给Activity、Fragment减肥。能把他们之中在生命周期变动时，需要做的各类事件抽离出来，集中到我们想的地方进行管理。
准备
添加依赖
dependencies {
.....
// 低版本SDK是compile
implementation 'android.arch.lifecycle:extensions:1.1.1'
annotationProcessor "android.arch.lifecycle:compiler:1.1.1"
.....
}
添加仓库 （非必须，有些环境需要）
buildscript {
repositories {
....
// 官方提供，会被墙
maven { url 'https://maven.google.com' }
// 不能翻墙用这个
maven { url 'https://dl.google.com/dl/android/maven2' }
....
}
}
案例
public class MyLife implements LifecycleObserver {
private static final String TAG = "T-MyLife";
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
void A(){
Log.d(TAG, "create");
}
@OnLifecycleEvent(Lifecycle.Event.ON_START)
void B(){
Log.d(TAG, "onStart");
}
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
void C(){
Log.d(TAG, "onResume");
}
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
void D(){
Log.d(TAG, "Pause");
}
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
void E(){
Log.d(TAG, "onStop");
}
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
void F(){
Log.d(TAG, "destroy");
}
@OnLifecycleEvent(Lifecycle.Event.ON_ANY)
void G(){
Log.d(TAG, "Any");
}
}
在Activity里进行注册
MyLife life;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_b);
life = new MyLife();
getLifecycle().addObserver(life);
}
日志，如下图
从日志中能看到，各生命周期变动时相应的被标示的函数都获得了执行机会，并且ANY在任意生命周期变动时都会被执行。
注册过程
Marks a class as a LifecycleObserver. It does not have any methods, instead, relies on
{@link OnLifecycleEvent} annotated methods.
大意是令该类成为生命周期观察者，无需实现任何方法，周期事件的触发依赖于@OnLifecycleEvent注解
首先，要监听使命周期必须要实现LifecycleObserver以做观察者标识，其中没有任何方法，通过源码注解可以看到。
getLifecycle().addObserver(life);
观察者通过以上代码进行注册
当前位置
LifecycleRegistry.addObserver()
// 初始化状态
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
// 装配观察者信息
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
// 保存信息
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
这里可以先了解一下State，代码入下
// 以下所说调用方法均指android.app.Activity
public enum State {
//此状态下，Lifecycle不会分发任何事件
DESTROYED,
//此状态下，说明走到onCreate()
INITIALIZED,
//此状态下，说明走到onCreate()之后，或onStop()之前
CREATED,
//此状态下，说明走到onStart()之后，或onPause()之前
STARTED,
//此状态下，说明走到onResume()之后
RESUMED;
}
简单来说，State用来标示被观察者所处于的生命状态
观察者信息的装配
当前位置 ObserverWithState
构造函数
public ObserverWithState(LifecycleObserver observer, State initialState) {
// 装配观察者，获取回调对象
mLifecycleObserver = Lifecycling.getCallback(observer);
mState = initialState;
}
不解释
当前位置
LifecycleRegistry.addObserver()
-- ObserverWithState()
-- Lifecycling.getCallback()
代码如下图
从代码上看，getCallback()主要通过反射并根据type以及Constructor对象的具体情况返回了不同的GenericLifecycleObserver(通过搜索能看到的实现类有5个，自行验证)对象。这里要注意，用来做判断的Constructor，并不是从我们传来的object对象也就是MyLife提取的，而是通过加工MyLife生成了一个新的类——MyLife_LifecycleAdapter，然后进行提取。不难发现，这一切是在getObserverConstructorType()里完成的。
这里就要问，为什么要构成新的类，具体情况如何
当前位置
Lifecycling.getCallback()
-- getObserverConstructorType()
-- resolveObserverCallbackTyp()
-- generatedConstructor()
可见，generatedConstructor()构造出了即将会被放在MyLife同路径下的类MyLife_LifecycleAdapter的构造信息
当前位置
Lifecycling.getCallback()
-- getObserverConstructorType()
-- resolveObserverCallbackTyp()
private static int resolveObserverCallbackType(Class<?> klass) {
....
Constructor<? extends GeneratedAdapter> constructor = generatedConstructor(klass);
if (constructor != null) {
sClassToAdapters.put(klass, Collections
.<Constructor<? extends GeneratedAdapter>>singletonList(constructor));
// 此例中运行到此
return GENERATED_CALLBACK;
}
....
}
MyLife_LifecycleAdapter的构造信息被保存到了sClassToAdapters中，并在此函数中将type=GENERATED_CALLBACK信息传回getCallback()
在当前节点MyLife_LifecycleAdapter还没有被构造出来，不难猜测在其他节点会被构造，在这里忽略跟踪这个过程，直接看一眼MyLife_LifecycleAdapter具体情况
public class MyLife_LifecycleAdapter implements GeneratedAdapter {
final MyLife mReceiver;
MyLife_LifecycleAdapter(MyLife receiver) {
this.mReceiver = receiver;
}
@Override
public void callMethods(LifecycleOwner owner, Lifecycle.Event event, boolean onAny,
MethodCallsLogger logger) {
boolean hasLogger = logger != null;
if (onAny) {
if (!hasLogger || logger.approveCall("G", 1)) {
mReceiver.G();
}
return;
}
if (event == Lifecycle.Event.ON_CREATE) {
if (!hasLogger || logger.approveCall("A", 1)) {
mReceiver.A();
}
return;
}
if (event == Lifecycle.Event.ON_START) {
if (!hasLogger || logger.approveCall("B", 1)) {
mReceiver.B();
}
return;
}
if (event == Lifecycle.Event.ON_RESUME) {
if (!hasLogger || logger.approveCall("C", 1)) {
mReceiver.C();
}
return;
}
if (event == Lifecycle.Event.ON_PAUSE) {
if (!hasLogger || logger.approveCall("D", 1)) {
mReceiver.D();
}
return;
}
if (event == Lifecycle.Event.ON_STOP) {
if (!hasLogger || logger.approveCall("E", 1)) {
mReceiver.E();
}
return;
}
if (event == Lifecycle.Event.ON_DESTROY) {
if (!hasLogger || logger.approveCall("F", 1)) {
mReceiver.F();
}
return;
}
}
}
仅有方法callMethods()，以及我们的观察者MyLife的实例。以上代码告知信息如下
-Lifecycle框架为我们适配了MyLife，以符合使用标准，实际是会通过适配类去触发调用此例中的的生命周期观察者MyLife
-被@OnLifecycleEvent的函数最终被解析如生成的适配类中，并根据Event情况触发
插播一下Event
public enum Event {
ON_CREATE,
ON_START,
ON_RESUME,
ON_PAUSE,
ON_STOP,
ON_DESTROY,
ON_ANY
}
用来标示观察者相应生命周期触发的事件，并据此被分配在生成的适配类中的相应位置
回到getCallback()
在我们的例子中，返回的是SingleGeneratedAdapterObserver，以下为完整代码
public class SingleGeneratedAdapterObserver implements GenericLifecycleObserver {
private final GeneratedAdapter mGeneratedAdapter;
SingleGeneratedAdapterObserver(GeneratedAdapter generatedAdapter) {
mGeneratedAdapter = generatedAdapter;
}
@Override
public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
mGeneratedAdapter.callMethods(source, event, false, null);
mGeneratedAdapter.callMethods(source, event, true, null);
}
}
可见，生成的适配类的实例被保存了下来。其他的GenericLifecycleObserver与此类似持有此信息
到这里，整个注册完毕，流程如下：
- 调用LifecycleRegistry.addObserver()进行注册
- ObserverWithState负责存储装配的信息
- 初始化State
- Lifecycling.getCallback()根据观察者情况生成了适配类，信息被GenericLifecycleObserver持有，且GenericLifecycleObserver被ObserverWithState持有
- 观察者于ObserverWithState绑定
触发阶段
public class SupportActivity extends Activity implements LifecycleOwner{
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// 注入
ReportFragment.injectIfNeededIn(this);
}
}
ReportFragment会被注入到SupportActivity中，在声明周期发生变更时，作为Fragment，ReportFragment会接收到讯息
ReportFragment部分代码
@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) {
// 也就是SupportActivity
Activity activity = getActivity();
if (activity instanceof LifecycleRegistryOwner) {
((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
return;
}
if (activity instanceof LifecycleOwner) {
// 也就是LifecycleRegistry
Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
if (lifecycle instanceof LifecycleRegistry) {
((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
}
}
}
在触发此Fragment的生命周期时，所有事件都会通过dispatch()触发，最终交由LifecycleRegistry处理
当前位置
LifecycleRegistry.handleLifecycleEvent()
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
// 获取状态
State next = getStateAfter(event);
// 执行事件，并更新状态
moveToState(next);
}
当前位置
LifecycleRegistry. moveToState()
-sync()
private void sync() {
// 也就是SupportActiviy
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
if (lifecycleOwner == null) {
Log.w(LOG_TAG, "LifecycleOwner is garbage collected, you shouldn't try dispatch "
+ "new events from it.");
return;
}
while (!isSynced()) {
mNewEventOccurred = false;
// no need to check eldest for nullability, because isSynced does it for us.
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);
}
}
mNewEventOccurred = false;
}
主要看backwardPass(lifecycleOwner)和forwardPass(lifecycleOwner)，代码类似，择其一
private void backwardPass(LifecycleOwner lifecycleOwner) {
Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
mObserverMap.descendingIterator();
while (descendingIterator.hasNext() && !mNewEventOccurred) {
Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
// 获取到每一个注册时根据观察者装配的信息ObserverWithState
ObserverWithState observer = entry.getValue();
while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
&& mObserverMap.contains(entry.getKey()))) {
// 更新Event状态
Event event = downEvent(observer.mState);
pushParentState(getStateAfter(event));
// 分发事件
observer.dispatchEvent(lifecycleOwner, event);
popParentState();
}
}
}
直接看事件分发
当前位置
ObserverWithState.dispatchEvent()
void dispatchEvent(LifecycleOwner owner, Event event) {
State newState = getStateAfter(event);
// 状态校准
mState = min(mState, newState);
// mLifecycleObserver在本例中是SingleGeneratedAdapterObserver,在观察者注册也就是LifecycleRegistry.addObserver时获得
mLifecycleObserver.onStateChanged(owner, event);
// 更新状态
mState = newState;
}
回看SingleGeneratedAdapterObserver
@Override
public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
mGeneratedAdapter.callMethods(source, event, false, null);
mGeneratedAdapter.callMethods(source, event, true, null);
}
}
mGeneratedAdapter是在ObserverWithState初始化时Lifecycling.getCallback()根据观察者生成的适配类MyLife_LifecycleAdapter，最后观察者的相应事件得以触发(MyLife_LifecycleAdapter的代码就不贴了，可以回去看)
其他
public interface GenericLifecycleObserver extends LifecycleObserver {
/**
* Called when a state transition event happens.
*
* @param source The source of the event
* @param event The event
*/
void onStateChanged(LifecycleOwner source, Lifecycle.Event event);
}
在这里注意一下，其实GenericLifecycleObserver也是一个LifecycleObserver，只不过是在职责上与真正的观察者有所别。GenericLifecycleObserver主要还是作为中转，对事件做一些自己的处理，才继续将事件传下去。实际上，完全可以通过实现GenericLifecycleObserver作为观察者去直接对Event自行处理，注册方法不变。从Lifecycling.getCallback()能看到，如果观察者属于GenericLifecycleObserver，是不会生成适配类的，就直接交由观察者自行处理了。这里就不实现了。
生命周期观察者事件触发总结
- 注册时生成适配类
- SupportActivity负责注入ReportFragment
- ReportFragment获得周期事件时，通过SupportActivity、LifecycleRegistry、ObserverWithState层层通知，最终告知生成的适配类：“是时候表演真正的技术了”
- 观察者事件被触发
简单原理图（观察者不为GenericLifecycleObserver）
元素职责标示
整个分析过程中涉及到的类和接口如下：
SupportActivity ：持有LifecycleRegistry并负责注入ReportFragment
LifecycleOwner ：标示被观察者
ReportFragment : 传递生命周期事件讯息，为出发点
LifecycleRegistry : 持有观察者、被观察者等信息
Event : 标示观察者事件触发时机
ObserverWithState : 持有state和适配类的信息
Lifecycing : 适配观察者，生成适配类，获取合适的GenericLifecycleObserver
GeneratedAdapter: 标示适配类，以供调用
GenericLifecycleObserver ：传递生命周期事件讯息，中转点
State : 标示被观察者生命周期阶段
