源码进阶之lifecycle组件原理分析

移动开发 Android
如何利用 android.arch.lifecycle 包提供的类来控制数据、监听器等的 lifecycle。同时,LiveData 与 ViewModel 的 lifecycle 也依赖于 Lifecycle 框架;今天我们就来聊聊lifecycle的实现原理,来一波分析。

[[421728]]

前言

如何利用 android.arch.lifecycle 包提供的类来控制数据、监听器等的 lifecycle。同时,LiveData 与 ViewModel 的 lifecycle 也依赖于 Lifecycle 框架;

今天我们就来聊聊lifecycle的实现原理,来一波分析

一、为什么要引进Lifecycle?

1、没有引进Lifecycle做法

  • 在处理Activity或者Fragment组件的生命周期相关时,不可避免会遇到这样的问题;
  • 在Activity的onCreate()中初始化某些成员(比如MVP架构中的Presenter,或者AudioManager、MediaPlayer等),然后在onStop中对这些成员进行对应处理,在onDestroy中释放这些资源,这样导致我们的代码也许会像这样;
  1. class MyPresenter{ 
  2.     public MyPresenter() { 
  3.     } 
  4.     void create() { 
  5.         //do something 
  6.     } 
  7.     void destroy() { 
  8.         //do something 
  9.     } 
  10. class MyActivity extends AppCompatActivity { 
  11.     private MyPresenter presenter; 
  12.     public void onCreate(...) { 
  13.         presenter= new MyPresenter (); 
  14.         presenter.create(); 
  15.     } 
  16.     public void onDestroy() { 
  17.         super.onDestroy(); 
  18.         presenter.destory(); 
  19.     } 

代码没有问题,关键问题是,实际生产环境中 ,这样的代码会非常复杂,你最终会有太多的类似调用并且会导致 onCreate() 和 onDestroy() 方法变的非常臃肿;

2、引进Lifecycle做法

Lifecycle 是一个类,它持有关于组件(如 Activity 或 Fragment)生命周期状态的信息,并且允许其他对象观察此状态;

代码如下:

Prestener继承LifecycleObserver接口

  1. public interface IPresenter extends LifecycleObserver { 
  2.     @OnLifecycleEvent(Lifecycle.Event.ON_CREATE) 
  3.     void onCreate(@NotNull LifecycleOwner owner); 
  4.     @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY) 
  5.     void onDestroy(@NotNull LifecycleOwner owner); 
  6.     @OnLifecycleEvent(Lifecycle.Event.ON_ANY) 
  7.     void onLifecycleChanged(@NotNull LifecycleOwner owner, 
  8.                             @NotNull Lifecycle.Event event); 
  9. public class BasePresenter implements IPresenter { 
  10.     private static final String TAG = "com.qingmei2.module.base.BasePresenter";     
  11.     @Override 
  12.     public void onLifecycleChanged(@NotNull LifecycleOwner owner, @NotNull Lifecycle.Event event) { 
  13.     } 
  14.     @Override 
  15.     public void onCreate(@NotNull LifecycleOwner owner) { 
  16.         Log.d("tag""BasePresenter.onCreate" + this.getClass().toString()); 
  17.     } 
  18.     @Override 
  19.     public void onDestroy(@NotNull LifecycleOwner owner) { 
  20.         Log.d("tag""BasePresenter.onDestroy" + this.getClass().toString()); 
  21.     } 

直接将我想要观察到Presenter的生命周期事件都列了出来,然后封装到BasePresenter 中,这样每一个BasePresenter 的子类都能感知到Activity容器对应的生命周期事件,并在子类重写的方法中,对应相应行为

在Activity/Fragment容器中添加Observer

  1. public class MainActivity extends AppCompatActivity { 
  2.     private IPresenter mPresenter; 
  3.     @Override 
  4.     protected void onCreate(Bundle savedInstanceState) { 
  5.         super.onCreate(savedInstanceState); 
  6.         Log.d("tag""onCreate" + this.getClass().toString()); 
  7.         setContentView(R.layout.activity_main); 
  8.         mPresenter = new MainPresenter(this); 
  9.         getLifecycle().addObserver(mPresenter);//添加LifecycleObserver 
  10.     } 
  11.     @Override 
  12.     protected void onDestroy() { 
  13.         Log.d("tag""onDestroy" + this.getClass().toString()); 
  14.         super.onDestroy(); 
  15.     } 

每当Activity发生了对应的生命周期改变,Presenter就会执行对应事件注解的方法

二、Lifecycle原理层层深入分析

在Activity 获取 Lifecycle,实际上是通过Activity的父类 ComponentActvitiy 获取,父类实现了 LifecycleOwner 接口,就能获取 Lifecycle ,最后注册 LifecycleObserver 就能拿到生命周期回调了

1、 onCreate

  1. 在ComponentActvitiy的 onCreate 方法里面可以看到 ReportFragment 的创建。 
  2.     /* ComponentActvitiy */ 
  3.     @Override 
  4.     protected void onCreate(@Nullable Bundle savedInstanceState) { 
  5.         ... 
  6.         ReportFragment.injectIfNeededIn(this); 
  7.         ... 
  8.     } 

2、 getLifecycle方法

  1. /* ComponentActvitiy */ 
  2.   private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this); 
  3.   @NonNull 
  4.   @Override 
  5.   public Lifecycle getLifecycle() { 
  6.       return mLifecycleRegistry; 
  7.   } 
  8.  Life 

3、 Lifecycle.Event

Lifecycle.Event 是个枚举类,这里的生命周期 Event 并不是Fragment的,在后面的生命周期处理时会用上的。

  1. public enum Event { 
  2.      ON_CREATE, 
  3.      ON_START, 
  4.      ON_RESUME, 
  5.      ON_PAUSE, 
  6.      ON_STOP, 
  7.      ON_DESTROY, 
  8.      ON_ANY; 
  9.     ... 
  10.  } 

4、 ReportFragment的创建

ReportFragment 是一个 没有界面的Fragment,如果有了解过Glide原理的同学,应该也知道这个方法,就是通过看不见的Fragment,来感知生命周期,让使用者无需考虑生命周期的问题。

在SDK29以上的版本 使用的是 LifecycleCallbacks.registerIn(activity)。

  1. /* ReportFragment */ 
  2.   public static void injectIfNeededIn(Activity activity) { 
  3.       if (Build.VERSION.SDK_INT >= 29) { 
  4.           // On API 29+, we can register for the correct Lifecycle callbacks directly 
  5.           LifecycleCallbacks.registerIn(activity); 
  6.       } 
  7.       // Prior to API 29 and to maintain compatibility with older versions of 
  8.       // ProcessLifecycleOwner (which may not be updated when lifecycle-runtime is updated and 
  9.       // need to support activities that don't extend from FragmentActivity from support lib), 
  10.       // use a framework fragment to get the correct timing of Lifecycle events 
  11.       android.app.FragmentManager manager = activity.getFragmentManager(); 
  12.       if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) { 
  13.           manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit(); 
  14.           // Hopefully, we are the first to make a transaction
  15.           manager.executePendingTransactions(); 
  16.       } 
  17.   } 

5、 LifecycleCallbacks.registerIn(activity)

LifecycleCallbacks 实现了 Application.ActivityLifecycleCallbacks接口,在SDK29以上的生命周期分发是由Application 分发的,activity注册就能回调。

大名鼎鼎的LeakCanary在监听Activity生命周期,也是使用

  1. Application.ActivityLifecycleCallbacks。 
  2.     @RequiresApi(29) 
  3.     static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks { 
  4.         static void registerIn(Activity activity) { 
  5.             activity.registerActivityLifecycleCallbacks(new LifecycleCallbacks()); 
  6.         } 
  7.         ... 
  8.         @Override 
  9.         public void onActivityPostCreated(@NonNull Activity activity, 
  10.                 @Nullable Bundle savedInstanceState) { 
  11.             dispatch(activity, Lifecycle.Event.ON_CREATE); 
  12.         } 
  13.       ... 
  14.     } 

6、 ReportFragment.dispatch 版本兼容

如果SDK版本小于29,ReportFragment的各个生命周期方法里,会调用 dispatch 方法。

比如 onActivityCreated。

反正无论是使用 LifecycleCallbacks.registerIn(activity),还是 Fragment 的生命周期回调,最后都会dispatch。

  1. @Override 
  2.    public void onActivityCreated(Bundle savedInstanceState) { 
  3.        super.onActivityCreated(savedInstanceState); 
  4.        dispatchCreate(mProcessListener); 
  5.        dispatch(Lifecycle.Event.ON_CREATE); 
  6.    } 
  7.    private void dispatch(@NonNull Lifecycle.Event event) { 
  8.        if (Build.VERSION.SDK_INT < 29) { 
  9.            // Only dispatch events from ReportFragment on API levels prior 
  10.            // to API 29. On API 29+, this is handled by the ActivityLifecycleCallbacks 
  11.            // added in ReportFragment.injectIfNeededIn 
  12.            dispatch(getActivity(), event); 
  13.        } 
  14.    } 
  15.    static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) { 
  16.        if (activity instanceof LifecycleRegistryOwner) { 
  17.            ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event); 
  18.            return
  19.        } 
  20.        if (activity instanceof LifecycleOwner) { 
  21.            Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle(); 
  22.            if (lifecycle instanceof LifecycleRegistry) { 
  23.                ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event); 
  24.            } 
  25.        } 
  26.    } 

7、 Lifecycle.State

State只有5个但是生命周期可是不止5个,所以Google他们设计时,就创建流程正着走,销毁流程就反正走。

  1. Lifecycle.State 
  2.     /* Lifecycle.State */ 
  3.     public enum State { 
  4.         DESTROYED, 
  5.         INITIALIZED, 
  6.         CREATED, 
  7.         STARTED, 
  8.         RESUMED; 
  9.         public boolean isAtLeast(@NonNull State state) { 
  10.             return compareTo(state) >= 0; 
  11.         } 
  12.     } 

8、 handleLifecycleEvent

LifecycleRegistryOwner 也是继承 LifecycleOwner,所以他们最后都会执行 LifecycleRegistry 的 handleLifecycleEvent 方法。

就是把 Lifecycle.Event处理一下,转化成 Lifecycle.State

  1. /* Lifecycle.Event */ 
  2.       @NonNull 
  3.       public State getTargetState() { 
  4.           switch (this) { 
  5.               case ON_CREATE: 
  6.               case ON_STOP: 
  7.                   return State.CREATED; 
  8.               case ON_START: 
  9.               case ON_PAUSE: 
  10.                   return State.STARTED; 
  11.               case ON_RESUME: 
  12.                   return State.RESUMED; 
  13.               case ON_DESTROY: 
  14.                   return State.DESTROYED; 
  15.               case ON_ANY: 
  16.                   break; 
  17.           } 
  18.           throw new IllegalArgumentException(this + " has no target state"); 
  19.       } 
  20. Lifecycle.State 继续往下传,先用 mState 保存,再 sync 方法处理。 
  21.   /* LifecycleRegistry  */ 
  22.   public void handleLifecycleEvent(@NonNull Lifecycle.Event event) { 
  23.       enforceMainThreadIfNeeded("handleLifecycleEvent"); 
  24.       moveToState(event.getTargetState()); 
  25.   } 
  26.   private void moveToState(State next) { 
  27.       if (mState == next) { 
  28.           return
  29.       } 
  30.       //保存state状态 
  31.       mState = next
  32.       if (mHandlingEvent || mAddingObserverCounter != 0) { 
  33.           mNewEventOccurred = true
  34.           // we will figure out what to do on upper level
  35.           return
  36.       } 
  37.       mHandlingEvent = true
  38.       sync(); 
  39.       mHandlingEvent = false
  40.   } 

9、 sync

这里利用上一个方法保存的mState,用于比较,判断是正向执行还是反向执行生命周期

  1. /* LifecycleRegistry  */ 
  2.    private void sync() { 
  3.        //这是弱引用包装过的LifecycleOwner  
  4.        LifecycleOwner lifecycleOwner = mLifecycleOwner.get(); 
  5.        if (lifecycleOwner == null) { 
  6.            throw new IllegalStateException("LifecycleOwner of this LifecycleRegistry is already" 
  7.                    + "garbage collected. It is too late to change lifecycle state."); 
  8.        } 
  9.        while (!isSynced()) { 
  10.            mNewEventOccurred = false
  11.            // no need to check eldest for nullability, because isSynced does it for us. 
  12.            //上一个方法保存的mState,跟组件之前的的mState对比 
  13.            if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) { 
  14.                //返向执行流程 
  15.                backwardPass(lifecycleOwner); 
  16.            } 
  17.            Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest(); 
  18.            if (!mNewEventOccurred && newest != null 
  19.                    && mState.compareTo(newest.getValue().mState) > 0) { 
  20.                //正向执行流程 
  21.                forwardPass(lifecycleOwner); 
  22.            } 
  23.        } 
  24.        mNewEventOccurred = false
  25.    } 

10、 forwardPass

反向的逻辑差不多,只是执行 backwardPass ,先转换Stata,最后执行 observer.dispatchEvent。

这里又把 Lifecycle.State 转回 Lifecycle.Event,然后给观察者分发出去。

  1. /* Lifecycle.Event */ 
  2.      @Nullable 
  3.      public static Event upFrom(@NonNull State state) { 
  4.          switch (state) { 
  5.              case INITIALIZED: 
  6.                  return ON_CREATE; 
  7.              case CREATED: 
  8.                  return ON_START; 
  9.              case STARTED: 
  10.                  return ON_RESUME; 
  11.              default
  12.                  return null
  13.          } 
  14.      } 

转换 Event.upFrom ,发送 observer.dispatchEvent。

  1. /* LifecycleRegistry  */ 
  2.   private void forwardPass(LifecycleOwner lifecycleOwner) { 
  3.       Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> ascendingIterator = 
  4.               mObserverMap.iteratorWithAdditions(); 
  5.       while (ascendingIterator.hasNext() && !mNewEventOccurred) { 
  6.           Map.Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next(); 
  7.           ObserverWithState observer = entry.getValue(); 
  8.           while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred 
  9.                   && mObserverMap.contains(entry.getKey()))) { 
  10.               pushParentState(observer.mState); 
  11.               //转化 
  12.               final Event event = Event.upFrom(observer.mState); 
  13.               if (event == null) { 
  14.                   throw new IllegalStateException("no event up from " + observer.mState); 
  15.               } 
  16.               //发送 
  17.               observer.dispatchEvent(lifecycleOwner, event); 
  18.               popParentState(); 
  19.           } 
  20.       } 
  21.   } 

11、 发送生命周期状态

ObserverWithState 发送出 Lifecycle.Event ,至此就结束了,有注册订阅关系的地方就能收到

  1. static class ObserverWithState { 
  2.       State mState; 
  3.       LifecycleEventObserver mLifecycleObserver; 
  4.       ObserverWithState(LifecycleObserver observer, State initialState) { 
  5.           mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer); 
  6.           mState = initialState; 
  7.       } 
  8.       /* 分发生命周期状态 */ 
  9.       void dispatchEvent(LifecycleOwner owner, Event event) { 
  10.           State newState = event.getTargetState(); 
  11.           mState = min(mState, newState); 
  12.           mLifecycleObserver.onStateChanged(owner, event); 
  13.           mState = newState; 
  14.       } 
  15.   } 

原理比较清晰:Activity/Fragment实现LifecycleOwner接口,通过LifecycleRegistry在对应生命周期分发事件Lifecycle.Event,回调到生命周期观察者LifecycleObserver对应订阅方法

图片

总结

Lifecycle还是有可取之处的,相对于其它架构组件之间的配合,Lifecycle更简单且独立;

LifecycleObserver接口( Lifecycle观察者):实现该接口的类,通过注解的方式,可以通过被LifecycleOwner类的addObserver(LifecycleObserver o)方法注册,被注册后,LifecycleObserver便可以观察到LifecycleOwner的生命周期事件;

LifecycleOwner接口(Lifecycle持有者):实现该接口的类持有生命周期(Lifecycle对象),该接口的生命周期(Lifecycle对象)的改变会被其注册的观察者LifecycleObserver观察到并触发其对应的事件;

Lifecycle(生命周期):和LifecycleOwner不同的是,LifecycleOwner本身持有Lifecycle对象,LifecycleOwner通过其Lifecycle getLifecycle()的接口获取内部Lifecycle对象;

State(当前生命周期所处状态);

Event(当前生命周期改变对应的事件),当Lifecycle发生改变,如进入onCreate,会自动发出ON_CREATE事件;

后面会陆续介绍一些官方架构方面的知识点;

本文转载自微信公众号「Android开发编程」

 

责任编辑:姜华 来源: Android开发编程
相关推荐

2021-09-09 06:55:43

AndroidViewDragHel原理

2021-09-07 06:40:25

AndroidLiveData原理

2024-08-30 10:40:12

2021-09-01 06:48:16

AndroidGlide缓存

2021-09-08 06:51:52

AndroidRetrofit原理

2021-10-15 09:19:17

AndroidSharedPrefe分析源码

2021-08-12 16:28:10

AndroidHandleLooper

2021-05-17 09:50:06

Kubebuilde源码CURD

2022-01-05 08:53:13

Spring原理分析MVC

2019-09-20 08:54:38

KafkaBroker消息

2021-02-22 21:49:33

Vue动态组件

2021-08-05 20:39:34

AndroidKotlinStandard.kt

2021-08-09 11:15:28

MybatisJavaSpring

2021-11-26 17:17:43

Android广播运行原理源码分析

2011-05-26 10:05:48

MongoDB

2021-09-02 07:00:01

Glide流程Android

2016-11-25 13:26:50

Flume架构源码

2016-11-29 09:38:06

Flume架构核心组件

2021-09-12 07:30:10

配置

2021-08-28 07:48:04

AndroidActivityRecActivitySta
点赞
收藏

51CTO技术栈公众号