amp.gradle

class AndroidManifestPreprocessorExtension {
    HashMap<String, String> placeHolders = new HashMap<>()

    void placeholder(String key, String value) {
        placeHolders.put('${' + key + '}', value)
    }
}

class AndroidManifestPreprocessorTask extends DefaultTask {

    String group = "Android Manifest Preprocessor"
    String description = "Replace placeholders for configured strings."
    List<TaskConfiguration> configurations

    AndroidManifestPreprocessorTask() {
        outputs.upToDateWhen { false }
    }

    @TaskAction
    def execute(IncrementalTaskInputs inputs) {
        AndroidManifestPreprocessorExtension extension = project.extensions.getByType(AndroidManifestPreprocessorExtension.class)

        configurations.each { config ->
            def input = config.inputFile
            def workingText = input.text
            extension.placeHolders.each { placeholder ->
                workingText = workingText.replace(placeholder.key, placeholder.value)
            }
            config.outputFile.write(workingText)
        }
    }

    static class TaskConfiguration {
        File inputFile
        File outputFile

        TaskConfiguration(File inputFile, File outputFile) {
            this.inputFile = inputFile
            this.outputFile = outputFile
        }
    }
}

class AndroidManifestPreprocessorPlugin implements Plugin<Project> {

    @SuppressWarnings("GroovyUnusedDeclaration")
    public static final String VERSION = "0.1"
    private AndroidManifestPreprocessorExtension extension

    @Override
    void apply(Project project) {
        project.afterEvaluate {
            if (!containsAndroid(project))
                throw GradleException("Project does not contains Android Plugin")
            project.android.applicationVariants.all { variant ->
                def manifestFiles = findManifestFiles(variant)

                def task = project.tasks.create("preProcessAndroidManifest${variant.name.capitalize()}", AndroidManifestPreprocessorTask.class) {
                    configurations = manifestFiles
                }
                Task pluginTask = findPluginTask(project, variant)
                pluginTask?.dependsOn?.add(task)
            }
        }
        extension = project.extensions.create("amp", AndroidManifestPreprocessorExtension)
    }

    private static boolean containsAndroid(Project project) {
        def plugins = project.plugins
        if (plugins == null || plugins.isEmpty())
            return false
        return plugins.findPlugin("com.android.application") != null ||
                plugins.findPlugin("com.android.library") != null
    }

    private static List<AndroidManifestPreprocessorTask.TaskConfiguration> findManifestFiles(variant) {
        variant.sourceSets.collect { sourceSet ->
            new AndroidManifestPreprocessorTask.TaskConfiguration(
                    new File(sourceSet.manifestFile.parentFile, "manifest/AndroidManifest.xml"),
                    sourceSet.manifestFile
            )
        }.findAll {
            it.inputFile.exists()
        }.toList()
    }

    private static Task findPluginTask(project, variant) {
        def pluginTaskName = "check${variant.name.capitalize()}Manifest"
        def pluginTask = project.tasks.findByName(pluginTaskName)

        if (pluginTask == null) {
            project.logger.log(LogLevel.ERROR, "The task \"${pluginTaskName}\" does not exists!")
            return null
        }

        return pluginTask
    }
}

plugins.apply(AndroidManifestPreprocessorPlugin.class)