- From Kotlin synthetics to Android ViewBinding: the definitive guide
- Binding your views like a pro in 2 minutes.
- Setup
- Enable view binding
- Remove android extensions plugin
- Parcelize annotations
- Activities
- Fragments
- ViewHolder
- Includes
- With a view group
- With a
- Conclusion
- View Binding in Android
- Getting started with View Binding
- Using View Binding in Fragments
- Start using View Binding
- One-Liner ViewBinding Library
- Use view binding to replace findViewById
- Update build.gradle to enable view binding
- Use view binding in an Activity
- Safe code using binding objects
- What code does it generate?
- What about included layouts
- Using view binding and data binding
- View binding and Kotlin synthetics or ButterKnife
- Learn more
From Kotlin synthetics to Android ViewBinding: the definitive guide
Binding your views like a pro in 2 minutes.
Since Kotlin 1.4.20, JetBrains deprecated the kotlin-android-extensions plugin in favor of Android View Binding solution.
If you have been using this plugin, it’s time to move on before this feature is completely removed (or switch to Compose?).
For having completely refactored our Android application to use View Binding, we know that it can be somehow painful and sometimes it looks less simple with this new solution. For example, the binding of your view will have to be done differently if you’re working with an Activity or a Fragment. If your layout uses include there are some tricky ways to handle them too.
That’s why we’ve been implementing some convenient methods to make it simpler.
Setup
If you’re refactoring your whole application code, we advise you to do it module per module to avoid committing too many updates.
Enable view binding
To enable the ViewBinding feature, you just need to enable this build feature on your module build.gradle files:
Remove android extensions plugin
If you’ve been using kotlin-android-extensions before, remove the plugin from the build.gradle file too:
Don’t forget to also remove the Android Extensions experimental flag:
Parcelize annotations
The Parcelize annotations have been moved to another package & the previous one has been deprecated.
So, if you used the Kotlin Parcelize annotation to automatize the implementation of your Parcelable objects, you’ll need to use the new plugin :
Then, replace imports in your code from kotlinx.android.parcel to kotlinx.parcelize.
Activities
To set up an Activity to use your binding class you basically have to:
1- Declare a late init variable for your binding class.
2- In the onCreate method, inflate your layout using the static inflate method from the generated Binding class.
3- Call the Activity setContentView with the root view from your binding class.
We can definitely make it way shorter using some extensions:
Our viewBinding method is a simple delegate that inflates lazily the view of the activity by using the inflater method given as a parameter.
In the Activity we just need to declare the binding as a simple val property and set the content view of the activity.
Fragments
Using View Binding in Fragments is quite less easy as you have to do many things to make it works:
- 1- Declare a var property for your binding class instance.
- In the onCreateView callback, inflate the layout for your binding class & return the root view of it.
- To avoid potential leaks, reset your binding class to null in the onDestroyView callback.
As per the official documentation, it should look like that:
That’s a lot of code to add & you should also pay attention to potential leaks on the binding class. This can also be disturbing as the method is quite different from using it in an Activity. Note that you also need to use the !! operator to hide the nullability of the original field.
There’s a lot of room for improvement here and I found a way better solution to deal with it in 1 line:
Yep, really simple!🚀
Here are some explanations:
- We pass to the Fragment constructor the id of our fragment layout, which will be inflated for us.
- We declare the binding property that will handle the fragment lifecycle work for us.
Have a look at this Gist:
Our viewBindingWithBinder simply instantiate a delegate object that will bind the view of our fragment lazily. As the Fragment already inflate the view from the layout id that we pass to it in its constructor, we just need to bind our binding class from it.
The FragmentAutoClearedValueBinding class is the one that will be responsible to clear the reference to the binding class when the fragment gets destroyed by adding an observer to its lifecycle. In the getValue method, we bind the view to our binding class the first time we access our binding property from our fragment.
ViewHolder
If you’ve been using Kotlin synthetics, you probably have something that looks like this:
You can now remove the usage of LayoutContainer and make some updates in your view holder:
Here we have simply changed our constructor to take the binding class in parameter instead of having a view object.
To instantiate your view holder, you can create a static method in a companion object:
Includes
In your layouts, you probably have views that are included in your layout using the include tag. Then, you must be aware that it can be tricky to deal with it with view binding.
With a view group
If your included view has a root view that is a ViewGroup (LinearLayout, FrameLayout, etc.) then you can set an id to the include tag in your main layout.
The generated LayoutBinding class will have a property mergeLayout of type LayoutMergeBinding that reference the layout_mege layout views.
So in an activity, you can easily reference your TextView as:
With a
If your included view uses a tag in it like in this example:
And your main layout is:
Then, the layout_merge.xml file content will be merged into your main layout. But, the binding class will not expose a property titleLbl (it will only contain your root LinearLayout ) 😭.
So, what can you do to access to your titleLbl ? You’ll need to re-bind your view with another binding class. As each layout files have its own binding class, your layout_merge layout will have a LayoutMergeBinding class generated. That’s the one we will use to retrieve our views.
From an activity, you can add another property for the 2nd binding class:
The mergeBinding property will then allow you to access the titleLbl view.
Conclusion
We hope this article was useful to you if you’re still refactoring your views to use ViewBinding or to give you some hints to refactor how you’re using it.
And you, how did you implement it into your app? Don’t hesitate to share with us your tip&tricks!
If you want to join our Bureau of Technology or any other Back Market department, take a look here, we’re hiring! 🦄
Источник
View Binding in Android
We have learnt that every time we need to access a view from our XML layout into our Java or Kotlin code, we must use findViewById(). It was okay for small/personal projects where we use 5 to 6 views in a layout. But for larger projects we have comparatively more views in a layout, and accessing each view using the same findViewById() is not really comfortable.
What is View Binding?
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
Simply put, this allows us to access the views from the layout file in a very simple way by linking variables of our Kotlin or Java code with the XML views. When a layout is inflated, it creates a Binding object, which contains all the XML views that are casted to the correct type. This makes it really easier for us since we can retrieve all views in one line of code.
Getting started with View Binding
- Let’s start by enabling view binding in our project:
In build.gradle(:app) add the code in -> android
2. Before the onCreate() method, we create our binding object
3. Perform the following steps in onCreate() method:
- Call the inflate() method to create an instance of the binding class for the activity to use.
- Get reference to the root view
- Pass the root view to setContentView() [setContentView(binding.root)] instead of layout [setContentView(R.id.activity_main)]
4. To get reference of any view, we can use the binding object:
Using View Binding in Fragments
We follow the same steps:
- Before the onCreateView() method, we create our binding object
2. Initialize our binding object in onCreateView()
3. To get reference of any view, we can use the binding object
Note: The name of the binding class is generated by converting the name of the XML file to camel case and adding the word “Binding” to the end. Similarly, the reference for each view is generated by removing underscores and converting the view name to camel case . For example, activity_main.xml becomes ActivityMainBinding, and you can access @id/text_view as binding.textView.
View binding has important advantages over using findViewById():
- Null safety: Since view binding creates direct references to views, there’s no risk of a null pointer exception due to an invalid view ID.
- Type safety: The fields in each binding class have types matching the views they reference in the XML file. This means that there’s no risk of a class cast exception.
Start using View Binding
If you’re intrigued by View Binding and want to learn more about it, here’s some resources for you to learn:
One-Liner ViewBinding Library
You would have noticed that to use View Binding, we need to call the static inflate() method included in the generated binding class ( which creates an instance of the binding class for the activity or fragment )
Yesterday I came across an awesome library that makes ViewBinding one-liner ( By removing the boilerplate code and easily set ViewBindings with a single line )
One-liner ViewBinding Library : [Click Here]
Источник
Use view binding to replace findViewById
New in Android Studio 3.6, view binding gives you the ability to replace findViewById with generated binding objects to simplify code, remove bugs, and avoid all the boilerplate of findViewById .
- Enable view binding in build.gradle (no libraries dependencies)
- View binding generates a binding object for every layout in your module ( activity_awesome.xml → ActivityAwesomeBinding.java )
- Binding object contains one property for every view with an id in the layout — with the correct type and null-safety
- Full support for both the Java programming language and Kotlin
Update build.gradle to enable view binding
You don’t need to include any extra libraries to enable view binding. It’s built into the Android Gradle Plugin starting with the versions shipped in Android Studio 3.6. To enable view binding, configure viewBinding in your module-level build.gradle file.
In Android Studio 4.0, viewBinding has been moved into buildFeatures [release notes] and you should use:
Once enabled for a project, view binding will generate a binding class for all of your layouts automatically. You don’t have to make changes to your XML — it’ll automatically work with your existing layouts.
View binding works with your existing XML, and will generate a binding object for each layout in a module.
You can use the binding class whenever you inflate layouts such as Fragment , Activity , or even a RecyclerView Adapter (or ViewHolder ).
Use view binding in an Activity
If you have a layout called activity_awesome.xml , which contains a button and two text views, view binding generates a small class called ActivityAwesomeBinding that contains a property for every view with an ID in the layout.
You don’t have to call findViewById when using view binding — instead just use the properties provided to reference any view in the layout with an id.
The root element of the layout is always stored in a property called root which is generated automatically for you. In an Activity ’s onCreate method you pass root to setContentView to tell the Activity to use the layout from the binding object.
Easy Mistake: Calling setContentView(…) with the layout resource id instead of the inflated binding object is an easy mistake to make. This causes the layout to be inflated twice and listeners to be installed on the wrong layout object.
Solution: When using view binding in an Activity , you should always pass the layout from the binding object with setContentView(binding.root) .
Safe code using binding objects
findViewById is the source of many user-facing bugs in Android. It’s easy to pass an id that’s not in the current layout — producing null and a crash. And, since it doesn’t have any type-safety built in it’s easy to ship code that calls findViewById
(R.id.image) . View binding replaces findViewById with a concise, safe alternative.
View bindings are…
- Type-safe because properties are always correctly typed based on the views in the layout. So if you put a TextView in the layout, view binding will expose a TextView property.
- Null-safe for layouts defined in multiple configurations. View binding will detect if a view is only present in some configurations and create a @Nullable property.
And since the generated binding classes are regular Java classes with Kotlin-friendly annotations, you can use view binding from both the Java programming language and Kotlin.
What code does it generate?
View binding generates a Java class that replaces the need for findViewById in your code. It will generate one binding object for every XML layout in your module while mapping names so activity_awesome.xml maps to ActivityAwesomeBinding.java .
When editing an XML layout in Android Studio, code generation will be optimized to only update the binding object related to that XML file, and it will do so in memory to make things fast. This means that changes to the binding object are available immediately in the editor and you don’t have to wait for a full rebuild.
Android Studio is optimized to update the binding objects immediately when editing XML layouts.
Let’s step through the generated code for the example XML layout from earlier in this post to learn what view binding generates.
View binding will generate one correctly-typed property for each view with a specified id . It will also generate a property called rootView that’s exposed via a getter getRoot . View binding doesn’t do any logic– it just exposes your views in a binding object so you can wire them up without error-prone calls to findViewById . This keeps the generated file simple (and avoids slowing down builds).
If you’re using Kotlin, this class is optimized for interoperability. Since all properties are annotated with @Nullable or @NonNull Kotlin knows how to expose them as null-safe types. To learn more about interop between the languages, check out the documentation for calling Java from Kotlin.
In ActivityAwesomeBinding.java , view binding generates a public inflate method. The one argument version passes null as the parent view and doesn’t attach to parent. View binding also exposes a three argument version of inflate that lets you pass the parent and attachToParent parameters when needed.
The call to bind is where the magic happens. It will take the inflated layout and bind all of the properties, with some error checking added to generate readable error messages.
The bind method is the most complex code in the generated binding object, with a call to findViewById for each view to bind. And here you can see the magic happen – since the compiler can check the types and potential nullability of each property directly from the XML layouts it can safely call findViewById .
Note, the actual generated code for the bind method is longer and uses a labeled break to optimize bytecode. Check out this post by Jake Wharton to learn more about the optimizations applied.
On each binding class, view binding exposes three public static functions to create a binding an object, here’s a quick guide for when to use each:
- inflate(inflater) – Use this in an Activity onCreate where there is no parent view to pass to the binding object.
- inflate(inflater, parent, attachToParent) – Use this in a Fragment or a RecyclerView Adapter (or ViewHolder ) where you need to pass the parent ViewGroup to the binding object.
- bind(rootView) – Use this when you’ve already inflated the view and you just want to use view binding to avoid findViewById . This is useful for fitting view binding into your existing infrastructure and when refactoring code to use ViewBinding .
What about included layouts
One binding object will be generated for each layout.xml in a module. This is true even when another layout s this this layout.
In the case of included layouts, view binding will create a reference to the included layout’s binding object.
Note that the tag has an id: android:id=»@+id/includes» . This is required for view binding to generate a property (just like a normal view).
Include tags must have an id to generate a binding property.
View binding will generate a reference to the IncludedButtonsBinding object in ActivityAwesomeBinding .
Using view binding and data binding
View binding is only a replacement for findViewById . If you also want to automatically bind views in XML you can use the data binding library. Both libraries can be applied to the same module and they’ll work together.
When both are enabled, layouts that use a tag will use data binding to generate binding objects. All other layouts will use view binding to generate binding objects.
You can use data binding and view binding in the same module.
We developed view binding in addition to data binding because many developers provided feedback that they wanted a lighter weight solution to replace findViewById without the rest of the data binding library – and view binding provides that solution.
View binding and Kotlin synthetics or ButterKnife
One of the most common questions asked about view binding is, “Should I use view binding instead of Kotlin synthetics or ButterKnife?” Both of these libraries are used successfully by many apps and solve the same problem.
For most apps we recommend trying out view binding instead of these libraries because view binding provides safer, more concise view lookup.
While ButterKnife validates nullable/non-null at runtime, the compiler does not check that you’ve correctly matched what’s in your layouts
We recommend trying out view binding for safe, concise, view lookup.
Learn more
To learn more about view binding check out the official documentation.
And we’d love to hear your experiences with #ViewBinding library on twitter!
Источник