Classes de vinculação gerada

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.