android源码（1）LiveData源码

最新推荐文章于 2024-05-16 14:32:35 发布
最新推荐文章于 2024-05-16 14:32:35 发布
阅读量220 收藏
点赞数
分类专栏： android 文章标签： livecycle源码分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shinecjj/article/details/88807580
版权

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 {
		
		 @Override
		    public void onActivityCreated(Bundle savedInstanceState) {
		        super.onActivityCreated(savedInstanceState);
		        dispatchCreate(mProcessListener);
		        dispatch(Lifecycle.Event.ON_CREATE);
		    }
		
		    @Override
		    public void onStart() {
		        super.onStart();
		        dispatchStart(mProcessListener);
		        dispatch(Lifecycle.Event.ON_START);
		    }
		
		    @Override
		    public void onResume() {
		        super.onResume();
		        dispatchResume(mProcessListener);
		        dispatch(Lifecycle.Event.ON_RESUME);
		    }
		
		    @Override
		    public void onPause() {
		        super.onPause();
		        dispatch(Lifecycle.Event.ON_PAUSE);
		    }
		
		    @Override
		    public void onStop() {
		        super.onStop();
		        dispatch(Lifecycle.Event.ON_STOP);
		    }
		
		    @Override
		    public void onDestroy() {
		        super.onDestroy();
		        dispatch(Lifecycle.Event.ON_DESTROY);
		        // just want to be sure that we won't leak reference to an activity
		        mProcessListener = 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 {
       
       .........
       
        @Override
        boolean shouldBeActive() {
            return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
        }
        
        //该方法会在生命周期变化后触发
        @Override
        public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
          
           //根据事件判断是否要解除订阅
            if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
                removeObserver(mObserver);
                return;
            }
            //看这里
            activeStateChanged(shouldBeActive());
        }
   }

LiveData中：

@MainThread
    public 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 GenericLifecycleObserver
            if (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>() {
		            @Override
		            public void onChanged(@Nullable Object o) {
		
		            }
		        });

进入observe方法：

            // key: observer  ;   value:  new LifecycleBoundObserver(owner, observer)
             private SafeIterableMap<Observer<T>, ObserverWrapper> mObservers = new SafeIterableMap<>();
             
                 @MainThread
			    public 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中mObservers
			        ObserverWrapper 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添加到LifecycleRegistry
			        owner.getLifecycle().addObserver(wrapper);
			    }

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

//  key：LifecycleBoundObserver(owner, observer)    
//  value : ObserverWithState( LifecycleBoundObserver(owner, observer),   initialState)
private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =
            new FastSafeIterableMap<>();
            
     @Override
    public void addObserver(@NonNull LifecycleObserver observer) {
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
              // 将LifecycleObserver包装为ObserverWithState
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
           // 如果没有保存过就存入mObserverMap
           // mObserverMap是一个可以在迭代过程中修改的HashMap
        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;
        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 recalculate
            targetState = calculateTargetState(observer);
        }

        if (!isReentrance) {
            // we do sync only on the top level.
            sync();     //源码前面有
        }
        mAddingObserverCounter--;
    }

4、LiveData数据设置

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

			 @MainThread
			    protected 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() {
			        @Override
			        public void run() {
			            Object newValue;
			            synchronized (mDataLock) {
			                newValue = mPendingData;
			                mPendingData = NOT_SET;
			            }
			            //noinspection unchecked
			            setValue((T) newValue);
			        }
			    };

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

			public class DefaultTaskExecutor extends TaskExecutor {
				       private final Object mLock = new Object();
					    private ExecutorService mDiskIO = Executors.newFixedThreadPool(2);
					
					    @Nullable
					    private volatile Handler mMainHandler;
					
					    @Override
					    public void executeOnDiskIO(Runnable runnable) {
					        mDiskIO.execute(runnable);
					    }
					
					    @Override
					    public void postToMainThread(Runnable runnable) {
					        if (mMainHandler == null) {
					            synchronized (mLock) {
					                if (mMainHandler == null) {
					                    mMainHandler = new Handler(Looper.getMainLooper());
					                }
					            }
					        }
					        //noinspection ConstantConditions
					        mMainHandler.post(runnable);
					    }
					
					    @Override
					    public boolean isMainThread() {
					        return Looper.getMainLooper().getThread() == Thread.currentThread();
					    }
			}
小李飞飞砖
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Lifecycle之SafeIterableMap
做有意思的事情
07-06 560
前言 在 Lifecycle 使用与源码分析文章中，我们分析LifecycleRegistry类时，说到新增的Observer都会被添加到mObserverMap里面。而这个mObserverMap就是FastSafeIterableMap，FastSafeIterableMap继承了SafeIterableMap。本篇我们就会讲解一下SafeIterableMap类。 1. FastSafeIterableMap 首先先说一下FastSafeIterableMap类。 FastSafeIterableMa
Lifecycle组件快速入门教程
09-08
循序渐进，系统地介绍Android中生命周期感应组件Lifecycle的基本使用与实现原理
2024年最全Android livedata 源码解剖(3)，美团 三面
最新发布
2301_82243523的博客
05-16 252
学完之后，若是想验收效果如何，其实最好的方法就是可自己去总结一下。比如我就会在学习完一个东西之后自己去手绘一份xmind文件的知识梳理大纲脑图，这样也可方便后续的复习，且都是自己的理解，相信随便瞟几眼就能迅速过完整个知识，脑补回来。下方即为我手绘的Android框架体系架构知识脑图，由于是xmind文件，不好上传，所以小编将其以图片形式导出来传在此处，细节方面不是特别清晰。但可给感兴趣的朋友提供完整的Android框架体系架构知识脑图原件（包括上方的面试解析xmind文档）
FastSafeIterableMap和SafeIterableMap 来自anroidx.arch.core
AdrianAndroid的专栏
12-28 257
.......
android LifeCycle-简单使用和详细原理解析
ymeddmn的博客
06-13 709
关注我的公众号：”安安安安卓“ 学习更多知识 Lifecycle是用来做什么的 Lifecycle 用于存储有关组件（如 Activity 或 Fragment）的生命周期状态的信息，并允许其他对象观察此状态。 更通俗的说，你可一通过注册回调的方式，拿到我们activity的所有生命周期方法回调 下图展示了观察生命周期的机制的所有类型 使用方法 总的来说LifeCycle的使用非常简单，基本没什么好写的，使用方法的章节仅限于绝对新手参考。 说是徒劳的，先上一波简单使用的代码吧 代码展示 class M.
关于协程，你知道LifecycleScope吗，超详细解释给你听！
chuyouyinghe的专栏
07-26 1万+
前言 使用协程，相信很多同学已经信手拈来了，但是也有很多同学是不知道LifecycleScope的。 LifecycleScope，顾名思义，具有生命周期的协程。 它是LifecycleOwner生命周期所有者的扩展属性，与LifecycleOwner生命周期绑定，并会在LifecycleOwner生命周期destroyed的时候取消掉。 推荐理由： 自动取消，不会造成内存泄漏，可以替代MainScope。 可以基于指定的生命周期执行。 后面会重点介绍LifecycleScope是怎么做到的。 使用
安卓Android源码——UI界面源码.zip
10-14
这个名为“安卓Android源码——UI界面源码.zip”的压缩包，很显然是一个包含Android用户界面（UI）相关源代码的资源集合。下面我们将详细探讨Android UI界面的构建原理以及可能包含的知识点。 1. **Android UI框架*...
几个比较好的Android项目源码
09-02
1. **Android架构组件**： - **ViewModel**: 用于保持UI相关的数据在配置变更（如屏幕旋转）时存活，避免数据丢失。 - **LiveData**: 一种观察者模式的实现，确保数据在生命周期安全的情境下更新UI。 - **...
安卓Android源码——FaceBook.zip
10-14
1. **Android源码分析**： Android源码是开发者了解系统底层工作原理、优化性能和定制系统的基石。在这个项目中，我们可以看到Facebook如何对Android SDK进行扩展和定制，以满足其特定需求。通过分析Activity、...
Android 天气预报源码.zip
07-19
1. **Android SDK与环境搭建**：首先，你需要安装Android Studio，它是Google提供的官方集成开发环境（IDE），包含了Android SDK。源码的运行依赖于合适的Android SDK版本，确保你的环境设置正确，能够支持项目中...
安卓Android源码——WeatherForecast1.rar
10-11
【Android源码解析——WeatherForecast应用】 在Android开发领域，理解源码对于提升开发者技能至关重要。本篇将深入探讨名为"WeatherForecast1"的Android应用源码，这是一款天气预报应用，通过它我们可以学习到如何...
LiveData 面试题库、解答、源码分析
maniuT的博客
08-21 458
……
Android--Jetpack--LiveData源码分析
袁震的博客
12-08 1191
时人不识凌云木，直待凌云始道高。
LiveData-原理全解析
qq_21349039的博客
07-11 5579
LiveData 是 Jetpack 推出的基于观察者的消息订阅/分发的可观察数据组件，具有宿主（Activity、Fragment）生命周期感知能力，这种感知能力可确保 LiveData 仅分发消息给处于活跃状态的观察者，即只有处于活跃状态的观察者才能收到消息。而LiveData 的事件分发机制，会根据监听者的活跃状态来判断是否分发数据源变化事件，这样的话，我们就能避免当前页面在后台时，响应了事件，做出一些无用的逻辑浪费性能。LiveData 遵循观察者模式。当生命周期状态发生变化时，LiveData 会
Android开发——架构组件LiveData源码解析
热门推荐
关于Android开发的一些技术点总结 ╮(￣▽￣”)╭
08-31 2万+
近期的业务代码中使用到了LiveData， 研究了一下发现很好用，因此总结整理出了此篇学习笔记。希望各位多批评指正。 1. LiveData概述 简单地来说，LiveData就是一个持有数据的类。 LiveData中的数据可以被观察者订阅，当数据被修改时通知观察者。观察者包括Fragment、Activity以及Service等。 LiveData能够感知观察者的生命周期。只有在观察者处...
Android JetPack深入分析LiveData源码
故不积跬步无以至千里
07-04 295
Google Android开发者 LiveData概览在了解LiveData源码之前，建议先了解LifeCycleAndroid JetPack深入分析Lifecycle源码定义LiveData是一种可观察的数据存储器类。与常规的可观察类不同，LiveData具有生命周期感知能力，意指它遵循其他应用组件（如 activity、fragment 或 service）的生命周期。这种感知能力可确保 LiveData 仅更新处于活跃生命周期状态的应用组件观察者。LiveData是一个数据存储类，能够感知。
对LiveData源码阅读，了解LiveData如何观察活动中数据变化，以及对UI更新
qq_44035463的博客
12-21 500
对经常使用的LiveData源码阅读，了解LiveData如何观察活动中数据变化，以及对UI更新，
Android Jetpack之LiveData 使用及源码
csdn_aiyang的博客
09-15 1227
LiveData 是一种持有可被观察的数据存储类。和其他可被观察的类不同的是LiveData 可以在 Activity ，fragment 或者 service 生命周期发生改变时通知更新。LiveData 已经是必不可少的一环了，例如 MVVM 以及 MVI 开发模式中，都用到了 LiveData。
Android Jetpack 之Livedata介绍，面试题以及答案
wchg21131的博客
04-26 690
Jetpack LiveData 简单介绍 以及面试题答案
android repository rxjava livedata
08-09
LiveData是Android Jetpack组件中的一部分，用于解决UI数据和生命周期的关联问题。LiveData具有生命周期感知能力，当数据发生变化时，它会自动通知相关观察者进行更新。LiveData可以确保在合适的时间和生命周期下...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值