Android Data binding官方指南

1. 布局和绑定表达式

表达式语言允许您编写处理由视图分发的事件的表达式。数据绑定库自动生成将布局中的视图与数据对象绑定的类。

数据绑定布局文件稍有不同，以布局的根标记开始，后面跟着数据元素和视图根元素。此视图元素是您的根将在非绑定布局文件中的内容。下面的代码显示了一个示例布局文件：

（1）布局文件这样写

<layout xmlns:android="http://schemas.android.com/apk/res/android">
   <data>
       <variable name="user" type="com.example.User"/>
   data>
   <LinearLayout
       android:orientation="vertical"
       android:layout_width="match_parent"
       android:layout_height="match_parent">
       <TextView android:layout_width="wrap_content"
           android:layout_height="wrap_content"
           android:text="@{user.firstName}"/>
       <TextView android:layout_width="wrap_content"
           android:layout_height="wrap_content"
           android:text="@{user.lastName}"/>
   LinearLayout>
layout>

数据中的user变量描述了可以在该布局中使用的属性。

"user" type="com.example.User" />

布局中的表达式使用“@ {}”语法写入属性。这里，TextView文本被设置为用户变量的firstName属性：

<TextView android:layout_width="wrap_content"
          android:layout_height="wrap_content"
          android:text="@{user.firstName}" />

注意：布局表达式应该保持小而简单，因为它们不能进行单元测试，并且IDE支持有限。为了简化布局表达式，可以使用自定义绑定适配器。

1.1 数据对象

这里假设你有一个普通的对象用于描述User实体：

KOTLIN

data class User(val firstName: String, val lastName: String)

JAVA

public class User {
   public final String firstName;
   public final String lastName;
   public User(String firstName, String lastName) {
       this.firstName = firstName;
       this.lastName = lastName;
   }
}

在数据绑定中，访问@{user.firstName}，那么默认就会访问同名的属性firstName，或对应的getFirstName方法。

这种类型的对象具有从不改变的数据。在应用中常见的数据是一次读取，此后不改变。也可以使用遵循一组约定的对象，如Java中的访问器方法的使用，如下面的示例所示：

KOTLIN

// Not applicable in Kotlin.
data class User(val firstName: String, val lastName: String)

JAVA

1.2 绑定数据

默认情况下，绑定类将基于布局文件的名称来产生
如布局文件为main_activity.xml，这样生成的类是 MainActivityBinding
如下设置Activity的contentView：

KOTLIN

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)

    val binding: ActivityMainBinding = DataBindingUtil.setContentView(
            this, R.layout.activity_main)

    binding.user = User("Test", "User")
}

JAVA

@Override
protected void onCreate(Bundle savedInstanceState) {
   super.onCreate(savedInstanceState);
   MainActivityBinding binding = DataBindingUtil.setContentView(this, R.layout.main_activity);
   User user = new User("Test", "User");
   binding.setUser(user);
}

上文说，在xml中用表达式可以获取数据，那么同样的，在代码中也可以设置数据，如这里的：binding.setUser(user)，还可以使用inflate的方式来获取生成数据绑定类：

KOTLIN

val binding: ActivityMainBinding = ActivityMainBinding.inflate(getLayoutInflater())

JAVA

MainActivityBinding binding = MainActivityBinding.inflate(getLayoutInflater());

如果是在一个adapter中来使用，例如Fragment, ListView, or RecyclerView 内部的adapter，

你可能倾向于使用bindings类的inflate()方法或者DataBindingUtil类，如下样例代码所示：

KOTLIN

val listItemBinding = ListItemBinding.inflate(layoutInflater, viewGroup, false)
// or
val listItemBinding = DataBindingUtil.inflate(layoutInflater, R.layout.list_item, viewGroup, false)

JAVA

ListItemBinding binding = ListItemBinding.inflate(layoutInflater, viewGroup, false);
//or
ListItemBinding binding = DataBindingUtil.inflate(layoutInflater, R.layout.list_item, viewGroup, false);

1.3 表达式语言

1.3.1 共同的特征

表达式语言看起来很像Java表达式。如下这些都是相同的：

Mathematical + - / * %
String concatenation +
Logical && ||
Binary & | ^
Unary + - ! ~
Shift >> >>> <<
Comparison == > < >= <=
instanceof
Grouping ()
Literals - character, String, numeric, null
Cast
Method calls
Field access
Array access []
Ternary operator ?:

例：

android:text="@{String.valueOf(index + 1)}"
android:visibility="@{age < 13 ? View.GONE : View.VISIBLE}"
android:transitionName='@{"image_" + id}'

1.3.2 不支持的操作符

this、new、super 如这些，还是只能在java类中使用

1.3.3 合并null操作符

如下使用 “??” 操作符

android:text="@{user.displayName ?? user.lastName}"

等价于

android:text="@{user.displayName != null ? user.displayName : user.lastName}"

1.3.4 属性引用

表达式可以通过如下格式引用一个类的属性，字段，getters，和ObservableField对象与此相同，如下，user有getLastName()，可以简单引用：

android:text="@{user.lastName}"

1.3.5 NullPointerException处理

数据绑定代码会自动检查null值，避免NullPointerException。例如String类型默认为null， Int类型默认0.

1.3.6 集合

一般的集合都可以使用”[]”操作符： arrays, lists, sparse lists, and maps。例

<data>
    <import type="android.util.SparseArray"/>
    <import type="java.util.Map"/>
    <import type="java.util.List"/>
    <variable name="list" type="List"/>
    <variable name="sparse" type="SparseArray"/>
    <variable name="map" type="Map"/>
    <variable name="index" type="int"/>
    <variable name="key" type="String"/>
</data>
…
android:text="@{list[index]}"
…
android:text="@{sparse[index]}"
…
android:text="@{map[key]}"

1.3.7 字符串常量引用

如下，可以使用单引号在属性值上，用双引号在字符串字面值上：

android:text='@{map["firstName"]}'

也可以反过来

android:text="@{map[`firstName`}"
android:text="@{map['firstName']}"

1.3.8 资源

可以使用正常的访问资源的表达式语法：

android:padding="@{large? @dimen/largePadding : @dimen/smallPadding}"

可以为格式字符串和复数提供参数：

android:text="@{@string/nameFormat(firstName, lastName)}"
android:text="@{@plurals/banana(bananaCount)}"

一些资源需要显示的引用

Type	Normal reference	Expression reference
String[]	@array	@stringArray
int[]	@array	@intArray
TypedArray	@array	@typedArray
Animator	@animator	@animator
StateListAnimator	@animator	@stateListAnimator
color int	@color	@color
ColorStateList	@color	@colorStateList

2. 事件处理

数据绑定允许您编写处理从视图中分发的事件的表达式（例如，onClick()方法）。事件属性名称由侦听器方法的名称来确定，但有少数例外。例如，View.OnClickListener有一个方法onClick()，所以这个事件的属性是android:onClick。

有一些用于click事件的专用事件处理程序，它们需要除android:onClick之外的属性以避免冲突。可以使用以下属性来避免这些类型的冲突：

Class	Listener setter	Attribute
SearchView	setOnSearchClickListener(View.OnClickListener)	android:onSearchClick
ZoomControls	setOnZoomInClickListener(View.OnClickListener)	android:onZoomIn
ZoomControls	setOnZoomOutClickListener(View.OnClickListener)	android:onZoomOut

您可以使用以下机制来处理事件：

• 方法引用：在表达式中，可以引用符合侦听器方法签名的方法。当表达式计算为方法引用时，数据绑定将侦听器中的方法引用和所有者对象封装起来，并将该侦听器设置在目标视图上。如果表达式计算为NULL，则数据绑定不创建侦听器，并设置空侦听器。

• 侦听器绑定：这些lambda表达式是在事件发生时被计算的。数据绑定总是创建一个监听器，监听器设置在视图上。当事件被分发时，侦听器调用lambda表达式。

2.1 方法引用

比如定义一个符合OnClickListener#onClick(View view)方法参数签名规则的方法：

public class MyHandlers {
    public void onClickFriend(View view) { ... }
}

如下在xml中绑定并使用：

<layout xmlns:android="http://schemas.android.com/apk/res/android">
   <data>
       <variable name="handlers" type="com.example.Handlers"/>
       <variable name="user" type="com.example.User"/>
   data>
   <LinearLayout
       android:orientation="vertical"
       android:layout_width="match_parent"
       android:layout_height="match_parent">
       <TextView android:layout_width="wrap_content"
           android:layout_height="wrap_content"
           android:text="@{user.firstName}"
           android:onClick="@{handlers::onClickFriend}"/>
   LinearLayout>
layout>

2.2 监听器绑定

表达式使用的方法就可以定义的比较随意了，不用像”方法引用”那样遵循特定规则，如一个方法

public class Presenter {
    public void onSaveClick(Task task){}
}

xml中使用它

  <layout xmlns:android="http://schemas.android.com/apk/res/android">
      <data>
          <variable name="task" type="com.android.example.Task" />
          <variable name="presenter" type="com.android.example.Presenter" />
      data>
      <LinearLayout android:layout_width="match_parent" android:layout_height="match_parent">
          <Button android:layout_width="wrap_content" android:layout_height="wrap_content"
          android:onClick="@{() -> presenter.onSaveClick(task)}" />
      LinearLayout>
  layout>

像上面，我们并没有定义onClick(android.view.View) 参数view。监听器绑定，允许我们忽略所有的参数。如果想要使用参数，可以忽略参数类型，随意定义一个名字。监听器绑定还有很多灵活的写法，可以参考官方文档。

3. 导入、变量和包含

数据绑定库提供了诸如导入、变量和包含的特征。导入使布局文件中的类易于引用。变量允许您描述可以在绑定表达式中使用的属性。包括让您重用应用程序中的复杂布局。

3.1 导入

导入允许您轻松地在布局文件中引用类，就像托管代码一样。可以在数据元素内部使用零个或多个导入元素。下面的代码示例将View类导入布局文件：

<data>
    <import type="android.view.View"/>
data>

导入View类允许您从绑定表达式中引用它。下面的示例演示如何引用View类的VISIBLE 和 GONE常量：

"@{user.lastName}"
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"
   android:visibility="@{user.isAdult ? View.VISIBLE : View.GONE}"/>

类型重命名

当类名过长或者有类名称冲突，其中一个类可以重命名一个别名

type="com.grandstream.gsmarket.R.string" alias="Strings"/>

type="android.view.View"/>
type="com.example.real.estate.View"
        alias="EsView"/>

其他类引用

导入类型可以用作变量和表达式中的类型引用。下面的示例显示用户和列表作为变量的类型：

<data>
    <import type="com.example.User"/>
    <import type="java.util.List"/>
    <variable name="user" type="User"/>
    <variable name="userList" type="List"/>
</data>

警告：Android Studio尚不支持自动补全imports，因此变量导入的自动补全在IDE中可能无法工作。您的应用程序仍然可以编译，并且可以通过在变量定义中使用完全限定名来解决IDE问题。

还可以使用强制类型转换作为表达式的一部分。下面的示例将连接属性强制转换为用户类型：

<TextView
   android:text="@{((User)(user.connection)).lastName}"
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"/>

静态类引用

也可以在表达式中运用静态属性或方法，使用MyStringUtils.capitalize()：

<data>
    <import type="com.example.MyStringUtils"/>
    <variable name="user" type="com.example.User"/>
</data>
…
<TextView
   android:text="@{MyStringUtils.capitalize(user.lastName)}"
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"/>

正如托管代码一样，Java.Lang.*是自动导入的。

示例代码

<layout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    >
    <data>

        <variable
            name="viewmodel"
            type="com.grandstream.gsmarket.appdetail.AppDetailItemViewModel" />

        <import type="android.view.View"/>

        <import type="com.grandstream.gsmarket.R.string" alias="Strings"/>
    data>

<LinearLayout
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:orientation="vertical">
    <android.support.v7.widget.AppCompatTextView
                        android:id="@+id/download_count_text"
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content"
                        android:layout_marginLeft="15dp"
                        android:singleLine="true"
                        android:textColor="#999999"
                        android:textSize="36px"
                        android:text='@{viewmodel.getContext().getString(Strings.download) + viewmodel.downloadCount}'/>
                LinearLayout>

3.2Variables

可以在数据元素内部使用多个变量元素。每个变量元素描述了可以在布局上设置的属性，用于布局文件中的表达式的绑定。下面的示例声明user, image, 和 note变量：

<data>
    <import type="android.graphics.drawable.Drawable"/>
    <variable name="user" type="com.example.User"/>
    <variable name="image" type="Drawable"/>
    <variable name="note" type="String"/>
</data>

这些variable变量在编译时会进行类型检查，如果一个variable实现了Observable接口或是一个Observable的collection，那就需要在type中声明；如果不是一个Observable的实现，那么该variable就不会被观察到.

当对于各种配置（例如，横向或纵向）存在不同的布局文件时，将组合这些变量。在这些布局文件之间不存在冲突的变量定义。

所生成的绑定类对于所描述的变量中的每一个都具有setter和getter。变量采用默认托管代码值（null作为引用类型，0作为int，false作为boolean等等），直到setter被调用。

生成一个名为context的特殊变量，以便根据需要在绑定表达式中使用。context的值是从根视图的getContext()方法中的Context对象。context变量由具有该名称的显式变量声明重写。

<data>

        <import type="android.view.View" />

        <variable
            name="view"
            type="com.grandstream.gsmarket.apps.ApkListFragment" />

        <variable
            name="viewmodel"
            type="com.grandstream.gsmarket.apps.AppsViewModel" />

    </data>

3.3 include

variables可以传递给使用了include标签的子布局中，如

<layout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:bind="http://schemas.android.com/apk/res-auto">
   <data>
       <variable name="user" type="com.example.User"/>
   data>
   <LinearLayout
       android:orientation="vertical"
       android:layout_width="match_parent"
       android:layout_height="match_parent">
       <include layout="@layout/name"
           bind:user="@{user}"/>
       <include layout="@layout/contact"
           bind:user="@{user}"/>
   LinearLayout>
layout>

如上，在name.xml和contract.xml中都可以使用变量user了

不支持在merge下直接使用include的情形。

4. 可观察数据对象

可观测性是指对象能够通知他人其数据变化的能力。数据绑定库允许您使对象、字段或集合可观察。

任何POJO对象都可以用于数据绑定，但是更改POJO对象，并不会引起UI更新。有三种不同的数据更改通知机制：观察对象，观察字段和观察集合。当其中一个绑定到用户界面的可观察的数据对象，观察到数据对象的属性变化，用户界面将自动更新。

4.1 可观察对象(Observable Objects)

类实现 Observable接口可以实现被观察，将被允许附加一个listener，来监听对象所有属性的改变

Observable interface有一个机制来添加和删除listeners，但需要通知开发者。为了让开发变得更容易，提供一个基类，BaseObservable，它实现创建listener的注册机制。当属性数据改变时，数据类实现者需要响应通知。这是通过在getter上使用一个注解@Bindable，并在setter中调用notifyPropertyChanged()进行通知。

KOTLIN

class User : BaseObservable() {

    @get:Bindable
    var firstName: String = ""
        set(value) {
            field = value
            notifyPropertyChanged(BR.firstName)
        }

    @get:Bindable
    var lastName: String = ""
        set(value) {
            field = value
            notifyPropertyChanged(BR.lastName)
        }
}

JAVA

private static class User extends BaseObservable {
   private String firstName;
   private String lastName;
   @Bindable
   public String getFirstName() {
       return this.firstName;
   }
   @Bindable
   public String getLastName() {
       return this.lastName;
   }
   public void setFirstName(String firstName) {
       this.firstName = firstName;
       notifyPropertyChanged(BR.firstName);
   }
   public void setLastName(String lastName) {
       this.lastName = lastName;
       notifyPropertyChanged(BR.lastName);
   }
}

@Bindable 在编译时将生成一个BR class，包含了数据绑定使用的资源IDs ，BR类文件将生成在moudle的package下。如果数据类的基类不能被改变，Observable interface的实现类可以使用PropertyChangeRegistry存储和有效地通知listeners。

4.2 可观察属性(ObservableFields)

如果想做比创建上面的观察对象更少的工作，那么可以使用ObservableField 和它的同级的一些类型：
ObservableBoolean,
ObservableByte,
ObservableChar,
ObservableShort,
ObservableInt,
ObservableLong,
ObservableFloat,
ObservableDouble, and
ObservableParcelable。

它们都是一个包含单一属性的可观察的对象。为避免装箱、拆箱操作，可以在数据类中定义成 public final field …

KOTLIN

class User {
    val firstName = ObservableField()
    val lastName = ObservableField()
    val age = ObservableInt()
}

JAVA

private static class User {
   public final ObservableField firstName =
       new ObservableField<>();
   public final ObservableField lastName =
       new ObservableField<>();
   public final ObservableInt age = new ObservableInt();
}

如下，使用get或set来获取和设置属性值：

KOTLIN

user.firstName = "Google"
val age = user.age

JAVA

user.firstName.set("Google");
int age = user.age.get();

注意：Android Studio 3.1和更高版本允许您用LiveData对象替换可观察字段，这对您的应用程序提供了额外的好处。有关更多信息，请参见Use LiveData to notify the UI about data changes。

4.3 可观察集合(Observable Collections)

一些应用程序使用更多的动态结构来保存数据。可观察集合允许通过key访问这些数据对象。当key是一个引用类型，如String，就可以用ObservableArrayMap。

KOTLIN

ObservableArrayMap().apply {
    put("firstName", "Google")
    put("lastName", "Inc.")
    put("age", 17)
}

JAVA

ObservableArrayMap<String, Object> user = new ObservableArrayMap<>();
user.put("firstName", "Google");
user.put("lastName", "Inc.");
user.put("age", 17);

在下面的布局中，就可以通过String类型的key来访问map中的数据：

<data>
    <import type="android.databinding.ObservableMap"/>
    <variable name="user" type="ObservableMap"/>
data>
…
<TextView
    android:text="@{user.lastName}"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"/>
<TextView
    android:text="@{String.valueOf(1 + (Integer)user.age)}"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"/>

当key是一个Integer时，可用ObservableArrayList：

KOTLIN

ObservableArrayList().apply {
    add("Google")
    add("Inc.")
    add(17)
}

JAVA

ObservableArrayList