| /* |
| * Copyright 2018 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. |
| */ |
| |
| package androidx.build |
| |
| import androidx.build.dependencyTracker.AffectedModuleDetector |
| import com.android.build.gradle.internal.dsl.LintOptions |
| import org.gradle.api.DefaultTask |
| import org.gradle.api.Project |
| import org.gradle.api.file.RegularFileProperty |
| import org.gradle.api.tasks.InputFile |
| import org.gradle.api.tasks.InputFiles |
| import org.gradle.api.tasks.TaskAction |
| import org.gradle.kotlin.dsl.getByType |
| import java.io.File |
| import java.util.Locale |
| |
| /** |
| * Setting this property means that lint will update lint-baseline.xml if it exists. |
| */ |
| private const val UPDATE_LINT_BASELINE = "updateLintBaseline" |
| |
| /** |
| * Property used by Lint to continue creating baselines without failing lint, normally set by: |
| * -Dlint.baselines.continue=true from command line. |
| */ |
| private const val LINT_BASELINE_CONTINUE = "lint.baselines.continue" |
| |
| fun Project.configureNonAndroidProjectForLint(extension: AndroidXExtension) { |
| apply(mapOf("plugin" to "com.android.lint")) |
| |
| // Create fake variant tasks since that is what is invoked by developers. |
| val lintTask = tasks.named("lint") |
| lintTask.configure { task -> |
| AffectedModuleDetector.configureTaskGuard(task) |
| } |
| afterEvaluate { |
| tasks.named("lintAnalyze").configure { task -> |
| AffectedModuleDetector.configureTaskGuard(task) |
| } |
| /* TODO: uncomment when we upgrade to AGP 7.1.0-alpha04 |
| tasks.named("lintReport").configure { task -> |
| AffectedModuleDetector.configureTaskGuard(task) |
| }*/ |
| } |
| tasks.register("lintDebug") { |
| it.dependsOn(lintTask) |
| it.enabled = false |
| } |
| tasks.register("lintAnalyzeDebug") { |
| it.dependsOn(lintTask) |
| it.enabled = false |
| } |
| tasks.register("lintRelease") { |
| it.dependsOn(lintTask) |
| it.enabled = false |
| } |
| addToBuildOnServer(lintTask) |
| |
| val lintOptions = extensions.getByType<LintOptions>() |
| configureLint(lintOptions, extension) |
| } |
| |
| fun Project.configureAndroidProjectForLint(lintOptions: LintOptions, extension: AndroidXExtension) { |
| project.afterEvaluate { |
| // makes sure that the lintDebug task will exist, so we can find it by name |
| setUpLintDebugIfNeeded() |
| } |
| tasks.register("lintAnalyze") { |
| it.dependsOn("lintDebug") |
| it.enabled = false |
| } |
| configureLint(lintOptions, extension) |
| tasks.named("lint").configure { task -> |
| // We already run lintDebug, we don't need to run lint which lints the release variant |
| task.enabled = false |
| } |
| afterEvaluate { |
| for (variant in project.agpVariants) { |
| tasks.named( |
| "lint${variant.name.replaceFirstChar { |
| if (it.isLowerCase()) it.titlecase(Locale.US) else it.toString() |
| }}" |
| ).configure { task -> |
| AffectedModuleDetector.configureTaskGuard(task) |
| } |
| tasks.named( |
| "lintAnalyze${variant.name.replaceFirstChar { |
| if (it.isLowerCase()) it.titlecase(Locale.US) else it.toString() |
| }}" |
| ).configure { task -> |
| AffectedModuleDetector.configureTaskGuard(task) |
| } |
| /* TODO: uncomment when we upgrade to AGP 7.1.0-alpha04 |
| tasks.named("lintReport${variant.name.capitalize(Locale.US)}").configure { task -> |
| AffectedModuleDetector.configureTaskGuard(task) |
| }*/ |
| } |
| } |
| } |
| |
| private fun Project.setUpLintDebugIfNeeded() { |
| val variants = project.agpVariants |
| val variantNames = variants.map { v -> v.name } |
| if (!variantNames.contains("debug")) { |
| tasks.register("lintDebug") { |
| for (variantName in variantNames) { |
| if (variantName.lowercase(Locale.US).contains("debug")) { |
| it.dependsOn( |
| tasks.named( |
| "lint${variantName.replaceFirstChar { |
| if (it.isLowerCase()) it.titlecase(Locale.US) else it.toString() |
| }}" |
| ) |
| ) |
| } |
| } |
| } |
| } |
| } |
| |
| @Suppress("DEPRECATION") // lintOptions methods |
| fun Project.configureLint(lintOptions: LintOptions, extension: AndroidXExtension) { |
| project.dependencies.add( |
| "lintChecks", |
| project.rootProject.project(":lint-checks") |
| ) |
| |
| // The purpose of this specific project is to test that lint is running, so |
| // it contains expected violations that we do not want to trigger a build failure |
| val isTestingLintItself = (project.path == ":lint-checks:integration-tests") |
| |
| // If -PupdateLintBaseline was set we should update the baseline if it exists |
| val updateLintBaseline = hasProperty(UPDATE_LINT_BASELINE) && !isTestingLintItself |
| |
| lintOptions.apply { |
| // Skip lintVital tasks on assemble. We explicitly run lintRelease for libraries. |
| isCheckReleaseBuilds = false |
| } |
| |
| // Lint is configured entirely in finalizeDsl so that individual projects cannot easily |
| // disable individual checks in the DSL for any reason. |
| val finalizeDsl: () -> Unit = { |
| lintOptions.apply { |
| if (!isTestingLintItself) { |
| isAbortOnError = true |
| } |
| isIgnoreWarnings = true |
| |
| // Run lint on tests. Uses top-level lint.xml to specify checks. |
| isCheckTestSources = true |
| |
| // Write output directly to the console (and nowhere else). |
| textReport = true |
| htmlReport = false |
| |
| // Format output for convenience. |
| isExplainIssues = true |
| isNoLines = false |
| isQuiet = true |
| |
| // We run lint on each library, so we don't want transitive checking of each dependency |
| isCheckDependencies = false |
| |
| fatal("VisibleForTests") |
| |
| // Disable dependency checks that suggest to change them. We want libraries to be |
| // intentional with their dependency version bumps. |
| disable("KtxExtensionAvailable") |
| disable("GradleDependency") |
| |
| // Disable a check that's only relevant for real apps. For our test apps we're not |
| // concerned with drawables potentially being a little bit blurry |
| disable("IconMissingDensityFolder") |
| |
| // Disable a check that's only triggered by translation updates which are |
| // outside of library owners' control, b/174655193 |
| disable("UnusedQuantity") |
| |
| // Disable until it works for our projects, b/171986505 |
| disable("JavaPluginLanguageLevel") |
| |
| // Disable the TODO check until we have a policy that requires it. |
| disable("StopShip") |
| |
| // Broken in 7.0.0-alpha15 due to b/180408990 |
| disable("RestrictedApi") |
| |
| // Broken in 7.0.0-alpha15 due to b/187508590 |
| disable("InvalidPackage") |
| |
| // Provide stricter enforcement for project types intended to run on a device. |
| if (extension.type.compilationTarget == CompilationTarget.DEVICE) { |
| fatal("Assert") |
| fatal("NewApi") |
| fatal("ObsoleteSdkInt") |
| fatal("NoHardKeywords") |
| fatal("UnusedResources") |
| fatal("KotlinPropertyAccess") |
| fatal("LambdaLast") |
| fatal("UnknownNullness") |
| fatal("SupportAnnotationUsage") |
| |
| // Only override if not set explicitly. |
| // Some Kotlin projects may wish to disable this. |
| if ( |
| severityOverrides!!["SyntheticAccessor"] == null && |
| extension.type != LibraryType.SAMPLES |
| ) { |
| fatal("SyntheticAccessor") |
| } |
| |
| // Only check for missing translations in finalized (beta and later) modules. |
| if (extension.mavenVersion?.isFinalApi() == true) { |
| fatal("MissingTranslation") |
| } else { |
| disable("MissingTranslation") |
| } |
| } else { |
| disable("BanUncheckedReflection") |
| } |
| |
| // Broken in 7.0.0-alpha15 due to b/187343720 |
| disable("UnusedResources") |
| |
| if (extension.type == LibraryType.SAMPLES) { |
| // TODO: b/190833328 remove if / when AGP will analyze dependencies by default |
| // This is needed because SampledAnnotationDetector uses partial analysis, and |
| // hence requires dependencies to be analyzed. |
| isCheckDependencies = true |
| // TODO: baselines from dependencies aren't used when we run lint with |
| // isCheckDependencies = true. NewApi was recently enabled for tests, and so |
| // there are a large amount of baselined issues that would be reported here |
| // again, and we don't want to add them to the baseline for the sample modules. |
| // Instead just temporarily disable this lint check until the underlying issues |
| // are fixed. |
| disable("NewApi") |
| } |
| |
| // Only run certain checks where API tracking is important. |
| if (extension.type.checkApi is RunApiTasks.No) { |
| disable("IllegalExperimentalApiUsage") |
| } |
| |
| // If the project has not overridden the lint config, set the default one. |
| if (lintConfig == null) { |
| // suppress warnings more specifically than issue-wide severity (regexes) |
| // Currently suppresses warnings from baseline files working as intended |
| lintConfig = File(project.getSupportRootFolder(), "buildSrc/lint.xml") |
| } |
| |
| // Ideally, teams aren't able to add new violations to a baseline file; they should only |
| // be able to burn down existing violations. That's hard to enforce, though, so we'll |
| // generally allow teams to update their baseline files with a publicly-known flag. |
| if (updateLintBaseline) { |
| // Continue generating baselines regardless of errors. |
| isAbortOnError = false |
| |
| // Avoid printing every single lint error to the terminal. |
| textReport = false |
| |
| // Analyze tasks are responsible for reading baselines and detecting issues, but |
| // they won't detect any issues that are already in the baselines. Delete them |
| // before the task evaluates up-to-date-ness using: |
| // |
| // find . -type f -name lint-baseline.xml -exec rm -f {} \; |
| |
| // Regular lint tasks are responsible for reading the output of analyze tasks and |
| // generating baseline files. They will fail if they generate a new baseline but |
| // there are no issues, so we need to delete the file as a finalization step using: |
| // |
| // find . -type f -name lint-baseline.xml \ |
| // -exec awk -v x=5 'NR==x{exit 1}' {} \; \ |
| // -exec rm -f {} \; |
| |
| // Continue running after errors or after creating a new, blank baseline file. |
| // This doesn't work right now due to b/188545420, but it's technically correct. |
| System.setProperty(LINT_BASELINE_CONTINUE, "true") |
| } |
| |
| // Lint complains when it generates a new, blank baseline file so we'll just avoid |
| // telling it about the baseline if one doesn't already exist OR we're explicitly |
| // updating (and creating) baseline files. |
| if (updateLintBaseline or lintBaseline.exists()) { |
| baseline(lintBaseline) |
| } |
| } |
| } |
| |
| // TODO(aurimas): migrate away from this when upgrading to AGP 7.1.0-alpha03 or newer |
| @Suppress("UnstableApiUsage", "DEPRECATION") |
| val androidComponents = extensions.findByType( |
| com.android.build.api.extension.AndroidComponentsExtension::class.java |
| ) |
| if (null != androidComponents) { |
| @Suppress("UnstableApiUsage") |
| androidComponents.finalizeDsl { finalizeDsl() } |
| } else { |
| // Support the lint standalone plugin case which, as yet, lacks AndroidComponents DSL |
| afterEvaluate { finalizeDsl() } |
| } |
| } |
| |
| val Project.lintBaseline get() = File(projectDir, "/lint-baseline.xml") |
| |
| /** |
| * Task that removes the specified `lint-baseline.xml` file if it does not contain any issues. |
| */ |
| abstract class RemoveEmptyBaselineTask : DefaultTask() { |
| @get:InputFile |
| abstract val baselineFile: RegularFileProperty |
| |
| @TaskAction |
| fun removeEmptyBaseline() { |
| val lintBaseline = baselineFile.get().asFile |
| if (lintBaseline.exists()) { |
| // Does the baseline contain any issues? |
| val hasAnyIssues = lintBaseline.reader().useLines { lines -> |
| lines.any { line -> |
| line.endsWith("<issue") |
| } |
| } |
| if (!hasAnyIssues) { |
| lintBaseline.delete() |
| println("Deleted empty baseline file ${lintBaseline.path}") |
| } |
| } |
| } |
| } |
| |
| /** |
| * Task that removes the specified `lint-baseline.xml` file. |
| */ |
| abstract class RemoveBaselineTask : DefaultTask() { |
| @get:InputFiles // allows missing files |
| abstract val baselineFile: RegularFileProperty |
| |
| @TaskAction |
| fun removeBaseline() { |
| val lintBaseline = baselineFile.get().asFile |
| if (lintBaseline.exists()) { |
| lintBaseline.delete() |
| } |
| } |
| } |
