LiveData和ViewModel源码学习

最新推荐文章于 2025-12-19 19:34:15 发布

原创

最新推荐文章于 2025-12-19 19:34:15 发布 · 756 阅读

5 ·

CC 4.0 BY-SA版权

文章标签：

#android

本文解析了LiveData中的ObserverWrapper和LifecycleEventObserver的作用，探讨了ViewModel与Activity的生命周期关联，以及ViewModelStore、ViewModelProvider在Activity销毁时的内存管理和数据保留策略。

文章目录

LiveData

ObserverWrapper 数据观察者

LifecycleEventObserver 生命周期观察者

活跃状态接受并更新数据刷新页面数据

非活跃状态暂停接收数据防止崩溃，

销毁状态的时候移除观察者防止内存泄漏

数据可以监听

数据倒灌，就是先发送数据，通过生命周期响应来触发change

数据粘性，先发送数据，后订阅的也能收到数据

为什么能感知生命周期和数据观察者因为把传入的观察者通过LifecicleBoundObserver包了一层
LifecicleBoundObserver继承了LifecicleEventObserver和ObserverWrapper,然后添加到lifecicle和livedata中



package androidx.lifecycle;

import androidx.annotation.MainThread;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.arch.core.executor.ArchTaskExecutor;
import androidx.arch.core.internal.SafeIterableMap;
import androidx.lifecycle.Lifecycle.State;
import java.util.Iterator;
import java.util.Map;

public abstract class LiveData<T> {
   
   
    final Object mDataLock = new Object();
    static final int START_VERSION = -1;
    static final Object NOT_SET = new Object();
    private SafeIterableMap<Observer<? super T>, LiveData<T>.ObserverWrapper> mObservers = new SafeIterableMap();
    int mActiveCount = 0;
    private volatile Object mData;
    volatile Object mPendingData;
    private int mVersion;
    private boolean mDispatchingValue;
    private boolean mDispatchInvalidated;
    private final Runnable mPostValueRunnable;

    public LiveData(T value) {
   
   
        this.mPendingData = NOT_SET;
        this.mPostValueRunnable = new NamelessClass_1();
        this.mData = value;
        this.mVersion = 0;
    }

    public LiveData() {
   
   
        this.mPendingData = NOT_SET;

        class NamelessClass_1 implements Runnable {
   
   
            NamelessClass_1() {
   
   
            }

            public void run() {
   
   
                Object newValue;
                synchronized(LiveData.this.mDataLock) {
   
   
                    newValue = LiveData.this.mPendingData;
                    LiveData.this.mPendingData = LiveData.NOT_SET;
                }

                LiveData.this.setValue(newValue);
            }
        }

        this.mPostValueRunnable = new NamelessClass_1();
        this.mData = NOT_SET;
        this.mVersion = -1;
    }

    private void considerNotify(LiveData<T>.ObserverWrapper observer) {
   
   
        if (observer.mActive) {
   
   
            if (!observer.shouldBeActive()) {
   
   
                observer.activeStateChanged(false);
            } else if (observer.mLastVersion < this.mVersion) {
   
   
                observer.mLastVersion = this.mVersion;
                observer.mObserver.onChanged(this.mData);
            }
        }
    }

    void dispatchingValue(@Nullable LiveData<T>.ObserverWrapper initiator) {
   
   
        if (this.mDispatchingValue) {
   
   
            this.mDispatchInvalidated = true;
        } else {
   
   
            this.mDispatchingValue = true;

            do {
   
   
                this.mDispatchInvalidated = false;
                if (initiator != null) {
   
   
                    this.considerNotify(initiator);
                    initiator = null;
                } else {
   
   
                    Iterator<Map.Entry<Observer<? super T>, LiveData<T>.ObserverWrapper>> iterator = this.mObservers.iteratorWithAdditions();

                    while(iterator.hasNext()) {
   
   
                        this.considerNotify((ObserverWrapper)((Map.Entry)iterator.next()).getValue());
                        if (this.mDispatchInvalidated) {
   
   
                            break;
                        }
                    }
                }
            } while(this.mDispatchInvalidated);

            this.mDispatchingValue = false;
        }
    }

    @MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
   
   
        assertMainThread("observe");
        if (owner.getLifecycle().getCurrentState() != State.DESTROYED) {
   
   
            LiveData<T>.LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
            LiveData<T>.ObserverWrapper existing = (ObserverWrapper)this.mObservers.putIfAbsent(observer, wrapper);
            if (existing != null && !existing.isAttachedTo(owner)) {
   
   
                throw new IllegalArgumentException("Cannot add the same observer with different lifecycles");
            } else if (existing == null) {
   
   
                owner.getLifecycle().addObserver(wrapper);
            }
        }
    }

    @MainThread