Vincular visualizações de layout aos componentes da arquitetura

A biblioteca do AndroidX inclui os Componentes de arquitetura, que você pode usar para criar apps robustos, testáveis e de fácil manutenção. A biblioteca Data Binding funciona perfeitamente com os componentes de arquitetura para simplificar ainda mais o desenvolvimento da interface. Os layouts do seu app podem ser vinculados aos dados nos Componentes da arquitetura, que ajudam a gerenciar o ciclo de vida do controlador e notificar a IU sobre mudanças nos dados.

Esta página mostra como incorporar os Componentes da arquitetura ao app para aproveitar ao máximo a biblioteca Data Binding.

Usar LiveData para notificar a IU sobre mudanças de dados

Você pode usar objetos LiveData como fonte de vinculação de dados para notificar automaticamente a interface sobre mudanças nos dados. Para saber mais sobre esse componente de arquitetura, consulte a Visão geral do LiveData.

Ao contrário dos objetos que implementam Observable, como campos observáveis, os objetos LiveData conheçam o ciclo de vida dos observadores que se inscreveram nas mudanças de dados. Esse conhecimento proporciona muitos benefícios, que são explicados em As vantagens de usar o LiveData. No Android Studio 3.1 e versões mais recentes, é possível substituir campos observáveis por objetos LiveData no código de vinculação de dados.

Para usar um objeto LiveData com sua classe de vinculação, especifique um proprietário do ciclo de vida para definir o escopo do objeto LiveData. O exemplo a seguir especifica a atividade como a proprietária do ciclo de vida após a classe de vinculação ser instanciada:

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

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);
    }
}

Você pode usar um componente ViewModel, conforme explicado na seção a seguir, para vincular os dados ao layout. No componente ViewModel, é possível usar o objeto LiveData para transformar os dados ou mesclar várias fontes de dados. O exemplo abaixo mostra como transformar os dados no ViewModel:

Kotlin

class ScheduleViewModel : ViewModel() {
    val userName: LiveData

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

Java

class ScheduleViewModel extends ViewModel {
    LiveData username;

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

Usar o ViewModel para gerenciar dados relacionados à IU

A biblioteca Data Binding funciona perfeitamente com componentes ViewModel. O ViewModel expõe os dados que o layout observa e reage às mudanças. O uso de componentes ViewModel com a biblioteca Data Binding permite mover a lógica da interface dos layouts para os componentes, que são mais fáceis de testar. A biblioteca Data Binding garante que as visualizações sejam vinculadas e desvinculadas da fonte de dados quando necessário. A maior parte do trabalho restante consiste em garantir que você esteja expondo os dados corretos. Para saber mais sobre esse componente de arquitetura, consulte a Visão geral do ViewModel.

Para usar o componente ViewModel com a biblioteca Data Binding, é necessário instanciar o componente, que herda da classe ViewModel, conseguir uma instância da classe de vinculação e atribuir o componente ViewModel a uma propriedade na classe de vinculação. O exemplo abaixo mostra como usar o componente com a biblioteca:

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

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

No layout, atribua as propriedades e os métodos do componente ViewModel às visualizações correspondentes usando expressões de vinculação, conforme mostrado no exemplo abaixo.

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

Usar um ViewModel observável para ter mais controle sobre os adaptadores de vinculação

Você pode usar um componente ViewModel que implemente a interface Observable para notificar outros componentes do app sobre mudanças nos dados, da mesma forma que você usaria um objeto LiveData.

Há situações em que você pode preferir usar um componente ViewModel que implemente a interface Observable em vez de usar objetos LiveData, mesmo que perca os recursos de gerenciamento do ciclo de vida de LiveData. Usar um componente ViewModel que implementa Observable oferece mais controle sobre os adaptadores de vinculação no app. Por exemplo, esse padrão oferece mais controle sobre as notificações quando os dados mudam e também permite especificar um método personalizado para definir o valor de um atributo na vinculação de dados bidirecional.

Para implementar um componente ViewModel observável, crie uma classe herdada da classe ViewModel e que implemente a interface Observable. Você pode fornecer uma lógica personalizada quando um observador se inscrever ou cancelar a inscrição nas notificações usando os métodos addOnPropertyChangedCallback() e removeOnPropertyChangedCallback(). Também é possível fornecer uma lógica personalizada que é executada quando as propriedades mudam no método notifyPropertyChanged(). O exemplo de código abaixo mostra como implementar um ViewModel observável:

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

/**
 * 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);
    }
}

Outros recursos

Para saber mais sobre vinculação de dados, consulte os recursos adicionais a seguir.