Create your personal Gradle Duties and Plugins

class growth

Cease being afraid of Gradle and make it be just right for you

As Android builders, we use Gradle every day to configure our Android initiatives.

We’re used to interacting with:

• settings.gradle.kts which lists the modules utilized in a venture.
• construct.gradle.kts permits us to configure the Plugins and Actions we wish to use, dependenciesand many others.. For instance, if you happen to use com.android.utility plugin, you’ll outline minSdk model and buildTypes configuration.

Typically we add a brand new “magical” Plugin that brings new options and a brand new DSL to configure them.

We’re extra shoppers than producers of those instruments. As an alternative, we are able to develop our personal Actions and Plugins to suit our wants, make Gradle work for us and assist us in our life as Android builders.

• Individuals who wish to automate some duties.
• Individuals who wish to perceive how the instruments they use day-after-day work.

1. What’s a job, tips on how to create it and tips on how to use it.
2. What’s a plugin, tips on how to create it and tips on how to use it.

On this tutorial we are going to develop a Copy Plugin in a brand new folder:

• Launched APKs
• Launch package deal
• mapping file

The brand new folder will likely be named after the Android app model code.

This plugin might be helpful for versioning your launched apps to later simply check app migrations or just to take a look at outdated variations.

We won’t clarify the file administration logic of this Plugin to give attention to the Gradle half. If you need easy implementation, examine this out Github gist to get the code.

The place to place the code?

There are a number of potentialities:

1. Instantly within the Gradle module construct.gradle.kt:

• Professionals: It is the simplest method to create Duties. It should mechanically be out there to make use of with out doing anything.
• Cons: The duty shouldn’t be out there exterior of the script through which it’s outlined, so not good for reusability.

2. In buildSrc class:

• Professionals: Gradle mechanically takes into consideration scripts inside this listing. The duty will likely be out there to all modules of the venture.
• Professionals: Your motion code is segregated from the place it is used.
• Cons: A change in buildSrc renders the complete venture out of date and requires re-syncing, even for a small change.

3. Create a standalone venture to create JAR

• Professionals: We will use a plugin like maven-publish to launch it on a repository.
• Benefit: The compiled Process Code is within the JAR, so syncing the consumer venture will not take time to compile it at every sync, in contrast to in buildSrc answer.
• Cons: We needed to arrange a brand new venture so it took some time to get began.

Know the Professionals & Cons and for the sake of simplicity for this text we are going to write our code in buildSrc folder however if you wish to publish your Plugin you’ll have to create a standalone venture.

How one can create a Quest

If it would not exist but, create one buildSrc folder on the root of your venture.

add one construct.gradle.kts incorporates code:

kotlin-dsl plugin configures all the pieces we have to write Kotlin code within the module.

Our job will want some parameters to work:

• The situation of the modules folder the place the Process is ready up in order that launch recordsdata might be retrieved.
• Software model to create output listing.
• The listing location the place the output is positioned.

Now let’s create a summary class IN src/predominant/kotlin name BundleReleaseFilesTask and put the next code:

First we have a look at the declaration of the three parameters that our Process wants. There’s additionally much more to clarify right here:

1. ONE DefaultTask is an summary class that it’s essential to lengthen to create your personal Actions.
2. Notice @get:Enter, @get:InputDirectory And @get:OutputDirectory is used to mark which parameters have an effect on the output of the Process. The aim of those annotations is to skip the execution of the Motion if the output already exists and the enter has not modified. that is known as incremental building. Once you execute a Motion and it’s marked UP-TO-DATEwhich means it isn’t executed as a result of the output would be the similar as the present output.
3. @TaskAction tells Gradle which methodology it should name when the Process is executed.
4. Parameters aren’t primitive sorts however Properties. ONE Asset lazy, its worth calculation is delayed till it’s used. If appVersion worth comes from a calculation, we are going to delay its calculation till we use it.

to have a property is topic to altera variable should be summary. This explains why your Process is an summary class. Gradle is accountable for offering your Motion implementation to create Properties.

How one can use our new Mission

Register your Duties in construct.gradle.kts of your app module.

This code wants some clarification.

• duties Is one MissionContainer. It permits to handle a set of duties. We use it to create our job occasion. duties straight accessible within the Gradle file.
• register lets outline a brand new Process to be created lazily. The create this methodology additionally exists for fast creation and configuration of a Process however should be averted out of respect Keep away from job configuration in order to not decelerate the sync step.
• inside register name the tactic, we set the classpath of our Motion class and the identify we give our Process.
• Parameter is Attribute. we have now to name set to set a price.

How one can carry out our job

Now that we have now our Process declared, we are able to execute it. In a terminal, write:

Right here is the output:

In case we execute the Motion once more and not one of the enter or output parameters change, the Motion is marked as UP-TO-DATE and it’ll not be executed once more.

We all know our Customized Mission is beneficial for our wants and so we thought to share BundleReleaseFilesTask with different initiatives.

For an an identical utilization in all places, we wish to outline its identify, group and set an outline to stop purchasers from doing so.

To do this, we are able to create a Plugin that incorporates this logic.

Earlier than we proceed:

1. Take away from yours construct.gradle.kts join the Process that we have executed earlier than. Our plugin will do the job.
2. Change the visibility of BundleReleaseFilesTask ARRIVE inside to drive prospects to use our Plugin to make use of Actions.

How one can write Plugins

We put the Plugin code subsequent to our Duties within the module buildSrc IN src/predominant/kotlin. Title it BundleReleaseFilesPlugin and put the next code:

There are some things to clarify right here:

• Plugin is the interface that must be applied to create a Plugin. The apply methodology should be overridden. It should include the complete logic. This methodology is known as when the Plugin is utilized.
• T There might be many sorts Undertaking, Settings And Gradle. Right here we use Undertaking as a result of we wish to add our Motion in Android App module, so we are going to apply Plugin in construct.gradle.kts of this module.

Make Our Plugin Usable

Earlier than we add any logic to our Plugin, we are going to see tips on how to make it usable utilizing the Gradle module.

To do this, we use java class plugin. It should assist us to create the jar containing our Plugin. The plugin exposes a easy DSL to outline:

• class: the classpath of our Plugin class.
• id:string will likely be used to establish the Plugin and apply it in a module.

In case we have now some Plugins to declare, we are going to add some blocks in pluginsone for every Plugin.

How one can Use Our New Plugin

To make use of our Plugin and make Gradle execute the command apply we have now to use it within the module we wish to set.

We add it in builds.gradle.kts of our app, moreover different Plugins like Firebase, Google-services and com.android.utility.

Configure Plugin Parameters

Our Customized Mission BundleReleaseFilesTask there are a number of parameters. For our Plugin to work, we have now to grasp tips on how to get these parameters to go them to the Motion.

We’ll use what we name a extension. It is a easy Java/Kotlin bean with properties.

We want the next interface to match our Process parameters.

Gradle will likely be accountable for creating an implementation of this interface.

Notice that we might have used a summary class with summary properties. Will probably be the identical.

In the event you’ve been paying consideration, you have observed that rootProject parameter shouldn’t be right here. Certainly we do not want it since we will likely be retrieving the module path from goal parameter of apply methodology.

Now, we create this extension in apply methodology of our Plugin.

ONE Undertaking just one ExtensionsContainer used to create the extension. We identify our DSL and the extension’s class.

Then we are able to use extension variable to get the parameter values.

Now let’s examine tips on how to declare the extension in our consumer module. Put the next code in construct.gradle.kts the place you utilized the Plugin.

We use the identify offered when creating the extension to declare the DSL. As for the parameters, we do the identical for the 2 that we did to declare our Process parameters.

Register BundleReleaseFilesTask in our Plugin

We will lastly register our Duties. This is similar logic as after we implement our Motion within the construct file.

There are 2 new parameters within the Process registration name:

• group: Duties are grouped by this info. In IntelliJ, the Gradle window permits to view all out there Duties grouped.
• description: Clarify what the Process does.

After registering for the Mission, we name configure in its case to go values ​​obtained from extension.

Give rootProject Process parameter, we use parameter goal to get projectDir. That is why we are able to take away a parameter in our vs Motion extension.

And that is it, we have configured all the pieces for our Plugin to work. In modules this plugin is utilized, now we are able to do Motion bundleReleaseFiles the identical method that in Process growth.

There are nonetheless a number of subjects to discover to enhance our Plugin:

• How one can publish Plugin to make use of it in different initiatives.
• Mechanically execute our Actions after creating launch recordsdata by including dependent.
• Get higher DX by offering default parameter values ​​utilizing Conference.
• Enhance our DSL to stop prospects from managing Properties and stop them from calling set methodology on Attribute.

This text was dense and we discovered so much:

• Lengthen DefaultTask to create your personal Process.
• Use Property to declare lazy parameters that will likely be computed solely when used.
• use annotations @get:Enter And @get:Output to make use of the Incremental construct and skip the pointless work.
• Carry out Plugin to create your personal Plugin.
• use one Extension to create a pleasant DSL to configure your Plugin.
• How one can use Actions and tips on how to use Plugins in Gradle modules

With all this data, you’ll have a transparent view of how all of the Actions and Plugins you employ day-after-day, and extra importantly, you now have all of the The important thing to creating your personal logic and making your life simpler by automating some duties.

In case you have any questions or feedback, do not hesitate to jot down them. Will probably be a pleasure to reply it.