LiveData源码分析

1.在上一篇文章中介绍了LiveData的简单使用，可以查看LiveData简单使用_niuyongzhi的博客-CSDN博客

源码分析：

也可以分成两部分来看，一部分是注册observe源码，另一部分是setValue的源码。

先看Observe注册监听的方法。

1）先看liveData.observe()

 MutableLiveData<Person> liveData = new MutableLiveData();
    
 liveData.observe(this, new Observer<Person>() {
      @Override
      public void onChanged(Person person) {
             ageTv.setText(String.valueOf(person.age));
             nameTv.setText(person.name);
          }
  });

    private SafeIterableMap<Observer<? super T>, ObserverWrapper> mObservers =
            new SafeIterableMap<>();
 
 
    @MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            return;
        }
        //定义了一个Observer的包装类，用于数据变化时的回调。
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        //将wrapper存入一个HashMap中，
        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
        ....
        //向LifeCycle注册监听，这样wrapper就可以感知Activity声明周期变化。
        owner.getLifecycle().addObserver(wrapper);
    }

 看下这个LifecycleBoundObserver 类。

 class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
        @NonNull
        final LifecycleOwner mOwner;
 
        LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observersuper T> observer) {
            super(observer);
            mOwner = owner;
        }
 
        @Override
        boolean shouldBeActive() {
            return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
        }
        
        //在收到Activity生命周期变化时，会回调这个方法。
        @Override
        public void onStateChanged(@NonNull LifecycleOwner source,
                @NonNull Lifecycle.Event event) {
             //拿到当前的状态
            Lifecycle.State currentState = mOwner.getLifecycle().getCurrentState();
            if (currentState == DESTROYED) {
                //如果Activity的状态是销毁状态，则会从集合中移除注册的observer，防止内存泄露
                removeObserver(mObserver);
                return;
            }
            //状态同步
            Lifecycle.State prevState = null;
            while (prevState != currentState) {
                prevState = currentState;
                activeStateChanged(shouldBeActive());
                currentState = mOwner.getLifecycle().getCurrentState();
            }
        }
 
        @Override
        boolean isAttachedTo(LifecycleOwner owner) {
            return mOwner == owner;
        }
 
        @Override
        void detachObserver() {
            mOwner.getLifecycle().removeObserver(this);
        }
    }

 看activeStateChanged()方法 更新状态。

 void activeStateChanged(boolean newActive) {
            if (newActive == mActive) {
                return;
            }
            // immediately set active state, so we'd never dispatch anything to inactive
            // owner
            mActive = newActive;
            changeActiveCounter(mActive ? 1 : -1);
            if (mActive) {
                dispatchingValue(this);
            }
        }

    2）在看setValue中做了啥

     //看setValue的执行逻辑
      protected void setValue(T value) {
        //不是运行在主线程，抛异常
        assertMainThread("setValue");
        //版本控制，每调用一次setValue，version加1
        mVersion++;
        mData = value;
        //数据分发，注意这里传的参数是null
        dispatchingValue(null);
      }

看dispatchingValue方法

 private void dispatchingValue(@Nullable ObserverWrapper initiator) {
        if (mDispatchingValue) {
            mDispatchInvalidated = true;
            return;
        }
        mDispatchingValue = true;
        do {
            mDispatchInvalidated = false;
            if (initiator != null) {
                considerNotify(initiator);
                initiator = null;
            } else {
               //由于上面传过来的参数是null，所以会执行这个循环遍历mObservers
               //而mObservers就保存了向liveData添加的observer
                for (Iterator<Map.Entry<Observer<T>, ObserverWrapper>> iterator =
                        mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
                    considerNotify(iterator.next().getValue());
                    if (mDispatchInvalidated) {
                        break;
                    }
                }
            }
        } while (mDispatchInvalidated);
        mDispatchingValue = false;
    }

由于上面参数initiator传递过来的是null，所以会执行到for循环中的     considerNotify(iterator.next().getValue());  iterator.next().getValue()拿到的就是ObserverWrapper的实例。

再看considerNotify方法（）

 private void considerNotify(ObserverWrapper observer) {
       //如果观察在没有处于活跃状态，则不会受到更新的数据
        if (!observer.mActive) {
            return;
        }
        //这个判断是LifeCycleOwner的状态是否处于活跃状态
        if (!observer.shouldBeActive()) {
            observer.activeStateChanged(false);
            return;
        }
        //如果Observer中的版本已经是最新的，则不会更新
        if (observer.mLastVersion >= mVersion) {
            return;
        }
        observer.mLastVersion = mVersion;
        //调用observer中的回调方法。
        //observer就是上面创建的LifecycleBoundObserver的实例
        //mObserver就是添加的观察者
        observer.mObserver.onChanged((T) mData);
    }

 if (!observer.mActive) {
            return;
        }

这行代码，就控制了，不是活跃状态的观察者，不会去更新数据，保证处于前台的Activity中的LiveData，会刷新UI。

2.LiveData的粘性事件：

在第一个Activity中调用 liveData.setValue("main");已经注册的Observer能够收到消息。
当跳转到第二个Activity向第一个Activity中的LiveData添加Observer时，也会收到之前发送的消息。
这样的情况就是粘性事件。
正常的流程是  new LiveData----addObserver---setValue--收到消息
粘性事件的流程是 new LiveData---setValue-----addObserver--收到消息。
LiveData的粘性事件，并不是他的bug，而是出于某种业务需要才这样做到的，就是为了确保数据更新后，即使打开新的Activity也能够显示最新的数据。如果不期望这种效果，由于目前LiveData还没有提供这样的Api，所以得需要我们自己来实现。

LiveData出现粘性事件的源码分析。

由于第二个Activity也是实现了LifecycleOwner，也会调用ReportFragment的dispatch(Lifecycle.Event event)方法

private void dispatch(Lifecycle.Event event) {
    if (activity instanceof LifecycleOwner) {
        Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
        if (lifecycle instanceof LifecycleRegistry) {
            ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
        }
    }
}

看过LifeCycle源码分析的，对后面的执行流程应该很熟悉。

 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.onStateChanged(owner, event);
            mState = newState;
        }
 }

直接看到这里mLifecycleObserver是谁的实例？看Lifecycling.getCallback(observer);
在LifeCycle的回调中返回的是ReflectiveGenericLifecycleObserver的实例。
但是在LiveData中mLifecycleObserver是LifecycleBoundObserver的实例，实现了GenericLifecycleObserver接口。
 在调用LiveData.Observer()创建了LifecycleBoundObserver的实例。

 static GenericLifecycleObserver getCallback(Object object) {
        if (object instanceof FullLifecycleObserver) {
            return new FullLifecycleObserverAdapter((FullLifecycleObserver) object);
        }
        //LiveData中传进来的是LifecycleBoundObserver
        //所以在这里就return了
        if (object instanceof GenericLifecycleObserver) {
            return (GenericLifecycleObserver) object;
        }
 
        .......
        return new ReflectiveGenericLifecycleObserver(object);
    }

看LiveData.Observer()源码，创建了LifecycleBoundObserver对象，并作为观察者，添加到了LifeCycle中

public void observe(@NonNull LifecycleOwner owner, @NonNull Observer observer) {
    LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
    ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
    owner.getLifecycle().addObserver(wrapper);
}

在addObserver中，用ObserverWithState对LifecycleBoundObserver进行了一层封装。

 public void addObserver(@NonNull LifecycleObserver observer) {
    State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
    ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
    ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
}

综上代码，可以知道  mLifecycleObserver.onStateChanged(owner, event);
调用的是LifecycleBoundObserver的onStateChanged方法。

public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
        //如果当前Activity是Destroy的，则回收Observer，防止发送内存泄露
        if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
            removeObserver(mObserver);
            return;
        }
        activeStateChanged(shouldBeActive());
  }

 //删除的LiveData中该Activity(LifecycleOwner)添加的observer，
 //在LiveData.Observer时会传入LifecycleOwner，
 public void removeObserver(@NonNull final Observer<T> observer) {
     assertMainThread("removeObserver");
     ObserverWrapper removed = mObservers.remove(observer);
     if (removed == null) {
         return;
     }
     removed.detachObserver();
     removed.activeStateChanged(false);
 }

activeStateChanged(shouldBeActive());
//shouldBeActive判断是Activity是否是线上状态。
 boolean shouldBeActive() {
    return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
}

//在第二个Activity启动后，这个newActive传过来的是true
void activeStateChanged(boolean newActive) {
    //mActive默认是false，newActive是true
    if (newActive == mActive) {
        return;
    }
    mActive = newActive;
    boolean wasInactive = LiveData.this.mActiveCount == 0;
    //记录avtiveCount，如果活跃加1否则减1
    LiveData.this.mActiveCount += mActive ? 1 : -1;
    if (wasInactive && mActive) {
        onActive();
    }
    if (LiveData.this.mActiveCount == 0 && !mActive) {
        onInactive();
    }
    if (mActive) {
        dispatchingValue(this);
    }
}

//dispatchingValue把this传进来了，所以下面代码会执行if判断的第一个分支
 private void dispatchingValue(@Nullable ObserverWrapper initiator) {
        if (mDispatchingValue) {
            mDispatchInvalidated = true;
            return;
        }
        mDispatchingValue = true;
        do {
            mDispatchInvalidated = false;
            //initiator不是null执行这里
            if (initiator != null) {
                considerNotify(initiator);
                initiator = null;
            } else {
                for (Iterator<Map.Entry<Observer<T>, ObserverWrapper>> iterator =
                        mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
                    considerNotify(iterator.next().getValue());
                    if (mDispatchInvalidated) {
                        break;
                    }
                }
            }
        } while (mDispatchInvalidated);
        mDispatchingValue = false;
  }

 private void considerNotify(ObserverWrapper observer) {
       //observer.mActive 为true
        if (!observer.mActive) {
            return;
        }
        //observer.shouldBeActive()为true
        if (!observer.shouldBeActive()) {
            observer.activeStateChanged(false);
            return;
        }
        //mVersion是LiveData的变量，会大于0
        //observer.mLastVersion初始值是0，
        //所以这个分支判断也不会进来
        if (observer.mLastVersion >= mVersion) {
            return;
        }
        //版本同步
        observer.mLastVersion = mVersion;
        //这行代码，就会调用observer的onChange方法
        observer.mObserver.onChanged((T) mData);
    }

所以在第二个Activity中添加的observer就收到了第一个Activity发送的消息。
 这就是LiveData粘性事件的源码执行原理。
 如果想要消除这种粘性事件，通过上面的代码分析，我们可以修改添加的Observer的mLastVersion值，
 使它在初始化时就和LiveData中的mVersion一致，就不会出现粘性事件。

3. liveData.observeForever(observer)

 liveData.observeForever 是一个和Activity声明周期无关的消息订阅与发送的方法

public void observeForever(@NonNull Observer observer) {
    AlwaysActiveObserver wrapper = new AlwaysActiveObserver(observer);
    ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
 
    if (existing != null) {
        return;
    }
    //这个参数是true
    wrapper.activeStateChanged(true);
}