jetpack之数据绑定的源码解读(二)

最新推荐文章于 2022-05-26 11:42:00 发布
最新推荐文章于 2022-05-26 11:42:00 发布
阅读量184 收藏 1
点赞数
分类专栏： # Android-Jetpack使用与源码分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Duckdan/article/details/107294560
版权

源码版本：Android10

在上一篇 jetpack之数据绑定的源码解读(一)中介绍了DataBinding的基本原理，这篇文章主要是讲@InverseBindingAdapter以及是如何实现双向绑定的。

一、Demo源码

1.1 activity_recycler_view.xml源码
<?xml version="1.0" encoding="utf-8"?>
<layout>
    <data>
        <variable
            name="refresh"
            type="com.study.jetpackstudykotlin.databinding.bean.Refresh" />
    </data>

    <androidx.swiperefreshlayout.widget.SwipeRefreshLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:id="@+id/srl"
        refreshing="@={refresh.swipeRefreshViewRefreshing}"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        tools:context=".databinding.RecyclerViewActivity">

        <FrameLayout
            android:layout_width="match_parent"
            android:layout_height="match_parent">

            <androidx.recyclerview.widget.RecyclerView
                android:id="@+id/rv"
                android:layout_width="match_parent"
                android:layout_height="match_parent" />
            <Button
                android:id="@+id/bt"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"/>
        </FrameLayout>

    </androidx.swiperefreshlayout.widget.SwipeRefreshLayout>
</layout>
1.2 RecyclerViewActivity源码
package com.study.jetpackstudykotlin.databinding

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import androidx.databinding.DataBindingUtil
import androidx.recyclerview.widget.LinearLayoutManager
import com.study.jetpackstudykotlin.R
import com.study.jetpackstudykotlin.databinding.adapter.RvAdapter
import com.study.jetpackstudykotlin.databinding.bean.Refresh
import com.study.jetpackstudykotlin.databinding.bean.User

class RecyclerViewActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_recycler_view)
        val binding = DataBindingUtil.setContentView<ActivityRecyclerViewBinding>(
            this,
            R.layout.activity_recycler_view
        )
        val refresh = Refresh()
        binding.refresh = refresh
        binding.rv.layoutManager = LinearLayoutManager(this, LinearLayoutManager.VERTICAL, false)
        var arrayList = arrayListOf<User>()
        for (j in 0..100) {
            arrayList.add(User("简单$j", "粗暴$j"))
        }
        binding.rv.adapter = RvAdapter(this, arrayList)


        binding.bt.setOnClickListener {
            Log.e("refresh::", "当前binding.refresh值为Activity" + refresh.swipeRefreshViewRefreshing.get())
            //修改刷新状态值
            refresh.swipeRefreshViewRefreshing.set(false)
        }
    }
}
1.3 ViewAdapter源码
package com.study.jetpackstudykotlin.databinding.viewAdapter;

import android.graphics.drawable.ColorDrawable;
import android.util.Log;
import android.view.View;
import android.widget.Toast;

import androidx.appcompat.widget.AppCompatImageView;
import androidx.databinding.BindingAdapter;
import androidx.databinding.BindingConversion;
import androidx.databinding.InverseBindingAdapter;
import androidx.databinding.InverseBindingListener;
import androidx.swiperefreshlayout.widget.SwipeRefreshLayout;

public class ViewAdapter {


    @BindingAdapter(value = {"imgContent"})
    public static void loadImage(AppCompatImageView imageView, final String content) {
        imageView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Toast.makeText(v.getContext(), content, Toast.LENGTH_SHORT).show();
            }
        });
    }

    @BindingConversion
    public static ColorDrawable convertColorToDrawable(int color) {
        return new ColorDrawable(color);
    }
    
    
    //===================SwipeRefreshLayout双向绑定的具体实现===================
    @InverseBindingAdapter(attribute = "refreshing", event = "refreshingAttrChanged")
    public static boolean isRefreshing(SwipeRefreshLayout view) {
        return view.isRefreshing();
    }
	
	//InverseBindingListener refreshingAttrChanged是由apt帮忙生成的
    @BindingAdapter(value = {"refreshingAttrChanged"}, requireAll = false)
    public static void setOnRefreshListener(final SwipeRefreshLayout view,
                                            final InverseBindingListener refreshingAttrChanged) {

        if (refreshingAttrChanged != null) {
        //给view设置刷新监听
            view.setOnRefreshListener(new SwipeRefreshLayout.OnRefreshListener() {
                @Override
                public void onRefresh() {
                    refreshingAttrChanged.onChange();
                    Log.e("refresh::", "当前binding.refresh值为" + view.isRefreshing());
                }
            });
        }
    }

    @BindingAdapter("refreshing")
    public static void setRefreshing(SwipeRefreshLayout view, boolean refreshing) {
    //两者不相同，才去刷新SwipeRefreshLayout
        if (refreshing != view.isRefreshing()) {
            view.setRefreshing(refreshing);
        }
    }
}

二、源码分析

这里使用SwipeRefreshLayout来作为实现双向绑定的示例，xml文件中

refreshing="@={refresh.swipeRefreshViewRefreshing}"，@=是实现双向绑定的关键条件之一

com.study.jetpackstudykotlin.databinding.ActivityRecyclerViewBindingImpl源码如下所示：

package com.study.jetpackstudykotlin.databinding;
import com.study.jetpackstudykotlin.R;
import com.study.jetpackstudykotlin.BR;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import android.view.View;
@SuppressWarnings("unchecked")
public class ActivityRecyclerViewBindingImpl extends ActivityRecyclerViewBinding  {

    @Nullable
    private static final androidx.databinding.ViewDataBinding.IncludedLayouts sIncludes;
    @Nullable
    private static final android.util.SparseIntArray sViewsWithIds;
    static {
        sIncludes = null;
        sViewsWithIds = new android.util.SparseIntArray();
        sViewsWithIds.put(R.id.rv, 1);
        sViewsWithIds.put(R.id.bt, 2);
    }
    // views
    // variables
    // values
    // listeners
    // Inverse Binding Event Handlers，生产双向绑定的监听类
    private androidx.databinding.InverseBindingListener srlrefreshingAttrChanged = new androidx.databinding.InverseBindingListener() {
        @Override
        public void onChange() {
            // Inverse of refresh.swipeRefreshViewRefreshing.get()
            //         is refresh.swipeRefreshViewRefreshing.set((boolean) callbackArg_0)
            //通过调用isRefreshing方法，获取SwipeRefreshLayout刷新状态的回调值
            boolean callbackArg_0 = com.study.jetpackstudykotlin.databinding.viewAdapter.ViewAdapter.isRefreshing(srl);
            // localize variables for thread safety
            // refresh != null
            boolean refreshJavaLangObjectNull = false;
            // refresh.swipeRefreshViewRefreshing != null
            boolean refreshSwipeRefreshViewRefreshingJavaLangObjectNull = false;
            // refresh 进入页面的首次状态值
            com.study.jetpackstudykotlin.databinding.bean.Refresh refresh = mRefresh;
            // refresh.swipeRefreshViewRefreshing.get()
            boolean refreshSwipeRefreshViewRefreshingGet = false;
            // refresh.swipeRefreshViewRefreshing
            androidx.databinding.ObservableBoolean refreshSwipeRefreshViewRefreshing = null;



            refreshJavaLangObjectNull = (refresh) != (null);
            if (refreshJavaLangObjectNull) {

				//获取xml文件中操作SwipeRefreshLayout刷新状态的对象
                refreshSwipeRefreshViewRefreshing = refresh.getSwipeRefreshViewRefreshing();

                refreshSwipeRefreshViewRefreshingJavaLangObjectNull = (refreshSwipeRefreshViewRefreshing) != (null);
                if (refreshSwipeRefreshViewRefreshingJavaLangObjectNull) {
					//将改变之后的刷新状态值交给Activity里面refreshSwipeRefreshViewRefreshing，从而实现双向绑定
                    refreshSwipeRefreshViewRefreshing.set(((boolean) (callbackArg_0)));
                }
            }
        }
    };

    public ActivityRecyclerViewBindingImpl(@Nullable androidx.databinding.DataBindingComponent bindingComponent, @NonNull View root) {
        this(bindingComponent, root, mapBindings(bindingComponent, root, 3, sIncludes, sViewsWithIds));
    }
    private ActivityRecyclerViewBindingImpl(androidx.databinding.DataBindingComponent bindingComponent, View root, Object[] bindings) {
        super(bindingComponent, root, 1
            , (android.widget.Button) bindings[2]
            , (androidx.recyclerview.widget.RecyclerView) bindings[1]
            , (androidx.swiperefreshlayout.widget.SwipeRefreshLayout) bindings[0]
            );
        this.srl.setTag(null);
        setRootTag(root);
        // listeners
        invalidateAll();
    }

    @Override
    public void invalidateAll() {
        synchronized(this) {
                mDirtyFlags = 0x4L;
        }
        requestRebind();
    }

    @Override
    public boolean hasPendingBindings() {
        synchronized(this) {
            if (mDirtyFlags != 0) {
                return true;
            }
        }
        return false;
    }

    @Override
    public boolean setVariable(int variableId, @Nullable Object variable)  {
        boolean variableSet = true;
        if (BR.refresh == variableId) {
            setRefresh((com.study.jetpackstudykotlin.databinding.bean.Refresh) variable);
        }
        else {
            variableSet = false;
        }
            return variableSet;
    }

    public void setRefresh(@Nullable com.study.jetpackstudykotlin.databinding.bean.Refresh Refresh) {
        this.mRefresh = Refresh;
        synchronized(this) {
            mDirtyFlags |= 0x2L;
        }
        notifyPropertyChanged(BR.refresh);
        super.requestRebind();
    }

    @Override
    protected boolean onFieldChange(int localFieldId, Object object, int fieldId) {
        switch (localFieldId) {
            case 0 :
                return onChangeRefreshSwipeRefreshViewRefreshing((androidx.databinding.ObservableBoolean) object, fieldId);
        }
        return false;
    }
    private boolean onChangeRefreshSwipeRefreshViewRefreshing(androidx.databinding.ObservableBoolean RefreshSwipeRefreshViewRefreshing, int fieldId) {
        if (fieldId == BR._all) {
            synchronized(this) {
                    mDirtyFlags |= 0x1L;
            }
            return true;
        }
        return false;
    }

    @Override
    protected void executeBindings() {
        long dirtyFlags = 0;
        synchronized(this) {
            dirtyFlags = mDirtyFlags;
            mDirtyFlags = 0;
        }
        com.study.jetpackstudykotlin.databinding.bean.Refresh refresh = mRefresh;
        boolean refreshSwipeRefreshViewRefreshingGet = false;
        androidx.databinding.ObservableBoolean refreshSwipeRefreshViewRefreshing = null;

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



                if (refresh != null) {
                    // read refresh.swipeRefreshViewRefreshing
                    refreshSwipeRefreshViewRefreshing = refresh.getSwipeRefreshViewRefreshing();
                }
                updateRegistration(0, refreshSwipeRefreshViewRefreshing);


                if (refreshSwipeRefreshViewRefreshing != null) {
                    // read refresh.swipeRefreshViewRefreshing.get()
                    refreshSwipeRefreshViewRefreshingGet = refreshSwipeRefreshViewRefreshing.get();
                }
        }
        // batch finished
        if ((dirtyFlags & 0x7L) != 0) {
            // api target 1

            com.study.jetpackstudykotlin.databinding.viewAdapter.ViewAdapter.setRefreshing(this.srl, refreshSwipeRefreshViewRefreshingGet);
        }
        if ((dirtyFlags & 0x4L) != 0) {
            // api target 1

            com.study.jetpackstudykotlin.databinding.viewAdapter.ViewAdapter.setOnRefreshListener(this.srl, srlrefreshingAttrChanged);
        }
    }
    // Listener Stub Implementations
    // callback impls
    // dirty flag
    private  long mDirtyFlags = 0xffffffffffffffffL;
    /* flag mapping
        flag 0 (0x1L): refresh.swipeRefreshViewRefreshing
        flag 1 (0x2L): refresh
        flag 2 (0x3L): null
    flag mapping end*/
    //end
}

三、总结

数据绑定中的注解和kotlin结合使用时总是会报各种各样的异常，目前我还没找到原因，所以我是通过用java来实现这部分代码来解决掉这个问题的。更多数据绑定的使用请看官方文档 数据绑定
Duckdan
关注
专栏目录
❤️即学即用Android Jetpack - Navigation❤️（从构建到源码，十分详细）
云雾蜜蜜，咩咩
07-30 1466
前言 在移动开发中，对开发者来说不同的人具有不同的能力。就像读一本书一样，一千个读者，有一千个哈姆雷特。但不管怎样，只要你是个软件开发者你就必须学习windows或Linux等操作系统的运行原理。就不扯这么多了直接上干货。【由于文中篇幅较长，提前预告：文末有大量手写框架源码及架构思维资料，需要的可直接跳越至文末领取】 实战 在实战之前，我们先来了解一下 Navigation 中最关键的三要素，他们是： Navigation Graph (New XML resource) 如我们的第一张图所示，这
Android-ViewModel源码分析
nufuli123的博客
02-25 562
简介 ViewModel是JetPack生命周期管理库中的一个组件。它可以提供并且管理数据，可感知生命周期，同时不会随着配置（eg：屏幕旋转导致的Activity重新创建）变更而改变。 使用它可以方便的将UI界面和数据逻辑剥离开来，从而达到 UI只负责显示数据和处理用户操作，ViewModel负责提供、管理数据以及通讯。 典型使用场景： 作为数据持有和管理者（eg：处理网络请求）； Fragment之间的通信； ViewModel代替加载器（eg：CursorLoader）。 生命周期 官方对其生命周期
jetpack之DataBinding的双向绑定
snoto的专栏
08-01 647
双向绑定 已经实现的绑定是绑定的model发生改变的时候，UI更新 双向绑定是：UI改变Model提交到Model 比如，一个Edittext绑定了Model的某个值，我们对这个值编辑的时候会将变化提交到Model。 比如表单功能 方式：这里的意思是，我们之前写的绑定是@{user.name}，这里在@与大括号之间加了一个等号=，就实现了双向绑定（待验证，因为视频中的举例还是使用了Observer...
jetpack-数据绑定库(DataBinding)
zhizhuodewo6的博客
02-17 231
1、数据绑定库是一个支持库，允许您使用声明式格式将布局中的UI组件绑定到应用程序中的数据源。这样不仅提高应用性能，而且有助于防止内存泄漏以及避免发生空指针异常。例如： <layout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="http://schemas.androi...
DataBinding学习笔记（一）源码分析
listen2code的博客
11-29 2354
DataBinding整体使用流程开发阶段UserModel.javapublic class UserModel { public String name; public String nickName; public int age; public UserModel(String name, String nickName, int age) {
Databinding 使用以及相关问题
nanxuan521的专栏
07-20 2237
DataBinding 官方文档的解释：数据绑定库是一个支持库，允许您使用声明性格式而不是以编程方式将布局中的UI组件绑定到应用程序中的数据源。其实已经出来很久了，但是身边朋友使用的人不是特别多，今天出一个使用教程： 优点：DataBinding的优点比普通的findViewById之后再设置数据简单了很多，并且数据更新也很简单只要更新绑定的binding，数据更新会自动生效 官方文档 下面介...
DataBinding源码分析
u013773608的博客
05-26 496
1. 为什么配置了 dataBinding{enabled = true}之后就可以使用dataBinding方式进行开发了？ Android Studio中是依靠gradle来管理项目的，在创建一个项目时，从开始创建一直到创建完毕，整个过程是需要执行很多个gradle task的，这些task有很多是系统预先帮我们定义好的，比如build task，clean task等，DataBinding相关的task也是系统预先帮我们定义好的，但是默认情况下，DataBinding相关的task在task列表
Android设计思想解读开源框架.pdf
12-23
**5.2 OkHttp源码解读** - **连接池**：OkHttp通过连接池复用HTTP连接，减少网络延迟。 - **请求队列**：OkHttp内部维护了一个请求队列，用于管理并发请求。 - **重试机制**：当网络请求失败时，OkHttp会自动进行重...
安卓Android源码——eoe社区客户端.zip
10-14
- Android Data Binding库可能被用于实现视图与数据模型的双向绑定，简化UI与业务逻辑的交互。 6. **网络请求**： - 可能使用Retrofit或OkHttp进行网络请求，这两者是安卓开发中常用的网络库，提供了简单易用的...
Android+上百实例源码+集合打包
10-18
其次，开源分析部分则提供了对流行开源库的解读，如Retrofit用于网络请求、ButterKnife进行视图绑定、GreenDAO或Room进行数据库操作等。这些库通常经过了大量项目的验证，有着良好的性能和稳定性。通过分析它们的...
从零开始的Android新项目7 - Data Binding入门篇
马克宅只是个码农
07-27 3602
Data Binding自从去年的Google I/O发布到至今，也有近一年的时间了。这一年来，从Beta到如今比较完善的版本，从Android Studio 1.3到如今2.1.2的支持，可以说Data Binding已经是一个可用度较高，也能带来实际生产力提升的技术了。然而事实上，真正使用到Data Binding的公司、项目仍然是比较少的。可能是出于稳定性考虑，亦或是对Data Binding
认识Android中的双向绑定
zwenkai
09-18 4950
转载请标明出处：http://blog.csdn.net/xuehuayous/article/details/81100571； 本文出自:【Kevin.zhou的博客】 前言：在和一些朋友&amp;网友聊的过程中，发现很多人对于Android中的双向绑定还不太了解，所以MVVM架构就比较难以向大家描述清楚，那么先来了解一下Android中的双向绑定。 什么是双向绑定 双向绑定到底是什...
Android Data Binding从抵触到爱不释手
cpongo5
04-28 183
1 引入 如何高效地实现以下界面？ 登录/未登录 有好几年findViewById实战经验的我，感觉并不难啊。一般会 1.先定义一个User的Model类，数据来自JSON解析； 2.创建一个xml，随后在xml中布局完所有View，对头像、标题、积分、登录按钮一个id； 3.在Activity中通过findViewById获取到头像Imag...
vlc for android中的数据绑定(Data Binding)
happyweb的专栏
04-08 1251
数据绑定(Data Binding)在布局文件中实现数据绑定申明，使数据的变化引起视图的自动更新，减少逻辑代码，从而在Android中方便地实现MVVM的开发模式。 vlc for android中用到了数据绑定（databinding）,下面看一个例子.
Android进阶(五)DataBinding解析
Kinsomy的博客
03-14 1674
1 概述 在上篇文章Android进阶(四)LiveData解析中讲到了关于JetPack框架的LiveData解析，这是一个基于ViewModel和观察者模式的实践。 这篇文章要讲的DataBinding同样可以认为是基于ViewModel的实践，同时做到了数据和UI的双向绑定。DataBinding允许你使用声明式的而不是以编程方式将布局中的UI组件绑定到应用程序中的数据源。免去了编写find...
Android DataBinding原理分析
isJoker的博客
12-08 1814
一、DataBinding使用 本文着重讲解DataBinding原理，使用的例子比较简单，若读者想要了解更多的DataBinding的使用方法介绍，可以自寻相关资料，本文纯属个人理解，若有错误，还望指出（抱拳） 在app模块的build.gradle中加入如下配置 android { ... dataBinding { enabled = true } }...
DataBinding源码解析
海的鼻涕的博客
10-11 4341
DataBinding是谷歌15年推出的library。DataBinding支持双向绑定，能大大减少绑定app逻辑与layout文件的“胶水代码”，例如findViewById等代码。双向绑定，指的是将数据与界面绑定起来，当数据发生变化时会体现在界面上，反过来界面内容变化也会同步更新到数据上，使用DataBinding能轻松实现MVVM模式。
Android Jetpack架构组件及MVVM架构
10-17
Android Jetpack架构组件，大部分程序员还未接触到，本课程紧跟时代，内容始终保持技术先进性，以简洁的代码来解释难懂的理论，程序员们每学完1小节课程就能快速上手，将知识运用到自己的项目中。本课程中介绍的Android Jetpack组件可以只学习其中的一部分就能使用到项目中，也可以全部系统的学习。课程的最后，会用Android Jetpack架构组件搭建一个MVVM架构的Demo，一边写代码一边讲解，以最简洁的程序案例让大家明白如何使用Android Jetpack架构组件搭建项目。
JetPack DataBinding入门：分离视图与控制器
本文主要介绍了Android开发中JetPack框架下的DataBinding库，它提供了一种声明式的编程方式，用于将界面组件与应用的数据源绑定，从而减少Controller与View之间的紧密耦合。通过学习和实践，我们可以更好地理解和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值