LiveData 源码初探

喜欢ヅ旅行 2023-01-16 15:22 165阅读 0赞

# 前言 #

文本需要一定`lifecycle`基础知识.`LiveData`是一个基础观察者设计模式的基础框架,可结合`databinding`或者直接作为数据观察回调使用.

class MainActivity : AppCompatActivity() {
        
       //MutableLiveData继承LiveData
      val mutableLiveData = MutableLiveData<String>()
      override fun onCreate(savedInstanceState: Bundle?) {
        
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    	//分析点1 
        mutableLiveData.observe(this as LifecycleOwner, Observer {
        
        })
        //分析点2
    	mutableLiveData.value=""
      }
    }

*  `mutableLiveData.observe`

public abstract class LiveData<T> {
        
    		//一个可以在迭代期间删减元素的集合类
    	   private SafeIterableMap<Observer<? super T>, ObserverWrapper> mObservers =
                new SafeIterableMap<>();
                	
    	  public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        
            //必须是主线程调用
            assertMainThread("observe");
    		//当前如果lifecycle显示已经销毁那么没有必要进行事件监听        
            if (owner.getLifecycle().getCurrentState() == DESTROYED) {
        
                return;
            }
            //LifecycleBoundObserver实现LifecycleObserver接口所以可以监听lifecycle变化
            LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
            //放入集合中
            ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
           
            owner.getLifecycle().addObserver(wrapper);
        }
    }

*  `setValue(T value)`

//MutableLiveData.java
    public class MutableLiveData<T> extends LiveData<T> {
        
        @Override
        public void postValue(T value) {
        
            super.postValue(value);
        }
    
        @Override
        public void setValue(T value) {
        
            super.setValue(value);
        }
    }

//LiveData.java
    public abstract class LiveData<T> {
        
      
      static final int START_VERSION = -1;
      //每次livedata改变版本+1
      private int mVersion = START_VERSION;
      
      protected void setValue(T value) {
        
      		//断言是在主线程
            assertMainThread("setValue");
      		//版本号加一
            mVersion++;
            //放入数值
            mData = value;
            //分发事件
            dispatchingValue(null);
        }
        //当前是否正在分发
        //如果正在分发返回true
        private boolean mDispatchingValue;
        
        void dispatchingValue(@Nullable ObserverWrapper initiator) {
        
         //如果当前正在分发直接返回	
         if (mDispatchingValue) {
        
         	//通知正在分发的线程,当前有数据变化你继续分发一次
             mDispatchInvalidated = true;
             return;
         }
         //设置标志位,表示正在分发
         mDispatchingValue = true;
         
         do {
        
             mDispatchInvalidated = false;
             //initiator一般都为空,所以我们直接看else
             if (initiator != null) {
        
                 considerNotify(initiator);
                 initiator = null;
             } else {
        
             	//遍历所有观察者
                 for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
                         mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
        
                    
                     considerNotify(iterator.next().getValue());
                    //mDispatchInvalidated
                     if (mDispatchInvalidated) {
        
                         break;
                     }
                 }
             }
         } while (mDispatchInvalidated);
         mDispatchingValue = false;
     }
    
    }

上面的代码我们知道所有的核心分发代码都是`considerNotify`完成

class LiveData{
        
    	 private void considerNotify(ObserverWrapper observer) {
        
    	 	//mActive表示当前是on_resume或者或者on_start状态
    	 	
            if (!observer.mActive) {
        
                return;
            }
           	//当前lifecycle状态是on_resume或者或者on_start状态shouldBeActive就返回true
           	//如果这里为取反表示当前状态不是on_resume或者或者on_start,所以推迟事件分发
            if (!observer.shouldBeActive()) {
        
            	//如果不是推迟执行
                observer.activeStateChanged(false);
                return;
            }
            //如果当前观察者的版本号大于当前版本号那么不处理
            //mVersion会在每次数据改变的时候+1
            if (observer.mLastVersion >= mVersion) {
        
                return;
            }
            //将当前版本号赋值给观察者
            observer.mLastVersion = mVersion;
    		//回调观察者
            observer.mObserver.onChanged((T) mData);
        }
    }

在上面的理想状态我们的回调是非常简单的,我们简单修改下,我们在`onstop`更新`livedata`数据

class MainActivity : AppCompatActivity() {
        
    
      val mutableLiveData = MutableLiveData<String>()
      override fun onCreate(savedInstanceState: Bundle?) {
        
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    
        mutableLiveData.observe(this as LifecycleOwner, Observer {
        
          println("MainActivity.onCreate")
        })
        
      }
    
      override fun onStop() {
        
        super.onStop()
        mutableLiveData.value = ""
      }
    
    }

当我们在`onstop`更新数据时,不会立马回调观察者,而是在`activity`的`onstart`时,我们看`livedata`是如何延迟发送数据的.livedata对于每个观察者都会构建一个`LifecycleBoundObserver`去监听`lifecycle`的回调.

//LiveData.java
     class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver {
        
            @NonNull
            final LifecycleOwner mOwner;
    		//observer是我们的livedata观察者
            LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<? super T> observer) {
        
                super(observer);
                mOwner = owner;
            }
    
         
    		//生命周期改变的时候会回调这个函数
            @Override
            public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
        
                //如果当前lifecycle被销毁那么移除所有的观察者
                if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
        
                    removeObserver(mObserver);
                    return;
                }
                //可见activeStateChanged实现主要逻辑
                activeStateChanged(shouldBeActive());
            }
            //保证当前至少是start状态才返回true,
            //这里返回true情况时onstart和onresume两种生命周期.onstop状态是CREATED,比STARTED小
       		@Override
            boolean shouldBeActive() {
        
                return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
            }
            
            @Override
            boolean isAttachedTo(LifecycleOwner owner) {
        
                return mOwner == owner;
            }
    
            @Override
            void detachObserver() {
        
                mOwner.getLifecycle().removeObserver(this);
            }
        }

//LiveData.java
    private abstract class ObserverWrapper {
        
    	 //newActive为true表示当前状态是可以进行事件分发的
    	 void activeStateChanged(boolean newActive) {
        
    	 		//如果和之前状态一样直接返回
                if (newActive == mActive) {
        
                    return;
                }
    
    			//赋值给成员属性保存
                mActive = newActive;
     			//这里判断是否为0的用意:
     			//在默认的情况mActiveCount在newActive为true时+1,在newActive为false时-1.
     			//在这种情况下可以实现一种平衡,保证onActive和onInactive不会回调多次,这里需要读者稍微自行理解下
    			
                boolean wasInactive = LiveData.this.mActiveCount == 0;
                //根据mActive状态调用onActive或onInactive函数
                LiveData.this.mActiveCount += mActive ? 1 : -1;
    
                if (wasInactive && mActive) {
        
                    onActive();
                }
                
                if (LiveData.this.mActiveCount == 0 && !mActive) {
        
                    onInactive();
                }
                //如果当前状态是可以进行事件分发的
                if (mActive) {
        
                    dispatchingValue(this);
                }
            }
    }

`LiveData`实现上比较简单,也比较实用.