build.gradle

buildscript {
    repositories {
        maven { url "$rootDir/../../prebuilts/tools/common/gradle-plugins/repository" }
    }
    dependencies {
        classpath 'com.android.tools.internal:internal-plugins:1.0'
    }
}

apply plugin: 'clone-artifacts'
apply plugin: 'distrib'

// artifact cloning destinations
cloneArtifacts {
    mainRepo = "$rootDir/../../prebuilts/tools/common/m2/repository"
    secondaryRepo = "$rootDir/../../prebuilts/tools/common/m2/internal"
}
// set up the distribution destination
distribution {
    destinationPath = "$rootDir/../../prebuilts/devtools"
    dependenciesRepo = cloneArtifacts.mainRepo
}

// ext.androidHostOut is shared by all tools/{base,build,swt} gradle projects/
ext.androidHostOut = file("$rootDir/../../out/host/gradle")
ext.androidRootDir = file(new File(ext.androidHostOut, "../../../"))
// rootProject.buildDir is specific to this gradle build.
buildDir = new File(file(ext.androidHostOut), "tools/base/build")

ext.localRepo = project.hasProperty('localRepo') ? localRepo : "$ext.androidHostOut/repo"

def getVersion(Project p, String baseVersion) {
    if (p.has("release")) {
        return baseVersion
    }

    return baseVersion + '-SNAPSHOT'
}

subprojects { Project project ->
    // Change buildDir first so that all plugins pick up the new value.
    project.buildDir = project.file("$project.parent.buildDir/../$project.name")

    apply plugin: 'java'
    apply plugin: 'maven'
    apply plugin: 'signing'
    apply plugin: 'findbugs'
    apply plugin: 'distrib'
    apply plugin: 'clone-artifacts'

    repositories {
        maven { url = uri(rootProject.cloneArtifacts.mainRepo) }
        maven { url = uri(rootProject.cloneArtifacts.secondaryRepo) }
    }

    // find bug dependencies is added dynamically so it's hard for the
    // clone artifact plugin to find it. This custom config lets us manually
    // add such dependencies.
    configurations {
        hidden
    }
    dependencies {
        hidden "com.google.code.findbugs:findbugs:2.0.1"
    }

    version = getVersion(project, '22.2.0')

    project.ext.sonatypeUsername = project.hasProperty('sonatypeUsername') ? sonatypeUsername : ""
    project.ext.sonatypePassword = project.hasProperty('sonatypePassword') ? sonatypePassword : ""

    // set all java compilation to use UTF-8 encoding.
    tasks.withType(JavaCompile) {
        options.encoding = 'UTF-8'
    }

    task disableTestFailures << {
        tasks.withType(Test) {
            ignoreFailures = true
        }
    }

    // custom tasks for creating source/javadoc jars
    task sourcesJar(type: Jar, dependsOn:classes) {
        classifier = 'sources'
        from sourceSets.main.allSource
    }

    task javadocJar(type: Jar, dependsOn:javadoc) {
        classifier = 'javadoc'
        from javadoc.destinationDir
    }

    // add javadoc/source jar tasks as artifacts
    artifacts {
        archives jar

        archives sourcesJar
        archives javadocJar
    }

    task publishLocal(type: Upload) {
        configuration = configurations.archives
        repositories {
            mavenDeployer {
                repository(url: uri(rootProject.ext.localRepo))
            }
        }
    }

    def userHome = System.getProperty("user.home")
    publishLocal.doFirst {
        System.setProperty("user.home", file("$buildDir/fakem2home").absolutePath)
    }
    publishLocal.doLast {
        System.setProperty("user.home", userHome)
    }

    findbugs {
        ignoreFailures = true
        effort = "max"
        reportLevel = "high"
    }

    signing {
        required { project.has("release") && gradle.taskGraph.hasTask("uploadArchives") }
        sign configurations.archives
    }

}

// delay evaluation of this project before all subprojects have been evaluated.
subprojects.each { subproject -> evaluationDependsOn(subproject.path) }

def testTasks = subprojects.collect { it.tasks.withType(Test) }.flatten()

task aggregateResults(type: Copy) {
    from { testTasks*.testResultsDir }
    into { file("$buildDir/results") }
}