| /* |
| * 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); |
| } |
| } |
