Jetpack-LiveData源码解析
|
1,800
|
0
|
Jetpack,源码

3115 字
|
32 分钟

LiveData源码解析

源码版本：
* 源码版本：2.8.7
* 更新时间：2025-3月
* 需会使用：Lifecycle

导航：
* Jetpack-Lifecycle源码解析
* Jetpack-LiveData源码解析
* Jetpack-ViewModel源码详解
* 更多的文章看这里：主页

使用

监听值

val liveData = MutableLiveData<Int>()
val observer = object : Observer<Int> {
    override fun onChanged(value: Int) {
        // 数据改变
    }
}
liveData.observe(this, observer) // 生命周期感知观察
liveData.observeForever(observer) // 永远观察

设置值

liveData.setValue(value) // 只能在主线程
liveData.postValue(value) // 在后台线程

获取值

liveData.getValue() // 获取值

移除监听

liveData.removeObserver(observer) // 移除指定的某个Observer
liveData.removeObservers(this) // 移除指定Lifecycle绑定的所有Observer

是否

val initialized = liveData.isInitialized // 是否初始化
val hasObservers = liveData.hasObservers() // 是否有观察者
val hasActiveObservers = liveData.hasActiveObservers() // 是否有活跃的观察者

源码

成员变量

// 数据锁
final Object mDataLock = new Object();
// 开始版本号
static final int START_VERSION = -1;
// 没有设置数据的默认值
static final Object NOT_SET = new Object();
// 所有的Observer，key为原始Observer，value为包装后的Observer。
private SafeIterableMap<Observer<? super T>, ObserverWrapper> mObservers =
        new SafeIterableMap<>();
// 活动Observer的数量
int mActiveCount = 0;
// 是否活跃状态改变中
private boolean mChangingActiveState;
// 当前数据
private volatile Object mData;
// 延迟的数据
volatile Object mPendingData = NOT_SET;
// 当前版本号
private int mVersion;

// 是否值分发中
private boolean mDispatchingValue;
// 是否分发无效
private boolean mDispatchInvalidated;
// 延迟的赋值，详细看后面的postValue()方法源码。
private final Runnable mPostValueRunnable = new Runnable() {
    @SuppressWarnings("unchecked")
    @Override
    public void run() {
        Object newValue;
        synchronized (mDataLock) {
            newValue = mPendingData;
            mPendingData = NOT_SET;
        }
        setValue((T) newValue);
    }
};

创建LiveData

// 有默认值
public LiveData(T value) {
    // 记录设置的值
    mData = value;
    // 版本号加1，以标记此LivaData的数据版本要比Observer包装者的数据版本要高（新），以进行通知观察者Observer值改变。
    mVersion = START_VERSION + 1;
}

// 无默认值
public LiveData() {
    // 设置的值为默认
    mData = NOT_SET;
    // 版本号和Observer包装者的版本相同，以不进行通知观察者Observer值改变。
    mVersion = START_VERSION;
}

监听值

observe()

@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
    // 断言只能在主线程调用，否则抛异常。
    assertMainThread("observe");
    // 当Lifecycle处于DESTROYED状态时，再观察是没有意义的，直接返回。
    if (owner.getLifecycle().getCurrentState() == DESTROYED) {
        // ignore
        return;
    }
    // 创建新的Observer包装者LifecycleBoundObserver，让其监听生周周期变化，并处理。
    LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
    // mObservers是一个Map，key为Observer，value为ObserverWrapper，持有多个观察者包装者。
    // putIfAbsent，如果传入key对应的value已经存在，就返回存在的value，不进行替换。如果不存在，就添加key和value，并返回null。
    ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
    if (existing != null && !existing.isAttachedTo(owner)) {
        // 该Observer对象已经被该LiveData持有，且该值ObserverWrapper对象没依附到参数owner的Lifecycle，
        // 说明该Observer之前已经被其它的Lifecycle添加，再被当前的Lifecycle添加，则直接抛出异常。
        throw new IllegalArgumentException("Cannot add the same observer"
                + " with different lifecycles");
    }
    if (existing != null) {
        // 该Observer对象已经被该LiveData持有，且该值ObserverWrapper对象依附到参数owner的Lifecycle，说明该Observer之前已经被当前的Lifecycle添加，则直接返回。
        return;
    }
    // 使用Lifecycle控件，观察该ObserverWrapper对象生命周期。
    owner.getLifecycle().addObserver(wrapper);
}

observe()方法，就是把我们的Observer对象包装成LifecycleBoundObserver后存入mObservers中，并将其添加到参数owner的Lifecycle中，以监听生命周期变化。它继承ObserverWrapper并实现了LifecycleEventObserver。

说明：

  1. observe()方法，只能在主线程调用。
  2. 当Lifecycle处于DESTROYED状态时，此时不会添加。
  3. 同一个LiveData，无法添加具有不同的Lifecycle的同一个Observer。

接下来，我们先看一下LifecycleBoundObserver的父类ObserverWrapper，最后再看它。

ObserverWrapper类

private abstract class ObserverWrapper {
    // 传入的原始观察者对象
    final Observer<? super T> mObserver;
    // 此观察者包装者，是否处于活跃状态，只有活跃状态的时候才可以被通知。
    boolean mActive;
    // 此观察者包装者，数据的版本号。
    int mLastVersion = START_VERSION;

    ObserverWrapper(Observer<? super T> observer) {
        // 记录传入的原始观察者对象
        mObserver = observer;
    }

    // 此观察者包装者，是否处于活跃状态。
    abstract boolean shouldBeActive();

    // 此观察者包装者，是否依附到LifecycleOwner中。
    boolean isAttachedTo(LifecycleOwner owner) {
        return false;
    }

    // 此观察者包装者，分离Observer，即不再观察此ObserverWrapper。
    void detachObserver() {
    }

    // 此观察者包装者，活跃状态改变。
    void activeStateChanged(boolean newActive) {
        if (newActive == mActive) {
            // 新状态和现有状态相同，则不处理。
            return;
        }
        // 立即设置活动状态，这样我们就永远不会向非活动所有者分派任何内容。
        mActive = newActive;
        // 改变活跃观察者的数量，此观察者包装者，变活跃+1，变非活跃-1。
        changeActiveCounter(mActive ? 1 : -1);
        if (mActive) {
            // 活跃状态下，进行分发值。
            dispatchingValue(this);
        }
    }
}

ObserverWrapper类，是抽象类，为Observer的包装者，其内部对其原始Observer（observe()、observeForever()传入）进行了包装。

说明：

  1. ObserverWrapper内部还含有mLastVersion（此ObserverWrapper数据的版本号），用于判断是否需要通知此ObserverWrapper数据改变，详细看后面的dispatchingValue()方法源码。
  2. activeStateChanged()方法，为活跃状态改变，内部判断了如果新状态和现有状态相同则不处理，并且其内部仅会在活跃状态下调用dispatchingValue()方法以进行分发此ObserverWrapper的值。

接下来，我们看下LifecycleBoundObserver类，然后再依次看上面用到的changeActiveCounter()、dispatchingValue()方法。

LifecycleBoundObserver类

class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
    // 传入的Lifecycle持有者对象
    @NonNull
    final LifecycleOwner mOwner;

    LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<? super T> observer) {
        super(observer);
        mOwner = owner;
    }

    // 此观察者包装者，是否应该处于活跃状态。
    @Override
    boolean shouldBeActive() {
        // onStart，onResume，onPause这三个状态处于活跃状态，其它处于非活跃状态。
        return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
    }

    // LifecycleEventObserver接口实现方法，生命周期状态改变的时候会收到通知。
    @Override
    public void onStateChanged(@NonNull LifecycleOwner source,
            @NonNull Lifecycle.Event event) {
        Lifecycle.State currentState = mOwner.getLifecycle().getCurrentState();
        if (currentState == DESTROYED) {
            // 当生命周期状态为destroyed的时候，把该观察者自动移除。
            // -说明：在removeObserver内部，会调用下面的detachObserver方法，将此ObserverWrapper从Lifecycle中移除，
            // -并调用父类的activeStateChanged方法，通知活跃状态改为：非活跃的。
            removeObserver(mObserver);
            return;
        }
        // 生命周期状态改变，通知活跃状态改变。
        // 说明：加While循环的目的，防止执行activeStateChanged的时候，mOwner的生命周期的状态更改。
        Lifecycle.State prevState = null;
        while (prevState != currentState) {
            prevState = currentState;
            // 通知活跃状态改变
            activeStateChanged(shouldBeActive());
            // 记录当前状态
            currentState = mOwner.getLifecycle().getCurrentState();
        }
    }

    // 此观察者包装者，是否依附到LifecycleOwner中。
    @Override
    boolean isAttachedTo(LifecycleOwner owner) {
        // 如果持有的（observe()方法传入的）mOwner与要比较的owner相同，则认为此观察者包装者，已经依附到传入的LifecycleOwner中。
        return mOwner == owner;
    }

    // 此观察者包装者，分离Observer，即不再观察此ObserverWrapper。
    @Override
    void detachObserver() {
        // Lifecycle移除此ObserverWrapper
        mOwner.getLifecycle().removeObserver(this);
    }
}

LifecycleBoundObserver类，是ObserverWrapper子类，内部实现了LifecycleEventObserver（实现了此才能被observe()方法内的Lifecycle添加，用于监听Lifecycle状态改变），为和生命周期绑定的Observer。

说明：

  1. 此类内部含有LifecycleOwner，为observe()方法owner参数传入。
  2. shouldBeActive()方法，用于判断此ObserverWrapper是否处于活跃状态，其内部判断为此Lifecycle的当前生命周期状态大于等于STARTED即为活跃状态（即：onStart，onResume，onPause为活跃状态，其它为非活跃状态）。
  3. onStateChanged()方法，为当生命周期状态改变的时候，通知此方法。
    1. 状态为destroyed的时候，会调用removeObserver()方法删除。此方法内部调用了此ObserverWrapper的detachObserver()方法，将此Observer从Lifecycle中移除，还会调用此ObserverWrapper的activeStateChanged()方法，通知活跃状态为非活跃的。removeObserver()相关，请看下面的移除监听–removeObserver()。
    2. 状态为其它的时候，会调用activeStateChanged()方法，通知活跃状态改变，此方法仅会在活跃状态下进行分发值。
  4. 由于Lifecycle在增加LifecycleEventObserver时，会在onStateChanged()立即收到接收到当前的状态，所以同一个LiveData，在observe()之前发的数据，在重新observe()时也会接收到之前发的，此为粘性效果（之前发送的数据，在重新订阅后，会重新获取到）。

接下来，我们来看一下ObserverWrapper类activeStateChanged()方法用到的changeActiveCounter()方法。

LiveData –> changeActiveCounter()方法

@MainThread
void changeActiveCounter(int change) {
    // 记录之前活跃的数量
    int previousActiveCount = mActiveCount;
    // 记录现在的活跃的数量，change：活跃状态为+1，非活跃状态为-1。
    mActiveCount += change;
    if (mChangingActiveState) {
        // 如果是改变中，则返回，因为有下面的while处理变化。
        return;
    }
    // 标记为改变中
    mChangingActiveState = true;
    try {
        // 之前的活跃数量和现在的活跃数量不一致，那么将执行下面的通知onActive()或者onInactive()。
        // 说明：加while的原因，因为当执行下面判断逻辑的时候，changeActiveCounter()方法再次调用，导致mActiveCount值更改，所以加while使其保持一致。
        while (previousActiveCount != mActiveCount) {
            // 之前的活跃数量为0，并且现在的活跃数量大于0，即说明之前是非活跃状态，然后现在是活跃状态，则需要调用onActive()方法。
            boolean needToCallActive = previousActiveCount == 0 && mActiveCount > 0;
            // 之前的活跃数量是大于0，并且现在的活跃数量为0，即说明之前是活跃状态，然后现在是非活跃状态，则需要调用onInactive()方法。
            boolean needToCallInactive = previousActiveCount > 0 && mActiveCount == 0;
            // 更新之前的为现在的
            previousActiveCount = mActiveCount;
            if (needToCallActive) {
                // 需要调用onActive()方法，它是空方法，可以自定义LiveData覆盖实现。
                onActive();
            } else if (needToCallInactive) {
                // 需要调用onInactive()方法，它是空方法，可以自定义LiveData覆盖实现。
                onInactive();
            }
        }
    } finally {
        // 标记为改变结束
        mChangingActiveState = false;
    }
}

changeActiveCounter()方法，为改变活跃观察者的数量，并会通知此LiveData的onActive()（不活跃变活跃）或者onInactive()（活跃变不活跃）。

接下来，我们来看一下ObserverWrapper类activeStateChanged()方法用到的dispatchingValue()方法。

LiveData –> dispatchingValue()方法

void dispatchingValue(@Nullable ObserverWrapper initiator) {
    if (mDispatchingValue) {
        // 分发值中，则标记分发失效，并返回（因为有下面的do-while处理变化）。
        mDispatchInvalidated = true;
        return;
    }
    // 标记分发值中
    mDispatchingValue = true;
    do {
        // 清空分发失效的标记
        mDispatchInvalidated = false;
        if (initiator != null) {
            // initiator不为空，为activeStateChanged()方法调用传入，则只通知该ObserverWrapper。
            // 考虑通知
            considerNotify(initiator);
            // 直接清空标记
            initiator = null;
        } else {
            // initiator为空，为setValue()方法调用，则通知所有的ObserverWrapper。
            for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
                    mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
                // 考虑通知
                considerNotify(iterator.next().getValue());
                // 在遍历过程中，如果遇到值更新（dispatchingValue()调用），则立即退出当前分发，则继续走while，再执行do中逻辑。
                if (mDispatchInvalidated) {
                    break;
                }
            }
        }
    } while (mDispatchInvalidated);
    // 标记分发值结束LiveData源码解析
    mDispatchingValue = false;
}

dispatchingValue()方法，为分发值方法，如果参数initiator不为空则只通知此ObserverWrapper分发值，如果参数initiator为空则通知此LiveData所有的ObserverWrapper分发值。

接下来，我们来看一下dispatchingValue()方法用到的considerNotify()方法。

LiveData –> considerNotify方法

@SuppressWarnings("unchecked")
private void considerNotify(ObserverWrapper observer) {
    if (!observer.mActive) {
        // 非活跃状态（仅setValue()通知所有ObserverWrapper分发传入，才会有此为不活跃状态），则不进行后续处理。
        return;
    }
    if (!observer.shouldBeActive()) {
        // shouldBeActive()为非活跃状态，不进行后续处理。
        observer.activeStateChanged(false);
        return;
    }
    if (observer.mLastVersion >= mVersion) {
        // 此Observer数据的版本号[大于等于]当前LiveData数据的版本号，则说明数据已经同步，则不进行后续处理。
        return;
    }
    // 观察者包装者，更新版本号。
    observer.mLastVersion = mVersion;
    // 观察者包装者，通知传入的观察者，数据改变。
    observer.mObserver.onChanged((T) mData);
}

considerNotify()方法，为考虑通知方法，其内部判断了此observer非活跃状态不通知，此observer数据版本号大于等于当前LiveData数据的版本号不通知（说明此observer数据已经是最新的），其余则更新此observer的版本号为当前LiveData数据最新的版本号（以标记当前ObserverWrapper已经数据最新）、通知参数的observer数据改变（传入最新的数据）。

小结

代码流程：

  1. LiveData的observe(owner, observer)方法，将参数observer包装成LifecycleBoundObserver后添加到mObservers，并添加到参数owner的Lifecycle中，以监听生命周期变化。
  2. 当生命周期状态改变的时候，通知LifecycleBoundObserver的onStateChanged方法。
    1. 状态为destroyed的时候，将此LifecycleBoundObserver从Lifecycle中移除。
    2. 状态为其它的时候，会调用LifecycleBoundObserver父类ObserverWrapper的activeStateChanged()方法，通知活跃状态改变（onStart、onResume、onPause为活跃，其它为非活跃）。
  3. ObserverWrapper的activeStateChanged()方法，会判断新状态和现有状态相同，则不处理。并调用LiveData的changeActiveCounter()方法（改变活跃观察者的数量）；以及如果通知的是活跃状态，则调用LiveData的dispatchingValue()方法（分发值）。
    1. LiveData的changeActiveCounter()方法，为改变活跃观察者的数量，并会通知此LiveData的onActive()（活跃）或者onInactive()（不活跃）。
    2. LiveData的dispatchingValue(initiator)方法，为分发值方法，如果是活跃状态改变而分发值（参数initiator不为空），则直接让此ObserverWrapper考虑通知（调用LiveData的considerNotify()方法）。如果是setValue()而分发值（参数initiator为空），则让所有的ObserverWrapper考虑通知。
  4. LiveData的considerNotify(observer)方法，会进行最终的判断，如果此observer是活跃的，并且此observer的数据版本号过低，则进行通知数据改变并传入最新的数据。

LiveData的observe(owner, observer)方法注释：

  1. 在给定的owner的生命周期内，将给定的observer添加到观察者列表中。事件在主线程上分派。如果LiveData已经有数据设置，它将被传递给此observer。observer只有在owner处于STARTED或RESUMED状态（活动）时才会接收事件。
  2. 如果owner移动到DESTROYED状态，observer将自动被移除。
  3. 当数据发生变化而owner不活动时，它将不会收到任何更新。如果它再次激活，它将自动接收最后可用的数据。
  4. 只要给定的LifecycleOwner没有被销毁，LiveData就会保持对observer和owner的强引用。当它被销毁时，LiveData会删除对observer和owner的引用。如果给定的owner已经处于DESTROYED状态，LiveData忽略调用。
  5. 如果给定的owner观察者元组已经在列表中，调用将被忽略。如果observer已经与另一个owner在列表中，LiveData抛出一个IllegalArgumentException。

observeForever()

@MainThread
public void observeForever(@NonNull Observer<? super T> observer) {
    // 断言只能在主线程调用，否则抛异常。
    assertMainThread("observeForever");
    // 创建新的Observer包装者AlwaysActiveObserver，让其处理。
    AlwaysActiveObserver wrapper = new AlwaysActiveObserver(observer);
    ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
    if (existing instanceof LiveData.LifecycleBoundObserver) {
        // 该Observer对象已经被该LiveData持有，且该ObserverWrapper是LifecycleBoundObserver对象，说明该Observer已经被Lifecycle观察，再被Forever观察，则直接抛出异常。
        throw new IllegalArgumentException("Cannot add the same observer"
                + " with different lifecycles");
    }
    if (existing != null) {
        // 该Observer对象已经被该LiveData持有，且该ObserverWrapper是非LifecycleBoundObserver对象，说明该Observer已经被observe()观察，再被Forever观察，则直接返回。
        return;
    }
    // 立即通知活跃状态为：活跃的。
    wrapper.activeStateChanged(true);
}

observeForever()方法，就是把我们的Observer对象包装成AlwaysActiveObserver后存入mObservers中，并会立即通知ObserverWrapper活跃状态改变为活跃的。

说明：

  1. observeForever()方法，只能在主线程调用。
  2. 同一个LiveData，无法添加具有不同的Lifecycle的同一个Observer。

接下来，我们先看一下AlwaysActiveObserver类。

AlwaysActiveObserver类

private class AlwaysActiveObserver extends ObserverWrapper {

    AlwaysActiveObserver(Observer<? super T> observer) {
        super(observer);
    }

    // 此观察者包装者，是否应该处于活跃状态。
    @Override
    boolean shouldBeActive() {
        // 始终处于活跃状态，此方法只在shouldBeActive()方法内调用。
        return true;
    }
}

AlwaysActiveObserver类，是ObserverWrapper子类，并覆盖了shouldBeActive()方法让其始终处于活跃状态。

小结

代码流程：

  1. LiveData的observeForever(observer)方法，将参数observer包装成AlwaysActiveObserver后添加到mObservers，并会立即通知ObserverWrapper的activeStateChanged()方法为活跃的。
  2. ObserverWrapper的activeStateChanged()方法，相关介绍及后面的流程，请看上面的：observe()-小结-代码流程-流程3。

LiveData的observeForever(observer)方法注释：

  1. 将给定的observer添加到观察者列表中。这个调用类似于带有一个始终处于活跃状态的LifecycleOwner的observe(LifecycleOwner, Observer)。这意味着给定的observer将接收所有事件，并且永远不会被自动删除。你应该手动调用removeObserver(Observer)来停止观察这个LiveData。虽然LiveData有这样一个观察者，但它将被认为是活跃的。

  2. 如果observer已经添加了一个owner到这个LiveData， LiveData抛出一个IllegalArgumentException。

设置值

setValue()

@MainThread
protected void setValue(T value) {
    // 断言只能在主线程调用，否则抛异常。
    assertMainThread("setValue");
    // 当前LiveData数据的版本号，每次有新值版本都会+1，用于和观察者包装者的版本号进行比较，如果观察者包装者的版本号小于此值，则进行通知更新。
    mVersion++;
    // 记录需要分发的值
    mData = value;
    // 进行分发值，传null代表考虑分发给所有的观察者包装者。
    dispatchingValue(null);
}

setValue()方法，为设置值方法，只能在主线程调用，内部会升级版本号以及更新最新的数据，并且会通知所有的观察者分发数据。

LiveData的setValue(value)方法注释：

  1. 设置值。如果有活跃的观察者，则将值分发给他们。
  2. 此方法必须从主线程调用。如果你需要从后台线程设置一个值，你可以使用postValue(Object)。

postValue()

protected void postValue(T value) {
    // 是否要发送任务
    boolean postTask;
    // 加synchronized，防止并发，保证线程安全。
    synchronized (mDataLock) {
        // 是否要发送，如果mPendingData != NOT_SET，即上一次的post还没有执行，再发送新值，则不再发送。
        postTask = mPendingData == NOT_SET;
        // 记录要待处理的数据
        mPendingData = value;
    }
    if (!postTask) {
        // 不发送，直接返回。
        return;
    }
    // 使用Handler，post到主线程，设置值。
    ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
}

private final Runnable mPostValueRunnable = new Runnable() {
    @SuppressWarnings("unchecked")
    @Override
    public void run() {
        // 记录新值，防止mPendingData更改
        Object newValue;
        // 加synchronized，防止并发，保证线程安全。
        synchronized (mDataLock) {
            // 记录新值
            newValue = mPendingData;
            // mPendingData重置，标记执行完成。
            mPendingData = NOT_SET;
        }
        // 调用setValue，设置新值。
        setValue((T) newValue);
    }
};

postValue()方法，为设置值方法，可以在任何线程调用，内部使用Handler的post()使其在主线程设置值，设置值是调用了上面setValue()。

LiveData的postValue(value)方法注释：

  1. 将任务发送到主线程以设置给定值。所以如果你在主线程中执行了下面的代码：

    liveData.postValue("a");
    liveData.setValue("b");

    首先设置值”b”，然后主线程将用值”a”覆盖它。

  2. 如果在主线程执行提交的任务之前多次调用此方法，则只会分发最后一个值。

获取值

getValue()

public T getValue() {
    Object data = mData;
    if (data != NOT_SET) {
        return (T) data;
    }
    return null;
}

getValue()方法，为获取值方法，如果当前有设置过值（LiveData(value)、setValue(value)、postValue(value) ）则返回此值，否则返回null。

LiveData的getValue()方法注释：

  1. 返回当前值。
  2. 请注意，在后台线程中调用此方法并不能保证将接收到最新设置的值。
  3. 返回：当前值，如果isInitialized()为false则返回null。

移除监听

removeObserver()

@MainThread
public void removeObserver(@NonNull final Observer<? super T> observer) {
    // 断言只能在主线程调用，否则抛异常。
    assertMainThread("removeObserver");
    // 将observer从mObservers中移除
    ObserverWrapper removed = mObservers.remove(observer);
    if (removed == null) {
        // removed为空，则代表observer就没有被mObservers添加，直接返回。
        return;
    }
    // 被移除的观察者包装者，分离Observer，不再观察ObserverWrapper。
    removed.detachObserver();
    // 被移除的观察者包装者，通知活跃状态改为：非活跃的。 
    removed.activeStateChanged(false);
}

removeObserver(observer)方法，为从观察者列表中移除给定的observer，此方法只能在主线程执行，并且会分离Observer和通知活跃状态改为非活跃的。

removeObservers()

@SuppressWarnings("WeakerAccess")
@MainThread
public void removeObservers(@NonNull final LifecycleOwner owner) {
    // 断言只能在主线程调用，否则抛异常。
    assertMainThread("removeObservers");
    for (Map.Entry<Observer<? super T>, ObserverWrapper> entry : mObservers) {
        if (entry.getValue().isAttachedTo(owner)) {
            // 只有所属于LifecycleOwner的才会移除，如observeForever添加的不会移除。
            removeObserver(entry.getKey());
        }
    }
}

removeObservers(owner)方法，为移除与给定LifecycleOwner绑定的所有Observer（如：observeForever()添加的永远不会移除），此方法只能在主线程执行，并且最终会调用上面的removeObserver(observer)方法进行单个移除。

是否

isInitialized()

public boolean isInitialized() {
    return mData != NOT_SET;
}

isInitialized()方法，为此LiveData是否初始化。

LiveData的isInitialized()方法注释：

  1. 返回是否在此LiveData上设置了显式值。如果返回true，则可以从getValue()获取当前值。
  2. 请注意，即使正在处理对postValue(Object)的调用，在后台线程上调用此方法仍可能导致此方法返回false。
  3. 返回：是否在此LiveData上设置了显式值。

hasObservers()

public boolean hasObservers() {
    return mObservers.size() > 0;
}

hasObservers()方法，为此LiveData是否有观察者。

hasActiveObservers()

public boolean hasActiveObservers() {
    return mActiveCount > 0;
}

hasActiveObservers()方法，为此LiveData是否有活跃的观察者。

总结

以上就是全面的Jetpack-LiveData源码了！欢迎大家点赞、收藏，以方便您后续查看，之后会出Jetpack其它源码系列，请及时关注。

JetpackLiveData源码
暂无评论

发送评论 编辑评论 


				

			

						

				

					

						

							

								
							

							
						

					

				

				

					

						

							

								
							

							
						

					

				

				

					

						

							

								
							

							
							
													

					

				

			

			
			

				

					
				

			

				

											

							
							
						

																				
					
											
						

	

		
|´・ω・)ノ
ヾ(≧∇≦*)ゝ
(☆ω☆)
（╯‵□′）╯︵┴─┴
￣﹃￣
(/ω＼)
∠( ᐛ 」∠)＿
(๑•̀ㅁ•́ฅ)
→_→
୧(๑•̀⌄•́๑)૭
٩(ˊᗜˋ*)و
(ノ°ο°)ノ
(´இ皿இ｀)
⌇●﹏●⌇
(ฅ´ω`ฅ)
(╯°A°)╯︵○○○
φ(￣∇￣o)
ヾ(´･ ･｀｡)ノ"
( ง ᵒ̌皿ᵒ̌)ง⁼³₌₃
(ó﹏ò｡)
Σ(っ °Д °;)っ
( ,,´･ω･)ﾉ"(´っω･｀｡)
╮(╯▽╰)╭
o(*////▽////*)q
＞﹏＜
( ๑´•ω•) "(ㆆᴗㆆ)
😂
😀
😅
😊
🙂
🙃
😌
😍
😘
😜
😝
😏
😒
🙄
😳
😡
😔
😫
😱
😭
💩
👻
🙌
🖕
👍
👫
👬
👭
🌚
🌝
🙈
💊
😶
🙏
🍦
🍉
😣
Source: github.com/k4yt3x/flowerhd
	

	

		
颜文字
Emoji
小恐龙
花!
	


									

			

			
			
		

	






上一篇
下一篇 



					
京ICP备18058279号-1