- Awards Season
- Big Stories
- Pop Culture
- Video Games
How to Find the Right Template to Write a Document for Free
Writing documents can be a daunting task, especially if you’re not sure where to start. Fortunately, there are many free templates available online that can help you get started. Here are some tips on how to find the right template to write a document for free.
The first step in finding the right template is to search online. There are many websites that offer free document templates, so it’s important to take some time to browse through them and find one that best suits your needs. When searching, make sure to look for templates that are easy to use and have all the features you need.
Check Out Professional Templates
If you’re looking for a more professional-looking template, then it’s worth checking out some of the paid options available online. Professional templates often come with more features and customization options than free ones, so they can be worth the investment if you need something more polished and professional-looking.
IntelliJ IDEA 2023.2 Help
A Gradle task is a small piece of work that is performed in the Gradle build cycle. For more information on the task concept, see the Gradle documentation .
IntelliJ IDEA lets you run, debug and manage Gradle tasks in your project.
Run Gradle tasks
You can use several ways to run Gradle tasks such as run them from the Run Anything window, with a run configuration , from a context menu, and even run several tasks with one run configuration.
Run a Gradle task in the Run Anything window
In the Run Anything window, start typing a name of the task you want to execute. To execute several tasks, enter task names using space to separate each new task. Alternatively, scroll down to the Gradle tasks section and select the task you need. Press Enter .
If you have linked projects and want to run a task for the specified project then in the Run Anything window, in the top-right corner, from the Project list, select the name of the project and in the search field enter the name of your task.
IntelliJ IDEA runs the specified task and displays the result in the Run tool window.
IntelliJ IDEA also saves the task in the Run Anything window under the Recent section as well as under the Run Configurations node in the Gradle tool window.
Run a Gradle task via Run Configurations
You can add some additional parameters to your task, configure it as a run configuration , save it and use that run configuration in your project whenever you need.
Open the Gradle tool window.
Right-click the task for which you want to create the Run configuration.
From the context menu select Modify Run Configuration .
In Create Run Configuration: 'task name' , you can use the default settings or configure the additional options and click OK .
IntelliJ IDEA displays the task under the Run Configurations node.
Double-click the task to run it or right-click the task and from the context menu select Run .
Run a Gradle task from the context menu
Right-click a task that you want to run.
From the context menu select Run 'task name' .
Run several Gradle tasks simultaneously
You can create a run configuration for several tasks.
Select Run | Edit Configurations Alt+Shift+F10 .
The Run/Debug Configurations dialog opens.
On the right side of the Run/Debug Configurations dialog, in the Name field, enter the name of your configuration. Also, you can specify where you want to run your configuration. Use the Run on drop-down list to specify the run target option.
Use the Run section to specify settings for the run configuration.
As an example, check the following settings:
For example, specify clean and build , and add the argument --debug .
If you want to add VM options , click the Modify options link and in the dialog that opens, under Java section, select Add VM options . The VM options field is added to the run configuration, and you can specify the needed parameters. For example, specify -Xmx3g .
For more information about run configurations, refer to Run/debug configurations .
The created configuration is added to the Run Configurations node in the Gradle Projects tool window.
Double-click the configuration to run the task or right-click the configuration and select Run .
Debug Gradle tasks and scripts
You can debug Gradle tasks and scripts the same way you debug your regular applications.
IntelliJ IDEA opens one tab per debugging session for Gradle scripts and for your regular tests. The Debug tool window contains Frames and Variables , as well as the Console output.
You can perform stepping actions and stop on breakpoints that you set in build.gradle and in the regular test classes under a single tab in the debugging session.
Configure Gradle debugging process
Create a run/debug configuration . If you have the existing run/debug configuration, select it on the main menu, and click Edit Configurations .
On the Run/Debug Configurations page, click the Gradle Debug tab.
Use the following options to configure the gradle debugging process:
Debug Gradle scripts :
this option is disabled when you execute your test using left gutter in the editor or the context menu. This is done to speed up your debugging process.
Debug forked Gradle tasks in separate debug tabs : when this option is selected any new debugging process is run under the different tab in the Debug tool window. By default, this option is disabled and the debugging process is performed under the same tab.
Debug all tasks on the execution graph : when you select this option, every task in the execution graph will be debugged. For example, all the dependent tasks of the task you are trying to debug will be debugged as well.
Debug a Gradle script task
Open your build.gradle in the editor.
IntelliJ IDEA starts the debugging session, and you can check the results in the Debug tool window.
Debug a Gradle task
Use the Gradle tool window to debug Gradle tasks that implement the org.gradle.process.JavaForkOptions interface, for example, test or run .
In the Gradle tool window, click the project, open the Tasks node, and right-click a task you want to debug.
From the context menu, select Debug .
The debugging process is started and the task is added to the list of the recent tasks located under the Run Configurations node.
Assign a shortcut to a Gradle task
IntelliJ IDEA lets you assign shortcuts to Gradle tasks and execute those tasks with a single key. You can also assign a shortcut to the Gradle run/debug configuration that can contain more than one task.
In the Gradle tool window, right-click the desired task.
From the context menu, choose Assign Shortcut .
The Keymap dialog opens.
In the Keymap dialog, under the Gradle node navigate to your task.
Right-click the task and from the list that opens, select a type of the shortcut you want to assign.
In the dialog that opens, depending on the shortcut's type, configure your shortcut and click OK .
In our case let's add a keyboard shortcut.
You can see that the shortcut is displayed against your task in the Gradle tool window.
While in the Keymap dialog, you can add a new task to which you want to assign a shortcut.
In the Keymap dialog, under the Gradle node, click Choose a task to assign a shortcut .
In the dialog that opens, select a task you need and click OK .
The task is added to the list under the Gradle node. Now you can configure the shortcut .
Configure running triggers for Gradle tasks
IntelliJ IDEA lets you run Gradle tasks before your project's execution or set other conditions using the task activation configuration.
In the Gradle tool window, right-click a Gradle project.
From the context menu, select Tasks Activation .
On the Choose activation phase menu, choose when to run your task, for example, Before Build , After Sync , and so on.
On the Choose task menu, select the actual task.
The task and activation phase will be added to the list in the Task Activation dialog. You can also see the activation phase name against the selected task in the Gradle tool window.
Alternatively, you can select the activation phase name from the context menu when you right-click the task you want to execute in the Gradle tool window.
You can also create a run/debug configuration that would depend on a Gradle task.
Go to Run | Edit Configurations to open the run/debug configuration for your project.
In the list that opens, select Run Gradle task .
In the Select Gradle Task dialog, specify the project and the task that you want to execute before launching the project. You can specify a Gradle linked project or any other Gradle project. Note that if your Gradle project is not linked then IntelliJ IDEA will use the default configurations (for example, a bundled Gradle version) to run the task.
Create your own gradle tasks and plugins in less than 10 minutes, stop being afraid of gradle and make it work for you.
As Android developers, we use Gradle on a daily basis to configure our Android projects.
We are used to interacting with:
- settings.gradle.kts which lists the modules used in a project.
- build.gradle.kts which allows us to configure Plugins and Tasks we want to use, the dependencies , etc… For instance, if you use the com.android.application plugin, you will define minSdk version and buildTypes configuration.
Sometimes, we add a new Plugin that “magically” brings new features and new DSLs to configure them.
We are more consumers than producers of these tools. Instead, we could develop our own Tasks and Plugins to fit our needs, making Gradle work for us and help us in our life as Android developers.
Who this article is for
- People who want to automate some tasks.
- People who want to understand how the tools they use daily work.
What you’ll learn
- What is a Task, how to create one, and how to use it.
- What is a Plugin, how to create one, and how to use it.
What will we build?
In this tutorial, we’ll develop a Plugin that copy in a new directory:
- the released APK
- the released Bundle
- the mapping file
The new directory will be named according to the Android application version code.
This Plugin can be useful for versioning your release apps to later easily test app migration or simply test old versions.
We won’t explain the Files management logic of this Plugin to stay focused on the Gradle part. If you want a simple implementation, check this Github Gist to get the code.
Write our first “enhanced” Task
Where to put the code.
There are several possibilities:
- Directly in a Gradle module build.gradle.kt :
- Pros: It’s the easiest way to create a Task. It will be automatically available for use without doing anything else.
- Cons: The Task is not available outside the script it’s defined in, so it’s not good for reusability.
2. In the buildSrc directory:
- Pros: Gradle automatically takes into account scripts inside this directory. Tasks will be available to all modules of the project.
- Pros: Your Task code is separated from where it’s used.
- Cons: A change in buildSrc causes the whole project to become out-of-date and requires syncing again, even for a small change.
3. Create a standalone project to generate a JAR
- Pros: We can use a plugin like maven-publish to release it on a repository.
- Pros: The compiled Task code is in a JAR, so client project synchronization won’t take time to compile it at each synchronization, unlike in the buildSrc solution.
- Cons: We have to set up a new project so it’s a little bit longer at the beginning.
Knowing Pro & Cons and for the simplicity of this article, we will write our code in the buildSrc directory but if you want to publish your Plugin, you will have to create a standalone project.
How to create a Task
If it doesn’t exist yet, create a buildSrc directory at the root of your project.
Add a build.gradle.kts containing the code:
kotlin-dsl plugin configures everything we need to write Kotlin code in the module.
Our Task will need some parameters to work:
- The location of the module directory the Task is setup in, to be able to retrieve generated release files.
- The app version to create the output directory.
- The directory location where to put the output.
Now, create an abstract class in src/main/kotlin called BundleReleaseFilesTask and put the following code:
First, we see the declaration of the 3 parameters our Task needs. There are also a lot of things to explain here:
- A DefaultTask is an abstract class that you must extend to create your own Task.
- Annotations @get:Input , @get:InputDirectory and @get:OutputDirectory are used to mark which parameters have an impact on the Task output. The goal of these annotations is to skip the Task execution if the output already exists and inputs didn’t change. This is called Incremental build . When you execute a Task and it’s marked UP-TO-DATE , it means it wasn’t executed because the output would have been the same as the existing one.
- @TaskAction indicates to Gradle which method it has to call when the Task is executed.
- Parameters are not primitive types but are Properties. A Property is lazy, the computation of its value is delayed until it’s used. If appVersion value comes from a computation, we will delay its computation until we use it.
To have a mutable Property , a variable has to be abstract . This explains why your Task is an abstract class. Gradle is in charge of providing an implementation of your Task that creates the Properties.
How to use our new Task
Register your Task in the build.gradle.kts of your application module.
This code needs some explanation.
- tasks is a TaskContainer . It allows to manage a set of Task instances. We use it to create our task instance. tasks is directly accessible in a Gradle files.
- register allows to define a new Task that will be lazyly created. The create method also exists to immediately create and configure a Task but it must be avoided to respect the Task Configuration Avoidance to not slow down the synchronization step.
- In the register method call, we set the classpath of our Task class and the name we give to our Task.
- Parameters are Properties. We have to call set to set a value.
How to execute our Task
Now that we have declared our Task, we can execute it. In a terminal, write:
Here is the output:
In the case we execute the Task again and none of the inputs or output parameters change, the Task is marked as UP-TO-DATE and it won’t be executed again.
Write our first Plugin
We know our custom Task is useful for our needs and so we think to share BundleReleaseFilesTask with other projects.
To have an identical usage everywhere, we want to define its name, its group and set a description to prevent clients from doing so.
To do that, we can create a Plugin that will contain this logic.
Before we continue:
- Remove from your build.gradle.kts the Task registration we previously did. Our Plugin will do the job.
- Change the visibility of BundleReleaseFilesTask to internal to force clients to apply our Plugin to use the Task.
How to write a Plugin
We put our Plugin code next to our Task in the module buildSrc in src/main/kotlin . Name it BundleReleaseFilesPlugin and put the following code:
There are several things to explain here:
- Plugin<T> is the interface to implement to create a Plugin. The apply method has to be overriden. It will contain the whole logic. This method is called when the Plugin is applied.
- T can be of several types Project , Settings and Gradle . Here we use Project because we want to add our Task to an Android Application module, so we will apply the Plugin in the build.gradle.kts of this module.
Make our Plugin usable
Before we add any logic to our Plugin, we will see how to make it usable by a Gradle module.
To do that, we use the java gradle plugin . It will help us create the jar containing our Plugin. The Plugin exposes a simple DSL to define:
- class : the classpath of our Plugin class.
- id : the string that will be used to identify the Plugin and apply it in a module.
In the case we have several Plugins to declare, we would add several blocks in plugins , one for each Plugin.
How to use our new Plugin
To use our Plugin and make Gradle execute the apply method, we have to apply it in the module we want to set it up.
We add it in the builds.gradle.kts of our app, next to other Plugins like Firebase , Google-services and the com.android.application .
Configure Plugin parameters
Our custom Task BundleReleaseFilesTask has some parameters. To make our Plugin work, we have to understand how to get these parameters to pass them to the Task.
We will use what we call an extension . It’s a simple Java/Kotlin bean with properties.
We need the following interface to match our Task parameters.
Gradle will be in charge of generating an implementation of this interface.
Note that we could have used an abstract class with abstract properties . It would be the same.
If you have been paying attention, you noticed that the rootProject parameter is not present here. Indeed, we don’t need it because we will retrieve the module path from the target parameter of the apply method.
Now, we create this extension in the apply method of our Plugin.
A Project has an ExtensionContainer used to create extensions. We set the name of our DSL and the class of the extension.
After that, we can use the extension variable to get the parameter values.
Now, let’s see how to declare the extension in our client module. Put the following code in the build.gradle.kts where you applied the Plugin.
We use the name given at the extension creation to declare the DSL. For the parameters, we do the same thing for the two parameters that we did to declare our Task parameters.
Register BundleReleaseFilesTask in our Plugin
We can finally register our Task. This is the same logic that when we implemented our Task in the build file.
There are 2 new parameters in the call to register the Task:
- group : Tasks are grouped according this information. In IntelliJ, the Gradle window allows to see all the available Tasks grouped.
- description : Explain what the Task does.
After the Task registration, we call configure on its instance to pass the values got from the extension.
For the rootProject Task parameter, we use the parameter target to get the projectDir. That’s why we were able to remove a parameter in our extension compared to our Task.
And that’s it, we configured everything to make our Plugin work. In the modules this plugin is applied, we can now execute the Task bundleReleaseFiles the same way that during the Task development.
To go further
There are still a lot of subjects to dig in to improve our Plugin:
- How to publish the Plugin to use it in other projects.
- Automatically execute our Task after the generation of the release files by adding dependsOn .
- Have a better DX by providing default parameter values using Convention .
- Improve our DSL to prevent clients to manage Properties and prevent them to call the set method on Properties.
This article was dense and we learned a lot of things:
- Extend DefaultTask to create your own Task .
- Use Property to declare lazy parameters that will be computed only when used.
- Use annotation @get:Input and @get:Output to use Incremental build and skip unnecessary work.
- Implement Plugin to create your own Plugin.
- Use an Extension to create a nice DSL to configure your Plugin.
- How to use a Task and how to use a Plugin in a Gradle module
With all these knowledge, you should have a clear view of how all the Tasks and Plugins you daily use work, and more importantly, you have now all the keys to create your own piece of logic and make your life easier by automating some work.
If you have any questions or comments, don’t hesitate to write them. It would be a pleasure to answer it.
Written by Torcheux Frédéric
I’m a French Android developer at MWM. I humbly try to contribute to the developer community from which I learnt everything.
More from Torcheux Frédéric and ProAndroidDev
Are you sure you know how Kotlin Flow works?
Test your kotlin flow knowledge through 8 code examples.
ViewModel: Events as State are an Antipattern
In this article nikita explores how a popular notion about expressing events as states may be a misleading one..
Evolving with Kotlin — Advanced Functional Programming Techniques
Deep dive with real world examples for more expressive and efficient code.
How ViewModel works under the hood
Learn how a viewmodel survives to a configuration change, recommended from medium.
GitHub Copilot With Android Studio
Github copilot are primarily designed to work with visual studio code (vs code), visual studio, jetbrains and neovim. and not supported….
Yudistiro Septian Dwi Saputro
Gradle Convention Plugins: A Powerful Tool for Reusing Build Configuration
Have you ever found yourself lost in the complexity of a modular project, struggling to maintain consistency and organization across your….
Medium Publications Accepting Story Submissions
Build and Publish multi-module Android library to Maven Central
Learn to build and publish your single or multi-module android library to maven central.
Using Version Catalogs from Gradle Precompiled Scripts with Kotlin DSL
In this concise article, we will explore the utilization of gradle version catalogs + gradle precompiled scripts using gradle kotlin dsl….
Modern Dependency Management: Gradle Version Catalogs and Convention Plugins
What you will find in this article is the process of defining a single source of truth for dependencies and their respective versions using….
Migrating My Build Gradle Files From Groovy To Kotlin DSL
An encyclopedia for the migration process of groovy dsl android gradle files to kotlin dsl.
Text to speech