Android源码进阶之LiveData工作原理详解

移动开发 Android
LiveData 是一种可观察的数据存储器类。与常规的可观察类不同,LiveData 具有生命周期感知能力,意指它遵循其他应用组件(如 Activity、Fragment 或 Service)的生命周期。

[[422179]]

本文转载自微信公众号「Android开发编程」,作者Android开发编程。转载本文请联系Android开发编程公众号。

前言

LiveData 是一种可观察的数据存储器类。与常规的可观察类不同,LiveData 具有生命周期感知能力,意指它遵循其他应用组件(如 Activity、Fragment 或 Service)的生命周期。

这种感知能力可确保 LiveData 仅更新处于活跃生命周期状态的应用组件观察者。

LiveData本身是观察者,观察组件的Lifecycle,也是被观察者,数据变化时要通知数据的观察者。

前面我们讲解了Lifecycle实现原理,今天我们来看LiveData

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

一、livedata的在app中的应用

1、使用livedata的步骤

  • 创建一个实例LiveData来保存某种类型的数据。这通常在你的ViewModel类内完成;
  • 创建一个Observer 定义onChanged()方法的对象,该对象 控制LiveData对象保存的数据更改时发生的情况。您通常Observer在UI控制器中创建对象,例如activity或fragment;
  • 使用该 方法将Observer对象附加到对象。该方法需要一个对象。这将对象订阅到对象,以便通知其更改。您通常将该对象附加到UI控制器中,例如活动或片段;

2、livedata的简单例子

在viewModel中之定义live data

  1. public class NameViewModel extends ViewModel { 
  2. // Create a LiveData with a String 
  3. private MutableLiveData<String> mCurrentName; 
  4.     public MutableLiveData<String> getCurrentName() { 
  5.         if (mCurrentName == null) { 
  6.             mCurrentName = new MutableLiveData<String>(); 
  7.         } 
  8.         return mCurrentName; 
  9.     } 
  10. // Rest of the ViewModel... 

在activity或者Fragment中实施监听来更新ui

  1. public class NameActivity extends AppCompatActivity { 
  2.     private NameViewModel mModel; 
  3.     @Override 
  4.     protected void onCreate(Bundle savedInstanceState) { 
  5.         super.onCreate(savedInstanceState); 
  6.         // Other code to setup the activity... 
  7.         // Get the ViewModel. 
  8.         mModel = ViewModelProviders.of(this).get(NameViewModel.class); 
  9.         // Create the observer which updates the UI. 
  10.         final Observer<String> nameObserver = new Observer<String>() { 
  11.             @Override 
  12.             public void onChanged(@Nullable final String newName) { 
  13.                 // Update the UI, in this case, a TextView. 
  14.                 mNameTextView.setText(newName);    
  15.                  //注意这里 在MVVM 中不是这样写的 这里只是单行绑定 
  16.             } 
  17.         }; 
  18.         // Observe the LiveData, passing in this activity as the LifecycleOwner and the observer. 
  19.         mModel.getCurrentName().observe(this, nameObserver);      
  20.         //注意这个地方用没有用Java8的lambda表达式,可以写的更加简练, 
  21.     } 

更新livedata对象

调用setValue(T)示例会导致观察者onChanged()使用该值调用其ui进行刷新。该示例示出了按钮按下,但setValue()还是postValue()可以被调用以更新mName为各种各样的原因,包括响应于网络请求或数据库负荷完成; 在所有情况下,呼叫setValue()或postValue()触发观察员并更新UI;

  1. mButton.setOnClickListener(new OnClickListener() { 
  2.     @Override 
  3.     public void onClick(View v) { 
  4.         String anotherName = "John Doe"
  5.         mModel.getCurrentName().setValue(anotherName); 
  6.     } 
  7. }); 
  8. mButton.setOnClickListener(new OnClickListener() { 
  9.     @Override 
  10.     public void onClick(View v) { 
  11.         String anotherName = "John Doe"
  12.         mModel.getCurrentName().setValue(anotherName); 
  13.     } 
  14. }); 

二、livedata原理详细分析

1、observe 方法

  • 首先这个方法只能在主线程注册观察;
  • 官方文档说LiveData仅处于活跃生命周期才有效,所以一开始就开始判断是否为 Lifecycle.Stete.DESTROYED,是的话就没有然后了,直接return;
  • 接下来就是 创建 LifecycleBoundObserver ,生命周期变化逻辑在这里面;
  • 然后就是最后一行注册观察,如果想了解 Lifecycle.addObserver 做了什么可以看 Android Lifecycle实现原理;
  1. //map 的 key 为LiveData数据观察者,value为组件的Lifecycle观察者 
  2.     private SafeIterableMap<Observer<? super T>, ObserverWrapper> mObservers = 
  3.             new SafeIterableMap<>(); 
  4.     @MainThread 
  5.     public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) { 
  6.         assertMainThread("observe"); 
  7.         //判断当前生命周期的状态 
  8.         if (owner.getLifecycle().getCurrentState() == DESTROYED) { 
  9.             // ignore 
  10.             return
  11.         } 
  12.         //Lifecycle的生命周期变化逻辑在这里 
  13.         LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer); 
  14.         //mObservers 保存 
  15.         ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper); 
  16.         if (existing != null && !existing.isAttachedTo(owner)) { 
  17.             throw new IllegalArgumentException("Cannot add the same observer" 
  18.                     + " with different lifecycles"); 
  19.         } 
  20.         if (existing != null) { 
  21.             return
  22.         } 
  23.         //感知lifecycle的生命周期变化 
  24.         owner.getLifecycle().addObserver(wrapper); 
  25.     } 

2、LifecycleBoundObserver

  • LifecycleBoundObserver 继承 ObserverWrapper ,实现 LifecycleEventObserver 接口。
  • ObserverWrapper 用于判断组件当前是否活跃;
  • LifecycleEventObserver 就是 Lifecycle 的观察者了,重写了 onStateChanged 方法,当Lifecycle 生命周期发生变化时,就会在此方法接收到,LiveData 也就能感知到,如果组件的生命周期是 DESTROYED ,那也就移除观察;
  • 到这里 LiveData 对组件的生命周期感知就注册完成了,可以开始发送数据;
  1. class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver { 
  2.         @NonNull 
  3.         //一般组件,比如Activity、fragment可以会实现LifecycleOwner ,可以拿到lifecycle 
  4.         final LifecycleOwner mOwner; 
  5.         LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<? super T> observer) { 
  6.             super(observer); 
  7.             mOwner = owner; 
  8.         } 
  9.         /* 判断当前组件当前是否活跃 */ 
  10.         @Override 
  11.         boolean shouldBeActive() { 
  12.             return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED); 
  13.         } 
  14.         @Override 
  15.         public void onStateChanged(@NonNull LifecycleOwner source, 
  16.                 @NonNull Lifecycle.Event event) { 
  17.             //获取当前生命周期状态 
  18.             Lifecycle.State currentState = mOwner.getLifecycle().getCurrentState(); 
  19.             //如果组件已销毁了,就移除观察 
  20.             if (currentState == DESTROYED) { 
  21.                 removeObserver(mObserver); 
  22.                 return
  23.             } 
  24.             Lifecycle.State prevState = null
  25.             while (prevState != currentState) { 
  26.                 prevState = currentState; 
  27.                 activeStateChanged(shouldBeActive()); 
  28.                 currentState = mOwner.getLifecycle().getCurrentState(); 
  29.             } 
  30.         } 
  31.         /* 判断是否绑定 */ 
  32.         @Override 
  33.         boolean isAttachedTo(LifecycleOwner owner) { 
  34.             return mOwner == owner; 
  35.         } 
  36.         /* 移除观察 */ 
  37.         @Override 
  38.         void detachObserver() { 
  39.             mOwner.getLifecycle().removeObserver(this); 
  40.         } 
  41.     } 

3、activeStateChanged

ObserverWrapper 这个类里面有个方法,后面的粘性事件会用到;

  1. void activeStateChanged(boolean newActive) { 
  2.             //组件状态如果不变返回 
  3.             if (newActive == mActive) { 
  4.                 return
  5.             } 
  6.             // immediately set active state, so we'd never dispatch anything to inactive 
  7.             // owner 
  8.             mActive = newActive; 
  9.             changeActiveCounter(mActive ? 1 : -1); 
  10.             //如果是活动的就发送数据 
  11.             if (mActive) { 
  12.                 dispatchingValue(this); 
  13.             } 
  14.         } 

4、发送数据分析

4.1、postValue 发送数据到主线程

这个方法最核心的就是利用主线程Handler发送数据,一步步拆开分析;

  1. protected void postValue(T value) { 
  2.         boolean postTask; 
  3.         //加锁 
  4.         synchronized (mDataLock) { 
  5.             postTask = mPendingData == NOT_SET; 
  6.             //保存要发送的数据value 
  7.             mPendingData = value; 
  8.         } 
  9.         if (!postTask) { 
  10.             return
  11.         } 
  12.         //利用主线程Handler发送 
  13.         ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable); 
  14.     } 

4.2、postValue 其实就是 setValue

在postValue 要发送的 Runnable ,可以看到最后一行就是 setValue 方法,数据也即是之前保存的mPendingData ,只是在这又给 newValue;

  1. private final Runnable mPostValueRunnable = new Runnable() { 
  2.         @SuppressWarnings("unchecked"
  3.         @Override 
  4.         public void run() { 
  5.             Object newValue; 
  6.             synchronized (mDataLock) { 
  7.                 newValue = mPendingData; 
  8.                 mPendingData = NOT_SET; 
  9.             } 
  10.             setValue((T) newValue); 
  11.         } 
  12.     }; 

4.3、postToMainThread 主线程Handler

ArchTaskExecutor 类 postToMainThread 方法,实际就是 DefaultTaskExecutor 类执行 postToMainThread 方法;

  1. public class ArchTaskExecutor extends TaskExecutor { 
  2.     @NonNull 
  3.     private TaskExecutor mDelegate; 
  4.     @NonNull 
  5.     private TaskExecutor mDefaultTaskExecutor; 
  6.     private ArchTaskExecutor() { 
  7.         mDefaultTaskExecutor = new DefaultTaskExecutor(); 
  8.         mDelegate = mDefaultTaskExecutor; 
  9.     } 
  10.     ... 
  11.     @Override 
  12.     public void postToMainThread(Runnable runnable) { 
  13.         mDelegate.postToMainThread(runnable); 
  14.     } 
  15.     ... 

4.4、DefaultTaskExecutor类

我们知道是 DefaultTaskExecutor. postToMainThread,就直接看这个方法,哎呀,太熟悉的代码,创建 Handler ,传入的是 Looper.getMainLooper() ,就是主线程Handler ,然后就 post 消息;

  1. public class DefaultTaskExecutor extends TaskExecutor { 
  2.     @Nullable 
  3.     private volatile Handler mMainHandler; 
  4.     @Override 
  5.     public void postToMainThread(Runnable runnable) { 
  6.         if (mMainHandler == null) { 
  7.             synchronized (mLock) { 
  8.                 if (mMainHandler == null) { 
  9.                     mMainHandler = createAsync(Looper.getMainLooper()); 
  10.                 } 
  11.             } 
  12.         } 
  13.         //noinspection ConstantConditions 
  14.         mMainHandler.post(runnable); 
  15.     } 

4.5、setValue 方法

mVersion 在初始化的构造方法里就赋值了,为-1,每次setValue,版本号就会变一次;

setValue 也就是用 mData 保存一下 value ,然后交给 dispatchingValue 方法处理;

  1. @MainThread 
  2.     protected void setValue(T value) { 
  3.         assertMainThread("setValue"); 
  4.         mVersion++; 
  5.         mData = value; 
  6.         dispatchingValue(null); 
  7.     } 

4.6、dispatchingValue 方法

setValue走该方法,传的 initiator为空,那就遍历 mObservers 保存的观察者发送数据;

  1. @SuppressWarnings("WeakerAccess") /* synthetic access */ 
  2.     void dispatchingValue(@Nullable ObserverWrapper initiator) { 
  3.         if (mDispatchingValue) { 
  4.             mDispatchInvalidated = true
  5.             return
  6.         } 
  7.         mDispatchingValue = true
  8.         do { 
  9.             mDispatchInvalidated = false
  10.             if (initiator != null) { 
  11.                 //粘性事件,就单个观察者接受数据 
  12.                 considerNotify(initiator); 
  13.                 initiator = null
  14.             } else { 
  15.                 //setvalue 传过来 initiator 为空,执行这里 
  16.                 // mObservers 拿出来,逐个发送数据 
  17.                 for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator = 
  18.                         mObservers.iteratorWithAdditions(); iterator.hasNext(); ) { 
  19.                     considerNotify(iterator.next().getValue()); 
  20.                     if (mDispatchInvalidated) { 
  21.                         break; 
  22.                     } 
  23.                 } 
  24.             } 
  25.         } while (mDispatchInvalidated); 
  26.         mDispatchingValue = false
  27.     } 

4.7、considerNotify 判断发送数据

  • 这里先判断组件是否活动
  • 在判断粘性事件
  • 然后用 mVersion ,判断是否发送过数据
  • 最后才是给观察者发送数据
  1. private void considerNotify(ObserverWrapper observer) { 
  2.         //组件是否活动 
  3.         if (!observer.mActive) { 
  4.             return
  5.         } 
  6.         // Check latest state b4 dispatch. Maybe it changed state but we didn't get the event yet. 
  7.         // 
  8.         // we still first check observer.active to keep it as the entrance for events. So even if 
  9.         // the observer moved to an active state, if we've not received that event, we better not 
  10.         // notify for a more predictable notification order
  11.         //判断粘性事件 
  12.         if (!observer.shouldBeActive()) { 
  13.             observer.activeStateChanged(false); 
  14.             return
  15.         } 
  16.         //校验是否发送过数据 
  17.         if (observer.mLastVersion >= mVersion) { 
  18.             return
  19.         } 
  20.         observer.mLastVersion = mVersion; 
  21.         //发送数据 
  22.         observer.mObserver.onChanged((T) mData); 
  23.     } 

5、粘性事件分析

  • 粘性事件就是先发送数据,后面再注册观察者,还能收到消息;
  • 我们就从LiveData.observe 开始,新的页面注册LiveData观察者,也注册Lifecycle观察;
  • 当新页面生命周期变化,就会执行 LifecycleBoundObserver.onStateChanged 的方法;
  • 接下来 activeStateChanged 方法,因为是新页面,组件状态是活动的,就走到 dispatchingValue 方法;
  • dispatchingValue 传进来当前新页面的 initiator 是不为空的,就只会给当前观察者发送数据;

总结:

1、LifecycleOwner生命周期从非活跃变成活跃状态时:

Livedata添加一个观察者时,会关联一个LifecycleOwner,然后把这个观察者包装成一个LifecycleBoundObserver,和LifecycleOwner的getLifecycle关联,当LifecycleBoundObserver的生命周期变化时,会调用LifecycleBoundObserver的onStateChanged方法,在这个方法中判断当前生命周期和上次的生命周期是否是同一类型(要么活跃要么非活跃),如果是,就直接返回,避免重复通知(start通知了,resume就不需要通知了),如果不是同一类型,并且当前生命周期是活跃状态,就调用dispatchingValue方法通知观察者,判断LifecycleOwner是否时活跃状态,如果是,将Livedata中持有的最新更新给观察者;

2、Livedata中的值改变时:

 

同样是调用dispatchingValue,判断LifecycleOwner是否时活跃状态,如果是,就遍历通知所有观察者;

 

责任编辑:武晓燕 来源: Android开发编程
相关推荐

2021-09-01 06:48:16

AndroidGlide缓存

2021-09-08 06:51:52

AndroidRetrofit原理

2021-09-09 06:55:43

AndroidViewDragHel原理

2021-09-02 07:00:01

Glide流程Android

2021-08-05 20:39:34

AndroidKotlinStandard.kt

2021-08-10 20:41:33

AndroidApp流程

2021-10-15 09:19:17

AndroidSharedPrefe分析源码

2021-08-17 13:41:11

AndroidView事件

2021-09-05 07:35:58

lifecycleAndroid组件原理

2021-09-12 07:30:10

配置

2021-09-03 07:27:38

AndroidGlide管理

2021-08-09 20:29:27

Android沉浸式状态栏

2021-08-25 07:43:17

AndroidSurfaceViewTextureView

2021-09-06 13:12:05

前端JavaScript编程

2011-06-23 14:05:32

Qt 事件机制

2021-08-12 16:28:10

AndroidHandleLooper

2021-09-10 07:31:54

AndroidAppStartup原理

2021-09-04 07:29:57

Android

2021-10-03 15:08:32

Android

2021-09-11 07:32:15

Java线程线程池
点赞
收藏

51CTO技术栈公众号