build.gradle

import javax.imageio.ImageIO

private int toGray(color) {
    def a = (color & 0xFF000000)
    def r = (color & 0x00FF0000) >> 16
    def g = (color & 0x0000FF00) >>  8
    def b = (color & 0x000000FF)

    def c = (int)((2.0*r + 4.0*g + b) / 7.0) //
    return a | (c << 16) | (c << 8) | c
}

ext.iconToGrayScale = { File inputFile, File outputFile ->
    if (outputFile.exists() && outputFile.lastModified() >= inputFile.lastModified()) {
        return;
    }

    def img = ImageIO.read(inputFile)
    for (int y = 0; y < img.getHeight(); y++) {
        for (int x = 0; x < img.getWidth(); x++) {
            def color = img.getRGB(x, y)
            img.setRGB(x, y, toGray(color))
        }
    }

    outputFile.getParentFile().mkdirs()
    ImageIO.write(img, "png", outputFile)
}

/**
 * Makes gray-scaled launcher icons for the "debug" build variant.
 */
ext.makeGrayscaleLauncherIcon = { File dir, String name, List<String> buildTypes = ["debug"] ->
    fileTree(dir: dir, include: "res/drawable*/$name").each { File ic ->
        buildTypes.each { String buildType ->
            def outputFile = file(ic.getPath().replaceAll("/main/", "/$buildType/"))
            iconToGrayScale(ic, outputFile)
        }
    }
}

ext.writeProperties = { File propertiesFile, Map<String, String> dict ->
    def s = ""
    dict.each { key, value ->
        s += "$key=$value\n"
    }
    logger.info("writing $propertiesFile")
    propertiesFile.write(s)
}

/**
 * Initialize local.properties which includes sdk.dir, ndk.dir and extra properties.
 */
ext.initSdkDir = { Map<String, String> extra = null ->
    def localPropFile = file("local.properties")

    if (!localPropFile.exists()) {
        def dict = new HashMap<String, String>()
        if (extra != null) {
            dict.putAll(extra)
        }

        // sdk.dir is required
        [
            System.getenv("ANDROID_HOME"),
            System.getenv("ANDROID_SDK"),
            "/usr/local/opt/android-sdk",
            "/Applications/Android Studio/sdk"
        ].each { dir ->
            if (dir != null && file(dir).exists()) {
                dict["sdk.dir"] = dir
                return;
            }
        }
        if (dict["sdk.dir"] == null) {
            throw new RuntimeException("No Android SDK found.")
        }

        // ndk.dir is optional
        [
            System.getenv("ANDROID_NDK"),
            "/usr/local/opt/android-ndk",
        ].each { dir ->
            if (dir != null && file(dir).exists()) {
                dict["ndk.dir"] = dir
                return;
            }
        }

        writeProperties(localPropFile, dict)
    }
}

/**
 * Writes Android resources.
 * e.g. writeResources(file("src/main/res/values/_generated.xml"), ["foo" : "bar"])
 */
ext.writeResources = { File file, Map<String, Object> dict ->
    def s = ""
    s += """<?xml version="1.0" encoding="utf-8"?>\n<resources>\n"""
    dict.each { key, value ->
        if (value in Boolean) {
            s += """<bool name="$key">$value</bool>\n"""
        } else if (value in Integer) {
            s += """<integer name="$key">$value</integer>\n"""
        } else {
            s += """<string name="$key">$value</string>\n"""
        }
    }
    s += """</resources>\n"""

    logger.info("writing $file")
    file.write(s)
}

/**
 * Create `outputFile` from `inputFile` if it does not exist.
 * You can force overwrite with specifies the `true` to the 3rd argument.
 */
ext.copyFile = { File inputFile, File outputFile, boolean toOverwrite = false ->
    if (!inputFile.exists()) {
        throw new FileNotFoundException("Template file does not exist: ${inputFile.getAbsolutePath()}")
    }
    outputFile.getParentFile().mkdirs()
    if (toOverwrite || !outputFile.exists()) {
        outputFile.bytes = inputFile.readBytes()
    }
}

/**
 * Representation of Semantic Version (major.minor.patch-level)
 */
public class Version {
    public final int major;
    public final int minor;
    public final int patchLevel;

    public final String source;

    public Version(String v) {
        source = v.trim()

        def parts = source.split("\\.", 3)
        major = Integer.valueOf(parts[0])
        minor = Integer.valueOf(parts[1])
        patchLevel = Integer.valueOf(parts[2])
    }

    @Override
    public String toString() {
        return String.format("%s (%s)", toVersionName(), toVersionCode())
    }

    public String toVersionName() {
        return source
    }

    public int toVersionCode() {
        return major * (1000 * 1000) + minor * 1000 + patchLevel;
    }
}

ext.parseVersion = { String versionString ->
    return new Version(versionString)
}

ext.readVersion = { File file ->
    def s = new String(file.readBytes())
    return parseVersion(s)
}

/**
 * Set buildConfigField from "Map" to buildType or productFlavors.
 * You can specifies buildType or flavor object to the fist argument.
 * But don't provided `buildConfigField` in variant with `android-gradle-plugin` v0.9.0.
 */
ext.setBuildConfigField = { def buildType, Map<Object, Object> buildConfigMap ->
    for (def entry in buildConfigMap) {
        if (entry.value instanceof String) {
            buildType.buildConfigField "${entry.value.getClass().getName()}", "${entry.key}", "\"${entry.value}\""
        } else {
            buildType.buildConfigField "${entry.value.getClass().getName()}", "${entry.key}","${entry.value}"
        }
    }
}