LifeCycle核心原理：LifecycleRegistry

核心类：

Lifecycle可以有效的避免内存泄漏和解决android生命周期的常见难题，是一个表示android生命周期及状态的对象；

Lifecycle是一个抽象类，是实现子类为LifecycleRegistry

public class LifecycleRegistry extends Lifecycle{
  ......
}

LifecycleRegistry在Android中的应用：

- LifecycleOwner 用于连接有生命周期的对象；

public interface LifecycleOwner {
    /**
     * Returns the Lifecycle of the provider.
     */
    @NonNull
    Lifecycle getLifecycle();
}

在新版本SDK包中，Activity/Fragment已经默认实现了LifecycleOwner接口;
查看源码，我们可以看到，Activity/Fragment的实现是返回LifecycleRegistry对象：
public Lifecycle getLifecycle() {
   return mLifecycleRegistry;
}

针对Service，Android 单独提供了LifeCycleService，而不是像Activity、Fragment默认实现了LifeCycleOwner。

针对Application，Android 提供了ProcessLifeCycleOwner - 监听整个应用程序的生命周期。

- LifecycleObserver 用于观察查LifecycleOwner；

- Activity  或  Fragment

getLifecycle().addObserver(实现了LifecycleObserver接口的观察者);

- 观察者

public class LifeCycleObserverTest implements LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void onCreateOb(){

    }

}

基本原理：

#1  我们日常使用的Activity的父类ComponentActivity 和 Fragment 都实现了 LifecycleOwner 接口，其 getLifecycle() 方法返回的 Lifecycle 对象均为 LifecycleRegistry

#2  AppCompatActivity 默认挂载了一个无 UI 界面的 ReportFragment，ReportFragment 会根据用户手机的系统版本号高低，用不同的方式获取到 AppCompatActivity 的事件变化通知，最终调用 LifecycleRegistry 的 handleLifecycleEvent(Lifecycle.Event) 方法将  Lifecycle.Event 传递出去。此时，LifecycleRegistry 就拿到了  Lifecycle.Event

#3  androidx.fragment.app.Fragment 会在内部直接调用 LifecycleRegistry 的 handleLifecycleEvent(Lifecycle.Event) 方法完成事件通知，此时，LifecycleRegistry 也拿到了  Lifecycle.Event

#4  LifecycleRegistry 会将外部 addObserver 传进来的 LifecycleObserver 对象都给包装成 ObserverWithState 类内部的 LifecycleEventObserver 对象，屏蔽了外部传进来的 LifecycleObserver 的差异性（可能是接口，也可能是注解）

#5  LifecycleRegistry 通过直接调用 ObserverWithState 类内部的 LifecycleEventObserver 对象的 onStateChanged 方法来完成最终的事件回调。至此整个流程就完成了

核心原理分析 - 如何感知生命周期？如何分发生命周期状态给观察者?

1）如何感知生命周期？

我们以ComponentActivity为例。

- ComponentActivity

public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        LifecycleOwner,
        ViewModelStoreOwner,
        SavedStateRegistryOwner,
        OnBackPressedDispatcherOwner {

    private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

    // Lazily recreated from NonConfigurationInstances by getViewModelStore()
    private ViewModelStore mViewModelStore;

    ......

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mSavedStateRegistryController.performRestore(savedInstanceState);
        // #1 核心代码
        ReportFragment.injectIfNeededIn(this);
        if (mContentLayoutId != 0) {
            setContentView(mContentLayoutId);
        }
    }

    ......

    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }

    ......

}

在ComponentActivity的onCreate方法中，会通过FragmentManager添加一个透明无UI的Fragment，用于生命周期的感知，实现原理与Glide相同。

- ReportFragment

- ReportFragment

public class ReportFragment extends Fragment {

    private static final String REPORT_FRAGMENT_TAG = "androidx.lifecycle"
            + ".LifecycleDispatcher.report_fragment_tag";

    public static void injectIfNeededIn(Activity activity) {
        // ProcessLifecycleOwner should always correctly work and some activities may not extend
        // FragmentActivity from support lib, so we use framework fragments for activities
        android.app.FragmentManager manager = activity.getFragmentManager();
        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
            manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
            // Hopefully, we are the first to make a transaction.
            manager.executePendingTransactions();
        }
    }

    ......    

    @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);
    }

    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通过dispatch方法，最终调用对应Activity的LifecycleRegistry对象的handleLifecycleEvent方法，完成生命周期事件的分发。

2）如何分发生命周期状态给观察者?  这里以注解方式的观察者为例

- LifecycleRegistry

在LifecycleRegistry中，经过如下方法调用链：

handleLifecycleEvent -> moveToState -> sync -> 遍历mObserverMap(观察者Map) -> mLifecycleObserver.onStateChanged

具体分析：
在Jetpack中，页面的生命周期有五种状态，不同场景下的生命周期变化，则会在这五种状态下流转，而moveToState、sync 就是做这件事情的。

- LifecycleRegistry

    public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        State next = getStateAfter(event);// 根据当前的生命周期事件，得到对应的状态值
        moveToState(next);
    }

moveToState的核心是全局变量mState保存了当前的State，且调用了sync方法：

 private void sync() {
        // 此处的lifecycleOwner 就是我们的Activity 或 Fragment
        // 这个弱引用，是在LifecycleRegistry的构造方法中生成的，也即LifecycleRegistry持有Activity 或 Fragment的弱引用
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        
        // 生命周期状态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;
    }

这里涉及到一个新的概念 - State

 通过生命周期事件的值，流转到对应的状态：

- LifecycleRegistry
  
  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);
    }

接着我们分析生命周期状态的核心方法：forwardPass和backwardPass，这两个方法的功能一样，只不过一个是向前流转，一个是向后流转，可以对应于上图看下。这里以forwardPass为例进行分析：

- LifecycleRegistry

private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =
            new FastSafeIterableMap<>();

    private void forwardPass(LifecycleOwner lifecycleOwner) {
        // mObserverMap 为所有观察者的Map集合，key：LifecycleObserver , value：ReflectiveGenericLifecycleObserver(类似于EventBus，通过反射拿到了观察者所有注册的方法[通过@OnLifecycleEvent注解注册])
        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);// 保存分发前的状态，以便分发出问题可以回退
                // 调用观察者的dispatchEvent - 最终反射调用注册的各个生命周期方法
                observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
                popParentState();// 移除分发前的状态
            }
        }
    }

如果了解EventBus原理，下面就可以不用看了。

到了此处，我们分析了生命周期发生之后，生命周期状态时如何流转，并下发到对应的观察者的。

下面继续分析forwardPass的observer.dispatchEvent是如何分发的。

查看源码，我们会发现这个Observer并不是原始的LifecycleObserver，而是在原LifecycleObserver基础上包装了一层  -  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;
        }
    }

这里比较核心的代码：

Lifecycling.lifecycleEventObserver(observer)

也就是在注册观察者的同时，就通过该方法调用，完成 观察者 - 注册方法 = 1 ：1的这种关系封装。

- Lifecycling

    @NonNull
    static LifecycleEventObserver lifecycleEventObserver(Object object) {
        ......
        return new ReflectiveGenericLifecycleObserver(object);
    }

经过各种流转，最终一定是返回了ReflectiveGenericLifecycleObserver对象。

- ReflectiveGenericLifecycleObserver 

class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {
    private final Object mWrapped;
    private final CallbackInfo mInfo;
    
    // 此处的Object就是我们的观察者
    ReflectiveGenericLifecycleObserver(Object wrapped) {
        mWrapped = wrapped;
        mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
    }

    // 反射触发调用
    @Override
    public void onStateChanged(LifecycleOwner source, Event event) {
        mInfo.invokeCallbacks(source, event, mWrapped);
    }
}

同样，在构造函数中就完成了ClassInfo的采集工作【可以看到多次使用的都是这个方式】

- ReflectiveGenericLifecycleObserver核心方法

ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());

如何收集到观察者注册了哪些方法呢？核心就是反射 + 注解 + Map。

- ClassInfoCache

Map：

private final Map<Class, CallbackInfo> mCallbackMap = new HashMap<>();

反射 + 注解：

getInfo会触发createInfo的调用，createInfo的核心代码：

        ......
        Method[] methods = declaredMethods != null ? declaredMethods : getDeclaredMethods(klass);// klass是我们的观察者
        ......
        for (Method method : methods) {
            OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);
            ......
            Lifecycle.Event event = annotation.value();
            ......
            MethodReference methodReference = new MethodReference(callType, method);
            // Map<MethodReference, Lifecycle.Event> handlerToEvent = new HashMap<>();
            verifyAndPutHandler(handlerToEvent, methodReference, event, klass);
        }
        CallbackInfo info = new CallbackInfo(handlerToEvent);
        mCallbackMap.put(klass, info);

再回到ObserverWithState，在生命周期发生流转的时候，即forwardPass调用，会触发ObserverWithState的dispatchEvent的调用，并最终触发ReflectiveGenericLifecycleObserver的onStateChanged方法调用：

- ReflectiveGenericLifecycleObserver

    @Override
    public void onStateChanged(LifecycleOwner source, Event event) {
        mInfo.invokeCallbacks(source, event, mWrapped);
    }

也就是CallbackInfo的invokeCallbacks方法的调用。最终通过反射完成注册方法的调用。

- MethodReference

        void invokeCallback(LifecycleOwner source, Lifecycle.Event event, Object target) {
            //noinspection TryWithIdenticalCatches
            try {
                switch (mCallType) {
                    case CALL_TYPE_NO_ARG:
                        mMethod.invoke(target);
                        break;
                    case CALL_TYPE_PROVIDER:
                        mMethod.invoke(target, source);
                        break;
                    case CALL_TYPE_PROVIDER_WITH_EVENT:
                        mMethod.invoke(target, source, event);
                        break;
                }
            } catch (InvocationTargetException e) {
                throw new RuntimeException("Failed to call observer method", e.getCause());
            } catch (IllegalAccessException e) {
                throw new RuntimeException(e);
            }
        }

整体流程总结：

ReportFragment -> LifecycleRegistry的mObserverMap[观察者Map] -> 触发Observer的onStateChanged方法的调用；

不同的Observer在收到生命周期变化的时候(onStateChanged被调用)，所做的处理是不一样的：

• ReflectiveGenericLifecycleObserver(通过注解感知生命周期) - 反射调用注解方法
• LifecycleBoundObserver(LiveData自定义Observer) - 触发postValue/setValue方法调用