Non-transitive R information turned obtainable for all modules in AGP 4.2. Non-transitive R information hold your builds sooner and your AAB/APKs smaller. This publish will clarify learn how to implement and construct your utility with non-transitive R information.

Not transitive what?

In arithmetic, non-transitivity is a property of binary relations that aren’t transitive relations. This may embrace any relation that isn’t transitive, or the stronger property of antitransitivity, which describes a relation that’s by no means transitive.

https://en.wikipedia.org/wiki/Intransitivity

Does that mathematical quote assist us in any respect? Most likely not. Let’s do that: Sure A depends upon B. Y B. depends upon C., A do not learn about C.. Within the Android world, non-transitive R information:

Non-transitive R courses permit every library’s R class namespace in order that its R class contains solely the assets declared within the library itself and not one of the library’s dependencies, thus decreasing the dimensions of the R class to that library.

This weblog publish is just not about how the R file works and the historical past concerned, if you’re within the background I’d advocate this blog post here.

non-transitive modules

If the module A depends upon B. Y B. depends upon C.. How can we reference assets? We’ll see:

Module A You possibly can reference your personal assets (as regular):

R.string.hello_world

Module A you may reference the module B. assets (full bundle):

com.my.moduleB.R.string.hello_neighbour

Module A module can’t be referenced C.the assets of .

---

You should utilize non-transitive R courses with the Android Gradle plugin (> 4.2) to create sooner builds for purposes with a number of modules. …This results in extra up-to-date builds and the corresponding advantages of construct avoidance.

https://developer.android.com/studio/releases#refactor-nontransitive-rclasses

Advantages of non-transitive R courses?

• Decreased AAB/APK measurement, together with DEX Field Reference Count
• Decreased incremental construct pace as fewer dependencies might be included when making adjustments
• Elevated modularity, dependencies grow to be extra express
• Decreased complexity, assets can not come from transitive dependencies
• Lowering general construct period as much less code is included

Let’s do it!

You possibly can activate this setting your self by modifying your /gradle.properties file to incorporate:

android.nonTransitiveRClass=true

_{You will have examine android.namespacedRClass previously. Please observe that as of August 2020; android.namespacedRClass the property was renamed android.nonTransitiveRClass. as shown here.}

EITHER

You should utilize Android Studio’s automated refactor, this can activate the above configuration and search via your modules attempting to completely qualify any R references it finds.

Notice that this refactor was added in Android Studio Arctic Fox | 2020.3.1 “automated refactoring for non-transitive R information”. as shown here.

This auto-refactor is just not a panacea, it could have some incorrect useful resource references, i.e. it can add the incorrect bundle identify earlier than the R class otherwise you will not be capable of select one in any respect, or it can add one which your module does not have a dependency on. . In my expertise, these points are caught at compile time, and you’ll select from the three troubleshooting steps under, to complete what the refactoring instrument began:

As soon as that is completed, you have to to compile your venture and repair any errors. Errors can are available in a couple of codecs:

1. It makes use of a useful resource from one other module.
   Organize: Add the absolutely certified bundle, import the R file, or (Kotlin solely) use an alias.

   // Totally qualifed bundle
val foo = com.my.moduleB.R.string.hello_neighbour
// Import then use string.hello_neighbour
import com.my.moduleB.R
// Alias then use RB.string.hello_neighbour
import com.my.moduleB.R as RB

2. It makes use of a useful resource from one other module, however doesn’t declare it as a dependency on that module.
   Organize: Do as #1 but in addition add the dependency in gradle.

   implementation venture(":libraries:moduleB")

3. You employ a useful resource from one other module, however you do not declare a dependency on that module, and you do not wish to declare a dependency.
   Organize: The answer right here is both generate a reference and use the identical identify or copy/create a brand new useful resource of no matter you need.

conclusion

That is it, which is straightforward sufficient for me to say, however in follow, relying on the dimensions of your venture, you may need many hours forward of you, debugging/discovering the place your assets are coming from and which one is the right one. identify of the bundle to make use of. I extremely advocate for any new venture that you just activate nonTransitiveRClass earlier than having to take care of the results sooner or later.