Versión de Android del proyecto de git describe automáticamente con Android Studio/Gradle

android-studio auto-versioning

Question

He buscado mucho, pero probablemente debido a la novedad de Android Studio y Gradle, no he encontrado ninguna descripción de cómo hacer esto. Quiero básicamente hacer exactamente lo que se describe en esta publicación , pero con Android Studio, Gradle y Windows en lugar de Eclipse y Linux.

Answer 1

Aquí hay otra solución que requiere declaraciones en lugar de funciones para acceder a la línea de comandos. Advertencia: * nix solo solución

def gitSha = ''git rev-parse --short HEAD''.execute([], project.rootDir).text.trim()

// Auto-incrementing commit count based on counting commits to master (Build #543)
def commitCount = Integer.parseInt(''git rev-list master --count''.execute([], project.rootDir).text.trim())

// I want to use git tags as my version names (1.2.2)
def gitCurrentTag = ''git describe --tags --abbrev=0''.execute([], project.rootDir).text.trim()

android {
    compileSdkVersion 22
    buildToolsVersion "22.0.1"

    defaultConfig {
        applicationId "com.some.app"
        minSdkVersion 16
        targetSdkVersion 22
        versionCode commitCount
        versionName gitCurrentTag

        buildConfigField "String", "GIT_SHA", "/"${gitSha}/""

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

    }
}

Answer 2

Coloque lo siguiente en su archivo build.gradle para el proyecto. No es necesario modificar el manifiesto directamente: Google proporcionó los enganches necesarios en su configuración.

def getVersionCode = { ->
    try {
        def code = new ByteArrayOutputStream()
        exec {
            commandLine ''git'', ''tag'', ''--list''
            standardOutput = code
        }
        return code.toString().split("/n").size()
    }
    catch (ignored) {
        return -1;
    }
}

def getVersionName = { ->
    try {
        def stdout = new ByteArrayOutputStream()
        exec {
            commandLine ''git'', ''describe'', ''--tags'', ''--dirty''
            standardOutput = stdout
        }
        return stdout.toString().trim()
    }
    catch (ignored) {
        return null;
    }
}
android {
    defaultConfig {
        versionCode getVersionCode()
        versionName getVersionName()
    }
}

Tenga en cuenta que si git no está instalado en la máquina, o hay algún otro error al obtener el nombre / código de la versión, de manera predeterminada aparecerá lo que está en su manifiesto de Android.

Answer 3

Después de ver la respuesta de moveaway00 y el comentario de Avinash R sobre esa respuesta , terminé usando esto:

apply plugin: ''android''

def getVersionCode = { ->
    try {
        def stdout = new ByteArrayOutputStream()
        exec {
            commandLine ''git'', ''rev-list'', ''--first-parent'', ''--count'', ''master''
            standardOutput = stdout
        }
        return Integer.parseInt(stdout.toString().trim())
    }
    catch (ignored) {
        return -1;
    }
}

def getVersionName = { ->
    try {
        def stdout = new ByteArrayOutputStream()
        exec {
            commandLine ''git'', ''describe'', ''--tags'', ''--dirty''
            standardOutput = stdout
        }
        return stdout.toString().trim()
    }
    catch (ignored) {
        return null;
    }
}

android {
    defaultConfig {
        versionCode getVersionCode()
        versionName getVersionName()
    }
}

He editado el código de moveaway00 para incluir también el comentario de Avinash R: el código de la versión ahora es el número de confirmaciones desde el master , ya que se supone que es el código de la versión.

Tenga en cuenta que no necesité especificar el código de la versión y el nombre de la versión en el manifiesto, Gradle se encargó de ello.

Answer 4

En base a la respuesta de Léo Lam y mis explorations anteriores sobre la misma solución para hormiga, he ideado una solución puramente multiplataforma utilizando jgit:

( source original)

Archivo: git-version.gradle

buildscript {
    dependencies {
        //noinspection GradleDynamicVersion
        classpath "org.eclipse.jgit:org.eclipse.jgit:4.1.1.+"
    }
    repositories {
        jcenter()
    }
}
import org.eclipse.jgit.api.Git
import org.eclipse.jgit.revwalk.RevWalk
import org.eclipse.jgit.storage.file.FileRepositoryBuilder

import static org.eclipse.jgit.lib.Constants.MASTER

def git = Git.wrap(new FileRepositoryBuilder()
        .readEnvironment()
        .findGitDir()
        .build())

ext.readVersionCode = {
    def repo = git.getRepository()
    def walk = new RevWalk(repo)
    walk.withCloseable {
        def head = walk.parseCommit(repo.getRef(MASTER).getObjectId())
        def count = 0
        while (head != null) {
            count++
            def parents = head.getParents()
            if (parents != null && parents.length > 0) {
                head = walk.parseCommit(parents[0])
            } else {
                head = null
            }
        }
        walk.dispose()
        println("using version name: $count")
        return count
    }
}

ext.readVersionName = {
    def tag = git.describe().setLong(false).call()
    def clean = git.status().call().isClean()
    def version = tag + (clean ? '''' : ''-dirty'')
    println("using version code: $version")
    return version
}

El uso será:

apply from: ''git-version.gradle''

android {
  ...
  defaultConfig {
    ...
    versionCode readVersionCode()
    versionName readVersionName()
    ...
  }
  ...
}

Answer 5

Si puede ser de alguna ayuda, he configurado un script de Gradle de ejemplo que usa etiquetas de Git y describe a Git para lograr esto. Aquí está el código (también puedes encontrarlo here ).

1) Primero crea un archivo versioning.gradle que contenga:

import java.text.SimpleDateFormat

/**
 * This Gradle script relies on Git tags to generate versions for your Android app
 *
 * - The Android version NAME is specified in the tag name and it''s 3 digits long (example of a valid tag name: "v1.23.45")
 *   If the tag name is not in a valid format, then the version name will be 0.0.0 and you should fix the tag.
 *
 * - The Android version CODE is calculated based on the version name (like this: (major * 1000000) + (minor * 10000) + (patch * 100))
 *
 * - The 4 digits version name is not "public" and the forth number represents the number of commits from the last tag (example: "1.23.45.178")
 *
 */

ext {

    getGitSha = {
        return ''git rev-parse --short HEAD''.execute().text.trim()
    }

    getBuildTime = {
        def df = new SimpleDateFormat("yyyy-MM-dd''T''HH:mm''Z''")
        df.setTimeZone(TimeZone.getTimeZone("UTC"))
        return df.format(new Date())
    }

    /**
     * Git describe returns the following: [GIT_TAG_NAME]-[BUILD_NUMBER]-[GIT_SHA]
     */
    getAndroidGitDescribe = {
        return "git -C ${rootDir} describe --tags --long".execute().text.trim()
    }

    /**
     * Returns the current Git branch name
     */
    getGitBranch = {
        return "git rev-parse --abbrev-ref HEAD".execute().text.trim()
    }

    /**
     * Returns the full version name in the format: MM.mm.pp.ccc
     *
     * The version name is retrieved from the tag name which must be in the format: vMM.mm.pp, example: "v1.23.45"
     */
    getFullVersionName = {
        def versionName = "0.0.0.0"
        def (tag, buildNumber, gitSha) = getAndroidGitDescribe().tokenize(''-'')
        if (tag && tag.startsWith("v")) {
            def version = tag.substring(1)
            if (version.tokenize(''.'').size() == 3) {
                versionName = version + ''.'' + buildNumber
            }
        }
        return versionName
    }

    /**
     * Returns the Android version name
     *
     * Format "X.Y.Z", without commit number
     */
    getAndroidVersionName = {
        def fullVersionName = getFullVersionName()
        return fullVersionName.substring(0, fullVersionName.lastIndexOf(''.''))
    }

    /**
     * Returns the Android version code, deducted from the version name
     *
     * Integer value calculated from the version name
     */
    getAndroidVersionCode = {
        def (major, minor, patch) = getAndroidVersionName().tokenize(''.'')
        (major, minor, patch) = [major, minor, patch].collect{it.toInteger()}
        return (major * 1000000) + (minor * 10000) + (patch * 100)
    }

    /**
     * Return a pretty-printable string containing a summary of the version info
     */
    getVersionInfo = {
        return "/nVERSION INFO:/n/tFull version name: " + getFullVersionName() +
                "/n/tAndroid version name: " + getAndroidVersionName() +
                "/n/tAndroid version code: " + getAndroidVersionCode() +
                "/n/tAndroid Git branch: " + getGitBranch() +
                "/n/tAndroid Git describe: " + getAndroidGitDescribe() +
                "/n/tGit SHA: " + getGitSha() +
                "/n/tBuild Time: " + getBuildTime() + "/n"
    }

    // Print version info at build time
    println(getVersionInfo());
}

2) Luego edite su aplicación / build.gradle para usarla así:

import groovy.json.StringEscapeUtils;

apply plugin: ''com.android.application'' // << Apply the plugin

android {

    configurations {
        // ...
    }

    compileSdkVersion 22
    buildToolsVersion "22.0.1"

    defaultConfig {

        minSdkVersion 17
        targetSdkVersion 22

        applicationId "app.example.com"

        versionCode getAndroidVersionCode() // << Use the plugin!
        versionName getAndroidVersionName() // << Use the plugin!

        // Build config constants
        buildConfigField "String", "GIT_SHA", "/"${getGitSha()}/""
        buildConfigField "String", "BUILD_TIME", "/"${getBuildTime()}/""
        buildConfigField "String", "FULL_VERSION_NAME", "/"${getVersionName()}/""
        buildConfigField "String", "VERSION_DESCRIPTION", "/"${StringEscapeUtils.escapeJava(getVersionInfo())}/""
    }

    signingConfigs {
        config {
            keyAlias ''MyKeyAlias''
            keyPassword ''MyKeyPassword''
            storeFile file(''my_key_store.keystore'')
            storePassword ''MyKeyStorePassword''
        }
    }

    buildTypes {

        debug {
            minifyEnabled false
            debuggable true
        }

        release {
            minifyEnabled true
            proguardFiles getDefaultProguardFile(''proguard-android.txt''), ''proguard-rules.pro''
            signingConfig signingConfigs.config
            debuggable false
        }

    }

    productFlavors {
       // ...
    }

    dependencies {
        // ...
    }

    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_7
        targetCompatibility JavaVersion.VERSION_1_7
    }
}

/**
 * Save a build.info file
 */
task saveBuildInfo {
    def buildInfo = getVersionInfo()
    def assetsDir = android.sourceSets.main.assets.srcDirs.toArray()[0]
    assetsDir.mkdirs()
    def buildInfoFile = new File(assetsDir, ''build.info'')
    buildInfoFile.write(buildInfo)
}

gradle.projectsEvaluated {
    assemble.dependsOn(saveBuildInfo)
}

La parte más importante es aplicar el complemento

apply plugin: ''com.android.application''

Y luego usarlo para el nombre y código de la versión de Android

versionCode getAndroidVersionCode()
versionName getAndroidVersionName()

Answer 6

Una manera más apropiada y delgada de lograr el resultado que ganó fuerza últimamente sería usar la integración de gradle git a través de enlaces Groovy JGit . Como usa JGit, ni siquiera requiere que git se instale para funcionar.

Aquí hay un ejemplo básico que muestra una solución similar (pero con algo de información adicional en gitVersionName):

buildscript {
  dependencies {
    classpath ''org.ajoberstar:grgit:1.4.+''
  }
}
ext {
  git = org.ajoberstar.grgit.Grgit.open()
  gitVersionCode = git.tag.list().size()
  gitVersionName = "${git.describe()}"
}
android {
  defaultConfig {
    versionCode gitVersionCode
    versionName gitVersionName
  }
}
[...]

Como puede ver en la documentación de la API de Grgit, la operación de descripción proporciona información adicional distinta a la etiqueta más reciente accesible en la historia:

Encuentra la etiqueta más reciente que se puede alcanzar desde HEAD. Si la etiqueta apunta a la confirmación, solo se muestra la etiqueta. De lo contrario, incluye el nombre de la etiqueta con el número de confirmaciones adicionales en la parte superior del objeto etiquetado y el nombre abreviado del objeto de la confirmación más reciente.

De todos modos, no dirá si el estado está sucio o no. Esta información se puede agregar fácilmente al observar el estado de limpieza del repositorio y agregar una cadena si no está limpio.

Answer 7

Otra forma más:

https://github.com/gladed/gradle-android-git-version es un nuevo plugin de gradle que calcula los nombres de versiones compatibles con android y los códigos de versión de forma automática.

Maneja muchos casos especiales que no son posibles usando la solución aceptada:

• etiquetas de versión para proyectos múltiples en el mismo repositorio
• códigos de versión ampliada como 1002003 para 1.2.3
• tareas de gradle para extraer fácilmente información de versión para herramientas de CI
• etc.

Descargo de responsabilidad: lo escribí.

Answer 8

Otra forma, usando Android Studio (Gradle): Echa un vistazo a esta publicación en el blog: http://blog.android-develop.com/2014/09/automatic-versioning-and-increment.html

Aquí está la implementación del blog:

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

}