JetPack LifeCycle 组件
一、LifeCycle 简介:
lifeCycle 是 Android JetPack 系列库中的一个组件，可以使其他对象感知 activity 后者fragment 生命周期的变化。通过该组件可以使分离activity 和fragment 生命周期的方法同时可以获取当前的 生命周期状态 进行具体业务处理.
Lifecycle 使用两种主要枚举跟踪其关联组件的生命周期状态：
1.1、Event 和 state
Event:
- ON_CREATE
- ON_START
- ON_RESUME
- ON_PAUSE
- ON_STOP
- ON_DESTROY
- ON_ANY
State:
- DESTROYED
- INITIALIZED
- CREATED
- STARTED
- RESUMED
1.2 获取状态方法
public boolean isAtLeast(@NonNull State state) {
return compareTo(state) >= 0;
}
1.3 生命周期状态跟踪图
二、LifeCycle 使用
2.1添加依赖
dependencies {
implementation "androidx.lifecycle:lifecycle-runtime:2.0.0"
implementation "androidx.lifecycle:lifecycle-extensions:2.0.0"
implementation "androidx.lifecycle:lifecycle-common-java8:2.0.0"
annotationProcessor "androidx.lifecycle:lifecycle-compiler:2.0.0"
}
2.2 实现 LifecycleObserver 接口
public class xxxObserver implements LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
public void connectListener() {
...
}
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
public void disconnectListener() {
...
}
}
myLifecycleOwner.getLifecycle().addObserver(new MyObserver());
三、LifeCycle 源码：
lifeCycle 采用的是观察者模式，LifeCyle 是感知Activity 或者Fragment 生命周期的组件，自然是离不开activity 或Fragement对生命周期的处理,在使用LifeCycle 是需要实现一个 LifecycleObserver 接口 ；
LifecycleObserver ：
public interface LifecycleOwner {
@NonNull
Lifecycle getLifecycle();
}
LifeCycleOwner 接口定义了一个 LifeCycle 对象提供方法，LifeCycle 的具体 实现是 LifecycleRegistry ，这里其实是一个观察者模式
观察者模式：
指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。这种模式有时又称作发布-订阅模式、模型-视图模式，它是对象行为型模式。
优点：
- 降低了目标与观察者之间的耦合关系，两者之间是抽象耦合关系。
- 目标与观察者之间建立了一套触发机制。
缺点：
- 目标与观察者之间的依赖关系并没有完全解除，而且有可能出现循环引用。
- 当观察者对象很多时，通知的发布会花费很多时间，影响程序的效率。
模式的结构与实现：
实现观察者模式时要注意具体目标对象和具体观察者对象之间不能直接调用，否则将使两者之间紧密耦合起来，这违反了面向对象的设计原则。
观察者模式的主要角色如下。
- 模式的结构抽象主题（Subject）角色：也叫抽象目标类，它提供了一个用于保存观察者对象的聚集类和增加、删除观察者对象的方法，以及通知所有观察者的抽象方法。
- 具体主题（Concrete Subject）角色：也叫具体目标类，它实现抽象目标中的通知方法，当具体主题的内部状态发生改变时，通知所有注册过的观察者对象。
- 抽象观察者（Observer）角色：它是一个抽象类或接口，它包含了一个更新自己的抽象方法，当接到具体主题的更改通知时被调用。
- 具体观察者（Concrete Observer）角色：实现抽象观察者中定义的抽象方法，以便在得到目标的更改通知时更新自身的状态。
使用观察者模式理解LifeCycle 有四个角色
LifeCycle 四个角色：
LifeCycle:抽象被观察者
LifecycleRegistry:具体被观察者
标注了当前Activity 的对应生命周期状态 ((LifecycleRegistry)lifecycle).setCurrentState(Lifecycle.State.CREATED); 由此可以知道通过自定义进行修改
LifecycleObserver：观察者接口
LifecycleEventObserver: 生命周期观察者接口
先来看下Activity 的类图关系：
在 FragmentActivity 以及 ComponentActivity 都有 LifecycleEventObserver 的具体实现
ComponentActivity :
getLifecycle方法：
@NonNull@Overridepublic Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
在ComponentActivity 的构造方法：
public ComponentActivity() {
Lifecycle lifecycle = getLifecycle();
//noinspection ConstantConditions
if (lifecycle == null) {
throw new IllegalStateException("getLifecycle() returned null in ComponentActivity's "
+ "constructor. Please make sure you are lazily constructing your Lifecycle "
+ "in the first call to getLifecycle() rather than relying on field "
+ "initialization.");
}
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) {
if (!isChangingConfigurations()) {
getViewModelStore().clear();
}
}
}
});
if (19 <= SDK_INT && SDK_INT <= 23) {
getLifecycle().addObserver(new ImmLeaksCleaner(this));
}
}
myLifecycleOwner.getLifecycle().addObserver(new MyObserver()); 该方法的调用实际上调用了 LifeRegistry 的addObserver 方法
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
//构造 ObserverWithState 对象 后面通过 该对象进行状态分发
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
//从缓存中获取 ObserverWithState 对象
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;
}
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--;
}
通过 new ObserverWithState(observer, initialState); 构造了一个 ObserverWithState 对象，后面通过 该对象进行生命周期状态的分发
LifecycleRegistry:
static class ObserverWithState {
State mState;
LifecycleEventObserver mLifecycleObserver;
ObserverWithState(LifecycleObserver observer, State initialState) {
//通过反射构对象一个具体的LifecycleObserver 对象 这里有几种类型
// 自定义 xxxObserver 是由 MyObservable_LifecycleAdapter 生成的一个对象 CompositeGeneratedAdaptersObserver对象
mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
mState = initialState;
}
//生命周期状态分发
void dispatchEvent(LifecycleOwner owner, Event event) {
State newState = getStateAfter(event);
mState = min(mState, newState);
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}
Lifecycling.lifecycleEventObserver(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;
}
final Class<?> klass = object.getClass();
//ClassesInfoCache 处理了相关注解 LifeCycle.Event.XXX
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);
}
Lifecycling.lifecycleEventObserver(observer)–> CompositeGeneratedAdaptersObserver
CompositeGeneratedAdaptersObserver:
class CompositeGeneratedAdaptersObserver implements LifecycleEventObserver {
private final GeneratedAdapter[] mGeneratedAdapters;
CompositeGeneratedAdaptersObserver(GeneratedAdapter[] generatedAdapters) {
mGeneratedAdapters = generatedAdapters;
}
@Override
public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
MethodCallsLogger logger = new MethodCallsLogger();
//callmethods 调用了 XXX_LifecycleAdapter 的 callMethods
for (GeneratedAdapter mGenerated: mGeneratedAdapters) {
mGenerated.callMethods(source, event, false, logger);
}
for (GeneratedAdapter mGenerated: mGeneratedAdapters) {
mGenerated.callMethods(source, event, true, logger);
}
}
}
四、流程图
最后借鉴两张图说明下整体流程
554
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
