Nesse tutorial vou demonstrar como usar ViewBinding ao invés de Android Extensions em Kotlin e assim deixar seu aplicativo atualizado.

O plug-in ‘kotlin-android-extensions’ entrou em desuso então resolvi escrever este tutorial para a utilização do recurso que será usado no lugar o ViewBinding.

Vamos então nesse tutorial criar um aplicativo simples que vai conter a MainActivity com um Fragment e que quando clicado no botão ele vai modificar o fragment após 5 segundos.

Primeiramente vamos criar um projeto vazio(Empty) com o nome de br.com.uware.viewbind.

Logo após ter criado o projeto vamos editar o arquivo do gradle(Module App).

Então vamos deixar com o seguinte código para adicionar o binding.

plugins {
    id 'com.android.application'
    id 'kotlin-android'
    // Adicionar para o DataBinding
    id 'kotlin-kapt'
}

android {
    compileSdkVersion 30
    buildToolsVersion "30.0.2"

    defaultConfig {
        applicationId "br.com.uware.viewbind"
        minSdkVersion 19
        targetSdkVersion 30
        versionCode 1
        versionName "1.0"

        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }

    // Adicionar para o ViewBinding
    buildFeatures {
        dataBinding = true
        viewBinding = true
    }

    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
    kotlinOptions {
        jvmTarget = '1.8'
    }
}

dependencies {

    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
    implementation 'androidx.core:core-ktx:1.3.2'
    implementation 'androidx.appcompat:appcompat:1.2.0'
    implementation 'com.google.android.material:material:1.2.1'
    implementation 'androidx.constraintlayout:constraintlayout:2.0.4'
    implementation 'androidx.legacy:legacy-support-v4:1.0.0'
    implementation 'androidx.lifecycle:lifecycle-livedata-ktx:2.2.0'
    implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.2.0'
    implementation 'androidx.activity:activity-ktx:1.1.0'
    implementation "androidx.fragment:fragment-ktx:1.2.5"
    testImplementation 'junit:junit:4.+'
    androidTestImplementation 'androidx.test.ext:junit:1.1.2'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.3.0'
}

Logo após ter modificado o gradle sincronize para que seja adicionada as bibliotecas necessárias.

Vamos então criar adicionar um Fragment com ViewModel no projeto utilizando o nome MainFragment para fazer a função do botão quando clicado.

Layout

Logo depois de ter criado o fragment vamos acertar os layouts para ficar pronto o frontend e depois vamos acertar o backend.

Então vamos modificar o nosso arquivo activity_main.xml e deixar com o seguinte código.

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout 
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <Button
        android:id="@+id/btnClick"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Clique Aqui"
        android:layout_margin="8dp"
        app:layout_constraintTop_toTopOf="parent"/>
    <FrameLayout
        android:id="@+id/fragment"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        app:layout_constraintTop_toBottomOf="@+id/btnClick"
        app:layout_constraintBottom_toBottomOf="parent"/>

</androidx.constraintlayout.widget.ConstraintLayout>

Depois vamos modificar o main_fragment.xml e deixar com o seguinte código.

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    tools:context=".MainFragment">

    <TextView
        android:id="@+id/tvText"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:text="Após click vou Mudar em 5 segundos"
        android:gravity="center"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintBottom_toBottomOf="parent"/>

</androidx.constraintlayout.widget.ConstraintLayout>

Como usar ViewBinding ao invés de Android Extensions em Kotlin

Vamos modificar o arquivo do ViewModel agora.

Vamos deixar o arquivo com o seguinte código.

package br.com.uware.viewbind

import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch

class MainViewModel : ViewModel() {

    private var text: MutableLiveData<String> = MutableLiveData()
    private var times: Int = 0

    fun setClick(){
        viewModelScope.launch {
            ++times
            delay(5000)
            text.value = "Troquei o valor depois de 5 segundos \n( vezes: $times )"
        }
    }

    fun getText() = text

}

Com toda a base do projeto montada chegou a hora de ver como funciona o binding.

Vamos primeiramente editar o arquivo do fragment.

Então vamos deixar o arquivo MainFragment com o seguinte código.

package br.com.uware.viewbind

import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.Fragment
import androidx.fragment.app.activityViewModels
import androidx.lifecycle.Observer
import br.com.uware.viewbind.databinding.MainFragmentBinding

class MainFragment : Fragment() {

    companion object {
        fun newInstance() = MainFragment()
    }

    // Declaração da variável de binding referente ao
    // main_fragment.xml = MainFragmentBinding
    private var _binding: MainFragmentBinding? = null
    private val binding get() = _binding!!

    private val viewModel: MainViewModel by activityViewModels()

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

    // Destruindo o binding quando destroi o fragment
    override fun onDestroyView() {
        super.onDestroyView()
        _binding = null
    }

    override fun onActivityCreated(savedInstanceState: Bundle?) {
        super.onActivityCreated(savedInstanceState)

        viewModel.getText().observe(viewLifecycleOwner, Observer {
            // Utilizando o id do TextView tvText com binding
            binding.tvText.text = it
        })
    }

}

E por fim vamos editar o arquivo do MainActivity.kt e deixar com o seguinte código.

package br.com.uware.viewbind

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import androidx.activity.viewModels
import androidx.fragment.app.Fragment
import androidx.fragment.app.FragmentActivity
import br.com.uware.viewbind.databinding.ActivityMainBinding

class MainActivity : AppCompatActivity() {

    // Declaração da variável de binding referente ao
    // activity_main.xml = ActivityMainBinding
    private lateinit var binding: ActivityMainBinding

    private val viewModel: MainViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Binding view
        binding = ActivityMainBinding.inflate(layoutInflater)
        val view = binding.root
        setContentView(view)

        MainFragment.newInstance().loadFragment(this)

        // Utilizando o id do botão btnClick com binding
        binding.btnClick.setOnClickListener {
            viewModel.setClick()
        }
    }
    fun Fragment.loadFragment(act: FragmentActivity) {
        act.supportFragmentManager.beginTransaction()
            .setCustomAnimations(android.R.anim.fade_in, android.R.anim.fade_out)
            .replace(R.id.fragment, this)
            .commitNow()
    }
}

Logo após ter editado é só compilar e rodar a aplicação que você deve ter um app como o da seguinte imagem usando binding.

Enfim espero poder ter ajudado com mais este tutorial sobre como usar ViewBinding ao invés de Android Extensions em Kotlin.

Se você deseja obter mais informações sobre o recurso, acesse o seguinte link Android Developers.