A Data Binding Library gera classes de vinculação que podem ser usadas para acessar a variáveis e visualizações do layout. Esta documentação mostra como criar e personalizar as classes de vinculação geradas.
A classe de vinculação gerada vincula as variáveis de layout às visualizações no
o mesmo layout organizacional. É possível personalizar o nome e o pacote de
a vinculação. Todas as classes de vinculação geradas herdam da
classe ViewDataBinding
.
Uma classe de vinculação é gerada para cada arquivo de layout. Por padrão, o nome do
é o nome do arquivo de layout convertido para o formato Pascal Case com a função Binding
o sufixo dele. Por exemplo, se o nome do arquivo do layout for
activity_main.xml
, a classe gerada correspondente será ActivityMainBinding
.
Essa classe contém todas as vinculações, desde as propriedades de layout até o
visualizações e sabe como atribuir valores para as expressões de vinculação.
Criar um objeto de vinculação
O objeto de vinculação é criado imediatamente após inflar o layout para tornar
garantir que a hierarquia de visualização não seja modificada antes de se vincular às visualizações com
no layout. O método mais comum para vincular o objeto a um
layout é usar os métodos estáticos na classe de vinculação. É possível inflar
a hierarquia de visualização e vincule o objeto a ela usando o método inflate()
do
de vinculação, conforme mostrado no exemplo a seguir:
Kotlin
override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) val binding: MyLayoutBinding = MyLayoutBinding.inflate(layoutInflater) setContentView(binding.root) }
Java
@Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); MyLayoutBinding binding = MyLayoutBinding.inflate(getLayoutInflater()); setContentView(binding.root); }
Há uma versão alternativa do método inflate()
que usa uma
objeto ViewGroup
, além do
LayoutInflater
, conforme
como mostrado no exemplo a seguir:
Kotlin
val binding: MyLayoutBinding = MyLayoutBinding.inflate(getLayoutInflater(), viewGroup, false)
Java
MyLayoutBinding binding = MyLayoutBinding.inflate(getLayoutInflater(), viewGroup, false);
Se o layout for inflado usando um mecanismo diferente, você pode vinculá-lo separadamente, da seguinte maneira:
Kotlin
val binding: MyLayoutBinding = MyLayoutBinding.bind(viewRoot)
Java
MyLayoutBinding binding = MyLayoutBinding.bind(viewRoot);
Às vezes, você não sabe o tipo de vinculação com antecedência. Nesses casos, é possível
criar a vinculação usando
DataBindingUtil
,
conforme demonstrado neste snippet de código:
Kotlin
val viewRoot = LayoutInflater.from(this).inflate(layoutId, parent, attachToParent) val binding: ViewDataBinding? = DataBindingUtil.bind(viewRoot)
Java
View viewRoot = LayoutInflater.from(this).inflate(layoutId, parent, attachToParent); ViewDataBinding binding = DataBindingUtil.bind(viewRoot);
Se você estiver usando itens de vinculação de dados em um
Fragment
,
ListView
ou
RecyclerView
de carga, pode preferir usar o
inflate()
os métodos das classes de vinculação ou da
DataBindingUtil
, conforme
como mostrado neste exemplo de código:
Kotlin
val listItemBinding = ListItemBinding.inflate(layoutInflater, viewGroup, false) // or val listItemBinding = DataBindingUtil.inflate(layoutInflater, R.layout.list_item, viewGroup, false)
Java
ListItemBinding binding = ListItemBinding.inflate(layoutInflater, viewGroup, false); // or ListItemBinding binding = DataBindingUtil.inflate(layoutInflater, R.layout.list_item, viewGroup, false);
Visualizações com códigos
A Data Binding Library cria um campo imutável na classe de vinculação para
cada visualização que tem um ID no layout. Por exemplo, a biblioteca Data Binding
cria os campos firstName
e lastName
do tipo TextView
a partir da
seguinte 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>
A biblioteca extrai as visualizações, incluindo os IDs, da hierarquia de visualizações em uma
uma única passagem. Esse mecanismo pode ser mais rápido do que chamar
findViewById()
para cada visualização do layout.
IDs não são tão necessários quanto são sem vinculação de dados, mas ainda há em alguns casos em que o acesso a visualizações é necessário no código.
Variáveis
A Data Binding Library gera métodos do acessador para cada variável declarada
no layout. Por exemplo, o layout a seguir gera setter e getter
métodos na classe de vinculação para as variáveis user
, image
e note
:
<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
Ao contrário das visualizações normais, os objetos ViewStub
começam como visualizações invisíveis. Quando ficam visíveis ou são explicitamente inflados,
eles se substituem no layout inflando outro layout.
Como a ViewStub
desaparece da hierarquia de visualização, a visualização na
objeto de vinculação também deve desaparecer para permitir que seja reivindicado pela coleta de lixo.
Como as visualizações são finais, uma
Objeto ViewStubProxy
toma o lugar de ViewStub
na classe de vinculação gerada, oferecendo
Acesso ao ViewStub
quando ele existe e acesso à visualização inflada
hierarquia quando o ViewStub
é inflado.
Ao inflar outro layout, uma vinculação precisa estabelecer para o novo layout.
Portanto, o ViewStubProxy
precisa detectar o ViewStub
.
OnInflateListener
e estabelecer a vinculação quando necessário. Como só um listener pode existir em um
momento, o ViewStubProxy
permite que você defina um OnInflateListener
, que ele chama
após estabelecer a vinculação.
Vinculação imediata
Quando uma variável ou um objeto observável muda, a vinculação é programada para mudar
antes do próximo frame. No entanto, há momentos em que a vinculação precisa ser executada
imediatamente. Para forçar a execução, use o método
executePendingBindings()
.
Variáveis dinâmicas
Às vezes, a classe de vinculação específica é desconhecida. Por exemplo,
RecyclerView.Adapter
operar em layouts arbitrários não conhece a classe de vinculação específica. Ela
atribuir o valor de vinculação durante a chamada ao
onBindViewHolder()
.
No exemplo abaixo, todos os layouts aos quais o RecyclerView
se vincula têm um
item
. O objeto BindingHolder
tem um método getBinding()
.
retornando
ViewDataBinding
base
.
Kotlin
override fun onBindViewHolder(holder: BindingHolder, position: Int) { item: T = items.get(position) holder.binding.setVariable(BR.item, item); holder.binding.executePendingBindings(); }
Java
public void onBindViewHolder(BindingHolder holder, int position) { final T item = items.get(position); holder.getBinding().setVariable(BR.item, item); holder.getBinding().executePendingBindings(); }
Linha de execução em segundo plano
Você pode alterar seu modelo de dados em uma linha de execução em segundo plano, desde que não seja um coleção. A vinculação de dados localiza cada variável ou campo durante a avaliação para evitar problemas de simultaneidade.
Nomes de classes de vinculação personalizados
Por padrão, uma classe de vinculação é gerada com base no nome do arquivo de layout,
começando com letra maiúscula, removendo sublinhados ( _ ), capitalizando o
letra seguinte e sufixando a palavra Binding. Por exemplo, o arquivo de layout
contact_item.xml
gera a classe ContactItemBinding
. A turma é colocada
em um pacote databinding
no pacote do módulo. Por exemplo, se o módulo
pacote for com.example.my.app
, a classe de vinculação será colocada na
com.example.my.app.databinding
.
As classes de vinculação podem ser renomeadas ou colocadas em diferentes pacotes ajustando o
Atributo class
do elemento data
. Por exemplo, o layout a seguir
gera a classe de vinculação ContactItem
no pacote databinding
na
módulo atual:
<data class="ContactItem">
...
</data>
É possível gerar a classe de vinculação em um pacote diferente, adicionando como prefixo a classe com ponto final. O exemplo a seguir gera a classe de vinculação na módulo:
<data class=".ContactItem">
...
</data>
Você também pode usar o nome completo do pacote em que quer que a classe de vinculação seja
gerada. O exemplo a seguir cria a classe de vinculação ContactItem
na
Pacote com.example
:
<data class="com.example.ContactItem">
...
</data>
Outros recursos
Para saber mais sobre vinculação de dados, consulte os recursos a seguir.
- Amostras da Android Data Binding Library (link em inglês)
- Vinculação de dados no Android
- Vinculação de dados: lições aprendidas (link em inglês)
Recomendados para você
- Observação: o texto do link aparece quando o JavaScript está desativado.
- Layouts e expressões de vinculação
- Biblioteca Data Binding
- Vinculação de visualizações