build.gradle

/*
 * Copyright (C) 2015 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
apply from: 'version.gradle'
buildscript {
    repositories {
        maven { url "$rootDir/prebuilts/gradle-plugin" }
        maven { url "$rootDir/prebuilts/tools/common/m2/repository" }
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:1.2.3'
    }
}
repositories {
    maven { url "$rootDir/prebuilts/tools/common/m2/repository" }
    maven { url "$rootDir/prebuilts/maven_repo/android" }
}

ext.supportRepoOut = ''

// define extra property to enforce the use of prebuilt dependencies in all sub-projects.
project.ext.usePrebuilts = "true"

/*
 * With the build server you are given two env variables.
 * The OUT_DIR is a temporary directory you can use to put things during the build.
 * The DIST_DIR is where you want to save things from the build.
 *
 * The build server will copy the contents of DIST_DIR to somewhere and make it available.
 */
if (System.env.DIST_DIR != null && System.env.OUT_DIR != null) {
    buildDir = file(System.env.OUT_DIR + '/gradle/frameworks/testing/build')
    project.ext.distDir = file(System.env.DIST_DIR)
} else {
    buildDir = file("$rootDir/out/gradle/frameworks/testing/build")
    project.ext.distDir = file("$rootDir/out/dist")
}

ext.supportRepoOut = new File(buildDir, 'support_repo')


import com.google.common.io.Files
import com.google.common.base.Charsets
import com.google.common.hash.Hashing


// Main task called by the build server.
task(createArchive) << {
}

// Upload anchor for subprojects to upload their artifacts
// to the local repo.
task(mainUpload) << {
}

configurations {
    doclava
}

dependencies {
    doclava project(':doclava')
}

// Unified javadoc task
task createJavadocs(type: Javadoc, dependsOn: project.configurations.doclava) {
    title = null
    destinationDir = file("${buildDir}/javadoc")
    options.encoding = "UTF-8"
    options.doclet = "com.google.doclava.Doclava"
    options.addStringOption("templatedir", "${rootDir}/build/tools/droiddoc/templates-sdk")
    exclude '**/BuildConfig.java'
    exclude '**/R.java'
}
createJavadocs.dependsOn mainUpload
project.afterEvaluate {
    createJavadocs.options.docletpath = configurations.doclava.files.asType(List)
}

task packageJavadoc(type: Zip, dependsOn: createJavadocs) {
    from createJavadocs
    destinationDir distDir
    baseName = 'ub-support-test-javadocs'
}
createArchive.dependsOn packageJavadoc

// Repository creation task
task createRepository(type: Zip, dependsOn: mainUpload) {
    from project.supportRepoOut
    destinationDir project.distDir
    into 'm2repository'
    baseName = String.format("android_m2repository_r%02d", project.extraVersion)
}
createArchive.dependsOn createRepository

// prepare repository with older versions
task unzipRepo(type: Copy) {
    from "$rootDir/prebuilts/maven_repo/android"
    into project.supportRepoOut
    doFirst {
        project.supportRepoOut.deleteDir()
        project.supportRepoOut.mkdirs()
    }
}

// anchor for prepare repo. This is post unzip + sourceProp.
task(prepareRepo) << {
}

task createXml(dependsOn: createRepository) << {
    def repoArchive = createRepository.archivePath
    def repoArchiveName = createRepository.archiveName
    def size = repoArchive.length()
    def sha1 = Hashing.sha1().hashUnencodedChars(repoArchive.getAbsolutePath()).toString()

    def xml = """\
<sdk:sdk-addon xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:sdk="http://schemas.android.com/sdk/android/addon/6">
  <sdk:extra>
    <sdk:revision>
      <sdk:major>${project.extraVersion}</sdk:major>
    </sdk:revision>
    <sdk:vendor-display>Android</sdk:vendor-display>
    <sdk:vendor-id>android</sdk:vendor-id>
    <sdk:name-display>Local Maven repository for Support Libraries</sdk:name-display>
    <sdk:path>m2repository</sdk:path>
    <sdk:archives>
      <sdk:archive os="any" arch="any">
        <sdk:size>${size}</sdk:size>
        <sdk:checksum type="sha1">${sha1}</sdk:checksum>
        <sdk:url>${repoArchiveName}</sdk:url>
      </sdk:archive>
    </sdk:archives>
  </sdk:extra>
</sdk:sdk-addon>"""

    Files.write(xml, new File(project.distDir, 'repo-extras.xml'), Charsets.UTF_8)
}
createArchive.dependsOn createXml

task(createSourceProp) << {
    def sourceProp =
            "Extra.VendorDisplay=Android\n\
                Extra.Path=m2repository\n\
                Archive.Arch=ANY\n\
                Extra.NameDisplay=Android Support Repository\n\
                Archive.Os=ANY\n\
                Pkg.Revision=${project.extraVersion}.0.0\n\
                Extra.VendorId=android"

    Files.write(sourceProp, new File(project.supportRepoOut, 'source.properties'), Charsets.UTF_8)
}
createSourceProp.dependsOn unzipRepo
prepareRepo.dependsOn createSourceProp

Set<Project> getProjectsToArchive() {
    def projects = [] as Set
    if (project.hasProperty("buildEspresso") && project.buildEspresso == "true") {
        projects.addAll(subprojects.findAll {
            ['espresso-core', 'espresso-contrib', 'espresso-idling-resource', 'espresso-intents',
             'espresso-web'].contains(it.name)
        })
    }
    if (project.hasProperty("buildRunner") && project.buildRunner == "true") {
        projects.addAll(subprojects.findAll {
            ['runner', 'rules', 'exposed-instrumentation-api-publish'].contains(it.name)
        })
    }
    if (project.hasProperty("buildUiAutomator") && project.buildUiAutomator == "true") {
        projects.addAll(subprojects.findAll {
            ['uiautomator-v18'].contains(it.name)
        })
    }
    if (project.hasProperty("buildJankTestHelper") && project.buildJankTestHelper == "true") {
        projects.addAll(subprojects.findAll {
            ['janktesthelper-v23'].contains(it.name)
        })
    }
    return projects
}


ext.lastPublishTask = null;
configure(getProjectsToArchive()) {

    apply plugin: 'maven'

    group = 'com.android.support.test'

    Task releaseRepoTask =
            project.tasks.create(name: 'release' + it.name, type: Upload, dependsOn: prepareRepo) {
                configuration = configurations.archives
                repositories {
                    mavenDeployer {
                        repository(url: uri("$rootProject.supportRepoOut"))
                    }
                }
            }

    // Depending on a non jar dependency in a pom must include the type of the dependency
    // Gradle doesn't properly do this, a workaround is to customize the pom on the fly.
    def deployer = releaseRepoTask.repositories.mavenDeployer
    deployer.pom*.whenConfigured { pom ->
        pom.dependencies.findAll {dep -> dep.groupId.startsWith('com.android.support') &&
                dep.artifactId != 'support-annotations'}*.type = 'aar'
    }

    // Make the mainUpload depend on this one.
    mainUpload.dependsOn releaseRepoTask

    // Maven upload tasks are not thread safe. Force them to run serially:
    if (lastPublishTask) {
        releaseRepoTask.dependsOn lastPublishTask
    }
    lastPublishTask = releaseRepoTask
}


subprojects {

    repositories {
        maven { url "$rootDir/prebuilts/tools/common/m2/repository" }
        maven { url "$rootDir/prebuilts/maven_repo/android" }
    }


    project.plugins.whenPluginAdded { plugin ->
        boolean isAndroidLibrary = false
        switch (plugin.class.name) {
            case 'com.android.build.gradle.LibraryPlugin':
                isAndroidLibrary = true
        // fall through

            case 'com.android.build.gradle.AppPlugin':
                project.android.ext.isLibrary = isAndroidLibrary

                project.android.compileSdkVersion compileSdkVersion
                project.android.buildToolsVersion = buildToolsVersion

                break;
        }
    }

    // Change buildDir first so that all plugins pick up the new value.
    project.buildDir = project.file("$project.parent.buildDir/../$project.name/build")

}

FileCollection getAndroidPrebuilt(String apiLevel) {
    // Remove "android-" prefix if it exist
    if (apiLevel.contains("android-")) {
        apiLevel = apiLevel.replaceAll("android-", "")
    }
    files("$rootDir/prebuilts/sdk/$apiLevel/android.jar")
}