Kotlin: ViewBinding vs Kotlin Android Extensions with synthetic views

Kotlin Programming

Question or issue of Kotlin Programming:

How does the new ViewBinding compare with the Kotlin Android Extensions with synthetic views bindings?

Apart from the NullSafety and TypeSafety provided by new ViewBindings, why should we consider ditching the Kotlin way of using synthetic bindings on Views?

Is the new ViewBinding more performant since it generates the Binding class beforehand?

How to solve this issue?

Solution no. 1:

Let’s review the two.

Kotlin Android Extensions
  1. Import appropriate layout synthetic extensions: import kotlinx.android.synthetic.main.<layout>.*
  2. Reference views in code via their ids: textView.text = "Hello, world!". These extensions work on: Activities, Fragments and Views.
View Binding
  1. Create binding reference inside your class: private lateinit var binding
  2. Inflate your binding binding = YourClassBinding.inflate(layoutInflater) inside Activity‘s onCreate and call setContentView(binding.root), or inflate it in Fragment‘s onCreateView then return it: return binding.root
  3. Reference views in code via binding using their ids binding.textView.text = "Hello, world!"

Type safety

Kotlin Android Extensions and ViewBinding are type safe by definition, because referenced views are already casted to appropriate types.

Null safety

Kotlin Android Extensions and ViewBinding are both null safe. ViewBinding doesn’t have any advantage here. In case of KAE, if view is present only in some layout configurations, IDE will point that out for you:

enter image description here

So you just treat it as any other nullable type in Kotlin, and the error will disappear:

enter image description here

Applying layout changes

In case of Kotlin Android Extensions, layout changes instantly translate to generation of synthetic extensions, so you can use them right away. In case of ViewBinding, you have to build your project

Incorrect layout usage

In case of Kotlin Android Extensions, it is possible to import incorrect layout synthetic extensions, thus causing NullPointerException. The same applies to ViewBinding, since we can import wrong Binding class. Although, it is
more probable to overlook incorrect import than incorrect class name, especially if layout file is well named after Activity/Fragment/View, so ViewBinding has upper hand here.

Summary of KAE vs ViewBinding
  • Type safety – Draw.
  • Null safety – Draw.
  • Boilerplate codeKAE wins. From Kotlin Android Extensions documentation:

The Kotlin Android Extensions plugin allows us to obtain the same
experience we have with some of these libraries, without having to add
any extra code.

  • Applying layout changesKAE wins. Changes are instant in contrast to ViewBinding.
  • Incorrect layout usageViewBinding wins

I think there is big misconception about ViewBinding being replacement for KAE. People hear big keywords and repeat them without verifying it beforehand. Sure, ViewBinding is best option for Java development right now (replacement for ButterKnife), but there is no or little advantage over KAE in Kotlin (see Incorrect layout usage section).

Side note:
I’m sure DataBinding people will like ViewBinding 🙂

Solution no. 2:

ViewBinding solved the biggest problem of kotlinx.android.synthetic. In synthetic binding if you set your content view to a layout, then type an id that only exists in a different layout, the IDE lets you autocomplete and add the new import statement. Unless the developer specifically checks to make sure their import statements only import the correct views, there is no safe way to verify that this won’t cause a runtime issue. But in ViewBinding you should use your layout binding object to access its views so you never invoke to a view in a different layout and if you want to do this you will get a compile error not a runtime error. Here is an example.

We create two layouts called activity_main and activity_other like so :





Now if you write your activity like this:

import android.os.Bundle import android.support.v7.app.AppCompatActivity import kotlinx.android.synthetic.main.activity_other.* class MainActivity : AppCompatActivity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) //Application will crash because "message_other" doesn't exist in "activity_main" message_other.text = "Hello!" } } 

your code will compile without any error but your application will crash at runtime. Because the view with message_other id doesn’t exist in activity_main and the compiler didn’t check this. But if you use ViewBinding like so:

class MainActivity : AppCompatActivity() { private lateinit var binding: ActivityMainBinding override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) binding = ActivityMainBinding.inflate(layoutInflater) setContentView(binding.root) //This code will never compile and the IDE shows you an error binding.message_other.text = "Hello!" } } 

your code will never compile and Android Studio shows you an error in the last line.

Solution no. 3:

kotlinx.android.synthetic is no longer a recommended practice, said by google in one commit message “one of Reddit thread


Synthetics is not developed by google, it’s a part of kotlin android extension crafted by JetBrains and gradually google android developers started replacing the Synthetics with the ViewBindins in their demos and source-codes.

“Now question comes, which one we have to take it in consideration.”

According to google (View binding, ButterKnife, Kotlin synthetics) these libraries are used successfully by many apps and solve the same problem.

But for most of the apps google recommend trying out view binding instead of these libraries Because view binding provides safer, more concise view lookup.

Attached reference image to clear things quickly.
enter image description here

However if you would like to go in dept you can follow the given below link.

Solution no. 4:

Kotlin Android Extensions will be deprecated with Kotlin 1.4.20 so I would recommend to use ViewBinding.


Solution no. 5:

According to previous answers we can summary them.

Null Safe

both are null safe but sometimes they may suffer from NPE like with KAE when use view after view is destroyed also with viewBinding may occur when access view before inflating or after lifecycle is over.

Clean &Concise code


Support Kotlin & Java

viewBinding win here, but if your project is pure Kotlin so this feature valueless

Hope this helps!