android源码（1）LiveData源码

2023-12-05 06:08
文章标签 android 源码 livedata

本文主要是介绍android源码（1）LiveData源码，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

2、LiveData如何感知生命周期？

总结：首先看数据：LiveData中的 mObservers 和 LifecycleRegistry 中的 mObserverMap。

LiveData中：
// key: observer; value:  new LifecycleBoundObserver(owner, observer)
SafeIterableMap<Observer<T>, ObserverWrapper> mObservers = new SafeIterableMap<>();public void observe(LifecycleOwner owner, Observer<T> observer) {LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);mObservers.putIfAbsent(observer, wrapper);owner.getLifecycle().addObserver(wrapper);
}LifecycleRegistry中：//  key：LifecycleBoundObserver(owner, observer)    
//  value : ObserverWithState( LifecycleBoundObserver(owner, observer),   initialState)
FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =  new FastSafeIterableMap<>();public void addObserver(LifecycleObserver observer) {State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
}

说白了就这两条线：
1、从 livedata 的 setValue()触发：使用mObservers中存储的observer更新数据；
2、从 fragment 的 onCreat/onStart/…等触发： 使用LifecycleRegistry中存储的observer（不用mObservers）更新数据。

在这里插入图片描述
关键对象：

1、LiveData: 作为数据入口，维护观察者和被观察者的关系
2、Observer：数据改变后最终触发的函数，回调接口，调用端实现
3、LifecycleOwner: Activity, Fragment 提供 Lifecycle
4、Lifecycle, LifecycleRegistry
5、LifecycleObserver，GenericLifecycleObserver, LifecycleBoundObserver: 封装Observer, LifecycleOwner 对象

SupportActivity中：

public class SupportActivity extends Activity implements LifecycleOwner {@Override@SuppressWarnings("RestrictedApi")protected void onCreate(@Nullable Bundle savedInstanceState) {super.onCreate(savedInstanceState);ReportFragment.injectIfNeededIn(this);}
}

上面关键的一句ReportFragment.injectIfNeededIn(this);下面看ReportFragment各生命周期：

 public class ReportFragment extends Fragment {@Overridepublic void onActivityCreated(Bundle savedInstanceState) {super.onActivityCreated(savedInstanceState);dispatchCreate(mProcessListener);dispatch(Lifecycle.Event.ON_CREATE);}@Overridepublic void onStart() {super.onStart();dispatchStart(mProcessListener);dispatch(Lifecycle.Event.ON_START);}@Overridepublic void onResume() {super.onResume();dispatchResume(mProcessListener);dispatch(Lifecycle.Event.ON_RESUME);}@Overridepublic void onPause() {super.onPause();dispatch(Lifecycle.Event.ON_PAUSE);}@Overridepublic void onStop() {super.onStop();dispatch(Lifecycle.Event.ON_STOP);}@Overridepublic void onDestroy() {super.onDestroy();dispatch(Lifecycle.Event.ON_DESTROY);// just want to be sure that we won't leak reference to an activitymProcessListener = null;}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去处理生命周期事件,把生命周期 Event 传递给 LifecycleObserver((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);}}}
}

LifecycleRegistry就是LifeCycle的登记处，它以弱引用的方式持有了当前的Activity。
至此：当lifecycle发生变化时，handleLifecycleEvent 会通过 getStateAfter()方法获取当前应处的状态并修改mState值，紧接着遍历所有 ObserverWithState并调用他们的sync方法来同步且通知LifecycleObserver状态发生变化。

public class LifecycleRegistry extends Lifecycle {public LifecycleRegistry(@NonNull LifecycleOwner provider) {mLifecycleOwner = new WeakReference<>(provider);mState = INITIALIZED;}//设置当前状态并通知观察者public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {// 根据生命周期事件得到对应的状态State next = getStateAfter(event);moveToState(next);}private void moveToState(State next) {if (mState == next) {return;}mState = next;if (mHandlingEvent || mAddingObserverCounter != 0) {mNewEventOccurred = true;// we will figure out what to do on upper level.return;}mHandlingEvent = true;// 同步状态给各个观察者sync();mHandlingEvent = false;}private void sync() {LifecycleOwner lifecycleOwner = mLifecycleOwner.get();if (lifecycleOwner == null) {Log.w(LOG_TAG, "LifecycleOwner is garbage collected, you shouldn't try dispatch "+ "new events from it.");return;}while (!isSynced()) {mNewEventOccurred = false;//比较当前的生命周期和Map中第一个的观察者的生命周期if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {// 倒序遍历，通知LifecycleObserver，去修改状态backwardPass(lifecycleOwner);}Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();if (!mNewEventOccurred && newest != null&& mState.compareTo(newest.getValue().mState) > 0) {// 正序遍历，通知观察者，去修改状态 forwardPass(lifecycleOwner);}}mNewEventOccurred = false;}//  key：LifecycleBoundObserver(owner, observer)    //  value : ObserverWithState( LifecycleBoundObserver(owner, observer),   initialState)private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =  new FastSafeIterableMap<>();private void backwardPass(LifecycleOwner lifecycleOwner) {Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator = mObserverMap.descendingIterator();while(descendingIterator.hasNext() && !mNewEventOccurred) {Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();ObserverWithState observer = entry.getValue();while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred&& mObserverMap.contains(entry.getKey()))) {Event event = downEvent(observer.mState);pushParentState(getStateAfter(event));//生命周期变化后observer.dispatchEvent(lifecycleOwner, event);popParentState();}}}private void forwardPass(LifecycleOwner lifecycleOwner) {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);//生命周期变化后observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));popParentState();}}}}

ObserverWithState中：

static class ObserverWithState {State mState;GenericLifecycleObserver mLifecycleObserver;ObserverWithState(LifecycleObserver observer, State initialState) {mLifecycleObserver = Lifecycling.getCallback(observer);mState = initialState;}void dispatchEvent(LifecycleOwner owner, Event event) {State newState = getStateAfter(event);mState = min(mState, newState);//到这里//mLifecycleObserver ： LifecycleBoundObserver(owner, observer)mLifecycleObserver.onStateChanged(owner, event);  mState = newState;}}

LifecycleBoundObserver是LiveData的内部类：

LiveData 和 生命周期的关系基本操作：
生命周期正常的时候， addObserver 注册观察者；生命周期结束的时候 removeObserver 取消观察者

     class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver {.........@Overrideboolean shouldBeActive() {return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);}//该方法会在生命周期变化后触发@Overridepublic void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {//根据事件判断是否要解除订阅if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {removeObserver(mObserver);return;}//看这里activeStateChanged(shouldBeActive());}}

LiveData中：

@MainThreadpublic void removeObserver(@NonNull final Observer<T> observer) {assertMainThread("removeObserver");ObserverWrapper removed = mObservers.remove(observer);if (removed == null) {return;}removed.detachObserver();removed.activeStateChanged(false);}

ObserverWrapper中:

 private abstract class ObserverWrapper {void activeStateChanged(boolean newActive) {if (newActive == mActive) {return;}........if (mActive) {dispatchingValue(this);}}

liveData中dispatchingValue（）

 // key: observer  ;   value: LifecycleBoundObserver(owner, observer)private SafeIterableMap<Observer<T>, ObserverWrapper> mObservers = new SafeIterableMap<>();private void dispatchingValue(@Nullable ObserverWrapper initiator) {if (mDispatchingValue) {mDispatchInvalidated = true;return;}mDispatchingValue = true;do {mDispatchInvalidated = false;//initiator ：LifecycleBoundObserver(owner, observer)//class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserverif (initiator != null) {considerNotify(initiator);  //看这里initiator = null;} else {for (Iterator<Map.Entry<Observer<T>, ObserverWrapper>> iterator =mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {//mObservers看上面considerNotify(iterator.next().getValue());    //看这里if (mDispatchInvalidated) {break;}}}} while (mDispatchInvalidated);mDispatchingValue = false;}//class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver
//参数observer ：LifecycleBoundObserver(owner, observer)
private void considerNotify(ObserverWrapper observer) {if (!observer.mActive) {return;}if (!observer.shouldBeActive()) {observer.activeStateChanged(false);return;}if (observer.mLastVersion >= mVersion) {return;}observer.mLastVersion = mVersion;// 最终调用观察者的onChanged()回调observer.mObserver.onChanged((T) mData);    //最后到这里}

3、LiveData注册Observer

添加观察者过程实际上是把 Observer 传递给 LiveData 对象 和 LifecycleRegistry 对象。

我们一般在fragment中这样用：

		       liveData.observe(this, new Observer<Object>() {@Overridepublic void onChanged(@Nullable Object o) {}});

进入observe方法：

            // key: observer  ;   value:  new LifecycleBoundObserver(owner, observer)private SafeIterableMap<Observer<T>, ObserverWrapper> mObservers = new SafeIterableMap<>();@MainThreadpublic void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {if (owner.getLifecycle().getCurrentState() == DESTROYED) {return;}// 将LifecycleOwner和Observer包装了一层LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);// 判断Observer有没有被添加过，如果没有则添加到一个HashMap中mObserversObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);if (existing != null && !existing.isAttachedTo(owner)) {throw new IllegalArgumentException("Cannot add the same observer"+ " with different lifecycles");}if (existing != null) {return;}// 将包装了owner 和 observer 的 LifecycleBoundObserver添加到LifecycleRegistryowner.getLifecycle().addObserver(wrapper);}

继续进入LifecycleRegistry的addObserver()：LifecycleRegistry 中存储 observer:

//  key：LifecycleBoundObserver(owner, observer)    
//  value : ObserverWithState( LifecycleBoundObserver(owner, observer),   initialState)
private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =new FastSafeIterableMap<>();@Overridepublic void addObserver(@NonNull LifecycleObserver observer) {State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;// 将LifecycleObserver包装为ObserverWithStateObserverWithState statefulObserver = new ObserverWithState(observer, initialState);// 如果没有保存过就存入mObserverMap// mObserverMap是一个可以在迭代过程中修改的HashMapObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);if (previous != null) {return;}LifecycleOwner lifecycleOwner = mLifecycleOwner.get();if (lifecycleOwner == null) {// it is null we should be destroyed. Fallback quicklyreturn;}boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;State targetState = calculateTargetState(observer);mAddingObserverCounter++;while ((statefulObserver.mState.compareTo(targetState) < 0&& mObserverMap.contains(observer))) {pushParentState(statefulObserver.mState);statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));popParentState();// mState / subling may have been changed recalculatetargetState = calculateTargetState(observer);}if (!isReentrance) {// we do sync only on the top level.sync();     //源码前面有}mAddingObserverCounter--;}

4、LiveData数据设置

LiveData有两种方式设置数据，第一种setValue()，在主线程中使用
而 postValue在异步线程中使用：

			 @MainThreadprotected void setValue(T value) {assertMainThread("setValue");mVersion++;mData = value;dispatchingValue(null);    //前面已经有了dispatchingValue的源码}

postValue方法:

通过一个以MainLooper作为Looper的Handler将mPostValueRunnable发送到主线程上，最终还是调用了setValue()。setValue()中调用了dispatchingValue()，进而调用了considerNotify()来通知数据的改变。

			protected void postValue(T value) {boolean postTask;synchronized (mDataLock) {postTask = mPendingData == NOT_SET;mPendingData = value;}if (!postTask) {return;}ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);}private final Runnable mPostValueRunnable = new Runnable() {@Overridepublic void run() {Object newValue;synchronized (mDataLock) {newValue = mPendingData;mPendingData = NOT_SET;}//noinspection uncheckedsetValue((T) newValue);}};

ArchTaskExecutor 使用了代理模式, 实际函数执行类是 DefaultTaskExecutor：

			public class DefaultTaskExecutor extends TaskExecutor {private final Object mLock = new Object();private ExecutorService mDiskIO = Executors.newFixedThreadPool(2);@Nullableprivate volatile Handler mMainHandler;@Overridepublic void executeOnDiskIO(Runnable runnable) {mDiskIO.execute(runnable);}@Overridepublic void postToMainThread(Runnable runnable) {if (mMainHandler == null) {synchronized (mLock) {if (mMainHandler == null) {mMainHandler = new Handler(Looper.getMainLooper());}}}//noinspection ConstantConditionsmMainHandler.post(runnable);}@Overridepublic boolean isMainThread() {return Looper.getMainLooper().getThread() == Thread.currentThread();}}

这篇关于android源码（1）LiveData源码的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/456449。

相关文章

JAVA智听未来一站式有声阅读平台听书系统小程序源码

JAVA智听未来一站式有声阅读平台听书系统小程序源码

智听未来，一站式有声阅读平台听书系统 🌟&nbsp;开篇：遇见未来，从“智听”开始 在这个快节奏的时代，你是否渴望在忙碌的间隙，找到一片属于自己的宁静角落？是否梦想着能随时随地，沉浸在知识的海洋，或是故事的奇幻世界里？今天，就让我带你一起探索“智听未来”——这一站式有声阅读平台听书系统，它正悄悄改变着我们的阅读方式，让未来触手可及！ 📚&nbsp;第一站：海量资源，应有尽有 走进“智听
阅读更多...
Android实现任意版本设置默认的锁屏壁纸和桌面壁纸（两张壁纸可不一致）

Android实现任意版本设置默认的锁屏壁纸和桌面壁纸（两张壁纸可不一致）

客户有些需求需要设置默认壁纸和锁屏壁纸  在默认情况下 这两个壁纸是相同的  如果需要默认的锁屏壁纸和桌面壁纸不一样 需要额外修改 Android13实现 替换默认桌面壁纸： 将图片文件替换frameworks/base/core/res/res/drawable-nodpi/default_wallpaper.*  （注意不能是bmp格式） 替换默认锁屏壁纸： 将图片资源放入vendo
阅读更多...
Android平台播放RTSP流的几种方案探究（VLC VS ExoPlayer VS SmartPlayer）

Android平台播放RTSP流的几种方案探究（VLC VS ExoPlayer VS SmartPlayer）

技术背景 好多开发者需要遴选Android平台RTSP直播播放器的时候，不知道如何选的好，本文针对常用的方案，做个大概的说明： 1. 使用VLC for Android VLC Media Player（VLC多媒体播放器），最初命名为VideoLAN客户端，是VideoLAN品牌产品，是VideoLAN计划的多媒体播放器。它支持众多音频与视频解码器及文件格式，并支持DVD影音光盘，VCD影
阅读更多...
Java ArrayList扩容机制 （源码解读）

Java ArrayList扩容机制 （源码解读）

结论：初始长度为10，若所需长度小于1.5倍原长度，则按照1.5倍扩容。若不够用则按照所需长度扩容。 一. 明确类内部重要变量含义         1：数组默认长度         2:这是一个共享的空数组实例，用于明确创建长度为0时的ArrayList ，比如通过 new ArrayList<>(0)，ArrayList 内部的数组 elementData 会指向这个 EMPTY_EL
阅读更多...
如何在Visual Studio中调试.NET源码

如何在Visual Studio中调试.NET源码

今天偶然在看别人代码时，发现在他的代码里使用了Any判断List<T>是否为空。 我一般的做法是先判断是否为null，再判断Count。 看了一下Count的源码如下： 1 [__DynamicallyInvokable]2 public int Count3 {4 [__DynamicallyInvokable]5 get
阅读更多...
工厂ERP管理系统实现源码（JAVA）

工厂ERP管理系统实现源码（JAVA）

工厂进销存管理系统是一个集采购管理、仓库管理、生产管理和销售管理于一体的综合解决方案。该系统旨在帮助企业优化流程、提高效率、降低成本，并实时掌握各环节的运营状况。 在采购管理方面，系统能够处理采购订单、供应商管理和采购入库等流程，确保采购过程的透明和高效。仓库管理方面，实现库存的精准管理，包括入库、出库、盘点等操作，确保库存数据的准确性和实时性。 生产管理模块则涵盖了生产计划制定、物料需求计划、
阅读更多...
android-opencv-jni

android-opencv-jni

//------------------start opencv--------------------@Override public void onResume(){ super.onResume(); //通过OpenCV引擎服务加载并初始化OpenCV类库，所谓OpenCV引擎服务即是 //OpenCV_2.4.3.2_Manager_2.4_*.apk程序包，存
阅读更多...
从状态管理到性能优化：全面解析 Android Compose

从状态管理到性能优化：全面解析 Android Compose

文章目录 引言一、Android Compose基本概念1.1 什么是Android Compose?1.2 Compose的优势1.3 如何在项目中使用Compose 二、Compose中的状态管理2.1 状态管理的重要性2.2 Compose中的状态和数据流2.3 使用State和MutableState处理状态2.4 通过ViewModel进行状态管理 三、Compose中的列表和滚动
阅读更多...
Spring 源码解读：自定义实现Bean定义的注册与解析

Spring 源码解读：自定义实现Bean定义的注册与解析

引言 在Spring框架中，Bean的注册与解析是整个依赖注入流程的核心步骤。通过Bean定义，Spring容器知道如何创建、配置和管理每个Bean实例。本篇文章将通过实现一个简化版的Bean定义注册与解析机制，帮助你理解Spring框架背后的设计逻辑。我们还将对比Spring中的BeanDefinition和BeanDefinitionRegistry，以全面掌握Bean注册和解析的核心原理。
阅读更多...
Android 10.0 mtk平板camera2横屏预览旋转90度横屏拍照图片旋转90度功能实现

Android 10.0 mtk平板camera2横屏预览旋转90度横屏拍照图片旋转90度功能实现

1.前言 在10.0的系统rom定制化开发中，在进行一些平板等默认横屏的设备开发的过程中，需要在进入camera2的 时候，默认预览图像也是需要横屏显示的，在上一篇已经实现了横屏预览功能，然后发现横屏预览后，拍照保存的图片 依然是竖屏的，所以说同样需要将图片也保存为横屏图标了，所以就需要看下mtk的camera2的相关横屏保存图片功能， 如何实现实现横屏保存图片功能 如图所示: 2.mtk
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2