Define buildconfigfield for an specific flavor AND buildType

Question

I have 2 flavors, lets say Vanilla and Chocolate. I also have Debug and Release build types, and I need Vanilla Release to have a field true, while the other 3 combinations should be false.

def BOOLEAN = "boolean"
def VARIABLE = "VARIABLE"
def TRUE = "true"
def FALSE = "false"

    VANILLA {

        debug {

            buildConfigField BOOLEAN, VARIABLE, FALSE

        }

        release {

            buildConfigField BOOLEAN, VARIABLE, TRUE

        }


    }

    CHOCOLATE {
        buildConfigField BOOLEAN, VARIABLE, FALSE
    }

I'm having an error, so I guess the debug and release trick doesnt work. It is possible to do this?

I prefer to use BOOLEAN, TRUE and FALSE rather than "boolean", "true" and "false". However has nothing to do with the question — JesusS, May 21 '15 at 07:43

score 119 · Accepted Answer · answered May 27 '15 at 15:06

119

Loop the variants and check their names:

productFlavors {
    vanilla {}
    chocolate {}
}

applicationVariants.all { variant ->
    println("Iterating variant: " + variant.getName())
    if (variant.getName() == "chocolateDebug") {
        variant.buildConfigField "boolean", "VARIABLE", "true"
    } else {
        variant.buildConfigField "boolean", "VARIABLE", "false"
    }
}

answered May 27 '15 at 15:06

Simas

43,548
10
88
116

1

Thanks a lot! I still have to wait to give the bounty until tomorrow – JesusS May 27 '15 at 16:50
This solution has one lack - you use strings for determining a build variant. In case of a large number of buildConfigFields you'll have a boilerplate code. And also you shouldn't forget to correct checks after renaming of buildType or productFlavor – Alex Kucherenko Nov 09 '17 at 10:04
4

if this is going in a library instead of an application, small change like so: `libraryVariants.all { variant -> variant.outputs.all { println("Iterating variant: ${variant.name}") } }` – MrTristan Jan 12 '18 at 01:48
3

It stopped working after upgrade to Gradle plugin 4.0. :( Don't you have a solution by chance? – Georgiy Shur Dec 22 '20 at 12:32
@GeorgiyShur same issue here as well, did you find a fix for this? – AA_PV Apr 30 '21 at 08:00
Not work when using Gradle plugin 4.1.3 – DysaniazzZ May 18 '22 at 08:28

score 33 · Answer 2 · edited Feb 21 '19 at 10:08

33

Here is a solution without lacks I've described under Simas answer

buildTypes {
    debug {}
    release {}
}

productFlavors {
    vanilla {
        ext {
            variable = [debug: "vanilla-debug value", release: "vanilla-release value"]
        }
    }
    chocolate {
        ext {
            variable = [debug: "chocolate-debug value", release: "chocolate-release value"]
        }
    }
}

applicationVariants.all { variant ->
    def flavor = variant.productFlavors[0]
    variant.buildConfigField "boolean", "VARIABLE", "\"${flavor.variable[variant.buildType.name]}\""
}

edited Feb 21 '19 at 10:08

Naveen T P

6,955
2
22
29

answered Nov 09 '17 at 10:19

Alex Kucherenko

20,168
2
26
33

I don't usually write "thank you" comments, but this was really helpful - thank you! Btw, "ext" is mandatory here. – Micer May 09 '18 at 11:30

score 6 · Answer 3 · answered May 21 '15 at 08:39

6

Within the Gradle build system, buildTypes and productFlavors are unfortunately two separate entities.

As far as I am aware, to complete what you want to achieve, you would need to create another build flavour as such:

buildTypes {
        debug{}
        release {}
    }

    productFlavors {
        vanillaDebug {
             buildConfigField BOOLEAN, VARIABLE, FALSE
        }
        vanillaRelease {
             buildConfigField BOOLEAN, VARIABLE, TRUE
        }
        chocolate {
             buildConfigField BOOLEAN, VARIABLE, FALSE
        }
    }

answered May 21 '15 at 08:39

Ed Holloway-George

5,092
2
37
66

3

Thanks for the answer, that's what i was afraid of. With this approach i would have 6 different builds, right? vanillaDebugDebug, vanillaDebugRelease, vanillaReleaseDebug, vanillaReleaseRelease, chocolateDebug, chocolateRelease right? I think this solution is not suitable for my needs but I guess there's no good solution to the problem – JesusS May 21 '15 at 09:53
1

It is not ideal I know, but it is the correct way of doing it at present – Ed Holloway-George May 21 '15 at 10:00
This will produce vanillaDebugDebug, vanillaDebugRelease, vanillaReleaseDebug, vanillaReleaseRelease, chocolateDebug, chocolateRelease which is not right – Jemshit Apr 02 '20 at 08:17

score 5 · Answer 4 · answered Jun 22 '18 at 08:21

5

For your specific case, you can also just play with defaultConfig:

defaultConfig {
    buildConfigField BOOLEAN, VARIABLE, TRUE
}

buildTypes {
    debug {
        buildConfigField BOOLEAN, VARIABLE, FALSE
    }
    release {
    }
}

productFlavors {
    VANILLA {
    }
    CHOCOLATE {
        buildConfigField BOOLEAN, VARIABLE, FALSE
    }
}

The Default value is TRUE, but then you put FALSE to all Debug builds and all Chocolate builds. So the only remaining TRUE is VANILLA-release.

answered Jun 22 '18 at 08:21

Arnaud SmartFun

1,573
16
21

yes I did test it. yes it works. As I said this is for his specific case = vanillia release TRUE, the other FALSE. It is not possible to use this mehtod for any combination. BuildTypes and productFlavors override the defaultConfig value. So the idea is to put TRUE by default, and override to FALSE for debug (vanillia debug & chocolate debug) and chocolate (debug chocolate and release chocolate). So all is FALSE except release vanillia who was not overriden. – Arnaud SmartFun Nov 13 '18 at 17:47
This is a really good solution when you're just trying to add a `buildConfigField` for one `buildType`. Without adding that `buildConfigField` to the other `buildType`s, it won't compile. But using `defaultConfig` does the trick. – Joshua Pinter Oct 25 '19 at 02:23

score 3 · Answer 5 · answered Oct 05 '16 at 14:37

Here's how I solved this:

def GAME_DIMENSION = "game"
def BUILD_DIMENSION = "building"

flavorDimensions GAME_DIMENSION, BUILD_DIMENSION

productFlavors {
    lollipop {
        dimension BUILD_DIMENSION
        minSdkVersion 21
    }

    normal {
        dimension BUILD_DIMENSION
    }

    game_1 {
        dimension GAME_DIMENSION
        ext {
            fields = [
                    [type: 'String', name: 'TESTSTRING', values: [debug: 'debugstring', release: 'releasestring']],
                    [type: 'int', name: 'TESTINT', values: [debug: '1234', release: '31337']]
            ]
        }
    }

    game_2 {
        dimension GAME_DIMENSION
        ext {
            fields = []  // none for game_2
        }
    }
}

applicationVariants.all { variant ->

    // get the GAME dimension flavor
    def game = variant.getProductFlavors()
            .findAll({ flavor -> flavor.dimension == GAME_DIMENSION})
            .get(0)

    println "Adding " + game.ext.fields.size() + " custom buildConfigFields for flavor " + variant.name

    // loop over the fields and make appropriate buildConfigField
    game.ext.fields.each { field ->
        def fldType = field['type']
        def fldName = field['name']
        def fldValues = field['values']

        // get debug/release specific value from values array
        def fldSpecificValue = fldValues[variant.getBuildType().name]

        // add quotes for strings
        if (fldType == 'String') {
            fldSpecificValue = '\"' + fldSpecificValue + '\"'
        }

        println "    => " + fldType + " " + fldName + " = " + fldSpecificValue
        variant.buildConfigField fldType, fldName, fldSpecificValue
    }
}

(I have not yet been able to determine whether or not ext.fields exists on a flavor)

Alok Singh · Answer 6 · 2018-12-21T13:00:08.803

You can try this for multiple products flavors:

productFlavors {
        demo {
            applicationId "com.demo"
            versionCode 1
            versionName '1.0'
            ext {
                APP_BASE_URL = [debug: "${BASE_URL_DEV}", release: "${BASE_URL_PRODUCTION}"]
            }
        }
        demo1 {
            applicationId "com.demo1"
            versionCode 1
            versionName '1.2'
            ext {
                APP_BASE_URL = [debug: "${BASE_URL_DEV}", release: "${BASE_URL_PRODUCTION}"]
            }
        }


    applicationVariants.all { variant ->
            def flavor = variant.productFlavors[0]
            variant.buildConfigField "String", "BASE_URL", "${flavor.ext.APP_BASE_URL[variant.buildType.name]}"
        }

score 3 · Answer 7 · answered Feb 06 '20 at 09:56

@Simas Aswer is correct, but it might look a little bit better with switch case:

android {

    defaultConfig {
       ...
    }

    buildTypes {
        debug {
            ...
        }

        release {
            ...
        }

    }

    flavorDimensions "type"
    productFlavors {

        vanilla {
            dimension "type"
           ...
        }


        chocolate {
            dimension "type"
            ...
        }
    }

    applicationVariants.all { variant ->
        switch (variant.getName()) {
            case "vanillaDebug":
                variant.buildConfigField 'String', 'SDK_API_KEY', "\"$vanillaSdkApiKeyDebug\""
                break

            case "vanillaRelease":
                variant.buildConfigField 'String', 'SDK_API_KEY', "\"$vanillaSdkApiKeyRelease\""
                break

            case "chocolateDebug":
                variant.buildConfigField 'String', 'SDK_API_KEY', "\"$chocolateSdkApiKeyDebug\""
                break

            case "chocolateRelease":
                variant.buildConfigField 'String', 'SDK_API_KEY', "\"$chocolateSdkApiKeyRelease\""
                break

            default:
                throw new GradleException("The values are unknown for variant: ${variant.getName()}")
                break
        }
    }
}

Kayc90 · Answer 8 · 2022-10-25T10:58:31.293

I've solved it in following way (.kts)

 applicationVariants.all {
        when {
            flavorName.contains("flavor1", true) && buildType.name.equals("debug", true) -> {
                buildConfigField("String", "BACKEND_URL", "\"https://api.dev.flavor1.com\"")
            }
            flavorName.contains("flavor1", true) && buildType.name.equals("release", true) -> {
                buildConfigField("String", "BACKEND_URL", "\"https://api.prod.flavor1.com\"")
            }
            flavorName.contains("flavor2", true) && buildType.name.equals("debug", true) -> {
                buildConfigField("String", "BACKEND_URL", "\"https://api.dev.flavor2.com\"")
            }
            flavorName.contains("flavor2", true) && buildType.name.equals("release", true) -> {
                buildConfigField("String", "BACKEND_URL", "\"https://api.prod.flavor2.com\"")
            }
        }
}

This solution can be used when the URLs for each flavor/build-type combination have major differences from each other.

Additionally it's important to use applicationVariants.all{ .. } without the lambda-parameter.

score -1 · Answer 9 · answered Apr 05 '17 at 13:47

-1

productFlavors {
    vanilla {}
    chocolate {}
}

buildTypes {
        release {
            productFlavors.vanilla {
                //your configuration for vanilla flavor with release buildType
            }
        }
        debug {
            productFlavors.chocolate{
                //your configuration for chocolate flavor with debug buildType
            }
        }
    }

answered Apr 05 '17 at 13:47

Paha

864
7
15

2

When you do this, It will take the last definition you put. So in this case it will always compile with debugCocolate. When you change the order so vanilla is defined below chocolate, it will always take that. This is most likely not the desired result. Although, it would be nice if it would work like this. – pl3kn0r May 16 '17 at 15:35

Define buildconfigfield for an specific flavor AND buildType

9 Answers9

Linked

Related