Como adicionar View Binding a um projeto Android Gradle

A maioria dos desenvolvedores Android provavelmente está familiarizada com o clássico findViewById() método. Passe a ele um ID de uma das Views em seu layout XML e ele retornará uma referência à versão inflada dessa View. Isso tudo pressupõe que você passou o ID correto e que o View realmente existe. findViewById() não possui verificações integradas para impedir que você tente recuperar uma visualização que não pode ser recuperada. Insira a vinculação de visualização.

Ao invés de usar findViewById() em cada View desejada, View Binding gera automaticamente uma classe de ligação para cada XML de layout. Cada View com um ID é automaticamente adicionada à classe, para que você possa referenciá-las diretamente.

Adicionar View Binding a um projeto Android Gradle é super simples.

Configuração do Gradle

View Binding está habilitado no nível do módulo no Gradle. Se você tiver vários módulos, precisará habilitá-los individualmente para cada um.

No android bloquear no nível do seu módulo build.gradle, adicione a opção para ativar a vinculação de visualização.

android {
 ...
 buildFeatures {
 viewBinding true
 }
}

Pode haver um aviso sobre acesso ilegal, mas isso é um bug e pode ser ignorado com segurança.

Sincronize o projeto e View Binding será habilitado. É tão fácil.

Usando vinculação de visualização

Existem algumas maneiras de usar View Binding, mas antes que isso aconteça, vamos falar sobre como as classes de vinculação são geradas.

Sintaxe do nome da classe

Digamos que você tenha um XML de layout chamado some_layout.xml. Sua classe de ligação correspondente será nomeada SomeLayoutBinding. Esse padrão vale para todos os arquivos.

Cada palavra (separada por sublinhados no nome do arquivo) será maiúscula e os sublinhados serão removidos. "Binding" é adicionado ao final.

Instanciando com Visualização Existente

Se você já inflou o arquivo de layout e tem uma referência à raiz do layout, você pode dizer à classe de ligação View para usar o layout existente.

Kotlin:

val binding = SomeLayoutBinding.bind(someLayoutRoot /* should be a View instance */)

Java:

SomeLayoutBinding binding = SomeLayoutBinding.bind(someLayoutRoot /* should be a View instance */);

Por exemplo, se você quisesse usar a classe de ligação em um Fragment, seria algo assim.

Kotlin:

classSomeFragment : Fragment(R.layout.some_layout) {
//Lazy initialization means bind() won't be called until "binding" is referenced.
private val binding by lazy { SomeLayoutBinding.bind(view) }
override fun onViewCreated(view: View, savedInstanceState: Bundle?){
super.onViewCreated(view, savedInstanceState)

//Once this method is called, you can start using the binding.
 }
}

Java:

publicclassSomeFragmentextendsFragment{
private SomeLayoutBinding binding = null;
publicSomeFragment(){
super(R.layout.some_layout);
 }
@Override
publicvoidonViewCreated(View view, Bundle savedInstanceState){
super.onViewCreated(view, savedInstanceState);

//Initialize the binding.
 binding = SomeLayoutBinding.bind(view);
 }
}

Instanciando com Nova Visualização

A classe de ligação também pode cuidar de inflar o layout para você.

Kotlin:

val binding = SomeLayoutBinding.inflate(layoutInflater /* should be a LayoutInflater instance */)

Java:

SomeLayoutBinding binding = SomeLayoutBinding.inflate(layoutInflater /* should be a LayoutInflater instance */);

Este método é útil tanto em fragmentos quanto em atividades.

Um exemplo Fragmento seria algo parecido com o seguinte.

Kotlin:

classSomeFragment : Fragment() {
private val binding by lazy { SomeLayoutBinding.inflate(LayoutInflater.from(requireContext())) }
override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?){
//The "root" of the binding class is the root of its layout.
return binding.root
 }
}

Java:

publicclassSomeFragmentextendsFragment{
private SomeLayoutBinding binding = null;
@Override
publicvoidonCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState){
//Initialize the binding.
 binding = SomeLayoutBinding.inflate(inflater);
//The "getRoot()" method of the binding class returns the root of the layout.
return binding.getRoot();
 }
}

Um exemplo de atividade seria algo parecido com o seguinte.

Kotlin:

classSomeActivity : AppCompatActivity() {
private val binding by lazy { SomeLayoutBinding.inflate(layoutInflater) }
override fun onCreate(savedInstanceState: Bundle?){
super.onCreate(savedInstanceState)
//This is equivalent to calling "setContentView(R.layout.some_layout)" but allows use of the binding class.
setContentView(binding.root)
 }
}

Java:

publicclassSomeActivityextendsAppCompatActivity{
private SomeLayoutBinding binding = null;
@Override
protectedvoidonCreate(Bundle savedInstanceState){
super.onCreate(savedInstanceState);
//Instantiate the binding.
 binding = SomeLayoutBinding.inflate(getLayoutInflater());
//This is equivalent to calling "setContentView(R.layout.some_layout)" but allows use of the binding class.
setContentView(binding.getRoot());
 }
}

Referenciando Visualizações

Agora que a classe de vinculação View está configurada e pronta para uso, é hora de realmente usá-la.

Digamos que o conteúdo do some_layout.xml são algo como o seguinte:

 android:
 ...>
 android:
 ...
 />
 android:
 ...
 />
 android:
 ...>
 android:
 ...
 />
LinearLayout>
LinearLayout>

Existem muitos IDs para referência no código. Mas contanto que você tenha a classe de ligação instanciada, a referência será fácil.

No Kotlin, as Views são referenciadas por variáveis ​​que correspondem aos seus IDs, com algumas alterações. Os sublinhados são removidos e a string resultante tem caixa de camelo. Por exemplo, para fazer referência some_frame_layout do código, você usaria binding.someFrameLayout. O someFrameLayout variável será uma instância de FrameLayout.

val someFrameLayout: FrameLayout = binding.someFrameLayout

Em Java, as Views são referenciadas por métodos getter que correspondem aos seus IDs, com um formato semelhante ao Kotlin. Por exemplo, para fazer referência some_frame_layout, você usaria binding.getSomeFrameLayout(). O método retornará uma instância de FrameLayout.

FrameLayout someFrameLayout = binding.getSomeFrameLayout();

As referências de visualização também são niveladas na ligação. Referenciando inner_imageview é o mesmo que referenciar some_frame_layout.

Conclusão

Como tenho certeza que você pode ver, View Binding no Android é fácil de implementar e fácil de usar. Em muitos casos, é mais fácil de usar do que findViewById().

Para obter mais detalhes sobre a implementação do View Binding, juntamente com alguns exemplos, confira a documentação oficial do Google.