【Android Jetpack】Lifecycle你真的懂了吗？ |
您所在的位置：网站首页 › fragement生命周期 › 【Android Jetpack】Lifecycle你真的懂了吗？ |
【Android Jetpack】Lifecycle你真的懂了吗？
|
Lifecycle生命周期感知型组件，用来执行、操作、响应另一个组件（如 Activity 和 Fragment）的生命周期状态的变化。 本文Lifecycle版本为2.2.0： implementation 'androidx.lifecycler:lifecycle-common:2.2.0' //22.2.23 更新 2.5 ，2.2是用的比较多的版本你真的了解Lifecycle了吗？Lifecycle使用非常非常简单。默认你已经使用过Lifecycle。但如果我问你以下几个问题。你能回答出来几个？ Lifecycle的创建方式有几种？有什么不同？推荐使用哪种？为什么？Event事件和State状态是什么关系onStop()生命周期，处于什么State状态Lifecycle是如何进行生命周期同步如果在onResume() 注册观察者会收到那几个种回调？为什么？Activity/Fragment 实现Lifecycle能力的方式一样吗？为什么要这么设计？有什么好处？Application能感知Activity生命周期吗?（如何使用Lifecycle监听前后台的能力）Lifecycle从源码角度，简述Lifecycle的注册，派发，感知的过程什么嵌套事件？发生的时机？Lifecycle是如何解决的？如果我是面试官，遇到简历上写掌握Jetpack组件，我一定是会问Lifecycle这几个问题。因为它首先是Jetpack另外两个超级核心组件ViewModel,LiveData，实现能力的基石。同时它的使用频率也非常高，看似简单，容易被忽略，但却很多东西值得学习。 这十几个问题，从用法到源码，从表面到延伸。如果全懂，说明你真正掌握了Lifecycle的80%，没错~！仅仅是8成。因为下面的源码分析，还会有更多延伸的问题. Lifecycle基本使用作为生命周期感知组件、它的作用就是监听宿主Activity/Fragment，然后派发给观察者。这句看似简单的概括，却倒出3个重要的角色： 宿主，观察者，用来派发的调度器  使用Lifecycle的方法很简单： 先创建Observer，可以直接继承父类：LifecycleObserverpublic class LocationObserver implements LifecycleObserver { private static final String TAG = "LocationObserver"; //1. 自定义的LifecycleObserver观察者，用注解声明每个方法观察的宿主的状态 @OnLifecycleEvent(Lifecycle.Event.ON_CREATE) void onCreate(@NotNull LifecycleOwner owner) { Timber.e("onCreate_ON_CREATE"); } @OnLifecycleEvent(Lifecycle.Event.ON_START) void onStart(@NotNull LifecycleOwner owner) { Timber.e("onStart_ON_START"); } @OnLifecycleEvent(Lifecycle.Event.ON_RESUME) void onResume(@NotNull LifecycleOwner owner) { Timber.e("onResume_ON_RESUME"); } @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE) void onPause(@NotNull LifecycleOwner owner) { Timber.e("onPause_ON_PAUSE"); } @OnLifecycleEvent(Lifecycle.Event.ON_STOP) void onStop(@NotNull LifecycleOwner owner) { Timber.e("onStop_ON_STOP"); } @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY) void onDestroy(@NotNull LifecycleOwner owner) { Timber.e("onDestroy_ON_DESTROY"); } @OnLifecycleEvent(Lifecycle.Event.ON_ANY) void onAny(LifecycleOwner owner) { Timber.e("onAny_ON_ANY-->%s", owner.getLifecycle().getCurrentState()); } } 自己定义`生命周期方法，并在每个方法上面标记对应生命周期的注解。同时还能获得`LifecycleOwner `也就是`宿主Activity继承：LifecycleEventObserver，复写onStateChanged方法：public class EventObserver implements LifecycleEventObserver { @Override public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) { switch (event) { case ON_CREATE: Timber.d("ON_CREATE"); break; case ON_START: Timber.d("ON_START"); break; case ON_RESUME: Timber.d("ON_RESUME"); break; case ON_PAUSE: Timber.d("ON_PAUSE"); break; case ON_STOP: Timber.d("ON_STOP"); break; case ON_DESTROY: Timber.d("ON_DESTROY"); break; default: break; } } } 继承：FullLifecycleObserver，直接复写对应的生命周期回调：public class FullLocationObserver implements DefaultLifecycleObserver { @Override public void onCreate(@NonNull LifecycleOwner owner) { Timber.e("onCreate"); } @Override public void onStart(@NonNull LifecycleOwner owner) { Timber.e("onStart"); } @Override public void onResume(@NonNull LifecycleOwner owner) { Timber.e("onResume"); } @Override public void onPause(@NonNull LifecycleOwner owner) { Timber.e("onPause"); } @Override public void onStop(@NonNull LifecycleOwner owner) { Timber.e("onStop"); } @Override public void onDestroy(@NonNull LifecycleOwner owner) { Timber.e("onDestroy"); } }此时你会发现，你无法直接继承FullLifecycleObserver这时你要添加一个依赖： implementation 'androidx.lifecycler:lifecycle-common:2.2.0' 替换上面引入的依赖(默认会集成上面的) implementation "androidx.lifecycle:lifecycle-common-java8:2.2.0"继承：DefaultLifecycleObserver，它是FullLifecycleObserver的子类，因为在Java8以后，支持interface接口类型，可以有自己的默认实现。 然后在Activity#OnCreate()中调用如下方法： lifecycle.addObserver(LocationObserver())接着，你就可以使用Lifecycle的能力了。 从源码了解过程如果是MVP，你可以让你的Presenter去实现Observer，在处理逻辑时获得感知的能力。但如果我们把注册的代码lifecycle.addObserver(LocationObserver())放入onResume()方法中，会发生什么？你会发现Observer除了可以收到onResume事件，竟然还可以收到onCreate,onStart。也就说宿主的状态，会同步给观察者。这是怎么做到的？ 感知监听 getLifecycle点进去，会进入到ComponentActivity核心代码： public class ComponentActivity extends Activity implements LifecycleOwner{ private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this); @NonNull @Override public Lifecycle getLifecycle() { return mLifecycleRegistry; } protected void onCreate(Bundle bundle) { super.onCreate(savedInstanceState); //往Activity上添加一个fragment,用以报告生命周期的变化 //目的是为了兼顾不是继承自AppCompactActivity的场景. ReportFragment.injectIfNeededIn(this); } LifecycleRegistry是Lifecycle的子类，通过new LifecycleRegistry(this);把宿主Owner,也就是当前Activity作为构造参数传递进去Activity并不是直接派发生命周期，而是利用ReportFragment.injectIfNeededIn(this)，public class ReportFragment extends Fragment{ public static void injectIfNeededIn(Activity 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(); } } @Override public void onStart() { super.onStart(); dispatch(Lifecycle.Event.ON_START); } @Override public void onResume() { super.onResume(); dispatch(Lifecycle.Event.ON_RESUME); } @Override public void onPause() { super.onPause(); dispatch(Lifecycle.Event.ON_PAUSE); } @Override public void onDestroy() { super.onDestroy(); dispatch(Lifecycle.Event.ON_DESTROY); } private void dispatch(Lifecycle.Event event) { //调用宿主的Lifecycle Lifecycle lifecycle = activity.getLifecycle(); if (lifecycle instanceof LifecycleRegistry) { ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event); } }ReportFragment.injectIfNeededIn(this)的作用是在Activity之上，创建一个不可见的Fragment的。当Fragment的生命周期发生变化，会通过dispatch()，接着调用((LifecycleRegistry) lifecycle).handleLifecycleEvent(event)来分发事件。这样做的目的是为了，当页面不是继承ComponentActivity,而是直接继承Activity，那么它就没有了感知的能力。此时需要自己实现LifecycleOwner,复写getLifecycle(),然后将自己传入进new LifecycleRegistry(this),就可以成为宿主，让其他Observer来监听。ReportFragment.injectIfNeededIn(this)另一个使用的地方LifecycleDispatcher： class LifecycleDispatcher { private static AtomicBoolean sInitialized = new AtomicBoolean(false); static void init(Context context) { if (sInitialized.getAndSet(true)) { return; } ((Application) context.getApplicationContext()) .registerActivityLifecycleCallbacks(new DispatcherActivityCallback()); } @SuppressWarnings("WeakerAccess") @VisibleForTesting static class DispatcherActivityCallback extends EmptyActivityLifecycleCallbacks { @Override public void onActivityCreated(Activity activity, Bundle savedInstanceState) { ReportFragment.injectIfNeededIn(activity); } @Override public void onActivityStopped(Activity activity) { } @Override public void onActivitySaveInstanceState(Activity activity, Bundle outState) { } } private LifecycleDispatcher() {直接为Activity注入ReportFragment,使得每个页面都能成为宿主，让观察者感知,当然，你里面要自己实现LifecycleOwner,复写getLifecycle(),然后将自己传入进new LifecycleRegistry(this)。==这部分与Lifecycle关系不大，只是作为知识扩展==  总结： 监听过程就是，Activity/Fragment继承LifecycleOwner,并在子类CommponentActivity中创建Lifecycle的子类LifecycleRegistry。在复写getLifecycle()的方法中将子类LifecycleRegistry返回。在onCreate()中注入ReportFragment，在生命周期回调后，通过getLifecycle()的方法得到LifecycleRegistry对象中的handleLifecycleEvent(event)方法给每个观察者派发生命周期事件。为什么以Activity为例子，而不是像其他文章，以Fragement为例子，是因为你去看眼源码就会发现ReportFragment类中的dispatch()过程和Fragement如出一辙： public class Fragment implements xxx, LifecycleOwner { //... void performCreate(Bundle savedInstanceState) { onCreate(savedInstanceState); //1.先执行生命周期方法 //...省略代码 //2.生命周期事件分发 mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE); } void performStart() { onStart(); //... mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START); } void performResume() { onResume(); //... mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME); } void performPause() { //3.注意，调用顺序变了 mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE); //... onPause(); } void performStop() { mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP); //... onStop(); } void performDestroy() { mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY); //... onDestroy(); } }参照Android 架构组件（一）——Lifecycle, @ShymanZhu文中的时序图：  同时，你会发现Fragment中performCreate()、performStart()、performResume()会先调用自身的onXXX()方法，然后再调用LifecycleRegistry的handleLifecycleEvent()方法；而在performPause()、performStop()、performDestroy()中会先LifecycleRegistry的handleLifecycleEvent()方法 ，然后调用自身的onXXX()方法。同步 上面是监听过程，getLifecycle().addObserver(LocationObserver())注册代码的前半部分。现在我们获得感知宿主的能力，并将事件event转发给LifecycleRegistry,他是整个流程的核心。现在来看后半部分，如何注册Observer后可以在任何时机(onDestory除外),感知完整生命周期。 不过在此之前，我们要先搞懂什么是状态State和事件Event public abstract class Lifecycle { @MainThread public abstract void addObserver(@NonNull LifecycleObserver observer); @MainThread public abstract void removeObserver(@NonNull LifecycleObserver observer); @MainThread @NonNull public abstract State getCurrentState(); public enum Event { ON_CREATE, ON_START, ON_RESUME, ON_PAUSE, ON_STOP, ON_DESTROY, ON_ANY } public enum State { DESTROYED, INITIALIZED, CREATED, /** * after {@link android.app.Activity#onStart() onStart} call; * right before {@link android.app..Activity#onPause( onPause} call. * */ STARTED, RESUMED; public boolean isAtLeast(@NonNull State state) { return compareTo(state) >= 0; } } }在Lifecycle类中除了add，remove外，还有两个枚举类，Event事件对应的就是Activty的onCreate,onStart()事件，而状态却只有5种。以STARTED状态为例：这个状态发生在Activity#onStart()之后，Activity#onPause()之前。什么意思呢？请看下面这张图：  这张图我们一定见过，但这次我们横着对半切一刀,上面表示生命周期的前进,下面表示生命周期的后退，一定要记住，这对我们后的理解源码非常重要，接着我们在解释下： Activity刚刚创建的时候它一定是INITIALIZED状态，执行onCreate()方法后，进入到CREATED状态，执行onStart()方法后，进入到STARTED状态，执行onResume()方法后，进入到RESUMED状态，这个过程就表示生命周期的前进。 当我们跳转下一个Activity后，执行onPase()方法后，又重新回到STARTED状态，执行onStop()方法后，进入到CREATED状态，最后执行onDestory()方法后，进入到DESTROYED状态。这个过程表示生命周期的后退参照Android 架构组件（一）——Lifecycle, @ShymanZhu文中的关系图：  这个图片仅作参考，ObserverWithState类中的关系有所变换，mLifeCycleObserver->LifeCycleEventObserverLifecycleRegistryshi生命周期注册，记录，派发事件的地方，理解状态和事件的关系，对我们搞清楚LifecycleRegistry非常有帮助，下面以在onResume()中调用lifecycle.addObserver(LocationObserver())为例： public LifecycleRegistry(@NonNull LifecycleOwner provider) { mLifecycleOwner = new WeakReference(provider); mState = INITIALIZED; } public void addObserver(@NonNull LifecycleObserver observer) { //1 State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED; //2 ObserverWithState statefulObserver = new ObserverWithState(observer, initialState); //3 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; //4 State targetState = calculateTargetState(observer); mAddingObserverCounter++; while ((statefulObserver.mState.compareTo(targetState) ON_START,getStateAfter(event)：ON_START-->STARTED,保存状态newState,回调监听onStateChanged,保存状态：mState = newState,直到mState = RESUMED 经过循环之后。新注册的Observer和宿主同步到相同的生命周期。 派发 当宿主生命周期发生变化，会调用mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);来向观察者派发，直接看分析然后再结合源码 public void handleLifecycleEvent(@NonNull Lifecycle.Event event) { State next = getStateAfter(event); moveToState(next);//1 } private void moveToState(State next) { mState = next; sync();//2 } private void sync() { while (!isSynced()) {//3 //当宿主状态小于 最早添加进来的观察者，为什么是最早，首先集合中的观察者是按顺序添加的，State应该是一致的，小于最早观察者，一定小于后面最后观察者 if (mState.compareTo(mObserverMap.eldest().getValue().mState) 0) { forwardPass(lifecycleOwner);//5 } } } 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; } private void backwardPass(LifecycleOwner lifecycleOwner) { while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred && mObserverMap.contains(entry.getKey()))) { Event event = downEvent(observer.mState); observer.dispatchEvent(lifecycleOwner, event); } } private void forwardPass(LifecycleOwner lifecycleOwner) { while ((observer.mState.compareTo(mState) 0 上面判断是宿主小于观察者，backwardPass判断观察者大于宿主，完全是一个意思，接着会调用downEvent,根据状态回退RESUMED-->ON_PAUSEobserver.dispatchEvent(lifecycleOwner, event)更新状态，分发观察者事件，更新mStatemState.compareTo(newest.getValue().mState) > 0 事件前进forwardPass(lifecycleOwner);与之前同步过程完全相同 统一Observer思考一个问题：ObserverWithState#dispatch是给观察者分发事件的位置，但他调用的是onStateChange()，但我们回调方式的实现，是完全不同的，他是如何做到统一的呢？ 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; } }mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer)答案就是适配器模式，看就在这里： @NonNull static LifecycleEventObserver lifecycleEventObserver(Object object) {//Object 就是传入的observer 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(); //关键代码 int type = getObserverConstructorType(klass); if (type == GENERATED_CALLBACK) { List |
【本文地址】
今日新闻 |
推荐新闻 |