The Data Binding Library generates binding classes you can use to access the layout's variables and views. This documentation shows how to create and customize generated binding classes.

The generated binding class links the layout variables with the views within the layout. You can[customize](https://developer.android.com/topic/libraries/data-binding/generated-binding#custom_binding_class_names)the name and package of the binding. All generated binding classes inherit from the[`ViewDataBinding`](https://developer.android.com/reference/androidx/databinding/ViewDataBinding)class.

A binding class is generated for each layout file. By default, the name of the class is the name of the layout file converted to Pascal case with the*Binding* suffix added to it. So, for example, if the layout filename is`activity_main.xml`, the corresponding generated class is`ActivityMainBinding`. This class holds all the bindings from the layout properties to the layout's views and knows how to assign values for the binding expressions.

## Create a binding object

The binding object is created immediately after inflating the layout to make sure the view hierarchy isn't modified before it binds to the views with expressions within the layout. The most common method to bind the object to a layout is to use the static methods on the binding class. You can inflate the view hierarchy and bind the object to it by using the`inflate()`method of the binding class, as shown in the following example:  

### Kotlin

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

    val binding: MyLayoutBinding = MyLayoutBinding.inflate(layoutInflater)

    setContentView(binding.root)
}
```

### Java

```java
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    MyLayoutBinding binding = MyLayoutBinding.inflate(getLayoutInflater());

    setContentView(binding.root);
}
```

There is an alternate version of the`inflate()`method that takes a[`ViewGroup`](https://developer.android.com/reference/android/view/ViewGroup)object in addition to the[`LayoutInflater`](https://developer.android.com/reference/android/view/LayoutInflater)object , as shown in the following example:  

### Kotlin

```kotlin
val binding: MyLayoutBinding = MyLayoutBinding.inflate(getLayoutInflater(), viewGroup, false)
```

### Java

```java
MyLayoutBinding binding = MyLayoutBinding.inflate(getLayoutInflater(), viewGroup, false);
```

If the layout is inflated using a different mechanism, you can bind it separately, as follows:  

### Kotlin

```kotlin
val binding: MyLayoutBinding = MyLayoutBinding.bind(viewRoot)
```

### Java

```java
MyLayoutBinding binding = MyLayoutBinding.bind(viewRoot);
```

Sometimes you don't know the binding type in advance. In such cases, you can create the binding using the[`DataBindingUtil`](https://developer.android.com/reference/androidx/databinding/DataBindingUtil)class, as demonstrated in the following code snippet:  

### Kotlin

```kotlin
val viewRoot = LayoutInflater.from(this).inflate(layoutId, parent, attachToParent)
val binding: ViewDataBinding? = DataBindingUtil.bind(viewRoot)
```

### Java

```java
View viewRoot = LayoutInflater.from(this).inflate(layoutId, parent, attachToParent);
ViewDataBinding binding = DataBindingUtil.bind(viewRoot);
```

If you are using data binding items inside a[`Fragment`](https://developer.android.com/reference/android/app/Fragment),[`ListView`](https://developer.android.com/reference/android/widget/ListView), or[`RecyclerView`](https://developer.android.com/reference/androidx/recyclerview/widget/RecyclerView)adapter, you might prefer to use the[`inflate()`](https://developer.android.com/reference/androidx/databinding/DataBindingUtil#inflate(android.view.LayoutInflater,%20int,%20android.view.ViewGroup,%20boolean,%20android.databinding.DataBindingComponent))methods of the bindings classes or the[`DataBindingUtil`](https://developer.android.com/reference/androidx/databinding/DataBindingUtil)class, as shown in the following code example:  

### Kotlin

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

### Java

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

## Views with IDs

The Data Binding Library creates an immutable field in the binding class for each view that has an ID in the layout. For example, the Data Binding Library creates the`firstName`and`lastName`fields of type`TextView`from the following 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>

The library extracts the views, including the IDs, from the view hierarchy in a single pass. This mechanism can be faster than calling the[`findViewById()`](https://developer.android.com/reference/android/app/Activity#findViewById(int))method for every view in the layout.

IDs aren't as necessary as they are without data binding, but there are still some instances where access to views is necessary from code.

## Variables

The Data Binding Library generates accessor methods for each variable declared in the layout. For example, the following layout generates setter and getter methods in the binding class for the`user`,`image`, and`note`variables:  

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

## ViewStubs

Unlike normal views,[`ViewStub`](https://developer.android.com/reference/android/view/ViewStub)objects start as invisible views. When they are made visible or are explicitly inflated, they replace themselves in the layout by inflating another layout.

Because the`ViewStub`disappears from the view hierarchy, the view in the binding object must also disappear to let it be claimed by garbage collection. Because the views are final, a[`ViewStubProxy`](https://developer.android.com/reference/androidx/databinding/ViewStubProxy)object takes the place of the`ViewStub`in the generated binding class, giving you access to the`ViewStub`when it exists and access to the inflated view hierarchy when the`ViewStub`is inflated.

When inflating another layout, a binding must establish for the new layout. Therefore, the`ViewStubProxy`must listen to the`ViewStub`[`OnInflateListener`](https://developer.android.com/reference/android/view/ViewStub.OnInflateListener)and establish the binding when required. Since only one listener can exist at a time, the`ViewStubProxy`lets you set an`OnInflateListener`, which it calls after establishing the binding.

## Immediate binding

When a variable or observable object changes, the binding is scheduled to change before the next frame. There are times, however, when binding must be executed immediately. To force execution, use the[`executePendingBindings()`](https://developer.android.com/reference/android/databinding/ViewDataBinding#executependingbindings)method.

## Dynamic variables

At times, the specific binding class is unknown. For example, a[`RecyclerView.Adapter`](https://developer.android.com/reference/androidx/recyclerview/widget/RecyclerView.Adapter)operating against arbitrary layouts doesn't know the specific binding class. It must assign the binding value during the call to the[`onBindViewHolder()`](https://developer.android.com/reference/androidx/recyclerview/widget/RecyclerView.Adapter#onBindViewHolder(VH,int))method.

In the following example, all layouts that the`RecyclerView`binds to have an`item`variable. The`BindingHolder`object has a`getBinding()`method returning the[`ViewDataBinding`](https://developer.android.com/reference/androidx/databinding/ViewDataBinding)base class.  

### Kotlin

```kotlin
override fun onBindViewHolder(holder: BindingHolder, position: Int) {
    item: T = items.get(position)
    holder.binding.setVariable(BR.item, item);
    holder.binding.executePendingBindings();
}
```

### Java

```java
public void onBindViewHolder(BindingHolder holder, int position) {
    final T item = items.get(position);
    holder.getBinding().setVariable(BR.item, item);
    holder.getBinding().executePendingBindings();
}
```
| **Note:** The Data Binding Library generates a class named`BR`in the module package that contains the IDs of the resources used for data binding. In the preceding example, the library automatically generates the`BR.item`variable.

## Background thread

You can change your data model in a background thread as long as it isn't a collection. Data binding localizes each variable or field during evaluation to avoid any concurrency issues.

## Custom binding class names

By default, a binding class is generated based on the name of the layout file, starting with an uppercase letter, removing underscores ( _ ), capitalizing the following letter, and suffixing the word*Binding* . For example, the layout file`contact_item.xml`generates the`ContactItemBinding`class. The class is placed in a`databinding`package under the module package. For example, if the module package is`com.example.my.app`, then the binding class is placed in the`com.example.my.app.databinding`package.

Binding classes can be renamed or placed in different packages by adjusting the`class`attribute of the`data`element. For example, the following layout generates the`ContactItem`binding class in the`databinding`package in the current module:  

    <data class="ContactItem">
        ...
    </data>

You can generate the binding class in a different package by prefixing the class name with a period. The following example generates the binding class in the module package:  

    <data class=".ContactItem">
        ...
    </data>

You can also use the full package name where you want the binding class to be generated. The following example creates the`ContactItem`binding class in the`com.example`package:  

    <data class="com.example.ContactItem">
        ...
    </data>

## Additional resources

To learn more about data binding, see the following additional resources.

- [Android Data Binding Library samples](https://github.com/android/databinding-samples)
- [Data Binding in Android](https://codelabs.developers.google.com/codelabs/android-databinding)
- [Data Binding --- lessons learnt](https://medium.com/androiddevelopers/data-binding-lessons-learnt-4fd16576b719)

## Recommended for you

- Note: link text is displayed when JavaScript is off
- [Layouts and binding expressions](https://developer.android.com/topic/libraries/data-binding/expressions)
- [Data Binding Library](https://developer.android.com/topic/libraries/data-binding)
- [View binding](https://developer.android.com/topic/libraries/view-binding)