Androidで複数バリアントで、APIキーを分ける方法

apply plugin: "com.android.application"

android.applicationVariants.all { variant ->

    def variantName = variant.name.capitalize()
    def newRelicTasksGroup = "newrelic"
    def projectDirPath = project.getProjectDir().absolutePath
    def newRelicPropertyFileName = "newrelic.properties"
    def newRelicPropertyFilePath = "${projectDirPath}/${newRelicPropertyFileName}"

    // Cleanup task for New Relic property file creation process.
    def deleteNewRelicPropertyFile = "deleteNewRelicPropertyFile"
    def taskDeleteNewRelicPropertyFile = project.tasks.findByName(deleteNewRelicPropertyFile)

    if (!taskDeleteNewRelicPropertyFile) {
        taskDeleteNewRelicPropertyFile = tasks.create(name: deleteNewRelicPropertyFile) {
            group = newRelicTasksGroup
            description = "Delete the newrelic.properties file on project dir."

            doLast {
                new File("${newRelicPropertyFilePath}").with {
                    if (exists()) {
                        logger.lifecycle("Deleting file ${absolutePath}.")
                        delete()
                    } else {
                        logger.lifecycle("Nothing to do. File ${absolutePath} not found.")
                    }
                }
            }
        }
    }

    /*
     * Fix for warning message reported by task "newRelicMapUploadVariantName"
     * Message:
     * [newrelic] newrelic.properties was not found! Mapping file for variant [variantName] not uploaded.
     * New Relic discussion:
     * https://discuss.newrelic.com/t/how-to-set-up-newrelic-properties-file-for-project-with-multiple-build-variants/46176
     */

    def requiredTaskName = "assemble${variantName}"
    def taskAssembleByVariant = project.tasks.findByName(requiredTaskName)
    def createNewRelicPropertyFileVariantName = "createNewRelicPropertyFile${variantName}"

    // 0. Searching task candidate to be dependent.
    if (taskAssembleByVariant) {
        logger.debug("Candidate task to be dependent found: ${taskAssembleByVariant.name}")

        // 1. Task creation
        def taskCreateNewRelicPropertyFile = tasks.create(name: createNewRelicPropertyFileVariantName) {
            group = newRelicTasksGroup
            description = "Generate the newrelic.properties file on project dir.\nA key/value propety " +
                    "will be written in file to be consumed by newRelicMapUploadVariantName task."

            logger.debug("Creating task: ${name}")

            doLast {
                def newRelicPropertyKey = "com.newrelic.application_token"
                def newRelicStringResourceKey = "new_relic_key"
                def targetResourceFileName = "api.xml"
                def variantXmlResourceFilePath = "${projectDirPath}/src/${variant.name}/res/values/${targetResourceFileName}"
                def mainXmlResourceFilePath = "${projectDirPath}/src/main/res/values/${targetResourceFileName}"
                def xmlResourceFilesPaths = [variantXmlResourceFilePath, mainXmlResourceFilePath]

                xmlResourceFilesPaths.any { xmlResourceFilePath ->
                    // 1.1. Searching xml resource file.
                    def xmlResourceFile = new File(xmlResourceFilePath)
                    if (xmlResourceFile.exists()) {
                        logger.lifecycle("Reading property from xml resource file: ${xmlResourceFilePath}.")

                        // 1.2. Searching for string name new_relic_key api.xml resource file.
                        def nodeResources = new XmlParser().parse(xmlResourceFile)
                        def nodeString = nodeResources.find {
                            Node nodeString -> nodeString."@name".toString() == newRelicStringResourceKey
                        }

                        // 1.3. Checking if string name new_relic_key was found.
                        if (nodeString != null) {
                            def newRelicApplicationToken = "${nodeString.value()[0]}"
                            logger.lifecycle("name:${nodeString."@name".toString()};" +
                                    "value:${newRelicApplicationToken}")

                            // 1.4 Checking the content of newRelicApplicationToken
                            if (newRelicApplicationToken == "null" || newRelicApplicationToken.allWhitespace) {
                                logger.warn("Invalid value for key ${newRelicStringResourceKey}. " +
                                        "Please, consider configuring a value for key ${newRelicStringResourceKey}" +
                                        " on ${xmlResourceFile.name} resource file for buildVariant: ${variantName}. " +
                                        "The ${newRelicPropertyFileName} will be not created.")
                                return true // break the loop
                            }

                            // 1.5. File creation.
                            File fileProperties = new File(newRelicPropertyFilePath)
                            fileProperties.createNewFile()
                            logger.lifecycle("File ${fileProperties.absolutePath} created.")

                            // 1.6. Writing content on properties file.
                            def fileComments = "File generated dynamically by gradle task ${createNewRelicPropertyFileVariantName}.\n" +
                            "Don\"t change it manually.\n" +
                            "Don\"t track it on VCS."
                            new Properties().with {
                                load(fileProperties.newDataInputStream())
                                setProperty(newRelicPropertyKey, newRelicApplicationToken.toString())
                                store(fileProperties.newWriter(), fileComments)
                            }

                            logger.lifecycle("Properties saved on file ${fileProperties.absolutePath}.")
                            return true // break the loop
                        } else {
                            logger.warn("The key ${newRelicStringResourceKey} was not found on ${xmlResourceFile.absolutePath}.\n" +
                                    "Please, consider configuring a key/value on ${xmlResourceFile.name} resource file for buildVariant: ${variantName}.")
                            return // continue to next xmlResourceFilePath
                        }
                    } else {
                        logger.error("Resource file not found: ${xmlResourceFile.absolutePath}")
                        return // continue next xmlResourceFilePath
                    }
                }
            }
        }

        // 2. Task dependency setup
        // To check the task dependencies, use:
        // logger.lifecycle("Task ${name} now depends on tasks:")
        // dependsOn.forEach { dep -> logger.lifecycle("\tTask: ${dep}") }
        tasks["clean"].dependsOn taskDeleteNewRelicPropertyFile
        taskCreateNewRelicPropertyFile.dependsOn taskDeleteNewRelicPropertyFile
        taskAssembleByVariant.dependsOn taskCreateNewRelicPropertyFile
    } else {
        logger.error("Required task ${requiredTaskName} was not found. " +
                "The task ${createNewRelicPropertyFileVariantName} will be not created.")
    }

    //
}

plugins {
    id("com.android.application")
    id("newrelic")
}

//add here
apply (from = "./newrelic-util.gradle")

dependencies {
    implementation("com.newrelic.agent.android:android-agent:7.3.1")
}

apply from: "./newrelic-util.gradle"

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="new_relic_key">(New RelicのUIからコピーしたモバイルアプリのAPIキー)</string>
</resources>

        NewRelic.withApplicationToken(
                getResources().getString(R.string.new_relic_key)
        ).start(this.getApplicationContext());