web-dev-qa-db-fra.com

AutoCréation VersionCode avec gradle des propriétés supplémentaires

Je construis une application Android avec Gradle. Jusqu'à présent, j'utilisais le fichier Manifest pour augmenter le code de version, mais j'aimerais lire le code de version à partir d'un fichier externe et, selon qu'il s'agisse de la version ou de la version de débogage, augmenter le code de version. J'ai essayé les propriétés supplémentaires, mais vous ne pouvez pas les enregistrer, ce qui signifie que la prochaine fois que je les construirai, je recevrai le même code versionCode. Toute aide serait très appréciée!

project.ext{
    devVersionCode = 13
    releaseVersionCode = 1
}

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'com.Android.tools.build:gradle:0.6.+'
    }
}

apply plugin: 'Android'

repositories {
    mavenCentral()
}

dependencies {
    compile project(':Cropper')
    compile "com.Android.support:appcompat-v7:18.0.+"
    compile "com.Android.support:support-v4:18.0.+"
    compile fileTree(dir: 'libs', include: '*.jar')
}

def getReleaseVersionCode() {
    def version = project.releaseVersionCode + 1
    project.releaseVersionCode = version
    println sprintf("Returning version %d", version)
    return version
}

def getDevVersionCode() {
    def version = project.devVersionCode + 1
    project.devVersionCode = version
    println sprintf("Returning version %d", version)
    return version
}


def getLastVersioName(versionCode) {
    return "0.0." + versionCode
}

Android {
    compileSdkVersion 19
    buildToolsVersion "19.0.0"

    defaultConfig {
        minSdkVersion 9
        targetSdkVersion 19
    }

    sourceSets {
        main {
            manifest.srcFile 'AndroidManifest.xml'
            Java.srcDirs = ['src']
            resources.srcDirs = ['src']
            aidl.srcDirs = ['src']
            renderscript.srcDirs = ['src']
            res.srcDirs = ['res']
            assets.srcDirs = ['assets']
        }
    }

    buildTypes {
        release {
            runProguard true
            proguardFile getDefaultProguardFile('proguard-Android-optimize.txt')
            proguardFile 'proguard.cfg'
            debuggable false
            signingConfig null
            zipAlign false
        }
        debug {
            versionNameSuffix "-DEBUG"
        }
    }
    productFlavors {
        dev {
            packageName = 'com.swisscom.docsafe.debug'
            versionCode getDevVersionCode()
            versionName getLastVersioName(project.devVersionCode)
        }
        prod {
            packageName = 'com.swisscom.docsafe'
            versionCode getReleaseVersionCode()
            versionName getLastVersioName(project.releaseVersionCode)
        }
    }
}

task wrapper(type: Wrapper) {
    gradleVersion = '1.8'
}
androidgradleandroid-gradlebuild.gradle
107
carvaq

J'aimerais lire le versionCode à partir d'un fichier externe

Je suis sûr qu'il existe un certain nombre de solutions possibles. en voici un:

Android {
    compileSdkVersion 18
    buildToolsVersion "18.1.0"

    def versionPropsFile = file('version.properties')

    if (versionPropsFile.canRead()) {
        def Properties versionProps = new Properties()

        versionProps.load(new FileInputStream(versionPropsFile))

        def code = versionProps['VERSION_CODE'].toInteger() + 1

        versionProps['VERSION_CODE']=code.toString()
        versionProps.store(versionPropsFile.newWriter(), null)

        defaultConfig {
            versionCode code
            versionName "1.1"
            minSdkVersion 14
            targetSdkVersion 18
        }
    }
    else {
        throw new GradleException("Could not read version.properties!")
    }

    // rest of Android block goes here
}

Ce code s'attend à ce qu'un fichier version.properties existant, que vous créez manuellement avant la première génération, contienne VERSION_CODE=8.

Ce code remplace simplement le code de version sur chaque construction - vous auriez besoin d'étendre la technique pour gérer votre code de version par saveur.

Vous pouvez voir le projet exemple de gestion des versions qui illustre ce code.

187
CommonsWare

Voici une modernisation de ma réponse précédente qui peut être vu ci-dessous. Celui-ci fonctionne avec Gradle 4.4 et Android Studio 3.1.1.

Ce que fait ce script:

  • Crée un fichier version.properties s'il n'en existe pas (votez pour la réponse de Paul Cantrell ci-dessous, d'où j'ai eu l'idée si vous aimez cette réponse)
  • Le numéro de VERSION_BUILD augmente à chaque version, version de débogage ou chaque fois que vous appuyez sur le bouton Exécuter de Android Studio.
  • Chaque fois que vous assemblez une version, votre Android versionCode pour le Play Store augmente et votre numéro de correctif augmente.
  • Bonus: Une fois la construction terminée, copie votre apk sur projectDir/apk pour le rendre plus accessible.

Ce script va créer un numéro de version qui ressemble à v1.3.4 (123) et construire un fichier apk comme AppName-v1.3.4.apk.

Major version ⌄       ⌄ Build version
             v1.3.4 (123)
  Minor version ⌃|⌃ Patch version

Version majeure: Doit être modifié manuellement pour des modifications plus importantes.

Version mineure: Doit être modifié manuellement pour des changements légèrement moins importants.

Version du correctif: Augmente lors de l'exécution de gradle assembleRelease

Version de la version: Augmente chaque version

Numéro de version: Identique à Patch version , il s'agit du code de version que Play Store doit avoir augmenté pour chaque nouvel apk. télécharger.

Il suffit de changer le contenu des commentaires 1 à 3 ci-dessous et le script devrait faire le reste. :)

Android {
    compileSdkVersion 27
    buildToolsVersion '27.0.3'

    def versionPropsFile = file('version.properties')
    def value = 0
    Properties versionProps = new Properties()
    if (!versionPropsFile.exists()) {
        versionProps['VERSION_PATCH'] = "0"
        versionProps['VERSION_NUMBER'] = "0"
        versionProps['VERSION_BUILD'] = "-1" // I set it to minus one so the first build is 0 which isn't super important. 
        versionProps.store(versionPropsFile.newWriter(), null)
    }

    def runTasks = gradle.startParameter.taskNames
    if ('assembleRelease' in runTasks) {
        value = 1
    }

    def mVersionName = ""
    def mFileName = ""

    if (versionPropsFile.canRead()) {
        versionProps.load(new FileInputStream(versionPropsFile))

        versionProps['VERSION_PATCH'] = (versionProps['VERSION_PATCH'].toInteger() + value).toString()
        versionProps['VERSION_NUMBER'] = (versionProps['VERSION_NUMBER'].toInteger() + value).toString()
        versionProps['VERSION_BUILD'] = (versionProps['VERSION_BUILD'].toInteger() + 1).toString()

        versionProps.store(versionPropsFile.newWriter(), null)

        // 1: change major and minor version here
        mVersionName = "v1.0.${versionProps['VERSION_PATCH']}"
        // 2: change AppName for your app name
        mFileName = "AppName-${mVersionName}.apk"

        defaultConfig {
            minSdkVersion 21
            targetSdkVersion 27
            applicationId "com.example.appname" // 3: change to your package name
            versionCode versionProps['VERSION_NUMBER'].toInteger()
            versionName "${mVersionName} Build: ${versionProps['VERSION_BUILD']}"
        }

    } else {
        throw new FileNotFoundException("Could not read version.properties!")
    }

    if ('assembleRelease' in runTasks) {
        applicationVariants.all { variant ->
            variant.outputs.all { output ->
                if (output.outputFile != null && output.outputFile.name.endsWith('.apk')) {
                    outputFileName = mFileName
                }
            }
        }
    }

    task copyApkFiles(type: Copy){
        from 'build/outputs/apk/release'
        into '../apk'
        include mFileName
    }

    afterEvaluate {
        assembleRelease.doLast {
            tasks.copyApkFiles.execute()
        }
    }

    signingConfigs {
        ...
    }

    buildTypes {
        ...
    }
}

=============================================== ==

RÉPONSE INITIALE:

Je veux aussi que le nom de version augmente automatiquement. C’est donc un ajout à la réponse de CommonsWare qui a parfaitement fonctionné pour moi. C'est ce qui fonctionne pour moi

defaultConfig {
    versionCode code
    versionName "1.1." + code
    minSdkVersion 14
    targetSdkVersion 18
}

EDIT:

Étant donné que je suis un peu paresseux, je veux que mon contrôle de version fonctionne aussi automatiquement que possible. Ce que je veux, c'est une Version de la version qui augmente avec chaque construction, tandis que le Numéro de version et Nom de la version n'augmente que lorsque je publie une version. construire.

C'est ce que j'utilise depuis un an. Les bases proviennent de la réponse de CommonsWare et de ma réponse précédente, ainsi que de quelques autres. Cela entraîne le contrôle de version suivant:

Nom de la version: 1.0.5 (123) -> Major.Minor.Patch (Build), Major et Minor sont modifiés manuellement.

Dans build.gradle:

...
Android {
    compileSdkVersion 23
    buildToolsVersion '23.0.1'
    def versionPropsFile = file('version.properties')
    if (versionPropsFile.canRead()) {
        def Properties versionProps = new Properties()

        versionProps.load(new FileInputStream(versionPropsFile))

        def value = 0

        def runTasks = gradle.startParameter.taskNames
        if ('assemble' in runTasks || 'assembleRelease' in runTasks || 'aR' in runTasks) {
            value = 1;
        }

        def versionMajor = 1
        def versionMinor = 0
        def versionPatch = versionProps['VERSION_PATCH'].toInteger() + value
        def versionBuild = versionProps['VERSION_BUILD'].toInteger() + 1
        def versionNumber = versionProps['VERSION_NUMBER'].toInteger() + value

        versionProps['VERSION_PATCH'] = versionPatch.toString()
        versionProps['VERSION_BUILD'] = versionBuild.toString()
        versionProps['VERSION_NUMBER'] = versionNumber.toString()

        versionProps.store(versionPropsFile.newWriter(), null)

        defaultConfig {
            versionCode versionNumber
            versionName "${versionMajor}.${versionMinor}.${versionPatch} (${versionBuild}) Release"
            minSdkVersion 14
            targetSdkVersion 23
        }

        applicationVariants.all { variant ->
            variant.outputs.each { output ->
                def fileNaming = "apk/RELEASES"
                variant.outputs.each { output ->
                    def outputFile = output.outputFile
                    if (outputFile != null && outputFile.name.endsWith('.apk')) {
                        output.outputFile = new File(getProject().getRootDir(), "${fileNaming}-${versionMajor}.${versionMinor}.${versionPatch}-${outputFile.name}")
                    }
                }
            }
        }

    } else {
        throw new GradleException("Could not read version.properties!")
    }

    ...
}

...

Le patch et le versionCode sont augmentés si vous assemblez votre projet via le terminal avec 'assemble', 'assembleRelease' ou 'aR' qui crée un nouveau dossier dans la racine de votre projet appelé apk/RELEASE afin que vous n'ayez pas à parcourir build/output/more/more/more pour trouver votre apk.

Les propriétés de votre version doivent ressembler à ceci:

VERSION_NUMBER=1
VERSION_BUILD=645
VERSION_PATCH=1

Évidemment, commencez par 0. :)

72
just_user

Une version légèrement plus précise de l'excellente réponse de CommonsWare crée le fichier de version s'il n'existe pas:

def Properties versionProps = new Properties()
def versionPropsFile = file('version.properties')
if(versionPropsFile.exists())
    versionProps.load(new FileInputStream(versionPropsFile))
def code = (versionProps['VERSION_CODE'] ?: "0").toInteger() + 1
versionProps['VERSION_CODE'] = code.toString()
versionProps.store(versionPropsFile.newWriter(), null)

defaultConfig {
    versionCode code
    versionName "1.1"
    minSdkVersion 14
    targetSdkVersion 18
}
34
Paul Cantrell

J'ai examiné quelques options pour le faire et ai finalement décidé qu'il était plus simple d'utiliser simplement l'heure actuelle pour le versionCode au lieu d'essayer d'incrémenter automatiquement le versionCode et de l'insérer dans mon système de contrôle de révision.

Ajoutez ce qui suit à votre build.gradle:

/**
 * Use the number of seconds/10 since Jan 1 2016 as the versionCode.
 * This lets us upload a new build at most every 10 seconds for the
 * next 680 years.
 */
def vcode = (int)(((new Date().getTime()/1000) - 1451606400) / 10)

Android {
    defaultConfig {
        ...
        versionCode vcode
    }
}

Toutefois, si vous envisagez de télécharger des versions au-delà de l'année 2696, vous pouvez utiliser une solution différente.

25
emmby

Une autre façon d'obtenir un versionCode automatiquement consiste à définir versionCode sur le nombre de validations de la branche extraite git. Il accomplit les objectifs suivants:

  1. versionCode est généré automatiquement et systématiquement sur toute machine (y compris un serveur Continuous Integration et/ou Continuous Deployment.).
  2. L'application avec cette versionCode peut être soumise à GooglePlay.
  3. Ne repose sur aucun fichier en dehors du repo.
  4. Ne pousse rien au repo
  5. Peut être remplacé manuellement si nécessaire

Utiliser la bibliothèque gradle-git pour atteindre les objectifs ci-dessus. Ajoutez le code ci-dessous à votre fichier build.gradle dans le répertoire /app:

import org.ajoberstar.grgit.Grgit

repositories {
    mavenCentral()
}

buildscript {
    repositories {
        mavenCentral()
    }

    dependencies {
        classpath 'org.ajoberstar:grgit:1.5.0'
    }
}

Android {
/*
    if you need a build with a custom version, just add it here, but don't commit to repo,
    unless you'd like to disable versionCode to be the number of commits in the current branch.

    ex. project.ext.set("versionCodeManualOverride", 123)
*/
    project.ext.set("versionCodeManualOverride", null)

    defaultConfig {
        versionCode getCustomVersionCode()
    }
}

def getCustomVersionCode() {

    if (project.versionCodeManualOverride != null) {
        return project.versionCodeManualOverride
    }

    // current dir is <your proj>/app, so it's likely that all your git repo files are in the dir
    // above.
    ext.repo = Grgit.open(project.file('..'))

    // should result in the same value as running
    // git rev-list <checked out branch name> | wc -l
    def numOfCommits = ext.repo.log().size()
    return numOfCommits
}

REMARQUE: pour que cette méthode fonctionne, il est préférable de ne déployer sur Google Play Store qu'à partir de la même branche (ex. master).

16
C0D3LIC1OU5

Récemment, je travaillais sur un plugin Gradle pour Android permettant de générer versionCode et versionName automatiquement. il y a beaucoup de personnalisation. ici vous pouvez trouver plus d'informations à ce sujet https://github.com/moallemi/gradle-advanced-build-version

12
moallemi

Une autre option, pour incrémenter versionCode et versionName, consiste à utiliser un horodatage.

defaultConfig {
   versionName "${getVersionNameTimestamp()}"
   versionCode getVersionCodeTimestamp()
}


def getVersionNameTimestamp() {
    return new Date().format('yy.MM.ddHHmm')
}

def getVersionCodeTimestamp() {
    def date = new Date()
    def formattedDate = date.format('yyMMddHHmm')
    def code = formattedDate.toInteger()
    println sprintf("VersionCode: %d", code)
    return code
}

À compter du 1 er janvier 2022 formatéDate = date.format ('yyMMddHHmm') dépasse la capacité d’entiers.

10
carvaq

Pour incrémenter versionCode uniquement dans la version, procédez comme suit:

Android {
    compileSdkVersion 21
    buildToolsVersion "21.1.2"

    def versionPropsFile = file('version.properties')
    def code = 1;
    if (versionPropsFile.canRead()) {
        def Properties versionProps = new Properties()

        versionProps.load(new FileInputStream(versionPropsFile))
        List<String> runTasks = gradle.startParameter.getTaskNames();
        def value = 0
        for (String item : runTasks)
        if ( item.contains("assembleRelease")) {
            value = 1;
        }
        code = Integer.parseInt(versionProps['VERSION_CODE']).intValue() + value
        versionProps['VERSION_CODE']=code.toString()
        versionProps.store(versionPropsFile.newWriter(), null)
    }
    else {
        throw new GradleException("Could not read version.properties!")
    }

    defaultConfig {
        applicationId "com.pack"
        minSdkVersion 14
        targetSdkVersion 21
        versionName "1.0."+ code
        versionCode code
    }

s'attend à ce qu'un fichier c://YourProject/app/version.properties existant, que vous créeriez manuellement avant la première construction, contienne VERSION_CODE=8

Fichier version.properties:

VERSION_CODE=8

10
NickUnuchek

Créer un fichier version.properties

MAJOR=1
MINOR=3
PATCH=6
VERSION_CODE=1

Changer build.gradle:

Android {
def _versionCode=0
def _major=0
def _minor=0
def _patch=0

def _applicationId = "com.example.test"

def versionPropsFile = file('version.properties')

if (versionPropsFile.canRead()) {
    def Properties versionProps = new Properties()

    versionProps.load(new FileInputStream(versionPropsFile))

    _patch = versionProps['PATCH'].toInteger() + 1
    _major = versionProps['MAJOR'].toInteger()
    _minor = versionProps['MINOR'].toInteger() 
    _versionCode= versionProps['VERSION_CODE'].toInteger()+1
    if(_patch==99)
    {
        _patch=0
        _minor=_minor+1
    }
    if(_major==99){
        _major=0
        _major=_major+1
    }

    versionProps['MAJOR']=_major.toString()
    versionProps['MINOR']=_minor.toString()
    versionProps['PATCH']=_patch.toString()
    versionProps['VERSION_CODE']=_versionCode.toString()
    versionProps.store(versionPropsFile.newWriter(), null)
}
else {
    throw new GradleException("Could not read version.properties!")
}
def _versionName = "${_major}.${_versionCode}.${_minor}.${_patch}"


compileSdkVersion 23
buildToolsVersion "23.0.3"

defaultConfig {
    applicationId _applicationId
    minSdkVersion 11
    targetSdkVersion 23
    versionCode _versionCode
    versionName _versionName
}

}

Sortie: 1.1.3.6

3
Ahmad Aghazadeh

Définir versionName dans AndroidManifest.xml

Android:versionName="5.1.5"

À l'intérieur du bloc Android{...} dans build.gradle du niveau de l'application:

defaultConfig {
        applicationId "com.example.autoincrement"
        minSdkVersion 18
        targetSdkVersion 23
        multiDexEnabled true
        def version = getIncrementationVersionName()
        versionName version
}

En dehors du bloc Android{...} dans build.gradle du niveau de l'application:

def getIncrementedVersionName() {
    List<String> runTasks = gradle.startParameter.getTaskNames();

    //find version name in manifest
    def manifestFile = file('src/main/AndroidManifest.xml')
    def matcher = Pattern.compile('versionName=\"(\\d+)\\.(\\d+)\\.(\\d+)\"').matcher(manifestFile.getText())
    matcher.find()

    //extract versionName parts
    def firstPart = Integer.parseInt(matcher.group(1))
    def secondPart = Integer.parseInt(matcher.group(2))
    def thirdPart = Integer.parseInt(matcher.group(3))

    //check is runTask release or not
    // if release - increment version
    for (String item : runTasks) {
        if (item.contains("assemble") && item.contains("Release")) {
            thirdPart++
            if (thirdPart == 10) {
                thirdPart = 0;
                secondPart++
                if (secondPart == 10) {
                    secondPart = 0;
                    firstPart++
                }
            }
        }
    }

    def versionName = firstPart + "." + secondPart + "." + thirdPart

    // update manifest
    def manifestContent = matcher.replaceAll('versionName=\"' + versionName + '\"')
    manifestFile.write(manifestContent)

    println "incrementVersionName = " + versionName

    return versionName
}

Après avoir créé le fichier APK:

Android:versionName="5.1.6"

Remarque: Si votre versionName différent de my, vous devez modifier regex et extraire la logique des parties.

1
Sergey Shustikov

dans la version 5.1.1 de Gradle sous mac ive changé la façon dont les noms de tâches étaient récupérés, bien que j'aie essayé d'obtenir la saveur/le type de construction à partir de la version, mais qu'il fût trop paresseux pour scinder le nom de la tâche:

def versionPropsFile = file('version.properties')
if (versionPropsFile.canRead()) {
    def Properties versionProps = new Properties()

    versionProps.load(new FileInputStream(versionPropsFile))

    def value = 0

    def runTasks = gradle.getStartParameter().getTaskRequests().toString()

    if (runTasks.contains('assemble') || runTasks.contains('assembleRelease') || runTasks.contains('aR')) {
        value = 1
    }

    def versionMajor = 1
    def versionMinor = 0
    def versionPatch = versionProps['VERSION_PATCH'].toInteger() + value
    def versionBuild = versionProps['VERSION_BUILD'].toInteger() + 1
    def versionNumber = versionProps['VERSION_NUMBER'].toInteger() + value

    versionProps['VERSION_PATCH'] = versionPatch.toString()
    versionProps['VERSION_BUILD'] = versionBuild.toString()
    versionProps['VERSION_NUMBER'] = versionNumber.toString()

    versionProps.store(versionPropsFile.newWriter(), null)

    defaultConfig {
        applicationId "de.evomotion.ms10"
        minSdkVersion 21
        targetSdkVersion 28
        versionCode versionNumber
        versionName "${versionMajor}.${versionMinor}.${versionPatch} (${versionBuild})"
        testInstrumentationRunner "Android.support.test.runner.AndroidJUnitRunner"
        signingConfig signingConfigs.debug
    }

} else {
    throw new GradleException("Could not read version.properties!")
}

le code provient de @just_user celui-ci

0
Basur

En utilisant le graphe de tâche de Gradle , nous pouvons vérifier/changer le type de construction .

L'idée de base est d'incrémenter le versionCode sur chaque build. Sur chaque construction, un compteur est stocké dans le fichier version.properties . Il sera mis à jour à chaque nouvelle génération d'APK et remplacera la chaîne versionCode dans le fichier build.gradle par cette valeur de compteur incrémentée.

apply plugin: 'com.Android.application'

Android {
compileSdkVersion 25
buildToolsVersion '25.0.2'

def versionPropsFile = file('version.properties')
def versionBuild

/*Setting default value for versionBuild which is the last incremented value stored in the file */
if (versionPropsFile.canRead()) {
    def Properties versionProps = new Properties()
    versionProps.load(new FileInputStream(versionPropsFile))
    versionBuild = versionProps['VERSION_BUILD'].toInteger()
} else {
    throw new FileNotFoundException("Could not read version.properties!")
}


/*Wrapping inside a method avoids auto incrementing on every gradle task run. Now it runs only when we build apk*/
ext.autoIncrementBuildNumber = {

    if (versionPropsFile.canRead()) {
        def Properties versionProps = new Properties()
        versionProps.load(new FileInputStream(versionPropsFile))
        versionBuild = versionProps['VERSION_BUILD'].toInteger() + 1
        versionProps['VERSION_BUILD'] = versionBuild.toString()
        versionProps.store(versionPropsFile.nminSdkVersion 14
        targetSdkVersion 21
        versionCode 1ewWriter(), null)
    } else {
        throw new FileNotFoundException("Could not read version.properties!")
    }
}


defaultConfig {
    minSdkVersion 16
    targetSdkVersion 21
    versionCode 1
    versionName "1.0.0." + versionBuild
}

buildTypes {
    release {
        minifyEnabled false
        proguardFiles getDefaultProguardFile('proguard-Android.txt'), 'proguard-rules.pro'
    }
}

// Hook to check if the release/debug task is among the tasks to be executed.
//Let's make use of it
gradle.taskGraph.whenReady {taskGraph ->
    if (taskGraph.hasTask(assembleDebug)) {  /* when run debug task */
        autoIncrementBuildNumber()
    } else if (taskGraph.hasTask(assembleRelease)) { /* when run release task */
        autoIncrementBuildNumber()
    }
  }
}

dependencies {
  compile fileTree(dir: 'libs', include: ['*.jar'])
  compile 'com.Android.support:appcompat-v7:25.3.1'
}

Placez le script ci-dessus dans votre fichier build.gradle du module principal.

Site Web de référence: http://devdeeds.com/auto-increment-build-number-using-grading-in-Android/

Merci et salutations!

0
Jayakrishnan PM

Les exemples ci-dessus ne fonctionnent pas pour différentes raisons

Voici ma variante prête à l'emploi basée sur les idées de cet article:

Android {
    compileSdkVersion 28

    // https://stackoverflow.com/questions/21405457

    def propsFile = file("version.properties")
    // Default values would be used if no file exist or no value defined
    def customAlias = "Alpha"
    def customMajor = "0"
    def customMinor = "1"
    def customBuild = "1" // To be incremented on release

    Properties props = new Properties()
    if (propsFile .exists())
        props.load(new FileInputStream(propsFile ))

    if (props['ALIAS'] == null) props['ALIAS'] = customAlias else customAlias = props['ALIAS']
    if (props['MAJOR'] == null) props['MAJOR'] = customMajor else customMajor = props['MAJOR']
    if (props['MINOR'] == null) props['MINOR'] = customMinor else customMinor = props['MINOR']
    if (props['BUILD'] == null) props['BUILD'] = customBuild else customBuild = props['BUILD']

    if (gradle.startParameter.taskNames.join(",").contains('assembleRelease')) {
        customBuild = "${customBuild.toInteger() + 1}"
        props['BUILD'] = "" + customBuild

        applicationVariants.all { variant ->
            variant.outputs.all { output ->
                if (output.outputFile != null && (output.outputFile.name == "app-release.apk"))
                    outputFileName = "app-${customMajor}-${customMinor}-${customBuild}.apk"
            }
        }
    }

    props.store(propsFile.newWriter(), "Incremental Build Version")

    defaultConfig {
        applicationId "org.example.app"
        minSdkVersion 21
        targetSdkVersion 28
        versionCode customBuild.toInteger()
        versionName "$customAlias $customMajor.$customMinor ($customBuild)"

        ...
    }
...
}
0
Alexander Gavriliuk

Le premier code commenté incrémentera le nombre lors de chaque "reconstruction du projet" et enregistrera la valeur dans le fichier "Version Property".

Le second code commenté générera le nouveau nom de version du fichier APK pendant que "Build APK".

Android {
    compileSdkVersion 28
    buildToolsVersion "29.0.0"
    //==========================START==================================
    def Properties versionProps = new Properties()
    def versionPropsFile = file('version.properties')
    if(versionPropsFile.exists())
        versionProps.load(new FileInputStream(versionPropsFile))
    def code = (versionProps['VERSION_CODE'] ?: "0").toInteger() + 1
    versionProps['VERSION_CODE'] = code.toString()
    versionProps.store(versionPropsFile.newWriter(), null)
    //===========================END===================================
    defaultConfig {
        applicationId "com.example.myapp"
        minSdkVersion 15
        targetSdkVersion 28
        versionCode 1
        versionName "0.19"
        testInstrumentationRunner "Android.support.test.runner.AndroidJUnitRunner"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-Android-optimize.txt'), 'proguard-rules.pro'
            //=======================================START===============================================
            Android.applicationVariants.all { variant ->
                variant.outputs.all {
                    def appName = "MyAppSampleName"
                    outputFileName = appName+"_v${variant.versionName}.${versionProps['VERSION_CODE']}.apk"
                }
            }
            //=======================================END===============================================
        }
    }
}
0
Radha Krishna

Crédits dans CommonsWare (Réponse acceptée) Paul Cantrell (Créer un fichier s'il n'existe pas) ahmad aghazadeh (Nom de la version et code)

Alors j'ai écrasé toutes leurs idées et je l'ai trouvé. Ceci est la solution de glisser-déposer pour exactement ce que le premier post a demandé.

Il mettra automatiquement à jour le code de version et le nom de version en fonction du statut de la version. Bien sûr, vous pouvez déplacer les variables pour répondre à vos besoins.

def _versionCode=0
def versionPropsFile = file('version.properties')
def Properties versionProps = new Properties()
if(versionPropsFile.exists())
    versionProps.load(new FileInputStream(versionPropsFile))
    def _patch = (versionProps['PATCH'] ?: "0").toInteger() + 1
    def _major = (versionProps['MAJOR'] ?: "0").toInteger()
    def _minor = (versionProps['MINOR'] ?: "0").toInteger()
    List<String> runTasks = gradle.startParameter.getTaskNames();
    def value = 0
    for (String item : runTasks)
        if ( item.contains("assembleRelease")) {
            value = 1;
        }
    _versionCode = (versionProps['VERSION_CODE'] ?: "0").toInteger() + value
    if(_patch==99)
    {
        _patch=0
        _minor=_minor+1
    }
    if(_major==99){
        _major=0
        _major=_major+1
    }

versionProps['MAJOR']=_major.toString()
versionProps['MINOR']=_minor.toString()
versionProps['PATCH']=_patch.toString()
versionProps['VERSION_CODE']=_versionCode.toString()
versionProps.store(versionPropsFile.newWriter(), null)
def _versionName = "${_major}.${_versionCode}.${_minor}.${_patch}"

compileSdkVersion 24
buildToolsVersion "24.0.0"

defaultConfig {
    applicationId "com.yourhost.yourapp"
    minSdkVersion 16
    targetSdkVersion 24
    versionCode _versionCode
    versionName _versionName
}
0
Thunderstick