Vincular visualizações de layout aos componentes da arquitetura

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

Esta página mostra como incorporar os Componentes da arquitetura ao seu app para aproveitar ao máximo o uso da 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 alterações na dados. Para saber mais sobre esse componente de arquitetura, consulte a documentação do LiveData geral.

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

Para usar um objeto LiveData com sua classe de vinculação, é necessário especificar um proprietário do ciclo de vida para definir o escopo do objeto LiveData. O seguinte exemplo especifica a atividade como proprietário do ciclo de vida após a classe de vinculação foi instanciado:

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

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 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ários dados de dados. O exemplo abaixo mostra como transformar os dados no ViewModel:

class ScheduleViewModel : ViewModel() {
    val userName: LiveData

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

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. Usando Os componentes ViewModel com a biblioteca Data Binding permitem mover a lógica da interface dos layouts para os componentes, que são mais fáceis de testar. Os dados A Binding Library garante que as visualizações sejam vinculadas e desvinculadas dos dados. quando necessário. A maior parte do trabalho restante consiste em garantir que você está expondo os dados corretos. Para mais informações sobre esta arquitetura do componente, consulte a documentação do ViewModel geral do Google.

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

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

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, atribuir as propriedades e os métodos do componente ViewModel às visualizações correspondentes usando expressões de vinculação, conforme mostrado abaixo exemplo:

<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 ViewModel que implementa Interface do Observable para notificar outros componentes do aplicativo sobre alterações nos dados, semelhante a como você usaria uma objeto LiveData.

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

Para implementar um componente ViewModel observável, crie uma classe que herda da classe ViewModel e implementa o Observable interface gráfica do usuário. Você pode fornecer uma lógica personalizada quando um observador se inscrever ou cancela sua inscrição em notificações usando o addOnPropertyChangedCallback() e removeOnPropertyChangedCallback() métodos. Você também pode fornecer uma lógica personalizada que é executada quando as propriedades mudam as notifyPropertyChanged() . O exemplo de código a seguir mostra como implementar um elemento observável ViewModel:

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

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