tengo - Cómo obtener buildType actual en la configuración de Android Gradle

configurar gradle android studio

Question

Quiero agregar dinámicamente una dependencia en un proyecto de Android Gradle basado en el tipo de compilación actual. Sé que puedo especificar el buildType en la dependencia :

compile project(path: '':lib1'', configuration: ''debug'')

Pero, ¿cómo puedo usar el tipo de compilación actual para especificar qué variante de la biblioteca quiero importar, de modo que una compilación de depuración o liberación importe automáticamente la variante de depuración o liberación de la biblioteca? Lo que quiero es algo como esto (donde currentBuildType es una variable que contiene el nombre del buildType utilizado actualmente):

compile project(path: '':lib1'', configuration: currentBuildType)

El proyecto de la biblioteca que quiero importar ha establecido a publishNonDefault true , por lo que todos los tipos de compilación se publican.

Answer 1

Agregue una tarea que depende de la configuración de cada tarea y propiedad de assembleXxx después de invocarla

ext {
    currentConfig = ""
}
task generateConfigProperty(dependsOn: ''installDebug'') {

    android.applicationVariants.all { variant ->
        variant.outputs.each { output ->

            def taskName = "taskindicate$output.name"
            task "$taskName"() << {
                project.ext.set("currentConfig", "$output.name")
            }
            output.assemble.dependsOn "taskindicate$output.name"
        }
    }

}

task getConfig(dependsOn: [''installDebug'', ''generateConfigProperty'']) << {
    println("My config is $currentConfig")
}

tomó idea de la answer

Answer 2

Esta es la forma más fácil de obtener el resultado que desea. Usted define la variable global, luego la actualiza para usarla más tarde donde sea necesario.

// 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())
def buildTime = new Date().format("yyyy-MM-dd''T''HH:mm''Z''", TimeZone.getTimeZone("UTC"))

def versionMajor = 1
def versionMinor = 5
def versionPatch = 2
def versionBuild = 0 // bump for dogfood builds, public betas, etc.

def buildType // define here to update in loop

android {

    applicationVariants.all { variant ->
        buildType = variant.buildType.name // sets the current build type
    }

    defaultConfig {
        applicationId "com.example"
        minSdkVersion 19
        targetSdkVersion 25
        vectorDrawables.useSupportLibrary = true

        versionCode gitCommitCount
        versionName "${versionMajor}.${versionMinor}.${versionPatch}.${versionBuild}"
        versionNameSuffix "-${buildType}-build-${buildTime}"

}

Answer 3

Este es bastante simple:

android {
    applicationVariants.all { variant ->
        variant.buildType.name // this is the value!
    }
}

Editar: Aparentemente, en algún momento con la actualización de Gradle, esto no funciona como mencioné en un comentario a continuación. Por lo tanto, recomendaría consultar otras opciones.

Answer 4

No pude encontrar una forma limpia de obtener el tipo de compilación actual durante la fase de configuración de Gradle. En su lugar, defino la dependencia para cada tipo de compilación por separado de esa manera:

debugCompile project(path: '':lib1'', configuration: ''debug'')
releaseCompile project(path: '':lib1'', configuration: ''release'')

Si tiene muchos tipos de compilación y muchas dependencias de proyecto, esto puede volverse muy detallado, pero es posible agregar una función para hacer que la dependencia sea de una sola línea. Debe agregar esto a su archivo de compilación principal de Gradle:

subprojects {
    android {
        dependencies.metaClass.allCompile { dependency ->
            buildTypes.each { buildType ->
                "${buildType.name}Compile" project(path: ":${dependency.name}", configuration: buildType.name)
            }
        }
    }
}

Luego puede agregar dependencias de proyecto en sus módulos de Gradle de esta manera:

allCompile project('':lib1'')

Si también usa sabores de compilación, tendría que adaptar la solución. Consulte este enlace para obtener una documentación de la función: http://tools.android.com/tech-docs/new-build-system/user-guide#TOC-Library-Publication

Tenga en cuenta que el equipo de Android está trabajando en una mejora para este comportamiento: https://code.google.com/p/android/issues/detail?id=52962

Answer 5

Puedes usar

if(gradle.startParameter.taskNames.contains("assembleExample")) { // do stuff }

Esa variable se establecerá antes de buildConfig bloque buildConfig

Answer 6

// declare a custom task class so you can reuse it for the different
// variants
class MyTask extends DefaultTask {
     String mVariantName;
     public void setVariantName(String variant) {mVariantName = variant;}
     public String getVariantName() { return mVariantName; }
     @TaskAction
     void action(){
        // do stuff
     }
}

// put this after your `android{}` block.
android.applicationVariants.all { variant ->
    def taskName = "myTask_$variant.name"
    task "$taskName"(type: MyTask) << {
        // you can setup this task to various info regarding
        // variant
        variantName = variant.name
    }
    variant.assemble.dependsOn (taskName)
}

Consulte Personalización avanzada para obtener más detalles sobre lo que puede extraer de la variable variant .

ahora usted MyTask correctamente su MyTask a la cadena. Hacerlo de esta manera también debería manejar limpiamente la creación de múltiples sabores a la vez, ya que crea una nueva instancia de MyTask para cada variante.