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: LiveDatainit { val result = Repository.userName userName = Transformations.map(result) { result -> result.value } } }
Java
class ScheduleViewModel extends ViewModel { LiveDatausername; 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.
- Amostras da Android Data Binding Library (link em inglês)
Recomendados para você
- Observação: o texto do link aparece quando o JavaScript está desativado.
- Trabalhar com objetos de dados observáveis
- Carregar e exibir dados paginados
- Usar corrotinas do Kotlin com componentes que reconhecem o ciclo de vida