Renaming Android app Bundle and APK (.aab and .apk) files with app name, version and build type - build.gradle.kts

ONLINECAST

2 min read

·

04-10-2024

8

0

Share

How to Rename Your Android App Bundle and APK Files for Better Organization

Developing Android apps often involves managing multiple build variants, each with distinct configurations and target audiences. Keeping track of these variations becomes easier when your app bundle (.aab) and APK (.apk) files are named consistently, reflecting their version, build type, and even the app name itself. This article will guide you through renaming your Android app bundles and APKs using the power of Kotlin DSL in your build.gradle.kts file.

The Problem: Unclear File Names

Imagine a scenario where you're working on a project with several build types: "debug", "release", and "staging". Without proper naming conventions, your app bundle and APK files might end up looking like this:

• app-debug.aab
• app-release.aab
• app-staging.aab

While these names are technically correct, they lack context and become difficult to distinguish, especially when working with multiple apps or across different projects.

The Solution: Dynamic File Naming with Gradle

The Kotlin DSL in your build.gradle.kts file offers a convenient way to customize the naming of your app bundle and APK files. Here's how you can implement this:

android {
    ...
    buildTypes {
        getByName("debug") {
            isDebuggable = true
            applicationIdSuffix = ".debug"

            // Rename the APK and AAB files for debug build
            applicationVariants.all {
                outputs.all {
                    outputFileName = "${applicationId.replace(".", "_")}-${versionName}-${versionCode}-${buildType.name}.apk"
                    // For AAB, replace ".apk" with ".aab"
                    outputFileName = "${applicationId.replace(".", "_")}-${versionName}-${versionCode}-${buildType.name}.aab"
                }
            }
        }

        getByName("release") {
            isDebuggable = false
            // Similar naming conventions for release and other build types
        }
        ...
    }
}

Explanation:

1. android.buildTypes: The buildTypes block allows you to customize the behavior of each build variant.
2. getByName(): This function allows you to access and modify specific build types.
3. applicationVariants.all { ... }: This block iterates over all application variants generated for each build type.
4. outputs.all { ... }: This block iterates over all outputs, which include the APK or AAB files.
5. outputFileName: This property defines the name of the output file. We use string interpolation to include the app's applicationId, versionName, versionCode, and buildType.name for clear identification.

Further Considerations:

• applicationIdSuffix: This property is used to append a suffix to the package name for a specific build type. This can help differentiate between debug and release builds.
• applicationId: Replace dots with underscores to avoid invalid file name characters.
• Customization: You can modify the naming convention to fit your project's needs. For instance, you might want to add a date stamp or a project code for better organization.

Advantages of Dynamic Naming:

• Clarity: Consistent naming facilitates identification and management of different app versions.
• Organization: Easier to locate specific builds and their corresponding files.
• Automation: Eliminates manual renaming, reducing the chance of errors and saving time.

By implementing this dynamic renaming scheme in your build.gradle.kts file, you can streamline your Android app development workflow and ensure that your app bundles and APKs are well-organized and easily identifiable.