¿Es posible declarar una variable en Gradle utilizable en Java?

¿Es posible declarar una variable en Gradle utilizable en Java? Básicamente, me gustaría declarar algunos vars en build.gradle y luego obtenerlos (obviamente) en el momento de la compilación. Al igual que las macros de preprocesador en C / C ++ ...

Un ejemplo de declaración sería algo así ...:

android {
    debug {
        A_VAR_RETRIEVABLE_IN_JAVA = 42
    }
    release {
        A_VAR_RETRIEVABLE_IN_JAVA = 42+52
    }
}

¿Hay alguna manera de hacer algo así?

Generar constantes de Java

android {
    buildTypes {
        debug {
            buildConfigField "int", "FOO", "42"
            buildConfigField "String", "FOO_STRING", "\"foo\""
            buildConfigField "boolean", "LOG", "true"
        }

        release {
            buildConfigField "int", "FOO", "52"
            buildConfigField "String", "FOO_STRING", "\"bar\""
            buildConfigField "boolean", "LOG", "false"
        }
    }
}

Puedes acceder a ellos con BuildConfig.FOO

Generar recursos de Android

android {
    buildTypes {
        debug{
            resValue "string", "app_name", "My App Name Debug"
        }
        release {
            resValue "string", "app_name", "My App Name"
        }
    }
}

Puede acceder a ellos de la forma habitual con @string/app_nameoR.string.app_name

Un ejemplo de uso de una clave de aplicación Api en una aplicación de Android (Java y XML)

gradle.properties

AppKey="XXXX-XXXX"

build.gradle

buildTypes {
//...
    buildTypes.each {
        it.buildConfigField 'String', 'APP_KEY_1', AppKey
        it.resValue 'string', 'APP_KEY_2', AppKey
    }
}

Uso en código java

Log.d("UserActivity", "onCreate, APP_KEY: " + getString(R.string.APP_KEY_2));

BuildConfig.APP_KEY_1

Uso en código xml

<data android:scheme="@string/APP_KEY_2" />

• Enlace a un ejemplo de uso de Api App Key en una aplicación de Android
• Uso de constantes de cadena generadas por configuraciones de compilación Gradle

Ejemplo usando las propiedades del sistema, establecido en build.gradle, leído desde la aplicación Java (siguiendo la pregunta en los comentarios):

Básicamente, usando la testtarea en build.gradle, con el método de tarea de prueba systemPropertyestableciendo una propiedad del sistema que se pasa en tiempo de ejecución:

apply plugin: 'java'
group = 'example'
version = '0.0.1-SNAPSHOT'

repositories {
    mavenCentral()
    // mavenLocal()
    // maven { url 'http://localhost/nexus/content/groups/public'; }
}

dependencies {
    testCompile 'junit:junit:4.8.2'
    compile 'ch.qos.logback:logback-classic:1.1.2'
}

test {
  logger.info '==test=='
  systemProperty 'MY-VAR1', 'VALUE-TEST'
}

Y aquí está el resto del código de muestra (que probablemente podría inferir, pero se incluye aquí de todos modos): obtiene una propiedad del sistema MY-VAR1, que se espera que en el tiempo de ejecución se establezca en VALUE-TEST:

package example;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class HelloWorld {
  static final Logger log=LoggerFactory.getLogger(HelloWorld.class);
  public static void main(String args[]) {
    log.info("entering main...");
    final String val = System.getProperty("MY-VAR1", "UNSET (MAIN)");
    System.out.println("(main.out) hello, world: " + val);
    log.info("main.log) MY-VAR1=" + val);
  }
}

Caso de prueba: si no MY-VARestá configurado, la prueba debería fallar:

package example;
...
public class HelloWorldTest {
    static final Logger log=LoggerFactory.getLogger(HelloWorldTest.class);
    @Test public void testEnv() {
        HelloWorld.main(new String[]{});
        final String val = System.getProperty("MY-VAR1", "UNSET (TEST)");
        System.out.println("(test.out) var1=" + val);
        log.info("(test.log) MY-VAR1=" + val);
        assertEquals("env MY-VAR1 set.", "VALUE-TEST", val);
    }
}

Ejecutar (nota: la prueba está pasando):

$ gradle cleanTest test
:cleanTest
:compileJava UP-TO-DATE
:processResources UP-TO-DATE
:classes UP-TO-DATE
:compileTestJava UP-TO-DATE
:processTestResources UP-TO-DATE
:testClasses UP-TO-DATE
:test

BUILD SUCCESSFUL

Descubrí que la parte difícil es realmente obtener la salida de gradle ... Entonces, el registro se configura aquí (slf4j + logback), y el archivo de registro muestra los resultados (alternativamente, ejecutar gradle --info cleanTest test; también hay propiedades que se pueden usar como estándar). la consola, pero ya sabes por qué):

$ cat app.log
INFO Test worker example.HelloWorld - entering main...
INFO Test worker example.HelloWorld - main.log) MY-VAR1=VALUE-TEST
INFO Test worker example.HelloWorldTest - (test.log) MY-VAR1=VALUE-TEST

Si comenta " systemProperty..." (que, por cierto, solo funciona en una testtarea), entonces:

example.HelloWorldTest > testEnv FAILED
    org.junit.ComparisonFailure at HelloWorldTest.java:14

Para completar, aquí está el logback config ( src/test/resources/logback-test.xml):

<configuration>
    <appender name="FILE" class="ch.qos.logback.core.FileAppender">
        <file>app.log</file>
        <layout class="ch.qos.logback.classic.PatternLayout">
            <pattern>%d %p %t %c - %m%n</pattern>
        </layout>
 </appender>
 <root level="info">
     <appender-ref ref="FILE"/>
</root>
</configuration> 

Archivos:

• build.gradle
• src/main/java/example/HelloWorld.java
• src/test/java/example/HelloWorldTest.java
• src/test/resources/logback-test.xml

Puede crear el campo de configuración de compilación reemplazable mediante variables de entorno del sistema durante la compilación:

Fallback se usa durante el desarrollo, pero puede anular la variable cuando ejecuta la compilación en Jenkins u otra herramienta.

En su aplicación build.gradle :

buildTypes {
        def serverUrl =  '\"' + (System.getenv("SERVER_URL")?: "http://default.fallback.url.com")+'\"'
        debug{
            buildConfigField "String", "SERVER_URL", serverUrl
        }
        release {
            minifyEnabled true
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
            buildConfigField "String", "SERVER_URL", serverUrl
        }
    } 

La variable estará disponible como BuildConfig.SERVER_URL.

La respuesta de rciovati es completamente correcta. Solo quería agregar un tidbit más que también puede crear variables para cada tipo de compilación dentro de la parte de configuración predeterminada de su build.gradle. Esto se vería así:

android {
    defaultConfig {
        buildConfigField "String", "APP_NAME", "\"APP_NAME\""
    }
}

Esto le permitirá tener acceso a través de

BuildConfig.App_NAME

Solo quería tomar nota de este escenario también si desea una configuración común.

Estoy usando este código y estoy trabajando muy bien.

def baseUrl = '\"http://patelwala.com/myapi/"'
def googleServerKey = '\"87171841097-opu71rk2ps35ibv96ud57g3ktto6ioio.apps.googleusercontent.com"'
android {
  buildTypes {
  release {
        minifyEnabled true
        proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        buildConfigField 'String', 'BASE_URL', baseUrl
        buildConfigField 'String', 'web_client_id', googleServerKey
    }
    releasedebug {
        initWith debug
        buildConfigField 'String', 'BASE_URL', baseUrl
        buildConfigField 'String', 'web_client_id' ,googleServerKey
    }
    debug {

        buildConfigField 'String', 'BASE_URL', baseUrl
        buildConfigField 'String', 'web_client_id', googleServerKey
    }
 }
}

}

¿Cómo puede insertar el resultado de la función String en buildConfigField?

Aquí hay un ejemplo de fecha de compilación en un conjunto de formatos legibles por humanos:

def getDate() {
    return new SimpleDateFormat("dd MMMM yyyy", new Locale("ru")).format(new Date())
}

def buildDate = getDate()

defaultConfig {
    buildConfigField "String", "BUILD_DATE", "\"$buildDate\""
}

Estoy usando

buildTypes.each {
    it.buildConfigField 'String', 'GoogleMapsApiKey', "\"$System.env.GoogleMapsApiKey\""
}

Se basa en la respuesta de Dennis, pero la toma de una variable de entorno.

Ninguna de las respuestas anteriores me dio pautas, por lo que tuve que pasar dos horas aprendiendo sobre los métodos Groovy.

Quería poder ir en contra de un entorno de producción, sandbox y local. Como soy vago, solo quería cambiar la URL en un lugar. Esto es lo que se me ocurrió:

 flavorDimensions 'environment'
    productFlavors {
        production {
            def SERVER_HOST = "evil-company.com"
            buildConfigField 'String', 'API_HOST', "\"${SERVER_HOST}\""
            buildConfigField 'String', 'API_URL', "\"https://${SERVER_HOST}/api/v1/\""
            buildConfigField 'String', 'WEB_URL', "\"https://${SERVER_HOST}/\""
            dimension 'environment'
        }
        rickard {
            def LOCAL_HOST = "192.168.1.107"
            buildConfigField 'String', 'API_HOST', "\"${LOCAL_HOST}\""
            buildConfigField 'String', 'API_URL', "\"https://${LOCAL_HOST}/api/v1/\""
            buildConfigField 'String', 'WEB_URL', "\"https://${LOCAL_HOST}/\""
            applicationIdSuffix ".dev"
        }
    }

Sintaxis alternativa, porque solo puede usar ${variable}comillas dobles en Groovy Methods.

    rickard {
        def LOCAL_HOST = "192.168.1.107"
        buildConfigField 'String', 'API_HOST', '"' + LOCAL_HOST + '"'
        buildConfigField 'String', 'API_URL', '"https://' + LOCAL_HOST + '/api/v1/"'
        buildConfigField 'String', 'WEB_URL', '"https://' + LOCAL_HOST + '"'
        applicationIdSuffix ".dev"
    }

Lo que me resultó difícil de entender fue que las cadenas deben declararse como cadenas rodeadas de comillas. Debido a esa restricción, no pude usar la referencia API_HOSTdirectamente, que era lo que quería hacer en primer lugar.