web-dev-qa-db-fra.com

Comment définir versionName dans le nom du fichier APK à l'aide de gradle?

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

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

J'ai essayé de renommer des options qui semblent en désordre. Y a-t-il un moyen simple de faire cela?

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 le grade 1.6)

androidbuildgradleapkandroid-gradle
158
codaR0y

Cela a résolu mon problème: utiliser applicationVariants.all au lieu de applicationVariants.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")) 
        }
    }       
}

Mise à jour:

Il semble donc que cela ne fonctionne pas avec la version 0.14+ de Android plugin 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"))
        }
    }
}
171
codaR0y

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

Les exemples ci-dessous créeront des fichiers apk nommés 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 APK et Bundles d'applications (fichiers .aab).

Voir aussi: Comment changer le nom du fichier de mappage de proguard en dégradé pour le projet Android

Solution pour Gradine récent Plugin

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 de Android Gradle Plugin suivantes:

  • 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 (2015/11/12)
  • 1.4.0-beta6 (2015/10/05)
  • 1.3.1 (2015/08/11)

Je mettrai à jour ce post lorsque de nouvelles versions seront publiées.

Solution testée uniquement sur les versions 1.1.3-1.3.0

La solution suivante a été testée avec les versions de Android Gradle Plugin suivantes:

  • 1.3.0 (2015/07/30) - ne fonctionne pas, correction du bogue dans 1.3.1
  • 1.2.3 (2015/07/21)
  • 1.2.2 (2015/04/28)
  • 1.2.1 (2015/04/27)
  • 1.2.0 (2015/04/26)
  • 1.2.0-beta1 (2015/03/25)
  • 1.1.3 (2015/03/06)

fichier de classement de l'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"
    }
}
205
Jon

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

Je recherchais une option plus complexe de changement de nom de nom de fichier apk et j’ai écrit celle-ci dans l’espoir qu’elle serait utile à quiconque. 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 de diplômes et un peu de copier/coller d'autres réponses. J'utilise grade 3.1..

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 fichier suivants en fonction du type et du type de construction que vous avez choisis:

  • dev debug: myProject _dev_debug_1.3.6 _ 131016_1047.apk
  • version de dev: myProject _dev_release_1.3.6 _ 131016_1047.apk
  • prod debug: myProject _prod_debug_1.2. _ 131016_1047.apk
  • version du produit: myProject _prod_release_1.2. _ 131016_1047.apk

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

39
Fer

Pour résumer, pour ceux qui ne savent pas comment importer un paquet dans build.gradle (comme moi), utilisez le suivant 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")) 
        }
    }       
}

===== EDIT =====

Si vous définissez votre versionCode et versionName dans votre fichier build.gradle 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"))
            }
        }
}


====== EDIT 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 partie build.Types 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"))
                }
            }
        }
    }
18
Wesley

Si vous ne spécifiez pas versionName dans le bloc defaultConfig, alors defaultConfig.versionName entraînera null

pour obtenir le nom de version 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)
17
Arkadiusz Konior

Dans mon cas, je voulais juste trouver un moyen d’automatiser la génération de différentes variantes apk pour release et debug. J'ai réussi à le faire facilement en plaçant cet extrait 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 Android gradle plugin 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

8
yshahak

Grade 4

La syntaxe a un peu changé dans Gradle 4 (Android Studio 3+) (de output.outputFile à outputFileName, 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)
        }
    }
}
6
PHPirate

Une autre alternative consiste à utiliser les éléments suivants:

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.

5
Marco RS

La bonne façon de renommer apk, conformément à @ Jon réponse

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, vous pouvez 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"
        }
    }
}
5
Qamar

Il y a beaucoup de réponses qui sont correctes dans leur intégralité ou après quelques modifications. Mais je vais ajouter le mien quand même, car je rencontrais le problème avec chacun d’eux, car j’utilisais des scripts pour générer dynamiquement VersionName et VersionCode en s’accrochant à la tâche preBuild.

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: Depuis que je remplace le code de version et le nom dans la première action de preBuild, je dois ajouter le fichier renommé à la fin de cette tâche. Alors, quel sera le degré dans ce cas:

Injecter le code de version/nom-> faire des actions preBuild -> remplacer le nom pour apk

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

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

ajout d'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"
            }
        }
    }
1
exequielc

Depuis Android Studio 1.1.0, cette combinaison fonctionnait dans le corps Android du fichier build.gradle. Cela se produit si vous ne savez pas comment importer les données du fichier manifeste XML. J'aimerais que Android Studio prenne davantage en charge, mais il vous suffit de jouer avec les valeurs jusqu'à ce que vous obteniez le nom du fichier apk souhaité:

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"))
                }
            }
        }
    }
0
A13X

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

Définissez d'abord l'emplacement de votre manifeste d'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 construction. mais depuis que j'ai le seul - fonctionne parfaitement pour moi.

0
Alfishe