J'essaie de définir un numéro de version spécifique dans le nom de fichier APK généré automatiquement par gradle.

Maintenant, gradle génère myapp-release.apkmais je veux qu'il ressemble à quelque chose comme myapp-release-1.0.apk.

J'ai essayé de renommer des options qui semblent désordonnées. Existe-t-il un moyen simple de le faire?

buildTypes {
    release {
       signingConfig signingConfigs.release
       applicationVariants.each { variant ->
       def file = variant.outputFile
       variant.outputFile = new File(file.parent, file.name.replace(".apk", "-" +    defaultConfig.versionName + ".apk"))
    }
}

J'ai essayé le code ci-dessus sans succès. Aucune suggestion? (en utilisant gradle 1.6)

Je n'ai qu'à changer le nom de la version à un seul endroit. Le code est également simple.

Les exemples ci-dessous créeront des fichiers apk nommés MyCompany-MyAppName-1.4.8-debug.apk ou MyCompany-MyAppName-1.4.8-release.apk en fonction de la variante de construction sélectionnée.

Notez que cette solution fonctionne à la fois sur les fichiers APK et sur les bundles d'applications (fichiers .aab) .

Voir aussi: Comment changer le nom du fichier de mappage proguard dans le projet gradle pour Android

Solution pour le plugin Gradle récent

android {
    compileSdkVersion 22
    buildToolsVersion "22.0.1"
    defaultConfig {
        applicationId "com.company.app"
        minSdkVersion 13
        targetSdkVersion 21
        versionCode 14       // increment with every release
        versionName '1.4.8'   // change with every release
        setProperty("archivesBaseName", "MyCompany-MyAppName-$versionName")
    }
}

La solution ci-dessus a été testée avec les versions suivantes du plug-in Android Gradle:

• 3.5.2 (novembre 2019)
• 3.3.0 (janvier 2019)
• 3.1.0 (mars 2018)
• 3.0.1 (novembre 2017)
• 3.0.0 (octobre 2017)
• 2.3.2 (mai 2017)
• 2.3.1 (avril 2017)
• 2.3.0 (février 2017)
• 2.2.3 (décembre 2016)
• 2.2.2
• 2.2.0 (septembre 2016)
• 2.1.3 (août 2016)
• 2.1.2
• 2.0.0 (avril 2016)
• 1.5.0 (12/11/2015)
• 1.4.0-bêta6 (05/10/2015)
• 1.3.1 (11/08/2015)

Je mettrai à jour ce post au fur et à mesure que de nouvelles versions sortiront.

Solution testée uniquement sur les versions 1.1.3-1.3.0

La solution suivante a été testée avec les versions suivantes du plug-in Android Gradle:

• 1.3.0 (2015/07/30) - Ne fonctionne pas, bug prévu pour être corrigé dans la 1.3.1
• 1.2.3 (21/07/2015)
• 1.2.2 (28/04/2015)
• 1.2.1 (27/04/2015)
• 1.2.0 (26/04/2015)
• 1.2.0-bêta1 (2015/03/25)
• 1.1.3 (06/03/2015)

fichier de gradle d'application:

apply plugin: 'com.android.application'

android {
    compileSdkVersion 21
    buildToolsVersion "21.1.2"
    defaultConfig {
        applicationId "com.company.app"
        minSdkVersion 13
        targetSdkVersion 21
        versionCode 14       // increment with every release
        versionName '1.4.8'   // change with every release
        archivesBaseName = "MyCompany-MyAppName-$versionName"
    }
}

Cela a résolu mon problème: utiliser applicationVariants.allau lieu deapplicationVariants.each

buildTypes {
      release {
        signingConfig signingConfigs.release
        applicationVariants.all { variant ->
            def file = variant.outputFile
            variant.outputFile = new File(file.parent, file.name.replace(".apk", "-" + defaultConfig.versionName + ".apk")) 
        }
    }       
}

Mettre à jour:

Il semble donc que cela ne fonctionne pas avec les versions 0.14+ du plugin android studio gradle.

Cela fait l'affaire (référence de cette question ):

android {
    applicationVariants.all { variant ->
        variant.outputs.each { output ->
            output.outputFile = new File(
                    output.outputFile.parent,
                    output.outputFile.name.replace(".apk", "-${variant.versionName}.apk"))
        }
    }
}

(MODIFIÉ pour fonctionner avec Android Studio 3.0 et Gradle 4)

Je cherchais une option de changement de nom de fichier apk plus complexe et j'ai écrit celle-ci dans l'espoir qu'elle soit utile pour quelqu'un d'autre. Il renomme l'apk avec les données suivantes:

• saveur
• type de construction
• version
• Date

Il m'a fallu un peu de recherche dans les classes Gradle et un peu de copier / coller d'autres réponses. J'utilise gradle 3.1.3 .

Dans le build.gradle:

android {

    ...

    buildTypes {
        release {
            minifyEnabled true
            ...
        }
        debug {
            minifyEnabled false
        }
    }

    productFlavors {
        prod {
            applicationId "com.feraguiba.myproject"
            versionCode 3
            versionName "1.2.0"
        }
        dev {
            applicationId "com.feraguiba.myproject.dev"
            versionCode 15
            versionName "1.3.6"
        }
    }

    applicationVariants.all { variant ->
        variant.outputs.all { output ->
            def project = "myProject"
            def SEP = "_"
            def flavor = variant.productFlavors[0].name
            def buildType = variant.variantData.variantConfiguration.buildType.name
            def version = variant.versionName
            def date = new Date();
            def formattedDate = date.format('ddMMyy_HHmm')

            def newApkName = project + SEP + flavor + SEP + buildType + SEP + version + SEP + formattedDate + ".apk"

            outputFileName = new File(newApkName)
        }
    }
}

Si vous compilez aujourd'hui (13-10-2016) à 10:47, vous obtenez les noms de fichiers suivants en fonction de la saveur et du type de construction que vous avez choisis:

• débogage de développement : myProject_ dev_debug_1.3.6 _131016_1047.apk
• version de développement : myProject_ dev_release_1.3.6 _131016_1047.apk
• débogage prod : myProject_ prod_debug_1.2.0 _131016_1047.apk
• version de production : myProject_ prod_release_1.2.0 _131016_1047.apk

Remarque: le nom apk de la version non alignée est toujours celui par défaut.

Pour résumer, pour ceux qui ne savent pas comment importer un package dans build.gradle(comme moi), utilisez ce qui suit buildTypes,

buildTypes {
      release {
        signingConfig signingConfigs.release
        applicationVariants.all { variant ->
            def file = variant.outputFile
            def manifestParser = new com.android.builder.core.DefaultManifestParser()
            variant.outputFile = new File(file.parent, file.name.replace(".apk", "-" + manifestParser.getVersionName(android.sourceSets.main.manifest.srcFile) + ".apk")) 
        }
    }       
}

===== MODIFIER =====

Si vous définissez votre versionCodeet versionNamedans votre build.gradlefichier comme ceci:

defaultConfig {
    minSdkVersion 15
    targetSdkVersion 19
    versionCode 1
    versionName "1.0.0"
}

Vous devriez le définir comme ceci:

buildTypes {   
        release {
            signingConfig signingConfigs.releaseConfig
            applicationVariants.all { variant ->
                def file = variant.outputFile
                variant.outputFile = new File(file.parent, file.name.replace(".apk", "-" + defaultConfig.versionName + ".apk"))
            }
        }
}

====== MODIFIER avec Android Studio 1.0 ======

Si vous utilisez Android Studio 1.0, vous obtiendrez une erreur comme celle-ci:

Error:(78, 0) Could not find property 'outputFile' on com.android.build.gradle.internal.api.ApplicationVariantImpl_Decorated@67e7625f.

Vous devriez changer la build.Typespièce en ceci:

buildTypes {
        release {
            signingConfig signingConfigs.releaseConfig
            applicationVariants.all { variant ->
                variant.outputs.each { output ->
                    output.outputFile = new File(output.outputFile.parent, output.outputFile.name.replace(".apk", "-" + defaultConfig.versionName + ".apk"))
                }
            }
        }
    }

Si vous ne spécifiez pas versionName dans le bloc defaultConfig, defaultConfig.versionNamecela entraîneranull

pour obtenir versionName à partir du manifeste, vous pouvez écrire le code suivant dans build.gradle:

import com.android.builder.DefaultManifestParser

def manifestParser = new DefaultManifestParser()
println manifestParser.getVersionName(android.sourceSets.main.manifest.srcFile)

Dans mon cas, je voulais juste trouver un moyen d'automatiser la génération de différents apknoms releaseet debugvariantes. J'ai réussi à le faire facilement en mettant cet extrait de code en tant qu'enfant de android:

applicationVariants.all { variant ->
    variant.outputs.each { output ->
        def appName = "My_nice_name_"
        def buildType = variant.variantData.variantConfiguration.buildType.name
        def newName
        if (buildType == 'debug'){
            newName = "${appName}${defaultConfig.versionName}_dbg.apk"
        } else {
            newName = "${appName}${defaultConfig.versionName}_prd.apk"
        }
        output.outputFile = new File(output.outputFile.parent, newName)
    }
}

Pour le nouveau plugin Android gradle 3.0.0, vous pouvez faire quelque chose comme ça:

 applicationVariants.all { variant ->
    variant.outputs.all {
        def appName = "My_nice_name_"
        def buildType = variant.variantData.variantConfiguration.buildType.name
        def newName
        if (buildType == 'debug'){
            newName = "${appName}${defaultConfig.versionName}_dbg.apk"
        } else {
            newName = "${appName}${defaultConfig.versionName}_prd.apk"
        }
        outputFileName = newName
    }
}

Cela produit quelque chose comme: My_nice_name_3.2.31_dbg.apk

Une autre alternative consiste à utiliser ce qui suit:

String APK_NAME = "appname"
int VERSION_CODE = 1
String VERSION_NAME = "1.0.0"

project.archivesBaseName = APK_NAME + "-" + VERSION_NAME;

    android {
      compileSdkVersion 21
      buildToolsVersion "21.1.1"

      defaultConfig {
        applicationId "com.myapp"
        minSdkVersion 15
        targetSdkVersion 21
        versionCode VERSION_CODE
        versionName VERSION_NAME
      }

       .... // Rest of your config
}

Cela définira "appname-1.0.0" sur toutes vos sorties apk.

6e année et plus

J'utilise maintenant ce qui suit dans Android Studio 4.0 et Gradle 6.4:

android {
    defaultConfig {
        applicationId "com.mycompany.myapplication"
        minSdkVersion 21
        targetSdkVersion 29
        versionCode 15
        versionName "2.1.1"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
            applicationVariants.all { variant ->
                variant.outputs.all {
                    outputFileName = "ApplicationName-${variant.name}-${variant.versionName}.apk"
                }
            }
        }
    }
}

Gradle 4

La syntaxe a un peu changé dans Gradle 4 (Android Studio 3+) (de output.outputFileà outputFileName, l'idée de cette réponse est maintenant:

android {
    applicationVariants.all { variant ->
        variant.outputs.each { output ->
            def newName = outputFileName
            newName.replace(".apk", "-${variant.versionName}.apk")
            outputFileName = new File(newName)
        }
    }
}

La bonne façon de renommer apk, selon @Jon answer

defaultConfig {
        applicationId "com.irisvision.patientapp"
        minSdkVersion 24
        targetSdkVersion 22
        versionCode 2  // increment with every release
        versionName "0.2" // change with every release
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
        //add this line
        archivesBaseName = "AppName-${versionName}-${new Date().format('yyMMdd')}"
    }   

Ou une autre façon d'obtenir les mêmes résultats avec

android {
    ...

    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }

    applicationVariants.all { variant ->
        variant.outputs.all { output ->
            def formattedDate = new Date().format('yyMMdd')
            outputFileName = "${outputFileName.replace(".apk","")}-v${defaultConfig.versionCode}-${formattedDate}.apk"
        }
    }
}

Il existe de nombreuses réponses correctes soit dans leur intégralité, soit après quelques modifications. Mais je vais quand même ajouter le mien car j'avais le problème avec tous parce que j'utilisais des scripts pour générer dynamiquement VersionName et VersionCode en m'accrochant à la preBuildtâche.

Si vous utilisez une approche similaire, c'est le code qui fonctionnera:

project.android.applicationVariants.all { variant ->
    variant.preBuild.doLast {
    variant.outputs.each { output ->
        output.outputFile = new File(
                output.outputFile.parent,
                output.outputFile.name.replace(".apk", "-${variant.versionName}@${variant.versionCode}.apk"))
        }
    }
}

Pour expliquer: Puisque je remplace le code et le nom de la version dans la première action de, preBuildje dois ajouter le changement de nom du fichier à la fin de cette tâche. Donc ce que gradle fera dans ce cas est:

Injecter le code / le nom de la version-> faire des actions de pré-construction -> remplacer le nom pour apk

    applicationVariants.all { variant ->
        variant.outputs.all { output ->
            output.outputFileName = output.outputFileName.replace(".apk", "-${variant.versionName}.apk")
        }
    }

Dans mon cas, je résous cette erreur de cette façon

ajouter un SUFFIXE à la version de débogage, dans ce cas j'ajoute le texte "-DEBUG" à mon déploiement de débogage

 buildTypes {
        release {

            signingConfig signingConfigs.release
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'


        }
        debug {

            defaultConfig {
                debuggable true

                versionNameSuffix "-DEBUG"
            }
        }
    }

Pour les dernières versions de Gradle, vous pouvez utiliser l'extrait suivant:

Définissez d'abord l'emplacement du manifeste de votre application

 sourceSets {
        main {
            manifest.srcFile 'src/main/AndroidManifest.xml'
        {
    }

Et plus tard dans build.gradle

import com.android.builder.core.DefaultManifestParser

def getVersionName(manifestFile) {
    def manifestParser = new DefaultManifestParser();
    return manifestParser.getVersionName(manifestFile);
}

def manifestFile = file(android.sourceSets.main.manifest.srcFile);
def version = getVersionName(manifestFile)

buildTypes {
    release {
       signingConfig signingConfigs.release
       applicationVariants.each { variant ->
       def file = variant.outputFile
       variant.outputFile = new File(file.parent, file.name.replace(".apk", "-" +    versionName + ".apk"))
    }
}

Ajustez si vous avez différents manifestes par type de build. mais depuis que j'ai le seul - fonctionne parfaitement pour moi.

Depuis Android Studio 1.1.0, j'ai trouvé que cette combinaison fonctionnait dans le corps Android du build.gradlefichier. C'est si vous ne pouvez pas comprendre comment importer les données du fichier manifeste xml. J'aimerais qu'il soit plus pris en charge par Android Studio, mais jouez simplement avec les valeurs jusqu'à ce que vous obteniez la sortie de nom apk souhaitée:

defaultConfig {
        applicationId "com.package.name"
        minSdkVersion 14
        targetSdkVersion 21
        versionCode 6
        versionName "2"
    }
    signingConfigs {
        release {
            keyAlias = "your key name"
        }
    }
    buildTypes {
        release {
            minifyEnabled true
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'

            signingConfig signingConfigs.release
            applicationVariants.all { variant ->
                variant.outputs.each { output ->
                    output.outputFile = new File(output.outputFile.parent, output.outputFile.name.replace("app-release.apk", "appName_" + versionName + ".apk"))
                }
            }
        }
    }