How to autoincrement versionCode in Android Gradle

Question

I'm experimenting with new Android build system based on Gradle and I'm thinking, what is the best way to autoincrease versionCode with it. I am thinking about two options

create versionCode file, read number from it, increase it and write it back to the file
parse AndroidManifest.xml, read versionCode from it, increase it and write it back to the AndroidManifest.xml

Is there any more simple or suitable solution?

Has anyone used one of mentiod options and could share it with me?

Reading from a `version.properties` file http://stackoverflow.com/a/21405744 — Dori, Jan 21 '16 at 17:44

score 58 · Accepted Answer · answered Jul 08 '13 at 11:12

58

I have decided for second option - to parse AndroidManifest.xml. Here is working snippet.

task('increaseVersionCode') << {
    def manifestFile = file("AndroidManifest.xml")
    def pattern = Pattern.compile("versionCode=\"(\\d+)\"")
    def manifestText = manifestFile.getText()
    def matcher = pattern.matcher(manifestText)
    matcher.find()
    def versionCode = Integer.parseInt(matcher.group(1))
    def manifestContent = matcher.replaceAll("versionCode=\"" + ++versionCode + "\"")
    manifestFile.write(manifestContent)
}

tasks.whenTaskAdded { task ->
    if (task.name == 'generateReleaseBuildConfig') {
        task.dependsOn 'increaseVersionCode'
    }
}

versionCode is released for release builds in this case. To increase it for debug builds change task.name equation in task.whenTaskAdded callback.

answered Jul 08 '13 at 11:12

sealskej

7,281
12
53
64

5

one question, how to integrate those code into Cradle build system? – LiangWang Jan 07 '14 at 01:47
Also, somewhat cleaner answer here doesn't modify XML in place, but keeps version number in a props file: http://stackoverflow.com/questions/21405457/autoincrement-versioncode-with-gradle-extra-properties – Paul Cantrell Aug 06 '14 at 17:02
1

Just change file("AndroidManifest.xml") to file("src/main/AndroidManifest.xml") if you are using the new project structure. – Elhanan Mishraky Feb 16 '15 at 09:48
3

What if I don't set versionCode in my AndroidManifest.xml? – IgorGanapolsky Apr 02 '15 at 18:31
@Jacky If you guys still not got a workaround, see my answer: http://stackoverflow.com/a/39619297/1150251 – iStar Sep 21 '16 at 14:26
@Yazon2006 you should add the following line to your `app/build.gradle` file: `import java.util.regex.Pattern` Insert this line after `apply plugin ...`section – shimatai Sep 21 '17 at 20:17

score 40 · Answer 2 · 2014-06-17T11:51:55.997

I'm using this code to update both versionCode and versionName, using a "major.minor.patch.build" scheme.

import java.util.regex.Pattern

task('increaseVersionCode') << {
    def manifestFile = file("src/main/AndroidManifest.xml")
    def pattern = Pattern.compile("versionCode=\"(\\d+)\"")
    def manifestText = manifestFile.getText()
    def matcher = pattern.matcher(manifestText)
    matcher.find()
    def versionCode = Integer.parseInt(matcher.group(1))
    def manifestContent = matcher.replaceAll("versionCode=\"" + ++versionCode + "\"")
    manifestFile.write(manifestContent)
}

task('incrementVersionName') << {
    def manifestFile = file("src/main/AndroidManifest.xml")
    def patternVersionNumber = Pattern.compile("versionName=\"(\\d+)\\.(\\d+)\\.(\\d+)\\.(\\d+)\"")
    def manifestText = manifestFile.getText()
    def matcherVersionNumber = patternVersionNumber.matcher(manifestText)
    matcherVersionNumber.find()
    def majorVersion = Integer.parseInt(matcherVersionNumber.group(1))
    def minorVersion = Integer.parseInt(matcherVersionNumber.group(2))
    def pointVersion = Integer.parseInt(matcherVersionNumber.group(3))
    def buildVersion = Integer.parseInt(matcherVersionNumber.group(4))
    def mNextVersionName = majorVersion + "." + minorVersion + "." + pointVersion + "." + (buildVersion + 1)
    def manifestContent = matcherVersionNumber.replaceAll("versionName=\"" + mNextVersionName + "\"")
    manifestFile.write(manifestContent)
}

tasks.whenTaskAdded { task ->
    if (task.name == 'generateReleaseBuildConfig' || task.name == 'generateDebugBuildConfig') {
        task.dependsOn 'increaseVersionCode'
        task.dependsOn 'incrementVersionName'
    }
}

You forgot to import Pattern at the top: import java.util.regex.Pattern — Mic92, Jun 16 '14 at 20:17
I know this one is kinda old but hey it dont hurt to ask but I tried using the above snippet, I'm getting this error `Error:(48) Execution failed for task ':app:incrementVersionName'. > No match found` any ideas? — acrichm, May 30 '15 at 04:17
@acrichm: make sure you set `android:versionName="0.0.0.1"` in the manifest else there won't be expected number of matches — Jay Wick, Aug 18 '15 at 01:42
Its working perfectly, but in BuildConfig.java versionName is empty, public static final String VERSION_NAME = ""; — Al-Mothafar, Sep 01 '15 at 09:40
Beware that "Instant Run" in Android Studio would be slower because `Full recompilation is required because 'BuildConfig.java' was changed.` — Ivan Chau, Feb 14 '16 at 08:53

score 36 · Answer 3 · answered Apr 16 '14 at 17:46

36

it doesn't seem to be the exact setup you're using, but in my case the builds are being run by jenkins and i wanted to use its $BUILD_NUMBER as the app's versionCode. the following did the trick for me there.

defaultConfig {
    ...
    versionCode System.getenv("BUILD_NUMBER") as Integer ?: 9999
    ...
}

answered Apr 16 '14 at 17:46

user2399268

436
4
3

What is System.genenv? – IgorGanapolsky Apr 02 '15 at 18:08
This actually helped me a lot when using Jenkins. You can use this [this plugin](https://wiki.jenkins-ci.org/display/JENKINS/Version+Number+Plugin) to create environmt variable with build number and read it with `System.getenv()` in the gradle. – Lamorak May 12 '15 at 12:06

thanhbinh84 · Answer 4 · 2021-02-03T03:45:43.053

20

UPDATE

As google play warning:

The greatest value Google Play allows for versionCode is 2100000000.

We might change the format as below to reduce the risk of reaching limit:

def formattedDate = date.format('yyMMddHH')

ORIGINAL

I am using time stamp for the version code:

def date = new Date()
def formattedDate = date.format('yyMMddHHmm')
def code = formattedDate.toInteger()

defaultConfig {
    minSdkVersion 10
    targetSdkVersion 21
    versionCode code
}

edited Feb 03 '21 at 03:45

answered Feb 23 '16 at 07:26

thanhbinh84

17,876
6
62
69

1

this is simple and genius. thumbs up – Євген Гарастович Nov 09 '16 at 19:10
Do not do this! You will make your version code a very large number and start getting errors from the google play store stating that you are nearing the maximum allowed version code. If you reach that value you will then no longer be able to update your app. – James Parker Feb 02 '21 at 21:44
@JamesParker what's the max allowed version code? – thanhbinh84 Feb 03 '21 at 02:55
1

https://stackoverflow.com/questions/35275071/is-there-a-max-value-for-versioncode – James Parker Feb 03 '21 at 02:56
Unfortunately if you used the old format you are just out of luck. – James Parker Feb 12 '21 at 11:31

Elhanan Mishraky · Answer 5 · 2015-05-06T08:28:18.257

7

If you are holding the version code in the build.gradle file use the next snippet:

import java.util.regex.Pattern    
task('increaseVersionCode') << {
    def buildFile = file("build.gradle")
    def pattern = Pattern.compile("versionCode\\s+(\\d+)")
    def manifestText = buildFile.getText()
    def matcher = pattern.matcher(manifestText)
    matcher.find()
    def versionCode = Integer.parseInt(matcher.group(1))
    def manifestContent = matcher.replaceAll("versionCode " + ++versionCode)
    buildFile.write(manifestContent)
}

edited May 06 '15 at 08:28

answered Mar 25 '15 at 13:17

Elhanan Mishraky

2,736
24
26

That pattern is not matching with the versionCode. – lagos May 05 '15 at 13:38
Can you post your build.gradle? – Elhanan Mishraky May 05 '15 at 15:02
My build.gradle is a normal build-file. VersionCode line looks like `versionCode 18 `. Even if I ran your regex on a tester (`"versionCode \d+"`) it will not match. – lagos May 06 '15 at 07:18
The error was that one more whitespace. Android Studio use two whitespaces on `versionCode` and the digit, since it will be align together with the text in `versionName`. – lagos May 06 '15 at 07:41

score 5 · Answer 6 · answered Jan 12 '15 at 05:24

5

Gradle Advanced Build Version is a plugin for Android that makes generating versionCode and versionName automatically. there are lots of customization. here you can find more info about it https://github.com/moallemi/gradle-advanced-build-version

answered Jan 12 '15 at 05:24

moallemi

2,448
2
25
28

note: this does not support auto-incrementing the version name yet – hooby3dfx Feb 09 '15 at 17:50

score 4 · Answer 7 · answered Oct 03 '13 at 23:42

To take both product flavors and build types into account and using @sealskej's logic for parsing manifest:

android.applicationVariants.all { variant ->
    /* Generate task to increment version code for release */
    if (variant.name.contains("Release")) {
        def incrementVersionCodeTaskName = "increment${variant.name}VersionCode"
        task(incrementVersionCodeTaskName) << {
            if (android.defaultConfig.versionCode == -1) {
                def manifestFile = file(android.sourceSets.main.manifest.srcFile)
                def pattern = Pattern.compile("versionCode=\"(\\d+)\"")
                def manifestText = manifestFile.getText()
                def matcher = pattern.matcher(manifestText)
                matcher.find()
                def versionCode = Integer.parseInt(matcher.group(1))
                android.defaultConfig.versionCode = versionCode + 1
                def manifestContent = matcher.replaceAll("versionCode=\"" + android.defaultConfig.versionCode + "\"")
                manifestFile.write(manifestContent)
            }
        }
        def hookTask = variant.generateBuildConfig
        hookTask.dependsOn(incrementVersionCodeTaskName)
    }
}

Where do we need to write this... I mean in which class/file this code needs to be added — ChArAnJiT, Jan 04 '14 at 04:33
this is part of build.gradle as this is part of build process — Max Ch, Jan 06 '14 at 23:33

Jared Burrows · Answer 8 · 2014-09-29T02:54:53.840

Increment VersionCode Task(Integer):

This works by incrementing the Version Code by 1, for example:

  android:versionCode="1"

1 + 1 = 2

import java.util.regex.Pattern

task incrementVersionCode << {
    def manifestFile = file('AndroidManifest.xml')
    def matcher = Pattern.compile('versionCode=\"(\\d+)\"')
    .matcher(manifestFile.getText())
    matcher.find()
    def manifestContent = matcher.replaceAll('versionCode=\"' +
        ++Integer.parseInt(matcher.group(1)) + '\"')
    manifestFile.write(manifestContent)
}

Increment VersionName Task(String):

Warning: Must contain `1` period for Regex

This works by incrementing the Version Name by 0.01, for example: You can easily modify and change your increment or add more digits.

android:versionName="1.0"

1.00 + 0.01 -> 1.01
1.01 + 0.01 -> 1.02
1.10 + 0.01 -> 1.11
1.99 + 0.01 -> 2.0
1.90 + 0.01 -> 1.91

import java.util.regex.Pattern

task incrementVersionName << {
    def manifestFile = file('AndroidManifest.xml')
    def matcher = Pattern.compile('versionName=\"(\\d+)\\.(\\d+)\"')
    .matcher(manifestFile.getText())
    matcher.find()
    def versionName = String.format("%.2f", Integer
        .parseInt(matcher.group(1)) + Double.parseDouble("." + matcher
            .group(2)) + 0.01)
    def manifestContent = matcher.replaceAll('versionName=\"' +
        versionName + '\"')
    manifestFile.write(manifestContent)
}

Before:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.exmaple.test"
    android:installLocation="auto"
    android:versionCode="1"
    android:versionName="1.0" >

After:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.exmaple.test"
    android:installLocation="auto"
    android:versionCode="2"
    android:versionName="1.01" >

score 3 · Answer 9 · answered Sep 21 '16 at 14:21

If you write your versionCode in gradle.build file(most case currently), here is a workaround. A little bit stupid(update "self"), but it works!

import java.util.regex.Pattern

task('increaseVersionCode') << {
    def buildFile = file("build.gradle")
    def pattern = Pattern.compile("versionCode(\\s+\\d+)")
    def buildText = buildFile.getText()
    def matcher = pattern.matcher(buildText)
    matcher.find()
    def versionCode = android.defaultConfig.versionCode
    def buildContent = matcher.replaceAll("versionCode " + ++versionCode)
    buildFile.write(buildContent)

    System.out.println("Incrementing Version Code ===> " + versionCode)
}

tasks.whenTaskAdded { task ->
    if (task.name == 'generateReleaseBuildConfig') {
        task.dependsOn 'increaseVersionCode'
    }
}

score 2 · Answer 10 · answered Jul 13 '13 at 05:50

To add on to @sealskej's post, this is how you can update both your version code and version name (Here I'm assuming your major and minor version are both 0):

task('increaseVersion') << {
    def manifestFile = file("AndroidManifest.xml")
    def patternVersionCode = Pattern.compile("versionCode=\"(\\d+)\"")
    def manifestText = manifestFile.getText()
    def matcherVersionCode = patternVersionCode.matcher(manifestText)
    matcherVersionCode.find()
    def versionCode = Integer.parseInt(matcherVersionCode.group(1))
    def manifestContent = matcherVersionCode.replaceAll("versionCode=\"" + ++versionCode + "\"")

    manifestFile.write(manifestContent)

    def patternVersionNumber = Pattern.compile("versionName=\"0.0.(\\d+)\"")
    manifestText = manifestFile.getText()
    def matcherVersionNumber = patternVersionNumber.matcher(manifestText)
    matcherVersionNumber.find()
    def versionNumber = Integer.parseInt(matcherVersionNumber.group(1))
    manifestContent = matcherVersionNumber.replaceAll("versionName=\"0.0." + ++versionNumber + "\"")
    manifestFile.write(manifestContent)
}

score 1 · Answer 11 · answered Jul 16 '15 at 13:16

what about this ? add to build.gradle (app module)

def getBuildVersionCode() {
    def date = new Date()
    def formattedDate = date.format('yyyyMMdd')
    def formattedSeconds = date.format('HHmmssSSS')
    def formatInt = formattedDate as int;
    def SecondsInt = formattedSeconds as int;
    return (formatInt + SecondsInt) as int
}

   defaultConfig {
    applicationId "com.app"
    minSdkVersion 17
    targetSdkVersion 22
    versionCode getBuildVersionCode()
    versionName "1.0"
}

Great thought but `(20160129 + 000000000) < (20160128 + 125959999)` — C0D3LIC1OU5, Jan 29 '16 at 19:09

score 1 · Answer 12 · answered Nov 10 '15 at 19:05

So as I was looking into most of the solution, they were nice but not enough so I wrote this, one increment per multi-deploy:

This will increment the build when compiling debug versions, and increment the point and version code when deploying.

import java.util.regex.Pattern

def incrementVersionName(int length, int index) {
    def gradleFile = file("build.gradle")
    def versionNamePattern = Pattern.compile("versionName\\s*\"(.*?)\"")
    def gradleText = gradleFile.getText()
    def matcher = versionNamePattern.matcher(gradleText)
    matcher.find()

    def originalVersion = matcher.group(1)
    def originalVersionArray = originalVersion.split("\\.")
    def versionKeys = [0, 0, 0, 0]
    for (int i = 0; i < originalVersionArray.length; i++) {
        versionKeys[i] = Integer.parseInt(originalVersionArray[i])
    }
    def finalVersion = ""
    versionKeys[index]++;
    for (int i = 0; i < length; i++) {
        finalVersion += "" + versionKeys[i]
        if (i < length - 1)
            finalVersion += "."
    }

    System.out.println("Incrementing Version Name: " + originalVersion + " ==> " + finalVersion)

    def newGradleContent = gradleText.replaceAll("versionName\\s*\"(.*?)\"", "versionName \"" + finalVersion + "\"")
    gradleFile.write(newGradleContent)
}

def incrementVersionCode() {
    def gradleFile = file("build.gradle")
    def versionCodePattern = Pattern.compile("versionCode\\s*(\\d+)")
    def gradleText = gradleFile.getText()
    def matcher = versionCodePattern.matcher(gradleText)
    matcher.find()

    def originalVersionCode = Integer.parseInt(matcher.group(1) + "")
    def finalVersionCode = originalVersionCode + 1;
    System.out.println("Incrementing Version Code: " + originalVersionCode + " ==> " + finalVersionCode)

    def newGradleContent = gradleText.replaceAll("versionCode\\s*(\\d+)", "versionCode " + finalVersionCode)
    gradleFile.write(newGradleContent)
}

task('incrementVersionNameBuild') << {
    incrementVersionName(4, 3)
}

task('incrementVersionNamePoint') << {
    incrementVersionName(3, 2)
}

task('incrementVersionCode') << {
    incrementVersionCode()
}


def incrementedBuild = false
def incrementedRelease = false

tasks.whenTaskAdded { task ->
    System.out.println("incrementedRelease: " + incrementedRelease)
    System.out.println("incrementedBuild: " + incrementedBuild)
    System.out.println("task.name: " + task.name)

    if (!incrementedBuild && task.name.matches('generate.*?DebugBuildConfig')) {
        task.dependsOn 'incrementVersionNameBuild'
        incrementedBuild = true
        return
    }

    if (!incrementedRelease && task.name.matches('generate.*?ReleaseBuildConfig')) {
        task.dependsOn 'incrementVersionCode'
        task.dependsOn 'incrementVersionNamePoint'
        incrementedRelease = true
        return
    }
}

Katoteshi Fuku · Answer 13 · 2016-07-10T22:06:34.457

My approach is to read manifest file from build folder and get buildVersion out of there, than I delete a folder. When task creates new manifest, my incremented buildVersion variable is already there.

def versionPattern = "Implementation-Version=(\\d+.\\d+.\\d+.\\d+\\w+)"

task generateVersion (dependsOn : 'start') {
    // read build version from previous manifest
    def file = file("build/libs/MANIFEST.MF")
    if (file.exists()) {
        def pattern = Pattern.compile(versionPattern)
        def text = file.getText()
        def matcher = pattern.matcher(text)
        matcher.find()
        buildNumber = Integer.parseInt(matcher.group(1))
        // increment build version
        version = "${majorVer}.${minorVer}.${patchVer}.${++buildNumber}${classifier}_${access}"
    } 
    else 
        version = "${majorVer}.${minorVer}.${patchVer}.1${classifier}_${access}"
}

task specifyOutputDir (dependsOn : 'generateVersion', type : JavaCompile) {
    // create a folder for new build
    destinationDir = file("build/${version}/")
}

task clean (dependsOn : 'generateVersion', type : Delete) {
    doLast {
        delete "build/${version}"
        println 'Build directory is deleted'
    }
}

task configureJar (dependsOn : 'generateVersion', type : Jar) {
    baseName = applicationName
    version = project.version
    archiveName = "${applicationName}_ver${version}.${extension}"
    manifest {[
            "Main-Class" : mainClassName,
            "Implementation-Title" : name,
            "Implementation-Version" : version,
            "Access" : access,
            "Developer" : developer
    ]}
}

This does not provide an answer to the question. Once you have sufficient [reputation](http://stackoverflow.com/help/whats-reputation) you will be able to [comment on any post](http://stackoverflow.com/help/privileges/comment); instead, [provide answers that don't require clarification from the asker](http://meta.stackexchange.com/questions/214173/why-do-i-need-50-reputation-to-comment-what-can-i-do-instead). - [From Review](/review/low-quality-posts/12960913) — MLavoie, Jul 10 '16 at 19:58

How to autoincrement versionCode in Android Gradle

13 Answers13

Increment VersionCode Task(Integer):

Increment VersionName Task(String):

Warning: Must contain `1` period for Regex

Before:

After:

Linked

Related

How to autoincrement versionCode in Android Gradle

13 Answers13

Increment VersionCode Task(Integer):

Increment VersionName Task(String):

Warning: Must contain 1 period for Regex

Before:

After:

Linked

Related

Warning: Must contain `1` period for Regex