Android Jetpack -- ViewModel & LiveData

看到这些博客的时候，相信小伙伴们已经看了不少的有关于Android Jetpack的知识了，关于Jetpack的原理，有些文章讲的很好，这里就不重复了，此系列的博客，旨在通过一些很简单的小demo，和大家一起熟悉最基本的用法~

Android Jetpack -- Lifecycle

Android Jetpack -- ViewModel & LiveData

Android Jetpack -- paging & room

Android Jetpack -- navigation

项目git地址：https://github.com/zhangtiansimple/jetpack_demo

------------------------------------------------------------------------------------------------------------------------

因为LiveData和ViewModel的关系非常紧密，LIveData通常也声明在ViewModel里，所以将这两个组件放在一篇博客里来分享。

还是先来看一个小栗子

class MyViewModel() : ViewModel() {

    private var title: MutableLiveData<String>? = null

    public fun getTitle(): MutableLiveData<String> {
        if (title == null) {
            title = MediatorLiveData<String>()
            loadTitle()
        }
        return title as MutableLiveData<String>
    }

    private fun loadTitle() {
        title!!.setValue("load title success")
    }
}

MutableLiveData继承自LiveData

public class MutableLiveData<T> extends LiveData<T> {
    @Override
    public void postValue(T value) {
        super.postValue(value);
    }

    @Override
    public void setValue(T value) {
        super.setValue(value);
    }
}

在ViewModel里将LiveData的实例接口暴露出去，在需要的视图里进行调用

class ViewModelActivity : AppCompatActivity() {

    private lateinit var viewModel: MyViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_viewmodel)

        viewModel = ViewModelProviders.of(this).get(MyViewModel::class.java)
        viewModel.getTitle().observe(this, Observer {
            tv_viewmodel.setText(it)
        })
    }
}

在Activity里获取viewModel的实例后，直接使用LiveData里的观察方法，当数据有变化的时候，直接进行UI的更新，使用起来是不是非常方便。

接下来看看LiveData的observer（）方法

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

在这个方法中主要做了三件事

1.如果LifeCycle的状态是DESTROYED时，直接返回，不用接收新的数据。

2.声明一个LifeCycleBoundObserver对象建立了LifeCycleOwner和Observer的联系。

3.观察LifeCycleBoundObserver的实例

那么LifeCycleBoundObserver是用来做什么的呢

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

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

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

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

        @Override
        boolean isAttachedTo(LifecycleOwner owner) {
            return mOwner == owner;
        }

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

该方法主要作用是添加移除观察者，并且在生命周期发生变化时回调onStateChanged。

LiveData和ViewModel的简单使用就介绍到这里，系列文章都是科普性的，深入实践就需要小伙伴们在实践中不断的总结学习了。