LiveData用大衆語言來來講，是一個觀察者，也是一個數據持有類或者可以稱爲一個數據的包裹類。它有別於其他的觀察者的重點是，他具有生命週期感知能力，這裏生命週期指的是activities, fragments, or services 的生命週期。

講到LiveData，就想到DataBinding，想到MVVM。LiveData的確一開始是爲這種模式而設計出來的。LiveData搞懂，可以說了解了MVVM的一半了。

說到LiveData擁有生命週期感知能力，那麼如何實現。自己手寫代碼在onCreate、onStart、onResume這些方法里加入邏輯當然是一種方法，但這不夠靈活不夠解耦。所以在Android Support Library 26.1.0 開始，引入Lifecycles。

那麼Lifecycles是什麼？

可以理解爲一個庫或一堆類，加上在Activity、Fragment裏面插入的一些邏輯代碼，最終實現的生命週期可以通知到外界的體系。

像觀察者模式一樣。可以分爲註冊、反註冊、發送事件和接受事件這4部分。

先來看發送部分。

發送部分（處於源碼裏面）

上面這個圖以 android.support.v4.app.Fragment.java 爲例，可以看到從8.1.0開始，在 performCreate、performStart、performResume、performPause、performStop 和 performDestroy 等方法都加上了發送生命週期 Event 事件。

Activity 發送生命週期 Event 會複雜一點，是在 android.support.v4.app.SupportActivity 裏通過創建一個 ReportFragment，把在各個生命週期中發事件的代碼邏輯挪進去 ReportFragment 裏實現的。

這一招數讓我想起了 Glide 對於圖片生命週期的管理。Glide.with(Activity) 也是讓 Activity 創建出一個 Fragment ，在 Fragment 的各個生命週期方法內插入回調函數後，執行代碼來實現的。

SupportActivity.java（support庫）
------------------------------
    @Override
    @SuppressWarnings("RestrictedApi")
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ReportFragment.injectIfNeededIn(this);
    }


ComponentActivity.java（androidx庫）
------------------------------
    @Override
    @SuppressWarnings("RestrictedApi")
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ReportFragment.injectIfNeededIn(this);
    }


ReportFragment.java
------------------------------
    @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) lifecycle).handleLifecycleEvent(event);
            }
        }
    }

Activity 和 Fragment 都會調用到 LifecycleRegistry.handleLifecycleEvent(event) 方法。

LifecycleRegistry 是在 ComponentActivity 和 Fragment 中聲明並且直接new出來的成員變量。

同時它們還是實現了 LifecycleOwner 接口，裏面的 getLifecycle() 就是返回這個 mLifecycleRegistry 用的。

SupportActivity.java（用於support庫）
------------------------------
public class SupportActivity extends Activity implements LifecycleOwner {

    private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);


ComponentActivity.java（用於androidx庫）
------------------------------
public class ComponentActivity extends Activity
        implements LifecycleOwner, KeyEventDispatcher.Component {

    private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);


Fragment.java
------------------------------
public class Fragment implements ComponentCallbacks, OnCreateContextMenuListener, LifecycleOwner {

    LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);





LifecycleOwner.java
------------------------------
public interface LifecycleOwner {
    @NonNull
    Lifecycle getLifecycle();
}

用了 LifecycleRegistry 來管理註冊到Activity或Fragment來的所有觀察者。包括添加、刪除觀察者，接受生命週期事件並分發到各個觀察者中。

LifecycleRegistry 會維護一個 State 變量。同時這些觀察者 ObserverWithState 也會有維護一份屬於自己的聲明週期狀態 State。

這兩份 State 的作用是，兩者比較後，可以決定觀察者列表「從前往後遍歷」還是「從後往前遍歷」。爲什麼要分「從前往後遍歷」還是「從後往前遍歷」我猜可能是一些觀察者要遵循棧的後進先出原則吧，後註冊的一些觀察者組件需要先進行反註冊操作。

下面這圖是Lifecycles體系裏面 State 和 Event 的關係。

LifecycleRegistry.handleLifecycleEvent(event) 之後接着是

LifecycleRegistry.sync() 方法，接着是

backwardPass() 或者 forwardPass()，代表從後往前遍歷還是從前往後遍歷。

在裏面會遍歷 LifecycleRegistry 的成員變量 mObserverMap，這個 Map 就是該 Activity/Fragment 生命週期的觀察者。遍歷 Map 後逐個調用 ObserverWithState.dispatchEvent()，最後執行 GenericLifecycleObserver.onStateChanged()。即逐個通知到觀察者，當前 Activity/Fragment 處於哪個生命週期裏了。

註冊、反註冊和接受通知（處於源碼外面，需要開發者寫）

說完發送生命週期通知事件後，就該講在外面我們如何使用觀察者監聽通知了，包括註冊、反註冊和接受通知。

簡單寫法一般有這麼兩種，這是第一種，註解聲明只接受 ON_RESUME 事件通知

這是第二種

註冊後可以成功收到相應事件。看logcat日誌，我把一個MainActivity打開又關閉後，輸出了這些日誌。

ps：GenericLifecycleObserver 下面報紅了，因爲這個類上面的註解說明了，這個類只應該在自己的library 裏面使用。可以忽略這個警告。看 GenericLifecycleObserver 頭像的註解，如下圖

LiveData

下面要講回LiveData了，文章一開始介紹了了LiveData是什麼。它是一個基於觀察者模式的數據的包裹類，最重要的特點是生命週期感知能力。

怎麼實現生命週期感知能力，其實就是內部幫我們封裝了 Lifecycles 的「註冊」、「反註冊」和「接受生命週期事件，並且做出相應處理」的代碼。

下圖是 LiveData 的基本使用。

LiveData 執行 observe() 方法後，傳入當前 Activity 和回調方法。

註冊（LiveData的註冊生命週期）

LiveData.java
------------------------------
    @MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        assertMainThread("observe");
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            // ignore
            return;
        }
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        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;
        }
        
        //通過activity獲取LifecycleRegistry，將回調方法封裝成一個LifecycleBoundObserver傳進去
        owner.getLifecycle().addObserver(wrapper);
    }

可以看到，LiveData 裏面的註冊 Lifecycles 流程在這個 observe 方法裏。

owner.getLifecycle() 就是在 Activity/Fragment 中獲取到 LifecycleRegistry。將回調方法封裝成一個 LifecycleBoundObserver 實體後註冊到 Activity/Fragment 的功能。

反註冊（LiveData的反註冊生命週期）

LifecycleBoundObserver 中提供了一個 detachObserver() 方法，只有這個方法裏面，會進行生命週期的反註冊功能。

    @MainThread
    public void removeObserver(@NonNull final Observer<? super T> observer) {
        //判斷如果不是主線程則拋異常
        assertMainThread("removeObserver");

        //mObservers 是屬於這個 LiveData 的觀察者集合，需要從集合裏刪除這個觀察者
        ObserverWrapper removed = mObservers.remove(observer);
        if (removed == null) {
            return;
        }

        //這個 removed 變量的聲明是 ObserverWrapper 類型。這是個抽象類，無法實例化。
        //實際只能是 AlwaysActiveObserver 或者 LifecycleBoundObserver 兩種類型。
        //1.如果是 AlwaysActiveObserver 類型，沒有重寫 detachObserver() 方法。
        //因爲這是屬於 observeForever 的邏輯，永久觀察當然不用處於聲明週期方面的功能。
        //2.如果是 LifecycleBoundObserver 類型，則重寫了 detachObserver() 方法。
        //用於讓 owner 移除這個觀察者。
        removed.detachObserver();
        
        //因爲移除了一個觀察者，可能使得 LiveData 的活躍觀察者從1變0，所以需要通知一下。
        removed.activeStateChanged(false);
    }

    @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)) {
                removeObserver(entry.getKey());
            }
        }
    }


    class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver {
        @NonNull
        final LifecycleOwner mOwner;

        @Override
        void detachObserver() {
            mOwner.getLifecycle().removeObserver(this);
        }
    }

這裏的 detachObserver() 方法在 LiveData.removeObservers(Observer<T>) 和 LiveData.removeObservers(LifecycleOwner) 中調用的。

LiveData.removeObservers(LifecycleOwner) 內部也是調用的 LiveData.removeObservers(Observer<T>)。讓我們先捋清楚 removeObserver(Observer<? super T>) 幹了些什麼事情。

幹得四件事如代碼註釋所寫。

那麼 LiveData.removeObservers(Observer<T>) 在什麼時候調用呢？

LiveData.removeObservers(Observer<T>) 其實是在接受生命週期回調的 onStateChanged(LifecycleOwner, Lifecycle.Event) 方法中，會判斷如果是如果當前 owner 處於 DESTROYED 狀態就執行。LiveData 是用的此種方法讓它具有了自動反註冊功能。下面請看 LiveData 如何接受生命週期事件。

接受生命週期事件並且做出相應處理

LifecycleBoundObserver.java
------------------------------
class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver {

    @Override
    public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
        if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
            removeObserver(mObserver);
            return;
        }
        activeStateChanged(shouldBeActive());
    }

    @Override
    boolean shouldBeActive() {
        return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
    }


ObserverWrapper.java
------------------------------
private abstract class ObserverWrapper {

    void activeStateChanged(boolean newActive) {
        if (newActive == mActive) {
            return;
        }
        // immediately set active state, so we'd never dispatch anything to inactive
        // owner
        mActive = newActive;
        boolean wasInactive = LiveData.this.mActiveCount == 0;
        LiveData.this.mActiveCount += mActive ? 1 : -1;
        if (wasInactive && mActive) {
            onActive();
        }
        if (LiveData.this.mActiveCount == 0 && !mActive) {
            onInactive();
        }
        if (mActive) {
            dispatchingValue(this);
        }
    }

我們知道 LifecycleOwner 發送的生命週期事件會經過層層調用，最後到 GenericLifecycleObserver.onStateChanged(LifecycleOwner, Lifecycle.Event)。

在這裏體現在子類 LifecycleBoundObserver.onStateChanged(LifecycleOwner, Lifecycle.Event)。

方法裏第一步會判斷是 DESTROYED 事件則進行 LiveData 反註冊方面的操作。

第二步是調用了 ObserverWrapper.activeStateChanged(boolean) 方法。

方法裏傳了一個布爾值，表示當前 owner 的是否處於 Active 活躍狀態。在這裏意思是 State 爲 STARTED 或 RESUMED 纔算活躍。

方法裏判斷，如果當前狀態和新傳進來的狀態一樣，直接 return 了。只有不一樣纔會往下執行。

第一步會修改 mActiveCount 變量，表示當前 LiveData 所關聯的 owner 有多少個是活躍的。

第二步是根據之前的 Active 狀態，和新傳進來的 Active 狀態，判斷是否需要執行

LiveData.onActive() 活躍觀察者數量從0變成1

LiveData.onInactive() 活躍觀察者數量從1變成0

以及最重要的第三步！如果是狀態是從不活躍到活躍，則立即派發一輪事件到各個觀察者中。達到的就是粘性廣播或粘性EventBus 那樣的效果。

關於派發事件 dispatchingValue 方法留到下面講。

以上就是 LiveData 封裝好的 Lifecycles 的「註冊」、「反註冊」和「接受生命週期事件，並且做出相應處理」的代碼。

下面講下 LiveData 關於數據方面的操作，包括修改數據和數據修改後的回調操作（比如 DataBinding 的更新UI操作）。

開發者如何使用 LiveData

LiveData.java
------------------------------
    @MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        assertMainThread("observe");
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            // ignore
            return;
        }
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        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.getLifecycle().addObserver(wrapper);
    }

    @MainThread
    protected void setValue(T value) {
        assertMainThread("setValue");
        mVersion++;
        mData = value;
        dispatchingValue(null);
    }

    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);
        }
    };

    @Nullable
    public T getValue() {
        Object data = mData;
        if (data != NOT_SET) {
            //noinspection unchecked
            return (T) data;
        }
        return null;
    }

observe(LifecycleOwner, Observer<? super T>) 是在 LiveData 裏註冊一個觀察者，如果數據發生變化會通知這些觀察者。

setValue(T) 用於在主線程裏面修改數據

postValue(T) 用於在子線程裏面修改數據，當然最終還是會調到到 setValue(T)

getValue(T) 就是get方法很好理解吧，在簡單流程裏使用是不需要用到的，像在Android DataBinding架構裏纔會用到。

setValue(T) 最終調用到 dispatchingValue()

    private SafeIterableMap<Observer<? super T>, ObserverWrapper> mObservers =
            new SafeIterableMap<>();

    void dispatchingValue(@Nullable ObserverWrapper initiator) {
        if (mDispatchingValue) {
            mDispatchInvalidated = true;
            return;
        }
        mDispatchingValue = true;
        do {
            mDispatchInvalidated = false;
            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());
                    if (mDispatchInvalidated) {
                        break;
                    }
                }
            }
        } while (mDispatchInvalidated);
        mDispatchingValue = false;
    }

    private void considerNotify(ObserverWrapper observer) {
        if (!observer.mActive) {
            return;
        }
        // Check latest state b4 dispatch. Maybe it changed state but we didn't get the event yet.
        //
        // we still first check observer.active to keep it as the entrance for events. So even if
        // the observer moved to an active state, if we've not received that event, we better not
        // notify for a more predictable notification order.
        if (!observer.shouldBeActive()) {
            observer.activeStateChanged(false);
            return;
        }
        if (observer.mLastVersion >= mVersion) {
            return;
        }
        observer.mLastVersion = mVersion;
        //noinspection unchecked
        observer.mObserver.onChanged((T) mData);
    }

dispatchingValue() 裏對觀察者集合 mObservers 進行遍歷，執行 considerNotify 方法。consider 這單詞用得好啊，考慮要不要通知。

considerNotify 方法裏，會修改 LifecycleBoundObserver 的活躍狀態，判斷當前 LifecycleBoundObserver 的版本號。

最終調用到 Observer.onChanged(T) 方法。也就是我們使用 LiveData 一開始傳進來的回調函數。

這就是 LiveData 實現數據更新就回調，並且關聯生命週期的基本流程。

除此之外，還有不關聯生命週期的 observeForever 方法。

LiveData.java
------------------------------
    @MainThread
    public void observeForever(@NonNull Observer<? super T> observer) {
        assertMainThread("observeForever");
        AlwaysActiveObserver wrapper = new AlwaysActiveObserver(observer);
        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
        if (existing != null && existing instanceof LiveData.LifecycleBoundObserver) {
            throw new IllegalArgumentException("Cannot add the same observer"
                    + " with different lifecycles");
        }
        if (existing != null) {
            return;
        }
        wrapper.activeStateChanged(true);
    }

    private class AlwaysActiveObserver extends ObserverWrapper {

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

        @Override
        boolean shouldBeActive() {
            return true;
        }
    }

MutableLiveData 繼承自 LiveData，把setValue(T) 和 getValue(T) 方法public公開了。

最終使用 LiveData 修改數據，就像這樣使用 setValue 就可以。

LiveData 推出來是爲了實現谷歌的 DataBinding，實現 MVVM 架構。

然而後面一些第三方庫也開始使用這個強大的 LiveData 工具了。

比如說 LiveEventBus 。

https://github.com/JeremyLiao/LiveEventBus

LiveEventBus

先簡單看看 LiveEventBus 是怎麼使用 LiveData 的。

public final class LiveEventBus {

    public synchronized <T> Observable<T> with(String key, Class<T> type) {
        if (!bus.containsKey(key)) {
            bus.put(key, new LiveEvent<>(key));
        }
        return (Observable<T>) bus.get(key);
    }

    private class LiveEvent<T> implements Observable<T> {

        private final LifecycleLiveData<T> liveData;

        LiveEvent(@NonNull String key) {
            this.key = key;
            this.liveData = new LifecycleLiveData<>();
        }

        @Override
        public void observe(@NonNull final LifecycleOwner owner, @NonNull final Observer<T> observer) {
            if (ThreadUtils.isMainThread()) {
                observeInternal(owner, observer);
            } else {
                mainHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        observeInternal(owner, observer);
                    }
                });
            }
        }

        @MainThread
        private void observeInternal(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {
            ObserverWrapper<T> observerWrapper = new ObserverWrapper<>(observer);
            observerWrapper.preventNextEvent = liveData.getVersion() > ExternalLiveData.START_VERSION;
            liveData.observe(owner, observerWrapper);
        }

        @Override
        public void post(T value) {
            if (ThreadUtils.isMainThread()) {
                postInternal(value);
            } else {
                mainHandler.post(new PostValueTask(value));
            }
        }

        @MainThread
        private void postInternal(T value) {
            liveData.setValue(value);
        }

可以看到 LiveEventBus 那一行代碼調用的 observe 方法，最終會使用到 LiveEvent 裏面的 liveData 屬性，讓 liveData 屬性調用 observe(LifecycleOwner, Observer<? super T>) 方法。

而 LiveEventBus 的發送事件，也是調用了 LiveData.setValue(T)。

LiveEventBus 它聲稱具有「生命週期感知，消息隨時訂閱，自動取消訂閱」能力，那麼怎麼實現的呢？

我們前面講到，如果生命週期發生變化，LifecycleOwner 會發出事件通知，在 GenericLifecycleObserver.onStateChanged(LifecycleOwner, Lifecycle.Event) 中能接受到回調。

LiveData.java
------------------------------
public abstract class LiveData<T> {

    class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver {
        @NonNull
        final LifecycleOwner mOwner;

        @Override
        public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
            if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
                removeObserver(mObserver);
                return;
            }
            activeStateChanged(shouldBeActive());
        }
    }


    @MainThread
    public void removeObserver(@NonNull final Observer<? super T> observer) {
        assertMainThread("removeObserver");
        ObserverWrapper removed = mObservers.remove(observer);
        if (removed == null) {
            return;
        }
        removed.detachObserver();
        removed.activeStateChanged(false);
    }



LiveEventBus.java
------------------------------
public final class LiveEventBus {

    private class LiveEvent<T> implements Observable<T> {

        private class LifecycleLiveData<T> extends ExternalLiveData<T> {
            @Override
            protected Lifecycle.State observerActiveLevel() {
                return lifecycleObserverAlwaysActive ? Lifecycle.State.CREATED : Lifecycle.State.STARTED;
            }

            @Override
            public void removeObserver(@NonNull Observer<? super T> observer) {
                super.removeObserver(observer);
                if (autoClear && !liveData.hasObservers()) {
                    LiveEventBus.get().bus.remove(key);
                }
            }
        }

前面講過在 LiveData 的內部類 LifecycleBoundObserver.onStateChanged 方法中會判斷如果當前 state 是 DESTROYED，就刪除觀察者操作。這個要刪除的觀察者 Observer 是 LiveData 的所包裹的數據的觀察者。

具體在 LiveData 代碼的邏輯是，把這個observer 從 mObservers集合(LiveData 所緩存的一份觀察者列表) 中移除。

對應到我們 LiveEventBus ，就是我們使用 LiveEventBus 傳進去的 Observer 回調函數給移除了。

這樣就實現了「自動取消訂閱」的效果。

還有LiveEventBus聲稱具有「整個生命週期（從onCreate到onDestroy）都可以實時收到消息」能力，那麼怎麼實現的呢？

ps：這算值得寫出來的能力嗎？這不是一個正常的事件總線應有的能力嗎？

ExternalLiveData.java
------------------------------
public class ExternalLiveData<T> extends MutableLiveData<T> {

    protected Lifecycle.State observerActiveLevel() {
        return CREATED;
    }

    class ExternalLifecycleBoundObserver extends LifecycleBoundObserver {

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

        @Override
        boolean shouldBeActive() {
            return mOwner.getLifecycle().getCurrentState().isAtLeast(observerActiveLevel());
        }
    }



LiveEventBus.java
------------------------------
public final class LiveEventBus {

    private boolean lifecycleObserverAlwaysActive = true;

    private class LifecycleLiveData<T> extends ExternalLiveData<T> {
        @Override
        protected Lifecycle.State observerActiveLevel() {
            return lifecycleObserverAlwaysActive ? Lifecycle.State.CREATED : Lifecycle.State.STARTED;
        }



LiveData.java
------------------------------
public abstract class LiveData<T> {


    class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver {

        @Override
        boolean shouldBeActive() {
            return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
        }

原生 LiveData.java 使用了 LifecycleBoundObserver，所以在判定是否活躍的這個 shouldBeActive() 方法中，owner 的生命週期 state ≥ STARTED 纔會認爲是活躍。即 STARTED 和 RESUMED。符合 MVVM 的特性，可見的界面纔有必要更新UI。

LiveEventBus 如果使用這個策略是不太合理的，所以重寫了 shouldBeActive() 方法，讓它判斷邏輯是≥CREATED（LiveEventBus的默認情況）即認爲是活躍。達到了官網宣稱的「整個生命週期（從onCreate到onDestroy）都可以實時收到消息」效果。

參考來源：

https://developer.android.com/topic/libraries/architecture/lifecycle

https://developer.android.com/topic/libraries/architecture/livedata

Android LiveData我的理解

發送部分（處於源碼裏面）

註冊、反註冊和接受通知（處於源碼外面，需要開發者寫）

LiveData

註冊（LiveData的註冊生命週期）

反註冊（LiveData的反註冊生命週期）

接受生命週期事件並且做出相應處理

開發者如何使用 LiveData

LiveEventBus

HTML頁面關於高分屏的設置

北歐瑞典挪威芬蘭瑞士TikTok海外網紅與YouTube博主的合作模式

歐洲英國德國法國TikTok與YouTube海外網紅達人的完美合作策略

druid數據源 xml配置

併發任務執行的幾種方法 (同時上傳多張圖片請求）

關於Android 抓包與反抓包

(2019年10月更新) Android 最全的底部導航欄實現方法

Android 關於過度繪製的那些事兒 UI流暢度優化

Charles 的調試 & Mock 數據技巧

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結