[Jetpack]DataBinding源码浅析

最新推荐文章于 2023-12-11 23:02:37 发布
最新推荐文章于 2023-12-11 23:02:37 发布
阅读量319 收藏
点赞数
分类专栏： android 文章标签： android jetpack DataBinding
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22783769/article/details/107952300
版权

DataBinding源码探析


DataBinding的出现实现了数据和UI的双向绑定，极大的方便了数据更新时UI能同步显示，下面就以一个简单的Demo作为入口，简要分析一下DataBinding源码。

创建DataBinding项目
  1. 修改build.gradle文件
android {
		//......
    dataBinding {
        enabled = true
    }
  1. 新建User类
class User(name: String, password: String) : BaseObservable() {
    @Bindable
    var name: String = name
        set(value) {
            field = value
            notifyPropertyChanged(BR.name)
        }
    @Bindable
    var password: String = password
        set(value) {
            field = value
            notifyPropertyChanged(BR.password)
        }
}
  1. 修改activity_main.xml如下：
<?xml version="1.0" encoding="utf-8"?>

<layout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">
    <data>
        <variable
            name="user"
            type="com.hanshow.databinddemo.User" />
    </data>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical"
        tools:context=".MainActivity">

        <TextView
            android:id="@+id/tv1"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@{user.name}" />

        <TextView
            android:id="@+id/tv2"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginTop="10dp"
            android:text="@{user.password}" />

    </LinearLayout>
</layout>
  1. 修改MainActivity如下：
class MainActivity : AppCompatActivity() {


    private var user:User? = null
    private var binding: ActivityMainBinding? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        user = User("mfw","123456")
        //1.绑定布局
        binding = DataBindingUtil.setContentView(this,R.layout.activity_main)
        //2.给UIset数据
        binding?.user = user
        val runnable = Runnable {
            run {
                for (index in 1..10){
                    Thread.sleep(1000)
                    user?.let {
                            it ->
                        it.name = it.name + "1"
                    }
                }
            }

        }
        //3.子线程修改数据
        Thread(runnable).start()
    }
}

实现效果如下：
在这里插入图片描述
至此，一个简单的demo就写好了，为了学习源码，我们提出以下三个问题：
1.databinding如何实现Activity和xml文件的绑定？
2.databinding如何更新数据到xml？
3.为什么子线程更新数据后，UI能正常显示？

源码分析
  • 入口1：DataBindingUtil.setContentView
public static <T extends ViewDataBinding> T setContentView(@NonNull Activity activity,
            int layoutId) {
        return setContentView(activity, layoutId, sDefaultComponent);
    }

setContentView方法重载：

public static <T extends ViewDataBinding> 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);
    }

从这个方法可以看出，Activity和xml文件的绑定还是通过setContentView来完成的，继续往下查看bindToAddedViews方法：

private static <T extends ViewDataBinding> T bindToAddedViews(DataBindingComponent component,
            ViewGroup parent, int startChildren, int layoutId) {
        final int endChildren = parent.getChildCount();
        final int childrenAdded = endChildren - startChildren;
        if (childrenAdded == 1) {
            final View childView = parent.getChildAt(endChildren - 1);
            return bind(component, childView, layoutId);
        } else {
            final View[] children = new View[childrenAdded];
            for (int i = 0; i < childrenAdded; i++) {
                children[i] = parent.getChildAt(i + startChildren);
            }
            return bind(component, children, layoutId);
        }
    }

 static <T extends ViewDataBinding> T bind(DataBindingComponent bindingComponent, View[] roots,
            int layoutId) {
        return (T) sMapper.getDataBinder(bindingComponent, roots, layoutId);
    }

最终调用到sMapper.getDataBinder，sMapper又是什么呢？

private static DataBinderMapper sMapper = new DataBinderMapperImpl();

最后的最后会调到DataBinderMapperImpl的getDataBinder方法。

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

这时候就不得不说一下databinding的中间产物了，首先会额外生成两个xml文件：
在这里插入图片描述
由于篇幅原因就不再剖析生成的xml文件内容，可以自行格式化以后进行分析，out目录下的是对databinding的数据解释和说明并通过tag和layout下的view进行绑定，再看看生成核心java文件：
在这里插入图片描述
核心Java类中的内容会按调用顺序分析，继续回到DataBinderMapperImpl的getDataBinder方法，判断view文件的tag，然后初始化ActivityMainBindingImpl，查看layout下的activity_main.xml，根布局的tag就是"layout/activity_main_0"，所以下一步进入ActivityMainBindingImpl的构造方法：

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

继续查看mapBindings方法：

  protected static Object[] mapBindings(DataBindingComponent bindingComponent, View root,
            int numBindings, IncludedLayouts includes, SparseIntArray viewsWithIds) {
        Object[] bindings = new Object[numBindings];
        mapBindings(bindingComponent, root, bindings, includes, viewsWithIds, true);
        return bindings;
    }

会继续重载到mapBindings(DataBindingComponent bindingComponent, View view,
Object[] bindings, IncludedLayouts includes, SparseIntArray viewsWithIds,
boolean isRoot) 方法，该方法用于解析xml文件中的内容返回一个Object数据，然后继续看构造方法重载：

 private ActivityMainBindingImpl(androidx.databinding.DataBindingComponent bindingComponent, View root, Object[] bindings) {
        super(bindingComponent, root, 1
            , (android.widget.TextView) bindings[1]
            , (android.widget.TextView) bindings[2]
            );
        this.mboundView0 = (android.widget.LinearLayout) bindings[0];
        this.mboundView0.setTag(null);
        this.tv1.setTag(null);
        this.tv2.setTag(null);
        setRootTag(root);
        // listeners
        invalidateAll();
    }

至此，可以看到xml中申明的view会在解析阶段存储在ActivityMainBindingImpl中，这也就是为什么能在Activity中通过binding直接访问View。

  • 入口2：binding?.user = user
 public void setUser(@Nullable com.hanshow.databinddemo.User User) {
        updateRegistration(0, User);
        this.mUser = User;
        synchronized(this) {
            mDirtyFlags |= 0x1L;
        }
        notifyPropertyChanged(BR.user);
        super.requestRebind();
    }

binding?.user = user调用的是ActivityMainBindingImpl.setUser方法，然后继续深入：

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

CREATE_PROPERTY_LISTENER为一个CreateWeakListener常量，

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

此方法就是把CreateWeakListener 和数据的id形成绑定关系，数据的Id可通过BR文件内容获得，BR文件内容如下：

public class BR {
  public static final int _all = 0;

  public static final int name = 1;

  public static final int password = 2;

  public static final int user = 3;
}

name和password是因为我们重写了set方法，并加入了@Bindable注解，而user 是定义在xml中的，都会在BR文件中生成对应的ID，然后继续看notifyPropertyChanged方法：

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

这个方法就跟踪到这，后面会继续讨论，接下来看super.requestRebind方法:

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

可以看到最后需要Android版本，但是最终都会调用到mRebindRunnable：

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

然后继续看executePendingBindings：

 public void executePendingBindings() {
        if (mContainingBinding == null) {
            executeBindingsInternal();
        } else {
            mContainingBinding.executePendingBindings();
        }
    }

 private void executeBindingsInternal() {
        if (mIsExecutingPendingBindings) {
            requestRebind();
            return;
        }
        if (!hasPendingBindings()) {
            return;
        }
        mIsExecutingPendingBindings = true;
        mRebindHalted = false;
        if (mRebindCallbacks != null) {
            mRebindCallbacks.notifyCallbacks(this, REBIND, null);

            // The onRebindListeners will change mPendingHalted
            if (mRebindHalted) {
                mRebindCallbacks.notifyCallbacks(this, HALTED, null);
            }
        }
        if (!mRebindHalted) {
            executeBindings();
            if (mRebindCallbacks != null) {
                mRebindCallbacks.notifyCallbacks(this, REBOUND, null);
            }
        }
        mIsExecutingPendingBindings = false;
    }

这里最终会调用到executeBindings方法，但他是一个抽象方法，所以看他的实现就好了：

 protected void executeBindings() {
        long dirtyFlags = 0;
        synchronized(this) {
            dirtyFlags = mDirtyFlags;
            mDirtyFlags = 0;
        }
        java.lang.String userName = null;
        com.hanshow.databinddemo.User user = mUser;
        java.lang.String userPassword = 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.password
                        userPassword = user.getPassword();
                    }
            }
        }
        // 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, userPassword);
        }
    }
    // Listener Stub Implementations
    // callback impls
    // dirty flag
    private  long mDirtyFlags = 0xffffffffffffffffL;
    /* flag mapping
        flag 0 (0x1L): user
        flag 1 (0x2L): user.name
        flag 2 (0x3L): user.password
        flag 3 (0x4L): null
    flag mapping end*/
    //end
}

到这里应该就都能看的懂了，就是通过一层层回调以后最终还是会通过setText来更新UI。
顺便说一下第三个问题的答案，因为我们通过mUIThreadHandler.post来更新UI，所以最终的setText还是在主线程。

  • 入口3：notifyPropertyChanged(BR.name)
 public void notifyPropertyChanged(int fieldId) {
        synchronized (this) {
            if (mCallbacks == null) {
                return;
            }
        }
        mCallbacks.notifyCallbacks(this, fieldId, null);
    }

接上前面的，单数据发生变更时，都会调用 mCallbacks.notifyCallbacks：

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

然后看一下notifyRecurse方法：

 private void notifyRecurse(T sender, int arg, A arg2) {
        final int callbackCount = mCallbacks.size();
        final int remainderIndex = mRemainderRemoved == null ? -1 : mRemainderRemoved.length - 1;

        // Now we've got all callbakcs that have no mRemainderRemoved value, so notify the
        // others.
        notifyRemainder(sender, arg, arg2, remainderIndex);

        // notifyRemainder notifies all at maxIndex, so we'd normally start at maxIndex + 1
        // However, we must also keep track of those in mFirst64Removed, so we add 2 instead:
        final int startCallbackIndex = (remainderIndex + 2) * Long.SIZE;

        // The remaining have no bit set
        notifyCallbacks(sender, arg, arg2, startCallbackIndex, callbackCount, 0);
    }

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

mNotifier.onNotifyCallback是一个抽象方法，所以看他的实现类PropertyChangeRegistry，
然后继续调用WeakPropertyListener的onPropertyChanged方法：

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

又回调到ViewDataBind的handleFieldChange方法：

  private void handleFieldChange(int mLocalFieldId, Object object, int fieldId) {
        if (mInLiveDataRegisterObserver) {
            // We're in LiveData registration, which always results in a field change
            // that we can ignore. The value will be read immediately after anyway, so
            // there is no need to be dirty.
            return;
        }
        boolean result = onFieldChange(mLocalFieldId, object, fieldId);
        if (result) {
            requestRebind();
        }
    }

最后还是回到了requestRebind

2018Summer丶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android开发问题备忘录
Dev Blog
10-20 635
Android 使用 databinding：view must have a tag 这个坑是databinding编译时的问题，将xml布局文件重命名之后，就解决了 如：activity_main.xml 改为activity_main_2.xml
Jetpack databinding livedata lifecycle
09-28
Jetpack databinding livedata lifecycle
Android--Jetpack--Databinding源码解析
袁震的博客
12-11 1100
慢品人间烟火色，闲观万事岁月长。
Jetpack学习-8-Databinding源码分析及BindingAdapter的使用
行者Sun
05-15 798
Databinding的源码分析以及BindingAdapter的简单使用
【开发问题记录】android 使用databinding：view must have a tag
epitomizelu的专栏
02-24 6607
android 使用databinding：view must have a tag 这个坑是databinding编译时的问题，将xml布局文件重命名之后，就解决了 如：activity_main.xml 改为activity_main_2.xml ...
android开发之DataBinding的使用以及源码深度分析
Jesiah的博客
05-10 1600
本文详细介绍了DataBinding的使用、DataBinding的原理以及DataBinding源码的深度分析
Jetpack之DataBinding技术实战
最新发布
12-24
Jetpack之DataBinding技术实战
Kotlin、Dart教程、Jetpack 源码剖析
01-17
Kotlin、Dart教程、Jetpack 源码剖析、三方库源码解析、系统源码解析、三方框架使用指南、Flutter 教程、Kotlin 协程、多线程机制解析、个人开源库
DataBinding 架构组件 ④
04-18
【Jetpack】DataBinding 架构组件 ④ ( 使用 @BindingAdapter 注解为布局组件绑定自定义逻辑 | 网络图片加载 | 本地图片加载 ) https://blog.csdn.net/shulianghan/article/details/130043460 一、@BindingAdapter...
JetPack下的MVVM
07-27
JetPack下的MVVM . ViewModel + LiveData 组件结合 . 这样做的目的既能保证数据不会无缘无故丢失 , 还能自动关联宿主的生命周期 , 避免空指针的问题 . Activity , Fragment UI 逻辑和用户交互控制就可以了 . ...
Databinding使用、Databinding原理、Androidx集成Databinding、Databinding源码分析、Databinding双向绑定原理
01-03
简介 Databinding是谷歌的一个官方支持库，它允许您使用声明性格式而不是通过编程方式将布局中的UI组件绑定到应用程序中的数据源。 通常在活动中使用调用UI框架方法的代码来定义布局。例如，调用findViewById()以查找TextView窗口小部件并将其绑定到变量。 因为它通过在布局文件中绑定组件，您可以删除活动中的许多UI框架调用，从而使它们更易于维护。这也可以提高应用程序的性能，并有助于防止内存泄漏和空指针异常。 Androidx集成Databinding 1、将dataBinding元素添加到 build.gradle应用程序模块中 android { ......
dataBindingDemo
02-27
databinding反向绑定的实践demo，亲测有效。
DataBindingDemo
11-04
DataBindingDemo示例源码
OC中的类方法和对象方法
chongxienuo3437的博客
03-04 135
//1.对象方法 -(void)lookMyPhone; 以-号开头//里面可以使用成员变量//用对象来调用//对象方法可以调用类方法和对象方法 //2.类方法 +(NSString*)colorWithEnumColor:(Color)color; 以+号开头//...
Android JetPack DataBinding 使用和源码分析
lifeijiyuan126的专栏
04-01 412
使用方法： 1、配置 graldel文件 dataBinding{ enabled true } XML文件 <data> <variable name="users" type="com.example.myapplication.databinding.User" /> //对应继承BaseObs...
jetpack系列文章：Databinding源码分析（一）：单双向数据绑定
massonJ的博客
08-30 549
前言： 由于公司新项目使用MVVM模式，基于databinding的，因此专门分析了一下源码，有助于开发。之前项目用到的是MVP框架，其实MVP也能实现V和M的解耦，只是MVVM在解耦的基础上实现了V和M的双向绑定，达到自动更新同步数据，使开发更加便。 话不多说，开始分析，使用网上很多了，这里不说了： APT技术: databinding我们用起来很简单，越简单表示框架帮我们完成了越多的东西，毫无疑问自动生成的代码是通过apt技术完成的，这个我已经在Arouter源码分析中讲过了，这里附上链接，不再赘述：A
databinding源码分析一
读书未遍、未敢妄下雌黄
10-24 775
前言databinding是google在2015年发布的一个库，支持布局文件和mode数据之间进行绑定。最新版本已经支持双向绑定，数据的更新可以触发同步到布局对应的ui界面，布局文件的数据更新也可以传递到mode数据上。1. 数据更新如何触发ui更新的?2. ui操作是如何关联上数据的?3. 自定义view该如何关联数据绑定?带着以上三个问题分析源码，本篇先分析问题一： databinding源
DataBinding源码解析
海的鼻涕的博客
10-11 4256
DataBinding是谷歌15年推出的library。DataBinding支持双向绑定，能大大减少绑定app逻辑与layout文件的“胶水代码”，例如findViewById等代码。双向绑定，指的是将数据与界面绑定起来，当数据发生变化时会体现在界面上，反过来界面内容变化也会同步更新到数据上，使用DataBinding能轻松实现MVVM模式。
JetPack系列---Databinding源码分析
qq_32019367的博客
11-24 414
最近撸了一些Jetpack的源码，发现自己阅读源码的能力越来越强了，为自己的努力点赞，相信没有谁的努力会被辜负 Databinding本来是第一个就要撸的，但是当我进入源码世界之后，真的是被它弄糊涂了。找了半天没有什么头绪，最后只能把它放在最后来看了。即便是这样，把Databinding捋顺也用了半天的时间，期间还使用了反射来验证，也是麻烦至极。因为Databind所生成的代码文件，都是使用APT编译期生成的，所以我们可以使用debug打断点来找思路，一开始我自己没有注意这点，所以浪费了很多时间。行了，废
通过源码安装nvidia-jetpack
04-01
作为AI助手，我无法直接安装nvidia-jetpack，但是我可以为您提供一些步骤，帮助您完成源码安装nvidia-jetpack的过程。 1.下载nvidia-jetpack源码 您可以从官方网站下载nvidia-jetpack的源码包，下载后解压到本地...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值