The AndroidX library includes the [Architecture
Components](https://developer.android.com/topic/libraries/architecture), which you can
use to design robust, testable, and maintainable apps.
The Data Binding Library works seamlessly with the Architecture
Components to further simplify the
development of your UI. The layouts in your app
can bind to the data in the Architecture Components, which help you
manage the UI controller's lifecycle and notify the UI about changes in the data.

This page shows how to incorporate the Architecture Components into your app to
get the most from using the Data Binding Library.

## Use LiveData to notify the UI about data changes

You can use [`LiveData`](https://developer.android.com/reference/androidx/lifecycle/LiveData) objects as
the data binding source to automatically notify the UI about changes in the
data. For more information about this Architecture Component, see the [LiveData
overview](https://developer.android.com/topic/libraries/architecture/livedata).

Unlike objects that implement
[`Observable`](https://developer.android.com/reference/androidx/databinding/Observable)---such as
[observable
fields](https://developer.android.com/topic/libraries/data-binding/observability#observable_fields)---`LiveData`
objects know about the lifecycle of the observers subscribed to the data
changes. This knowledge enables many benefits, which are explained in [The
advantages of using
LiveData](https://developer.android.com/topic/libraries/architecture/livedata#the_advantages_of_using_livedata).
In Android Studio version 3.1 and higher, you can replace observable fields
with `LiveData` objects in your data binding code.

To use a `LiveData` object with your binding class, you need to specify a
lifecycle owner to define the scope of the `LiveData` object. The following
example specifies the activity as the lifecycle owner after the binding class
has been instantiated:  

### Kotlin

```kotlin
class ViewModelActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        // Inflate view and obtain an instance of the binding class.
        val binding: UserBinding = DataBindingUtil.setContentView(this, R.layout.user)

        // Specify the current activity as the lifecycle owner.
        binding.setLifecycleOwner(this)
    }
}
```

### Java

```java
class ViewModelActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // Inflate view and obtain an instance of the binding class.
        UserBinding binding = DataBindingUtil.setContentView(this, R.layout.user);

        // Specify the current activity as the lifecycle owner.
        binding.setLifecycleOwner(this);
    }
}
```

You can use a [`ViewModel`](https://developer.android.com/reference/androidx/lifecycle/ViewModel)
component, as explained in the following section, to bind the data to the layout. In the `ViewModel` component,
you can use the `LiveData` object to transform the data or merge multiple data
sources. The following example shows how to transform the data in the `ViewModel`:  

### Kotlin

```kotlin
class ScheduleViewModel : ViewModel() {
    val userName: LiveData

    init {
        val result = Repository.userName
        userName = Transformations.map(result) { result -> result.value }
    }
}
```

### Java

```java
class ScheduleViewModel extends ViewModel {
    LiveData username;

    public ScheduleViewModel() {
        String result = Repository.userName;
        userName = Transformations.map(result, result -> result.value);
    }
}
```

## Use ViewModel to manage UI-related data

The Data Binding Library works seamlessly with
[`ViewModel`](https://developer.android.com/reference/androidx/lifecycle/ViewModel) components. The `ViewModel`
exposes the data that the layout observes and reacts to its changes. Using
`ViewModel` components with the Data Binding Library lets you move UI logic
out of the layouts and into the components, which are easier to test. The Data
Binding Library ensures the views are bound and unbound from the data
source when needed. Most of the remaining work consists of making sure that
you're exposing the correct data. For more information about this Architecture
Component, see the [ViewModel
overview](https://developer.android.com/topic/libraries/architecture/viewmodel).

To use the `ViewModel` component with the Data Binding Library, you must
instantiate your component---which inherits from the
`ViewModel` class, obtain an
instance of your binding class, and assign your `ViewModel` component to a
property in the binding class. The following example shows how to use the
component with the library:  

### Kotlin

```kotlin
class ViewModelActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        // Obtain the ViewModel component.
        val userModel: UserModel by viewModels()

        // Inflate view and obtain an instance of the binding class.
        val binding: UserBinding = DataBindingUtil.setContentView(this, R.layout.user)

        // Assign the component to a property in the binding class.
        binding.viewmodel = userModel
    }
}
```

### Java

```java
class ViewModelActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // Obtain the ViewModel component.
        UserModel userModel = new ViewModelProvider(this).get(UserModel.class);

        // Inflate view and obtain an instance of the binding class.
        UserBinding binding = DataBindingUtil.setContentView(this, R.layout.user);

        // Assign the component to a property in the binding class.
        binding.viewmodel = userModel;
    }
}
```

In your layout, assign the properties and methods of your `ViewModel` component
to the corresponding views using binding expressions, as shown in the following
example:  

    <CheckBox
        android:id="@+id/rememberMeCheckBox"
        android:checked="@{viewmodel.rememberMe}"
        android:onCheckedChanged="@{() -> viewmodel.rememberMeChanged()}" />

## Use an Observable ViewModel for more control over binding adapters

You can use a [`ViewModel`](https://developer.android.com/reference/androidx/lifecycle/ViewModel)
component that implements the
[`Observable`](https://developer.android.com/reference/androidx/databinding/Observable) interface
to notify other
app components about changes in the data, similar to how you would use a
[`LiveData`](https://developer.android.com/reference/androidx/lifecycle/LiveData) object.

There are situations where you might prefer to use a
`ViewModel` component that implements the `Observable`
interface over using `LiveData` objects, even if you lose the lifecycle
management capabilities of `LiveData`. Using a `ViewModel` component that
implements `Observable` gives you more control over the binding adapters in your
app. For example, this pattern gives you more control over the notifications
when data changes; it also lets you specify a custom method to set the
value of an attribute in two-way data binding.

To implement an observable `ViewModel` component, you must create a class that
inherits from the `ViewModel` class and implements the `Observable`
interface. You can provide custom logic when an observer subscribes or
unsubscribes to notifications using the
[`addOnPropertyChangedCallback()`](https://developer.android.com/reference/androidx/databinding/Observable#addOnPropertyChangedCallback(android.databinding.Observable.OnPropertyChangedCallback))
and
[`removeOnPropertyChangedCallback()`](https://developer.android.com/reference/androidx/databinding/Observable#removeOnPropertyChangedCallback(android.databinding.Observable.OnPropertyChangedCallback))
methods. You can also provide custom logic that runs when properties change in
the
[`notifyPropertyChanged()`](https://developer.android.com/reference/androidx/databinding/BaseObservable#notifyPropertyChanged(int))
method. The following code example shows how to implement an observable
`ViewModel`:  

### Kotlin

```kotlin
/**
 * A ViewModel that is also an Observable,
 * to be used with the Data Binding Library.
 */
open class ObservableViewModel : ViewModel(), Observable {
    private val callbacks: PropertyChangeRegistry = PropertyChangeRegistry()

    override fun addOnPropertyChangedCallback(
            callback: Observable.OnPropertyChangedCallback) {
        callbacks.add(callback)
    }

    override fun removeOnPropertyChangedCallback(
            callback: Observable.OnPropertyChangedCallback) {
        callbacks.remove(callback)
    }

    /**
     * Notifies observers that all properties of this instance have changed.
     */
    fun notifyChange() {
        callbacks.notifyCallbacks(this, 0, null)
    }

    /**
     * Notifies observers that a specific property has changed. The getter for the
     * property that changes must be marked with the @Bindable annotation to
     * generate a field in the BR class to be used as the fieldId parameter.
     *
     * @param fieldId The generated BR id for the Bindable field.
     */
    fun notifyPropertyChanged(fieldId: Int) {
        callbacks.notifyCallbacks(this, fieldId, null)
    }
}
```

### Java

```java
/**
 * A ViewModel that is also an Observable,
 * to be used with the Data Binding Library.
 */
class ObservableViewModel extends ViewModel implements Observable {
    private PropertyChangeRegistry callbacks = new PropertyChangeRegistry();

    @Override
    protected void addOnPropertyChangedCallback(
            Observable.OnPropertyChangedCallback callback) {
        callbacks.add(callback);
    }

    @Override
    protected void removeOnPropertyChangedCallback(
            Observable.OnPropertyChangedCallback callback) {
        callbacks.remove(callback);
    }

    /**
     * Notifies observers that all properties of this instance have changed.
     */
    void notifyChange() {
        callbacks.notifyCallbacks(this, 0, null);
    }

    /**
     * Notifies observers that a specific property has changed. The getter for the
     * property that changes must be marked with the @Bindable annotation to
     * generate a field in the BR class to be used as the fieldId parameter.
     *
     * @param fieldId The generated BR id for the Bindable field.
     */
    void notifyPropertyChanged(int fieldId) {
        callbacks.notifyCallbacks(this, fieldId, null);
    }
}
```

## Additional resources

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

- [Android Data Binding Library samples](https://github.com/android/databinding-samples)

<!-- -->

- [Data Binding in Android codelab](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
- [Work with observable data objects](https://developer.android.com/topic/libraries/data-binding/observability)
- [Load and display paged data](https://developer.android.com/topic/libraries/architecture/paging/v3-paged-data)
- [Use Kotlin coroutines with lifecycle-aware components](https://developer.android.com/topic/libraries/architecture/coroutines)