LiveData源码分析

前言

公司的项目使用的是MVVM设计模式，自然离不开LiveData，今天就来学习一波LiveData相关的源码。

如何感知生命周期

LiveData是在LifeCycle包下的，使用LiveData首先来了解一下LifeCycle是如何感知生命周期的。

下图Activity的继承体系：

其中有一个SupportActivity：

public class SupportActivity extends Activity implements LifecycleOwner {
    ……
    private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
    ……
    @Override
    @SuppressWarnings("RestrictedApi")
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ReportFragment.injectIfNeededIn(this);
    }

    @CallSuper
    @Override
    protected void onSaveInstanceState(Bundle outState) {
        mLifecycleRegistry.markState(Lifecycle.State.CREATED);
        super.onSaveInstanceState(outState);
    }
    ……

其中ReportFragment.injectIfNeededIn(this);一句很关键，这里注入了一个ReportFragment到当前Activity中：

    public static void injectIfNeededIn(Activity activity) {
        // ProcessLifecycleOwner should always correctly work and some activities may not extend
        // FragmentActivity from support lib, so we use framework fragments for activities
        android.app.FragmentManager manager = activity.getFragmentManager();
        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
            // 如果没有注入过，注入
            manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
            // Hopefully, we are the first to make a transaction.
            manager.executePendingTransactions();
        }
    }

那ReportFragment是干嘛的呢？来看一下它的主要方法：

    @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) {
            // 如果继承自SupportActivity，getLifecycle()得到的就是SupportActivity的成员变量一个LifecycleRegistry
            Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
            if (lifecycle instanceof LifecycleRegistry) {
                // 让LifecycleRegistry去处理生命周期事件
                ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
            }
        }
    }

我们看到在ReportFragment的生命周期里去分发了对应生命周期的事件，而ReportFragment又是和Activity绑定的，那么分发的其实就是Activity对应的生命周期事件。

以上代码涉及到了LifecycleRegistry，回到SupportActivity，我们可以看到private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);：

    public LifecycleRegistry(@NonNull LifecycleOwner provider) {
        mLifecycleOwner = new WeakReference<>(provider);
        mState = INITIALIZED;
    }

顾名思义就是LifeCycle的登记处，它以弱引用的方式持有了当前的Activity。当Activity生命周期改变的时候，它会去处理对应的生命周期事件。

那如果是在Fragment中注册观察者呢？来看下v4包下的Fragment：

    LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
    ……

    void performCreate(Bundle savedInstanceState) {
        if (mChildFragmentManager != null) {
            mChildFragmentManager.noteStateNotSaved();
        }
        mState = CREATED;
        mCalled = false;
        onCreate(savedInstanceState);
        mIsCreated = true;
        if (!mCalled) {
            throw new SuperNotCalledException("Fragment " + this
                    + " did not call through to super.onCreate()");
        }
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
    }
    ……

    void performStart() {
        if (mChildFragmentManager != null) {
            mChildFragmentManager.noteStateNotSaved();
            mChildFragmentManager.execPendingActions();
        }
        mState = STARTED;
        mCalled = false;
        onStart();
        if (!mCalled) {
            throw new SuperNotCalledException("Fragment " + this
                    + " did not call through to super.onStart()");
        }
        if (mChildFragmentManager != null) {
            mChildFragmentManager.dispatchStart();
        }
        if (mLoaderManager != null) {
            mLoaderManager.doReportStart();
        }
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
    }

查看源码，会发现和Activity类似，也有一个成员变量LifecycleRegistry来持有Fragment。并且在Fragment生命周期变化之后，会将生命周期事件分发出去。

接着进入LifecycleRegistry的handleLifecycleEvent()：

    public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        // 根据生命周期事件得到对应的状态
        State next = getStateAfter(event);
        // 调整到对应的状态
        moveToState(next);
    }

    private void moveToState(State next) {
        if (mState == next) {
            return;
        }
        mState = next;
        if (mHandlingEvent || mAddingObserverCounter != 0) {
            mNewEventOccurred = true;
            // we will figure out what to do on upper level.
            return;
        }
        mHandlingEvent = true;
        // 同步状态给各个观察者
        sync();
        mHandlingEvent = false;
    }

继续进入sync()：

    private void sync() {
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        if (lifecycleOwner == null) {
            Log.w(LOG_TAG, "LifecycleOwner is garbage collected, you shouldn't try dispatch "
                    + "new events from it.");
            return;
        }
        while (!isSynced()) {
            mNewEventOccurred = false;
            // no need to check eldest for nullability, because isSynced does it for us.
            if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
                // 倒序遍历，通知观察者，去修改状态
                backwardPass(lifecycleOwner);
            }
            Entry newest = mObserverMap.newest();
            if (!mNewEventOccurred && newest != null
                    && mState.compareTo(newest.getValue().mState) > 0) {
                // 正序遍历，通知观察者，去修改状态 
                forwardPass(lifecycleOwner);
            }
        }
        mNewEventOccurred = false;
    }

LiveData注册观察者

一般我们这样使用：

        liveData.observe(this, new Observer