How to replace a string for a buildvariant with gradle in android studio?

Question

I have two flavors of my project:

flavor1 -> packagename: com.example.flavor1 
flavor2 -> packagename: com.example.flavor2

Now I want

Answer 1

I solved the problem on my own, so here is the solution "step by step" - perhaps it will help some other newbies to gradle :)

• Copy Task in General:

  copy{
      from("pathToMyFolder"){
          include "my.file"
      }
      // you have to use a new path for youre modified file
      into("pathToFolderWhereToCopyMyNewFile")
  }
  

• Replace a line in General:

  copy {
     ...
     filter{
         String line -> line.replaceAll("<complete line of regular expression>",
                                        "<complete line of modified expression>")
     }
  }
  

• I think the biggest problem was to get the right paths, because I had to make this dynamically (this link was very helpful for me). I solved my problem by replacing the special lines in the manifest and not in the String-file.

• The following example shows how to replace the "meta-data"-tag in the manifest to use youre google-maps-api-key (in my case there are different flavors that use different keys ):

  android.applicationVariants.each{ variant -> 
      variant.processManifest.doLast{ 
          copy{
              from("${buildDir}/manifests"){
                  include "${variant.dirName}/AndroidManifest.xml"
              }
              into("${buildDir}/manifests/$variant.name")
  
              // define a variable for your key:
              def gmaps_key = "<your-key>"
  
              filter{
                  String line -> line.replaceAll("<meta-data android:name=\"com.google.android.maps.v2.API_KEY\" android:value=\"\"/>",
                                                 "<meta-data android:name=\"com.google.android.maps.v2.API_KEY\" android:value=\"" + gmaps_key + "\"/>")
              }
  
              // set the path to the modified Manifest:
              variant.processResources.manifestFile = file("${buildDir}/manifests/${variant.name}/${variant.dirName}/AndroidManifest.xml")
          }    
     }
  }
  

Answer 2

The answers are quite outdated, there are better ways now to archive it. You can use the command in your build.gradle:

manifestPlaceholders = [
            myPlaceholder: "placeholder",
    ]

and in your manifest:

android:someManifestAttribute="${myPlaceholder}"

more information can be found here: https://developer.android.com/studio/build/manifest-merge.html

Answer 3

In the current Android Gradle DSL, the ApplicationVariant class has changed and Saad's approach has to be rewritten e.g. as follows:

applicationVariants.all { variant ->
    variant.outputs.each { output ->
        output.processManifest.doLast {
            replaceInManifest(output,
                    'GMAPS_KEY',
                    getGmapsKey(buildType))

            }
        }
    }

def replaceInManifest(output, fromString, toString) {
    def updatedContent = output.processManifest.manifestOutputFile.getText('UTF-8')
        .replaceAll(fromString, toString)
    output.processManifest.manifestOutputFile.write(updatedContent, 'UTF-8')
}

The new DSL also offers a cleaner approach to get directly to the manifest file.

Answer 4

I use almost exactly the approach you wanted to. The replaceInManfest is also generic and can be used for other placeholders as well. The getGMapsKey() method just returns the appropriate key based on the buildType.

applicationVariants.all { variant ->
    def flavor = variant.productFlavors.get(0)
    def buildType = variant.buildType
    variant.processManifest.doLast {
        replaceInManifest(variant,
            'GMAPS_KEY',
            getGMapsKey(buildType))
    }
}

def replaceInManifest(variant, fromString, toString) {
    def flavor = variant.productFlavors.get(0)
    def buildtype = variant.buildType
    def manifestFile = "$buildDir/manifests/${flavor.name}/${buildtype.name}/AndroidManifest.xml"
    def updatedContent = new File(manifestFile).getText('UTF-8').replaceAll(fromString, toString)
    new File(manifestFile).write(updatedContent, 'UTF-8')
}

I have it up on a gist too if you want to see if it evolves later.

I found this to be a more elegant and generalizable approach than the others (although the token replacement just working would have been nicer).