jetpack系列之databinding

DataBinding是一个实现数据和UI绑定的框架,同时也是实现MVVM模式所依赖的工具.简单说把数据映射到 view 的 xml中,不用去findViewById

使用

1.开启 DataBinding 功能

哪个module需要使用DataBinding就在对应的build.gradle编译配置文件中添加如下代码声明。开启后,在编译时就会执行Databinding相关的Task.

android {
    ...
    dataBinding {
        enabled = true
    }
    ...
}
2.布局中的变化

布局文件的写法变化,在之前的层级上增加了layout 和data标签,data标签不是必须的。
其中myuser是一个临时命名。


    
        
    
    
        
        
    

必须要使用 这个标签作为 xml 的根部局,所有 DataBinding 的内容都写在 标签内
是导入所使用的对象的类型
是具体声明一个数据对象, 是这个对象的名字, 是这个对象的类型, 可以有多个
使用 @{ } / @{book.price} 的方式可以把这个声明出来的数据对象的莫个数据设置给我们的 view

3.Activity中的实现

替换之前的setContentView(布局),其实源码里面还是调用了。

   binding= DataBindingUtil.setContentView(this,R.layout.activity_main);
        user=new User("测试","密码:999");
        binding.setUser(user);
        binding.setVariable(BR.name,"测试。。。。。");

再看下User类的定义,我们让这个继承BaseObservable ,同时通过注解再对象的get XX方法上,完成定义。

public class User extends BaseObservable {
    private String name;
    private String pwd;

    public User(String name, String pwd) {
        this.name = name;
        this.pwd = pwd;
    }

    @Bindable
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
        notifyPropertyChanged(BR.name);
    }

    @Bindable
    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
        notifyPropertyChanged(BR.pwd);
    }
}

这样,整个简单实用,基本就完成了,当然我们实际使用时,数据更新,可能是从网络获取到数据,也就是viewModel更新数据,更新User对象,更新UI。

源码分析

1.布局文件分析

我们可能会想到,布局文件这样写,怎么就能实现解析了。databinding框架在我们编译时候,会生成几个重要的文件如下图
首先是两个布局文件,第一个里面文件中,部分代码如下,我们布局中的每个View都被标记为targets,定义了一个tag,同时view表明之前是一个什么View类型。第二个布局,则是和我们最原始的布局几乎一致,只是每个View 中多了一个tag android:tag="binding_1"


        
            
            
        
image.png

除了上面生成的代码,还有一个比较重要的生成类如下:


image.png
2.继续看DataBindingUtil类

我们在activity中使用这个工具类去设置布局,里面设置布局,里面可以看到还调用setContentView, 然后获取到布局的content再作为参数传到bindToAddedViews方法

public static  T setContentView(@NonNull Activity activity,
            int layoutId, @Nullable DataBindingComponent bindingComponent) {
        activity.setContentView(layoutId);
        View decorView = activity.getWindow().getDecorView();
        ViewGroup contentView = (ViewGroup) decorView.findViewById(android.R.id.content);
        return bindToAddedViews(bindingComponent, contentView, 0, layoutId);
    }

里面调用bind 方法,同样会调用

sMapper.getDataBinder(bindingComponent, roots, layoutId)
3.APT生成的DataBinderMapperImpl类 的getDataBinder方法

看下面代码,如果命中判断,标签是我们定义的最外层的activity_main_0 就创建ActivityMainBindingImpl ,注意activity_main_0 就是我们布局提到的第一个生成的布局文件中的 tag,而创建的实现类,就是APT生成的第三个类

public ViewDataBinding getDataBinder(DataBindingComponent component, View view, int layoutId) {
    int localizedLayoutId = INTERNAL_LAYOUT_ID_LOOKUP.get(layoutId);
    if(localizedLayoutId > 0) {
      final Object tag = view.getTag();
      if(tag == null) {
        throw new RuntimeException("view must have a tag");
      }
      switch(localizedLayoutId) {
        case  LAYOUT_ACTIVITYMAIN: {
          if ("layout/activity_main_0".equals(tag)) {
            return new ActivityMainBindingImpl(component, view);
          }
          throw new IllegalArgumentException("The tag for activity_main is invalid. Received: " + tag);
        }
      }
    }
    return null;
  }
4.创建ActivityMainBindingImpl类

注意到构造方法里面传入了3,这个3,就是布局文件,原始布局文件中View的个数,比如我一个线性布局中嵌套放了5个TextView,那么这个地方就是6.里面主要是创建 Object[] bindings 数组,存放的是对XML文件信息读取数据,主要调用mapBindings方法,里面代码多,主要就是解析XML保存到数组中。

 public ActivityMainBindingImpl(@Nullable androidx.databinding.DataBindingComponent bindingComponent, @NonNull View root) {
        this(bindingComponent, root, mapBindings(bindingComponent, root, 3, sIncludes, sViewsWithIds));
    }


 protected static Object[] mapBindings(DataBindingComponent bindingComponent, View[] roots,
            int numBindings, IncludedLayouts includes, SparseIntArray viewsWithIds) {
        Object[] bindings = new Object[numBindings];
        for (int i = 0; i < roots.length; i++) {
            mapBindings(bindingComponent, roots[i], bindings, includes, viewsWithIds, true);
        }
        return bindings;
    }
//mapBindings 方法太长了。不复制了

>>>>>>>>>>>>> 上面是调用DataBindingUtil设置布局的逻辑>>>>>>>>>

二、调用 binding.setVariable源码分析

这个方法点进去是一个抽象方法,里面具体实现在APT生成的ActivityMainBindingImpl类中。

1. setVariable方法

我们在更改User对象时候,可能直接调用setUser("密码","123456");就如下的判断,BR 也是生成的一个类,代码中all是0 .如果命中的是user就调用setUser方法

 public boolean setVariable(int variableId, @Nullable Object variable)  {
        boolean variableSet = true;
        if (BR.user == variableId) {
            setUser((com.example.databindingdemo.User) variable);
        }
        else {
            variableSet = false;
        }
            return variableSet;
    }
public class BR {
  public static final int _all = 0;

  public static final int name = 1;

  public static final int pwd = 2;

  public static final int user = 3;
}

核心还是调用下面的updateRegistration 方法

public void setUser(@Nullable com.example.databindingdemo_20210117.User User) {
        updateRegistration(0, User);
        this.mUser = User;
        synchronized(this) {
            mDirtyFlags |= 0x1L;
        }
        notifyPropertyChanged(BR.user);
        super.requestRebind();
    }
5.updateRegistration 方法

CREATE_PROPERTY_LISTENER是一个回调接口,onCreate方法中会创建弱引用的监听,里面

protected boolean updateRegistration(int localFieldId, Observable observable) {
        return updateRegistration(localFieldId, observable, CREATE_PROPERTY_LISTENER);
    }

下面方法中首先从饮用的监听的数组中取出弱引用的监听,如果不为空,调用registerTo方法注册

private boolean updateRegistration(int localFieldId, Object observable,
            CreateWeakListener listenerCreator) {
        if (observable == null) {
            return unregisterFrom(localFieldId);
        }
        WeakListener listener = mLocalFieldObservers[localFieldId];
        if (listener == null) {
            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;
    }
5.调用registerTo方法

listenerCreator就是之前的那个CREATE_PROPERTY_LISTENER,
调用create方法就是调用 return new WeakPropertyListener(viewDataBinding,

 protected void registerTo(int localFieldId, Object observable,
            CreateWeakListener listenerCreator) {
        if (observable == null) {
            return;
        }
        WeakListener listener = mLocalFieldObservers[localFieldId];
        if (listener == null) {
            listener = listenerCreator.create(this, localFieldId);
            mLocalFieldObservers[localFieldId] = listener;
            if (mLifecycleOwner != null) {
                listener.setLifecycleOwner(mLifecycleOwner);
            }
        }
        listener.setTarget(observable);
    }

上面的判断中的代码:listener.setLifecycleOwner(mLifecycleOwner); 里面其实就是把被观察者 与listener绑定,里面就是前面说到的lifecycle的addObserver()

 public void setLifecycleOwner(LifecycleOwner lifecycleOwner) {
            mObservable.setLifecycleOwner(lifecycleOwner);
        }

重点还是要看 listener.setTarget(observable);

public void setTarget(T object) {
            unregister();
            mTarget = object;
            if (mTarget != null) {
                mObservable.addListener(mTarget);
            }
        }

再继续看进去 addListener 方法, 是一个接口的抽象方法,里面四个实现,重点看WeakPropertyListener的里面会调用到 target.addOnPropertyChangedCallback(this);
会执行到 下面方法,里面的mCallbacks.add(callback);ViewDataBinding保存在一个List中

 public void addOnPropertyChangedCallback(@NonNull OnPropertyChangedCallback callback) {
        synchronized (this) {
            if (mCallbacks == null) {
                mCallbacks = new PropertyChangeRegistry();
            }
        }
        mCallbacks.add(callback);
    }
5.

上面只是完成updateRegistration(0, User);方法的逻辑实现更新监听,执行Dirty 再执行下面我们看
notifyPropertyChanged(BR.user); 方法实现

  public void setUser(@Nullable com.example.databindingdemo.User User) {
        updateRegistration(0, User);
        this.mUser = User;
        synchronized(this) {
           mDirtyFlags |= 0x1L;
        }
        notifyPropertyChanged(BR.user);
        super.requestRebind();
    }

public void notifyPropertyChanged(int fieldId) {
        synchronized (this) {
            if (mCallbacks == null) {
                return;
            }
        }
        mCallbacks.notifyCallbacks(this, fieldId, null);
    }

三、刷新流程

1.notifyPropertyChanded 方法调用。

重点看notifyRecurse(sender, arg, arg2); 方法,后面都是移除回调

public synchronized void notifyCallbacks(T sender, int arg, A arg2) {
        mNotificationLevel++;
        notifyRecurse(sender, arg, arg2); //重点
        mNotificationLevel--;
        if (mNotificationLevel == 0) {
            if (mRemainderRemoved != null) {
                for (int i = mRemainderRemoved.length - 1; i >= 0; i--) {
                    final long removedBits = mRemainderRemoved[i];
                    if (removedBits != 0) {
                        removeRemovedCallbacks((i + 1) * Long.SIZE, removedBits);
                        mRemainderRemoved[i] = 0;
                    }
                }
            }
            if (mFirst64Removed != 0) {
                removeRemovedCallbacks(0, mFirst64Removed);
                mFirst64Removed = 0;
            }
        }
2.
private void notifyRecurse(T sender, int arg, A arg2) {
     ...删除其他代码
        notifyRemainder(sender, arg, arg2, remainderIndex)
    }
调用notifyFirst64方法
notifyFirst64(sender, arg, arg2);

再调用到

private void notifyCallbacks(T sender, int arg, A arg2, final int startIndex,
            final int endIndex, final long bits) {
        long bitMask = 1;
        for (int i = startIndex; i < endIndex; i++) {
            if ((bits & bitMask) == 0) {
                mNotifier.onNotifyCallback(mCallbacks.get(i), sender, arg, arg2);
            }
            bitMask <<= 1;
        }
    }

再调用到 PropertyChangeRegistry 类的onPropertyChanged方法

执行到监听的属性改变方法
public void onPropertyChanged(Observable sender, int propertyId) {
            ViewDataBinding binder = mListener.getBinder();
            if (binder == null) {
                return;
            }
            Observable obj = mListener.getTarget();
            if (obj != sender) {
                return; // notification from the wrong object?
            }
            binder.handleFieldChange(mListener.mLocalFieldId, sender, propertyId); //重点
        }

再调用 binder.handleFieldChange(mListener.mLocalFieldId, sender, propertyId);

再调用requestRebind

下面看编舞者类的另一个分支,通过一个handler执行runnable。

protected void requestRebind() {
        if (mContainingBinding != null) {
            mContainingBinding.requestRebind();
        } else {
            final LifecycleOwner owner = this.mLifecycleOwner;
            if (owner != null) {
                Lifecycle.State state = owner.getLifecycle().getCurrentState();
                if (!state.isAtLeast(Lifecycle.State.STARTED)) {
                    return; // wait until lifecycle owner is started
                }
            }
            synchronized (this) {
                if (mPendingRebind) {
                    return;
                }
                mPendingRebind = true;
            }
            if (USE_CHOREOGRAPHER) {
                mChoreographer.postFrameCallback(mFrameCallback);
            } else {
                mUIThreadHandler.post(mRebindRunnable); //重点
            }
        }
    }
Runnble中执行 executePendingBindings()
    private final Runnable mRebindRunnable = new Runnable() {
        @Override
        public void run() {
            synchronized (this) {
                mPendingRebind = false;
            }
            processReferenceQueue();

            if (VERSION.SDK_INT >= VERSION_CODES.KITKAT) {
                // Nested so that we don't get a lint warning in IntelliJ
                if (!mRoot.isAttachedToWindow()) {
                    // Don't execute the pending bindings until the View
                    // is attached again.
                    mRoot.removeOnAttachStateChangeListener(ROOT_REATTACHED_LISTENER);
                    mRoot.addOnAttachStateChangeListener(ROOT_REATTACHED_LISTENER);
                    return;
                }
            }
            executePendingBindings();
        }
    };

上面代码会再次执行到ViewDataBinding类的executeBindings方法,

会调用到APT 生成类的executeBindings方法
    long dirtyFlags = 0;
        synchronized(this) {
            dirtyFlags = mDirtyFlags;
            mDirtyFlags = 0;
        }
        java.lang.String userName = null;
        com.example.databindingdemo.User user = mUser;
        java.lang.String userPwd = null;

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


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

                    if (user != null) {
                        // read user.name
                        userName = user.getName();
                    }
            }
            if ((dirtyFlags & 0xdL) != 0) {

                    if (user != null) {
                        // read user.pwd
                        userPwd = user.getPwd();
                    }
            }
        }
        // batch finished
        if ((dirtyFlags & 0xbL) != 0) {
            // api target 1

            androidx.databinding.adapters.TextViewBindingAdapter.setText(this.tv1, userName);
        }
        if ((dirtyFlags & 0xdL) != 0) {
            // api target 1

            androidx.databinding.adapters.TextViewBindingAdapter.setText(this.tv2, userPwd);
        }
    }

可以看到上面的代码,TextViewBindingAdapter.setText ,感觉快到了!

 public static void setText(TextView view, CharSequence text) {
        final CharSequence oldText = view.getText();
        if (text == oldText || (text == null && oldText.length() == 0)) {
            return;
        }
        if (text instanceof Spanned) {
            if (text.equals(oldText)) {
                return; // No change in the spans, so don't set anything.
            }
        } else if (!haveContentsChanged(text, oldText)) {
            return; // No content changes, so don't set anything.
        }
        view.setText(text);
    }

上面就是当我们调用setUser这种或者setVariable方法,会调用到notifyPropertiChange方法,去更新binding,因为我们在使用DataBindingUtil 设置布局时,建立了监听关系,这个时候会通知发生变化,当然,中间还增加判断了,被观察者是否处于active状态,才能更新,最后会调用到我们在APT阶段生成的类的executeBindings方法, 里面还是调用了对应tag的更新UI的方法。最终其实就是跟我们使用MVP 加回调方式实现是一样的,只是框架对这套回调,封装在框架里面。防止开发者忘记注销,增加是否激活状态等封装,使用更方便。

小结

首先就是activity是一个被观察者,被databinding观察他的生命周期变化。只有当处于激活状态,才会回调更新UI;
其实activity是观察者,每个activity 可能会用到多个Viewmodel 对象,那么activity会在APT生成的实现类中创建数组,存放对应的tag,当数据tag发生变化后,通过DataBinding框架的监听,来通知activity 刷新UI。
最后我们会发现,这个框架其实思路还是比较简单,只是对绑定关系,回调,即是否处于active状态等逻辑封装判断,不用我们手写代码。使用起来简单,高效。

你可能感兴趣的:(jetpack系列之databinding)