Come posso implementare l'auto increrement della versione con codice gradle?

Question

In particolare ho alcune configurazioni di build:

signingConfigs { 
    debug { 
     keyAlias '' 
     keyPassword '' 
     storeFile file('') 
    } 
    release { 
     keyAlias '' 
     keyPassword '' 
     storeFile file('') 
     storePassword '' 
    } 
} 
.... 
defaultConfig { 
    applicationId "" 
    minSdkVersion 21 
    targetSdkVersion 23 
    versionCode code 
} 

Voglio che il Gradle a AutoIncrement versione del codice ogni volta che viene eseguito il 'rilascio'.

Quello che ho finora:

def code = 1; 

//Get all the gradle task names being run 
List<String> runTasks = gradle.startParameter.getTaskNames(); 

for (String item : runTasks) { 

    //Get the version.properties file. Its our custom file for storing a code version, please don't remove it 
    def versionPropsFile = file('version.properties') 

    def Properties versionProps = new Properties() 

    //This will prevent the gradle from exploding when there's no file yet created 
    if (versionPropsFile.exists()) 
     versionProps.load(new FileInputStream(versionPropsFile)) 

    //It will insert the "0" version in case the file does not exist 
    code = (versionProps['VERSION_CODE'] ?: "0").toInteger() 

    if (item.contains("release")) { 
     // If we're building up on Jenkins, increment the version strings 
     code++ 

     versionProps['VERSION_CODE'] = code.toString() 

     //It will overwrite the file even if it doesn't exist 
     versionProps.store(versionPropsFile.newWriter(), null) 
    } 
} 

Il problema:

non riesco a entrare if (item.contains("release")). È sempre falso, ma sicuramente vedo che gradle gestisce questo taks. Come posso risolvere il problema o almeno produrre in console tutte le attività (i loro nomi) gestite da gradle?

Answer 1

git può disponibile, segui questo link: Automatic versioning and increment using Git tags and Gradle

android { 
    defaultConfig { 
    ... 
     // Fetch the version according to git latest tag and "how far are we from last tag" 
     def longVersionName = "git -C ${rootDir} describe --tags --long".execute().text.trim() 
     def (fullVersionTag, versionBuild, gitSha) = longVersionName.tokenize('-') 
     def(versionMajor, versionMinor, versionPatch) = fullVersionTag.tokenize('.') 

     // Set the version name 
     versionName "$versionMajor.$versionMinor.$versionPatch($versionBuild)" 

     // Turn the version name into a version code 
     versionCode versionMajor.toInteger() * 100000 + 
       versionMinor.toInteger() * 10000 + 
       versionPatch.toInteger() * 1000 + 
       versionBuild.toInteger() 

     // Friendly print the version output to the Gradle console 
     printf("\n--------" + "VERSION DATA--------" + "\n" + "- CODE: " + versionCode + "\n" + 
       "- NAME: " + versionName + "\n----------------------------\n") 
    ... 
    } 
} 

Answer 2

Prova questa. Lo uso in tutte le mie applicazioni e funziona bene.Prima, crea un file version.properties nella cartella/app /. Questo file dovrebbe apparire come sotto. Qui VERSION_CODE indica il campo versionCode nella tua app. Questo dovrebbe essere incrementato sempre mentre VERSION_NAME indica patch minori nel nome della tua versione. (ad es. x.x.12).

/app/version.properties

VERSION_NAME=0  
VERSION_CODE=0 

Poi, nel tuo livello di modulo, il file build.Gradle aggiungere seguente codice nel blocco defaultconfig. Questo incrementerà il codice versione e il nome della versione di 1 dopo ogni build di rilascio. (Fondamentalmente, quando assambleRelease compito Gradle eseguito. Se si dispone di diverso nome del tipo di costruzione cambiamento compito secondo il vostro requisito.)

/app/build.gradle

//Version code increment 
    def versionPropsFile = file('version.properties') 
    if (versionPropsFile.canRead()) { 
     //load the version.properties file 
     def Properties versionProps = new Properties() 
     versionProps.load(new FileInputStream(versionPropsFile)) 

     /** 
     * get the name of currently running task 
     */ 
     def runTasks = gradle.startParameter.taskNames 

     /** 
     * Value to increment in minor version & version code. 
     */ 
     def incrementCount = 0 

     //Build version code and build type logic. 
     if (':storeFinder:assembleRelease' in runTasks) { 

      //if it is Production build package increment the version code by 1. 
      incrementCount = 1; 
     } 

     //generate new version code 
     def code = versionProps['VERSION_CODE'].toInteger() + incrementCount 
     def minorPatch = versionProps['VERSION_NAME'].toInteger() + incrementCount 

     //write new versionCode/version name suffix back to version.properties 
     versionProps['VERSION_CODE'] = code.toString() 
     versionProps['VERSION_NAME'] = minorPatch.toString() 
     versionProps.store(versionPropsFile.newWriter(), null) 

     //here version code is decided by above code. 
     //noinspection GroovyAssignabilityCheck 
     versionCode code 
     versionName "1.0." + minorPatch; //e.g. 1.0.61 

    } else { 
     //version.properties file not found. 
     throw new GradleException("Could not read version.properties! Copy that to /app folder from version control.") 
    } 

Answer 3

mia implementazione di questo problema :

Ho un file di versione che contiene il numero di versione. Da questo file otteniamo la versione. Quando la build contiene l'attività "publishRelease" (può essere qualsiasi altra attività), aumentiamo la versione nel file di versione. Mi piace questa soluzione perché mantiene il defaultConfig pulito della logica di codifica.

I version.properties

VERSION_CODE=45 

e nella parte Android config

defaultConfig { 
    applicationId "..." 
    minSdkVersion 16 
    targetSdkVersion 23 
    versionCode getVersion() 
    versionName "0.2." + versionCode 
} 

e getVersion()

def getVersion() { 
    def versionPropertiesFile = file('version.properties') 
    def appVersion = -1; 

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

     versionProps.load(new FileInputStream(versionPropertiesFile)) 

     appVersion = versionProps['VERSION_CODE'].toInteger() 

     def runTasks = gradle.startParameter.taskNames 
     if ('publishRelease' in runTasks) { 
      print("Increase version to " + appVersion + '\n') 

      appVersion += 1 

      versionProps['VERSION_CODE'] = appVersion.toString() 
      versionProps.store(versionPropertiesFile.newWriter(), null) 
     } 

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

    return appVersion; 
} 

Answer 4

Prendo seguente codice da Plaid app dalla googler Nick Butcher È davvero pulito.

apply plugin: 'com.android.application' 

// query git for the SHA, Tag and commit count. Use these to automate versioning. 
def gitSha = 'git rev-parse --short HEAD'.execute([], project.rootDir).text.trim() 
def gitTag = 'git describe --tags'.execute([], project.rootDir).text.trim() 
def gitCommitCount = 100 + Integer.parseInt('git rev-list --count HEAD'.execute([], project.rootDir).text.trim()) 

android { 
    compileSdkVersion 23 
    buildToolsVersion "23.0.3" 

    defaultConfig { 
     applicationId 'net.hadifar.dope' 
     minSdkVersion 14 
     targetSdkVersion 23 
     versionName gitTag 
     versionCode gitCommitCount 
     buildConfigField "String", "GIT_SHA", "\"${gitSha}\"" 

    } 

    lintOptions { 
     abortOnError false 
    } 

    compileOptions { 
     sourceCompatibility JavaVersion.VERSION_1_7 
     targetCompatibility JavaVersion.VERSION_1_7 
    } 

    buildTypes { 
     release { 
      minifyEnabled false 
      shrinkResources true 
      proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' 
     } 
    } 
    productFlavors {} 
} 
ext { 
    supportLibVersion = '23.3.0' 
} 

dependencies { 
    compile fileTree(include: ['*.jar'], dir: 'libs') 

    compile "com.android.support:appcompat-v7:${supportLibVersion}" 
}