path: root/extensions/build.gradle

import com.android.build.gradle.LibraryExtension

class VersionFileWriterTask extends DefaultTask {
    static final String RESOURCE_DIRECTORY = "generatedResources"
    static final VERSION_FILE_PATH = RESOURCE_DIRECTORY + "/META-INF/%s_%s.version"
    @Input
    String version
    @OutputFile
    File outputFile

    @TaskAction
    void write() {
        outputFile.write(version)
    }

    /**
     * Sets up Android Library project to have a task that generates a version file.
     * It must be called after [LibraryExtension] has been resolved.
     *
     * @param project an Android Library project.
     */
    static void setUpAndroidLibrary(Project project, LibraryExtension library) {
        def group = project.properties["group"] as String
        def artifactId = project.properties["name"] as String
        def version = project.properties["version"] as String

        // Add a java resource file to the library jar for version tracking purposes.
        def artifactName = new File(
                project.buildDir,
                String.format(VERSION_FILE_PATH, group, artifactId))

        def writeVersionFile = project.tasks.create("writeVersionFile",
                VersionFileWriterTask.class)
        writeVersionFile.version = version
        writeVersionFile.outputFile = artifactName

        if (library != null) {
            library.libraryVariants.all {
                it.processJavaResources.dependsOn(writeVersionFile)
            }

            library.sourceSets.getByName("main").resources.srcDir(
                new File(project.buildDir, RESOURCE_DIRECTORY)
            )
        }
    }
}

buildscript {
    Properties databindingProperties = new Properties()
    databindingProperties.load(new FileInputStream("$projectDir/../databinding.properties"))
    Properties buildToolsProperties = new Properties()
    buildToolsProperties.load(new FileInputStream("$projectDir/../../buildSrc/base/version.properties"))
    Properties dependencyProperties = new Properties()
    dependencyProperties.load(new FileInputStream("$projectDir/../../buildSrc/base/dependencies.properties"))

    def runningInIde = project.hasProperty('android.injected.invoked.from.ide')
    // this is done by bazel but if we are in IDE it also configures so we need to distinguish
    def autoConfigured = !gradle.startParameter.getInitScripts().isEmpty() && !runningInIde
    ext.autoConfigured = autoConfigured

    def TOOLS_VERSION =
            System.getenv("VERSION") ?: buildToolsProperties.get("buildVersion").toString()
    def OUT_REPO = System.getenv("OUT_REPO") ?: System.getenv("BUILD_DIR")
    def MAVEN_REPO = System.getenv("MAVEN_REPO")
    def PREBUILTS_REPO = System.getenv("PREBUILTS_REPO")
    if (runningInIde) {
        Properties devVersions = new Properties()
        devVersions.load(new FileInputStream("$projectDir/../../buildSrc/base/version.properties"))
        // invoked in the IDE, go w/ defaults.
        TOOLS_VERSION = devVersions.buildVersion
        if (TOOLS_VERSION .contains('-')) {
            TOOLS_VERSION = TOOLS_VERSION .substring(0, TOOLS_VERSION.indexOf('-')) + "-dev"
        }
        MAVEN_REPO = MAVEN_REPO ?: "${projectDir}/../../../out/repo"
        OUT_REPO = OUT_REPO ?: "${projectDir}/../../../out/repo"
        PREBUILTS_REPO = PREBUILTS_REPO ?: "${projectDir}/../../../prebuilts/tools/common/m2/repository"
    } else if (autoConfigured) {
        if (TOOLS_VERSION == null || OUT_REPO == null) {
            throw new GradleException("""must set the following env variables:
                    VERSION:$TOOLS_VERSION // tools build version
                    OUT_REPO:$OUT_REPO // maven repo to upload artifacts""")
        }
    } else if (TOOLS_VERSION == null
            || MAVEN_REPO == null
            || OUT_REPO == null
            || PREBUILTS_REPO == null) {
        throw new GradleException("""must set the following env variables:
                        VERSION:$TOOLS_VERSION // tools build version
                        MAVEN_REPO:$MAVEN_REPO // maven repo for ToT tools build
                        OUT_REPO:$OUT_REPO // maven repo to upload artifacts
                        PREBUILTS_REPO:$PREBUILTS_REPO // prebuilts repo to fix support library dependencies""")
    }

    databindingProperties.version = TOOLS_VERSION
    databindingProperties.androidPluginVersion = TOOLS_VERSION
    databindingProperties.compileSdkVersion = databindingProperties.compileSdkVersionStr.trim()
    databindingProperties.group = "androidx.databinding"
    databindingProperties.maven = [:]
    if (autoConfigured) {
        // bazel build
        databindingProperties.maven.out_repo = new File(OUT_REPO, "local_repo").getAbsolutePath()
        databindingProperties.maven.zip_out = new File(OUT_REPO, "local_repo_zip")
    } else {
        // gradle build
        databindingProperties.maven.out_repo = new File(OUT_REPO).getAbsolutePath()
        databindingProperties.maven.tools_repo = file(MAVEN_REPO).getAbsolutePath()
        databindingProperties.maven.prebuilts_repo = file(PREBUILTS_REPO).getAbsolutePath()
    }
    ext.dataBindingConfig = databindingProperties
    def supportLibVersion = "1.0.0"
    def lifecycleVersion = "2.4.0"
    ext.libs = [:]
    ext.libs.android_support_annotations = "androidx.annotation:annotation:$supportLibVersion"
    ext.libs.android_support_collection = "androidx.collection:collection:$supportLibVersion"
    ext.libs.android_support_cardview_v7 = "androidx.cardview:cardview:$supportLibVersion"
    ext.libs.android_support_appcompat_v7 = "androidx.appcompat:appcompat:$supportLibVersion"
    ext.libs.fragments = "androidx.fragment:fragment:1.2.0"
    // some of these lifecycle deps are unnecessary but we are keeping them to stay backwards
    // compatible with the lifecycle-extensions dependency
    ext.libs.lifecycle_livedata = "androidx.lifecycle:lifecycle-livedata:$lifecycleVersion"
    ext.libs.lifecycle_process = "androidx.lifecycle:lifecycle-process:$lifecycleVersion"
    ext.libs.lifecycle_service = "androidx.lifecycle:lifecycle-service:$lifecycleVersion"
    ext.libs.lifecycle_viewmodel = "androidx.lifecycle:lifecycle-viewmodel:$lifecycleVersion"
    ext.libs.android_arch_lifecycle_runtime = "androidx.lifecycle:lifecycle-runtime:$lifecycleVersion"
    ext.libs.android_arch_lifecycle_runtime_ktx = "androidx.lifecycle:lifecycle-runtime-ktx:$lifecycleVersion"
    ext.libs.kotlin_gradle_plugin = dependencyProperties.kotlin_gradle_plugin
    ext.libs.kotlin_stdlib = dependencyProperties.kotlin_stdlib
    ext.libs.coroutines = "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.4.1"

    dependencies {
        classpath "com.android.tools.build:gradle:$TOOLS_VERSION"
        classpath rootProject.ext.libs.kotlin_gradle_plugin
    }

    if (!autoConfigured) {
        repositories {
            maven {
                url = dataBindingConfig.maven.tools_repo
            }
            maven {
                url = dataBindingConfig.maven.prebuilts_repo
            }
        }
    }
}

task createArchive(type: Zip) {
    description "Creates a maven repository that includes just the libraries compiled in this" +
            " project, without any history from prebuilts."
    from dataBindingConfig.maven.out_repo
    if (dataBindingConfig.maven.zip_out != null) {
        destinationDir dataBindingConfig.maven.zip_out
    }
    archiveBaseName.set("dataBindingRuntimeRepo")
}

subprojects {
    def BUILD_DIR = System.getenv("BUILD_DIR")
    if (BUILD_DIR != null) {
        buildDir = new File(BUILD_DIR, "$name-build")
    }
    if (project.path == ":doclava") {
        return
    }
    apply plugin: 'maven-publish'
    group = dataBindingConfig.group
    version = dataBindingConfig.version
    if (!autoConfigured) {
        repositories {
            maven {
                url = dataBindingConfig.maven.tools_repo
            }
            maven {
                url = dataBindingConfig.maven.prebuilts_repo
            }
        }
    }

    publishing {
        repositories {
            maven {
                url = "${dataBindingConfig.maven.out_repo}"
            }
        }
    }
    createArchive.dependsOn tasks.named('publish')
    configurations.all {
        resolutionStrategy {
            failOnVersionConflict()

            preferProjectModules()
            force 'androidx.lifecycle:lifecycle-viewmodel:2.4.0'
            force 'androidx.lifecycle:lifecycle-livedata-core:2.4.0'
            force 'androidx.fragment:fragment:1.0.0'
        }
    }
    project.afterEvaluate {
        VersionFileWriterTask.setUpAndroidLibrary(project,
                project.extensions.findByType(LibraryExtension.class))
    }
}

// creates the javadoc task for all of data binding runtime libraries
def getRootDocsTask(p) {
    def rootDocs = rootProject.tasks.findByName("generateDocs")
    if (rootDocs != null) {
        return rootDocs
    }
    rootDocs = p.rootProject.tasks.create(name : "generateDocs",type: Javadoc, dependsOn: p.configurations.doclava) {
        def docDir = "javadoc-offline"
        if (project.hasProperty("online")) {
            docDir = "javadoc-online"
            options.addStringOption("dac_libraryroot", "android/databinding")
            options.addStringOption("dac_dataname", "DATABINDING_DATA")
            options.addStringOption("toroot", "/")
            options.addStringOption("hdf", "dac")
            options.addBooleanOption("yamlV2", true)
            options.addBooleanOption("devsite", true)
        }
        title = null
        def sdkVersion = dataBindingConfig.compileSdkVersionInt
        destinationDir = new File(buildDir, docDir)
        // add baseLibrary sources, not pretty but easy solution.
        source = files('../baseLibrary/src/main/java')
        classpath = files("${rootDir}/../../../prebuilts/sdk/${sdkVersion}/public/android.jar")
        options.addStringOption "federate Android", "http://developer.android.com"
        options.addStringOption "federationapi Android",
                "${rootDir}/../../../prebuilts/sdk/${sdkVersion}/public/api/android.txt"
        options.encoding = "UTF-8"
        options.doclet = "com.google.doclava.Doclava"
        options.docletpath = p.configurations.getByName("doclava").resolve().toList()
        options.addStringOption("templatedir", "${rootDir}/../../../external/doclava/res/assets/templates-sdk/")
        exclude '**/BuildConfig.java'
        exclude '**/R.java'
    }
}

def enableDoclava(p) {
    p.configurations {
        doclava
    }

    p.dependencies {
        doclava project(':doclava')
    }

    def docsTask  = getRootDocsTask(p)
    p.afterEvaluate {
        p.android.libraryVariants.all { variant ->
            def name = variant.buildType.name

            if (name.equals(com.android.builder.core.BuilderConstants.DEBUG)) {
                return // Skip debug builds.
            }
            docsTask.classpath += p.files(variant.javaCompile.classpath) +
                    p.files(variant.javaCompile.destinationDir)
            docsTask.source += files(p.android.sourceSets.main.java.srcDirs)
            docsTask.dependsOn variant.javaCompile
        }
    }

}

if (findProject(":doclava") != null) {
    subprojects { p ->
        if (p.path != ":doclava") {
            project.plugins.whenPluginAdded { plugin ->
                def isAndroidLibrary = "com.android.build.gradle.LibraryPlugin".equals(plugin.class.name)
                if (isAndroidLibrary) {
                    enableDoclava(p)
                }
            }
        }
    }
}