Vinculação de visualizações Parte do Android Jetpack.

A vinculação de visualizações é um recurso que facilita a criação de códigos que interagem com visualizações. Quando a vinculação de visualizações é ativada em um módulo, ela gera uma vinculação classe para cada arquivo de layout XML presente nesse módulo. Uma instância de uma vinculação contém referências diretas a todas as visualizações que têm um ID na classe pelo layout correspondente.

Na maioria dos casos, a vinculação de visualizações substitui findViewById.

Configurar

A vinculação de visualizações é ativada módulo por módulo. Para ativar a vinculação de visualizações em um defina a opção de build viewBinding como true no nível do módulo build.gradle, conforme mostrado no exemplo a seguir:

Groovy

android {
    ...
    buildFeatures {
        viewBinding true
    }
}

Kotlin

android {
    ...
    buildFeatures {
        viewBinding = true
    }
}

Se quiser que um arquivo de layout seja ignorado ao gerar classes de vinculação, adicione o atributo tools:viewBindingIgnore="true" à visualização raiz desse layout. arquivo:

<LinearLayout
        ...
        tools:viewBindingIgnore="true" >
    ...
</LinearLayout>

Uso

Se a vinculação de visualizações estiver ativada em um módulo, uma classe de vinculação será gerada para cada Arquivo de layout XML que o módulo contém. Cada classe de vinculação contém referências para a visualização raiz e todas as que têm um ID. O nome da classe de vinculação é gerado pela conversão do nome do arquivo XML para Pascal Case e adição do palavra "Vinculação" até o fim.

Por exemplo, considere um arquivo de layout chamado result_profile.xml que contém o seguinte:

<LinearLayout ... >
    <TextView android:id="@+id/name" />
    <ImageView android:cropToPadding="true" />
    <Button android:id="@+id/button"
        android:background="@drawable/rounded_button" />
</LinearLayout>

A classe de vinculação gerada terá o nome ResultProfileBinding. Esta classe tem duas campos: um TextView chamado name e um Button chamado button. A O ImageView no layout não tem ID, então não há referência a ele no classe de vinculação.

Toda classe de vinculação também inclui um método getRoot(), fornecendo uma referência da visualização raiz do arquivo de layout correspondente. Neste exemplo, O método getRoot() na classe ResultProfileBinding retorna a visualização raiz LinearLayout.

As seções a seguir demonstram o uso de classes de vinculação geradas em atividades e fragmentos.

Usar a vinculação de visualizações em atividades

Para configurar uma instância da classe de vinculação para uso com uma atividade, execute o seguindo os passos Método onCreate():

  1. Chame o método estático inflate() incluído na classe de vinculação gerada. Isso cria uma instância da classe de vinculação para a atividade usar.
  2. Receba uma referência para a visualização raiz chamando o método getRoot() ou usando propriedade do Kotlin sintaxe.
  3. Transmita a visualização raiz para setContentView() para torná-lo a visualização ativa na tela.

Essas etapas são mostradas no exemplo a seguir:

Kotlin

private lateinit var binding: ResultProfileBinding

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    binding = ResultProfileBinding.inflate(layoutInflater)
    val view = binding.root
    setContentView(view)
}

Java

private ResultProfileBinding binding;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    binding = ResultProfileBinding.inflate(getLayoutInflater());
    View view = binding.getRoot();
    setContentView(view);
}

Agora, você pode usar a instância da classe de vinculação para referenciar qualquer uma das visualizações:

Kotlin

binding.name.text = viewModel.name
binding.button.setOnClickListener { viewModel.userClicked() }

Java

binding.name.setText(viewModel.getName());
binding.button.setOnClickListener(new View.OnClickListener() {
    viewModel.userClicked()
});

Usar a vinculação de visualizações em fragmentos

Para configurar uma instância da classe de vinculação para uso com um fragmento, execute o as etapas a seguir na criação onCreateView() :

  1. Chame o método estático inflate() incluído na classe de vinculação gerada. Isso cria uma instância da classe de vinculação para o uso do fragmento.
  2. Receba uma referência para a visualização raiz chamando o método getRoot() ou usando propriedade do Kotlin sintaxe.
  3. Retorne a visualização raiz do método onCreateView() para torná-la a o Active View na tela.
.

Kotlin

private var _binding: ResultProfileBinding? = null
// This property is only valid between onCreateView and
// onDestroyView.
private val binding get() = _binding!!

override fun onCreateView(
    inflater: LayoutInflater,
    container: ViewGroup?,
    savedInstanceState: Bundle?
): View? {
    _binding = ResultProfileBinding.inflate(inflater, container, false)
    val view = binding.root
    return view
}

override fun onDestroyView() {
    super.onDestroyView()
    _binding = null
}

Java

private ResultProfileBinding binding;

@Override
public View onCreateView (LayoutInflater inflater,
                          ViewGroup container,
                          Bundle savedInstanceState) {
    binding = ResultProfileBinding.inflate(inflater, container, false);
    View view = binding.getRoot();
    return view;
}

@Override
public void onDestroyView() {
    super.onDestroyView();
    binding = null;
}

Agora, você pode usar a instância da classe de vinculação para referenciar qualquer uma das visualizações:

Kotlin

binding.name.text = viewModel.name
binding.button.setOnClickListener { viewModel.userClicked() }

Java

binding.name.setText(viewModel.getName());
binding.button.setOnClickListener(new View.OnClickListener() {
    viewModel.userClicked()
});

Fornecer dicas para diferentes configurações

Quando você declara visualizações em várias configurações, às vezes pode sentido usar um tipo de visualização diferente dependendo do layout específico. O snippet de código abaixo mostra um exemplo disso:

# in res/layout/example.xml

<TextView android:id="@+id/user_bio" />

# in res/layout-land/example.xml

<EditText android:id="@+id/user_bio" />

Nesse caso, você pode esperar que a classe gerada exponha um campo userBio do tipo TextView, porque TextView é a classe de base comum. Devido a as limitações técnicas, o gerador de código de vinculação de visualizações não pode determinar isso, e gera um campo View. Isso exige transmitir o campo mais tarde com binding.userBio as TextView:

Para contornar essa limitação, a vinculação de visualizações oferece suporte a uma tools:viewBindingType. , permitindo informar ao compilador qual tipo usar no código gerado. No exemplo anterior, você pode usar esse atributo para tornar o compilador gere o campo como uma TextView:

# in res/layout/example.xml (unchanged)

<TextView android:id="@+id/user_bio" />

# in res/layout-land/example.xml

<EditText android:id="@+id/user_bio" tools:viewBindingType="TextView" />

Em outro exemplo, suponha que você tenha dois layouts, um contendo um BottomNavigationView e outra que contenha um NavigationRailView. Ambos estendem NavigationBarView, que contém a maior parte da implementação detalhes. Caso seu código não precise saber exatamente qual subclasse está presente na o layout atual, use tools:viewBindingType para definir o digite como NavigationBarView nos dois layouts:

# in res/layout/navigation_example.xml

<BottomNavigationView android:id="@+id/navigation" tools:viewBindingType="NavigationBarView" />

# in res/layout-w720/navigation_example.xml

<NavigationRailView android:id="@+id/navigation" tools:viewBindingType="NavigationBarView" />

A vinculação de visualizações não pode validar o valor desse atributo ao gerar o código. Para evitar erros de tempo de compilação e execução, o valor precisa atender aos seguintes condições:

  • O valor precisa ser uma classe herdada de android.view.View.

  • O valor precisa ser uma superclasse da tag na qual é colocado. Por exemplo, o seguintes valores não funcionam:

      <TextView tools:viewBindingType="ImageView" /> <!-- ImageView is not related to TextView. -->
  <TextView tools:viewBindingType="Button" /> <!-- Button is not a superclass of TextView. -->

  • O tipo final precisa ser resolvido de maneira consistente em todas as configurações.

Diferenças de findViewById

A vinculação de visualizações tem vantagens importantes em relação ao uso de findViewById:

  • Segurança nula:já que a vinculação de visualizações cria referências diretas a visualizações, não há risco de uma exceção de ponteiro nulo devido a um ID de visualização inválido. Além disso, quando uma visualização está presente apenas em algumas configurações de uma layout, o campo que contém a referência na classe de vinculação será marcado com @Nullable.
  • Segurança de tipos: os campos em cada classe de vinculação têm tipos que correspondem ao visualizações referenciadas no arquivo XML. Isso significa que não há risco de uma classe exceção de transmissão.

Essas diferenças significam incompatibilidades entre o layout e o código resultar em falha do build no momento da compilação, e não durante a execução.

Comparação com a vinculação de dados

A vinculação de visualizações e a vinculação de dados geram classes de vinculação que podem ser usadas para referenciar visualizações diretamente. No entanto, visualize a vinculação destina-se a casos de uso mais simples e fornece os seguintes benefícios em relação à vinculação de dados:

  • Compilação mais rápida:a vinculação de visualizações não exige processamento de anotações. os tempos de compilação são mais rápidos.
  • Facilidade de uso:a vinculação de visualizações não exige um layout XML especialmente marcado. arquivos, o que facilita a adoção deles nos seus apps. Depois de ativar a vinculação de visualizações um módulo, ela será aplicada a todos os layouts desse módulo automaticamente.

Por outro lado, a vinculação de visualizações tem as seguintes limitações em comparação com os dados vinculação:

Por isso, em alguns casos, é melhor usar ambas as visualizações e vinculação de dados em um projeto. É possível usar a vinculação de dados em layouts que exigem recursos avançados e usam vinculação de visualizações em layouts que não precisam.

Outros recursos

Para saber mais sobre a vinculação de visualizações, consulte os seguintes recursos extras:

Amostras

Blogs

Vídeos