How can I implement gradle version of code for automatic input?

Question

In particular, I have several build configurations:

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

I want gradle to automatically update the version of the code every time "release" is run.

What I still have:

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

Problem:

I cannot get inside if (item.contains("release")) . Its always a lie, but I definitely see that gradle starts this taks. How can I fix this, or at least print to the console all the tasks (their names) that are controlled by gradle?

Answer 1

My implementation of this problem:

I have a version file that contains the version number. From this file we get the version. When the assembly contains the publishRelease task (this can be any other task), we increase the version in the version file. I like this solution because it keeps Config clean by default from coding logic.

Parameters version.properties

 VERSION_CODE=45 

and in the Android configuration section

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

and 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 2

Try it. I use this throughout my application and work great. First create the version.properties file in the / app / folder. This file should look like this. Here VERSION_CODE indicates the versionCode field in your application. This needs to be constantly increased while VERSION_NAME indicates a minor patch in the name of your version. (e.g. xx12).

/app/version.properties

 VERSION_NAME=0 VERSION_CODE=0 

Then at your build.Gradle module level add the following code to the default Conff block. This will increment the version code and version name by 1 after each release build. (Basically, when the assambleRelease gradle task is executed. If you have a different task name, change the assembly type to suit your requirement.)

/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; //eg 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

I take the following code from the Plaid app from googler Nick Butcher This is really clean.

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

Answer 4

git can help, follow this link: Automatic version control and incrementation using Git and Gradle tags

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