build.gradle

buildscript {
    ext.kotlin_version = '1.4.21'
    ext.dokka_version = '1.4.32'

    /**
     * Properties and environment variables needed to publish.
     */
    ext.jfrogUsername = (project.hasProperty('jfrog.username') ?
            project.property("jfrog.username") : '')
    ext.jfrogPassword = (project.hasProperty('jfrog.password') ?
            project.property("jfrog.password") : '')
    ext["signing.keyId"] = (project.hasProperty('signing.keyId') ?
            project.property("signing.keyId") : '')
    ext["signing.password"] = (project.hasProperty('signing.password') ?
            project.property("signing.password") : '')
    ext["signing.secretKeyRingFile"] = (project.hasProperty('signing.secretKeyRingFile') ?
            project.property("signing.secretKeyRingFile") : '')
    ext["ossrhUsername"] = (project.hasProperty('ossrhUsername') ?
            project.property("ossrhUsername") : '')
    ext["ossrhPassword"] = (project.hasProperty('ossrhPassword') ?
            project.property("ossrhPassword") : '')
    ext["sonatypeStagingProfileId"] = (project.hasProperty('sonatypeStagingProfileId') ?
            project.property("sonatypeStagingProfileId") : '')

    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.getShortCommitSha = {
        def gitSha = System.getenv("CIRCLE_SHA1")

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

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

    repositories {
        google()
        mavenCentral()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:7.0.3'
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
        classpath "org.jetbrains.dokka:dokka-gradle-plugin:$dokka_version"
    }
}

plugins {
    id "com.diffplug.spotless" version "5.6.1"
    id "org.jetbrains.dokka" version "$dokka_version"
    id "io.github.gradle-nexus.publish-plugin" version "1.0.0"
    id "maven-publish"
}
apply plugin: "com.diffplug.spotless"
spotless {
    format 'misc', {
        target '**/*.gradle', '**/*.md', '**/.gitignore'
        targetExclude 'docs/**'

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

allprojects {
    repositories {
        google()
        mavenCentral()
    }
}

nexusPublishing {
    repositories {
        sonatype {
            username = ossrhUsername
            password = ossrhPassword
            stagingProfileId = sonatypeStagingProfileId
            useStaging = !isPreRelease
        }
    }

    clientTimeout = Duration.ofSeconds(300)
    connectTimeout = Duration.ofSeconds(60)
}

/*
 * 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) || isPreRelease) ? ("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 sonatypeAudioSwitchReleaseUpload(type: RootGradleBuild) {
    description = 'Publish an AudioSwitch release or pre-release'
    group = 'Publishing'
    dependsOn validateReleaseTag
    buildFile = file('build.gradle')
    tasks = ['assembleRelease', 'publishAudioSwitchReleasePublicationToSonatypeRepository', 'closeAndReleaseSonatypeStagingRepository']
    startParameter.projectProperties += gradle.startParameter.projectProperties + [
            'signing.keyId': "${getPropertyValue("SIGNING_KEY_ID")}",
            'signing.password' : "${getPropertyValue("SIGNING_PASSWORD")}",
            'signing.secretKeyRingFile' : "${getPropertyValue("SIGNING_SECRET_KEY_RING_FILE")}",
            'ossrhUsername' : "${getPropertyValue("OSSRH_USERNAME")}",
            'ossrhPassword' : "${getPropertyValue("OSSRH_PASSWORD")}",
            'sonatypeStagingProfileId' : "${getPropertyValue("SONATYPE_STAGING_PROFILE_ID")}"
    ]
}

task publishDocs {
    description = 'Publish AudioSwitch KDocs to gh-pages branch'
    group = 'Publishing'
    dependsOn 'audioswitch:dokkaHtml'
    dependsOn validateReleaseTag
    def releaseVersion = System.getenv("CIRCLE_TAG") == null ?
            ("") :
            (System.getenv("CIRCLE_TAG"))
    def pinLatestDocsCommand = ["ln", "-sfn", "${releaseVersion}", "docs/latest"]
    def githubToken = System.getenv("GITHUB_TOKEN")
    def repoSlug = "${System.env.CIRCLE_PROJECT_USERNAME}/${System.env.CIRCLE_PROJECT_REPONAME}"
    def gitRef = "https://${githubToken}@github.com/${repoSlug}.git"
    def remote = "upstream"
    def pushNullFile = new FileOutputStream("/dev/null")

    doLast {
        exec {
            workingDir "${rootDir}"
            commandLine "cp", "audioswitch/index.html", "audioswitch/build"
        }

        exec {
            workingDir "${rootDir}"
            commandLine "git", "remote", "add", "${remote}", "${gitRef}"
            // Ignore exit value because remote may have been added in previous task
            ignoreExitValue true
        }

        exec {
            workingDir "${rootDir}"
            commandLine "git", "fetch", "${remote}"
        }

        exec {
            workingDir "${rootDir}"
            commandLine "git", "checkout", "-b", "gh-pages", "remotes/${remote}/gh-pages"
        }

        exec {
            workingDir "${rootDir}"
            commandLine "mkdir", "docs"
            ignoreExitValue true
        }

        exec {
            workingDir "${rootDir}"
            commandLine "cp", "-r", "audioswitch/build/dokka/html/.", "docs/${releaseVersion}"
        }

        exec {
            workingDir "${rootDir}"
            commandLine "cp", "audioswitch/build/index.html", "docs/${releaseVersion}"
        }

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

        exec {
            workingDir "${rootDir}"
            commandLine "git", "add", "docs/${releaseVersion}", "docs/latest"
        }

        exec {
            workingDir "${rootDir}"
            commandLine "git", "commit", "-m", "\"${releaseVersion} release docs [skip ci]\""
        }

        exec {
            workingDir "${rootDir}"
            commandLine "git", "push", "--quiet", "${remote}", "gh-pages"
            standardOutput pushNullFile
        }

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