Android DataBing详解

最新推荐文章于 2024-09-26 22:02:29 发布
最新推荐文章于 2024-09-26 22:02:29 发布
阅读量2.9w 收藏 36
点赞数 7
分类专栏： Android
转载于http://blog.csdn.net/qdjdeveloper/article/details/62236309

       前几天小试牛刀写了一篇 Android DataBinding 初探，只是简单的介绍了一下 DataBinding 的几个小问题，并没有特别详细的去介绍 DataBinding 的更多方法，这几天看了一下 DataBinding 的官网的相关内容，觉得有必要把官网的用法记录一下，用来参考及以后使用时的参考，以前大家很多人都使用过注解框架，包括 Jake Wharton 大神的 ButterKnife，但 DataBinding 出来后，相信会对此类的框架形成碾压，毕竟是 Google 的官方出品，接下来我们切入正题了，开始详细的去介绍这个 Android DataBinding Library，先上一张概况图：


一、构建环境(Build Environment)

  • 要使用 DataBinding 数据库，先从 Android SDK Manager 的支持库里下载该库
  • 配置你的应用程序使用数据绑定，在应用程序模块，你的 build.gradle 文件添加数据绑定元素
  • 另外，需要注意你使用的 Android Studio 的兼容版本，需要 1.3 及以上的版本
使用下面代码段来配置数据绑定：
[java] view plain copy
print ?
  1. android {  
  2.     ….  
  3.     dataBinding {  
  4.         enabled = true  
  5.     }  
  6. }  
android {
    ....
    dataBinding {
        enabled = true
    }
}
二、数据绑定布局文件(Data Binding Layout Files)

1) DataBinding 表达式

数据绑定的布局文件和我们以前经常写的布局文件稍有不同，并从布局的根标记开始，后面依次是数据元素和视图根元素，即根布局是 layout，接下来是 data 节点，variable 节点，示例如下：

[html] view plain copy
print ?
  1. <?xml version=“1.0” encoding=“utf-8”?>  
  2. <layout xmlns:android=“http://schemas.android.com/apk/res/android”>  
  3.    <data>  
  4.        <variable name=“user” type=“com.example.User”/>  
  5.    </data>  
  6.    <LinearLayout  
  7.        android:orientation=“vertical”  
  8.        android:layout_width=“match_parent”  
  9.        android:layout_height=“match_parent”>  
  10.        <TextView android:layout_width=“wrap_content”  
  11.            android:layout_height=“wrap_content”  
  12.            android:text=“@{user.firstName}”/>  
  13.        <TextView android:layout_width=“wrap_content”  
  14.            android:layout_height=“wrap_content”  
  15.            android:text=“@{user.lastName}”/>  
  16.    </LinearLayout>  
  17. </layout>  
<?xml version="1.0" encoding="utf-8"?>
<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>
数据中的用户变量描述此布局中可能使用的属性：

[html] view plain copy
print ?
  1. <variable name=“user” type=“com.example.User”/>  
<variable name="user" type="com.example.User"/>
布局中的表达式使用 “@{}” 语法在属性中写入，在这里，TextView 的文本设置为用户 FirstName 属性：

[html] view plain copy
print ?
  1. <span style=“color:#666666;”><TextView android:layout_width=“wrap_content”  
  2.           android:layout_height=“wrap_content”  
  3.           android:text=“@{user.firstName}”/></span>  
<TextView android:layout_width="wrap_content"
          android:layout_height="wrap_content"
          android:text="@{user.firstName}"/>
2)数据对象(Data Object)

假设你现在有一个普通的 Java 对象(User):

[java] view plain copy
print ?
  1. public class User {  
  2.    public final String firstName;  
  3.    public final String lastName;  
  4.    public User(String firstName, String lastName) {  
  5.        this.firstName = firstName;  
  6.        this.lastName = lastName;  
  7.    }  
  8. }  
public class User {
   public final String firstName;
   public final String lastName;
   public User(String firstName, String lastName) {
       this.firstName = firstName;
       this.lastName = lastName;
   }
}

这种类型的对象具有从不改变的数据，应用程序中国通常有一次读取数据，此后不会更改，也可以使用 JavaBeans 对象：

[java] view plain copy
print ?
  1. public class User {  
  2.    private final String firstName;  
  3.    private final String lastName;  
  4.    public User(String firstName, String lastName) {  
  5.        this.firstName = firstName;  
  6.        this.lastName = lastName;  
  7.    }  
  8.    public String getFirstName() {  
  9.        return this.firstName;  
  10.    }  
  11.    public String getLastName() {  
  12.        return this.lastName;  
  13.    }  
  14. }  
public class User {
   private final String firstName;
   private final String lastName;
   public User(String firstName, String lastName) {
       this.firstName = firstName;
       this.lastName = lastName;
   }
   public String getFirstName() {
       return this.firstName;
   }
   public String getLastName() {
       return this.lastName;
   }
}
从数据绑定的角度来看，这两个类是等价的，用于 TextView 中的 android:text 属性的表达式 @{user.firstName} 将访问前者 User 对象中的 firstName 和后者 JavaBeans 对象中的 getFirstName 方法

3）数据绑定(Binding Data)

默认情况下，绑定类将根据 layout 文件的名称生成，首字母大写的命名规范，并添加 “Binding” 后缀，上述的布局文件是main_activity.xml，所以生成类是 MainActivityBinding, 该类将布局属性(例如 User 变量)的所有绑定保存到布局视图中，并知道如何为绑定表达式赋值，创建最简单的方法是在 inflating 时绑定，如下:

[java] view plain copy
print ?
  1. @Override  
  2. protected void onCreate(Bundle savedInstanceState) {  
  3.    super.onCreate(savedInstanceState);  
  4.    MainActivityBinding binding = DataBindingUtil.setContentView(this, R.layout.main_activity);  
  5.    User user = new User(“Test”, “User”);  
  6.    binding.setUser(user);  
  7. }  
@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);
}
就这样，运行应用程序，你将会在 UI 中看到 Test User，或者你可以通过如下获取 View:

[java] view plain copy
print ?
  1. MainActivityBinding binding = MainActivityBinding.inflate(getLayoutInflater());  
MainActivityBinding binding = MainActivityBinding.inflate(getLayoutInflater());
如果你是在 ListView 或者 RecyclerView adapter 中使用 Data Binding 时，你可能使用：

[java] view plain copy
print ?
  1. ListItemBinding binding = ListItemBinding.inflate(layoutInflater, viewGroup, false);  
  2. //or  
  3. ListItemBinding binding = DataBindingUtil.inflate(layoutInflater, R.layout.list_item, viewGroup, false);  
ListItemBinding binding = ListItemBinding.inflate(layoutInflater, viewGroup, false);
//or
ListItemBinding binding = DataBindingUtil.inflate(layoutInflater, R.layout.list_item, viewGroup, false);
4）事件处理(Event Handing)

数据绑定允许你编写表达式处理，如 onClick 事件，有少数例外事件属性的名称受监听方法名称的约束，例如View.OnLongClickListener 有一个 onLongClick 方法，所以此事件的属性是：Android:onLongClick，它有两种处理事件的方法：

  • 方法引用：在表达式中，可以引用符合监听方法签名的方法，当表达式计算为方法引用时，数据绑定将监听器中的方法引用和所有者对象封装在一起，并在目标视图上设置监听器，如果表达式计算为 null，则数据绑定不会创建监听器，而是设置空监听器
  • 监听器绑定：这些是在事件发生时计算 Lambda 表达式，数据绑定总是创建一个监听器，它设置在视图上，当事件被发送时，监听器计算 Lambda 表达式

 方法引用：事件可以直接绑定到处理程序的方法，类似于 Android:onClick，相比来看 View#onClick 属性更重要的优势是，表达式在编译的时候处理的，所以如果方法不存在或签名是不正确的，你将会在编译时出错，方法引用和监听器绑定之间的主要区别是，当数据绑定时，实际的监听器实现将创建，而不是在触发时，如果你希望事件发生时对表达式进行审核，则应该使用监听器绑定，若将事件分配给其处理程序，请使用常规绑定表达式，该值是要调用的方法名，例如，如果你的数据对象有两种方法：

[java] view plain copy
print ?
  1. public class MyHandlers {  
  2.     public void onClickFriend(View view) { … }  
  3. }  
public class MyHandlers {
    public void onClickFriend(View view) { ... }
}
绑定表达式可以为视图分配单击监听器：

注意表达式中的方法的签名必须与监听对象中的方法的签名完全匹配

[html] view plain copy
print ?
  1. <?xml version=“1.0” encoding=“utf-8”?>  
  2. <layout xmlns:android=“http://schemas.android.com/apk/res/android”>  
  3.    <data>  
  4.        <variable name=“handlers” type=“com.example.Handlers”/>  
  5.        <variable name=“user” type=“com.example.User”/>  
  6.    </data>  
  7.    <LinearLayout  
  8.        android:orientation=“vertical”  
  9.        android:layout_width=“match_parent”  
  10.        android:layout_height=“match_parent”>  
  11.        <TextView android:layout_width=“wrap_content”  
  12.            android:layout_height=“wrap_content”  
  13.            android:text=“@{user.firstName}”  
  14.            android:onClick=“@{handlers::onClickFriend}”/>  
  15.    </LinearLayout>  
  16. </layout>  
<?xml version="1.0" encoding="utf-8"?>
<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>


监听器绑定：监听器绑定是在事件发生运行时的绑定表达式，它类似于方法引用，但它容许你运行任意的数据绑定表达式，需要注意的是此功能在 Android Gradle2.0 及以上版本可用，在方法引用中，该方法的参数必须与事件监听器的参数相匹配，在监听器绑定中，只有返回值必须与监听器的期望返回值相匹配，示例如下：

[java] view plain copy
print ?
  1. public class Presenter {  
  2.     public void onSaveClick(Task task){}  
  3. }  
public class Presenter {
    public void onSaveClick(Task task){}
}
然后你可以在你的 xml 文件中将点击事件绑定如下：

[html] view plain copy
print ?
  1. <?xml version=“1.0” encoding=“utf-8”?>  
  2. <layout xmlns:android=“http://schemas.android.com/apk/res/android”>  
  3.     <data>  
  4.         <variable name=“task” type=“com.android.example.Task” />  
  5.         <variable name=“presenter” type=“com.android.example.Presenter” />  
  6.     </data>  
  7.     <LinearLayout android:layout_width=“match_parent” android:layout_height=“match_parent”>  
  8.         <Button android:layout_width=“wrap_content” android:layout_height=“wrap_content”  
  9.         android:onClick=“@{() -> presenter.onSaveClick(task)}” />  
  10.     </LinearLayout>  
  11. </layout>  
  <?xml version="1.0" encoding="utf-8"?>
  <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>

监听器由 Lambda 表达式表示，这些表达式只允许作为表达式的根元素，当表达中使用回调时，数据绑定会自动创建时间的必要监听器和寄存器，当视图触发事件时，数据绑定将审核给定的表达式，与常规绑定方式一样，在审核这些监听器表达式时，任然可以得到数据绑定的 null 和线程安全性

请注意，在上面的例子中，我们还没有定义 View 的参数，通过 onClick(Android.view.View)Listener 绑定为监听器参数提供两种选择：你可以忽略所有方法参数或命名所有参数，如果你更喜欢命名参数，则也可以在表达式中使用它们，例如，上面的表达式可以写成：

[html] view plain copy
print ?
  1. android:onClick=“@{(view) -> presenter.onSaveClick(task)}”  
android:onClick="@{(view) -> presenter.onSaveClick(task)}"
或者如果你想使用表达式中的参数，它可以写成如下：

[java] view plain copy
print ?
  1. public class Presenter {  
  2.     public void onSaveClick(View view, Task task){}  
  3. }  
public class Presenter {
    public void onSaveClick(View view, Task task){}
}

[html] view plain copy
print ?
  1. android:onClick=“@{(theView) -> presenter.onSaveClick(theView, task)}”  
android:onClick="@{(theView) -> presenter.onSaveClick(theView, task)}"
可以使用多个参数的 Lambda 表达式：

[java] view plain copy
print ?
  1. public class Presenter {  
  2.     public void onCompletedChanged(Task task, boolean completed){}  
  3. }  
public class Presenter {
    public void onCompletedChanged(Task task, boolean completed){}
}
[html] view plain copy
print ?
  1. <CheckBox android:layout_width=“wrap_content” android:layout_height=“wrap_content”  
  2.         android:onCheckedChanged=“@{(cb, isChecked) -> presenter.completeChanged(task, isChecked)}” />  
<CheckBox android:layout_width="wrap_content" android:layout_height="wrap_content"
        android:onCheckedChanged="@{(cb, isChecked) -> presenter.completeChanged(task, isChecked)}" />
如果监听的事件返回类型无效的值，则表达式必须返回相同类型的值。例如，如果要监听长点击事件，则表达式应返回布尔值：

[java] view plain copy
print ?
  1. public class Presenter {  
  2.     public boolean onLongClick(View view, Task task){}  
  3. }  
public class Presenter {
    public boolean onLongClick(View view, Task task){}
}

[html] view plain copy
print ?
  1. android:onLongClick=“@{(theView) -> presenter.onLongClick(theView, task)}”  
android:onLongClick="@{(theView) -> presenter.onLongClick(theView, task)}"
你还可以使用三元表达式：

[html] view plain copy
print ?
  1. android:onClick=“@{(v) -> v.isVisible() ? doSomething() : void}”  
android:onClick="@{(v) -> v.isVisible() ? doSomething() : void}"
避免复杂的监听：
监听器表达式是非常强大的，可以使你的代码很容易阅读。另一方面，含有复杂的表达式的监听让你的布局难以阅读和维护。这些表达式应该是简单的，从用户界面传递可用数据到回调方法。您可以在从监听器表达式调用的回调方法中实现任何业务逻辑


三、布局细节(Layout Details)

1)imports

可以在数据元素内使用零个或多个导入元素。这些可以参考在你的布局文件的类，就像在 java:

[html] view plain copy
print ?
  1. <data>  
  2.     <import type=“android.view.View”/>  
  3. </data>  
<data>
    <import type="android.view.View"/>
</data>

现在，视图可以在绑定表达式中使用：

[html] view plain copy
print ?
  1. <TextView  
  2.    android:text=“@{user.lastName}”  
  3.    android:layout_width=“wrap_content”  
  4.    android:layout_height=“wrap_content”  
  5.    android:visibility=“@{user.isAdult ? View.VISIBLE : View.GONE}”/>  
<TextView
   android:text="@{user.lastName}"
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"
   android:visibility="@{user.isAdult ? View.VISIBLE : View.GONE}"/>
当有类名冲突时，其中一个类可以重命名为“alias:”,如下：

[html] view plain copy
print ?
  1. <import type=“android.view.View”/>  
  2. <import type=“com.example.real.estate.View”  
  3.         alias=“Vista”/>  
<import type="android.view.View"/>
<import type="com.example.real.estate.View"
        alias="Vista"/>
现在，Vista 可以用来参考的 com.example.real.estate.view 和视图可以用来参考 android.view.view 在布局文件中，导入类型可以用作变量和表达式中的类型引用：

[html] view plain copy
print ?
  1. <data>  
  2.     <import type=“com.example.User”/>  
  3.     <import type=“java.util.List”/>  
  4.     <variable name=“user” type=“User”/>  
  5.     <variable name=“userList” type=“List<User>”/>  
  6. </data>  
<data>
    <import type="com.example.User"/>
    <import type="java.util.List"/>
    <variable name="user" type="User"/>
    <variable name="userList" type="List<User>"/>
</data>
注意：Android Studio 还不能很好的兼容支持，变量可能不能在 IDE 中完成自动提示功能。但是你的应用程序将仍然可以编译，你可以通过使用完全限定名称来定义变量解决 IDE 的问题：

[html] view plain copy
print ?
  1. <TextView  
  2.    android:text=“@{((User)(user.connection)).lastName}”  
  3.    android:layout_width=“wrap_content”  
  4.    android:layout_height=“wrap_content”/>  
<TextView
   android:text="@{((User)(user.connection)).lastName}"
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"/>
在表达式中引用静态字段和方法时也可以使用导入类型：

[html] view plain copy
print ?
  1. <data>  
  2.     <import type=“com.example.MyStringUtils”/>  
  3.     <variable name=“user” type=“com.example.User”/>  
  4. </data>  
  5. …  
  6. <TextView  
  7.    android:text=“@{MyStringUtils.capitalize(user.lastName)}”  
  8.    android:layout_width=“wrap_content”  
  9.    android:layout_height=“wrap_content”/>  
<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 语言，java * 自动导入

2）Variables

可以在数据元素内使用任意数量的变量元素。每个变量元素描述可以在布局文件中用于绑定表达式中的布局的属性:

[html] view plain copy
print ?
  1. <data>  
  2.     <import type=“android.graphics.drawable.Drawable”/>  
  3.     <variable name=“user”  type=“com.example.User”/>  
  4.     <variable name=“image” type=“Drawable”/>  
  5.     <variable name=“note”  type=“String”/>  
  6. </data>  
<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>

在编译时检查变量类型，因此，如果变量实现 Observable 或 Observable 的集合，则该类型应反映在类型中。如果变量是不执行 Observable* 接口的基类或接口，则不会观察变量,当有不同的布局文件的各种配置（如头像），变量将被合并。这些布局文件之间不能有冲突的变量定义生成一个名为上下文的特殊变量，用于在需要时绑定表达式。上下文的值是根目录的 getcontext()，上下文变量将被一个显式变量声明所覆盖

3）自定义绑定类名(Custom Binding Class Names)

默认情况下，绑定类是基于布局的文件名生成，开始用大写，去掉下划线 “_”，然后加后缀 “Binding”，这个类将会被放置在一个绑定包的模块包下，例如，布局文件是 contant_item.xml 将生成 ContactItemBinding，如果模块封装为 com.example.my.app，那么它将被放置在 com.example.my.app.databinding

通过调整数据元素的类属性可以将绑定类重命名或放置在不同的包中。例如:

[html] view plain copy
print ?
  1. <data class=“ContactItem”>  
  2.     …  
  3. </data>  
<data class="ContactItem">
    ...
</data>
这个生成绑定类中的模块封装在数据绑定包 ContactItem，如果类产生在不同的包中的模块封装内，它可能会加 “.”，如下：

[html] view plain copy
print ?
  1. <data class=“.ContactItem”>  
  2.     …  
  3. </data>  
<data class=".ContactItem">
    ...
</data>
在这种情况下，ContactItem 直接在模块封装生成，如果提供完整的包，任何包可以使用：

[html] view plain copy
print ?
  1. <data class=“com.example.ContactItem”>  
  2.     …  
  3. </data>  
<data class="com.example.ContactItem">
    ...
</data>
4）Includes

通过使用应用程序命名空间和属性中的变量名，可以将变量从包含布局中传递到包含布局中：

[html] view plain copy
print ?
  1. <?xml version=“1.0” encoding=“utf-8”?>  
  2. <layout xmlns:android=“http://schemas.android.com/apk/res/android”  
  3.         xmlns:bind=“http://schemas.android.com/apk/res-auto”>  
  4.    <data>  
  5.        <variable name=“user” type=“com.example.User”/>  
  6.    </data>  
  7.    <LinearLayout  
  8.        android:orientation=“vertical”  
  9.        android:layout_width=“match_parent”  
  10.        android:layout_height=“match_parent”>  
  11.        <include layout=“@layout/name”  
  12.            bind:user=“@{user}”/>  
  13.        <include layout=“@layout/contact”  
  14.            bind:user=“@{user}”/>  
  15.    </LinearLayout>  
  16. </layout>  
<?xml version="1.0" encoding="utf-8"?>
<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 和 contact.xml 布局文件的用户变量

数据绑定不支持包括合并元素的直接子项。例如，不支持下列布局：

[html] view plain copy
print ?
  1. <?xml version=“1.0” encoding=“utf-8”?>  
  2. <layout xmlns:android=“http://schemas.android.com/apk/res/android”  
  3.         xmlns:bind=“http://schemas.android.com/apk/res-auto”>  
  4.    <data>  
  5.        <variable name=“user” type=“com.example.User”/>  
  6.    </data>  
  7.    <merge>  
  8.        <include layout=“@layout/name”  
  9.            bind:user=“@{user}”/>  
  10.        <include layout=“@layout/contact”  
  11.            bind:user=“@{user}”/>  
  12.    </merge>  
  13. </layout>  
<?xml version="1.0" encoding="utf-8"?>
<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>
   <merge>
       <include layout="@layout/name"
           bind:user="@{user}"/>
       <include layout="@layout/contact"
           bind:user="@{user}"/>
   </merge>
</layout>

5）表达式(Expression Language)

常用表达式给 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(三元运算) “?:“
示例如下：
[html] view plain copy
print ?
  1. android:text=“@{String.valueOf(index + 1)}”  
  2. android:visibility=“@{age < 13 ? View.GONE : View.VISIBLE}”  
  3. android:transitionName=‘@{“image_” + id}’  
android:text="@{String.valueOf(index + 1)}"
android:visibility="@{age < 13 ? View.GONE : View.VISIBLE}"
android:transitionName='@{"image_" + id}'

缺少的操作：
  • this
  • super
  • new
  • Explicit generic invocation
null 合并运算符：

null 合并运算符(??)左边不为 null 或正确，则返回左边，否则返回右边，如下：
[html] view plain copy
print ?
  1. android:text=“@{user.displayName ?? user.lastName}”  
android:text="@{user.displayName ?? user.lastName}"
在功能上和如下相同：
[html] view plain copy
print ?
  1. android:text=“@{user.displayName != null ? user.displayName : user.lastName}”  
android:text="@{user.displayName != null ? user.displayName : user.lastName}"

属性引用：

第一个前边已经提到了，DataBinding 表达式：JavaBean 引用的简短格式
当一个表达式引用一个类的属性，它仍使用同样的格式对于字段、getters 以及 ObservableFields
[html] view plain copy
print ?
  1. android:text=“@{user.lastName}”  
android:text="@{user.lastName}"
避免空指针(Avoiding NullPointerException)
Data Binding 代码生成时会自动检查是否为 null，来避免出现 null pointer exception 错误，例如在表达式 @{user.name} 中，如果 user 是 null，user.name 会赋予它的默认值 null，如果你引用 @{user.age}，age 是 int 类型，那么它的默认值是 0

集合：

常见的集合：数组，列表，稀疏列表和 maps，可以访问使用 [ ] 运算符
[html] view plain copy
print ?
  1. <data>  
  2.     <import type=“android.util.SparseArray”/>  
  3.     <import type=“java.util.Map”/>  
  4.     <import type=“java.util.List”/>  
  5.     <variable name=“list” type=“List<String>”/>  
  6.     <variable name=“sparse” type=“SparseArray<String>”/>  
  7.     <variable name=“map” type=“Map<String, String>”/>  
  8.     <variable name=“index” type=“int”/>  
  9.     <variable name=“key” type=“String”/>  
  10. </data>  
  11. …  
  12. android:text=“@{list[index]}”  
  13. …  
  14. android:text=“@{sparse[index]}”  
  15. …  
  16. android:text=“@{map[key]}”  
<data>
    <import type="android.util.SparseArray"/>
    <import type="java.util.Map"/>
    <import type="java.util.List"/>
    <variable name="list" type="List<String>"/>
    <variable name="sparse" type="SparseArray<String>"/>
    <variable name="map" type="Map<String, String>"/>
    <variable name="index" type="int"/>
    <variable name="key" type="String"/>
</data>
…
android:text="@{list[index]}"
…
android:text="@{sparse[index]}"
…
android:text="@{map[key]}"

字符串常量(String Literals)：

当在属性值周围使用单引号时，表达式中使用双引号：
[html] view plain copy
print ?
  1. android:text=‘@{map[“firstName”]}’  
android:text='@{map["firstName"]}'

使用双引号来包含属性值也可以，字符串前需要使用”`”:
[html] view plain copy
print ?
  1. android:text=“@{map[`firstName`}”  
  2. android:text=“@{map[‘firstName’]}”  
android:text="@{map[`firstName`}"
android:text="@{map['firstName']}"

资源(Resources):

可以使用正常语法的表达式访问资源：
[html] view plain copy
print ?
  1. android:padding=“@{large? @dimen/largePadding : @dimen/smallPadding}”  
android:padding="@{large? @dimen/largePadding : @dimen/smallPadding}"

格式字符串和复数可通过提供参数判断：
[html] view plain copy
print ?
  1. android:text=“@{@string/nameFormat(firstName, lastName)}”  
  2. android:text=“@{@plurals/banana(bananaCount)}”  
android:text="@{@string/nameFormat(firstName, lastName)}"
android:text="@{@plurals/banana(bananaCount)}"

当复数需要多个参数时，所有参数都应通过：
[html] view plain copy
print ?
  1.   Have an orange  
  2.   Have %d oranges  
  3.   
  4. android:text=“@{@plurals/orange(orangeCount, orangeCount)}”  
  Have an orange
  Have %d oranges

android:text="@{@plurals/orange(orangeCount, orangeCount)}"

一些资源需要显示类型判断：


四、数据对象(Data Objects)

任何普通的 java 对象（POJO）可用于数据绑定，但修改一个 POJO 不会造成UI更新。数据绑定的真正能力可以通过给数据对象在数据变化时通知来使用,有三种不同的数据更改通知机制，Observable 对象，ObservableFilelds 字段和 Observable Cllections 集合,当这些可观察数据对象绑定到 UI 和数据对象的属性更改时，用户界面将自动更新

Observable 对象(Observable Objects)
实现 Observable 接口类允许单个监听器连接到绑定对象以监听该对象所有属性的改变

Observable 接口有一个机制来添加和删除监听器，但通知是由开发人员管理,为使开发更容易，一个 BaseObservable 基类是为了实现监听器注册机制而创建。Data 类实现者仍然是负责通知时的性能变化。这是通过分配一个 Bindable 注释 getter 和 setter 进行通知来完成
[java] view plain copy
print ?
  1. private static class User extends BaseObservable {  
  2.    private String firstName;  
  3.    private String lastName;  
  4.    @Bindable  
  5.    public String getFirstName() {  
  6.        return this.firstName;  
  7.    }  
  8.    @Bindable  
  9.    public String getLastName() {  
  10.        return this.lastName;  
  11.    }  
  12.    public void setFirstName(String firstName) {  
  13.        this.firstName = firstName;  
  14.        notifyPropertyChanged(BR.firstName);  
  15.    }  
  16.    public void setLastName(String lastName) {  
  17.        this.lastName = lastName;  
  18.        notifyPropertyChanged(BR.lastName);  
  19.    }  
  20. }  
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 类的文件条目，BR 类文件会在模块包内生成，如果 Data 类的基类不能改变，Observable 接口通过 PropertyChangeRegistry 可以方便的来实现用于存储和有效的通知监听器


Observable 字段（ObservableFields）

一个小工作会涉及到创建 Observable 类，所以开发者们想节省时间或仅有几个特性可以用 observablefield 和它的同类observableboolean，observablebyte，observablechar，observableshort，observableint，observablelong，observablefloat，observabledouble，和observableparcelable。observablefields 完备可观察对象有一个单一的领域。原始版本避免装箱和拆箱过程中访问操作。若要使用，请在数据类中创建 public final 字段：
[java] view plain copy
print ?
  1. private static class User {  
  2.    public final ObservableField<String> firstName =  
  3.        new ObservableField<>();  
  4.    public final ObservableField<String> lastName =  
  5.        new ObservableField<>();  
  6.    public final ObservableInt age = new ObservableInt();  
  7. }  
private static class User {
   public final ObservableField<String> firstName =
       new ObservableField<>();
   public final ObservableField<String> lastName =
       new ObservableField<>();
   public final ObservableInt age = new ObservableInt();
}
是这么回事！访问值，使用设置和获取方法：
[java] view plain copy
print ?
  1. user.firstName.set(“Google”);  
  2. int age = user.age.get();  
user.firstName.set("Google");
int age = user.age.get();

Observable 集合(Observable Clollections)

一些应用程序使用更多的动态结构来保存数据。Observable 集合允许对这些数据对象进行键控访问。ObservableArrayMap 用于键是引用类型，关键是引用类型，比如 String:
[java] view plain copy
print ?
  1. ObservableArrayMap<String, Object> user = new ObservableArrayMap<>();  
  2. user.put(”firstName”, “Google”);  
  3. user.put(”lastName”, “Inc.”);  
  4. user.put(”age”, 17);  
ObservableArrayMap<String, Object> user = new ObservableArrayMap<>();
user.put("firstName", "Google");
user.put("lastName", "Inc.");
user.put("age", 17);

在布局中，map 可以通过字符串键访问：
[html] view plain copy
print ?
  1. <data>  
  2.     <import type=“android.databinding.ObservableMap”/>  
  3.     <variable name=“user” type=“ObservableMap<String, Object>”/>  
  4. </data>  
  5. …  
  6. <TextView  
  7.    android:text=‘@{user[“lastName”]}’  
  8.    android:layout_width=“wrap_content”  
  9.    android:layout_height=“wrap_content”/>  
  10. <TextView  
  11.    android:text=‘@{String.valueOf(1 + (Integer)user[“age”])}’  
  12.    android:layout_width=“wrap_content”  
  13.    android:layout_height=“wrap_content”/>  
<data>
    <import type="android.databinding.ObservableMap"/>
    <variable name="user" type="ObservableMap<String, Object>"/>
</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"/>
ObservableArrayList 用于键是整数：
[java] view plain copy
print ?
  1. ObservableArrayList<Object> user = new ObservableArrayList<>();  
  2. user.add(”Google”);  
  3. user.add(”Inc.”);  
  4. user.add(17);  
ObservableArrayList<Object> user = new ObservableArrayList<>();
user.add("Google");
user.add("Inc.");
user.add(17);
在布局中，可以通过索引访问 List:
[html] view plain copy
print ?
  1. <data>  
  2.     <import type=“android.databinding.ObservableList”/>  
  3.     <import type=“com.example.my.app.Fields”/>  
  4.     <variable name=“user” type=“ObservableList<Object>”/>  
  5. </data>  
  6. …  
  7. <TextView  
  8.    android:text=‘@{user[Fields.LAST_NAME]}’  
  9.    android:layout_width=“wrap_content”  
  10.    android:layout_height=“wrap_content”/>  
  11. <TextView  
  12.    android:text=‘@{String.valueOf(1 + (Integer)user[Fields.AGE])}’  
  13.    android:layout_width=“wrap_content”  
  14.    android:layout_height=“wrap_content”/>  
<data>
    <import type="android.databinding.ObservableList"/>
    <import type="com.example.my.app.Fields"/>
    <variable name="user" type="ObservableList<Object>"/>
</data>
…
<TextView
   android:text='@{user[Fields.LAST_NAME]}'
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"/>
<TextView
   android:text='@{String.valueOf(1 + (Integer)user[Fields.AGE])}'
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"/>

五、Binding 生成(Generated Binding)

生成的 Banging 类将布局 variables 与布局内的 views 连接起来。如前所述，Binding 的名称和包可以自定义。生成的 Binding 类都扩展 ViewDataBinding

创建(Creating)

Binding 应在 inflation 后不久创建，以确保 View 层次结构在绑定到 Views 中的表达式之前不会受到干扰。有几个方法绑定到layout，最常见的是使用静态方法 Binding 类。inflation 方法载入 View 的层次结构并且绑定到它只需要这一步，结合这一步，还有一个更简单的版本，只需要一个 LayoutInflater，或一个 ViewGroup：
[java] view plain copy
print ?
  1. MyLayoutBinding binding = MyLayoutBinding.inflate(layoutInflater);  
  2. MyLayoutBinding binding = MyLayoutBinding.inflate(layoutInflater, viewGroup, false);  
MyLayoutBinding binding = MyLayoutBinding.inflate(layoutInflater);
MyLayoutBinding binding = MyLayoutBinding.inflate(layoutInflater, viewGroup, false);
如果 layout 使用不同的机制 inflate，则可以单独绑定：
[java] view plain copy
print ?
  1. MyLayoutBinding binding = MyLayoutBinding.bind(viewRoot);  
MyLayoutBinding binding = MyLayoutBinding.bind(viewRoot);

有时 Binding 不能事先知道，在这种情况下，可以使用 DataBindingUtil 类来创建 Binding:
[java] view plain copy
print ?
  1. ViewDataBinding binding = DataBindingUtil.inflate(LayoutInflater, layoutId,  
  2.     parent, attachToParent);  
  3. ViewDataBinding binding = DataBindingUtil.bindTo(viewRoot, layoutId);  
ViewDataBinding binding = DataBindingUtil.inflate(LayoutInflater, layoutId,
    parent, attachToParent);
ViewDataBinding binding = DataBindingUtil.bindTo(viewRoot, layoutId);

ID 绑定(Views With IDs)

将在 layout 中使用 ID 生成每个 View 的公共 public final 字段，Binding 在 View 层次结构上执行单个传递，提取带 ID 的Views。这种机制可以比调用 findViewById 更快。例如:
[html] view plain copy
print ?
  1. <layout xmlns:android=“http://schemas.android.com/apk/res/android”>  
  2.    <data>  
  3.        <variable name=“user” type=“com.example.User”/>  
  4.    </data>  
  5.    <LinearLayout  
  6.        android:orientation=“vertical”  
  7.        android:layout_width=“match_parent”  
  8.        android:layout_height=“match_parent”>  
  9.        <TextView android:layout_width=“wrap_content”  
  10.            android:layout_height=“wrap_content”  
  11.            android:text=“@{user.firstName}”  
  12.    android:id=“@+id/firstName”/>  
  13.        <TextView android:layout_width=“wrap_content”  
  14.            android:layout_height=“wrap_content”  
  15.            android:text=“@{user.lastName}”  
  16.   android:id=“@+id/lastName”/>  
  17.    </LinearLayout>  
  18. </layout>  
<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}"
   android:id="@+id/firstName"/>
       <TextView android:layout_width="wrap_content"
           android:layout_height="wrap_content"
           android:text="@{user.lastName}"
  android:id="@+id/lastName"/>
   </LinearLayout>
</layout>
将生成一个 Binding 类：
[java] view plain copy
print ?
  1. public final TextView firstName;  
  2. public final TextView lastName;  
public final TextView firstName;
public final TextView lastName;

IDS 几乎没有必要在 DataBinding，但仍然有一些情况下，访问 Views 仍然是必要的代码

Variables:

每个 vaiables 都会有给定的访问方法：
[html] view plain copy
print ?
  1. <data>  
  2.     <import type=“android.graphics.drawable.Drawable”/>  
  3.     <variable name=“user”  type=“com.example.User”/>  
  4.     <variable name=“image” type=“Drawable”/>  
  5.     <variable name=“note”  type=“String”/>  
  6. </data>  
<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>
它会在Binding中结合生成setters和getters:
[java] view plain copy
print ?
  1. public abstract com.example.User getUser();  
  2. public abstract void setUser(com.example.User user);  
  3. public abstract Drawable getImage();  
  4. public abstract void setImage(Drawable image);  
  5. public abstract String getNote();  
  6. public abstract void setNote(String note);  
public abstract com.example.User getUser();
public abstract void setUser(com.example.User user);
public abstract Drawable getImage();
public abstract void setImage(Drawable image);
public abstract String getNote();
public abstract void setNote(String note);

ViewStubs:

ViewStubs 相比正常的 Views 略有不同，它们开始时是不可见的，当它们设置为可见或告知要载入时，它们通过载入另外一个layout 取代自己
由于 ViewStub 基本消失从View的层次结构，

因为 viewstub 基本消失从视图层次，在 Binding 对象的 View 也必须消失让收集，因为Views是最后一个 ViewStubProxy 对象以取代 ViewStub 的地方，给开发者获得 ViewStub，当 ViewStub 已经被载入时，它还可以存在并访问载入的 View 层结构

当载入另一个 layout，为新布局必须创建一个 Binding，因此，ViewStubProxy 必需监听 ViewStub 的 OnInflateListener 监听器并在哪个时候创建 Binding，因为只有一个可以存在，ViewStubProxy 允许开发者在其上设置一个 OnInflateListener 它会在建立Binding 后调用

高级绑定(Advanced Binding)

动态变量：
有时，不知道具体的 Binding 类，例如，一个 RecyclerView 适配器对任意 layout 并不知道具体的 Binding 结合类，它任然必需在 onBindViewHolder 期间赋值给 Binding
在下面的例子中，该 RecyclerView 绑定的所有 layouts 有一个 “item”的Variable，该 BindingHolder 有一个 getBinding 方法返回 ViewDataBinding:
[java] view plain copy
print ?
  1. public void onBindViewHolder(BindingHolder holder, int position) {  
  2.    final T item = mItems.get(position);  
  3.    holder.getBinding().setVariable(BR.item, item);  
  4.    holder.getBinding().executePendingBindings();  
  5. }  
public void onBindViewHolder(BindingHolder holder, int position) {
   final T item = mItems.get(position);
   holder.getBinding().setVariable(BR.item, item);
   holder.getBinding().executePendingBindings();
}

直接 Binding

当一个 Variable 或 Observable 变化时，binding 会在下一帧前被计划要求改变，但是有很多次在 Binding 时必需立即执行，要强制执行，使用 executePendingBindings() 方法

后台线程
只要它不是一个集合，你可以在后台中改变数据模型，在判断是否要避免任何并发问题时，Data Binding 会对每个 Variable/field本地化


六、属性 Setters

每当绑定值发生变化时，生成的绑定类必须使用绑定表达式在视图上调用 set 方法。Data Binding 框架具有自定义调用哪个方法来设置值的方法

自动安装(Automatic Setters)

对于一个属性，Data Binding 试图找到 setAttribute 方法，与该属性的 name space 并没有什么关系，仅仅与属性本身名称有关

例如，有关 TextView 的 android:text 属性的表达式会寻找一个 setText(String) 的方法，如果表达式返回一个 int,Data Binding会搜索的 setText(int) 方法，这里要注意：表达式要返回正确的类型，如果需要的话使用 casting，Data Binding 任然会工作，即使没有给定的名称属性存在，然后，你可以通过 Data Binding 轻松地为任何 setter “创造”属性，例如，DrawerLayout 没有任何属性，但大量的 setters，你可以使用自动 setters 来使用其中的一个：
[html] view plain copy
print ?
  1. <android.support.v4.widget.DrawerLayout  
  2.     android:layout_width=“wrap_content”  
  3.     android:layout_height=“wrap_content”  
  4.     app:scrimColor=“@{@color/scrim}”  
  5.     app:drawerListener=“@{fragment.drawerListener}”/>  
<android.support.v4.widget.DrawerLayout
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    app:scrimColor="@{@color/scrim}"
    app:drawerListener="@{fragment.drawerListener}"/>

重命名 Setters(Renamed Setters)

一些有 Setters 的属性按名称并不匹配，对于这些方法，属性可以通过 BindingMethods 注解相关联，还必须与一个包含BindingMethod 注解类相关联，每一个用于重命名的方法，例如  andorid:tin 属性与  setImageTintList 相关联，而不与 setTint相关
[java] view plain copy
print ?
  1. @BindingMethods({  
  2.        @BindingMethod(type = “android.widget.ImageView”,  
  3.                       attribute = ”android:tint”,  
  4.                       method = ”setImageTintList”),  
  5. })  
@BindingMethods({
       @BindingMethod(type = "android.widget.ImageView",
                      attribute = "android:tint",
                      method = "setImageTintList"),
})
上面的例子，开发者不太可能重命名编译程序，Android 框架属性已经实现了

自定义 Setters(Custom Setters)

有些属性需要自定义绑定逻辑，例如，对于 android:paddingLeft 属性并没有相关的setter，相反，setPadding (left、top、right、bottom)是存在，一个带有 BindingAdapter 注解的静态绑定适配器方法允许开发者自定义 setter 如何对于一个属性的调用
Android 的属性已经创造了 BindingAdapters，举例来说，对于 paddingLeft:
[java] view plain copy
print ?
  1. @BindingAdapter(“android:paddingLeft”)  
  2. public static void setPaddingLeft(View view, int padding) {  
  3.    view.setPadding(padding,  
  4.                    view.getPaddingTop(),  
  5.                    view.getPaddingRight(),  
  6.                    view.getPaddingBottom());  
  7. }  
@BindingAdapter("android:paddingLeft")
public static void setPaddingLeft(View view, int padding) {
   view.setPadding(padding,
                   view.getPaddingTop(),
                   view.getPaddingRight(),
                   view.getPaddingBottom());
}
Binding 适配对其他定制类型非常有用，例如，自定义 loader 可以用异步载入图像
当有冲突时，开发人员创建的 Binding 适配器将覆盖 Data Binding 默认适配器
你也可以创建可以接收多个参数的适配器：
[java] view plain copy
print ?
  1. @BindingAdapter({“bind:imageUrl”, “bind:error”})  
  2. public static void loadImage(ImageView view, String url, Drawable error) {  
  3.    Picasso.with(view.getContext()).load(url).error(error).into(view);  
  4. }  
@BindingAdapter({"bind:imageUrl", "bind:error"})
public static void loadImage(ImageView view, String url, Drawable error) {
   Picasso.with(view.getContext()).load(url).error(error).into(view);
}

[html] view plain copy
print ?
  1. <ImageView app:imageUrl=“@{venue.imageUrl}”  
  2. app:error=“@{@drawable/venueError}”/>  
<ImageView app:imageUrl="@{venue.imageUrl}"
app:error="@{@drawable/venueError}"/>

如果对于一个 ImageView imageUrl 和 error 都被使用，并且 imageUrl 是一个 String 类型以及 error 是一个 drawable 时，该适配器被调用
  • 匹配的过程中自定义 name spaces 将被忽略
  • 你也可以为 Android name spaces 写适配器

绑定适配器方法可以在其处理程序中选择旧值。取旧值和新值的方法应具有所有属性的旧值，其次是新值：
[java] view plain copy
print ?
  1. @BindingAdapter(“android:paddingLeft”)  
  2. public static void setPaddingLeft(View view, int oldPadding, int newPadding) {  
  3.    if (oldPadding != newPadding) {  
  4.        view.setPadding(newPadding,  
  5.                        view.getPaddingTop(),  
  6.                        view.getPaddingRight(),  
  7.                        view.getPaddingBottom());  
  8.    }  
  9. }  
@BindingAdapter("android:paddingLeft")
public static void setPaddingLeft(View view, int oldPadding, int newPadding) {
   if (oldPadding != newPadding) {
       view.setPadding(newPadding,
                       view.getPaddingTop(),
                       view.getPaddingRight(),
                       view.getPaddingBottom());
   }
}

事件处理程序只能用一个抽象方法与接口或抽象类一起使用,例如:
[java] view plain copy
print ?
  1. @BindingAdapter(“android:onLayoutChange”)  
  2. public static void setOnLayoutChangeListener(View view, View.OnLayoutChangeListener oldValue,  
  3.        View.OnLayoutChangeListener newValue) {  
  4.     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {  
  5.         if (oldValue != null) {  
  6.             view.removeOnLayoutChangeListener(oldValue);  
  7.         }  
  8.         if (newValue != null) {  
  9.             view.addOnLayoutChangeListener(newValue);  
  10.         }  
  11.     }  
  12. }  
@BindingAdapter("android:onLayoutChange")
public static void setOnLayoutChangeListener(View view, View.OnLayoutChangeListener oldValue,
       View.OnLayoutChangeListener newValue) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
        if (oldValue != null) {
            view.removeOnLayoutChangeListener(oldValue);
        }
        if (newValue != null) {
            view.addOnLayoutChangeListener(newValue);
        }
    }
}

当监听器有多个方法时，它必须被分割成多个监听器，例如，View.OnAttachStateChangeListener 的方法有两种：onViewAttachedToWindow() 和 onViewDetachedFromWindow()。然后，我们必须创建两个接口来区分它们的属性和处理程序:
[java] view plain copy
print ?
  1. @TargetApi(VERSION_CODES.HONEYCOMB_MR1)  
  2. public interface OnViewDetachedFromWindow {  
  3.     void onViewDetachedFromWindow(View v);  
  4. }  
  5.   
  6. @TargetApi(VERSION_CODES.HONEYCOMB_MR1)  
  7. public interface OnViewAttachedToWindow {  
  8.     void onViewAttachedToWindow(View v);  
  9. }  
@TargetApi(VERSION_CODES.HONEYCOMB_MR1)
public interface OnViewDetachedFromWindow {
    void onViewDetachedFromWindow(View v);
}

@TargetApi(VERSION_CODES.HONEYCOMB_MR1)
public interface OnViewAttachedToWindow {
    void onViewAttachedToWindow(View v);
}

因为改变一个监听器也会影响另一个，我们必须有三个不同的绑定适配器，一个为每个属性和一个为两者，他们应该被设置:
[java] view plain copy
print ?
  1. @BindingAdapter(“android:onViewAttachedToWindow”)  
  2. public static void setListener(View view, OnViewAttachedToWindow attached) {  
  3.     setListener(view, null, attached);  
  4. }  
  5.   
  6. @BindingAdapter(“android:onViewDetachedFromWindow”)  
  7. public static void setListener(View view, OnViewDetachedFromWindow detached) {  
  8.     setListener(view, detached, null);  
  9. }  
  10.   
  11. @BindingAdapter({“android:onViewDetachedFromWindow”, “android:onViewAttachedToWindow”})  
  12. public static void setListener(View view, final OnViewDetachedFromWindow detach,  
  13.         final OnViewAttachedToWindow attach) {  
  14.     if (VERSION.SDK_INT >= VERSION_CODES.HONEYCOMB_MR1) {  
  15.         final OnAttachStateChangeListener newListener;  
  16.         if (detach == null && attach == null) {  
  17.             newListener = null;  
  18.         } else {  
  19.             newListener = new OnAttachStateChangeListener() {  
  20.                 @Override  
  21.                 public void onViewAttachedToWindow(View v) {  
  22.                     if (attach != null) {  
  23.                         attach.onViewAttachedToWindow(v);  
  24.                     }  
  25.                 }  
  26.   
  27.                 @Override  
  28.                 public void onViewDetachedFromWindow(View v) {  
  29.                     if (detach != null) {  
  30.                         detach.onViewDetachedFromWindow(v);  
  31.                     }  
  32.                 }  
  33.             };  
  34.         }  
  35.         final OnAttachStateChangeListener oldListener = ListenerUtil.trackListener(view,  
  36.                 newListener, R.id.onAttachStateChangeListener);  
  37.         if (oldListener != null) {  
  38.             view.removeOnAttachStateChangeListener(oldListener);  
  39.         }  
  40.         if (newListener != null) {  
  41.             view.addOnAttachStateChangeListener(newListener);  
  42.         }  
  43.     }  
  44. }  
@BindingAdapter("android:onViewAttachedToWindow")
public static void setListener(View view, OnViewAttachedToWindow attached) {
    setListener(view, null, attached);
}

@BindingAdapter("android:onViewDetachedFromWindow")
public static void setListener(View view, OnViewDetachedFromWindow detached) {
    setListener(view, detached, null);
}

@BindingAdapter({"android:onViewDetachedFromWindow", "android:onViewAttachedToWindow"})
public static void setListener(View view, final OnViewDetachedFromWindow detach,
        final OnViewAttachedToWindow attach) {
    if (VERSION.SDK_INT >= VERSION_CODES.HONEYCOMB_MR1) {
        final OnAttachStateChangeListener newListener;
        if (detach == null && attach == null) {
            newListener = null;
        } else {
            newListener = new OnAttachStateChangeListener() {
                @Override
                public void onViewAttachedToWindow(View v) {
                    if (attach != null) {
                        attach.onViewAttachedToWindow(v);
                    }
                }

                @Override
                public void onViewDetachedFromWindow(View v) {
                    if (detach != null) {
                        detach.onViewDetachedFromWindow(v);
                    }
                }
            };
        }
        final OnAttachStateChangeListener oldListener = ListenerUtil.trackListener(view,
                newListener, R.id.onAttachStateChangeListener);
        if (oldListener != null) {
            view.removeOnAttachStateChangeListener(oldListener);
        }
        if (newListener != null) {
            view.addOnAttachStateChangeListener(newListener);
        }
    }
}

上面的例子是比正常的稍微复杂，因为 View 使用添加和删除的监听者而不是为 View.OnAttachStateChangeListener 设置方法，android.databinding.adapters.listenerutil 类有助于保持跟踪，他们可能会在绑定适配器删除以前的 listener

七、转换(Converters)

对象转换(Object Conversions)

当从 Binding 表达式返回对象时，将从自动、重命名和自定义 setters 中选择一个配置器。对象将被转换为所选集的参数类型
这是为那些使用 ObservableMaps 保存方便，例如：
[html] view plain copy
print ?
  1. <TextView  
  2.    android:text=‘@{userMap[“lastName”]}’  
  3.    android:layout_width=“wrap_content”  
  4.    android:layout_height=“wrap_content”/>  
<TextView
   android:text='@{userMap["lastName"]}'
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"/>
在 userMap 返回一个对象并且该对象将自动转换为 setText(CharSequence) 的参数类型，当有关参数类型可能混乱，开发人员需要在表达式中转换

自定义转换 Custom Conversions)

有时在特定类型之间应该自动转换。例如，当设置背景：
[html] view plain copy
print ?
  1. <View  
  2.    android:background=“@{isError ? @color/red : @color/white}”  
  3.    android:layout_width=“wrap_content”  
  4.    android:layout_height=“wrap_content”/>  
<View
   android:background="@{isError ? @color/red : @color/white}"
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"/>

这里，背景需要 Drawable 对象，但颜色是一个整数，不管何时有 Drawable 并且返回值是一个整数，那么整数类型会被转换为ColorDrawable 看，这个转换是通过使用带带有 BindingConversion 注解的静态方法完成的：
[java] view plain copy
print ?
  1. @BindingConversion  
  2. public static ColorDrawable convertColorToDrawable(int color) {  
  3.    return new ColorDrawable(color);  
  4. }  
@BindingConversion
public static ColorDrawable convertColorToDrawable(int color) {
   return new ColorDrawable(color);
}

注意，转换只发生在 setter 级别，所以它不允许混合以下类型：
[html] view plain copy
print ?
  1. <View  
  2.    android:background=“@{isError ? @drawable/error : @color/white}”  
  3.    android:layout_width=“wrap_content”  
  4.    android:layout_height=“wrap_content”/>  
<View
   android:background="@{isError ? @drawable/error : @color/white}"
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"/>

八、Android Studio 对 DataBinding 的支持(Android Studio Support for Data Binding)

Android Studio 支持 DataBinding 代码的许多代码编辑功能,例如，它支持数据绑定表达式的下列功能：
  • 语法高亮
  • 表达式语言语法错误的标记
  • XML 代码完成
  • 引用和快速文档
注意：数组和泛型类型（如可观察类）可能在没有错误时显示错误

预览窗格显示数据绑定表达式的默认值，如果提供，以下从布局的 XML 文件的元素实例摘录，预览窗格中显示的默认文本值的占位符文本：
[html] view plain copy
print ?
  1. <TextView android:layout_width=“wrap_content”  
  2.    android:layout_height=“wrap_content”  
  3.    android:text=“@{user.firstName, default=PLACEHOLDER}”/>  
<TextView android:layout_width="wrap_content"
   android:layout_height="wrap_content"
   android:text="@{user.firstName, default=PLACEHOLDER}"/>

如果你需要你的项目的设计阶段中显示一个默认值，你也可以使用工具的属性而不是默认的表达式的值，在设计 layout 描述属性

原文地址：点击打开链接

如有翻译错误，请指正




document.getElementById("bdshell_js").src = "http://bdimg.share.baidu.com/static/js/shell_v2.js?cdnversion=" + Math.ceil(new Date()/3600000) var fromjs = ("#fromjs");
    if (fromjs.length > 0) {("#fromjs .markdown_views pre").addClass("prettyprint"); prettyPrint(); ('pre.prettyprint code').each(function () {
                var lines =(this).text().split('\n').length; var numbering= ('
  • ').addClass('pre-numbering').hide(); (this).addClass(′has−numbering′).parent().append( numbering); for (i = 1; i
掉头发程序员
关注
专栏目录
Android———＞DataBinging---＞小案例
lbj23vs6的博客
06-06 195
文章目录前言项目流程1.gradle中对DataBinding进行配置2.xml页面3，Beauty 类4，Activity总结项目文件 前言 DataBinging是jetpack的一个组件，意在降低xml和活动的耦合性，让我们来写一个小demo来认识一下databinding,熟悉一下使用流程 项目流程 1.gradle中对DataBinding进行配置 在该文件的defaultConfig中添加下面的命令 dataBinding { enabled = tr
Android Data Binding数据绑定详解（基础篇）
weixin_42046829的博客
03-19 1632
简介 在2015年的谷歌IO大会上，Android UI Toolkit团队发布了DataBinding 框架，将数据绑定引入了Android开发。以后可以直接在 layout 布局 xml 文件中绑定数据了，无需再 findViewById 然后手工设置数据了。 构建环境 使用之前，需要在Android Studio中build.gradle配置开启Data Binding，具体如下： andr...
android-databing
娜娜子_的专栏
05-27 69
写到这里也结束了，在文章最后放上一个小小的福利，以下为小编自己在学习过程中整理出的一个关于Flutter的学习思路及方向，从事互联网开发，最主要的是要学好技术，而学习技术是一条慢长而艰苦的道路，不能靠一时激情，也不是熬几天几夜就能学好的，必须养成平时努力学习的习惯，更加需要准确的学习方向达到有效的学习效果。所以有了dataBinding我们极大的减轻了Activity所要做的操作，Activity可以更专注于对数据与逻辑的处理，而UI的获取与数据和UI的绑定都交给了布局文件。然后打印日志查看运行效果。
探索 Android DataBinding：实现数据与视图的完美融合
最新发布
无尽的大道的专栏
09-26 1166
DataBinding 是 Android 框架提供的一个数据绑定库，它允许你将数据与视图组件进行绑定，实现数据的自动更新和视图的响应式布局。通过 DataBinding，你可以减少手动操作视图的代码，提高代码的可读性和可维护性，同时也能够更好地实现 MVVM（Model-View-ViewModel）设计模式，提高应用的模块化和可测试性。DataBinding 的核心概念是数据绑定表达式，它是一种特殊的语法，允许你在 XML 布局文件中使用表达式来绑定数据到视图组件上。
android databing视频,Android DataBinding 从入门到进阶
weixin_31533357的博客
05-29 266
DataBinding 是谷歌官方发布的一个框架，顾名思义即为数据绑定，是 MVVM 模式在 Android 上的一种实现，用于降低布局和逻辑的耦合性，使代码逻辑更加清晰。MVVM 相对于 MVP，其实就是将 Presenter 层替换成了 ViewModel 层。DataBinding 能够省去我们一直以来的 findViewById() 步骤，大量减少 Activity 内的代码，数据能够单向...
Android DataBinding
zenmela2011的专栏
03-21 2395
首先定义一个静态方法，并添加BindingAdapte注解，注解值即为ImageView控件自定义的属性名，而该静态方法的两个参数可以这样来理解：当ImageView控件的url属性值发生变化时dataBinding就会将ImageView实例以及新的url值传递给loadImage()方法，从而可以在此动态改变ImageView的相关属性。控件的获取方式类似，但首字母小写。以上实现数据绑定的方式，每当绑定的变量发生变化的时候，都需要重新向ViewDataBinding传递新的变量值才能刷新UI。
安卓DataBing解决问题
JafarOne的博客
05-07 1285
VM管理视图和数据 package com.vpgame.eric.main.articles; import android.databinding.Bindable; import android.databinding.ObservableBoolean; import android.util.Log; import android.view.View; import com...
android快速数据绑定,Android Data Binding数据绑定详解
weixin_35935249的博客
05-26 1210
去年谷歌 I/O大会上介绍了一个非常厉害的新框架DataBinding， 数据绑定框架给我们带来了很大的方便，以前我们可能需要在每个Activity里写很多的findViewById，不仅麻烦，还增加了代码的耦合性，如果我们使用DataBinding，就可以抛弃那么多的findViewById，省时省力。说到这里，其实网上也有很多快速的注解框架，但是注解框架与DataBinding想比还是不好用，...
Android databinding详解(二)--activity解析
非洲的企鹅
04-05 6623
在本篇文章中主要讲述的是集成了data binding框架以后，我们的Activity文件中应该如何书写？下面依旧是先粘贴上Activity所有的代码， 然后通过代码讲述它与普通的Activity的不同之处。
DataBinding使用全面详解
blueangle17的专栏
03-12 957
转自：https://www.jianshu.com/p/ba4982be30f8一、DataBinding使用&lt;h2 id="1-1"&gt;1.使用环境&lt;/h2&gt;DataBinding是一个support library,所以它可以支持所有的android sdk，最低可以到android2.1（API7）。使用DataBinding需要Android Gradle插件的支持...
Android DataBinid在RecyclerView上应用
Du_ZiLin的博客
07-03 421
如果你不了解dataBinding,请看我的另一篇文章Activity布局文件如下，如果看过我的上一篇文章应该可以看懂这里的布局文件&lt;?xml version="1.0" encoding="utf-8"?&gt; &lt;layout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="...
android Datading讲解
kai1ge1的博客
07-22 645
DataBinding DataBinding可以将数据和xml绑定起来，也是实现mvvm的一种工具。先撇开mvvm我们先了解DataBing的用法。 首先在 app moudle中的gradle文件添加dataBing的task。 dataBinding { enabled = true } 我们先来写一个小例子。创建一个Person的java类如下。 publ...
Android DataBinding应用（一）
C++ JAVA的专栏
08-17 280
背景：最近项目中使用到了 DataBinding (Google 在 2015年开发者大会提出)， 正好目前的项目中也有所涉及，现在来学习一下 https://blog.csdn.net/qq_33689414/article/details/52205703 https://blog.csdn.net/qq_33689414/article/details/52205718 https://blog.csdn.net/qq_33689414/article/details/52205724 htt
android databing的学习（一）
w4901的博客
07-24 1153
Data binding 在2015年7月发布的android Studio v1.3.0 版本上引入，在2016年4月Android Studio v2.0.0 上正式支持。目前为止，Data Binding 已经支持双向绑定了，实在2016年的google I／O大会上发布的。现在已经很普及啦，在项目中也在慢慢使用。
Android DataBing基础使用 +ViewModel 及setvalue过程及原理
秃头还奋进的博客
03-30 3310
Android DataBing基础使用 +ViewModel 单向绑定 双向绑定
android databing视频,Android Studio 之 DataBing ，不需要再一个个findViewById了
weixin_31255215的博客
05-29 205
使用DataBinding，不需要再一个个findViewById了1.在 build.gradel 中 添加下面语句dataBinding{enabled true}2.在 activity_main.xml 文件中 点小灯炮，自动生成 data 结点3.在 MainActivity.java 中能得到一个新的类， ActivityMainBinding(此类取Activity名称，这个类不是固...
android:DataBind
调上调下的女生
11-11 686
http://blog.csdn.net/a60687688/article/details/50396150
Android DataBinding 使用指南
步入人工智能
04-05 1899
本内容主要介绍如何使用 Android 架构组件中的 Data Binding。
kotlin如何使用databing
05-23
使用 Kotlin 开发 Android 应用时，可以使用 Data Binding 来简化 UI 代码。以下是使用 Kotlin 和 Data Binding 的步骤： 1. 在 app 模块的 build.gradle 文件中添加以下依赖： ``` android { ... dataBinding {...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值