| /* |
| * Copyright (C) 2017 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. |
| */ |
| |
| import androidx.build.BuildServerConfigurationKt |
| import androidx.build.dependencyTracker.AffectedModuleDetector |
| import androidx.build.gmaven.GMavenVersionChecker |
| import androidx.build.jacoco.Jacoco |
| |
| def supportRoot = ext.supportRootFolder |
| if (supportRoot == null) { |
| throw new RuntimeException("variable supportRootFolder is not set. you must set it before" + |
| " including this script") |
| } |
| def init = new Properties() |
| ext.init = init |
| rootProject.ext.versionChecker = new GMavenVersionChecker(rootProject.logger) |
| apply from: "${supportRoot}/buildSrc/dependencies.gradle" |
| |
| def setupRepoOutAndBuildNumber() { |
| /* |
| * The OUT_DIR is a temporary directory you can use to put things during the build. |
| */ |
| if (BuildServerConfigurationKt.isRunningOnBuildServer()) { |
| buildDir = new File(System.env.OUT_DIR + '/gradle/frameworks/support/build') |
| .getCanonicalFile() |
| // the build server should always print out full stack traces for any failures. |
| gradle.startParameter.showStacktrace = ShowStacktrace.ALWAYS |
| } else { |
| buildDir = file("${ext.supportRootFolder}/../../out/host/gradle/frameworks/support/build") |
| } |
| subprojects { |
| // Change buildDir first so that all plugins pick up the new value. |
| project.buildDir = new File("$project.parent.buildDir/../$project.name/build") |
| } |
| ext.supportRepoOut = new File(buildDir, 'support_repo') |
| ext.supportRepoOut.mkdirs() |
| ext.docsDir = new File(buildDir, 'javadoc') |
| } |
| |
| def configureSubProjects() { |
| subprojects { |
| repos.addMavenRepositories(repositories) |
| } |
| setupSubprojectsForBuildServer() |
| } |
| def setupSubprojectsForBuildServer() { |
| subprojects { |
| project.plugins.whenPluginAdded { plugin -> |
| def isAndroidLibrary = "com.android.build.gradle.LibraryPlugin" |
| .equals(plugin.class.name) |
| def isAndroidApp = "com.android.build.gradle.AppPlugin".equals(plugin.class.name) |
| |
| if (isAndroidLibrary || isAndroidApp) { |
| // Copy the class files in a jar to be later used to generate code coverage report |
| project.android.testVariants.all { v -> |
| // check if the variant has any source files |
| // and test coverage is enabled |
| if (v.buildType.testCoverageEnabled |
| && v.sourceSets.any { !it.java.sourceFiles.isEmpty() }) { |
| def jarifyTask = project.tasks.register( |
| "package${v.name.capitalize()}ClassFilesForCoverageReport", |
| Jar) { |
| dependsOn v.testedVariant.javaCompileProvider |
| // using get() here forces task configuration, but is necessary |
| // to obtain a valid value for destinationDir |
| from v.testedVariant.javaCompileProvider.get().destinationDir |
| exclude "**/R.class" |
| exclude "**/R\$*.class" |
| exclude "**/BuildConfig.class" |
| destinationDir BuildServerConfigurationKt.getDistributionDirectory(rootProject) |
| archiveName "${project.name}-${v.baseName}-allclasses.jar" |
| } |
| Jacoco.registerClassFilesTask(project, jarifyTask) |
| |
| v.assembleProvider.configure { |
| it.dependsOn jarifyTask |
| } |
| } |
| } |
| } |
| } |
| |
| // Copy instrumentation test APKs and app APKs into the dist dir |
| // For test apks, they are uploaded only if we have java test sources. |
| // For regular app apks, they are uploaded only if they have java sources. |
| project.tasks.configureEach { task -> |
| if (task.name.startsWith("packageDebug")) { |
| // run this task only if we should run it |
| def testApk = task.name.contains("AndroidTest") |
| if (testApk) { |
| AffectedModuleDetector.configureTaskGuard(task) |
| } |
| task.doLast { |
| def source = testApk ? project.android.sourceSets.androidTest |
| : project.android.sourceSets.main |
| def hasKotlinSources = false |
| if (source.hasProperty('kotlin')) { |
| if (!source.kotlin.files.isEmpty()) { |
| hasKotlinSources = true |
| } else { |
| // kotlin files does not show in java sources due to the *.java filter |
| // so we need to check them manually |
| hasKotlinSources = source.java.sourceDirectoryTrees.any { |
| !fileTree(dir: it.dir, include:'**/*.kt').files.isEmpty() |
| } |
| } |
| } |
| def hasSourceCode = !source.java.sourceFiles.isEmpty() || hasKotlinSources |
| if (task.hasProperty("outputDirectory") && (hasSourceCode || !testApk)) { |
| copy { |
| from(task.outputDirectory) |
| include '*.apk' |
| into(BuildServerConfigurationKt.getDistributionDirectory(rootProject)) |
| rename { String fileName -> |
| if (fileName.contains("media-compat-test") |
| || fileName.contains("media2-test")) { |
| // Exclude media-compat-test-* and media2-test-* modules from |
| // existing support library presubmit tests. |
| fileName.replace("-debug-androidTest", "") |
| } else if (fileName.contains("-benchmark-debug-androidTest")){ |
| // Exclude '-benchmark' modules from correctness tests, and |
| // remove '-debug' from the APK name, since it's incorrect |
| fileName.replace("-debug-androidTest", "-androidBenchmark") |
| } else { |
| // multiple modules may have the same name so prefix the name with |
| // the module's path to ensure it is unique. |
| // e.g. palette-v7-debug-androidTest.apk becomes |
| // support-palette-v7_palette-v7-debug-androidTest.apk |
| "${project.getPath().replace(':', '-').substring(1)}_${fileName}" |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| // copy host side test results to DIST |
| project.tasks.withType(Test) { task -> |
| def junitReport = task.reports.junitXml |
| if (junitReport.enabled) { |
| def zipTask = project.tasks.create( |
| name: "zipResultsOf${task.name.capitalize()}", type: Zip) { |
| destinationDir(BuildServerConfigurationKt.getHostTestResultDirectory(project)) |
| // first one is always :, drop it. |
| archiveName("${project.getPath().split(":").join("_").substring(1)}.zip") |
| } |
| if (BuildServerConfigurationKt.isRunningOnBuildServer()) { |
| task.ignoreFailures = true |
| } |
| task.finalizedBy zipTask |
| task.doFirst { |
| zipTask.from(junitReport.destination) |
| } |
| } |
| } |
| } |
| } |
| |
| ext.init.setupRepoOutAndBuildNumber = this.&setupRepoOutAndBuildNumber |
| ext.init.configureSubProjects = this.&configureSubProjects |
