Databinding與LiveData的合作

one_cup發表於2018-01-03
LiveData

背景

在谷歌官方的最新框架中我們可以學到的一個新元件就是LiveData，能夠監聽生命週期的變化並且在適當的生命週期中回撥方法，有效的解決了之前需要處理回撥中View消失的問題。在使用層面上利用LiveData能夠消除掉之前MVP中關於View的生命週期控制等類似的問題。

但是在使用的過程中，會發現一個弊端就是當你使用LiveData控制的資料，需要展示到介面上時，你需要將一個LiveData資料變成Observable型別的資料，然後通過Databinding進行繫結。雖然他們是內容是相同的，但是仍需要做一層轉化。

這裡說一下各自的優點，簡單的概括一下：

  • LiveData：與生命週期關聯，能夠實現在特定的生命週期中進行回撥。
  • Observable：能夠與UI進行雙向繫結。

從最開始使用LiveData時，就在思考一個問題，有沒有方法能夠消除掉這一層的轉化，或者說有沒有一種新的資料型別，既能與生命週期關聯，又能與UI進行雙向繫結。慚愧的說嘗試一番，無果。在學習LiveData的過程中，在官方的issue中看到作者正在著手解決這個痛點，不過一直都沒有最新的訊息。直到這個新年的第一個工作日。

最新進展

新年第一天上班，開啟電腦，習慣性的把日常的Android站點都逛一遍，就發現了一篇新的文章介紹說官方已經在最新的Androdi Studio 3.1 canary6預覽版中加入了LiveData和Databinding的處理，不用再進行轉換才能響應到UI上了，文章還給了一個小的例子。那個文章的地址會放在為文末，還有對應的github地址。看到這個，我馬上就嘗試了一下，下面就都是流水賬了。

下載最新預覽版Studio

預覽版地址
安裝和建立一個普通的專案這裡都不說了。然後就是新增依賴：

dependencies {
 	...
    implementation 'android.arch.lifecycle:extensions:1.0.0'
    annotationProcessor 'android.arch.lifecycle:compiler:1.0.0'
    ...
}
複製程式碼

這裡就引用最基本的一個extension就可以了。在新增這兩個依賴的時候操作起來特別的卡，不知道是我電腦的問題還是最新的這個Studio的問題。

寫個小例子

這裡我建立了一個MainViewModel,用於測試，直接上程式碼，基本都沒有難度：

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:

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，我們能夠實現任何和生命週期相關的東西，而不僅僅就是資料。作為新年你的第一篇文章，有點水，也有些倉促，有好幾個關鍵的點，沒有進行驗證和測試，不過目前的版本不會是最終的版本，等有正式版的時候會重新寫一篇正式一點的。

相關地址

國外文章

國外文章專案地址

本文的專案地址

相關文章