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。

相关文章

Android开发中gradle下载缓慢的问题级解决方法

Android开发中gradle下载缓慢的问题级解决方法

《Android开发中gradle下载缓慢的问题级解决方法》本文介绍了解决Android开发中Gradle下载缓慢问题的几种方法,本文给大家介绍的非常详细,感兴趣的朋友跟随小编一起看看吧... 目录一、网络环境优化二、Gradle版本与配置优化三、其他优化措施针对android开发中Gradle下载缓慢的问
阅读更多...
Android 悬浮窗开发示例((动态权限请求 | 前台服务和通知 | 悬浮窗创建 )

Android 悬浮窗开发示例((动态权限请求 | 前台服务和通知 | 悬浮窗创建 )

《Android悬浮窗开发示例((动态权限请求|前台服务和通知|悬浮窗创建)》本文介绍了Android悬浮窗的实现效果,包括动态权限请求、前台服务和通知的使用,悬浮窗权限需要动态申请并引导... 目录一、悬浮窗 动态权限请求1、动态请求权限2、悬浮窗权限说明3、检查动态权限4、申请动态权限5、权限设置完毕后
阅读更多...
Android里面的Service种类以及启动方式

Android里面的Service种类以及启动方式

《Android里面的Service种类以及启动方式》Android中的Service分为前台服务和后台服务,前台服务需要亮身份牌并显示通知,后台服务则有启动方式选择,包括startService和b... 目录一句话总结：一、Service 的两种类型：1. 前台服务（必须亮身份牌）2. 后台服务（偷偷干
阅读更多...
Android kotlin语言实现删除文件的解决方案

Android kotlin语言实现删除文件的解决方案

《Androidkotlin语言实现删除文件的解决方案》：本文主要介绍Androidkotlin语言实现删除文件的解决方案,在项目开发过程中,尤其是需要跨平台协作的项目,那么删除用户指定的文件的... 目录一、前言二、适用环境三、模板内容1.权限申请2.Activity中的模板一、前言在项目开发过程中，尤
阅读更多...
Go中sync.Once源码的深度讲解

Go中sync.Once源码的深度讲解

《Go中sync.Once源码的深度讲解》sync.Once是Go语言标准库中的一个同步原语,用于确保某个操作只执行一次,本文将从源码出发为大家详细介绍一下sync.Once的具体使用,x希望对大家有... 目录概念简单示例源码解读总结概念sync.Once是Go语言标准库中的一个同步原语，用于确保某个操
阅读更多...
Java汇编源码如何查看环境搭建

Java汇编源码如何查看环境搭建

《Java汇编源码如何查看环境搭建》：本文主要介绍如何在IntelliJIDEA开发环境中搭建字节码和汇编环境,以便更好地进行代码调优和JVM学习,首先,介绍了如何配置IntelliJIDEA以方... 目录一、简介二、在IDEA开发环境中搭建汇编环境2.1 在IDEA中搭建字节码查看环境2.1.1 搭建步
阅读更多...
Android数据库Room的实际使用过程总结

Android数据库Room的实际使用过程总结

《Android数据库Room的实际使用过程总结》这篇文章主要给大家介绍了关于Android数据库Room的实际使用过程,详细介绍了如何创建实体类、数据访问对象（DAO）和数据库抽象类,需要的朋友可以... 目录前言一、Room的基本使用1.项目配置2.创建实体类（Entity）3.创建数据访问对象（DAO
阅读更多...
Android WebView的加载超时处理方案

Android WebView的加载超时处理方案

《AndroidWebView的加载超时处理方案》在Android开发中,WebView是一个常用的组件,用于在应用中嵌入网页,然而,当网络状况不佳或页面加载过慢时,用户可能会遇到加载超时的问题,本... 目录引言一、WebView加载超时的原因二、加载超时处理方案1. 使用Handler和Timer进行超
阅读更多...
JAVA智听未来一站式有声阅读平台听书系统小程序源码

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

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

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

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

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2