Java tutorial
/* * Copyright (C) 2011 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.detector.api; import static com.android.SdkConstants.ANDROID_LIBRARY; import static com.android.SdkConstants.ANDROID_LIBRARY_REFERENCE_FORMAT; import static com.android.SdkConstants.ANDROID_MANIFEST_XML; import static com.android.SdkConstants.ANDROID_URI; import static com.android.SdkConstants.APPCOMPAT_LIB_ARTIFACT; import static com.android.SdkConstants.ATTR_MIN_SDK_VERSION; import static com.android.SdkConstants.ATTR_PACKAGE; import static com.android.SdkConstants.ATTR_TARGET_SDK_VERSION; import static com.android.SdkConstants.FN_PROJECT_PROGUARD_FILE; import static com.android.SdkConstants.OLD_PROGUARD_FILE; import static com.android.SdkConstants.PROGUARD_CONFIG; import static com.android.SdkConstants.PROJECT_PROPERTIES; import static com.android.SdkConstants.RES_FOLDER; import static com.android.SdkConstants.SUPPORT_LIB_ARTIFACT; import static com.android.SdkConstants.TAG_USES_SDK; import static com.android.SdkConstants.VALUE_TRUE; import static com.android.sdklib.SdkVersionInfo.HIGHEST_KNOWN_API; import com.android.SdkConstants; import com.android.annotations.NonNull; import com.android.annotations.Nullable; import com.android.build.FilterData; import com.android.build.OutputFile; import com.android.builder.model.AndroidArtifact; import com.android.builder.model.AndroidArtifactOutput; import com.android.builder.model.AndroidLibrary; import com.android.builder.model.AndroidProject; import com.android.builder.model.ProductFlavor; import com.android.builder.model.ProductFlavorContainer; import com.android.builder.model.Variant; import com.android.ide.common.repository.ResourceVisibilityLookup; import com.android.resources.Density; import com.android.resources.ResourceFolderType; import com.android.sdklib.AndroidVersion; import com.android.sdklib.IAndroidTarget; import com.android.sdklib.SdkVersionInfo; import com.android.tools.lint.client.api.CircularDependencyException; import com.android.tools.lint.client.api.Configuration; import com.android.tools.lint.client.api.LintClient; import com.android.tools.lint.client.api.LintDriver; import com.android.tools.lint.client.api.SdkInfo; import com.google.common.annotations.Beta; import com.google.common.base.CharMatcher; import com.google.common.base.Charsets; import com.google.common.base.Splitter; import com.google.common.collect.Lists; import com.google.common.collect.Sets; import com.google.common.io.Closeables; import com.google.common.io.Files; import org.w3c.dom.Document; import org.w3c.dom.Element; import org.w3c.dom.NodeList; import java.io.BufferedInputStream; import java.io.File; import java.io.FileInputStream; import java.io.IOException; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.List; import java.util.Map; import java.util.Properties; import java.util.Set; import java.util.regex.Matcher; import java.util.regex.Pattern; /** * A project contains information about an Android project being scanned for * Lint errors. * <p> * <b>NOTE: This is not a public or final API; if you rely on this be prepared * to adjust your code for the next tools release.</b> */ @Beta public class Project { protected final LintClient mClient; protected final File mDir; protected final File mReferenceDir; protected Configuration mConfiguration; protected String mPackage; protected int mBuildSdk = -1; protected IAndroidTarget mTarget; protected AndroidVersion mManifestMinSdk = AndroidVersion.DEFAULT; protected AndroidVersion mManifestTargetSdk = AndroidVersion.DEFAULT; protected boolean mLibrary; protected String mName; protected String mProguardPath; protected boolean mMergeManifests; /** The SDK info, if any */ protected SdkInfo mSdkInfo; /** * If non null, specifies a non-empty list of specific files under this * project which should be checked. */ protected List<File> mFiles; protected List<File> mProguardFiles; protected List<File> mGradleFiles; protected List<File> mManifestFiles; protected List<File> mJavaSourceFolders; protected List<File> mJavaClassFolders; protected List<File> mJavaLibraries; protected List<File> mTestSourceFolders; protected List<File> mResourceFolders; protected List<Project> mDirectLibraries; protected List<Project> mAllLibraries; protected boolean mReportIssues = true; protected Boolean mGradleProject; protected Boolean mSupportLib; protected Boolean mAppCompat; private Map<String, String> mSuperClassMap; private ResourceVisibilityLookup mResourceVisibility; /** * Creates a new {@link Project} for the given directory. * * @param client the tool running the lint check * @param dir the root directory of the project * @param referenceDir See {@link #getReferenceDir()}. * @return a new {@link Project} */ @NonNull public static Project create(@NonNull LintClient client, @NonNull File dir, @NonNull File referenceDir) { return new Project(client, dir, referenceDir); } /** * Returns true if this project is a Gradle-based Android project * * @return true if this is a Gradle-based project */ public boolean isGradleProject() { if (mGradleProject == null) { mGradleProject = mClient.isGradleProject(this); } return mGradleProject; } /** * Returns true if this project is an Android project. * * @return true if this project is an Android project. */ @SuppressWarnings("MethodMayBeStatic") public boolean isAndroidProject() { return true; } /** * Returns the project model for this project if it corresponds to * a Gradle project. This is the case if {@link #isGradleProject()} * is true and {@link #isLibrary()} is false. * * @return the project model, or null */ @Nullable public AndroidProject getGradleProjectModel() { return null; } /** * Returns the project model for this project if it corresponds to * a Gradle library. This is the case if both * {@link #isGradleProject()} and {@link #isLibrary()} return true. * * @return the project model, or null */ @SuppressWarnings("UnusedDeclaration") @Nullable public AndroidLibrary getGradleLibraryModel() { return null; } /** * Returns the current selected variant, if any (and if the current project is a Gradle * project). This can be used by incremental lint rules to warn about problems in the current * context. Lint rules should however strive to perform cross variant analysis and warn about * problems in any configuration. * * @return the select variant, or null */ @Nullable public Variant getCurrentVariant() { return null; } /** Creates a new Project. Use one of the factory methods to create. */ protected Project(@NonNull LintClient client, @NonNull File dir, @NonNull File referenceDir) { mClient = client; mDir = dir; mReferenceDir = referenceDir; initialize(); } protected void initialize() { // Default initialization: Use ADT/ant style project.properties file try { // Read properties file and initialize library state Properties properties = new Properties(); File propFile = new File(mDir, PROJECT_PROPERTIES); if (propFile.exists()) { BufferedInputStream is = new BufferedInputStream(new FileInputStream(propFile)); try { properties.load(is); String value = properties.getProperty(ANDROID_LIBRARY); mLibrary = VALUE_TRUE.equals(value); String proguardPath = properties.getProperty(PROGUARD_CONFIG); if (proguardPath != null) { mProguardPath = proguardPath; } mMergeManifests = VALUE_TRUE.equals(properties.getProperty("manifestmerger.enabled")); //$NON-NLS-1$ String target = properties.getProperty("target"); //$NON-NLS-1$ if (target != null) { int index = target.lastIndexOf('-'); if (index == -1) { index = target.lastIndexOf(':'); } if (index != -1) { String versionString = target.substring(index + 1); try { mBuildSdk = Integer.parseInt(versionString); } catch (NumberFormatException nufe) { mClient.log(Severity.WARNING, null, "Unexpected build target format: %1$s", target); } } } for (int i = 1; i < 1000; i++) { String key = String.format(ANDROID_LIBRARY_REFERENCE_FORMAT, i); String library = properties.getProperty(key); if (library == null || library.isEmpty()) { // No holes in the numbering sequence is allowed break; } File libraryDir = new File(mDir, library).getCanonicalFile(); if (mDirectLibraries == null) { mDirectLibraries = new ArrayList<Project>(); } // Adjust the reference dir to be a proper prefix path of the // library dir File libraryReferenceDir = mReferenceDir; if (!libraryDir.getPath().startsWith(mReferenceDir.getPath())) { // Symlinks etc might have been resolved, so do those to // the reference dir as well libraryReferenceDir = libraryReferenceDir.getCanonicalFile(); if (!libraryDir.getPath().startsWith(mReferenceDir.getPath())) { File file = libraryReferenceDir; while (file != null && !file.getPath().isEmpty()) { if (libraryDir.getPath().startsWith(file.getPath())) { libraryReferenceDir = file; break; } file = file.getParentFile(); } } } try { Project libraryPrj = mClient.getProject(libraryDir, libraryReferenceDir); mDirectLibraries.add(libraryPrj); // By default, we don't report issues in inferred library projects. // The driver will set report = true for those library explicitly // requested. libraryPrj.setReportIssues(false); } catch (CircularDependencyException e) { e.setProject(this); e.setLocation(Location.create(propFile)); throw e; } } } finally { try { Closeables.close(is, true /* swallowIOException */); } catch (IOException e) { // cannot happen } } } } catch (IOException ioe) { mClient.log(ioe, "Initializing project state"); } if (mDirectLibraries != null) { mDirectLibraries = Collections.unmodifiableList(mDirectLibraries); } else { mDirectLibraries = Collections.emptyList(); } } @Override public String toString() { return "Project [dir=" + mDir + ']'; } @Override public int hashCode() { return mDir.hashCode(); } @Override public boolean equals(@Nullable Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Project other = (Project) obj; return mDir.equals(other.mDir); } /** * Adds the given file to the list of files which should be checked in this * project. If no files are added, the whole project will be checked. * * @param file the file to be checked */ public void addFile(@NonNull File file) { if (mFiles == null) { mFiles = new ArrayList<File>(); } mFiles.add(file); } /** * The list of files to be checked in this project. If null, the whole * project should be checked. * * @return the subset of files to be checked, or null for the whole project */ @Nullable public List<File> getSubset() { return mFiles; } /** * Returns the list of source folders for Java source files * * @return a list of source folders to search for .java files */ @NonNull public List<File> getJavaSourceFolders() { if (mJavaSourceFolders == null) { if (isAospFrameworksProject(mDir)) { return Collections.singletonList(new File(mDir, "java")); //$NON-NLS-1$ } if (isAospBuildEnvironment()) { String top = getAospTop(); if (mDir.getAbsolutePath().startsWith(top)) { mJavaSourceFolders = getAospJavaSourcePath(); return mJavaSourceFolders; } } mJavaSourceFolders = mClient.getJavaSourceFolders(this); } return mJavaSourceFolders; } /** * Returns the list of output folders for class files * @return a list of output folders to search for .class files */ @NonNull public List<File> getJavaClassFolders() { if (mJavaClassFolders == null) { if (isAospFrameworksProject(mDir)) { File top = mDir.getParentFile().getParentFile().getParentFile(); if (top != null) { File out = new File(top, "out"); if (out.exists()) { String relative = "target/common/obj/JAVA_LIBRARIES/framework_intermediates/classes.jar"; File jar = new File(out, relative.replace('/', File.separatorChar)); if (jar.exists()) { mJavaClassFolders = Collections.singletonList(jar); return mJavaClassFolders; } } } } if (isAospBuildEnvironment()) { String top = getAospTop(); if (mDir.getAbsolutePath().startsWith(top)) { mJavaClassFolders = getAospJavaClassPath(); return mJavaClassFolders; } } mJavaClassFolders = mClient.getJavaClassFolders(this); } return mJavaClassFolders; } /** * Returns the list of Java libraries (typically .jar files) that this * project depends on. Note that this refers to jar libraries, not Android * library projects which are processed in a separate pass with their own * source and class folders. * * @return a list of .jar files (or class folders) that this project depends * on. */ @NonNull public List<File> getJavaLibraries() { if (mJavaLibraries == null) { // AOSP builds already merge libraries and class folders into // the single classes.jar file, so these have already been processed // in getJavaClassFolders. mJavaLibraries = mClient.getJavaLibraries(this); } return mJavaLibraries; } /** * Returns the list of source folders for Java test source files * * @return a list of source folders to search for .java files */ @NonNull public List<File> getTestSourceFolders() { if (mTestSourceFolders == null) { mTestSourceFolders = mClient.getTestSourceFolders(this); } return mTestSourceFolders; } /** * Returns the resource folder. * * @return a file pointing to the resource folder, or null if the project * does not contain any resources */ @NonNull public List<File> getResourceFolders() { if (mResourceFolders == null) { List<File> folders = mClient.getResourceFolders(this); if (folders.size() == 1 && isAospFrameworksProject(mDir)) { // No manifest file for this project: just init the manifest values here mManifestMinSdk = mManifestTargetSdk = new AndroidVersion(HIGHEST_KNOWN_API, null); File folder = new File(folders.get(0), RES_FOLDER); if (!folder.exists()) { folders = Collections.emptyList(); } } mResourceFolders = folders; } return mResourceFolders; } /** * Returns the relative path of a given file relative to the user specified * directory (which is often the project directory but sometimes a higher up * directory when a directory tree is being scanned * * @param file the file under this project to check * @return the path relative to the reference directory (often the project directory) */ @NonNull public String getDisplayPath(@NonNull File file) { String path = file.getPath(); String referencePath = mReferenceDir.getPath(); if (path.startsWith(referencePath)) { int length = referencePath.length(); if (path.length() > length && path.charAt(length) == File.separatorChar) { length++; } return path.substring(length); } return path; } /** * Returns the relative path of a given file within the current project. * * @param file the file under this project to check * @return the path relative to the project */ @NonNull public String getRelativePath(@NonNull File file) { String path = file.getPath(); String referencePath = mDir.getPath(); if (path.startsWith(referencePath)) { int length = referencePath.length(); if (path.length() > length && path.charAt(length) == File.separatorChar) { length++; } return path.substring(length); } return path; } /** * Returns the project root directory * * @return the dir */ @NonNull public File getDir() { return mDir; } /** * Returns the original user supplied directory where the lint search * started. For example, if you run lint against {@code /tmp/foo}, and it * finds a project to lint in {@code /tmp/foo/dev/src/project1}, then the * {@code dir} is {@code /tmp/foo/dev/src/project1} and the * {@code referenceDir} is {@code /tmp/foo/}. * * @return the reference directory, never null */ @NonNull public File getReferenceDir() { return mReferenceDir; } /** * Gets the configuration associated with this project * * @param driver the current driver, if any * @return the configuration associated with this project */ @NonNull public Configuration getConfiguration(@Nullable LintDriver driver) { if (mConfiguration == null) { mConfiguration = mClient.getConfiguration(this, driver); } return mConfiguration; } /** * Returns the application package specified by the manifest * * @return the application package, or null if unknown */ @Nullable public String getPackage() { //assert !mLibrary; // Should call getPackage on the master project, not the library // Assertion disabled because you might be running lint on a standalone library project. return mPackage; } /** * Returns the minimum API level for the project * * @return the minimum API level or {@link AndroidVersion#DEFAULT} if unknown */ @NonNull public AndroidVersion getMinSdkVersion() { return mManifestMinSdk == null ? AndroidVersion.DEFAULT : mManifestMinSdk; } /** * Returns the minimum API <b>level</b> requested by the manifest, or -1 if not * specified. Use {@link #getMinSdkVersion()} to get a full version if you need * to check if the platform is a preview platform etc. * * @return the minimum API level or -1 if unknown */ public int getMinSdk() { AndroidVersion version = getMinSdkVersion(); return version == AndroidVersion.DEFAULT ? -1 : version.getApiLevel(); } /** * Returns the target API level for the project * * @return the target API level or {@link AndroidVersion#DEFAULT} if unknown */ @NonNull public AndroidVersion getTargetSdkVersion() { return mManifestTargetSdk == AndroidVersion.DEFAULT ? getMinSdkVersion() : mManifestTargetSdk; } /** * Returns the target API <b>level</b> specified by the manifest, or -1 if not * specified. Use {@link #getTargetSdkVersion()} to get a full version if you need * to check if the platform is a preview platform etc. * * @return the target API level or -1 if unknown */ public int getTargetSdk() { AndroidVersion version = getTargetSdkVersion(); return version == AndroidVersion.DEFAULT ? -1 : version.getApiLevel(); } /** * Returns the target API used to build the project, or -1 if not known * * @return the build target API or -1 if unknown */ public int getBuildSdk() { return mBuildSdk; } /** * Returns the target used to build the project, or null if not known * * @return the build target, or null */ @Nullable public IAndroidTarget getBuildTarget() { if (mTarget == null) { mTarget = mClient.getCompileTarget(this); } return mTarget; } /** * Initialized the manifest state from the given manifest model * * @param document the DOM document for the manifest XML document */ public void readManifest(@NonNull Document document) { Element root = document.getDocumentElement(); if (root == null) { return; } mPackage = root.getAttribute(ATTR_PACKAGE); // Treat support libraries as non-reportable (in Eclipse where we don't // have binary libraries, the support libraries have to be source-copied into // the workspace which then triggers warnings in these libraries that users // shouldn't have to investigate) if (mPackage != null && mPackage.startsWith("android.support.")) { mReportIssues = false; } // Initialize minSdk and targetSdk mManifestMinSdk = AndroidVersion.DEFAULT; mManifestTargetSdk = AndroidVersion.DEFAULT; NodeList usesSdks = root.getElementsByTagName(TAG_USES_SDK); if (usesSdks.getLength() > 0) { Element element = (Element) usesSdks.item(0); String minSdk = null; if (element.hasAttributeNS(ANDROID_URI, ATTR_MIN_SDK_VERSION)) { minSdk = element.getAttributeNS(ANDROID_URI, ATTR_MIN_SDK_VERSION); } if (minSdk != null) { IAndroidTarget[] targets = mClient.getTargets(); mManifestMinSdk = SdkVersionInfo.getVersion(minSdk, targets); } if (element.hasAttributeNS(ANDROID_URI, ATTR_TARGET_SDK_VERSION)) { String targetSdk = element.getAttributeNS(ANDROID_URI, ATTR_TARGET_SDK_VERSION); if (targetSdk != null) { IAndroidTarget[] targets = mClient.getTargets(); mManifestTargetSdk = SdkVersionInfo.getVersion(targetSdk, targets); } } else { mManifestTargetSdk = mManifestMinSdk; } } else if (isAospBuildEnvironment()) { extractAospMinSdkVersion(); mManifestTargetSdk = mManifestMinSdk; } } /** * Returns true if this project is an Android library project * * @return true if this project is an Android library project */ public boolean isLibrary() { return mLibrary; } /** * Returns the list of library projects referenced by this project * * @return the list of library projects referenced by this project, never * null */ @NonNull public List<Project> getDirectLibraries() { return mDirectLibraries != null ? mDirectLibraries : Collections.<Project>emptyList(); } /** * Returns the transitive closure of the library projects for this project * * @return the transitive closure of the library projects for this project */ @NonNull public List<Project> getAllLibraries() { if (mAllLibraries == null) { if (mDirectLibraries.isEmpty()) { return mDirectLibraries; } List<Project> all = new ArrayList<Project>(); Set<Project> seen = Sets.newHashSet(); Set<Project> path = Sets.newHashSet(); seen.add(this); path.add(this); addLibraryProjects(all, seen, path); mAllLibraries = all; } return mAllLibraries; } /** * Adds this project's library project and their library projects * recursively into the given collection of projects * * @param collection the collection to add the projects into * @param seen full set of projects we've processed * @param path the current path of library dependencies followed */ private void addLibraryProjects(@NonNull Collection<Project> collection, @NonNull Set<Project> seen, @NonNull Set<Project> path) { for (Project library : mDirectLibraries) { if (seen.contains(library)) { if (path.contains(library)) { mClient.log(Severity.WARNING, null, "Internal lint error: cyclic library dependency for %1$s", library); } continue; } collection.add(library); seen.add(library); path.add(library); // Recurse library.addLibraryProjects(collection, seen, path); path.remove(library); } } /** * Gets the SDK info for the current project. * * @return the SDK info for the current project, never null */ @NonNull public SdkInfo getSdkInfo() { if (mSdkInfo == null) { mSdkInfo = mClient.getSdkInfo(this); } return mSdkInfo; } /** * Gets the paths to the manifest files in this project, if any exists. The manifests * should be provided such that the main manifest comes first, then any flavor versions, * then any build types. * * @return the path to the manifest file, or null if it does not exist */ @NonNull public List<File> getManifestFiles() { if (mManifestFiles == null) { File manifestFile = new File(mDir, ANDROID_MANIFEST_XML); if (manifestFile.exists()) { mManifestFiles = Collections.singletonList(manifestFile); } else { mManifestFiles = Collections.emptyList(); } } return mManifestFiles; } /** * Returns the proguard files configured for this project, if any * * @return the proguard files, if any */ @NonNull public List<File> getProguardFiles() { if (mProguardFiles == null) { List<File> files = new ArrayList<File>(); if (mProguardPath != null) { Splitter splitter = Splitter.on(CharMatcher.anyOf(":;")); //$NON-NLS-1$ for (String path : splitter.split(mProguardPath)) { if (path.contains("${")) { //$NON-NLS-1$ // Don't analyze the global/user proguard files continue; } File file = new File(path); if (!file.isAbsolute()) { file = new File(getDir(), path); } if (file.exists()) { files.add(file); } } } if (files.isEmpty()) { File file = new File(getDir(), OLD_PROGUARD_FILE); if (file.exists()) { files.add(file); } file = new File(getDir(), FN_PROJECT_PROGUARD_FILE); if (file.exists()) { files.add(file); } } mProguardFiles = files; } return mProguardFiles; } /** * Returns the Gradle build script files configured for this project, if any * * @return the Gradle files, if any */ @NonNull public List<File> getGradleBuildScripts() { if (mGradleFiles == null) { if (isGradleProject()) { mGradleFiles = Lists.newArrayListWithExpectedSize(2); File build = new File(mDir, SdkConstants.FN_BUILD_GRADLE); if (build.exists()) { mGradleFiles.add(build); } File settings = new File(mDir, SdkConstants.FN_SETTINGS_GRADLE); if (settings.exists()) { mGradleFiles.add(settings); } } else { mGradleFiles = Collections.emptyList(); } } return mGradleFiles; } /** * Returns the name of the project * * @return the name of the project, never null */ @NonNull public String getName() { if (mName == null) { mName = mClient.getProjectName(this); } return mName; } /** * Sets the name of the project * * @param name the name of the project, never null */ public void setName(@NonNull String name) { assert !name.isEmpty(); mName = name; } /** * Sets whether lint should report issues in this project. See * {@link #getReportIssues()} for a full description of what that means. * * @param reportIssues whether lint should report issues in this project */ public void setReportIssues(boolean reportIssues) { mReportIssues = reportIssues; } /** * Returns whether lint should report issues in this project. * <p> * If a user specifies a project and its library projects for analysis, then * those library projects are all "included", and all errors found in all * the projects are reported. But if the user is only running lint on the * main project, we shouldn't report errors in any of the library projects. * We still need to <b>consider</b> them for certain types of checks, such * as determining whether resources found in the main project are unused, so * the detectors must still get a chance to look at these projects. The * {@code #getReportIssues()} attribute is used for this purpose. * * @return whether lint should report issues in this project */ public boolean getReportIssues() { return mReportIssues; } /** * Returns whether manifest merging is in effect * * @return true if manifests in library projects should be merged into main projects */ public boolean isMergingManifests() { return mMergeManifests; } // --------------------------------------------------------------------------- // Support for running lint on the AOSP source tree itself private static Boolean sAospBuild; /** Is lint running in an AOSP build environment */ private static boolean isAospBuildEnvironment() { if (sAospBuild == null) { sAospBuild = getAospTop() != null; } return sAospBuild; } /** * Is this the frameworks AOSP project? Needs some hardcoded support since * it doesn't have a manifest file, etc. * * @param dir the project directory to check * @return true if this looks like the frameworks/base/core project */ public static boolean isAospFrameworksProject(@NonNull File dir) { if (!dir.getPath().endsWith("core")) { //$NON-NLS-1$ return false; } File parent = dir.getParentFile(); if (parent == null || !parent.getName().equals("base")) { //$NON-NLS-1$ return false; } parent = parent.getParentFile(); //noinspection RedundantIfStatement if (parent == null || !parent.getName().equals("frameworks")) { //$NON-NLS-1$ return false; } return true; } /** Get the root AOSP dir, if any */ private static String getAospTop() { return System.getenv("ANDROID_BUILD_TOP"); //$NON-NLS-1$ } /** Get the host out directory in AOSP, if any */ private static String getAospHostOut() { return System.getenv("ANDROID_HOST_OUT"); //$NON-NLS-1$ } /** Get the product out directory in AOSP, if any */ private static String getAospProductOut() { return System.getenv("ANDROID_PRODUCT_OUT"); //$NON-NLS-1$ } private List<File> getAospJavaSourcePath() { List<File> sources = new ArrayList<File>(2); // Normal sources File src = new File(mDir, "src"); //$NON-NLS-1$ if (src.exists()) { sources.add(src); } // Generates sources for (File dir : getIntermediateDirs()) { File classes = new File(dir, "src"); //$NON-NLS-1$ if (classes.exists()) { sources.add(classes); } } if (sources.isEmpty()) { mClient.log(null, "Warning: Could not find sources or generated sources for project %1$s", getName()); } return sources; } private List<File> getAospJavaClassPath() { List<File> classDirs = new ArrayList<File>(1); for (File dir : getIntermediateDirs()) { File classes = new File(dir, "classes"); //$NON-NLS-1$ if (classes.exists()) { classDirs.add(classes); } else { classes = new File(dir, "classes.jar"); //$NON-NLS-1$ if (classes.exists()) { classDirs.add(classes); } } } if (classDirs.isEmpty()) { mClient.log(null, "No bytecode found: Has the project been built? (%1$s)", getName()); } return classDirs; } /** Find the _intermediates directories for a given module name */ private List<File> getIntermediateDirs() { // See build/core/definitions.mk and in particular the "intermediates-dir-for" definition List<File> intermediates = new ArrayList<File>(); // TODO: Look up the module name, e.g. LOCAL_MODULE. However, // some Android.mk files do some complicated things with it - and most // projects use the same module name as the directory name. String moduleName = mDir.getName(); String top = getAospTop(); final String[] outFolders = new String[] { top + "/out/host/common/obj", //$NON-NLS-1$ top + "/out/target/common/obj", //$NON-NLS-1$ getAospHostOut() + "/obj", //$NON-NLS-1$ getAospProductOut() + "/obj" //$NON-NLS-1$ }; final String[] moduleClasses = new String[] { "APPS", //$NON-NLS-1$ "JAVA_LIBRARIES", //$NON-NLS-1$ }; for (String out : outFolders) { assert new File(out.replace('/', File.separatorChar)).exists() : out; for (String moduleClass : moduleClasses) { String path = out + '/' + moduleClass + '/' + moduleName + "_intermediates"; //$NON-NLS-1$ File file = new File(path.replace('/', File.separatorChar)); if (file.exists()) { intermediates.add(file); } } } return intermediates; } private void extractAospMinSdkVersion() { // Is the SDK level specified by a Makefile? boolean found = false; File makefile = new File(mDir, "Android.mk"); //$NON-NLS-1$ if (makefile.exists()) { try { List<String> lines = Files.readLines(makefile, Charsets.UTF_8); Pattern p = Pattern.compile("LOCAL_SDK_VERSION\\s*:=\\s*(.*)"); //$NON-NLS-1$ for (String line : lines) { line = line.trim(); Matcher matcher = p.matcher(line); if (matcher.matches()) { found = true; String version = matcher.group(1); if (version.equals("current")) { //$NON-NLS-1$ mManifestMinSdk = findCurrentAospVersion(); } else { mManifestMinSdk = SdkVersionInfo.getVersion(version, mClient.getTargets()); } break; } } } catch (IOException ioe) { mClient.log(ioe, null); } } if (!found) { mManifestMinSdk = findCurrentAospVersion(); } } /** Cache for {@link #findCurrentAospVersion()} */ private static AndroidVersion sCurrentVersion; /** In an AOSP build environment, identify the currently built image version, if available */ private static AndroidVersion findCurrentAospVersion() { if (sCurrentVersion == null) { File apiDir = new File(getAospTop(), "frameworks/base/api" //$NON-NLS-1$ .replace('/', File.separatorChar)); File[] apiFiles = apiDir.listFiles(); if (apiFiles == null) { sCurrentVersion = AndroidVersion.DEFAULT; return sCurrentVersion; } int max = 1; for (File apiFile : apiFiles) { String name = apiFile.getName(); int index = name.indexOf('.'); if (index > 0) { String base = name.substring(0, index); if (Character.isDigit(base.charAt(0))) { try { int version = Integer.parseInt(base); if (version > max) { max = version; } } catch (NumberFormatException nufe) { // pass } } } } sCurrentVersion = new AndroidVersion(max, null); } return sCurrentVersion; } /** * Returns true if this project depends on the given artifact. Note that * the project doesn't have to be a Gradle project; the artifact is just * an identifier for name a specific library, such as com.android.support:support-v4 * to identify the support library * * @param artifact the Gradle/Maven name of a library * @return true if the library is installed, false if it is not, and null if * we're not sure */ @Nullable public Boolean dependsOn(@NonNull String artifact) { if (SUPPORT_LIB_ARTIFACT.equals(artifact)) { if (mSupportLib == null) { for (File file : getJavaLibraries()) { String name = file.getName(); if (name.equals("android-support-v4.jar") //$NON-NLS-1$ || name.startsWith("support-v4-")) { //$NON-NLS-1$ mSupportLib = true; break; } } if (mSupportLib == null) { for (Project dependency : getDirectLibraries()) { Boolean b = dependency.dependsOn(artifact); if (b != null && b) { mSupportLib = true; break; } } } if (mSupportLib == null) { mSupportLib = false; } } return mSupportLib; } else if (APPCOMPAT_LIB_ARTIFACT.equals(artifact)) { if (mAppCompat == null) { for (File file : getJavaLibraries()) { String name = file.getName(); if (name.startsWith("appcompat-v7-")) { //$NON-NLS-1$ mAppCompat = true; break; } } if (mAppCompat == null) { for (Project dependency : getDirectLibraries()) { Boolean b = dependency.dependsOn(artifact); if (b != null && b) { mAppCompat = true; break; } } } if (mAppCompat == null) { mAppCompat = false; } } return mAppCompat; } return null; } private List<String> mCachedApplicableDensities; /** * Returns the set of applicable densities for this project. If null, there are no density * restrictions and all densities apply. * * @return the list of specific densities that apply in this project, or null if all densities * apply */ @Nullable public List<String> getApplicableDensities() { if (mCachedApplicableDensities == null) { // Use the gradle API to set up relevant densities. For example, if the // build.gradle file contains this: // android { // defaultConfig { // resConfigs "nodpi", "hdpi" // } // } // ...then we should only enforce hdpi densities, not all these others! if (isGradleProject() && getGradleProjectModel() != null && getCurrentVariant() != null) { Set<String> relevantDensities = Sets.newHashSet(); Variant variant = getCurrentVariant(); List<String> variantFlavors = variant.getProductFlavors(); AndroidProject gradleProjectModel = getGradleProjectModel(); addResConfigsFromFlavor(relevantDensities, null, getGradleProjectModel().getDefaultConfig()); for (ProductFlavorContainer container : gradleProjectModel.getProductFlavors()) { addResConfigsFromFlavor(relevantDensities, variantFlavors, container); } // Are there any splits that specify densities? if (relevantDensities.isEmpty()) { AndroidArtifact mainArtifact = variant.getMainArtifact(); Collection<AndroidArtifactOutput> outputs = mainArtifact.getOutputs(); for (AndroidArtifactOutput output : outputs) { for (OutputFile file : output.getOutputs()) { final String DENSITY_NAME = OutputFile.FilterType.DENSITY.name(); if (file.getFilterTypes().contains(DENSITY_NAME)) { for (FilterData data : file.getFilters()) { if (DENSITY_NAME.equals(data.getFilterType())) { relevantDensities.add(data.getIdentifier()); } } } } } } if (!relevantDensities.isEmpty()) { mCachedApplicableDensities = Lists.newArrayListWithExpectedSize(10); for (String density : relevantDensities) { String folder = ResourceFolderType.DRAWABLE.getName() + '-' + density; mCachedApplicableDensities.add(folder); } Collections.sort(mCachedApplicableDensities); } else { mCachedApplicableDensities = Collections.emptyList(); } } else { mCachedApplicableDensities = Collections.emptyList(); } } return mCachedApplicableDensities.isEmpty() ? null : mCachedApplicableDensities; } /** * Returns a super class map for this project. The keys and values are internal * class names (e.g. java/lang/Integer, not java.lang.Integer). * @return a map, possibly empty but never null */ @NonNull public Map<String, String> getSuperClassMap() { if (mSuperClassMap == null) { mSuperClassMap = mClient.createSuperClassMap(this); } return mSuperClassMap; } /** * Adds in the resConfig values specified by the given flavor container, assuming * it's in one of the relevant variantFlavors, into the given set */ private static void addResConfigsFromFlavor(@NonNull Set<String> relevantDensities, @Nullable List<String> variantFlavors, @NonNull ProductFlavorContainer container) { ProductFlavor flavor = container.getProductFlavor(); if (variantFlavors == null || variantFlavors.contains(flavor.getName())) { if (!flavor.getResourceConfigurations().isEmpty()) { for (String densityName : flavor.getResourceConfigurations()) { Density density = Density.getEnum(densityName); if (density != null && density.isRecommended() && density != Density.NODPI && density != Density.ANYDPI) { relevantDensities.add(densityName); } } } } } /** * Returns a shared {@link ResourceVisibilityLookup} * * @return a shared provider for looking up resource visibility */ @NonNull public ResourceVisibilityLookup getResourceVisibility() { if (mResourceVisibility == null) { if (isGradleProject()) { AndroidProject project = getGradleProjectModel(); Variant variant = getCurrentVariant(); if (project != null && variant != null) { mResourceVisibility = mClient.getResourceVisibilityProvider().get(project, variant); } else if (getGradleLibraryModel() != null) { try { mResourceVisibility = mClient.getResourceVisibilityProvider().get(getGradleLibraryModel()); } catch (Exception ignore) { // Handle talking to older Gradle plugins (where we don't // have access to the model version to check up front } } } if (mResourceVisibility == null) { mResourceVisibility = ResourceVisibilityLookup.NONE; } } return mResourceVisibility; } /** * Returns the associated client * * @return the client */ @NonNull public LintClient getClient() { return mClient; } /** * Returns the compile target to use for this project * * @return the compile target to use to build this project */ @Nullable public IAndroidTarget getCompileTarget() { return mClient.getCompileTarget(this); } }