A vinculação de visualizações é um recurso que facilita a programação de códigos que interagem com visualizações. Quando a vinculação de visualizações é ativada em um módulo, ela gera uma classe de vinculação para cada arquivo de layout XML presente nesse módulo. A instância de uma classe de vinculação contém referências diretas a todas as visualizações que têm um código no layout correspondente.
Na maioria dos casos, a vinculação de visualizações substitui findViewById
.
Instruções de configuração
A vinculação de visualizações é ativada em um módulo por base de módulo. Para ativar a vinculação de visualizações em um módulo, adicione o elemento viewBinding
ao arquivo build.gradle
dele, conforme mostrado no exemplo a seguir:
android {
...
viewBinding {
enabled = true
}
}
Caso você queira que um arquivo de layout seja ignorado ao gerar classes de vinculação, adicione o atributo tools:viewBindingIgnore="true"
à visualização raiz do arquivo de layout:
<LinearLayout
...
tools:viewBindingIgnore="true" >
...
</LinearLayout>
Uso
Se a vinculação de visualizações estiver ativada para um módulo, uma classe de vinculação será gerada para cada arquivo de layout XML que ele contiver. Cada classe de vinculação contém referências à visualização raiz e a todas as visualizações que têm um código. O nome da classe de vinculação é gerado por meio da conversão do nome do arquivo XML em minúsculas concatenadas e da adição da palavra "Binding" ao final.
Por exemplo, considerando um arquivo de layout denominado result_profile.xml
:
<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
. Essa classe tem dois campos: um TextView
denominado name
e um Button
denominado button
. A ImageView
no layout não tem código. Portanto, não há referência a ela na classe de vinculação.
Toda classe de vinculação também inclui um método getRoot()
, que disponibiliza uma referência direta para a visualização raiz do arquivo de layout correspondente. Nesse exemplo, o método getRoot()
na classe ResultProfileBinding
retorna a visualização raiz de 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 ser usada com uma atividade, siga as seguintes etapas no método onCreate()
da atividade:
- 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. - Receba uma referência para a visualização raiz chamando o método
getRoot()
ou usando a sintaxe da propriedade Kotlin (link em inglês). - Transmita a visualização raiz para
setContentView()
a fim de torná-la a visualização ativa na tela.
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.getName().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 a ser usada com um fragmento, siga as etapas a seguir no método onCreateView()
do fragmento:
- 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. - Receba uma referência para a visualização raiz chamando o método
getRoot()
ou usando a sintaxe da propriedade Kotlin (link em inglês). - Retorne a visualização raiz do método
onCreateView()
para torná-la a visualização ativa 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.getName().setText(viewModel.getName()); binding.button.setOnClickListener(new View.OnClickListener() { viewModel.userClicked() });
Diferenças de findViewById
A vinculação de visualizações tem vantagens importantes em relação ao uso de findViewById
:
- Segurança nula: como esse tipo de vinculação cria referências diretas a visualizações, não há risco de uma exceção de ponteiro nulo devido a um código de visualização inválido. Além disso, quando uma visualização está presente apenas em algumas configurações de um layout, o campo que contém a referência na classe de vinculação é marcado com
@Nullable
. - Segurança de tipo: os campos em cada classe de vinculação têm tipos correspondentes às visualizações referenciadas no arquivo XML. Isso significa que não há risco de uma exceção de transmissão de classes.
Essas diferenças significam que as incompatibilidades entre seu layout e seu código resultarão em uma falha no momento da compilação, não no momento da 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, a vinculação de visualizações processa casos de uso mais simples e oferece 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, por isso os tempos de compilação são mais rápidos.
- Facilidade de uso: a vinculação de visualizações não requer arquivos de layout XML com tags especiais. Portanto, é mais rápido adotá-la nos apps. Depois de ativar a vinculação de visualizações em um módulo, ela será aplicada automaticamente a todos os layouts desse módulo.
Por outro lado, a vinculação de visualizações tem as seguintes limitações em comparação com a vinculação de dados:
- A vinculação de visualizações não é compatível com variáveis ou expressões de layout, por isso não pode ser usada para declarar conteúdo de IU dinâmica diretamente de arquivos de layout XML.
- A vinculação de visualizações não é compatível com vinculação de dados bidirecional.
Devido a essas limitações, em alguns casos é melhor usar tanto a vinculação de visualizações quanto a vinculação de dados em um projeto. Você pode usar a vinculação de dados em layouts que precisam de recursos avançados e a vinculação de visualizações em layouts que não precisam.