android déployer - Comment définir le nom de version dans le fichier APK en utilisant gradle?





publier upload (12)


Une autre alternative est d'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 va mettre "appname-1.0.0" à toutes vos sorties apk.

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 que ça ressemble à myapp-release-1.0.apk .

J'ai essayé de renommer les options qui semblent désordonnées. Y a-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 aucune chance. Aucune suggestion? (en utilisant le gradage 1.6)




Gradle 4

La syntaxe a changé un peu 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)
        }
    }
}



Cela a résolu mon problème: en utilisant 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")) 
        }
    }       
}

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



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

  • saveur
  • type de construction
  • version
  • rendez-vous amoureux

Il m'a fallu un peu de recherche dans les classes graduées et un peu de copier / coller à partir d'autres réponses. J'utilise Gradle 2.1.3 (non testé dans d'autres versions).

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.each { 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"

            output.outputFile = new File(output.outputFile.parent, 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 choisi:

  • dev debug : myProject_ dev_debug_1.3.6 _131016_1047.apk
  • dev version : myProject_ dev_release_1.3.6 _131016_1047.apk
  • prod debug : myProject_prod_debug_1.2.0 _131016_1047.apk
  • sortie de prod : myProject_ prod_release_1.2.0 _131016_1047.apk

Note: le nom apk non aligné est toujours celui par défaut.




    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

ajout d'un SUFFIX à la version Debug, dans ce cas j'ai ajouté le texte "-DEBUG" à mon déploiement Debug

 buildTypes {
        release {

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


        }
        debug {

            defaultConfig {
                debuggable true

                versionNameSuffix "-DEBUG"
            }
        }
    }



Il y a beaucoup de réponses qui sont correctes en totalité ou après quelques modifications. Mais je vais ajouter le mien de toute façon puisque j'avais le problème avec chacun d'entre eux parce que j'utilisais des scripts pour générer VersionName et VersionCode dynamiquement en accrochant dans la tâche preBuild .

Si vous utilisez une approche similaire, voici 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 preBuild je dois ajouter le nom du fichier à la fin de cette tâche. Alors, quel gradle fera dans ce cas est:

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




Pour les dernières versions, 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 puisque j'ai le seul - fonctionne parfaitement pour moi.




Dans mon cas, je voulais juste trouver un moyen d'automatiser la génération de différents noms d' apk pour les variantes de release et de debug . J'ai réussi à le faire facilement en mettant cet extrait comme un enfant d' 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




À partir de Android Studio 1.1.0, j'ai trouvé cette combinaison fonctionnait dans le corps android du fichier build.gradle . C'est si vous ne pouvez pas comprendre comment importer les données du fichier manifeste xml. Je souhaite qu'il soit plus supporté par Android Studio, mais jouez juste avec les valeurs jusqu'à ce que vous obteniez la sortie du nom d'apk désiré:

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



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

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.and[email protected]67e7625f.

Vous devriez changer la partie build.Types à 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"))
                }
            }
        }
    }



Vous pouvez essayer DexPatcher . Il s'intègre même avec Android Studio. Il utilise apktool et Dex2Jar interne.
Vous pouvez également utiliser ces outils de manière indépendante. apktool décompile apktool , et extrait les fichiers .dex, qui peuvent être convertis en jar en utilisant Dex2Jar. Jar peut être décompilé en utilisant JD-GUI . Vous pouvez voir le code Java à l'aide de cet outil. Bien que la similitude du code décompilé au code réel ne peut pas être garantie. Il existe sur le marché des outils perfectionnés d' obfuscation de code , qui gâchent le code pour le rendre difficile à décompiler / comprendre. par exemple. Proguard





android build gradle apk android-gradle