When developing an Android application, you’re probably familiar with findViewById, which is used to connect to objects in the layout. Using findViewById requires a lot of effort when calling views in a class. To replace findViewById, several methods exist, such as using the ButterKnife library, the Kotlin Android Extensions plugin (often called synthetic views), Data Binding, and View Binding. In this article, we will discuss Kotlin Android Extensions and View Binding.

View Binding dan Kotlin Android Extension

View Binding

Quoted from the official documentation:

“View binding is a feature that allows you to more easily write code that interacts with views. Once view binding is enabled in a module, it generates a binding class for each XML layout file present in that module. An instance of a binding class contains direct references to all views that have an ID in the corresponding layout.”

From the above definition, View Binding is used to simplify the use/calling of views in a class. When using View Binding, a binding class is created for each layout. This binding class contains references to every object in our layout/view.

Kotlin Android Extensions

Similar to View Binding, Kotlin Android Extensions is a feature provided by Kotlin to simplify view usage/calling. However, unlike View Binding, Kotlin Android Extensions/synthetic views do not create a new class. Instead, it imports:

kotlinx.android.synthetic.<layout>

within the corresponding class.

Differences Between View Binding and Kotlin Android Extensions

Untuk dapat memahami perbedaan dari kedua metode tersebut, kita akan membuat sebuah aplikasi yang sama dengan layout sebagai berikut :

To understand the differences between these two methods, we will create an application with the following layout:

I will add an event where clicking hideBtn hides titleTxt, and clicking showBtn does the opposite. When calling and using it in an activity, I redundantly invoke findViewById and automatically import two widgets, as shown in the following code.

Implementation Using View Binding

To use View Binding, the first step is to add the following code to build.gradle (app). Don’t forget to sync Gradle and rebuild the project.

viewBinding {
	enabled = true
}

Thus, the build.gradle (app) file will look like this:

After modifying build.gradle (app), a binding class is created with a name based on our layout. In this case, I have a layout named activity_main.xml, so the generated binding class will be ActivityMainBinding.

Next, we will inflate the layout for our activity. The layout inflation process will be as follows:

Implementation Using Kotlin Android Extensions

Note : Kotlin Android Extensions can be used in Android Studio 3.6 and above.

To use Kotlin Android Extensions/synthetic views, the first step is to add the following plugin to build.gradle. Don’t forget to sync Gradle after adding the plugin.

apply plugin: 'kotlin-android-extensions'

After adding the plugin, Kotlin Android Extensions can be used by directly calling the view’s ID. The activity will look like this:

When using View Binding, it automatically imports kotlinx.android.synthetic.activity_main.xml and does not redundantly invoke findViewById. Unlike View Binding, using Kotlin Android Extensions makes the code look much cleaner and simpler because it does not require a binding class.

Using findViewById()

Using View Binding

Using Kotlin Android Extensions

Conclusion

By comparing View Binding and Kotlin Android Extensions, we can conclude several things:

Import Type Safety
Using either View Binding or Kotlin Android Extensions eliminates the need to manually import object types, as they are already cast to their respective types. This reduces import errors that commonly occur with findViewById().
Layout Changes
With View Binding, to use a newly added view object, the project must be built first. In contrast, Kotlin Android Extensions allows direct use without rebuilding the project, making it more convenient.
Layout Import
View Binding imports a binding class that matches the layout name, while Kotlin Android Extensions imports synthetic views for the used layout. Checking imported classes is easier and more manageable with View Binding compared to synthetic views, making View Binding more advantageous.
Clean & Boilerplate Code
Compared to View Binding, Kotlin Android Extensions results in cleaner code, as seen in the examples above, because it does not require extra code like View Binding or findViewById().

Referensi

To learn more about View Binding and Kotlin Android Extensions, refer to the official documentation below.

Happy Coding ❣️

Kotlin Android Extensions vs View Binding