Databinding与LiveData的合做

时间  2019-12-10
标签 databinding livedata 繁體版
原文   原文链接

背景

在谷歌官方的最新框架中咱们能够学到的一个新组件就是LiveData，可以监听生命周期的变化而且在适当的生命周期中回调方法，有效的解决了以前须要处理回调中View消失的问题。在使用层面上利用LiveData可以消除掉以前MVP中关于View的生命周期控制等相似的问题。html

可是在使用的过程当中，会发现一个弊端就是当你使用LiveData控制的数据，须要展现到界面上时，你须要将一个LiveData数据变成Observable类型的数据，而后经过Databinding进行绑定。虽然他们是内容是相同的，可是仍须要作一层转化。java

这里说一下各自的优势，简单的归纳一下：android

  • LiveData：与生命周期关联，可以实如今特定的生命周期中进行回调。
  • Observable：可以与UI进行双向绑定。

从最开始使用LiveData时，就在思考一个问题，有没有方法可以消除掉这一层的转化，或者说有没有一种新的数据类型，既能与生命周期关联，又能与UI进行双向绑定。惭愧的说尝试一番，无果。在学习LiveData的过程当中，在官方的issue中看到做者正在着手解决这个痛点，不过一直都没有最新的消息。直到这个新年的第一个工做日。git

最新进展

新年第一天上班，打开电脑，习惯性的把平常的Android站点都逛一遍，就发现了一篇新的文章介绍说官方已经在最新的Androdi Studio 3.1 canary6预览版中加入了LiveData和Databinding的处理，不用再进行转换才能响应到UI上了，文章还给了一个小的例子。那个文章的地址会放在为文末，还有对应的github地址。看到这个，我立刻就尝试了一下，下面就都是流水帐了。github

下载最新预览版Studio

预览版地址
安装和建立一个普通的项目这里都不说了。而后就是添加依赖：api

dependencies {
 	...
    implementation 'android.arch.lifecycle:extensions:1.0.0'
    annotationProcessor 'android.arch.lifecycle:compiler:1.0.0'
    ...
}
复制代码

这里就引用最基本的一个extension就能够了。在添加这两个依赖的时候操做起来特别的卡，不知道是我电脑的问题仍是最新的这个Studio的问题。数组

写个小例子

这里我建立了一个MainViewModel,用于测试，直接上代码，基本都没有难度：bash

public class MainViewModel extends ViewModel {

    public final MutableLiveData<String> input = new MutableLiveData<>();
    public final MutableLiveData<String> include_string = new MutableLiveData<>();
    Handler handler;

    public MainViewModel() {
        input.setValue("test");
        include_string.setValue("include_string");
        handler = new Handler();
    }

    public void onClick() {
        Random random = new Random();
        input.setValue(random.nextInt(100) + "");
        include_string.setValue(random.nextInt(100) + "");
    }

    public void onAsyncClick() {
        final Random random = new Random();

        handler.postDelayed(new Runnable() {
            @Override
            public void run() {
                input.setValue(random.nextInt(100) + "async");
                include_string.setValue(random.nextInt(100) + "async");
            }
        }, 5000);
    }
    
}
复制代码

这里有两个string,分别对应两个EditText,一个是正常界面里的，一个是include进来的。两个点击事件，一个是正常的，一个是异步的。框架

看一下MainActivity:dom

public class MainActivity extends AppCompatActivity {
    ActivityMainBinding mBinding;
    MainViewModel mainViewModel;
    String TAG = "TAG";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mBinding = DataBindingUtil.setContentView(this, R.layout.activity_main);
        mainViewModel = ViewModelProviders.of(this, new ViewModelProvider.NewInstanceFactory()).get(MainViewModel.class);
        mBinding.setViewModel(mainViewModel);
        mBinding.setLifecycleOwner(this);
        mBinding.input.addTextChangedListener(new TextWatcher() {
            @Override
            public void beforeTextChanged(CharSequence s, int start, int count, int after) {
                Log.d(TAG, "beforeTextChanged: ");
            }

            @Override
            public void onTextChanged(CharSequence s, int start, int before, int count) {
                Log.d(TAG, "onTextChanged: ");
            }

            @Override
            public void afterTextChanged(Editable s) {
                if (s != null) {
                    Log.d("TAG", "afterTextChanged: " + s.toString());
                } else {
                    Log.d("TAG", "afterTextChanged: " + "null");
                }
                Log.d(TAG, "afterTextChanged: " + mainViewModel.input.getValue());
            }
        });
        mBinding.includeView.setLifecycleOwner(this);
        mBinding.includeView.setViewModel(mainViewModel);
    }
}

复制代码

先是绑定下布局，而后建立个MainViewModel,以后就是将ViewModel绑定到View上，而后就是新的API了， 也是最为重要的方法，给当前的Databinding添加生命周期的拥有者，而后我给当前界面的EditText添加了一个监听。关于include的一会再聊，跑一下以后，你就会发现项目正常运行，而且当MainViewModel中数据改变，UI也会跟着改变。

这里须要给以前不是特别熟悉LiveData和Databinding的小伙伴们说一下，一般状况下，Databinding可以通知到Ui的数据，必须得是继承自BaseObsevable的。可是上面的例子中并无，那么是若是进行通知的那？

原始后代码解读

先从setLifecycleOwner()开始：

@MainThread
    public void setLifecycleOwner(@Nullable LifecycleOwner lifecycleOwner) {
    	 //先判断当前mLifecycleOwner相同，相同返回
        if (mLifecycleOwner == lifecycleOwner) {
            return;
        }
        //当前有，可是不一致的话先将先前的LifecycleObserver移除
        if (mLifecycleOwner != null) {
            mLifecycleOwner.getLifecycle().removeObserver(mOnStartListener);
        }
        //赋新值
        mLifecycleOwner = lifecycleOwner;
        if (lifecycleOwner != null) {
        	//从新添加LifecycleObserver，若是以前有就添加以前的，没有就新建立一个。
            if (mOnStartListener == null) {
                mOnStartListener = new OnStartListener();
            }
            lifecycleOwner.getLifecycle().addObserver(mOnStartListener);
        }
        //将全部的注册的UI变化须要响应监听对象都设置当前的lifecycleOwner。
        for (WeakListener<?> weakListener : mLocalFieldObservers) {
            if (weakListener != null) {
                weakListener.setLifecycleOwner(lifecycleOwner);
            }
        }
    }
复制代码

我的对Databinding不是特别熟悉，不过这个方法的主要目的仍是给当前的lifecycleOwner，添加一个生命周期的观察者，而后将全部的须要进行响应的都注册到这个lifecycleOwner上。看一下OnStartListener 这个监听。

public class OnStartListener implements LifecycleObserver {
        private OnStartListener() {
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_START)
        public void onStart() {
            executePendingBindings();
        }
    }
复制代码

能够看到只有一个ON_START的生命周期事件，当上面的lifecycleOwner是ON_START的时候会调用到executePendingBindings()方法;

这里原始代码层面的就没有了，新添加了一个方法，用于设置当前的生命周期持有者，而后给这个持有者添加一个只接收ON_START事件的生命周期观察者，当生命周期可用的时候刷新当前页面的数据。

编译后代码解读

在上面的例子中使用LiveData通知到View上有两种状况：

  1. 在当前的View是可用的状况下，更新数据，直接修改UI。
  2. 在当前的View是不可用的状况下，更新数据，等待View是可用的，而后修改UI。

第二种状况中判断Ui是不是可用的，而后调用刷新数据的就是上文的OnStartListener。

针对第一种状况，思考一下，是如何作到的当LiveData数据修改的时候，可以通知DataBinding 刷新对应的UI的呢？

这里先看一个DataBinding的核心函数：

@Override
    protected void executeBindings() {
        long dirtyFlags = 0;
        synchronized(this) {
            dirtyFlags = mDirtyFlags;
            mDirtyFlags = 0;
        }
        java.lang.String viewModelInputGetValue = null;
        android.arch.lifecycle.MutableLiveData<java.lang.String> viewModelInput = null;
        com.example.huangbaole.databindinglivedata.MainViewModel viewModel = mViewModel;

        if ((dirtyFlags & 0xdL) != 0) {



                if (viewModel != null) {
                    // read viewModel.input
                    viewModelInput = viewModel.input;
                }
                //*******
                updateLiveDataRegistration(0, viewModelInput);


                if (viewModelInput != null) {
                    // read viewModel.input.getValue()
                    viewModelInputGetValue = viewModelInput.getValue();
                }
        }
        // batch finished
        if ((dirtyFlags & 0xcL) != 0) {
            // api target 1

            this.includeView.setViewModel(viewModel);
        }
        if ((dirtyFlags & 0xdL) != 0) {
            // api target 1

            android.databinding.adapters.TextViewBindingAdapter.setText(this.input, viewModelInputGetValue);
        }
        if ((dirtyFlags & 0x8L) != 0) {
            // api target 1

            android.databinding.adapters.TextViewBindingAdapter.setTextWatcher(this.input, (android.databinding.adapters.TextViewBindingAdapter.BeforeTextChanged)null, (android.databinding.adapters.TextViewBindingAdapter.OnTextChanged)null, (android.databinding.adapters.TextViewBindingAdapter.AfterTextChanged)null, inputandroidTextAttrChanged);
            this.mboundView2.setOnClickListener(mCallback1);
            this.mboundView3.setOnClickListener(mCallback2);
        }
        executeBindingsOn(includeView);
    }
复制代码

有了解过DataBinding编译后代码的小伙伴们都应该熟悉这个函数，与以前有些不一样的是，当你在XML中绑定的数据是LiveData类型的时候，它对应的UpDate方法是updateLiveDataRegistration()，看一下这个方法都作了什么？

protected boolean updateLiveDataRegistration(int localFieldId, LiveData<?> observable) {
        return updateRegistration(localFieldId, observable, CREATE_LIVE_DATA_LISTENER);
    }
复制代码

内部调用了updateRegistration()方法，这个方式是全部的可以通知到UI的数据类型都会调用的（目前有Observable,ObservableList,ObservableMap,LiveData）,这里的主要区别是CreateWeakListener，不一样的类型对应的生成弱引用监听者的类型不一致。这里使用的是CREATE_LIVE_DATA_LISTENER会建立一个LiveDataListener而后获取持有的弱引用返回。

private boolean updateRegistration(int localFieldId, Object observable,
            CreateWeakListener listenerCreator) {
        if (observable == null) {
            return unregisterFrom(localFieldId);
        }
        WeakListener listener = mLocalFieldObservers[localFieldId];
        if (listener == null) {
        	//若是当前的fieldID没有对应的监听的话，那么会调用注册的方法
            registerTo(localFieldId, observable, listenerCreator);
            return true;
        }
        if (listener.getTarget() == observable) {
            return false;//nothing to do, same object
        }
        unregisterFrom(localFieldId);
        registerTo(localFieldId, observable, listenerCreator);
        return true;
    }
    
      protected void registerTo(int localFieldId, Object observable,
            CreateWeakListener listenerCreator) {
        if (observable == null) {
            return;
        }
        WeakListener listener = mLocalFieldObservers[localFieldId];
        if (listener == null) {
        	//使用listenerCreator建立一个当前与fieldId对应的Listener
            listener = listenerCreator.create(this, localFieldId);
            mLocalFieldObservers[localFieldId] = listener;
            if (mLifecycleOwner != null) {
            		//调用这个Listener的setLifecycleOwner方法。
                listener.setLifecycleOwner(mLifecycleOwner);
            }
        }
        listener.setTarget(observable);
    }
复制代码

这里跟以前的旧版本基本是一直的，只是多了一个listener.setLifecycleOwner(mLifecycleOwner);方法，在以前的listener中是没有setLifecycleOwner这个方法的。而且也只有LiveDataListener须要这个方法，其余的都是空实现。这里估计后面会从新优化一下吧。

接下来就是重点了，也是LiveData可以通知UI更新的关键，LiveDataListener:

private static class LiveDataListener implements Observer,
            ObservableReference<LiveData<?>> {
        final WeakListener<LiveData<?>> mListener;
        LifecycleOwner mLifecycleOwner;

        public LiveDataListener(ViewDataBinding binder, int localFieldId) {
            mListener = new WeakListener(binder, localFieldId, this);
        }

        @Override
        public void setLifecycleOwner(LifecycleOwner lifecycleOwner) {
            LifecycleOwner owner = (LifecycleOwner) lifecycleOwner;
            LiveData<?> liveData = mListener.getTarget();
            if (liveData != null) {
                if (mLifecycleOwner != null) {
                    liveData.removeObserver(this);
                }
                if (lifecycleOwner != null) {
                		//这里就是LiveDatag观察生命周期的地方。owner是以前的mLifecycleOwner,this则是对应的响应，这是是当前类自己，回调是onChanged()
                    liveData.observe(owner, this);
                }
            }
            mLifecycleOwner = owner;
        }

        @Override
        public WeakListener<LiveData<?>> getListener() {
            return mListener;
        }

        @Override
        public void addListener(LiveData<?> target) {
            if (mLifecycleOwner != null) {
                target.observe(mLifecycleOwner, this);
            }
        }

        @Override
        public void removeListener(LiveData<?> target) {
            target.removeObserver(this);
        }

        @Override
        public void onChanged(@Nullable Object o) {
        		//这里是LiveData观察LifecycleOwner对应的响应，调用当前的fieldId刷新。
            ViewDataBinding binder = mListener.getBinder();
            binder.handleFieldChange(mListener.mLocalFieldId, mListener.getTarget(), 0);
        }
    }
复制代码

目前就这么多吧，有一个总体的轮廓。简单总结一下

总结

当使用LiveData进行更新数据的时候，会建立一个LiveDataListener添加的当前binding的数组中 针对上文的两种更新数据的状况：

第一种：当LiveData更新的时候，会调用LiveDataListener中的onChange方法，而后binding会刷新对应FieldID的UI。

第二种：View从不可用到可用，调用onStart生命周期函数的时候，会调用onStartListener的onStart方法，会刷新全部的bind数据。同时因为当前的LiveDataListener中也将LifecycleOwner订阅到LiveData上了，因此，第一种方案应该也是会执行的，也就是说会出现重复赋值的状况（这里是猜想，目前没有进行验证）。

关于include的使用

这里说一下include中使用LiveData的影响，默认的状况下，我觉得只须要绑定下ViewModel就能够，其实不是，这里须要给include的binding 也要设置LifecycleOwner。就如我上面例子写的那样，估计这里之后也可能会优化，毕竟include的View 应该会和当前的View拥有相同的LifecycleOwner吧。

收获

对DataBinding的原理应该是更熟悉了一些吧，而后LiveData的使用应该更加的灵活，而不只仅的就是一个有用生命周期的数据，经过Lifecycle，咱们可以实现任何和生命周期相关的东西，而不只仅就是数据。做为新年你的第一篇文章，有点水，也有些仓促，有好几个关键的点，没有进行验证和测试，不过目前的版本不会是最终的版本，等有正式版的时候会从新写一篇正式一点的。

相关地址

国外文章

国外文章项目地址

本文的项目地址

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程