In the previous article, we explored how to automate feature creation using a Gradle task. Now, let’s take it a step further and implement a Gradle task that does the reverse — transforming an existing feature into a reusable template. This approach is invaluable for modular apps where features need to be replicated with slight variations.

What Will Be Generated?

The moveFeatureToTemplate Gradle task will generate a template version of the specified feature by extracting its structure and replacing feature-specific details with placeholders.

1. A New Template Directory

A new folder inside featureTemplate/ with the specified templateName (e.g., featureTemplate/screenTemplate).

2. Transformed Files

All files from the original feature (featureName) will be copied to the new template folder.

The feature-specific names, such as class names and package names, will be replaced with placeholders:

• {{packageName}} instead of the original package.
• {{featureName}} instead of the lowercase feature name.
• {{className}} instead of the PascalCase feature name.

3. Updated File Names

The new files in the template will have generic names instead of being tied to a specific feature. Example structure:

featureTemplate/
    ├── screenTemplate/
    │   ├── Screen.kt
    │   ├── UiState.kt
    │   └── ViewModel.kt

How It Works

The custom Gradle task simplifies the process of creating reusable templates from existing features in your Android project. This task scans a specific feature directory, extracts its structure and files, and transforms them into a generalized template format using placeholders. The resulting templates can then be reused for generating new features.

1. Input Directory and Feature Files

The Gradle task expects an existing feature directory under your project’s src/main/java/ folder. The feature directory contains files like <FeatureName>Screen.kt, <FeatureName>UiState.kt, and <FeatureName>ViewModel.kt.

Example of the feature directory structure:

src/main/java/com/example/app/<FeatureName>/
    ├── <FeatureName>Screen.kt
    ├── <FeatureName>UiState.kt
    └── <FeatureName>ViewModel.kt

For instance, if the feature name is Home, the directory might look like this:

src/main/java/com/example/app/home/
    ├── HomeScreen.kt
    ├── HomeUiState.kt
    └── HomeViewModel.kt

2. Generated Template Directory Structure

The task transforms the feature directory into a reusable template structure by creating placeholders ({{packageName}}, {{featureName}}, {{className}}) in the file contents and filenames. The generated template is stored in the featureTemplate directory under the specified template name.

Example of the generated template structure:

featureTemplate/
    ├── templateName/
    │   ├── Screen.kt
    │   ├── UiState.kt
    │   └── ViewModel.kt

If you convert the Home feature into a template called screenTemplate, the task will generate:

featureTemplate/
    ├── screenTemplate/
    │   ├── Screen.kt
    │   ├── UiState.kt
    │   └── ViewModel.kt

3. Placeholder Replacement

The task scans each file in the feature directory and replaces specific parts of the file names and contents with placeholders. This ensures that the feature can be reused for different features without manual adjustments. The following components are replaced with placeholders:

• File names: HomeScreen.kt becomes Screen.kt.
• Class names: The class name HomeScreen becomes {{className}}Screen.
• Package names: The actual package name (e.g., com.example.app.home) becomes {{packageName}}.

Example:

Input (HomeScreen.kt):

package com.example.app.home

import androidx.compose.runtime.Composable

@Composable
fun HomeScreen() {
    // TODO: Implement HomeScreen UI
}

Output Template (Screen.kt):

package {{packageName}}

import androidx.compose.runtime.Composable

@Composable
fun {{className}}Screen() {
    // TODO: Implement {{className}}Screen UI
}

This process allows the feature files to be converted into a generalized template format. When you need to create a new feature, the task will replace these placeholders with the correct values based on the feature you specify.

Implementation of Feature Template Automation in Android Project

To implement the automation of template generation in your Android project, follow the steps outlined below. These steps will guide you in setting up the necessary Gradle task, preparing feature files, and automatically generating templates from existing features.

Step 1: Setting Up the Gradle Task

The first step is to define a custom Gradle task in your build.gradle.kts file. This task will automatically generate the necessary template files based on the feature files you specify.

How It Works:

1. Defining Properties: The task will accept two properties:

• featureName: The name of the feature you want to use (e.g., Home).
• templateName: The type of template you want to generate (e.g., screenTemplate).
• rootFolderName: Identifies the directory containing your template files (default is featureTemplate).

2. Code Replacement: The task will read the feature files and replace actual values based on your project configuration to placeholders ({{featureName}}, {{className}}, and {{packageName}})

Code Implementation:

// build.gradle.kts (Module :app)
tasks.register("moveFeatureToTemplate") {
    val rootFolderName = "featureTemplate"

    val featureName = project.findProperty("featureName") as String?
        ?: error("Feature name is required. Use -PfeatureName=<name> to specify it.")

    val templateName = project.findProperty("templateName") as String?
        ?: error("Template name is required. Use -PtemplateName=<name> to specify it.")

    // Retrieve the base package name from the project configuration
    val basePackageName = project.android.defaultConfig.applicationId
        ?: error("Base package could not be detected. Ensure applicationId is set in defaultConfig.")

    val copyFilePath = projectDir.path + "/src/main/java/" + basePackageName.replace(".", "/")

    val placeholders = mapOf(
        basePackageName to "{{packageName}}",
        featureName.lowercase() to "{{featureName}}",
        featureName.replaceFirstChar { it.titlecase(Locale.getDefault()) } to "{{className}}",
    )

    doLast {

        val featureDir = File(copyFilePath, featureName.lowercase())
        val templateDir = File(rootDir, "$rootFolderName/$templateName")

        if (!featureDir.exists()) {
            throw IllegalArgumentException("Feature '$featureName' not exists.")
        }
        if (templateDir.exists()) {
            throw IllegalArgumentException("Template '$templateName' already exists.")
        }
        val fileName = featureName.replaceFirstChar {
            if (it.isLowerCase()) it.titlecase(
                Locale.getDefault()
            ) else it.toString()
        }
        featureDir.walkTopDown().filter { it.isFile }.forEach { file ->

            val findName = file.name.indexOf(fileName) + fileName.length
            val templateFileName = file.name.substring(findName, file.name.length)
            val targetFile = File(templateDir, templateFileName)
            targetFile.parentFile.mkdirs()

            var content = file.readText()
            placeholders.forEach { (key, value) ->
                content = content.replace(key, value)
            }
            targetFile.writeText(content)

            println("Generated file: $targetFile")
        }
        println("Template '$featureName' generated successfully in $templateDir")
    }
}

Step 2: Preparing the Feature Files

Ensure that the feature files exist in the project before running the task.

Step 3: Generating a Template

Run the following command from the terminal:

./gradlew moveFeatureToTemplate -P featureName=Home -P templateName=screenTemplate

Generated Template Successfully:

featureTemplate/
    ├── screenTemplate/
    │   ├── Screen.kt
    │   ├── UiState.kt
    │   └── ViewModel.kt

Customizations

1. Configurable Output Directory

Instead of always saving templates in featureTemplate/, allow the user to specify a custom output directory:

val outputDir = project.findProperty("outputDir") as String? ?: "featureTemplate"
val templateDir = File(rootDir, "$outputDir/$templateName")

2. Exclude Certain Files

You might not want to include test files, documentation, or specific files in the template. Modify the filtering logic to exclude them:

val excludedFiles = listOf("README.md", "test/", "androidTest/")
featureDir.walkTopDown()
    .filter { it.isFile && !excludedFiles.any { ex -> it.path.contains(ex) } }
    .forEach { file -> /* Process File */ }

3. Include Additional Placeholder Replacements

For further customization, extend the placeHoldersmap to replace additional project-specific values, such as:

val placeholders = mapOf(
    basePackageName to "{{packageName}}",
    featureName.lowercase() to "{{featureName}}",
    featureName.replaceFirstChar { it.titlecase(Locale.getDefault()) } to "{{className}}",
    "com.example.app" to "{{basePackage}}"
)

Benefits of Using Gradle for Feature Generation

Gradle provides a powerful automation framework for managing Android projects efficiently. Here’s why it’s a great choice for feature template automation:

1. Eliminates Manual Work

Manually copying and modifying files for every new feature is error-prone and time-consuming. This task automates the entire process, reducing human errors.

2. Ensures Consistency

Using a standardized template guarantees that all features follow the same structure, improving code maintainability and readability across the project.

3. Accelerates Development

Developers can focus on implementing features rather than boilerplate setup, significantly reducing onboarding time for new team members.

4. Fully Integrated with Build System

Since it runs inside Gradle, the template generation fits seamlessly into the existing Android build pipeline without requiring external scripts or tools.

5. Easy to Customize and Extend

Gradle allows developers to modify the task as per project requirements, whether by adding more placeholders, supporting multiple template types, or integrating it with CI/CD pipelines.

6. Version Control Friendly

Since the template transformation is deterministic and automated, it ensures that every developer gets the same template structure, avoiding inconsistencies in codebase contributions.

Conclusion

This Gradle task provides a streamlined way to extract existing feature modules and convert them into reusable templates. By automating the transformation process, it enhances maintainability and accelerates the development of new features. Stay tuned for further improvements and integrations in upcoming articles!

Note: If you need an example, check out my repository

. . .

This article is previously published on proandroiddev.com.