1、原理解析
1.1 从注册观察者的入口方法开始
1.1.1 LifecycleOwner
/**
* 接口，用来获取Lifecycle对象
*/
public interface LifecycleOwner {
@NonNull
Lifecycle getLifecycle();
}
1.1.2 ComponentActivity、androidx包中的Fragment自身实现了LifecycleOwner接口，并创建了继承了Lifecycle类的LifecycleRegistry对象，lifecycleOwner.getLifecycle()获取的就是LifecycleRegistry对象，通过LifecycleRegistry来进行注册和反注册观察者
lifecycleOwner.getLifecycle().addObserver(this);
1.1.3 Lifecycle
/**
* 抽象类，提供注册/反注册方法和记录组件生命周期事件和状态的枚举
*/
public abstract class Lifecycle {
@MainThread
public abstract void addObserver(@NonNull LifecycleObserver observer);
@MainThread
public abstract void removeObserver(@NonNull LifecycleObserver observer);
@SuppressWarnings("WeakerAccess")
public enum Event {
ON_CREATE,
ON_START,
ON_RESUME,
ON_PAUSE,
ON_STOP,
ON_DESTROY,
ON_ANY;
}
@SuppressWarnings("WeakerAccess")
public enum State {
DESTROYED,
INITIALIZED,
CREATED,
STARTED,
RESUMED;
/**
* DESTROYED<INITIALIZED<CREATED<STARTED<RESUMED
*/
public boolean isAtLeast(@NonNull State state) {
return compareTo(state) >= 0;
}
}
}
1.1.4 LifecycleRegistry
public class LifecycleRegistry extends Lifecycle {
/**
* 是一个可以在遍历中删除数据的链表,用来保存ObserverWithState
*/
private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =
new FastSafeIterableMap<>();
/**
* 注册观察者的地方
*/
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
//是否是在主线程，不是，抛异常，终止。
enforceMainThreadIfNeeded("addObserver");
//新注册的观察者的 initialState 一般是INITIALIZED
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
//LifecycleObserver 和 State 创建ObserverWithState对象
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
//查看要注册的观察者是否已经存在，存在，终止，不存在，添加到mObserverMap中。
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
if (previous != null) {
return;
}
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
if (lifecycleOwner == null) {
// it is null we should be destroyed. Fallback quickly
return;
}
// 下面的逻辑就是：把之前优先分发的事件，一个个分发给后添加的观察者
// 比如在Activity的onResume生命周期中调用LifecycleRegistry.addObserver的时候
// 因为新添加的statefulObserver的mState为INITIALIZED
// 而targetState已经发生了变化，在LifecycleRegistry中的mState变成了RESUMED
// 这里就会满足小于0的条件，并且在map中也有了新加入的这个Observer
// 分发一次之后，就会改变targetState的值，如果新的值还是比当前的大，则继续分发
boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
State targetState = calculateTargetState(observer);
mAddingObserverCounter++;
while ((statefulObserver.mState.compareTo(targetState) < 0
&& mObserverMap.contains(observer))) {
pushParentState(statefulObserver.mState);
statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
popParentState();
// mState / subling may have been changed recalculate
targetState = calculateTargetState(observer);
}
if (!isReentrance) {
// we do sync only on the top level.
sync();
}
mAddingObserverCounter--;
}
@Override
public void removeObserver(@NonNull LifecycleObserver observer) {
enforceMainThreadIfNeeded("removeObserver");
mObserverMap.remove(observer);
}
}
1.2 ComponentActivity
ComponentActivity 实现了LifecycleOwner接口，内部创建了继承Lifecycle类的LifecycleRegistry，add一个空的ReportFragment，并通过ReportFragment来分管理生命周期事件
public class ComponentActivity extends Activity implements LifecycleOwner {
private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
@SuppressLint("RestrictedApi")
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
ReportFragment.injectIfNeededIn(this);
}
@NonNull
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
}
1.3 ReportFragment 在对应的生命周期方法中分发事件，最后其实是调用LifecycleRegistry的handleLifecycleEvent方法来分发事件
ReportFragment
public class ReportFragment extends android.app.Fragment {
public static void injectIfNeededIn(Activity activity) {
//Sdk >= 29的时候会，通过Application.ActivityLifecycleCallbacks来监听
//生命周期方法分发事件，具体的自己可以去看一下，这也是我们上面例子，代码中打出的log
//页面中的onPause、onStop、onDestory 后调用的原因
if (Build.VERSION.SDK_INT >= 29) {
LifecycleCallbacks.registerIn(activity);
}
...
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);
}
private void dispatch(@NonNull Lifecycle.Event event) {
if (Build.VERSION.SDK_INT < 29) {
dispatch(getActivity(), event);
}
}
@SuppressWarnings("deprecation")
static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
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);
}
}
}
}
1.4 LifecycleRegistry 对事件进行分发，最后会调用子类ObserverWithState的dispatchEvent()
public class LifecycleRegistry extends Lifecycle {
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
enforceMainThreadIfNeeded("handleLifecycleEvent");
moveToState(event.getTargetState());
}
private void moveToState(State next) {
if (mState == next) {
return;
}
mState = next;
if (mHandlingEvent || mAddingObserverCounter != 0) {
mNewEventOccurred = true;
return;
}
mHandlingEvent = true;
sync();
mHandlingEvent = false;
}
// 把生命周期状态同步给所有观察者
private void sync() {
...
while (!isSynced()) {
mNewEventOccurred = false;
if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
backwardPass(lifecycleOwner);
}
Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
if (!mNewEventOccurred && newest != null
&& mState.compareTo(newest.getValue().mState) > 0) {
forwardPass(lifecycleOwner);
}
}
mNewEventOccurred = false;
}
//正序遍历，分发事件
private void forwardPass(LifecycleOwner lifecycleOwner) {
Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
mObserverMap.iteratorWithAdditions();
while (ascendingIterator.hasNext() && !mNewEventOccurred) {
Map.Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
ObserverWithState observer = entry.getValue();
while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
&& mObserverMap.contains(entry.getKey()))) {
pushParentState(observer.mState);
final Event event = Event.upFrom(observer.mState);
if (event == null) {
throw new IllegalStateException("no event up from " + observer.mState);
}
observer.dispatchEvent(lifecycleOwner, event);
popParentState();
}
}
}
//倒序遍历，分发事件
private void backwardPass(LifecycleOwner lifecycleOwner) {
Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
mObserverMap.descendingIterator();
while (descendingIterator.hasNext() && !mNewEventOccurred) {
Map.Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
ObserverWithState observer = entry.getValue();
while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
&& mObserverMap.contains(entry.getKey()))) {
Event event = Event.downFrom(observer.mState);
if (event == null) {
throw new IllegalStateException("no event down from " + observer.mState);
}
pushParentState(event.getTargetState());
observer.dispatchEvent(lifecycleOwner, event);
popParentState();
}
}
}
//最后会调用ObserverWithState的dispatchEvent来分发事件
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 = event.getTargetState();
mState = min(mState, newState);
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}
}
1.5 ObserverWithState的dispatchEvent 方法分发事件过程解析
ObserverWithState对象创建的时候，会通过Lifecycling.lifecycleEventObserver(observer)方法创建一个LifecycleEventObserver对象，事件分发的dispatchEvent()方法中最终也是调用了
LifecycleEventObserver对象的onStateChanged方法
//LifecycleRegistry 子类
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 = event.getTargetState();
mState = min(mState, newState);
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}
public interface LifecycleEventObserver extends LifecycleObserver {
/**
* Called when a state transition event happens.
*
* @param source The source of the event
* @param event The event
*/
void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);
}
看一下Lifecycling类的lifecycleEventObserver方法
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);
}
//如果观察者是通过FullLifecycleObserver接口实现的，接口回调出发事件
if (isFullLifecycleObserver) {
return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
}
//如果观察者是通过LifecycleEventObserver接口实现的，接口回调出发事件
if (isLifecycleEventObserver) {
return (LifecycleEventObserver) object;
}
//如果是LifecycleObserver接口+注解形式实现
//反射来判断类型
//如果是GENERATED_CALLBACK类型，根据constructors数据的size来判断是
//返回SingleGeneratedAdapterObserver 或 CompositeGeneratedAdaptersObserver
//否则返回ReflectiveGenericLifecycleObserver
final Class<?> klass = object.getClass();
int type = getObserverConstructorType(klass);
if (type == GENERATED_CALLBACK) {
List<Constructor<? extends GeneratedAdapter>> 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);
}
1.如果观察者实现的是FullLifecycleObserver接口，会返回FullLifecycleObserverAdapter对象，最终调用FullLifecycleObserverAdapter的onStateChanged方法，并通过接口回掉来处理事件
interface FullLifecycleObserver extends LifecycleObserver {
void onCreate(LifecycleOwner owner);
void onStart(LifecycleOwner owner);
void onResume(LifecycleOwner owner);
void onPause(LifecycleOwner owner);
void onStop(LifecycleOwner owner);
void onDestroy(LifecycleOwner owner);
}
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) {
switch (event) {
case ON_CREATE:
mFullLifecycleObserver.onCreate(source);
break;
case ON_START:
mFullLifecycleObserver.onStart(source);
break;
case ON_RESUME:
mFullLifecycleObserver.onResume(source);
break;
case ON_PAUSE:
mFullLifecycleObserver.onPause(source);
break;
case ON_STOP:
mFullLifecycleObserver.onStop(source);
break;
case ON_DESTROY:
mFullLifecycleObserver.onDestroy(source);
break;
case ON_ANY:
throw new IllegalArgumentException("ON_ANY must not been send by anybody");
}
if (mLifecycleEventObserver != null) {
mLifecycleEventObserver.onStateChanged(source, event);
}
}
}
2.如果观察者实现的是LifecycleEventObserver接口那么直接返回，并调用onStateChanged()方法通过接口回调来分发事件，这种方式在ComponentActivity类中有实现，如下：
public ComponentActivity() {
Lifecycle lifecycle = getLifecycle();
...
if (Build.VERSION.SDK_INT >= 19) {
getLifecycle().addObserver(new LifecycleEventObserver() {
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
if (event == Lifecycle.Event.ON_STOP) {
Window window = getWindow();
final View decor = window != null ? window.peekDecorView() : null;
if (decor != null) {
decor.cancelPendingInputEvents();
}
}
}
});
}
getLifecycle().addObserver(new LifecycleEventObserver() {
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
if (event == Lifecycle.Event.ON_DESTROY) {
// Clear out the available context
mContextAwareHelper.clearAvailableContext();
// And clear the ViewModelStore
if (!isChangingConfigurations()) {
getViewModelStore().clear();
}
}
}
});
getLifecycle().addObserver(new LifecycleEventObserver() {
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
ensureViewModelStore();
getLifecycle().removeObserver(this);
}
});
}
3.如果观察者的实现方式不是继承的上面的两个接口，而是通过LifecycleObserver接口+注解的
方式实现的话，就会走到下面的逻辑。
首先根据反射判断是什么type，type定义了两种
public class Lifecycling {
private static final int REFLECTIVE_CALLBACK = 1;
private static final int GENERATED_CALLBACK = 2;
private static Map<Class<?>, Integer> sCallbackCache = new HashMap<>();
private static Map<Class<?>, List<Constructor<? extends GeneratedAdapter>>> sClassToAdapters =
new HashMap<>();
}
方法getObserverConstructorType()返回的type若等于GENERATED_CALLBACK则会采用SingleGeneratedAdapterObserver或者CompositeGeneratedAdaptersObserver来实现观察者，这个方法有是通过resolveObserverCallbackType()来解析type的：
private static int getObserverConstructorType(Class<?> klass) {
//看Map中是否已经有这个类的类型，有直接返回
Integer callbackCache = sCallbackCache.get(klass);
if (callbackCache != null) {
return callbackCache;
}
//没有，判断是什么类型并保存到map中
int type = resolveObserverCallbackType(klass);
sCallbackCache.put(klass, type);
return type;
}
上面函数主要是在判断该观察者对象是否有相应的GeneratedAdapter类生成，是通过generatedConstructor方法实现的，若有相应的GeneratedAdapter类生成，则通过反射生成相应的构造器：
private static int resolveObserverCallbackType(Class<?> klass) {
// 1.根据本类klass对象来判断是否有APT生成相应的GeneratedAdapter对象
if (klass.getCanonicalName() == null) {
return REFLECTIVE_CALLBACK;
}
Constructor<? extends GeneratedAdapter> constructor = generatedConstructor(klass);
if (constructor != null) {
sClassToAdapters.put(klass, Collections
.<Constructor<? extends GeneratedAdapter>>singletonList(constructor));
return GENERATED_CALLBACK;
}
boolean hasLifecycleMethods = ClassesInfoCache.sInstance.hasLifecycleMethods(klass);
if (hasLifecycleMethods) {
return REFLECTIVE_CALLBACK;
}
// 2.根据父类superclass对象来判断是否有APT生成相应的GeneratedAdapter对象
Class<?> superclass = klass.getSuperclass();
List<Constructor<? extends GeneratedAdapter>> adapterConstructors = null;
if (isLifecycleParent(superclass)) {
if (getObserverConstructorType(superclass) == REFLECTIVE_CALLBACK) {
return REFLECTIVE_CALLBACK;
}
adapterConstructors = new ArrayList<>(sClassToAdapters.get(superclass));
}
//3.根据其实现接口来判断是否有APT生成相应的GeneratedAdapter对象
for (Class<?> intrface : klass.getInterfaces()) {
if (!isLifecycleParent(intrface)) {
continue;
}
if (getObserverConstructorType(intrface) == REFLECTIVE_CALLBACK) {
return REFLECTIVE_CALLBACK;
}
if (adapterConstructors == null) {
adapterConstructors = new ArrayList<>();
}
adapterConstructors.addAll(sClassToAdapters.get(intrface));
}
if (adapterConstructors != null) {
sClassToAdapters.put(klass, adapterConstructors);
return GENERATED_CALLBACK;
}
return REFLECTIVE_CALLBACK;
}
private static Constructor<? extends GeneratedAdapter> generatedConstructor(Class<?> klass) {
try {
Package aPackage = klass.getPackage();
String name = klass.getCanonicalName();
final String fullPackage = aPackage != null ? aPackage.getName() : "";
final String adapterName = getAdapterName(fullPackage.isEmpty() ? name :
name.substring(fullPackage.length() + 1));
@SuppressWarnings("unchecked") final Class<? extends GeneratedAdapter> aClass =
(Class<? extends GeneratedAdapter>) Class.forName(
fullPackage.isEmpty() ? adapterName : fullPackage + "." + adapterName);
Constructor<? extends GeneratedAdapter> constructor =
aClass.getDeclaredConstructor(klass);
if (!constructor.isAccessible()) {
constructor.setAccessible(true);
}
return constructor;
} catch (ClassNotFoundException e) {
return null;
} catch (NoSuchMethodException e) {
// this should not happen
throw new RuntimeException(e);
}
}
调用GeneratedAdapter的callMethods()的方法来进行事件分发。
@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP_PREFIX)
public interface GeneratedAdapter {
/**
* Called when a state transition event happens.
*
* @param source The source of the event
* @param event The event
* @param onAny approveCall onAny handlers
* @param logger if passed, used to track called methods and prevent calling the same method
* twice
*/
void callMethods(LifecycleOwner source, Lifecycle.Event event, boolean onAny,
MethodCallsLogger logger);
}
其实，调用resolveObserverCallbackType()方法，该过程中已经生成了相应GeneratedAdapter的构造器，并返回一个SingleGeneratedAdapterObserver对象或CompositeGeneratedAdaptersObserver对象，在SingleGeneratedAdapterObserver中onStateChanged()方法中调用相应GeneratedAdapter对象的callMethods()来分发生命周期事件（通过Apt生成一个相应的Adapter对象，最后调用这个对象的callMethods的方法）。
4.以上情况都不是，最后会返回ReflectiveGenericLifecycleObserver对象，并调用LifecycleObserver.onStateChanged(owner, event)方法 。
创建CallBackInfo时候，通过反射来解析具有OnLifecycleEvent注解的方法，最后通过CallBackInfo.invokeCallbacks 反射调用注解方法
ReflectiveGenericLifecycleObserver
class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {
private final Object mWrapped;
private final CallbackInfo mInfo;
ReflectiveGenericLifecycleObserver(Object wrapped) {
mWrapped = wrapped;
mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
}
@Override
public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Event event) {
mInfo.invokeCallbacks(source, event, mWrapped);
}
}
CallbackInfo对象的创建过程
private CallbackInfo createInfo(Class<?> klass, @Nullable Method[] declaredMethods) {
//1.递归解析父类
Class<?> superclass = klass.getSuperclass();
Map<MethodReference, Lifecycle.Event> handlerToEvent = new HashMap<>();
if (superclass != null) {
//因为会有多重继承，因此会递归解析父类，getInfo()方法还会调用createInfo()方法
CallbackInfo superInfo = getInfo(superclass);
if (superInfo != null) {
handlerToEvent.putAll(superInfo.mHandlerToEvent);
}
}
//2.递归解析接口。Java中接口也可以继承，这里getInterfaces()方法处理两种情况：a. klass对应一个类，b. kclass对应一个接口
Class<?>[] interfaces = klass.getInterfaces();
for (Class<?> intrfc : interfaces) {
for (Map.Entry<MethodReference, Lifecycle.Event> entry : getInfo(
intrfc).mHandlerToEvent.entrySet()) {
//接口中解析的方法可能与父类中解析的是重复定义的，会做去重后再添加到handlerToEvent中
verifyAndPutHandler(handlerToEvent, entry.getKey(), entry.getValue(), klass);
}
}
//3. 解析本类对象具有OnLifecycleEvent注解的方法
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();
//OnLifecycleEvent注解的方法最多允许两个Event参数，定义参数超过两个会抛出异常
int callType = CALL_TYPE_NO_ARG;
if (params.length > 0) {
callType = CALL_TYPE_PROVIDER;
//第一个参数类型期望为LifecycleOwner类型
if (!params[0].isAssignableFrom(LifecycleOwner.class)) {
throw new IllegalArgumentException(
"invalid parameter type. Must be one and instanceof LifecycleOwner");
}
}
Lifecycle.Event event = annotation.value();
if (params.length > 1) {
callType = CALL_TYPE_PROVIDER_WITH_EVENT;
//第二个参数类型期望为Event类型
if (!params[1].isAssignableFrom(Lifecycle.Event.class)) {
throw new IllegalArgumentException(
"invalid parameter type. second arg must be an event");
}
if (event != Lifecycle.Event.ON_ANY) {
throw new IllegalArgumentException(
"Second arg is supported only for ON_ANY value");
}
}
if (params.length > 2) {
throw new IllegalArgumentException("cannot have more than 2 params");
}
MethodReference methodReference = new MethodReference(callType, method);
//去重添加到handlerToEvent中
verifyAndPutHandler(handlerToEvent, methodReference, event, klass);
}
CallbackInfo info = new CallbackInfo(handlerToEvent);
mCallbackMap.put(klass, info);
mHasLifecycleMethods.put(klass, hasLifecycleMethods);
return info;
}
CallbackInfo通过反射调用注解方法
static class CallbackInfo {
final Map<Lifecycle.Event, List<MethodReference>> mEventToHandlers;
final Map<MethodReference, Lifecycle.Event> mHandlerToEvent;
CallbackInfo(Map<MethodReference, Lifecycle.Event> handlerToEvent) {
mHandlerToEvent = handlerToEvent;
mEventToHandlers = new HashMap<>();
for (Map.Entry<MethodReference, Lifecycle.Event> entry : handlerToEvent.entrySet()) {
Lifecycle.Event event = entry.getValue();
List<MethodReference> methodReferences = mEventToHandlers.get(event);
if (methodReferences == null) {
methodReferences = new ArrayList<>();
mEventToHandlers.put(event, methodReferences);
}
methodReferences.add(entry.getKey());
}
}
@SuppressWarnings("ConstantConditions")
void invokeCallbacks(LifecycleOwner source, Lifecycle.Event event, Object target) {
invokeMethodsForEvent(mEventToHandlers.get(event), source, event, target);
invokeMethodsForEvent(mEventToHandlers.get(Lifecycle.Event.ON_ANY), source, event,
target);
}
private static void invokeMethodsForEvent(List<MethodReference> handlers,
LifecycleOwner source, Lifecycle.Event event, Object mWrapped) {
if (handlers != null) {
for (int i = handlers.size() - 1; i >= 0; i--) {
handlers.get(i).invokeCallback(source, event, mWrapped);
}
}
}
}
上面这些是根据ComponentActivity的实现方式来分析的，Fragment的实现方式与之类似，却别就是没有用ReportFragment来管理事件的分发，而是在对应的生命周期方法中通过LifecycleRegistry直接来分发的。
总结
关键类和接口
1.1 、Lifecycle
用于有关组件（如 Activity 或 Fragment）的生命周期状态的信息，并允许其他对象观察此状态。
1.2、LifecycleOwner ：
实现该接口的类持有生命周期(Lifecycle对象)，该接口的生命周期(Lifecycle对象)的改变会被其注册的观察者LifecycleObserver观察到并触发其对应的事件。
1.3、LifecycleObserver：
实现该接口的类，通过注解的方式，可以通过被LifecycleOwner类的addObserver(LifecycleObserver o)方法注册,被注册后，LifecycleObserver便可以观察到LifecycleOwner的生命周期事件。
1.4、LifecycleRegistry：
Lifecycle的具体实现类，注册和反注册观察者，并进行事件的分发。
1.5、ObserverWithState：
持有观察者，并进行事件分发
1.6、Lifecycling：
处理具体的分发事件逻辑。
原理概括
Activity/Fragment实现LifecycleOwner接口，通过LifecycleRegistry在对应生命周期分发事件，最后回调观察者中对应订阅方法。
扫一扫
891
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
