Android Jetpack架构组件之 Lifecycle（源码篇）
一、前言
最近简单看了下google推出的框架Jetpack，感觉此框架的内容可以对平时的开发有很大的帮助，也可以解决很多开发中的问题，对代码的逻辑和UI界面实现深层解耦，打造数据驱动型UI界面。
Android Architecture组件是Android Jetpack的一部分，它们是一组库，旨在帮助开发者设计健壮、可测试和可维护的应用程序，包含一下组件：
- 带你领略Android Jetpack组件的魅力
- Android Jetpack 架构组件之 Lifecycle（使用篇）
- Android Jetpack 架构组件之 Lifecycle（源码篇）
- Android Jetpack 架构组件之 ViewModel （源码篇）
- Android Jetpack 架构组件之 LiveData（使用、源码篇）
- Android Jetpack架构组件之 Paging（使用、源码篇）
- Android Jetpack 架构组件之 Room（使用、源码篇）
- Android Jetpack 架构组件之Navigation
- Android Jetpack架构组件之WorkManger
- 实战：从0搭建Jetpack版的WanAndroid客户端
本文从源码和实现的角度分析一下，LifeCycle是如何实现感知活动生命周期的。
二、源码分析
关于Lifecycle的使用考上一篇文章Android Jetpack框架之 Lifecycles（使用篇），从使用的方法中我们知道Lifecycle的实现主要依赖：LifecycleObserver、LifecycleOwner；通过像Owner注册Observer实现感知Owner的生命周期，下面一起看看源码是如何巧妙设计的；
2.1、生命周期观察者：LifecycleObserver
// 实现LifecycleObserver
class MyObserver(var lifecycle: Lifecycle, var callback: CallBack) : LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
public fun connectOnCreate() {
p("connectOnCreate")
}
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
public fun connectOnResume() {
p("connectOnResume")
}
}
// LifecycleObserver 是一个空接口
public interface LifecycleObserver {
}上面过程做了三件事情：
- 实现LifecycleObserver的接口
- 编写要执行的方法
- 为每个方法添加注解，表示其执行的时机
- @OnLifecycleEvent：运行注解
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface OnLifecycleEvent {
Lifecycle.Event value();
}2.2、生命周期：Lifecycle.Event & State
// 生命周期Event
public enum Event {
/**
* Constant for onCreate event of the {@link LifecycleOwner}.
*/
ON_CREATE,
/**
* Constant for onStart event of the {@link LifecycleOwner}.
*/
ON_START,
/**
* Constant for onResume event of the {@link LifecycleOwner}.
*/
ON_RESUME,
/**
* Constant for onPause event of the {@link LifecycleOwner}.
*/
ON_PAUSE,
/**
* Constant for onStop event of the {@link LifecycleOwner}.
*/
ON_STOP,
/**
* Constant for onDestroy event of the {@link LifecycleOwner}.
*/
ON_DESTROY,
/**
* An {@link Event Event} constant that can be used to match all events.
*/
ON_ANY
}
//5个对应的生命周期状态
public enum State {
DESTROYED,
INITIALIZED,
CREATED,
STARTED,
RESUMED;
public boolean isAtLeast(@NonNull State state) {
return compareTo(state) >= 0;
}
}
通过Lifecycle.Event和State的查看，系统提供了Activity每个生命周期对应的Event，而Event有会有对应的State，此时 以大致猜想到上面的执行过程：
- 使用LifeEvent标记每个执行方法的Event
- 当活动状态改变时，系统会判断即将要改变成的状态
- 根据状态获取要执行的Event
- 从注册的Observer中获取标注为对应的Event，执行逻辑
2.3、生命周期的感知
- LifecycleOwner
class LifeCyclerActivity : AppCompatActivity() {
...
var myObserver = MyObserver(lifecycle, object : CallBack { // 创建LifecyclerObserver
override fun update() {
...
}
})
lifecycle.addObserver(myObserver) // 添加观察者
}
}从上面的使用情况看出，使用的活动需要调用getLifecycle（）方法，返回LifecycleRegistry，这里的getLifecycle（）方法其实是接口LifecycleOwner接口中的方法，
@SuppressWarnings({"WeakerAccess", "unused"})
public interface LifecycleOwner {
/**
* Returns the Lifecycle of the provider.
*
* @return The lifecycle of the provider.
*/
@NonNull
Lifecycle getLifecycle();
}此时LifecycleActivity虽然没有实现接口，因为他继承的AppCompatActivity继承了SupportActivity，而SupportActivity实现了接口
@RestrictTo(LIBRARY_GROUP)
public class SupportActivity extends Activity implements LifecycleOwner {
private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this); //创建
@Override
public Lifecycle getLifecycle() { // 重写方法返回LifecycleRegistry
return mLifecycleRegistry;
}
}SupportActivity除了执行上述操作外，在onCrate的方法中还有一句重要的代码，初始化了一个ReportFragment
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
ReportFragment.injectIfNeededIn(this);
}
- ReportFragment
public class ReportFragment extends Fragment {
private static final String REPORT_FRAGMENT_TAG = "android.arch.lifecycle"
+ ".LifecycleDispatcher.report_fragment_tag";
public static void injectIfNeededIn(Activity activity) { //初始化Fragment
android.app.FragmentManager manager = activity.getFragmentManager();
if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
manager.executePendingTransactions();
}
}
@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);
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);
}
}
}
}上面代码中做了两件事：
- 添加一个ReportFragment的实例
- 根据Fragment的每个生命周期的回调，调用dispatch（）处理回调事件
在dispatch（）方法中根据LifecyclerOwner和LifecyclerRegistryOwner实例分别处理，因为LifecyclerRegistryOwner也是继承LifecyclerOwner，而在我们SupportActivity中的getLifecycler（）中返回的是LifecycleRegistry，所以此处回调的都是LifecycleRegistry的handleLifecycleEvent；
2.4、生命周期处理
- LifecycleRegistry
创建LifecycleRegistry实例
// 对LifecycleOwner使用了弱引用
private final WeakReference mLifecycleOwner;
public LifecycleRegistry(@NonNull LifecycleOwner provider) {
mLifecycleOwner = new WeakReference<>(provider);
// 状态为初始化状态
mState = INITIALIZED;
} 接着上面的执行，我们找到handleLifecycleEvent（）
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
State next = getStateAfter(event);
moveToState(next);
}还记的上面的猜想吗？和此处执行的逻辑完全一致，对于getStateAfter（）和moveToState（），从名字中可以看出他们是执行响应生命周期的地方
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);
}
private void moveToState(State next) {
if (mState == next) {
return;
}
mState = next;
// 当正在sync中处理改变状态时 mHandlingEvent = true
// 当我们调用addObserver时 mAddingObserverCounter ！= 0
// 这两种状态都是正在执行任务的状态，所以此时直接return
if (mHandlingEvent || mAddingObserverCounter != 0) {
mNewEventOccurred = true;
// we will figure out what to do on upper level.
return;
}
mHandlingEvent = true;
sync();
mHandlingEvent = false;
}在getStateAfter中首先根据执行的Lifecycle.Event，判断执行事件后下一个到达的状态，然后使用moveToState（）中的sync（）修改活动的生命周期：
private void sync() {
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;
// 比较的是出现的顺序 如果下一个周期小于当前的周期 即向前back
if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
backwardPass(lifecycleOwner); // 修改集合
}
//获取新的Map的Entry
Entry newest = mObserverMap.newest();
if (!mNewEventOccurred && newest != null
&& mState.compareTo(newest.getValue().mState) > 0) {
forwardPass(lifecycleOwner);
}
}
mNewEventOccurred = false;
} 在sync()方法中除了必要的条件和判断外，主要的逻辑还是生命周期的比较和处理，由前面我们知道Lifecycle.Event和Lifecycle.State的声明顺序是和活动 的声明周期执行顺序一致的，所以对Lifecycle.State的前后顺序的比较也就反应了声明周期状态的变换，比如活动此时的生命周期为Resumed（此时mObserverMap中保存的状态为Resumed），而下一个变换的状态为Started(此时的mState为Started)，从声明周期中可以知道此时执行的时onPause（），对应的LIfecycle.Event为ON_PAUSE，那么上述逻辑中此时执行的是
if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
backwardPass(lifecycleOwner); // 修改集合
}- backwardPass
private void backwardPass(LifecycleOwner lifecycleOwner) {
Iterator> descendingIterator =
mObserverMap.descendingIterator();
while (descendingIterator.hasNext() && !mNewEventOccurred) {
Entry entry = descendingIterator.next();
// 获取当前保存的 ObserverWithState 从中提取状态
ObserverWithState observer = entry.getValue();
while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
&& mObserverMap.contains(entry.getKey()))) {
// 如果保存的状态大于 要变化的状态 向前修改
Event event = downEvent(observer.mState); //查找对应周期变化的事件
pushParentState(getStateAfter(event));
observer.dispatchEvent(lifecycleOwner, event); // 发送事件
popParentState();
}
}
}
在backwardPass（）方法中会将mObserverMap中保存的状态与mState比较，然后调用downEvent（）根据保存的状态找出要执行的Event，并调用Observer的dispatEvent（）方法发送事件，对于downEvent（）还有个与之对应的方法upEvent（）：
private static Event downEvent(State state) {
switch (state) {
case INITIALIZED:
throw new IllegalArgumentException();
case CREATED:
return ON_DESTROY;
case STARTED:
return ON_STOP;
case RESUMED:
return ON_PAUSE;
case DESTROYED:
throw new IllegalArgumentException();
}
throw new IllegalArgumentException("Unexpected state value " + state);
}
private static Event upEvent(State state) {
switch (state) {
case INITIALIZED:
case DESTROYED:
return ON_CREATE;
case CREATED:
return ON_START;
case STARTED:
return ON_RESUME;
case RESUMED:
throw new IllegalArgumentException();
}
throw new IllegalArgumentException("Unexpected state value " + state);
}上面的判断逻辑就是根据下一个目标生命周期的变化，与要执行的Event之间的转换，逻辑如下图：
按照我们上面的举例，从Resumed变为Started，从上图可以看出执行的Event是ON_PAUSE，与我们的猜想一致，总结一下Lifecycle对状态的处理流程：
- 实现LifecycleOwner获取LifecycleRegistry实例
- 绑定并存储HolderFragment
- 当HolderFragment生命周期改变时，调用handleLifecycleEvent处理事件
- LifecycleRegistry根据要执行的Event获取要改变的状态和当前储存的状态
- 比较两个状态，获取真正要执行的Lifecycle.Event
- 调用储存的ObserverWithState的dispatchEvent（）发送事件
事件的处理流程已经清楚了，那么mState和ObserverWithState实例是什么时候存储的？又执行了哪些操作呢？那现在就从第一步添加开始看
2.5、添加Observer
- addObserver：添加观察者Observer
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
...
}- ObserverWithState
上述过程中获取了要执行的Event后，调用了Observer的dispatchEvent（）发送事件，我么知道此时调用的就是ObserverWithState .dispatchEvent（）方法，ObserverWithState封装了State和GenericLifecycleObserver 实例，在dispatchEvent（）又调用了mLifecycleObserver.onStateChanged(owner, event)，所以事件真正的执行是从onStateChanged（）开始的。
static class ObserverWithState {
State mState;
GenericLifecycleObserver mLifecycleObserver;
ObserverWithState(LifecycleObserver observer, State initialState) {
mLifecycleObserver = Lifecycling.getCallback(observer);
mState = initialState;
}
void dispatchEvent(LifecycleOwner owner, Event event) {
State newState = getStateAfter(event);
mState = min(mState, newState);
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}在ObserverWithState 的初始化过程中，同时调用了Lifecycling.getCallback(observer)创建了GenericLifecycleObserver实例
- GenericLifecycleObserver
GenericLifecycleObserver的通过Lifecycling.getCallback(observer) 创建实例
@NonNull
static GenericLifecycleObserver getCallback(Object object) {
if (object instanceof FullLifecycleObserver) {
return new FullLifecycleObserverAdapter((FullLifecycleObserver) object);
}
if (object instanceof GenericLifecycleObserver) {
return (GenericLifecycleObserver) object;
}
final Class klass = object.getClass();
int type = getObserverConstructorType(klass);
if (type == GENERATED_CALLBACK) {
List> constructors =
sClassToAdapters.get(klass);
if (constructors.size() == 1) {
GeneratedAdapter generatedAdapter = createGeneratedAdapter(
constructors.get(0), object);
return new SingleGeneratedAdapterObserver(generatedAdapter);
}
GeneratedAdapter[] adapters = new GeneratedAdapter[constructors.size()];
for (int i = 0; i < constructors.size(); i++) {
adapters[i] = createGeneratedAdapter(constructors.get(i), object);
}
return new CompositeGeneratedAdaptersObserver(adapters);
}
return new ReflectiveGenericLifecycleObserver(object);
} 创建不同的GenericLifecycleObserver并传入GeneratedAdapter实例，以SingleGeneratedAdapterObserver为例，实现GenericLifecycleObserver的接口重写onStateChange（）方法，在方法内部调用GeneratedAdapter的callMethod（）执行设定Observer的相关方法。
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);
}
}在使用Debug追踪方法执行，在Lifecycling.getCallback(observer)中返回的是ReflectiveGenericLifecycleObserver，查看源码
class ReflectiveGenericLifecycleObserver implements GenericLifecycleObserver {
private final Object mWrapped;
private final CallbackInfo mInfo;
ReflectiveGenericLifecycleObserver(Object wrapped) {
mWrapped = wrapped;
mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
}
@Override
public void onStateChanged(LifecycleOwner source, Event event) {
mInfo.invokeCallbacks(source, event, mWrapped);
}
}在构造函数中，初始化CallbackInfo实例，储存了Observer中定义的方法注解，在CallbackInfo的类中有一段代码比较明显：
//获取Observer的所有方法
Method[] methods = declaredMethods != null ? declaredMethods : getDeclaredMethods(klass);
boolean hasLifecycleMethods = false;
for (Method method : methods) {
// 获取方法的注解
OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);
if (annotation == null) {
continue;
}
hasLifecycleMethods = true;
//方法的参数
Class[] params = method.getParameterTypes();
int callType = CALL_TYPE_NO_ARG;
if (params.length > 0) {
callType = CALL_TYPE_PROVIDER;
if (!params[0].isAssignableFrom(LifecycleOwner.class)) {
throw new IllegalArgumentException(
"invalid parameter type. Must be one and instanceof LifecycleOwner");
}
}
// 获取注解对应的Lifecycle.Event
Lifecycle.Event event = annotation.value();
if (params.length > 1) {
callType = CALL_TYPE_PROVIDER_WITH_EVENT;
...
}
//创建MethodReference 封装了参数和方法
MethodReference methodReference = new MethodReference(callType, method);
verifyAndPutHandler(handlerToEvent, methodReference, event, klass);
}
// 创建并保存CallbackInfo实例
CallbackInfo info = new CallbackInfo(handlerToEvent);
mCallbackMap.put(klass, info);
mHasLifecycleMethods.put(klass, hasLifecycleMethods);
return info;上述执行的逻辑很清楚，里面的几个属性需要简单说明：
- MethodReference：封装了Method的参数类型和方法
- handlerToEvent：是一个Map
- mCallbackMap：Map
- mHasLifecycleMethods：用于标注Observer类是否有注解的方法
所以在ReflectiveGenericLifecycleObserver中的CallbackInfo是储存了Observer中方法信息的实例，我们只需要在使用的时候获取并调用其中的方法，所以ReflectiveGenericLifecycleObserver的onStateChange（）中调用mInfo.invokeCallbacks(source, event, mWrapped)执行相应的方法，对于添加执行的逻辑总结：
- 初始化State为INITIALIZED或Destroy状态
- 调用ClassesInfoCache.sInstance.getInfo（），遍历获取Observer中的所有注解、参数和方法，并对应储存
- 创建ObserverWithState保存状态和CallbackInfo
到此结束，执行的时候只是按照上面的执行逻辑取出存储的ObserverWithState中的信息，即可在生命周期改变时，提取储存的方法和注解，找到目标方法，执行我们注解的Observer中的逻辑了。
三、实战
因为前面使用篇已经介绍过用法了，此处至简单看一下内部执行时的数据
- MyObserver：简单创建了LifecyclerObserver子类，并定义两个方法
class MyLifeObserver : LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_START)
fun start() {
Log.e("LifecycleObserver = ", "Start")
}
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
fun resume() {
Log.e("LifecycleObserver = ", "Resume")
}
}- 添加时初始化ObserverWithState时储存的信息：获取到的正是我们定义的方法
- 事件变化时的处理 onStateChange（），最终调用方法如下：
其中handlers的数据就是根据Lifecycler.Event获取到的注解方法：
到此Lifecycler组件的使用和源码分析到此结束了，希望有助于对此组件的理解和使用。