Lifecycle 是我认为 android Jetpack 里面我认为最核心的一个库。包括LiveData 、ViewModel 可以说都是在Lifecycle的基础上构建自己的逻辑。
它用很简单但是却很巧妙的方式，为我们提供了生命周期的回调，方便我们进行各种控制。
//监听Activity/Fragment 周期
lifecycle.addObserver(object :LifecycleEventObserver{
override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
}
//注册监听activity的周期
registerActivityLifecycleCallbacks(new ActivityLifecycleCallbacks() {
@Override
public void onActivityCreated(@NonNull Activity activity, @Nullable Bundle savedInstanceState) {
}
@Override
public void onActivityStarted(@NonNull Activity activity) {
}
@Override
public void onActivityResumed(@NonNull Activity activity) {
}
@Override
public void onActivityPaused(@NonNull Activity activity) {
}
@Override
public void onActivityStopped(@NonNull Activity activity) {
}
@Override
public void onActivitySaveInstanceState(@NonNull Activity activity, @NonNull Bundle outState) {
}
@Override
public void onActivityDestroyed(@NonNull Activity activity) {
}
});
核心类如下
-
LifecycleOwner -
LifecycleObserver -
LifecycleRegistry -
Lifecycle
核心类的分析
LifecycleOwner
生命周期拥有者，现在高版本sdk，默认的ComponentActivity/Fragment 其实都实现了该接口。
LifecycleObserver
生命周期观察者
谷歌默认实现的有如下几个可以方便我们使用，
LifecycleEventObserver
DefaultLifecycleObserver
FullLifecycleObserverAdapter
LifecycleRegistry
核心部件， 继承 抽象类 Lifecycle，可以为无生命周期的组件添加生命周期。
常用方法
addObserver //添加回调
handleLifecycleEvent(Lifecycle.Event.ON_CREATE)//下发生命周期
markState() //过时
setCurrentState（State state）//设置状态
moveToState(State next)//移动到某个状态
Lifecycle
该类主要提供 Event 和State, 可以看出Event和我们常见的页面生命周期差不多，
在 getTargetState 方法中，提供了对于当前Event 对应的 State的状态。也就说State 只有四种 创建，启动，可见，销毁，但是Event 可以对应的更加详细一些。
该类还提供了State向上向下推进的时候，返回的下一阶段的State，我很喜欢用状态机这个词语来描述，比较好理解。
//State状态
public enum Event {
ON_CREATE,
ON_START,
ON_RESUME,
ON_PAUSE,
ON_STOP,
ON_DESTROY,
ON_ANY;
@Nullable
public static Event downFrom(@NonNull State state) {
switch (state) {
case CREATED:
return ON_DESTROY;
case STARTED:
return ON_STOP;
case RESUMED:
return ON_PAUSE;
default:
return null;
}
}
@Nullable
public static Event downTo(@NonNull State state) {
switch (state) {
case DESTROYED:
return ON_DESTROY;
case CREATED:
return ON_STOP;
case STARTED:
return ON_PAUSE;
default:
return null;
}
}
@Nullable
public static Event upFrom(@NonNull State state) {
switch (state) {
case INITIALIZED:
return ON_CREATE;
case CREATED:
return ON_START;
case STARTED:
return ON_RESUME;
default:
return null;
}
}
@Nullable
public static Event upTo(@NonNull State state) {
switch (state) {
case CREATED:
return ON_CREATE;
case STARTED:
return ON_START;
case RESUMED:
return ON_RESUME;
default:
return null;
}
}
@NonNull
public State getTargetState() {
switch (this) {
case ON_CREATE:
case ON_STOP:
return State.CREATED;
case ON_START:
case ON_PAUSE:
return State.STARTED;
case ON_RESUME:
return State.RESUMED;
case ON_DESTROY:
return State.DESTROYED;
case ON_ANY:
break;
}
throw new IllegalArgumentException(this + " has no target state");
}
}
@SuppressWarnings("WeakerAccess")
public enum State {
DESTROYED,
INITIALIZED,
STARTED,
RESUMED;
public boolean isAtLeast(@NonNull State state) {
return compareTo(state) >= 0;
}
}
LifecycleRegistry 相关分析
构造函数
private final WeakReference<LifecycleOwner> mLifecycleOwner;
private final boolean mEnforceMainThread;
public LifecycleRegistry(@NonNull LifecycleOwner provider) {
this(provider, true);
}
private LifecycleRegistry(@NonNull LifecycleOwner provider, boolean enforceMainThread) {
mLifecycleOwner = new WeakReference<>(provider);
mState = INITIALIZED;
mEnforceMainThread = enforceMainThread;
}
构建一个弱引用的 mLifecycleOwner 用于 包裹 LifecycleOwner，控制内存泄露。
默认 mState 推进到 INITIALIZED。默认为主线程。
addObserver( )
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
//判断是否主线程
enforceMainThreadIfNeeded("addObserver");
//构建默认state 如果当前是 DESTROYED 那就是 DESTROYED 否则就是默认初始化INITIALIZED
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
//构建一个 statefulObserver对象
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
//缓存进map集合
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
//如果已经添加过了就返回 不在走下面的逻辑
if (previous != null) {
return;
}
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
//如果已经销毁了则返回
if (lifecycleOwner == null) {
return;
}
//第一次为false
boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
//求出当前最小的阶段
State targetState = calculateTargetState(observer);
//++
mAddingObserverCounter++;
//如果比当前阶段还小而且还是当前集合中的observer
//会不断的去推进observer中当前状态 知道配平为止
while ((statefulObserver.mState.compareTo(targetState) < 0
&& mObserverMap.contains(observer))) {
pushParentState(statefulObserver.mState);
final Event event = Event.upFrom(statefulObserver.mState);
if (event == null) {
throw new IllegalStateException("no event up from " + statefulObserver.mState);
}
statefulObserver.dispatchEvent(lifecycleOwner, event);
popParentState();
targetState = calculateTargetState(observer);
}
if (!isReentrance) {
//这里是同步所有的保存的observer 的状态 如果最老的和最新的推进的状态不一致的话
sync();
}
mAddingObserverCounter--;
}
这里涉及到一个类 ObserverWithState ,可以看出当调用dispatchEvent 的时候，就会回调
LifecycleOwner接口的onStateChanged。
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;
}
}
handleLifecycleEvent（Lifecycle.Event event）event的回调
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
//判断主线程 并移动生命周期
enforceMainThreadIfNeeded("handleLifecycleEvent");
moveToState(event.getTargetState());
}
setCurrentState( )设置当前状态
@MainThread
public void setCurrentState(@NonNull State state) {
enforceMainThreadIfNeeded("setCurrentState");
moveToState(state);
}
moveToState( ) 状态的移动
private void moveToState(State next) {
//如果设置的状态和当前一致 就返回
if (mState == next) {
return;
}
//不能够设置INITIALIZED 和 DESTROYED 没什么意义
if (mState == INITIALIZED && next == DESTROYED) {
throw new IllegalStateException("no event down from " + mState);
}
mState = next;
if (mHandlingEvent || mAddingObserverCounter != 0) {
mNewEventOccurred = true;
// we will figure out what to do on upper level.
return;
}
//设置当前状态后会进行所有的 observer 的状态同步，如果同步完发现到DESTROYED 就可以清空缓存重新构建了。
mHandlingEvent = true;
sync();
mHandlingEvent = false;
if (mState == DESTROYED) {
mObserverMap = new FastSafeIterableMap<>();
}
}
isSynced( ) 是否同步
private boolean isSynced() {
if (mObserverMap.size() == 0) {
return true;
}
State eldestObserverState = mObserverMap.eldest().getValue().mState;
State newestObserverState = mObserverMap.newest().getValue().mState;
return eldestObserverState == newestObserverState && mState == newestObserverState;
}
至此我们大体上了解 在LifecycleRegistry 中，添加一个新的 LifecycleObserver的时候，会将当前状态mState 配平到 LifecycleObserver 中，并会回调 onStateChanged（） 方法。
在Activity/Fragment中相关逻辑
这里先来讲一个核心类 ReportFragment
ReportFragment
public class ReportFragment extends android.app.Fragment {
public static void injectIfNeededIn(Activity activity) {
//版本29以后
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();
}
}
private void dispatch(@NonNull Lifecycle.Event event) {
if (Build.VERSION.SDK_INT < 29) {
dispatch(getActivity(), event);
}
}
//多参
static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
//如果是 LifecycleRegistryOwner 则转换为 LifecycleRegistryOwner 回调handleLifecycleEvent
if (activity instanceof LifecycleRegistryOwner) {
((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
return;
}
//如果是 LifecycleOwner 也回调handleLifecycleEvent
if (activity instanceof LifecycleOwner) {
Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
if (lifecycle instanceof LifecycleRegistry) {
((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
}
}
}
@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);
}
//。。。省略
}
涉及方法如下
injectIfNeededIn()
我们先暂时不管 LifecycleCallbacks.registerIn(activity);
这个方法的主要作用就是给传入的activity 添加了一个 ReportFragment
然后在 ReportFragment 被回调onResume /onStart 等方法时候，会调用
dispatch(Lifecycle.Event.ON_START); 等。该方法回回调dispatch 多参方法。
dispatch(Activity activity,Lifecycle.Event event)
这里就比较简单，就是判断类型然后回调 handleLifecycleEvent ，这里要注意一下
FragmentActivity继承了ComponentActivity， 而ComponentActivity是实现了 LifecycleOwner，所以会走下面代码 调用
getLifecycle()，然后调用 handleLifecycleEvent（）。
总结一下： 主要依赖于ReportFragment的生命周期去处理回调，大名鼎鼎的Glide 其实也是使用这种方法 去管理生命周期。我个人一直认为谷歌借鉴了Glide。
版本29以后的我们放在最后讲一下。
ComponentActivity
public class ComponentActivity extends androidx.core.app.ComponentActivity implements LifecycleOwner
private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
protected void onCreate(@Nullable Bundle savedInstanceState) {
//省略
ReportFragment.injectIfNeededIn(this);
}
@NonNull
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
我们再看完 ReportFragment 后了解 是依托于它的生命周期进行事件的分发，
这里如果我们是ComponentActivity的情况下，日常使用getLifecycle().addObserver()
其实就会回调 mLifecycleRegistry去调用addObserver（LifecycleObserver observer）。当ReportFragment 开始生命周期的时候，就会进行如下一串的调用
LifecycleRegistry的handleLifecycleEvent()
->moveToState()
->sync()
->backwardPass()/forwardPass() ->
ObserverWithState(lifecycleOwner, event);
->LifecycleEventObserver.onStateChanged()
最后回调到我们的回调里。
可以简单的看出在ComponentActivity中 其实就是利用了 LifecycleRegistry 进行的生命周期回调。
FragmentActivity
public class FragmentActivity extends ComponentActivity{
final LifecycleRegistry mFragmentLifecycleRegistry = new LifecycleRegistry(this);
public Lifecycle getLifecycle() {
return mFragmentLifecycleRegistry;
}
}
protected void onStart() {
//省略
mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
mFragments.dispatchStart();
}
@Override
protected void onStop() {
super.onStop();
mFragments.dispatchStop();
mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
}
protected void onDestroy() {
super.onDestroy();
mFragments.dispatchDestroy();
mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);
}
@Override
protected void onPause() {
super.onPause();
mResumed = false;
mFragments.dispatchPause();
mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
}
//省略
FragmentActivity 虽然继承了 ComponentActivity，但是它没有使用ReportFragment ，而是在自己的生命周期的时候，调用 LifecycleRegistry 进行了事件的分发，可以看出大部分时间 先进了对自己所拥有的的Fragment的生命周期回调，保证了包含的Fragment的生命周期正常推进，然后才调用了分发。
Fragment
public class Fragment implements LifecycleOwner{
public Fragment() {
initLifecycle();
}
private void initLifecycle() {
mLifecycleRegistry = new LifecycleRegistry(this);
mSavedStateRegistryController = SavedStateRegistryController.create(this);
}
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
void performCreate(Bundle savedInstanceState) {
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
}
void performResume() {
//省略
onResume();
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
if (mView != null) {
mViewLifecycleOwner.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
}
mChildFragmentManager.dispatchResume();
}
void performCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container,
@Nullable Bundle savedInstanceState) {
mChildFragmentManager.noteStateNotSaved();
mPerformedCreateView = true;
mViewLifecycleOwner = new FragmentViewLifecycleOwner(this, getViewModelStore());
mView = onCreateView(inflater, container, savedInstanceState);
if (mView != null) {
mViewLifecycleOwner.initialize();
ViewTreeLifecycleOwner.set(mView, mViewLifecycleOwner);
ViewTreeViewModelStoreOwner.set(mView, mViewLifecycleOwner);
ViewTreeSavedStateRegistryOwner.set(mView, mViewLifecycleOwner);
mViewLifecycleOwnerLiveData.setValue(mViewLifecycleOwner);
}
}
//省略
}
Fragment 在空的构造里构建了LifecycleRegistry ，自己维护了生命周期的分发。当FragmentStateManager调用对应的方法时，进行了对应的Event分发，这里有个比较有意思的mViewLifecycleOwner ，在构造的View 的时候，View 也进行了生命周期的监控。这块不扩展，但是也可见谷歌的想法 是处处皆可以生命周期维护。
到此可以看出，其实LifeCycle的核心机制，在FragmentActivity和Fragment其实还是走的基础的生命周期 ，自己进行了事件的分发。而ComponentActivity 是自己添加了 ReportFragment，借用了它的生命周期进行了事件的分发。基于状态的逐渐推进和回退，形成了一个巧妙的观察者模式。
Application
我们知道很早以前的时候，监听Activity的构建和销毁，基本都在Base类里 进行一个单例的Map/List 进行添加和删除，但是LifeCycle 提供了 给Application 的全局监听
在高版本上，我们可以写下如下代码，就实现了我们所需。那为什么？
public class Application extends android.app.Application {
@Override
public void onCreate() {
super.onCreate();
registerActivityLifecycleCallbacks(new ActivityLifecycleCallbacks() {
@Override
public void onActivityCreated(@NonNull Activity activity, @Nullable Bundle savedInstanceState) {
}
@Override
public void onActivityStarted(@NonNull Activity activity) {
}
@Override
public void onActivityResumed(@NonNull Activity activity) {
}
//省略
});
}
}
我们先看完如下两段代码，我们得知 在Acitivity的对应生命周期，会回调Application的
.dispatchActivityxxxx()方法。然后会回调我们注册的页面监听。也就实现了上面代码的回调。
//Acitivity
public void registerActivityLifecycleCallbacks(
@NonNull Application.ActivityLifecycleCallbacks callback) {
synchronized (mActivityLifecycleCallbacks) {
mActivityLifecycleCallbacks.add(callback);
}
}
//onCreate()调用dispatchActivityCreated（）
private void dispatchActivityCreated(@Nullable Bundle savedInstanceState) {
//调用application.dispatchActivityCreated()
getApplication().dispatchActivityCreated(this, savedInstanceState);
Object[] callbacks = collectActivityLifecycleCallbacks();
if (callbacks != null) {
for (int i = 0; i < callbacks.length; i++) {
((Application.ActivityLifecycleCallbacks) callbacks[i]).onActivityCreated(this,
savedInstanceState);
}
}
}
//onStart()->调用 dispatchActivityStarted（）
private void dispatchActivityStarted() {
//调用application.dispatchActivityStarted()
getApplication().dispatchActivityStarted(this);
Object[] callbacks = collectActivityLifecycleCallbacks();
if (callbacks != null) {
for (int i = 0; i < callbacks.length; i++) {
((Application.ActivityLifecycleCallbacks) callbacks[i]).onActivityStarted(this);
}
}
}
// onStop()-->调用 dispatchActivityStopped
private void dispatchActivityStopped() {
//回掉注册的的callBack
Object[] callbacks = collectActivityLifecycleCallbacks();
if (callbacks != null) {
for (int i = callbacks.length - 1; i >= 0; i--) {
((Application.ActivityLifecycleCallbacks) callbacks[i]).onActivityStopped(this);
}
}
// //调用application.dispatchActivityStopped()
getApplication().dispatchActivityStopped(this);
}
//省略。。。
//Applicaion
//监听回调
private ArrayList<ActivityLifecycleCallbacks> mActivityLifecycleCallbacks =
new ArrayList<ActivityLifecycleCallbacks>();
//注册回调
public void registerActivityLifecycleCallbacks(ActivityLifecycleCallbacks callback) {
synchronized (mActivityLifecycleCallbacks) {
mActivityLifecycleCallbacks.add(callback);
}
}
//唤醒回调
@UnsupportedAppUsage
/* package */ void dispatchActivityCreated(@NonNull Activity activity,
@Nullable Bundle savedInstanceState) {
Object[] callbacks = collectActivityLifecycleCallbacks();
if (callbacks != null) {
for (int i=0; i<callbacks.length; i++) {
//回调注册的监听
((ActivityLifecycleCallbacks)callbacks[i]).onActivityCreated(activity,
savedInstanceState);
}
}
}
//省略
在ReportFragment里，我们讲版本29以后会多调用 LifecycleCallbacks.registerIn(activity);,
其实就会调用到Acitivity的registerActivityLifecycleCallbacks()。Activity 在执行生命周期的时候，就会回调到下面的内部类LifecycleCallbacks，对应的方法，然后调用dispatch（Activity activity, @NonNull Lifecycle.Event event);方法，然后调用事件的分发。这样更加的生命周期是依赖于Activity的生命周期。做个理解就好。只能说谷歌大佬脑洞大，各种优化都埋下。
public static void injectIfNeededIn(Activity activity) {
if (Build.VERSION.SDK_INT >= 29) {
LifecycleCallbacks.registerIn(activity);
}
//省略
}
}
@RequiresApi(29)
static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {
static void registerIn(Activity activity) {
activity.registerActivityLifecycleCallbacks(new LifecycleCallbacks());
}
@Override
public void onActivityCreated(@NonNull Activity activity,
@Nullable Bundle bundle) {
}
@Override
public void onActivityPostCreated(@NonNull Activity activity,
@Nullable Bundle savedInstanceState) {
dispatch(activity, Lifecycle.Event.ON_CREATE);
}
@Override
public void onActivityStarted(@NonNull Activity activity) {
}
//省略
}
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);
}
}
}
总结
核心类其实是 LifecycleRegistry，内部实现了对新添加的观察者的状态配平以及状态回调。
ComponentActivity 是依赖于ReportFragment 的生命周期回调，调用内部构建的LifecycleRegistry进行了生命周期的回调。 在29以后 ，额外添加了依赖于Activity的生命周期的回调。
Fragment和FragmentActivity 在内部构建了LifecycleRegistry，依赖于自己的生命周期进行了 对生命周期状态的分发。
Application 对于页面的监听，则依赖于Activity 的生命周期回调，对于注册的ActivityLifecycleCallback进行依次回调。
其实Lifecycle 原理并不复杂，甚至简单到我这些小白都能很快理解，但是我个人觉得他最厉害的一点是进行了统一的封装，保证了我们可以随时对于生命周期进行获取和监听。基于此我们甚至可以模仿Fragment中的mViewLifecycleOwner 对于基础View 进行构建，不再仅仅依赖于 onDetachedFromWindow/onAttachedToWindow ，让对于生命周期的观测更加简单。
才疏学浅，希望诸位大佬多多斧正。
