| buildscript { |
| ext.dataBindingRootFolder = project.projectDir |
| apply from: 'propLoader.gradle' |
| ext.addRepos(repositories) |
| dependencies { |
| classpath 'net.sf.proguard:proguard-gradle:5.2.1' |
| } |
| } |
| |
| def publishAllSubprojects = project.tasks.create("publishAllSubprojects") |
| |
| subprojects { |
| if (dataBindingConfig.isIndependent) { |
| apply plugin: 'maven-publish' |
| if (it.name != "compilationTests") { |
| publishing { |
| repositories { |
| maven { |
| url = "${dataBindingConfig.mavenRepoDir}" |
| } |
| } |
| } |
| } |
| publishAllSubprojects.dependsOn tasks.named("publish") |
| } else { |
| apply plugin: 'com.android.tools.java-library' |
| Project includedProject = it |
| includedProject.plugins.withId('kotlin') { |
| includedProject.plugins.apply('com.android.tools.kotlin') |
| } |
| } |
| |
| if (it.name != "compilationTests") { |
| group = dataBindingConfig.group |
| version = dataBindingConfig.version |
| } |
| } |
| |
| task deleteRepo(type: Delete) { |
| delete "${dataBindingConfig.mavenRepoDir}/${dataBindingConfig.group.replace('.', '/')}" |
| } |
| |
| task deletePrebuildFolder(type: Delete) { |
| delete "${dataBindingConfig.prebuildFolder}" |
| } |
| |
| task deleteEap(type: Delete) { |
| delete "${dataBindingConfig.eapOutDir}" |
| } |
| |
| def buildExtensionsTask = project.tasks.create "buildExtensionsTask", Exec |
| buildExtensionsTask.workingDir file('extensions').getAbsolutePath() |
| buildExtensionsTask.commandLine './gradlew' |
| buildExtensionsTask.args 'clean', 'publish', '--info', '--stacktrace', |
| "-PuseReleaseVersion=${dataBindingConfig.inReleaseBuild ? 'true' : 'false'}", |
| "-PaddRemoteRepos=${dataBindingConfig.addRemoteRepos ? 'true' : 'false'}", |
| "-PforGradlePlugin=${dataBindingConfig.forGradlePlugin ? 'true' : 'false'}" |
| buildExtensionsTask.dependsOn publishAllSubprojects |
| |
| def prepareExtensionPrebuilds = project.tasks.create "prepareExtensionPrebuilds", Exec |
| prepareExtensionPrebuilds.workingDir file('extensions').getAbsolutePath() |
| prepareExtensionPrebuilds.commandLine './gradlew' |
| prepareExtensionPrebuilds.args 'clean', 'preparePrebuilds', '--info', '--stacktrace', |
| "-PuseReleaseVersion=${dataBindingConfig.inReleaseBuild ? 'true' : 'false'}", |
| "-PaddRemoteRepos=${dataBindingConfig.addRemoteRepos ? 'true' : 'false'}", |
| "-PforGradlePlugin=${dataBindingConfig.forGradlePlugin ? 'true' : 'false'}" |
| prepareExtensionPrebuilds.dependsOn publishAllSubprojects |
| |
| file('integration-tests').listFiles().findAll { it.isDirectory() }.each { |
| def strippedName = it.getName().replaceAll("[^A-Za-z0-9]", "-") |
| def testTask = project.tasks.create "runTestsOf${strippedName.capitalize()}", Exec |
| testTask.workingDir it.getAbsolutePath() |
| //on linux |
| testTask.commandLine './gradlew' |
| testTask.args 'clean', 'connectedCheck', '--info', '--stacktrace', |
| "-PuseReleaseVersion=${dataBindingConfig.inReleaseBuild ? 'true' : 'false'}", |
| "-PaddRemoteRepos=${dataBindingConfig.addRemoteRepos ? 'true' : 'false'}", |
| "-PforGradlePlugin=${dataBindingConfig.forGradlePlugin ? 'true' : 'false'}" |
| testTask.dependsOn publishAllSubprojects |
| } |
| |
| task runIntegrationTests { |
| dependsOn tasks.findAll { task -> task.name.startsWith('runTestsOf') } |
| } |
| |
| task runAllTests { |
| dependsOn runIntegrationTests |
| } |
| |
| task preparePrebuilds() { |
| dependsOn deletePrebuildFolder |
| dependsOn prepareExtensionPrebuilds |
| } |
| |
| allprojects { |
| afterEvaluate { project -> |
| runAllTests.dependsOn project.tasks.findAll {task -> task.name.equals('test')} |
| runAllTests.dependsOn project.tasks.findAll {task -> task.name.equals('connectedCheck')} |
| preparePrebuilds.dependsOn project.tasks.findAll {task -> task.name.startsWith('prebuild')} |
| } |
| } |
| |
| publishAllSubprojects.shouldRunAfter deleteRepo |
| publishAllSubprojects.shouldRunAfter deletePrebuildFolder |
| |
| buildExtensionsTask.shouldRunAfter deleteRepo |
| tasks['runTestsOfMultiModuleTestApp'].dependsOn tasks['runTestsOfIndependentLibrary'] |
| |
| |
| task rebuildRepo() { |
| dependsOn deleteRepo |
| dependsOn publishAllSubprojects |
| } |
| |
| task copySamplesToEap(type : Copy) { |
| mustRunAfter deleteEap |
| from ("$projectDir/samples") { |
| exclude "**/build" |
| exclude "**/local.properties" |
| } |
| into "${dataBindingConfig.eapOutDir}/samples" |
| } |
| |
| task updateGradleVersion() { |
| doLast { |
| // development task to update gradle version in sub projects |
| def props = new Properties() |
| props.put("distributionBase", "GRADLE_USER_HOME") |
| props.put("distributionPath", "wrapper/dists") |
| props.put("zipStoreBase", "GRADLE_USER_HOME") |
| props.put("zipStorePath", "wrapper/dists") |
| def distributionFile = file(project.projectDir.absolutePath |
| + "/../../tools/external/gradle/${dataBindingConfig.gradleVersion}") |
| println distributionFile.absolutePath |
| fileTree(dir: project.projectDir, |
| include: "**/gradle-wrapper.properties").each { |
| def relPath= it.parentFile.toPath().relativize( distributionFile.toPath() ).toString() |
| props.put("distributionUrl", relPath) |
| def writer = it.newWriter() |
| props.store(writer, "generated via updateGradleVersion task") |
| } |
| } |
| } |
| |
| def findChildByTag(node, tag) { |
| return node.children().find { |
| it.name().getLocalPart().equals(tag) |
| } |
| } |
| |
| def fullJar(project) { |
| def localizeTask = project.parent.tasks.findByName('localizeDependencies') |
| if (localizeTask != null) { |
| localizeTask.dependsOn project.tasks.findByName('buildLicenseNotice') |
| } |
| if (!dataBindingConfig.inReleaseBuild) { |
| return |
| } |
| def jarName = project.uploadArchives.repositories.mavenDeployer.pom.artifactId |
| def workingDir = "${project.buildDir}/intermediates/fullJar" |
| def fatJar = "${workingDir}/${jarName}-fat.jar" |
| def proguardJar = "${workingDir}/${jarName}-proguard.jar" |
| def jarJar = project.jar.archivePath |
| def runProguard = dataBindingConfig.runProguard |
| |
| project.configurations { |
| jarJarArchives |
| } |
| |
| project.tasks.create(name: 'fatJar', type: Jar) { |
| baseName = jarName + '-fat' |
| doFirst { |
| file(workingDir).mkdirs() |
| } |
| def deps = new HashSet<ResolvedDependency>() |
| project.configurations.compile.resolvedConfiguration.firstLevelModuleDependencies.each { |
| if (!it.moduleGroup.startsWith('com.android.tools')) { |
| deps.addAll(it.allModuleArtifacts) |
| } |
| } |
| from { deps.findAll { !it.name.contains('baseLibrary') && !it.name.contains("juniversalchardet")}.collect { |
| it.file.isDirectory() ? it.file : project.zipTree(it.file) |
| } } { |
| exclude "META-INF/maven/**" |
| exclude "META-INF/MANIFEST.MF" |
| exclude "META-INF/LICENSE.txt" |
| exclude "META-INF/NOTICE.txt" |
| exclude "META-INF/services/javax.annotation.processing.Processor" |
| exclude "**/*.stg" |
| } |
| archiveBaseName.set("${baseName}.jar") |
| destinationDir = new File(workingDir) |
| with project.jar |
| } |
| /** |
| * not used unless jarJarFile is changed to use proguarded version instead. |
| */ |
| project.tasks.create(name: 'proguard', type: proguard.gradle.ProGuardTask) { |
| dependsOn 'fatJar' |
| |
| injars fatJar |
| outjars proguardJar |
| |
| configuration '../proguard.cfg' |
| } |
| |
| project.tasks.create(name: 'jarJarFile') { |
| dependsOn runProguard ? 'proguard' : 'fatJar' |
| dependsOn project.jar |
| def inputLibrary = runProguard ? proguardJar : fatJar |
| def outputLibrary = jarJar |
| inputs.file(inputLibrary) |
| outputs.file(outputLibrary) |
| |
| doLast { |
| def jarJarLibrary = new File(dataBindingConfig.externalPrebuiltsBase, |
| 'tools/common/m2/repository/com/googlecode/jarjar/jarjar/1.4/jarjar-1.4.jar'). |
| getCanonicalPath() |
| // in Ant |
| ant.taskdef(name: "jarjarIt", |
| classname: 'com.tonicsystems.jarjar.JarJarTask', |
| classpath: jarJarLibrary) |
| // start jarjar task |
| ant.jarjarIt(jarfile: outputLibrary) { |
| // input is our inputLibrary |
| zipfileset(src: inputLibrary) |
| // rule to repackage antlr to new package |
| rule pattern: 'org.antlr.**', result: 'android.databinding.repacked.org.antlr.@1' |
| rule pattern: 'org.abego.treelayout.**', result: 'android.databinding.repacked.treelayout.@1' |
| // rule to repackage commons |
| rule pattern: 'org.apache.**', result: 'android.databinding.repacked.apache.@1' |
| rule pattern: 'kotlin.**', result: 'android.databinding.repacked.kotlin.@1' |
| rule pattern: 'org.stringtemplate.**', result: 'android.databinding.repacked.stringtemplate.@1' |
| rule pattern: 'com.google.**', result: 'android.databinding.repacked.google.@1' |
| } |
| } |
| } |
| |
| def setupUpload = { uploadTask -> |
| uploadTask.dependsOn 'jarJarFile' |
| uploadTask.repositories { |
| mavenDeployer { |
| pom.whenConfigured { pom -> |
| pom.dependencies.removeAll { dep -> |
| def isBaseLibrary = dep.groupId == 'com.android.databinding' && |
| dep.artifactId == 'baseLibrary' |
| def isGradle = dep.groupId == 'com.android.tools.build' && |
| dep.artifactId == 'gradle' |
| def isChardet = dep.groupId == 'com.googlecode.juniversalchardet' && |
| dep.artifactId == 'juniversalchardet' |
| return !isBaseLibrary && !isGradle && !isChardet |
| } |
| } |
| } |
| } |
| uploadTask.outputs.upToDateWhen { false } // force it to re-run all the time. |
| } |
| |
| if (project.publishLocal != null) { |
| setupUpload(project.publishLocal) |
| } |
| if (project.uploadArchives != null) { |
| setupUpload(project.uploadArchives) |
| } |
| |
| project.bintrayUpload.dependsOn 'jarJarFile' |
| project.publishing.publications.mavenJava(MavenPublication) { |
| pom.withXml { |
| def deps = findChildByTag(asNode(), "dependencies") |
| if (deps == null) { |
| throw new IllegalArgumentException("cannot find dependencies in pom file") |
| } |
| def unwanted = deps.children().findAll { |
| def groupId = findChildByTag(it, "groupId").localText()[0] |
| def artifactId = findChildByTag(it, "artifactId").localText()[0] |
| def isBaseLibrary = groupId == 'com.android.databinding' && |
| artifactId == 'baseLibrary' |
| def isGradle = groupId == 'com.android.tools.build' && artifactId == 'gradle' |
| def isChardet = groupId == 'com.googlecode.juniversalchardet' && |
| artifactId == 'juniversalchardet' |
| return !isBaseLibrary && !isGradle && !isChardet |
| } |
| unwanted.each { |
| deps.remove(it) |
| } |
| } |
| } |
| } |
| |
| def getOsSdkFolderName() { |
| final String osName = System.getProperty("os.name").toLowerCase(); |
| if (osName.startsWith("mac")) { |
| return "darwin"; |
| } else if (osName.startsWith("linux")) { |
| return "linux"; |
| } else if (osName.startsWith("windows")) { |
| return "windows"; |
| } |
| throw new IllegalStateException("cannot run build on $osName") |
| } |
| // compilation for runtime libraries |
| def getFullSdkPath() { |
| return rootProject.file("../prebuilts/studio/sdk/${getOsSdkFolderName()}") |
| } |
| |
| def createExtensionsBuildTask(folder, taskName) { |
| def buildRuntimeLibrary = tasks.create(name: taskName, type: Exec) { |
| def libBuild = file("${dataBindingRootFolder}/$folder") |
| workingDir libBuild.getAbsolutePath() |
| if (System.getProperty("os.name").toLowerCase().startsWith("windows")) { |
| commandLine "$rootDir\\gradlew.bat" |
| } else { |
| commandLine "$rootDir/gradlew" |
| } |
| args '-q', '-p', libBuild.getAbsolutePath(), 'publish', '--stacktrace' |
| environment VERSION: rootProject.buildVersion |
| environment MAVEN_REPO: rootProject.ext.localRepo |
| environment PREBUILTS_REPO: rootProject.file('../prebuilts/tools/common/m2/repository') |
| environment OUT_REPO: rootProject.ext.localRepo |
| def fullSdkPath = getFullSdkPath() |
| if (fullSdkPath.exists()) { |
| environment ANDROID_HOME: fullSdkPath |
| } |
| } |
| return buildRuntimeLibrary |
| } |
| |
| if (!dataBindingConfig.isIndependent) { |
| apply from: '../buildSrc/base/runtimeArtifact.gradle' |
| registerRuntimeArtifactTask(createExtensionsBuildTask("extensions", "buildDataBindingRuntimeArtifacts")) |
| registerRuntimeArtifactTask(createExtensionsBuildTask("extensions-support", "buildDataBindingRuntimeArtifactsForSupport")) |
| } |
