build.gradle

buildscript {
    ext.kotlin_version = '1.3.72'

    /**
     * Properties and environment variables needed to publish to Bintray.
     */
    ext.mavenRepo = (project.hasProperty('maven.repo') ?
            project.property("maven.repo") : '')
    ext.mavenUsername = (project.hasProperty('maven.username') ?
            project.property("maven.username") : '')
    ext.mavenPassword = (project.hasProperty('maven.password') ?
            project.property("maven.password") : '')
    ext.jfrogUsername = (project.hasProperty('jfrog.username') ?
            project.property("jfrog.username") : '')
    ext.jfrogPassword = (project.hasProperty('jfrog.password') ?
            project.property("jfrog.password") : '')

    ext.getPropertyValue =  { propertyKey ->
        def property  = System.getenv(propertyKey)

        if (property == null) {
            logger.log(LogLevel.INFO, "Could not locate $propertyKey as environment variable. " +
                    "Trying local.properties")
            Properties properties = new Properties()
            if (project.rootProject.file('local.properties').exists()) {
                properties.load(project.rootProject.file('local.properties').newDataInputStream())
                property = properties.getProperty(propertyKey)
            }
        }

        if (property == null) {
            logger.log(LogLevel.WARN, "$propertyKey unavailable.")
        }

        return property
    }

    ext.getAudioSwitchJfrogOssPassword = {
        def audioSwitchJfrogOssPassword  = System.getenv("AUDIOSWITCH_JFROG_OSS_PASSWORD");

        if (audioSwitchJfrogOssPassword == null) {
            logger.log(LogLevel.INFO, "Could not locate AUDIOSWITCH_JFROG_OSS_PASSWORD environment variable. " +
                    "Trying local.properties")
            Properties properties = new Properties()
            if (project.rootProject.file('local.properties').exists()) {
                properties.load(project.rootProject.file('local.properties').newDataInputStream())
                audioSwitchJfrogOssPassword = properties.getProperty('AUDIOSWITCH_JFROG_OSS_PASSWORD')
            }
        }

        if (audioSwitchJfrogOssPassword == null) {
            logger.log(LogLevel.WARN, "AudioSwitch Jfrog OSS password unavailable.")
        }

        return audioSwitchJfrogOssPassword;
    }

    ext.getShortCommitSha = {
        def gitSha = System.getenv("CIRCLE_SHA1")

        if(gitSha != null) return gitSha.substring(0, 7) else return ""
    }

    ext.audioSwitchVersion = "${versionMajor}.${versionMinor}.${versionPatch}" +
            ((project.hasProperty("preRelease") && project.property("preRelease").toBoolean() == true) ?
                    "-SNAPSHOT" :
                    '')

    repositories {
        google()
        jcenter()

    }
    dependencies {
        classpath 'com.android.tools.build:gradle:4.0.0'
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
    }
}

plugins {
    id "com.diffplug.gradle.spotless" version "4.0.1"
    id "com.jfrog.artifactory" version "4.15.2"
}
apply plugin: "com.diffplug.gradle.spotless"
spotless {
    format 'misc', {
        target '**/*.gradle', '**/*.md', '**/.gitignore'

        trimTrailingWhitespace()
        indentWithSpaces()
        endWithNewline()
    }
    java {
        target '**/*.java'
        googleJavaFormat().aosp()
    }
    kotlin {
        target '**/*.kt'
        ktlint()
    }
}

allprojects {
    repositories {
        google()
        jcenter()
    }
}

/*
 * Utility GradleBuild task that enables defining custom tasks derived from gradle modules in a
 * root level gradle file.
 *
 * TODO: Replace this approach in favor of pushing tasks down into their respective modules.
 */
class RootGradleBuild extends GradleBuild {
    private static final String ROOT_PROJECT_NAME = "audioswitch-root"

    RootGradleBuild() {
        super()
        buildName = ROOT_PROJECT_NAME
    }
}

/*
 * Checks if release tag matches version and current commit
 */
def matchesVersion(versionTag) {
    def properties = new Properties()
    file("${rootDir}/gradle.properties").withInputStream { properties.load(it) }
    def releaseTag = "${properties.getProperty("versionMajor")}." +
            "${properties.getProperty("versionMinor")}." +
            "${properties.getProperty("versionPatch")}"

    return releaseTag == versionTag
}

task validateReleaseTag {
    description = 'Validate the release tag matches the release version ' +
            'present on commit'
    group = 'Git'

    doLast {
        def circleTag = System.getenv("CIRCLE_TAG")
        def tagsMatch = (matchesVersion(circleTag)) ? ("true") : ("false")

        exec {
            workingDir "${rootDir}"
            commandLine tagsMatch
        }
    }
}

task incrementVersion(type: RootGradleBuild) {
    description = 'Increment the SDK version after a release'
    group = 'Git'

    doLast {
        def stdOut = new ByteArrayOutputStream()

        exec {
            commandLine "bash", "-c", "git remote show origin | grep HEAD | cut -d: -f2-"
            standardOutput stdOut
        }

        def gitBranch = stdOut.toString().replaceAll("\\s","")
        def circleTag = System.getenv("CIRCLE_TAG")
        def nextVersionPatch = versionPatch.toInteger() + 1

        if (!buildDir.exists()) {
            buildDir.mkdir()
        }

        exec {
            workingDir "${rootDir}"
            commandLine "git", "checkout", "${gitBranch}"
        }

        /*
         * Only update the version on upstream branch if the version matches tag. It is possible
         * these values do not match if a job is performed on an earlier commit and a PR
         * with a version update occurs later in history.
         */
        if (matchesVersion(circleTag)) {
            exec {
                workingDir "${rootDir}"
                commandLine "echo", "Incrementing from versionPatch ${versionPatch} to " +
                        "${nextVersionPatch}"
            }

            exec {
                workingDir "${rootDir}"
                commandLine "sed",
                        "s@versionPatch=.*@versionPatch=${nextVersionPatch}@",
                        "gradle.properties"
                standardOutput new FileOutputStream("${buildDir}/gradle.properties")
            }

            exec {
                workingDir "${rootDir}"
                commandLine "mv", "${buildDir}/gradle.properties", "gradle.properties"
            }

            exec {
                workingDir "${rootDir}"
                commandLine "git", "commit", "gradle.properties", "-m", "\"Bump patch version [skip ci]\""
            }

            exec {
                workingDir "${rootDir}"
                commandLine "git", "push", "origin", "${gitBranch}"
            }
        }
    }
}

task jfrogOssSnapshotsAudioSwitchUpload(type: RootGradleBuild) {
    description = 'Publish an AudioSwitch Snapshot to JFrog OSS'
    group = 'Publishing'
    buildFile = file('audioswitch/build.gradle')
    tasks = ['assembleRelease', 'artifactoryPublish']
    startParameter.projectProperties += gradle.startParameter.projectProperties + [
            'preRelease': true,
            'jfrog.username': "${getPropertyValue("AUDIOSWITCH_JFROG_OSS_USERNAME")}",
            'jfrog.password': "${getPropertyValue("AUDIOSWITCH_JFROG_OSS_PASSWORD")}"
    ]
}

task bintrayAudioSwitchReleaseUpload(type: RootGradleBuild) {
    description = 'Publish an AudioSwitch release'
    group = 'Publishing'
    dependsOn validateReleaseTag
    buildFile = file('audioswitch/build.gradle')
    tasks = ['assembleRelease', 'uploadArchives']
    startParameter.projectProperties += gradle.startParameter.projectProperties + [
            'maven.repo': 'https://api.bintray.com/maven/twilio/releases/audioswitch/;publish=1',
            'maven.username': "${getPropertyValue("AUDIOSWITCH_BINTRAY_USERNAME")}",
            'maven.password': "${getPropertyValue("AUDIOSWITCH_BINTRAY_PASSWORD")}"
    ]
}