具备生命周期后期感知能力的组件，它能持有组件（如Activity、Fragment）生命周期状态的信息，并且允许其他观察者监听宿主的状态
用注解的形式标记在方法上来观察宿主的生命周期变化的事件
//1.自定义的LifecycleObserver观察者，用注解声明每个方法观察的宿主的状态
public class TestObserver implements LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_START)
void onStart(LifecycleOwner owner){
}
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
void onStop(LifecycleOwner owner){
}
}
//2.注册观察者，观察宿主生命周期状态的变化 不需要在宿主销毁的时候进行反注册
public class MyFragment extends Fragment {
@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
TestObserver observer = new TestObserver();
getLifecycle().addObserver(observer);
}
}
public interface LifecycleEventObserver extends androidx.lifecycle.LifecycleObserver {
void onStateChanged(@androidx.annotation.NonNull androidx.lifecycle.LifecycleOwner lifecycleOwner, @androidx.annotation.NonNull androidx.lifecycle.Lifecycle.Event event);
}public class LocationObserver implements LifecycleEventObserver {
@Override
public void onStateChanged(@NonNull LifecycleOwner lifecycleOwner, @NonNull Lifecycle.Event event) {
//自行判断life-event 是onStart 还是onStop
}
}
3种方式都需要在宿主里面注册观察者
//实现自LifecycleOwner 生命周期宿主的意思
public class Fragment implements LifecycleOwner {
//注册接口时都会被注册到LifecycleRegistry这个类中
LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
//Lifecycle是LifecycleRegistry的父类 面向接口编程思想
@NonNull
@Override
public Lifecycle getLifecycle() {
//复写自LifecycleOwner 所以必须new LifecycleRegistry返回
return mLifecycleRegistry;
}
//分发每一个状态到每一个观察者，从而实现观察生命周期变化的能力
void performCreate() {
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
}
void performStart() {
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
}
void performStop() {
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
}
}public class ComponentActivity extends Activity implements LifecycleOwner {
LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
@NonNull
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
//往自己上面添加一个不可见的fragment ReportFragment，专门用于报告当前状态分发给每一个观察者
//目的是为了兼顾继承来自AppCompactActivity的场景
ReportFragment.injectIfNeededIn(this);
}
}ReportFragment相关代码：
public static void injectIfNeededIn(Activity activity) {
if (VERSION.SDK_INT >= 29) {
ReportFragment.LifecycleCallbacks.registerIn(activity);
}
FragmentManager manager = activity.getFragmentManager();
if (manager.findFragmentByTag("androidx.lifecycle.LifecycleDispatcher.report_fragment_tag") == null) {
manager.beginTransaction().add(new ReportFragment(), "androidx.lifecycle.LifecycleDispatcher.report_fragment_tag").commit();
manager.executePendingTransactions();
}
}
public void onStart() {
super.onStart();
this.dispatchStart(this.mProcessListener);
this.dispatch(Event.ON_START);
}
public void onResume() {
super.onResume();
this.dispatchResume(this.mProcessListener);
this.dispatch(Event.ON_RESUME);
}
public void onPause() {
super.onPause();
this.dispatch(Event.ON_PAUSE);
}
public void onStop() {
super.onStop();
this.dispatch(Event.ON_STOP);
}
public void onDestroy() {
super.onDestroy();
this.dispatch(Event.ON_DESTROY);
this.mProcessListener = null;
}
static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
if (activity instanceof LifecycleRegistryOwner) {
((LifecycleRegistryOwner)activity).getLifecycle().handleLifecycleEvent(event);
} else {
if (activity instanceof LifecycleOwner) {
Lifecycle lifecycle = ((LifecycleOwner)activity).getLifecycle();
if (lifecycle instanceof LifecycleRegistry) {
((LifecycleRegistry)lifecycle).handleLifecycleEvent(event);
}
}
}
}往自己上面添加一个不可见的fragment ReportFragment，专门用于报告当前状态分发给每一个观察者
在ReportFragment中将自己添加到Activity里，在它的各个生命周期中都调用dispatch方法，在dispatch方法中拿到Lifecycle对象，然后把当前事件分发给每一个观察者
总结：
LifecycleOwner：宿主，代表着Activity、Fragment，都实现了这个接口，也可以自定义一个类，是现在这个接口，让它成为生命周期的宿主，从而让其他的观察者来观察变化
Lifecycle：只要实现了LifecycleOwner接口，就必须实现getLifecycle()方法，返回一个Lifecycle对象
LifecycleRegistry：这个Lifecycle对象也就是LifecycleRegistry，采用了面向接口的编程方式，向LifecycleRegistry注册接口时可以是LifecycleObserver、FullLifecycleObserver、LifecycleEventObserver
总结：宿主在自己的各个生命周期的方法里让这个LifecycleRegistry去分发自己的生命周期事件给每一个观察者
在LifecycleRegistry的addObserver方法中得到initState对象，然把传递进来的observer封装成了ObserverWithState对象没并且把initState状态传递了进去，然后添加到mObserverMap集合中
@0verride
public void addObserver(@NonNull Lifecycle0bserver observer){
State initialState = mState == DESTR?YED ? DESTROYED : INITIALIZED;
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
ObserverWithState previous = mobserverMap.putIfAbsent(observer, statefulObserver);
}State：当前宿主的状态，一个枚举，定义了DESTROYED, INITIALIZED, CREATED, STARTED, RESUMED
initState：只要不是在onDestory中创建的，初始状态都为INITIALIZED状态
ObserverWithState：拥有宿主状态的观察者
for循环中，让当前观察者，也就是statefulObserver，把它的状态INITIALIZED状态，让它前进到宿主当前的状态
State targetState = calculateTargetState(observer);
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);先通过calculateTargetState去计算出observe应该到达的状态，也就是当前宿主的状态，接下来把观察者的状态和target状态做一个比较，如果小于0，就说明观察者的状态还没有达到target状态，就让生命周期前进，通过dispatchEvent，upEvent 。直到观察者状态达到target状态，退出for循环
如果宿主的onResume生命周期中注册一个observer，需要把宿主的onCreate、onStart、onResume都分发给observer，直到观察者的状态和宿主的状态对齐为止
在每一个生命周期的方法中调用LifecycleRegistry的handleLifecycleEvent 方法，并且传递一个事件
首先通过getStateAfter根据当前事件推导出每一个观察者应该到达的生命周期的状态
然后调用moveToState，在这个方法中做一些条件判断，状态同步在sync方法中
private void sync(){
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
if (lifecycleOwner == null){
throw new IllegalStateException("Lifecycle0wner of this LifecycleRegistry is already " + "garbage collected, It is too late to change lifecycle state.");
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：让集合中所有观察者都倒退到和宿主一样的状态，并且分发相应的事件给它们，根据观察者当前的状态计算出应该分发哪一种事件，由于是生命周期的倒退，调用downEvent
forwardPass：生命周期前进，调用upEvent
直到观察者的状态和宿主的状态都一致，才退出循环
总结：每一个生命周期变化时都会分发相应事件，并且根据事件推导出宿主的状态，然后遍历所有的观察者，让它们的状态随之升级，或者降级，并且把本次事件分发给观察者
如何区分LifecycleObserver、FullLifecycleObserver还是LifecycleEventObserver
ObserverWithState，一个静态内部类?
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 = getStateAfter(event);
mState = min(mState, newState);
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}分发事件时调用了onStateChanged方法
Lifecycling一个工具类，通过适配器，把observer转化成LifecycleEventObserver对象，
@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 (isFullLifecycle0bserver){
return new FullLifecycle0bserverAdapter((FullLifecycle0bserver) object, null);
}
if(isLifecycleEventobserver){
return(LifecycleEvent0bserver)obiect;
}
final class<?> klass = obiect.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)，obiect);
return new SingleGeneratedAdapterObserver(generatedAdapter);
}
GeneratedAdapterl] adapters = new GeneratedAdapter[constructors.size()];
for(int i = 0;i < constructors.size(); i++){
adapters[i]= createGeneratedAdapter(constructors.get(i), object);
}
return new compositeGeneratedAdapters0bserver(adapters);
}
return new ReflectiveGenericLifecycle0bserver(object);
}通过一个不可见的ReportFragment去分发的
在任意位置注册观察者，都可以接收到完整的生命周期事件，从而完成初始化、开始、暂停、释放等工作