configurar - Android Gradle: cambia dinámicamente versionName en tiempo de compilación

configure gradle android studio

Question

Intento emular el complemento de lanzamiento de Maven en Android utilizando una versión personalizada del complemento de lanzamiento de Gradle: https://github.com/townsfolk/gradle-release

Los pasos interesantes son:

• Verificar cambios no confirmados
• Paso código de la versión y eliminar el sufijo -SNAPSHOT del nombre de la versión
• Construir
• Ingrese el nombre de la versión y agregue el sufijo -SNAPSHOT para la próxima versión de desarrollo

Sin embargo, la APK generada siempre tiene las versiones anteriores (es decir, 1.0.0-SNAPSHOT en lugar de 1.0.0).

Los números de versión se almacenan y se actualizan correctamente en gradle.properties, por lo que supongo que también necesito actualizar las versiones en el modelo de datos para que los cambios entren en vigencia.

Mi configuración de complemento de Android:

defaultConfig {
    versionCode versionCode as int  // taken from gradle.properties
    versionName versionName // taken from gradle.properties
    minSdkVersion 10
    targetSdkVersion 19
}

Cosas que intenté:

preBuild << {
    android.applicationVariants.each { variant ->
        variant.versionName = versionName
    }
}

Pero no hay versionName en una variante.

preBuild << {
    android.buildTypes.each { type ->
        type.versionName = versionName
    }
}

Pero no hay versionName en un tipo.

preBuild << {
    android.productFlavors.each { flavor ->
        flavor.versionName = versionName
    }
}

Pero no hay sabores en mi aplicación (solo depuración simple y tipos de compilación de versiones).

Mi alternativa es escribir un script bash / bat para pasar las versiones antes de invocar a Gradle, lo que prácticamente frustra el propósito de usar Groovy para mejorar la personalización de compilación.

¿Cómo puedo actualizar las versiones de forma dinámica en el complemento Android Gradle en la fase de ejecución?

Answer 1

Acabo de usar la respuesta de Javanator y la modifiqué un poco para que el conteo de los commits no solo ayude a cambiar el nombre, sino que también asegure que el código de la versión también permanezca único. Aquí hay una muestra de lo que hice (Tal vez un par de cosas se pueden optimizar, pero sin embargo hace el trabajo por mí):

android {
    compileSdkVersion 25
    buildToolsVersion "25.0.2"
    def gitCommitCount = "git rev-list HEAD --count".execute().text.trim().toBigInteger()
    project.ext.set("versionCode", gitCommitCount)
    project.ext.set("versionNameSuffix", "(${gitCommitCount})")

    defaultConfig {
        applicationId "my.app.package.name"
        minSdkVersion 15
        targetSdkVersion 25
        versionCode  project.versionCode
        versionName "1.0"
        versionNameSuffix project.versionNameSuffix
        setProperty("archivesBaseName", "MyProject-$versionName")
        ....
    }

    signingConfigs {
        config {
            .........
        }
    }

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

    packagingOptions {
        .....
    }

    applicationVariants.all { variant ->
        variant.outputs.each { output ->
            output.outputFile = new File(
                    output.outputFile.parent,
                    output.outputFile.name.replace(".apk", "-${variant.versionName}.apk"))
        }
    }
}

Answer 2

Esto no aborda directamente su pregunta sobre cómo cambiar completamente el nombre de la versión, pero esto es lo que uso para anexar un sufijo para mis buildTypes:

defaultConfig {
    versionName "1.0"
}

buildTypes {
    debug {
        versionNameSuffix "-SNAPSHOT"
    }
}

Answer 3

Me enfrentaba a la necesidad similar de tener una lógica de compilación separada para compilaciones de lanzamiento y no de lanzamiento. Además de versiones diferentes, tuve que usar un conjunto diferente de dependencias, incluso repositorios diferentes.

Ninguno de los complementos disponibles tenía todas las características que necesitaba, así que desarrollé mi propia solución, basada en un enfoque simple: argumento de línea de comando.

Puede pasar un parámetro de línea de comando al invocar el script de compilación gradle de la siguiente manera:

gradle build -PmyParameter=myValue

o en mi caso

gradle build -PisRelease=true

Gradle lo analizará, y automágicamente estará disponible como una propiedad del objeto del proyecto. Podrías usarlo así:

if (project.isRelease) {
        // Here be the logic!
}

Extraje esta lógica en un complemento separado, y la he usado con éxito en diferentes proyectos.

Aunque esto no responde su pregunta directamente, espero haberle dado otro punto de vista para pensar sobre el problema y otra posible solución.

Answer 4

Necesitaba anexar el conteo actual de commit de git de la revisión del código al nombre de la versión. Es realmente útil en muchas situaciones. Terminé con el siguiente archivo simple gradle

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

android {
    compileSdkVersion 21
    buildToolsVersion "21.1.2"

    def gitCommitCount = "git rev-list HEAD --count".execute().text.trim()

    defaultConfig {
        applicationId "my.app.package.name"
        minSdkVersion 16
        targetSdkVersion 21
        versionCode 6
        versionName "0.8"
    }

    buildTypes {

        debug {
            versionNameSuffix ".${gitCommitCount}"
        }

        release {
            versionNameSuffix ".${gitCommitCount}"
            minifyEnabled true
            proguardFiles getDefaultProguardFile(''proguard-android-optimize.txt''), ''proguard-rules.pro''

        }
    }
}

Similar a gitCommitCount, puede generar variables propias para personalizar el nombre de la versión. Como solo estoy ejecutando un comando de terminal para almacenar su resultado en una variable.

Answer 5

Para eso son los buildTypes . Lo que estás describiendo es una compilación de release , IMO.

Aquí hay un ejemplo: al ejecutar assembleDebug , obtendrá una compilación instantánea, y al ejecutar assembleRelease obtendrá una compilación limpia sin sufijo ni número de versión incrementado. La próxima versión de depuración también usará el número incrementado.

La siguiente es una compilación completamente funcional cuando los archivos se crean en una carpeta. También debería funcionar con sabores, pero eso es solo un producto secundario :). Gradle 2.2.1, complemento de Android 1.1.3

build.gradle

apply plugin: ''com.android.application''
apply from: ''auto-version.gradle''

buildscript {
    repositories { jcenter() }
    dependencies { classpath ''com.android.tools.build:gradle:1.1.3'' }
}

android {
    buildToolsVersion = "21.1.2"
    compileSdkVersion = "android-21"

    buildTypes {
        debug {
            versionNameSuffix "-SNAPSHOT"
        }
    }
}

println "config code: ${calculateVersionCode()}, name: ${calculateVersionName()}"

src / main / AndroidManifest.xml

<manifest package="com.example" />

auto-version.gradle

ext {
    versionFile = new File(project.rootDir, ''version.properties'')
    calculateVersionName = {
        def version = readVersion()
        return "${version[''major'']}.${version[''minor'']}.${version[''build'']}"
    }
    calculateVersionCode = {
        def version = readVersion()
        def major = version[''major''] as int // 1..∞
        def minor = version[''minor''] as int // 0..99
        def build = version[''build''] as int // 0..999
        return (major * 100 + minor) * 1000 + build
    }
}


Properties readVersion() {
    def version = new Properties()
    def stream
    try {
        stream = new FileInputStream(versionFile)
        version.load(stream)
    } catch (FileNotFoundException ignore) {
    } finally {
        if (stream != null) stream.close()
    }
    // safety defaults in case file is missing
    if(!version[''major'']) version[''major''] = "1"
    if(!version[''minor'']) version[''minor''] = "0"
    if(!version[''build'']) version[''build''] = "0"
    return version
}

void incrementVersionNumber() {
    def version = readVersion()

    // careful with the types, culprits: "9"++ = ":", "9" + 1 = "91"
    def build = version[''build''] as int
    build++
    version[''build''] = build.toString()

    def stream = new FileOutputStream(versionFile)
    try {
        version.store(stream, null)
    } finally {
        stream.close()
    }
}

task incrementVersion {
    description "Increments build counter in ${versionFile}"
    doFirst {
        incrementVersionNumber()
    }
}

if (plugins.hasPlugin(''android'') || plugins.hasPlugin(''android-library'')) {
    android {
        defaultConfig {
            versionName = calculateVersionName()
            versionCode = calculateVersionCode()
        }

        afterEvaluate {
            def autoIncrementVariant = { variant ->
                if (variant.buildType.name == buildTypes.release.name) { // don''t increment on debug builds
                    variant.preBuild.dependsOn incrementVersion
                    incrementVersion.doLast {
                        variant.mergedFlavor.versionName = calculateVersionName()
                        variant.mergedFlavor.versionCode = calculateVersionCode()
                    }
                }
            }
            if (plugins.hasPlugin(''android'')) {
                applicationVariants.all { variant -> autoIncrementVariant(variant) }
            }
            if (plugins.hasPlugin(''android-library'')) {
                libraryVariants.all { variant -> autoIncrementVariant(variant) }
            }
        }
    }
}

Ejecute gradle assembleDebug para compilar normalmente, gradle assembleRelease para incrementar y compilar, y gradle incrementVersion para incrementar. Nota: tenga cuidado con gradle assemble porque el orden de assembleDebug y assembleRelease arrojará resultados diferentes.

Verifique los archivos generados en el directorio de build para ver si los valores son de su agrado.

Ejecución manual (de los comentarios)

Es posible que tenga varios sabores, en cuyo caso la versión se incrementa varias veces porque varias variantes coinciden con el tipo de compilación de lanzamiento. La consulta original no era de sabores. Si desea tener más control cuando se incrementa el número de versión, simplemente elimine el bloque afterEvaluate y llame a la tarea incrementVersion cuando lo desee:

gradle incrementVersion assembleFreeRelease assemblePaidRelease

(La ejecución manual anterior es una idea no probada).

Verificar cambios no confirmados

Los "Controlar cambios no confirmados" no están cubiertos en esta respuesta, ese es otro juego. Podría enganchar en tasks.preBuild.doFirst { /*fail here if uncommited changes*/ } si entiendo correctamente. Pero eso depende en gran medida del control de tu versión. ¡Haga otra pregunta para más!