依赖
implementation 'androidx.lifecycle:lifecycle-extensions:2.2.0'
kapt 'androidx.lifecycle:lifecycle-compiler:2.2.0'
示例代码
- 生命周期观察者
class MyLifecycleObserver : LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
fun onCreate(owner: LifecycleOwner?) {
//doSomething
}
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
fun onDestroy(owner: LifecycleOwner?) {
//doSomething
}
}
Activity中的代码
class LifecycleDemoActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
...
// 添加观察者
lifecycle.addObserver(MyLifecycleObserver())
}
}
概述
LifecycleOwner:生命周期的事件分发者,在Activity/Fragment他们的生命周期发生变化的时发出相应的Event给LifecycleRegistry.LifecycleObserver:生命周期的观察者,通过注解将处理函数与希望监听的Event绑定,当相应的Event发生时,LifecycleRegistry会通知相应的函数进行处理。LifecycleRegistry:控制中心。它负责控制state的转换、接受分发event事件。
观察者被添加到哪里了?
- 首先,
Android X中ComponentActivity实现了LifecycleOwner接口, 该接口唯一方法getLifecycle()用来返回一个Lifecycle对象.
// ComponentActivity类实现LifecycleOwner接口
public class ComponentActivity extends androidx.core.app.ComponentActivity implements LifecycleOwner,ViewModelStoreOwner,HasDefaultViewModelProviderFactory,SavedStateRegistryOwner{
// ComponentActivity类中创建了一个LifecycleRegistry变量,getLifecycle()方法返回的正是此变量.
private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
@CallSuper
@Override
protected void onSaveInstanceState(@NonNull Bundle outState) {
Lifecycle lifecycle = getLifecycle();
if (lifecycle instanceof LifecycleRegistry) {
// 设置LifecycleRegistry对象当前的状态为Lifecycle.State.CREATED.
((LifecycleRegistry) lifecycle).setCurrentState(Lifecycle.State.CREATED);
}
super.onSaveInstanceState(outState);
mSavedStateRegistryController.performSave(outState);
}
@NonNull
@Override
public Lifecycle getLifecycle() {
// LifecycleRegistry类型变量
return mLifecycleRegistry;
}
}
// LifecycleOwner 接口
public interface LifecycleOwner {
@NonNull
Lifecycle getLifecycle();
}
调用lifecycle.addObserver(MyLifecycleObserver())实际上就是调用ComponentActivity中的mLifecycleRegistry对象的addObserver()方法
2. 分析LifecycleRegistry.addObserver(LifecycleObserver observer)
public class LifecycleRegistry extends Lifecycle {
// LifecycleRegistry的状态
private State mState;
// 保留观察者并在遍历期间可以处理删除/添加的自定义列表
private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap = new FastSafeIterableMap<>();
// 构造方法
public LifecycleRegistry(@NonNull LifecycleOwner provider) {
// mLifecycleOwner代表当前Activity的弱引用.
mLifecycleOwner = new WeakReference<>(provider);
// LifecycleRegistry刚创建时候为INITIALIZED状态.
mState = INITIALIZED;
}
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
// 将用户传入的观察者和当前观察者对应的初始状态放入ObserverWithState对象中保存起来.
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
// 将观察者对象与它对应的ObserverWithState对象保存在FastSafeIterableMap集合中.
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
if (previous != null) {
// 如果观察者往mObserverMap中添加不成功,就不继续向下执行了.
return;
}
// 从Activity弱引用mLifecycleOwner中获取Activity对象.
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
// mAddingObserverCounter: 是否在添加观察者中.
// mHandlingEvent: 是否在处理事件同步
// 这里为false.
boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
// 计算当前被添加进来的观察者应该同步到哪种最终状态
State targetState = calculateTargetState(observer);
mAddingObserverCounter++;
// 当前观察者的状态是INITIALIZED,LifecycleRegistry当前的状态一般都比INITIALIZED要大,
// 就要进入while()循环提升当前观察者的状态.
while ((statefulObserver.mState.compareTo(targetState) < 0 && mObserverMap.contains(observer))) {
pushParentState(statefulObserver.mState);
// upEvent() 方法就是将状态转换为事件,然后再由dispatchEvent()方法中将事件转换为状态.
// dispatchEvent() 方法负责分发事件以及更新ObserverWithState对象中的状态.
statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
popParentState();
// 再次计算当前观察者应该同步到哪种最终状态,因为这个过程中可能LifecycleRegistry的状态会改变.
// 如果LifecycleRegistry的状态改变了或者第一次循环完事后,当前观察者的状态还未和LifecycleRegistry的状态同步,那么还需要继续的循环执行.
targetState = calculateTargetState(observer);
}
if (!isReentrance) {
// 该方法的作用是将mObserverMap中所有的观察者的状态都同步为当前LifecycleRegistry的状态.
sync();
}
mAddingObserverCounter--;
}
}
- 分析
calculateTargetState()该方法,该方法是计算LifecycleRegistry对象当前的状态的.
private State calculateTargetState(LifecycleObserver observer)
// 获取observer键在mObserverMap中对应的前一个对象
Entry<LifecycleObserver, ObserverWithState> previous = mObserverMap.ceil(observer);
// 获取前一个对象的状态
State siblingState = previous != null ? previous.getValue().mState : null;
// 这里一般是null
State parentState = !mParentStates.isEmpty() ? mParentStates.get(mParentStates.size() - 1): null;
// 所以最终返回的就是LifecycleRegistry对象的mState变量.
return min(min(mState, siblingState), parentState);
}
以上主要是分析观察者对象被添加是怎么回事,其中主要的dispatchEvent()和sync()方法下面分析.
事件是如何从Activity被分发到LifecycleRegistry中间的?
- 还是看
ComponentActivity类
public class ComponentActivity extends androidx.core.app.ComponentActivity implements LifecycleOwner,ViewModelStoreOwner,HasDefaultViewModelProviderFactory,SavedStateRegistryOwner{
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mSavedStateRegistryController.performRestore(savedInstanceState);
// 这里狠关键
ReportFragment.injectIfNeededIn(this);
if (mContentLayoutId != 0) {
setContentView(mContentLayoutId);
}
}
}
ReportFragment可以感知Activity的生命周期,生命周期事件最终由ReportFragment对象来分发.
public class ReportFragment extends Fragment {
public static void injectIfNeededIn(Activity activity) {
if (Build.VERSION.SDK_INT >= 29) {
// Android10以上的系统生命周期的事件分发与10以下的稍微不同
activity.registerActivityLifecycleCallbacks(new LifecycleCallbacks());
}
android.app.FragmentManager manager = activity.getFragmentManager();
if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
// 将无界面的Fragment添加到Activity中.
manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
manager.executePendingTransactions();
}
}
// ReportFragment中的onActivityCreated()方法
@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
dispatchCreate(mProcessListener);
// 10 以下的系统直接在Fragment的生命周期中调用调用方法分发生命周期事件
dispatch(Lifecycle.Event.ON_CREATE);
}
// 10 以上的系统调用方法分发生命周期事件
// LifecycleCallbacks类继承了ActivityLifecycleCallbacks接口.
static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {
@Override
public void onActivityPostCreated(@NonNull Activity activity,
@Nullable Bundle savedInstanceState) {
dispatch(activity, Lifecycle.Event.ON_CREATE);
}
@Override
public void onActivityPostStarted(@NonNull Activity activity) {
dispatch(activity, Lifecycle.Event.ON_START);
}
}
// 生命周期事件分发最终由该方法来做
@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) {
// 当前Activity实现的是LifecycleOwner方法,创建的对象为LifecycleRegistry类型.
((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
}
}
}
}
上面捋了下生命周期事件如何传递到LifecycleRegistry中的.
LifecycleRegistry如何处理生命周期事件?
handleLifecycleEvent()处理生命周期事件.
public class LifecycleRegistry extends Lifecycle {
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
// 将当前Activity传递过来的生命周期事件转化为对应的生命周期状态
State next = getStateAfter(event);
// 该方法是同步观察者的生命周期状态以及通知各个观察者调用对应的生命周期方法的开端.
moveToState(next);
}
}
moveToState(State next)方法分析
public class LifecycleRegistry extends Lifecycle {
private void moveToState(State next) {
// 如果当前LifecycleRegistry状态和需要同步的状态相同就不向下执行了.
if (mState == next) {
return;
}
// 更新LifecycleRegistry当前状态
mState = next;
// mHandlingEvent: 如果正在处理生命周期事件
// mAddingObserverCounter: 如果正在添加观察者中
// 两个条件满足其一也将不会向下执行.
if (mHandlingEvent || mAddingObserverCounter != 0) {
mNewEventOccurred = true;
// we will figure out what to do on upper level.
return;
}
mHandlingEvent = true;
// 这里开始正式的同步状态以及通知观察者调用相应的生命周期了.
sync();
mHandlingEvent = false;
}
}
sync()同步以及通知观察者
public class LifecycleRegistry extends Lifecycle {
private void sync() {
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
// isSynced(): 判断观察者是否需要同步,该方法下面分析.
while (!isSynced()) {
mNewEventOccurred = false;
// mObserverMap.eldest().getValue().mState: 获取最后一个观察者对应的状态
// mState.compareTo(mObserverMap.eldest().getValue().mState) : 当前LifecycleRegistry状态与最后一个观察者对应的状态进行比较,
// 如果LifecycleRegistry状态比观察者对应的状态小,那么执行backwardPass(lifecycleOwner);.
if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
backwardPass(lifecycleOwner);
}
Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
// 这里表示的是如果当前LifecycleRegistry状态与最开始的观察者对应的状态比较,如果LifecycleRegistry状态比观察者对应的状态大,那么执行forwardPass(lifecycleOwner);.
if (!mNewEventOccurred && newest != null&& mState.compareTo(newest.getValue().mState) > 0) {
forwardPass(lifecycleOwner);
}
}
mNewEventOccurred = false;
}
}
backwardPass(lifecycleOwner);与forwardPass(lifecycleOwner);
public class LifecycleRegistry extends Lifecycle {
private void backwardPass(LifecycleOwner lifecycleOwner) {
Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator = mObserverMap.descendingIterator();
// 遍历mObserverMap集合中的所有键值对,键为观察者LifecycleObserver,值为ObserverWithState
while (descendingIterator.hasNext() && !mNewEventOccurred) {
Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
// 获取ObserverWithState对象
ObserverWithState observer = entry.getValue();
// observer.mState.compareTo(mState): 比较当前ObserverWithState对象中的状态与LifecycleRegistry对应的状态,
// 如果ObserverWithState的状态需要降级,继续向下执行.
// 这里为何要使用while()循环,因为LifecycleRegistry当前状态与ObserverWithState的状态可能隔了2个或者多个等级,所以需要while()循环执行,
// 直到ObserverWithState的状态与LifecycleRegistry当前状态相等位置.
while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred && mObserverMap.contains(entry.getKey()))) {
// downEvent()获取当前状态降级之后的目标事件.
Event event = downEvent(observer.mState);
pushParentState(getStateAfter(event));
// 然后调用ObserverWithState对象中的事件分发的方法, 这个方法稍后分析.
observer.dispatchEvent(lifecycleOwner, event);
popParentState();
}
}
}
// 该方法与上面的backwardPass()方法差不多,他是将观察者对应的状态,升级为当前LifecycleRegistry的状态.
private void forwardPass(LifecycleOwner lifecycleOwner) {
Iterator<Entry<LifecycleObserver, ObserverWithState>> ascendingIterator = mObserverMap.iteratorWithAdditions();
while (ascendingIterator.hasNext() && !mNewEventOccurred) {
Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
ObserverWithState observer = entry.getValue();
while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred && mObserverMap.contains(entry.getKey()))) {
pushParentState(observer.mState);
observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
popParentState();
}
}
}
}
在这个对观察者对应的状态进行与当前LifecycleRegistry的状态同步的过程中,就会调用到观察者对应的生命周期方法了.
调用ObserverWithState.dispatchEvent()将生命周期方法分发到观察者中
- 分析
ObserverWithState类
public class LifecycleRegistry extends Lifecycle {
static class ObserverWithState {
State mState;// 当前观察者对应的状态
LifecycleEventObserver mLifecycleObserver; // 生命周期事件观察者
ObserverWithState(LifecycleObserver observer, State initialState) {
// lifecycleEventObserver() 通过观察者得到对应的生命周期事件观察者.
mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
mState = initialState;
}
void dispatchEvent(LifecycleOwner owner, Event event) {
// 将当前生命周期事件转化为对应的生命周期状态
State newState = getStateAfter(event);
mState = min(mState, newState);
// 调用LifecycleEventObserver.onStateChanged()通知观察者调用相应的方法.
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}
}
Lifecycling.lifecycleEventObserver(observer)适配不同的观察者对象得到对应的LifecycleEventObserver适配器对象
public class Lifecycling {
// 视Observer的不同情况返回对应的观察者适配器对象.
@NonNull
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);
}
if (isFullLifecycleObserver) {
return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
}
if (isLifecycleEventObserver) {
return (LifecycleEventObserver) object;
}
// 上面几种适配器都好说,然后这个适配器是根据注释来生成的,编译后生成,路径为..\jetpack-sample\app\build\generated\source\kapt\debug\com\chiclaim\jetpack\test\MyLifeCycleObserver_LifecycleAdapter.java
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);
}
}
通过注解生成适配器逻辑关键看getAdapterName()方法
public class Lifecycling {
// 这里通过反射将观察者的名字拼接后得到适配器对应的类名称,然后反射创建该适配器对象.
public static String getAdapterName(String className) {
return className.replace(".", "_") + "_LifecycleAdapter";
}
}
- 最后回到
forwardPass()与backwardPass()方法中调用的ObserverWithState.dispatchEvent()方法
static class ObserverWithState {
void dispatchEvent(LifecycleOwner owner, Event event) {
State newState = getStateAfter(event);
mState = min(mState, newState);
// 上面分析过mLifecycleObserver就是通过不同类型的观察者获取到的对应的适配器对象,
// 通过调用这些适配器对象的onStateChanged()方法,继续向下看.
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}
mLifecycleObserver.onStateChanged(owner, event);
假如获取的是FullLifecycleObserverAdapter对象
class FullLifecycleObserverAdapter implements LifecycleEventObserver {
private final FullLifecycleObserver mFullLifecycleObserver; // 传入的观察者对象
// 上一步中的mLifecycleObserver.onStateChanged(owner, event)最终调用了这里
@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;
...
}
}
}
假如获取的是SingleGeneratedAdapterObserver对象的话
class SingleGeneratedAdapterObserver implements LifecycleEventObserver {
private final GeneratedAdapter mGeneratedAdapter; // 为注解编译后生成的类通过反射获取到的对象
// 上一步中的mLifecycleObserver.onStateChanged(owner, event)最终调用了这里
@Override
public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
// 这里是调用通过注解生成类对象中的callMethods()方法
mGeneratedAdapter.callMethods(source, event, false, null);
mGeneratedAdapter.callMethods(source, event, true, null);
}
}
再来看看示例代码中通过注解设置的观察者编译之后得到的类
public class MyLifeCycleObserver_LifecycleAdapter implements GeneratedAdapter {
final MyLifecycleObserver mReceiver; // 这里就是用户创建的观察者对象了.
MyLifeCycleObserver_LifecycleAdapter(MyLifecycleObserver receiver) {
this.mReceiver = receiver;
}
// 上一步调用的callMethods()方法
@Override
public void callMethods(LifecycleOwner owner, Lifecycle.Event event, boolean onAny, MethodCallsLogger logger) {
...
if (event == Lifecycle.Event.ON_CREATE) {
if (!hasLogger || logger.approveCall("onCreate", 2)) {
// 到了这里,最终会通过相应的事件调用对应的观察者中的方法了.
mReceiver.onCreate(owner);
}
return;
}
if (event == Lifecycle.Event.ON_DESTROY) {
if (!hasLogger || logger.approveCall("onDestroy", 2)) {
mReceiver.onDestroy(owner);
}
return;
}
}
}
观察订阅模式其实很简单,为何Lifecycles组件整这么复杂呢?原因可以看这个大佬写的一篇博客.