| /* |
| * Copyright (C) 2014 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 com.android.tools.lint.checks; |
| |
| import static com.android.SdkConstants.FD_BUILD_TOOLS; |
| import static com.android.SdkConstants.GRADLE_PLUGIN_MINIMUM_VERSION; |
| import static com.android.SdkConstants.GRADLE_PLUGIN_RECOMMENDED_VERSION; |
| import static com.android.ide.common.repository.GradleCoordinate.COMPARE_PLUS_HIGHER; |
| import static com.android.tools.lint.checks.ManifestDetector.TARGET_NEWER; |
| import static com.android.tools.lint.detector.api.LintUtils.findSubstring; |
| import static com.google.common.base.Charsets.UTF_8; |
| |
| import com.android.SdkConstants; |
| import com.android.annotations.NonNull; |
| import com.android.annotations.Nullable; |
| import com.android.annotations.VisibleForTesting; |
| import com.android.builder.model.AndroidLibrary; |
| import com.android.builder.model.Dependencies; |
| import com.android.builder.model.MavenCoordinates; |
| import com.android.builder.model.Variant; |
| import com.android.ide.common.repository.GradleCoordinate; |
| import com.android.ide.common.repository.GradleCoordinate.RevisionComponent; |
| import com.android.ide.common.repository.SdkMavenRepository; |
| import com.android.sdklib.repository.PreciseRevision; |
| import com.android.tools.lint.client.api.LintClient; |
| import com.android.tools.lint.detector.api.Category; |
| import com.android.tools.lint.detector.api.Context; |
| import com.android.tools.lint.detector.api.Detector; |
| import com.android.tools.lint.detector.api.Implementation; |
| import com.android.tools.lint.detector.api.Issue; |
| import com.android.tools.lint.detector.api.LintUtils; |
| import com.android.tools.lint.detector.api.Location; |
| import com.android.tools.lint.detector.api.Scope; |
| import com.android.tools.lint.detector.api.Severity; |
| import com.android.tools.lint.detector.api.Speed; |
| import com.android.tools.lint.detector.api.TextFormat; |
| import com.google.common.base.Splitter; |
| import com.google.common.collect.Lists; |
| |
| import java.io.BufferedReader; |
| import java.io.File; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.InputStreamReader; |
| import java.io.UnsupportedEncodingException; |
| import java.net.URL; |
| import java.net.URLConnection; |
| import java.net.URLEncoder; |
| import java.util.Collections; |
| import java.util.List; |
| import java.util.Map; |
| |
| /** |
| * Checks Gradle files for potential errors |
| */ |
| public class GradleDetector extends Detector implements Detector.GradleScanner { |
| |
| private static final Implementation IMPLEMENTATION = new Implementation( |
| GradleDetector.class, |
| Scope.GRADLE_SCOPE); |
| |
| /** Obsolete dependencies */ |
| public static final Issue DEPENDENCY = Issue.create( |
| "GradleDependency", //$NON-NLS-1$ |
| "Obsolete Gradle Dependency", |
| "This detector looks for usages of libraries where the version you are using " + |
| "is not the current stable release. Using older versions is fine, and there are " + |
| "cases where you deliberately want to stick with an older version. However, " + |
| "you may simply not be aware that a more recent version is available, and that is " + |
| "what this lint check helps find.", |
| Category.CORRECTNESS, |
| 4, |
| Severity.WARNING, |
| IMPLEMENTATION); |
| |
| /** Deprecated Gradle constructs */ |
| public static final Issue DEPRECATED = Issue.create( |
| "GradleDeprecated", //$NON-NLS-1$ |
| "Deprecated Gradle Construct", |
| "This detector looks for deprecated Gradle constructs which currently work but " + |
| "will likely stop working in a future update.", |
| Category.CORRECTNESS, |
| 6, |
| Severity.WARNING, |
| IMPLEMENTATION); |
| |
| /** Incompatible Android Gradle plugin */ |
| public static final Issue GRADLE_PLUGIN_COMPATIBILITY = Issue.create( |
| "AndroidGradlePluginVersion", //$NON-NLS-1$ |
| "Incompatible Android Gradle Plugin", |
| "Not all versions of the Android Gradle plugin are compatible with all versions " + |
| "of the SDK. If you update your tools, or if you are trying to open a project that " + |
| "was built with an old version of the tools, you may need to update your plugin " + |
| "version number.", |
| Category.CORRECTNESS, |
| 8, |
| Severity.ERROR, |
| IMPLEMENTATION); |
| |
| /** Invalid or dangerous paths */ |
| public static final Issue PATH = Issue.create( |
| "GradlePath", //$NON-NLS-1$ |
| "Gradle Path Issues", |
| "Gradle build scripts are meant to be cross platform, so file paths use " + |
| "Unix-style path separators (a forward slash) rather than Windows path separators " + |
| "(a backslash). Similarly, to keep projects portable and repeatable, avoid " + |
| "using absolute paths on the system; keep files within the project instead. To " + |
| "share code between projects, consider creating an android-library and an AAR " + |
| "dependency", |
| Category.CORRECTNESS, |
| 4, |
| Severity.WARNING, |
| IMPLEMENTATION); |
| |
| /** Constructs the IDE support struggles with */ |
| public static final Issue IDE_SUPPORT = Issue.create( |
| "GradleIdeError", //$NON-NLS-1$ |
| "Gradle IDE Support Issues", |
| "Gradle is highly flexible, and there are things you can do in Gradle files which " + |
| "can make it hard or impossible for IDEs to properly handle the project. This lint " + |
| "check looks for constructs that potentially break IDE support.", |
| Category.CORRECTNESS, |
| 4, |
| Severity.ERROR, |
| IMPLEMENTATION); |
| |
| /** Using + in versions */ |
| public static final Issue PLUS = Issue.create( |
| "GradleDynamicVersion", //$NON-NLS-1$ |
| "Gradle Dynamic Version", |
| "Using `+` in dependencies lets you automatically pick up the latest available " + |
| "version rather than a specific, named version. However, this is not recommended; " + |
| "your builds are not repeatable; you may have tested with a slightly different " + |
| "version than what the build server used. (Using a dynamic version as the major " + |
| "version number is more problematic than using it in the minor version position.)", |
| Category.CORRECTNESS, |
| 4, |
| Severity.WARNING, |
| IMPLEMENTATION); |
| |
| /** Accidentally calling a getter instead of your own methods */ |
| public static final Issue GRADLE_GETTER = Issue.create( |
| "GradleGetter", //$NON-NLS-1$ |
| "Gradle Implicit Getter Call", |
| "Gradle will let you replace specific constants in your build scripts with method " + |
| "calls, so you can for example dynamically compute a version string based on your " + |
| "current version control revision number, rather than hardcoding a number.\n" + |
| "\n" + |
| "When computing a version name, it's tempting to for example call the method to do " + |
| "that `getVersionName`. However, when you put that method call inside the " + |
| "`defaultConfig` block, you will actually be calling the Groovy getter for the " + |
| "`versionName` property instead. Therefore, you need to name your method something " + |
| "which does not conflict with the existing implicit getters. Consider using " + |
| "`compute` as a prefix instead of `get`.", |
| Category.CORRECTNESS, |
| 6, |
| Severity.ERROR, |
| IMPLEMENTATION); |
| |
| /** Using incompatible versions */ |
| public static final Issue COMPATIBILITY = Issue.create( |
| "GradleCompatible", //$NON-NLS-1$ |
| "Incompatible Gradle Versions", |
| |
| "There are some combinations of libraries, or tools and libraries, that are " + |
| "incompatible, or can lead to bugs. One such incompatibility is compiling with " + |
| "a version of the Android support libraries that is not the latest version (or in " + |
| "particular, a version lower than your `targetSdkVersion`.)", |
| |
| Category.CORRECTNESS, |
| 8, |
| Severity.ERROR, |
| IMPLEMENTATION); |
| |
| /** Using a string where an integer is expected */ |
| public static final Issue STRING_INTEGER = Issue.create( |
| "StringShouldBeInt", //$NON-NLS-1$ |
| "String should be int", |
| |
| "The properties `compileSdkVersion`, `minSdkVersion` and `targetSdkVersion` are " + |
| "usually numbers, but can be strings when you are using an add-on (in the case " + |
| "of `compileSdkVersion`) or a preview platform (for the other two properties).\n" + |
| "\n" + |
| "However, you can not use a number as a string (e.g. \"19\" instead of 19); that " + |
| "will result in a platform not found error message at build/sync time.", |
| |
| Category.CORRECTNESS, |
| 8, |
| Severity.ERROR, |
| IMPLEMENTATION); |
| |
| /** A newer version is available on a remote server */ |
| public static final Issue REMOTE_VERSION = Issue.create( |
| "NewerVersionAvailable", //$NON-NLS-1$ |
| "Newer Library Versions Available", |
| "This detector checks with a central repository to see if there are newer versions " + |
| "available for the dependencies used by this project. " + |
| "This is similar to the `GradleDependency` check, which checks for newer versions " + |
| "available in the Android SDK tools and libraries, but this works with any " + |
| "MavenCentral dependency, and connects to the library every time, which makes " + |
| "it more flexible but also *much* slower.", |
| Category.CORRECTNESS, |
| 4, |
| Severity.WARNING, |
| IMPLEMENTATION).setEnabledByDefault(false); |
| |
| /** Accidentally using octal numbers */ |
| public static final Issue ACCIDENTAL_OCTAL = Issue.create( |
| "AccidentalOctal", //$NON-NLS-1$ |
| "Accidental Octal", |
| |
| "In Groovy, an integer literal that starts with a leading 0 will be interpreted " + |
| "as an octal number. That is usually (always?) an accident and can lead to " + |
| "subtle bugs, for example when used in the `versionCode` of an app.", |
| |
| Category.CORRECTNESS, |
| 2, |
| Severity.ERROR, |
| IMPLEMENTATION); |
| |
| /** The Gradle plugin ID for Android applications */ |
| public static final String APP_PLUGIN_ID = "com.android.application"; |
| /** The Gradle plugin ID for Android libraries */ |
| public static final String LIB_PLUGIN_ID = "com.android.library"; |
| |
| /** Previous plugin id for applications */ |
| public static final String OLD_APP_PLUGIN_ID = "android"; |
| /** Previous plugin id for libraries */ |
| public static final String OLD_LIB_PLUGIN_ID = "android-library"; |
| |
| private int mMinSdkVersion; |
| private int mCompileSdkVersion; |
| private int mTargetSdkVersion; |
| |
| @Override |
| public boolean appliesTo(@NonNull Context context, @NonNull File file) { |
| return true; |
| } |
| |
| @Override |
| @NonNull |
| public Speed getSpeed(@SuppressWarnings("UnusedParameters") @NonNull Issue issue) { |
| return issue == REMOTE_VERSION ? Speed.REALLY_SLOW : Speed.NORMAL; |
| } |
| |
| // ---- Implements Detector.GradleScanner ---- |
| |
| @Override |
| public void visitBuildScript(@NonNull Context context, Map<String, Object> sharedData) { |
| } |
| |
| @SuppressWarnings("UnusedDeclaration") |
| protected static boolean isInterestingBlock( |
| @NonNull String parent, |
| @Nullable String parentParent) { |
| return parent.equals("defaultConfig") |
| || parent.equals("android") |
| || parent.equals("dependencies") |
| || parent.equals("repositories") |
| || parentParent != null && parentParent.equals("buildTypes"); |
| } |
| |
| protected static boolean isInterestingStatement( |
| @NonNull String statement, |
| @Nullable String parent) { |
| return parent == null && statement.equals("apply"); |
| } |
| |
| @SuppressWarnings("UnusedDeclaration") |
| protected static boolean isInterestingProperty( |
| @NonNull String property, |
| @SuppressWarnings("UnusedParameters") |
| @NonNull String parent, |
| @Nullable String parentParent) { |
| return property.equals("targetSdkVersion") |
| || property.equals("buildToolsVersion") |
| || property.equals("versionName") |
| || property.equals("versionCode") |
| || property.equals("compileSdkVersion") |
| || property.equals("minSdkVersion") |
| || property.equals("applicationIdSuffix") |
| || property.equals("packageName") |
| || property.equals("packageNameSuffix") |
| || parent.equals("dependencies"); |
| } |
| |
| protected void checkOctal( |
| @NonNull Context context, |
| @NonNull String value, |
| @NonNull Object cookie) { |
| if (value.length() >= 2 |
| && value.charAt(0) == '0' |
| && (value.length() > 2 || value.charAt(1) >= '8' |
| && isInteger(value)) |
| && context.isEnabled(ACCIDENTAL_OCTAL)) { |
| String message = "The leading 0 turns this number into octal which is probably " |
| + "not what was intended"; |
| try { |
| long numericValue = Long.decode(value); |
| message += " (interpreted as " + numericValue + ")"; |
| } catch (NumberFormatException nufe) { |
| message += " (and it is not a valid octal number)"; |
| } |
| report(context, cookie, ACCIDENTAL_OCTAL, message); |
| } |
| } |
| |
| /** Called with for example "android", "defaultConfig", "minSdkVersion", "7" */ |
| @SuppressWarnings("UnusedDeclaration") |
| protected void checkDslPropertyAssignment( |
| @NonNull Context context, |
| @NonNull String property, |
| @NonNull String value, |
| @NonNull String parent, |
| @Nullable String parentParent, |
| @NonNull Object valueCookie, |
| @NonNull Object statementCookie) { |
| if (parent.equals("defaultConfig")) { |
| if (property.equals("targetSdkVersion")) { |
| int version = getIntLiteralValue(value, -1); |
| if (version > 0 && version < context.getClient().getHighestKnownApiLevel()) { |
| String message = |
| "Not targeting the latest versions of Android; compatibility " + |
| "modes apply. Consider testing and updating this version. " + |
| "Consult the android.os.Build.VERSION_CODES javadoc for details."; |
| report(context, valueCookie, TARGET_NEWER, message); |
| } |
| if (version > 0) { |
| mTargetSdkVersion = version; |
| checkTargetCompatibility(context, valueCookie); |
| } else { |
| checkIntegerAsString(context, value, valueCookie); |
| } |
| } else if (property.equals("minSdkVersion")) { |
| int version = getIntLiteralValue(value, -1); |
| if (version > 0) { |
| mMinSdkVersion = version; |
| } else { |
| checkIntegerAsString(context, value, valueCookie); |
| } |
| } |
| |
| if (value.startsWith("0")) { |
| checkOctal(context, value, valueCookie); |
| } |
| |
| if (property.equals("versionName") || property.equals("versionCode") && |
| !isInteger(value) || !isStringLiteral(value)) { |
| // Method call -- make sure it does not match one of the getters in the |
| // configuration! |
| if ((value.equals("getVersionCode") || |
| value.equals("getVersionName"))) { |
| String message = "Bad method name: pick a unique method name which does not " |
| + "conflict with the implicit getters for the defaultConfig " |
| + "properties. For example, try using the prefix compute- " |
| + "instead of get-."; |
| report(context, valueCookie, GRADLE_GETTER, message); |
| } |
| } else if (property.equals("packageName")) { |
| if (isModelOlderThan011(context)) { |
| return; |
| } |
| String message = "Deprecated: Replace 'packageName' with 'applicationId'"; |
| report(context, getPropertyKeyCookie(valueCookie), DEPRECATED, message); |
| } |
| } else if (property.equals("compileSdkVersion") && parent.equals("android")) { |
| int version = getIntLiteralValue(value, -1); |
| if (version > 0) { |
| mCompileSdkVersion = version; |
| checkTargetCompatibility(context, valueCookie); |
| } else { |
| checkIntegerAsString(context, value, valueCookie); |
| } |
| } else if (property.equals("buildToolsVersion") && parent.equals("android")) { |
| String versionString = getStringLiteralValue(value); |
| if (versionString != null) { |
| PreciseRevision version = parseRevisionSilently(versionString); |
| if (version != null) { |
| PreciseRevision recommended = getLatestBuildTools(context.getClient(), |
| version.getMajor()); |
| if (recommended != null && version.compareTo(recommended) < 0) { |
| // Keep in sync with {@link #getOldValue} and {@link #getNewValue} |
| String message = "Old buildToolsVersion " + version + |
| "; recommended version is " + recommended + " or later"; |
| report(context, valueCookie, DEPENDENCY, message); |
| } |
| } |
| } |
| } else if (parent.equals("dependencies")) { |
| if (value.startsWith("files('") && value.endsWith("')")) { |
| String path = value.substring("files('".length(), value.length() - 2); |
| if (path.contains("\\\\")) { |
| String message = "Do not use Windows file separators in .gradle files; " |
| + "use / instead"; |
| report(context, valueCookie, PATH, message); |
| |
| } else if (new File(path.replace('/', File.separatorChar)).isAbsolute()) { |
| String message = "Avoid using absolute paths in .gradle files"; |
| report(context, valueCookie, PATH, message); |
| } |
| } else { |
| String dependency = getStringLiteralValue(value); |
| if (dependency == null) { |
| dependency = getNamedDependency(value); |
| } |
| // If the dependency is a GString (i.e. it uses Groovy variable substitution, |
| // with a $variable_name syntax) then don't try to parse it. |
| if (dependency != null) { |
| GradleCoordinate gc = GradleCoordinate.parseCoordinateString(dependency); |
| if (gc != null && dependency.contains("$")) { |
| gc = resolveCoordinate(context, gc); |
| } |
| if (gc != null) { |
| if (gc.acceptsGreaterRevisions()) { |
| String message = "Avoid using + in version numbers; can lead " |
| + "to unpredictable and unrepeatable builds (" + dependency + ")"; |
| report(context, valueCookie, PLUS, message); |
| } |
| if (!dependency.startsWith(SdkConstants.GRADLE_PLUGIN_NAME) || |
| !checkGradlePluginDependency(context, gc, valueCookie)) { |
| checkDependency(context, gc, valueCookie); |
| } |
| } |
| } |
| } |
| } else if (property.equals("packageNameSuffix")) { |
| if (isModelOlderThan011(context)) { |
| return; |
| } |
| String message = "Deprecated: Replace 'packageNameSuffix' with 'applicationIdSuffix'"; |
| report(context, getPropertyKeyCookie(valueCookie), DEPRECATED, message); |
| } else if (property.equals("applicationIdSuffix")) { |
| String suffix = getStringLiteralValue(value); |
| if (suffix != null && !suffix.startsWith(".")) { |
| String message = "Package suffix should probably start with a \".\""; |
| report(context, valueCookie, PATH, message); |
| } |
| } |
| } |
| |
| @Nullable |
| private static GradleCoordinate resolveCoordinate(@NonNull Context context, |
| @NonNull GradleCoordinate gc) { |
| assert gc.getFullRevision().contains("$") : gc.getFullRevision(); |
| Variant variant = context.getProject().getCurrentVariant(); |
| if (variant != null) { |
| Dependencies dependencies = variant.getMainArtifact().getDependencies(); |
| for (AndroidLibrary library : dependencies.getLibraries()) { |
| MavenCoordinates mc = library.getResolvedCoordinates(); |
| if (mc != null |
| && mc.getGroupId().equals(gc.getGroupId()) |
| && mc.getArtifactId().equals(gc.getArtifactId())) { |
| List<RevisionComponent> revisions = |
| GradleCoordinate.parseRevisionNumber(mc.getVersion()); |
| if (!revisions.isEmpty()) { |
| return new GradleCoordinate(mc.getGroupId(), mc.getArtifactId(), |
| revisions, null); |
| } |
| break; |
| } |
| } |
| } |
| |
| return null; |
| } |
| |
| // Convert a long-hand dependency, like |
| // group: 'com.android.support', name: 'support-v4', version: '21.0.+' |
| // into an equivalent short-hand dependency, like |
| // com.android.support:support-v4:21.0.+ |
| @VisibleForTesting |
| @Nullable |
| static String getNamedDependency(@NonNull String expression) { |
| //if (value.startsWith("group: 'com.android.support', name: 'support-v4', version: '21.0.+'")) |
| if (expression.indexOf(',') != -1 && expression.contains("version:")) { |
| String artifact = null; |
| String group = null; |
| String version = null; |
| Splitter splitter = Splitter.on(',').omitEmptyStrings().trimResults(); |
| for (String property : splitter.split(expression)) { |
| int colon = property.indexOf(':'); |
| if (colon == -1) { |
| return null; |
| } |
| char quote = '\''; |
| int valueStart = property.indexOf(quote, colon + 1); |
| if (valueStart == -1) { |
| quote = '"'; |
| valueStart = property.indexOf(quote, colon + 1); |
| } |
| if (valueStart == -1) { |
| // For example, "transitive: false" |
| continue; |
| } |
| valueStart++; |
| int valueEnd = property.indexOf(quote, valueStart); |
| if (valueEnd == -1) { |
| return null; |
| } |
| String value = property.substring(valueStart, valueEnd); |
| if (property.startsWith("group:")) { |
| group = value; |
| } else if (property.startsWith("name:")) { |
| artifact = value; |
| } else if (property.startsWith("version:")) { |
| version = value; |
| } |
| } |
| |
| if (artifact != null && group != null && version != null) { |
| return group + ':' + artifact + ':' + version; |
| } |
| } |
| |
| return null; |
| } |
| |
| private void checkIntegerAsString(Context context, String value, Object valueCookie) { |
| // When done developing with a preview platform you might be tempted to switch from |
| // compileSdkVersion 'android-G' |
| // to |
| // compileSdkVersion '19' |
| // but that won't work; it needs to be |
| // compileSdkVersion 19 |
| String string = getStringLiteralValue(value); |
| if (isNumberString(string)) { |
| String quote = Character.toString(value.charAt(0)); |
| String message = String.format("Use an integer rather than a string here " |
| + "(replace %1$s%2$s%1$s with just %2$s)", quote, string); |
| report(context, valueCookie, STRING_INTEGER, message); |
| } |
| } |
| |
| /** |
| * Given an error message produced by this lint detector for the given issue type, |
| * returns the old value to be replaced in the source code. |
| * <p> |
| * Intended for IDE quickfix implementations. |
| * |
| * @param issue the corresponding issue |
| * @param errorMessage the error message associated with the error |
| * @param format the format of the error message |
| * @return the corresponding old value, or null if not recognized |
| */ |
| @Nullable |
| public static String getOldValue(@NonNull Issue issue, @NonNull String errorMessage, |
| @NonNull TextFormat format) { |
| errorMessage = format.toText(errorMessage); |
| |
| // Consider extracting all the error strings as constants and handling this |
| // using the LintUtils#getFormattedParameters() method to pull back out the information |
| if (issue == DEPENDENCY) { |
| // "A newer version of com.google.guava:guava than 11.0.2 is available: 17.0.0" |
| if (errorMessage.startsWith("A newer ")) { |
| return findSubstring(errorMessage, " than ", " "); |
| } |
| if (errorMessage.startsWith("Old buildToolsVersion ")) { |
| return findSubstring(errorMessage, "Old buildToolsVersion ", ";"); |
| } |
| // "The targetSdkVersion (20) should not be higher than the compileSdkVersion (19)" |
| return findSubstring(errorMessage, "targetSdkVersion (", ")"); |
| } else if (issue == STRING_INTEGER) { |
| return findSubstring(errorMessage, "replace ", " with "); |
| } else if (issue == DEPRECATED) { |
| if (errorMessage.contains(GradleDetector.APP_PLUGIN_ID) && |
| errorMessage.contains(GradleDetector.OLD_APP_PLUGIN_ID)) { |
| return GradleDetector.OLD_APP_PLUGIN_ID; |
| } else if (errorMessage.contains(GradleDetector.LIB_PLUGIN_ID) && |
| errorMessage.contains(GradleDetector.OLD_LIB_PLUGIN_ID)) { |
| return GradleDetector.OLD_LIB_PLUGIN_ID; |
| } |
| // "Deprecated: Replace 'packageNameSuffix' with 'applicationIdSuffix'" |
| return findSubstring(errorMessage, "Replace '", "'"); |
| } else if (issue == PLUS) { |
| return findSubstring(errorMessage, "(", ")"); |
| } else if (issue == COMPATIBILITY) { |
| if (errorMessage.startsWith("Version 5.2.08")) { |
| return "5.2.08"; |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Given an error message produced by this lint detector for the given issue type, |
| * returns the new value to be put into the source code. |
| * <p> |
| * Intended for IDE quickfix implementations. |
| * |
| * @param issue the corresponding issue |
| * @param errorMessage the error message associated with the error |
| * @param format the format of the error message |
| * @return the corresponding new value, or null if not recognized |
| */ |
| @Nullable |
| public static String getNewValue(@NonNull Issue issue, @NonNull String errorMessage, |
| @NonNull TextFormat format) { |
| errorMessage = format.toText(errorMessage); |
| |
| if (issue == DEPENDENCY) { |
| // "A newer version of com.google.guava:guava than 11.0.2 is available: 17.0.0" |
| if (errorMessage.startsWith("A newer ")) { |
| return findSubstring(errorMessage, " is available: ", null); |
| } |
| if (errorMessage.startsWith("Old buildToolsVersion ")) { |
| return findSubstring(errorMessage, " version is ", " "); |
| } |
| // "The targetSdkVersion (20) should not be higher than the compileSdkVersion (19)" |
| return findSubstring(errorMessage, "compileSdkVersion (", ")"); |
| } else if (issue == STRING_INTEGER) { |
| return findSubstring(errorMessage, " just ", ")"); |
| } else if (issue == DEPRECATED) { |
| if (errorMessage.contains(GradleDetector.APP_PLUGIN_ID) && |
| errorMessage.contains(GradleDetector.OLD_APP_PLUGIN_ID)) { |
| return GradleDetector.APP_PLUGIN_ID; |
| } else if (errorMessage.contains(GradleDetector.LIB_PLUGIN_ID) && |
| errorMessage.contains(GradleDetector.OLD_LIB_PLUGIN_ID)) { |
| return GradleDetector.LIB_PLUGIN_ID; |
| } |
| // "Deprecated: Replace 'packageNameSuffix' with 'applicationIdSuffix'" |
| return findSubstring(errorMessage, " with '", "'"); |
| } else if (issue == COMPATIBILITY) { |
| if (errorMessage.startsWith("Version 5.2.08")) { |
| return findSubstring(errorMessage, "Use version ", " "); |
| } |
| } |
| |
| return null; |
| } |
| |
| private static boolean isNumberString(@Nullable String s) { |
| if (s == null || s.isEmpty()) { |
| return false; |
| } |
| for (int i = 0, n = s.length(); i < n; i++) { |
| if (!Character.isDigit(s.charAt(i))) { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| protected void checkMethodCall( |
| @NonNull Context context, |
| @NonNull String statement, |
| @Nullable String parent, |
| @NonNull Map<String, String> namedArguments, |
| @SuppressWarnings("UnusedParameters") |
| @NonNull List<String> unnamedArguments, |
| @NonNull Object cookie) { |
| String plugin = namedArguments.get("plugin"); |
| if (statement.equals("apply") && parent == null) { |
| boolean isOldAppPlugin = OLD_APP_PLUGIN_ID.equals(plugin); |
| if (isOldAppPlugin || OLD_LIB_PLUGIN_ID.equals(plugin)) { |
| String replaceWith = isOldAppPlugin ? APP_PLUGIN_ID : LIB_PLUGIN_ID; |
| String message = String.format("'%1$s' is deprecated; use '%2$s' instead", plugin, |
| replaceWith); |
| report(context, cookie, DEPRECATED, message); |
| } |
| } |
| } |
| |
| @Nullable |
| private static PreciseRevision parseRevisionSilently(String versionString) { |
| try { |
| return PreciseRevision.parseRevision(versionString); |
| } catch (Throwable t) { |
| return null; |
| } |
| } |
| |
| private static boolean isModelOlderThan011(@NonNull Context context) { |
| return LintUtils.isModelOlderThan(context.getProject().getGradleProjectModel(), 0, 11, 0); |
| } |
| |
| private static int sMajorBuildTools; |
| private static PreciseRevision sLatestBuildTools; |
| |
| /** Returns the latest build tools installed for the given major version. |
| * We just cache this once; we don't need to be accurate in the sense that if the |
| * user opens the SDK manager and installs a more recent version, we capture this in |
| * the same IDE session. |
| * |
| * @param client the associated client |
| * @param major the major version of build tools to look up (e.g. typically 18, 19, ...) |
| * @return the corresponding highest known revision |
| */ |
| @Nullable |
| private static PreciseRevision getLatestBuildTools(@NonNull LintClient client, int major) { |
| if (major != sMajorBuildTools) { |
| sMajorBuildTools = major; |
| |
| List<PreciseRevision> revisions = Lists.newArrayList(); |
| if (major == 21) { |
| revisions.add(new PreciseRevision(21, 1, 2)); |
| } else if (major == 20) { |
| revisions.add(new PreciseRevision(20)); |
| } else if (major == 19) { |
| revisions.add(new PreciseRevision(19, 1)); |
| } else if (major == 18) { |
| revisions.add(new PreciseRevision(18, 1, 1)); |
| } |
| // The above versions can go stale. |
| // Check if a more recent one is installed. (The above are still useful for |
| // people who haven't updated with the SDK manager recently.) |
| File sdkHome = client.getSdkHome(); |
| if (sdkHome != null) { |
| File[] dirs = new File(sdkHome, FD_BUILD_TOOLS).listFiles(); |
| if (dirs != null) { |
| for (File dir : dirs) { |
| String name = dir.getName(); |
| if (!dir.isDirectory() || !Character.isDigit(name.charAt(0))) { |
| continue; |
| } |
| PreciseRevision v = parseRevisionSilently(name); |
| if (v != null && v.getMajor() == major) { |
| revisions.add(v); |
| } |
| } |
| } |
| } |
| |
| if (!revisions.isEmpty()) { |
| sLatestBuildTools = Collections.max(revisions); |
| } |
| } |
| |
| return sLatestBuildTools; |
| } |
| |
| private void checkTargetCompatibility(Context context, Object cookie) { |
| if (mCompileSdkVersion > 0 && mTargetSdkVersion > 0 |
| && mTargetSdkVersion > mCompileSdkVersion) { |
| // NOTE: Keep this in sync with {@link #getOldValue} and {@link #getNewValue} |
| String message = "The targetSdkVersion (" + mTargetSdkVersion |
| + ") should not be higher than the compileSdkVersion (" |
| + mCompileSdkVersion + ")"; |
| report(context, cookie, DEPENDENCY, message); |
| } |
| } |
| |
| @Nullable |
| private static String getStringLiteralValue(@NonNull String value) { |
| if (value.length() > 2 && (value.startsWith("'") && value.endsWith("'") || |
| value.startsWith("\"") && value.endsWith("\""))) { |
| return value.substring(1, value.length() - 1); |
| } |
| |
| return null; |
| } |
| |
| private static int getIntLiteralValue(@NonNull String value, int defaultValue) { |
| try { |
| return Integer.parseInt(value); |
| } catch (NumberFormatException e) { |
| return defaultValue; |
| } |
| } |
| |
| private static boolean isInteger(String token) { |
| return token.matches("\\d+"); |
| } |
| |
| private static boolean isStringLiteral(String token) { |
| return token.startsWith("\"") && token.endsWith("\"") || |
| token.startsWith("'") && token.endsWith("'"); |
| } |
| |
| private void checkDependency( |
| @NonNull Context context, |
| @NonNull GradleCoordinate dependency, |
| @NonNull Object cookie) { |
| if ("com.android.support".equals(dependency.getGroupId())) { |
| checkSupportLibraries(context, dependency, cookie); |
| if (mMinSdkVersion >= 14 && "appcompat-v7".equals(dependency.getArtifactId()) |
| && mCompileSdkVersion >= 1 && mCompileSdkVersion < 21) { |
| report(context, cookie, DEPENDENCY, |
| "Using the appcompat library when minSdkVersion >= 14 and " |
| + "compileSdkVersion < 21 is not necessary"); |
| } |
| return; |
| } else if ("com.google.android.gms".equals(dependency.getGroupId()) |
| && dependency.getArtifactId() != null) { |
| |
| // 5.2.08 is not supported; special case and warn about this |
| if ("5.2.08".equals(dependency.getFullRevision()) && context.isEnabled(COMPATIBILITY)) { |
| // This specific version is actually a preview version which should |
| // not be used (https://code.google.com/p/android/issues/detail?id=75292) |
| String version = "6.1.11"; |
| // Try to find a more recent available version, if one is available |
| File sdkHome = context.getClient().getSdkHome(); |
| File repository = SdkMavenRepository.GOOGLE.getRepositoryLocation(sdkHome, true); |
| if (repository != null) { |
| GradleCoordinate max = SdkMavenRepository.getHighestInstalledVersion( |
| dependency.getGroupId(), dependency.getArtifactId(), repository, |
| null, false); |
| if (max != null) { |
| if (COMPARE_PLUS_HIGHER.compare(dependency, max) < 0) { |
| version = max.getFullRevision(); |
| } |
| } |
| } |
| String message = String.format("Version `5.2.08` should not be used; the app " |
| + "can not be published with this version. Use version `%1$s` " |
| + "instead.", version); |
| report(context, cookie, COMPATIBILITY, message); |
| } |
| |
| checkPlayServices(context, dependency, cookie); |
| return; |
| } |
| |
| PreciseRevision version = null; |
| Issue issue = DEPENDENCY; |
| if ("com.android.tools.build".equals(dependency.getGroupId()) && |
| "gradle".equals(dependency.getArtifactId())) { |
| try { |
| PreciseRevision v = |
| PreciseRevision.parseRevision(GRADLE_PLUGIN_RECOMMENDED_VERSION); |
| if (!v.isPreview()) { |
| version = getNewerRevision(dependency, v); |
| } |
| } catch (NumberFormatException e) { |
| context.log(e, null); |
| } |
| } else if ("com.google.guava".equals(dependency.getGroupId()) && |
| "guava".equals(dependency.getArtifactId())) { |
| version = getNewerRevision(dependency, new PreciseRevision(18, 0)); |
| } else if ("com.google.code.gson".equals(dependency.getGroupId()) && |
| "gson".equals(dependency.getArtifactId())) { |
| version = getNewerRevision(dependency, new PreciseRevision(2, 3)); |
| } else if ("org.apache.httpcomponents".equals(dependency.getGroupId()) && |
| "httpclient".equals(dependency.getArtifactId())) { |
| version = getNewerRevision(dependency, new PreciseRevision(4, 3, 5)); |
| } |
| |
| // Network check for really up to date libraries? Only done in batch mode |
| if (context.getScope().size() > 1 && context.isEnabled(REMOTE_VERSION)) { |
| PreciseRevision latest = getLatestVersionFromRemoteRepo(context.getClient(), dependency, |
| dependency.isPreview()); |
| if (latest != null && isOlderThan(dependency, latest.getMajor(), latest.getMinor(), |
| latest.getMicro())) { |
| version = latest; |
| issue = REMOTE_VERSION; |
| } |
| } |
| |
| if (version != null) { |
| String message = getNewerVersionAvailableMessage(dependency, version); |
| report(context, cookie, issue, message); |
| } |
| } |
| |
| private static String getNewerVersionAvailableMessage(GradleCoordinate dependency, |
| PreciseRevision version) { |
| return getNewerVersionAvailableMessage(dependency, version.toString()); |
| } |
| |
| private static String getNewerVersionAvailableMessage(GradleCoordinate dependency, |
| String version) { |
| // NOTE: Keep this in sync with {@link #getOldValue} and {@link #getNewValue} |
| return "A newer version of " + dependency.getGroupId() + ":" + |
| dependency.getArtifactId() + " than " + dependency.getFullRevision() + |
| " is available: " + version; |
| } |
| |
| /** TODO: Cache these results somewhere! */ |
| @Nullable |
| public static PreciseRevision getLatestVersionFromRemoteRepo(@NonNull LintClient client, |
| @NonNull GradleCoordinate dependency, boolean allowPreview) { |
| return getLatestVersionFromRemoteRepo(client, dependency, true, allowPreview); |
| } |
| |
| @Nullable |
| private static PreciseRevision getLatestVersionFromRemoteRepo(@NonNull LintClient client, |
| @NonNull GradleCoordinate dependency, boolean firstRowOnly, boolean allowPreview) { |
| StringBuilder query = new StringBuilder(); |
| String encoding = UTF_8.name(); |
| try { |
| query.append("http://search.maven.org/solrsearch/select?q=g:%22"); |
| query.append(URLEncoder.encode(dependency.getGroupId(), encoding)); |
| query.append("%22+AND+a:%22"); |
| query.append(URLEncoder.encode(dependency.getArtifactId(), encoding)); |
| } catch (UnsupportedEncodingException ee) { |
| return null; |
| } |
| query.append("%22&core=gav"); |
| if (firstRowOnly) { |
| query.append("&rows=1"); |
| } |
| query.append("&wt=json"); |
| |
| String response = readUrlData(client, dependency, query.toString()); |
| if (response == null) { |
| return null; |
| } |
| |
| // Sample response: |
| // { |
| // "responseHeader": { |
| // "status": 0, |
| // "QTime": 0, |
| // "params": { |
| // "fl": "id,g,a,v,p,ec,timestamp,tags", |
| // "sort": "score desc,timestamp desc,g asc,a asc,v desc", |
| // "indent": "off", |
| // "q": "g:\"com.google.guava\" AND a:\"guava\"", |
| // "core": "gav", |
| // "wt": "json", |
| // "rows": "1", |
| // "version": "2.2" |
| // } |
| // }, |
| // "response": { |
| // "numFound": 37, |
| // "start": 0, |
| // "docs": [{ |
| // "id": "com.google.guava:guava:17.0", |
| // "g": "com.google.guava", |
| // "a": "guava", |
| // "v": "17.0", |
| // "p": "bundle", |
| // "timestamp": 1398199666000, |
| // "tags": ["spec", "libraries", "classes", "google", "code"], |
| // "ec": ["-javadoc.jar", "-sources.jar", ".jar", "-site.jar", ".pom"] |
| // }] |
| // } |
| // } |
| |
| // Look for version info: This is just a cheap skim of the above JSON results |
| boolean foundPreview = false; |
| int index = response.indexOf("\"response\""); //$NON-NLS-1$ |
| while (index != -1) { |
| index = response.indexOf("\"v\":", index); //$NON-NLS-1$ |
| if (index != -1) { |
| index += 4; |
| int start = response.indexOf('"', index) + 1; |
| int end = response.indexOf('"', start + 1); |
| if (end > start && start >= 0) { |
| PreciseRevision revision = parseRevisionSilently(response.substring(start, end)); |
| if (revision != null) { |
| foundPreview = revision.isPreview(); |
| if (allowPreview || !foundPreview) { |
| return revision; |
| } |
| } |
| } |
| } |
| } |
| |
| if (!allowPreview && foundPreview && firstRowOnly) { |
| // Recurse: search more than the first row this time to see if we can find a |
| // non-preview version |
| return getLatestVersionFromRemoteRepo(client, dependency, false, false); |
| } |
| |
| return null; |
| } |
| |
| /** Normally null; used for testing */ |
| @Nullable |
| @VisibleForTesting |
| static Map<String,String> sMockData; |
| |
| @Nullable |
| private static String readUrlData( |
| @NonNull LintClient client, |
| @NonNull GradleCoordinate dependency, |
| @NonNull String query) { |
| // For unit testing: avoid network as well as unexpected new versions |
| if (sMockData != null) { |
| String value = sMockData.get(query); |
| assert value != null : query; |
| return value; |
| } |
| |
| try { |
| URL url = new URL(query); |
| |
| URLConnection connection = client.openConnection(url); |
| if (connection == null) { |
| return null; |
| } |
| try { |
| InputStream is = connection.getInputStream(); |
| if (is == null) { |
| return null; |
| } |
| BufferedReader reader = new BufferedReader(new InputStreamReader(is, UTF_8)); |
| try { |
| StringBuilder sb = new StringBuilder(500); |
| String line; |
| while ((line = reader.readLine()) != null) { |
| sb.append(line); |
| sb.append('\n'); |
| } |
| |
| return sb.toString(); |
| } finally { |
| reader.close(); |
| } |
| } finally { |
| client.closeConnection(connection); |
| } |
| } catch (IOException ioe) { |
| client.log(ioe, "Could not connect to maven central to look up the " + |
| "latest available version for %1$s", dependency); |
| return null; |
| } |
| } |
| |
| private boolean checkGradlePluginDependency(Context context, GradleCoordinate dependency, |
| Object cookie) { |
| GradleCoordinate latestPlugin = GradleCoordinate.parseCoordinateString( |
| SdkConstants.GRADLE_PLUGIN_NAME + |
| GRADLE_PLUGIN_MINIMUM_VERSION); |
| if (GradleCoordinate.COMPARE_PLUS_HIGHER.compare(dependency, latestPlugin) < 0) { |
| String message = "You must use a newer version of the Android Gradle plugin. The " |
| + "minimum supported version is " + GRADLE_PLUGIN_MINIMUM_VERSION + |
| " and the recommended version is " + GRADLE_PLUGIN_RECOMMENDED_VERSION; |
| report(context, cookie, GRADLE_PLUGIN_COMPATIBILITY, message); |
| return true; |
| } |
| return false; |
| } |
| |
| private void checkSupportLibraries(Context context, GradleCoordinate dependency, |
| Object cookie) { |
| String groupId = dependency.getGroupId(); |
| String artifactId = dependency.getArtifactId(); |
| assert groupId != null && artifactId != null; |
| |
| // See if the support library version is lower than the targetSdkVersion |
| if (mTargetSdkVersion > 0 && dependency.getMajorVersion() < mTargetSdkVersion && |
| dependency.getMajorVersion() != GradleCoordinate.PLUS_REV_VALUE && |
| // The multidex library doesn't follow normal supportlib numbering scheme |
| !dependency.getArtifactId().startsWith("multidex") && |
| context.isEnabled(COMPATIBILITY)) { |
| String message = "This support library should not use a lower version (" |
| + dependency.getMajorVersion() + ") than the `targetSdkVersion` (" |
| + mTargetSdkVersion + ")"; |
| report(context, cookie, COMPATIBILITY, message); |
| } |
| |
| // Check to make sure you have the Android support repository installed |
| File sdkHome = context.getClient().getSdkHome(); |
| File repository = SdkMavenRepository.ANDROID.getRepositoryLocation(sdkHome, true); |
| if (repository == null) { |
| report(context, cookie, DEPENDENCY, |
| "Dependency on a support library, but the SDK installation does not " |
| + "have the \"Extras > Android Support Repository\" installed. " |
| + "Open the SDK manager and install it."); |
| } else { |
| checkLocalMavenVersions(context, dependency, cookie, groupId, artifactId, |
| repository); |
| } |
| } |
| |
| private void checkPlayServices(Context context, GradleCoordinate dependency, Object cookie) { |
| String groupId = dependency.getGroupId(); |
| String artifactId = dependency.getArtifactId(); |
| assert groupId != null && artifactId != null; |
| |
| File sdkHome = context.getClient().getSdkHome(); |
| File repository = SdkMavenRepository.GOOGLE.getRepositoryLocation(sdkHome, true); |
| if (repository == null) { |
| report(context, cookie, DEPENDENCY, |
| "Dependency on Play Services, but the SDK installation does not " |
| + "have the \"Extras > Google Repository\" installed. " |
| + "Open the SDK manager and install it."); |
| } else { |
| checkLocalMavenVersions(context, dependency, cookie, groupId, artifactId, |
| repository); |
| } |
| } |
| |
| private void checkLocalMavenVersions(Context context, GradleCoordinate dependency, |
| Object cookie, String groupId, String artifactId, File repository) { |
| GradleCoordinate max = SdkMavenRepository.getHighestInstalledVersion(groupId, artifactId, |
| repository, null, false); |
| if (max != null) { |
| if (COMPARE_PLUS_HIGHER.compare(dependency, max) < 0 |
| && context.isEnabled(DEPENDENCY)) { |
| String message = getNewerVersionAvailableMessage(dependency, max.getFullRevision()); |
| report(context, cookie, DEPENDENCY, message); |
| } |
| } |
| } |
| |
| private static PreciseRevision getNewerRevision(@NonNull GradleCoordinate dependency, |
| @NonNull PreciseRevision revision) { |
| assert dependency.getGroupId() != null; |
| assert dependency.getArtifactId() != null; |
| GradleCoordinate coordinate; |
| if (revision.isPreview()) { |
| String coordinateString = dependency.getGroupId() |
| + ":" + dependency.getArtifactId() |
| + ":" + revision.toString(); |
| coordinate = GradleCoordinate.parseCoordinateString(coordinateString); |
| } else { |
| coordinate = new GradleCoordinate(dependency.getGroupId(), dependency.getArtifactId(), |
| revision.getMajor(), revision.getMinor(), revision.getMicro()); |
| } |
| if (COMPARE_PLUS_HIGHER.compare(dependency, coordinate) < 0) { |
| return revision; |
| } else { |
| return null; |
| } |
| } |
| |
| private static boolean isOlderThan(@NonNull GradleCoordinate dependency, int major, int minor, |
| int micro) { |
| assert dependency.getGroupId() != null; |
| assert dependency.getArtifactId() != null; |
| return COMPARE_PLUS_HIGHER.compare(dependency, |
| new GradleCoordinate(dependency.getGroupId(), |
| dependency.getArtifactId(), major, minor, micro)) < 0; |
| } |
| |
| private void report(@NonNull Context context, @NonNull Object cookie, @NonNull Issue issue, |
| @NonNull String message) { |
| if (context.isEnabled(issue)) { |
| // Suppressed? |
| // Temporarily unconditionally checking for suppress comments in Gradle files |
| // since Studio insists on an AndroidLint id prefix |
| boolean checkComments = /*context.getClient().checkForSuppressComments() |
| &&*/ context.containsCommentSuppress(); |
| if (checkComments) { |
| int startOffset = getStartOffset(context, cookie); |
| if (startOffset >= 0 && context.isSuppressedWithComment(startOffset, issue)) { |
| return; |
| } |
| } |
| |
| context.report(issue, createLocation(context, cookie), message); |
| } |
| } |
| |
| @SuppressWarnings("MethodMayBeStatic") |
| @NonNull |
| protected Object getPropertyKeyCookie(@NonNull Object cookie) { |
| return cookie; |
| } |
| |
| @SuppressWarnings({"MethodMayBeStatic", "UnusedDeclaration"}) |
| @NonNull |
| protected Object getPropertyPairCookie(@NonNull Object cookie) { |
| return cookie; |
| } |
| |
| @SuppressWarnings("MethodMayBeStatic") |
| protected int getStartOffset(@NonNull Context context, @NonNull Object cookie) { |
| return -1; |
| } |
| |
| @SuppressWarnings({"MethodMayBeStatic", "UnusedParameters"}) |
| protected Location createLocation(@NonNull Context context, @NonNull Object cookie) { |
| return null; |
| } |
| } |
