com.android.build.gradle.internal.DependencyManager Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of gradle-core Show documentation
Show all versions of gradle-core Show documentation
Core library to build Android Gradle plugin.
/*
* Copyright (C) 2015 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.build.gradle.internal;
import static com.android.SdkConstants.DOT_JAR;
import static com.android.SdkConstants.EXT_ANDROID_PACKAGE;
import static com.android.SdkConstants.EXT_JAR;
import static com.android.builder.core.BuilderConstants.EXT_LIB_ARCHIVE;
import static com.android.builder.core.ErrorReporter.EvaluationMode.STANDARD;
import static com.android.builder.model.AndroidProject.FD_INTERMEDIATES;
import com.android.annotations.NonNull;
import com.android.annotations.Nullable;
import com.android.build.gradle.internal.dependency.JarInfo;
import com.android.build.gradle.internal.dependency.LibInfo;
import com.android.build.gradle.internal.dependency.LibraryDependencyImpl;
import com.android.build.gradle.internal.dependency.ManifestDependencyImpl;
import com.android.build.gradle.internal.dependency.VariantDependencies;
import com.android.build.gradle.internal.model.MavenCoordinatesImpl;
import com.android.build.gradle.internal.tasks.PrepareDependenciesTask;
import com.android.build.gradle.internal.tasks.PrepareLibraryTask;
import com.android.build.gradle.internal.variant.BaseVariantData;
import com.android.build.gradle.internal.variant.BaseVariantOutputData;
import com.android.builder.dependency.DependencyContainer;
import com.android.builder.dependency.JarDependency;
import com.android.builder.dependency.LibraryDependency;
import com.android.builder.model.MavenCoordinates;
import com.android.builder.model.SyncIssue;
import com.android.utils.ILogger;
import com.google.common.base.Joiner;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Multimap;
import com.google.common.collect.Sets;
import org.gradle.api.CircularReferenceException;
import org.gradle.api.Project;
import org.gradle.api.Task;
import org.gradle.api.UnknownProjectException;
import org.gradle.api.artifacts.Configuration;
import org.gradle.api.artifacts.Dependency;
import org.gradle.api.artifacts.ModuleVersionIdentifier;
import org.gradle.api.artifacts.ProjectDependency;
import org.gradle.api.artifacts.ResolvedArtifact;
import org.gradle.api.artifacts.SelfResolvingDependency;
import org.gradle.api.artifacts.component.ComponentIdentifier;
import org.gradle.api.artifacts.component.ComponentSelector;
import org.gradle.api.artifacts.component.ProjectComponentIdentifier;
import org.gradle.api.artifacts.result.DependencyResult;
import org.gradle.api.artifacts.result.ResolvedComponentResult;
import org.gradle.api.artifacts.result.ResolvedDependencyResult;
import org.gradle.api.artifacts.result.UnresolvedDependencyResult;
import org.gradle.api.logging.Logging;
import org.gradle.api.plugins.JavaBasePlugin;
import org.gradle.api.specs.Specs;
import org.gradle.util.GUtil;
import java.io.File;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
/**
* A manager to resolve configuration dependencies.
*/
public class DependencyManager {
protected static final boolean DEBUG_DEPENDENCY = false;
private Project project;
private ExtraModelInfo extraModelInfo;
private ILogger logger;
final Map prepareTaskMap = Maps.newHashMap();
public DependencyManager(Project project, ExtraModelInfo extraModelInfo) {
this.project = project;
this.extraModelInfo = extraModelInfo;
logger = new LoggerWrapper(Logging.getLogger(DependencyManager.class));
}
/**
* Returns the list of packaged local jars.
*/
public static List getPackagedLocalJarFileList(DependencyContainer dependencyContainer) {
List jarDependencyList = dependencyContainer.getLocalDependencies();
Set files = Sets.newHashSetWithExpectedSize(jarDependencyList.size());
for (JarDependency jarDependency : jarDependencyList) {
if (jarDependency.isPackaged()) {
files.add(jarDependency.getJarFile());
}
}
return Lists.newArrayList(files);
}
public void addDependencyToPrepareTask(
@NonNull BaseVariantData variantData,
@NonNull PrepareDependenciesTask prepareDependenciesTask,
@NonNull LibraryDependencyImpl lib) {
PrepareLibraryTask prepareLibTask = prepareTaskMap.get(lib.getNonTransitiveRepresentation());
if (prepareLibTask != null) {
prepareDependenciesTask.dependsOn(prepareLibTask);
prepareLibTask.dependsOn(variantData.preBuildTask);
}
for (LibraryDependency childLib : lib.getDependencies()) {
addDependencyToPrepareTask(
variantData,
prepareDependenciesTask,
(LibraryDependencyImpl) childLib);
}
}
public void resolveDependencies(
@NonNull VariantDependencies variantDeps,
@Nullable VariantDependencies testedVariantDeps,
@Nullable String testedProjectPath) {
Multimap reverseMap = ArrayListMultimap.create();
resolveDependencyForConfig(variantDeps, testedVariantDeps, testedProjectPath, reverseMap);
processLibraries(variantDeps.getLibraries(), reverseMap);
}
private void processLibraries(
@NonNull Collection libraries,
@NonNull Multimap reverseMap) {
for (LibraryDependencyImpl lib : libraries) {
setupPrepareLibraryTask(lib, reverseMap);
//noinspection unchecked
processLibraries(
(Collection) (List) lib.getDependencies(),
reverseMap);
}
}
private void setupPrepareLibraryTask(
@NonNull LibraryDependencyImpl libDependency,
@NonNull Multimap reverseMap) {
Task task = maybeCreatePrepareLibraryTask(libDependency, project);
// Use the reverse map to find all the configurations that included this android
// library so that we can make sure they are built.
// TODO fix, this is not optimum as we bring in more dependencies than we should.
Collection configDepList = reverseMap.get(libDependency);
if (configDepList != null && !configDepList.isEmpty()) {
for (VariantDependencies configDependencies: configDepList) {
task.dependsOn(configDependencies.getCompileConfiguration().getBuildDependencies());
}
}
// check if this library is created by a parent (this is based on the
// output file.
// TODO Fix this as it's fragile
/*
This is a somewhat better way but it doesn't work in some project with
weird setups...
Project parentProject = DependenciesImpl.getProject(library.getBundle(), projects)
if (parentProject != null) {
String configName = library.getProjectVariant()
if (configName == null) {
configName = "default"
}
prepareLibraryTask.dependsOn parentProject.getPath() + ":assemble${configName.capitalize()}"
}
*/
}
/**
* Handles the library and returns a task to "prepare" the library (ie unarchive it). The task
* will be reused for all projects using the same library.
*
* @param library the library.
* @param project the project
* @return the prepare task.
*/
private PrepareLibraryTask maybeCreatePrepareLibraryTask(
@NonNull LibraryDependencyImpl library,
@NonNull Project project) {
// create proper key for the map. library here contains all the dependencies which
// are not relevant for the task (since the task only extract the aar which does not
// include the dependencies.
// However there is a possible case of a rewritten dependencies (with resolution strategy)
// where the aar here could have different dependencies, in which case we would still
// need the same task.
// So we extract a LibraryBundle (no dependencies) from the LibraryDependencyImpl to
// make the map key that doesn't take into account the dependencies.
LibraryDependencyImpl key = library.getNonTransitiveRepresentation();
PrepareLibraryTask prepareLibraryTask = prepareTaskMap.get(key);
if (prepareLibraryTask == null) {
String bundleName = GUtil.toCamelCase(library.getName().replaceAll("\\:", " "));
prepareLibraryTask = project.getTasks().create(
"prepare" + bundleName + "Library", PrepareLibraryTask.class);
prepareLibraryTask.setDescription("Prepare " + library.getName());
prepareLibraryTask.setBundle(library.getBundle());
prepareLibraryTask.setExplodedDir(library.getBundleFolder());
prepareLibraryTask.setVariantName("");
prepareTaskMap.put(key, prepareLibraryTask);
}
return prepareLibraryTask;
}
private void resolveDependencyForConfig(
@NonNull VariantDependencies variantDeps,
@Nullable VariantDependencies testedVariantDeps,
@Nullable String testedProjectPath,
@NonNull Multimap reverseMap) {
Configuration compileClasspath = variantDeps.getCompileConfiguration();
Configuration packageClasspath = variantDeps.getPackageConfiguration();
// TODO - shouldn't need to do this - fix this in Gradle
ensureConfigured(compileClasspath);
ensureConfigured(packageClasspath);
if (DEBUG_DEPENDENCY) {
System.out.println(">>>>>>>>>>");
System.out.println(
project.getName() + ":" +
compileClasspath.getName() + "/" +
packageClasspath.getName());
}
Set currentUnresolvedDependencies = Sets.newHashSet();
// TODO - defer downloading until required -- This is hard to do as we need the info to build the variant config.
Map> artifacts = Maps.newHashMap();
collectArtifacts(compileClasspath, artifacts);
collectArtifacts(packageClasspath, artifacts);
// --- Handle the external/module dependencies ---
// keep a map of modules already processed so that we don't go through sections of the
// graph that have been seen elsewhere.
Map> foundLibraries = Maps.newHashMap();
Map> foundJars = Maps.newHashMap();
// first get the compile dependencies. Note that in both case the libraries and the
// jars are a graph. The list only contains the first level of dependencies, and
// they themselves contain transitive dependencies (libraries can contain both, jars only
// contains jars)
List compiledAndroidLibraries = Lists.newArrayList();
List compiledJars = Lists.newArrayList();
Set dependencyResultSet = compileClasspath.getIncoming()
.getResolutionResult().getRoot().getDependencies();
for (DependencyResult dependencyResult : dependencyResultSet) {
if (dependencyResult instanceof ResolvedDependencyResult) {
addDependency(
((ResolvedDependencyResult) dependencyResult).getSelected(),
variantDeps,
compiledAndroidLibraries,
compiledJars,
foundLibraries,
foundJars,
artifacts,
reverseMap,
currentUnresolvedDependencies,
testedProjectPath,
Collections.emptyList(),
0);
} else if (dependencyResult instanceof UnresolvedDependencyResult) {
ComponentSelector attempted = ((UnresolvedDependencyResult) dependencyResult).getAttempted();
if (attempted != null) {
currentUnresolvedDependencies.add(attempted.toString());
}
}
}
// then the packaged ones.
List packagedAndroidLibraries = Lists.newArrayList();
List packagedJars = Lists.newArrayList();
dependencyResultSet = packageClasspath.getIncoming()
.getResolutionResult().getRoot().getDependencies();
for (DependencyResult dependencyResult : dependencyResultSet) {
if (dependencyResult instanceof ResolvedDependencyResult) {
addDependency(
((ResolvedDependencyResult) dependencyResult).getSelected(),
variantDeps,
packagedAndroidLibraries,
packagedJars,
foundLibraries,
foundJars,
artifacts,
reverseMap,
currentUnresolvedDependencies,
testedProjectPath,
Collections.emptyList(),
0);
} else if (dependencyResult instanceof UnresolvedDependencyResult) {
ComponentSelector attempted = ((UnresolvedDependencyResult) dependencyResult)
.getAttempted();
if (attempted != null) {
currentUnresolvedDependencies.add(attempted.toString());
}
}
}
// now look through both results.
// 1. Handle the compile and package list of Libraries.
// For Libraries:
// Only library projects can support provided aar.
// However, package(publish)-only are still not supported (they don't make sense).
// For now, provided only dependencies will be kept normally in the compile-graph.
// However we'll want to not include them in the resource merging.
// For Applications:
// All Android libraries must be in both lists.
// ---
// Since we reuse the same instance of LibInfo for identical modules
// we can simply run through each list and look for libs that are in only one.
// While the list of library is actually a graph, it's fine to look only at the
// top level ones since the transitive ones are in the same scope as the direct libraries.
List copyOfPackagedLibs = Lists.newArrayList(packagedAndroidLibraries);
boolean isLibrary = extraModelInfo.isLibrary();
for (LibInfo lib : compiledAndroidLibraries) {
if (!copyOfPackagedLibs.contains(lib)) {
if (isLibrary || lib.isOptional()) {
lib.setIsOptional(true);
} else {
//noinspection ConstantConditions
variantDeps.getChecker().addSyncIssue(extraModelInfo.handleSyncError(
lib.getResolvedCoordinates().toString(),
SyncIssue.TYPE_NON_JAR_PROVIDED_DEP,
String.format(
"Project %s: provided dependencies can only be jars. %s is an Android Library.",
project.getName(), lib.getResolvedCoordinates())));
}
} else {
copyOfPackagedLibs.remove(lib);
}
}
// at this stage copyOfPackagedLibs should be empty, if not, error.
for (LibInfo lib : copyOfPackagedLibs) {
//noinspection ConstantConditions
variantDeps.getChecker().addSyncIssue(extraModelInfo.handleSyncError(
lib.getResolvedCoordinates().toString(),
SyncIssue.TYPE_NON_JAR_PACKAGE_DEP,
String.format(
"Project %s: apk dependencies can only be jars. %s is an Android Library.",
project.getName(), lib.getResolvedCoordinates())));
}
// 2. merge jar dependencies with a single list where items have packaged/compiled properties.
// since we reuse the same instance of a JarInfo for identical modules, we can use an
// Identity set (ie both compiledJars and packagedJars will contain the same instance
// if it's both compiled and packaged)
Set jarInfoSet = Sets.newIdentityHashSet();
// go through the graphs of dependencies (jars and libs) and gather all the transitive
// jar dependencies.
// At the same this we set the compiled/packaged properties.
gatherJarDependencies(jarInfoSet, compiledJars, true /*compiled*/, false /*packaged*/);
gatherJarDependencies(jarInfoSet, packagedJars, false /*compiled*/, true /*packaged*/);
// at this step, we know that libraries have been checked and libraries can only
// be in both compiled and packaged scope.
gatherJarDependenciesFromLibraries(jarInfoSet, compiledAndroidLibraries);
// the final list of JarDependency, created from the list of JarInfo.
List jars = Lists.newArrayListWithCapacity(jarInfoSet.size());
// if this is a test dependencies (ie tested dependencies is non null), override
// packaged attributes for jars that are already in the tested dependencies in order to
// not package them twice (since the VM loads the classes of both APKs in the same
// classpath and refuses to load the same class twice)
if (testedVariantDeps != null) {
List jarDependencies = testedVariantDeps.getJarDependencies();
// gather the tested dependencies
Map testedDeps = Maps.newHashMapWithExpectedSize(jarDependencies.size());
for (JarDependency jar : jarDependencies) {
if (jar.isPackaged()) {
MavenCoordinates coordinates = jar.getResolvedCoordinates();
//noinspection ConstantConditions
testedDeps.put(
computeVersionLessCoordinateKey(coordinates),
coordinates.getVersion());
}
}
// now go through all the test dependencies and check we don't have the same thing.
// Skip the ones that are already in the tested variant, and convert the rest
// to the final immutable instance
for (JarInfo jar : jarInfoSet) {
if (jar.isPackaged()) {
MavenCoordinates coordinates = jar.getResolvedCoordinates();
String testedVersion = testedDeps.get(
computeVersionLessCoordinateKey(coordinates));
if (testedVersion != null) {
// same artifact, skip packaging of the dependency in the test app,
// whether the version is a match or not.
// if the dependency is present in both tested and test artifact,
// verify that they are the same version
if (!testedVersion.equals(coordinates.getVersion())) {
String artifactInfo = coordinates.getGroupId() + ":" + coordinates.getArtifactId();
variantDeps.getChecker().addSyncIssue(extraModelInfo.handleSyncError(
artifactInfo,
SyncIssue.TYPE_MISMATCH_DEP,
String.format(
"Conflict with dependency '%s'. Resolved versions for"
+ " app (%s) and test app (%s) differ. See"
+ " http://g.co/androidstudio/app-test-app-conflict"
+ " for details.",
artifactInfo,
testedVersion,
coordinates.getVersion())));
} else {
logger.info(String.format(
"Removed '%s' from packaging of %s: Already in tested package.",
coordinates,
variantDeps.getName()));
}
} else {
// new artifact, convert it.
jars.add(jar.createJarDependency());
}
}
}
} else {
// just convert all of them to JarDependency
for (JarInfo jarInfo : jarInfoSet) {
jars.add(jarInfo.createJarDependency());
}
}
// --- Handle the local jar dependencies ---
// also need to process local jar files, as they are not processed by the
// resolvedConfiguration result. This only includes the local jar files for this project.
Set localCompiledJars = Sets.newHashSet();
for (Dependency dependency : compileClasspath.getAllDependencies()) {
if (dependency instanceof SelfResolvingDependency &&
!(dependency instanceof ProjectDependency)) {
Set files = ((SelfResolvingDependency) dependency).resolve();
for (File f : files) {
if (DEBUG_DEPENDENCY) {
System.out.println("LOCAL compile: " + f.getName());
}
// only accept local jar, no other types.
if (!f.getName().toLowerCase(Locale.getDefault()).endsWith(DOT_JAR)) {
variantDeps.getChecker().addSyncIssue(extraModelInfo.handleSyncError(
f.getAbsolutePath(),
SyncIssue.TYPE_NON_JAR_LOCAL_DEP,
String.format(
"Project %s: Only Jar-type local dependencies are supported. Cannot handle: %s",
project.getName(), f.getAbsolutePath())));
} else {
localCompiledJars.add(f);
}
}
}
}
Set localPackagedJars = Sets.newHashSet();
for (Dependency dependency : packageClasspath.getAllDependencies()) {
if (dependency instanceof SelfResolvingDependency &&
!(dependency instanceof ProjectDependency)) {
Set files = ((SelfResolvingDependency) dependency).resolve();
for (File f : files) {
if (DEBUG_DEPENDENCY) {
System.out.println("LOCAL package: " + f.getName());
}
// only accept local jar, no other types.
if (!f.getName().toLowerCase(Locale.getDefault()).endsWith(DOT_JAR)) {
variantDeps.getChecker().addSyncIssue(extraModelInfo.handleSyncError(
f.getAbsolutePath(),
SyncIssue.TYPE_NON_JAR_LOCAL_DEP,
String.format(
"Project %s: Only Jar-type local dependencies are supported. Cannot handle: %s",
project.getName(), f.getAbsolutePath())));
} else {
localPackagedJars.add(f);
}
}
}
}
// loop through both the compiled and packaged jar to compute the list
// of jars that are: compile-only, package-only, or both.
Map localJars = Maps.newHashMap();
for (File file : localCompiledJars) {
localJars.put(file, new JarDependency(
file,
true /*compiled*/,
localPackagedJars.contains(file) /*packaged*/,
null /*resolvedCoordinates*/,
null /*projectPath*/));
}
for (File file : localPackagedJars) {
if (!localCompiledJars.contains(file)) {
localJars.put(file, new JarDependency(
file,
false /*compiled*/,
true /*packaged*/,
null /*resolvedCoordinates*/,
null /*projectPath*/));
}
}
if (extraModelInfo.getMode() != STANDARD &&
compileClasspath.getResolvedConfiguration().hasError()) {
for (String dependency : currentUnresolvedDependencies) {
extraModelInfo.handleSyncError(
dependency,
SyncIssue.TYPE_UNRESOLVED_DEPENDENCY,
String.format(
"Unable to resolve dependency '%s'",
dependency));
}
}
// convert the LibInfo in LibraryDependencyImpl and update the reverseMap
// with the converted keys
List libList = convertLibraryInfoIntoDependency(
compiledAndroidLibraries, reverseMap);
if (DEBUG_DEPENDENCY) {
for (LibraryDependency lib : libList) {
System.out.println("LIB: " + lib);
}
for (JarDependency jar : jars) {
System.out.println("JAR: " + jar);
}
for (JarDependency jar : localJars.values()) {
System.out.println("LOCAL-JAR: " + jar);
}
}
variantDeps.addLibraries(libList);
variantDeps.addJars(jars);
variantDeps.addLocalJars(localJars.values());
configureBuild(variantDeps);
if (DEBUG_DEPENDENCY) {
System.out.println(project.getName() + ":" + compileClasspath.getName() + "/" +packageClasspath.getName());
System.out.println("<<<<<<<<<<");
}
}
private static List convertLibraryInfoIntoDependency(
@NonNull List libInfos,
@NonNull Multimap reverseMap) {
List list = Lists.newArrayListWithCapacity(libInfos.size());
// since the LibInfos is a graph and the previous "foundLibraries" map ensure we reuse
// instance where applicable, we'll create a map to keep track of what we have already
// converted.
Map convertedMap = Maps.newIdentityHashMap();
for (LibInfo libInfo : libInfos) {
list.add(convertLibInfo(libInfo, reverseMap, convertedMap));
}
return list;
}
private static LibraryDependencyImpl convertLibInfo(
@NonNull LibInfo libInfo,
@NonNull Multimap reverseMap,
@NonNull Map convertedMap) {
LibraryDependencyImpl convertedLib = convertedMap.get(libInfo);
if (convertedLib == null) {
// first, convert the children.
@SuppressWarnings("unchecked")
List children = (List) (List) libInfo.getDependencies();
List convertedChildren = Lists.newArrayListWithCapacity(children.size());
for (LibInfo child : children) {
convertedChildren.add(convertLibInfo(child, reverseMap, convertedMap));
}
// now convert the libInfo
convertedLib = new LibraryDependencyImpl(
libInfo.getBundle(),
libInfo.getFolder(),
convertedChildren,
libInfo.getName(),
libInfo.getProjectVariant(),
libInfo.getProject(),
libInfo.getRequestedCoordinates(),
libInfo.getResolvedCoordinates(),
libInfo.isOptional());
// add it to the map
convertedMap.put(libInfo, convertedLib);
// and update the reversemap
// get the items associated with the libInfo. Put in a fresh list as the returned
// collection is backed by the content of the map.
Collection values = Lists.newArrayList(reverseMap.get(libInfo));
reverseMap.removeAll(libInfo);
reverseMap.putAll(convertedLib, values);
}
return convertedLib;
}
private static void gatherJarDependencies(
Set outJarInfos,
Collection inJarInfos,
boolean compiled,
boolean packaged) {
for (JarInfo jarInfo : inJarInfos) {
if (!outJarInfos.contains(jarInfo)) {
outJarInfos.add(jarInfo);
}
if (compiled) {
jarInfo.setCompiled(true);
}
if (packaged) {
jarInfo.setPackaged(true);
}
gatherJarDependencies(outJarInfos, jarInfo.getDependencies(), compiled, packaged);
}
}
private static void gatherJarDependenciesFromLibraries(
Set outJarInfos,
Collection inLibraryDependencies) {
for (LibInfo libInfo : inLibraryDependencies) {
gatherJarDependencies(outJarInfos, libInfo.getJarDependencies(),
true, !libInfo.isOptional());
gatherJarDependenciesFromLibraries(
outJarInfos,
libInfo.getLibInfoDependencies());
}
}
private void ensureConfigured(Configuration config) {
for (Dependency dependency : config.getAllDependencies()) {
if (dependency instanceof ProjectDependency) {
ProjectDependency projectDependency = (ProjectDependency) dependency;
project.evaluationDependsOn(projectDependency.getDependencyProject().getPath());
try {
ensureConfigured(projectDependency.getProjectConfiguration());
} catch (Throwable e) {
throw new UnknownProjectException(String.format(
"Cannot evaluate module %s : %s",
projectDependency.getName(), e.getMessage()),
e);
}
}
}
}
private void collectArtifacts(
Configuration configuration,
Map> artifacts) {
Set allArtifacts;
if (extraModelInfo.getMode() != STANDARD) {
allArtifacts = configuration.getResolvedConfiguration().getLenientConfiguration().getArtifacts(
Specs.satisfyAll());
} else {
allArtifacts = configuration.getResolvedConfiguration().getResolvedArtifacts();
}
for (ResolvedArtifact artifact : allArtifacts) {
ModuleVersionIdentifier id = artifact.getModuleVersion().getId();
List moduleArtifacts = artifacts.get(id);
if (moduleArtifacts == null) {
moduleArtifacts = Lists.newArrayList();
artifacts.put(id, moduleArtifacts);
}
if (!moduleArtifacts.contains(artifact)) {
moduleArtifacts.add(artifact);
}
}
}
private static void printIndent(int indent, @NonNull String message) {
for (int i = 0 ; i < indent ; i++) {
System.out.print("\t");
}
System.out.println(message);
}
private void addDependency(
@NonNull ResolvedComponentResult resolvedComponentResult,
@NonNull VariantDependencies configDependencies,
@NonNull Collection outLibraries,
@NonNull List outJars,
@NonNull Map> alreadyFoundLibraries,
@NonNull Map> alreadyFoundJars,
@NonNull Map> artifacts,
@NonNull Multimap reverseMap,
@NonNull Set currentUnresolvedDependencies,
@Nullable String testedProjectPath,
@NonNull List projectChain,
int indent) {
ModuleVersionIdentifier moduleVersion = resolvedComponentResult.getModuleVersion();
if (configDependencies.getChecker().excluded(moduleVersion)) {
return;
}
if (moduleVersion.getName().equals("support-annotations") &&
moduleVersion.getGroup().equals("com.android.support")) {
configDependencies.setAnnotationsPresent(true);
}
List libsForThisModule = alreadyFoundLibraries.get(moduleVersion);
List jarsForThisModule = alreadyFoundJars.get(moduleVersion);
if (libsForThisModule != null) {
if (DEBUG_DEPENDENCY) {
printIndent(indent, "FOUND LIB: " + moduleVersion.getName());
}
outLibraries.addAll(libsForThisModule);
for (LibInfo lib : libsForThisModule) {
reverseMap.put(lib, configDependencies);
}
} else if (jarsForThisModule != null) {
if (DEBUG_DEPENDENCY) {
printIndent(indent, "FOUND JAR: " + moduleVersion.getName());
}
outJars.addAll(jarsForThisModule);
}
else {
if (DEBUG_DEPENDENCY) {
printIndent(indent, "NOT FOUND: " + moduleVersion.getName());
}
// new module! Might be a jar or a library
// get the nested components first.
List nestedLibraries = Lists.newArrayList();
List nestedJars = Lists.newArrayList();
Set dependencies = resolvedComponentResult.getDependencies();
for (DependencyResult dependencyResult : dependencies) {
if (dependencyResult instanceof ResolvedDependencyResult) {
ResolvedComponentResult selected =
((ResolvedDependencyResult) dependencyResult).getSelected();
List newProjectChain = projectChain;
ComponentIdentifier identifier = selected.getId();
if (identifier instanceof ProjectComponentIdentifier) {
String projectPath =
((ProjectComponentIdentifier) identifier).getProjectPath();
int index = projectChain.indexOf(projectPath);
if (index != -1) {
projectChain.add(projectPath);
String path = Joiner
.on(" -> ")
.join(projectChain.subList(index, projectChain.size()));
throw new CircularReferenceException(
"Circular reference between projects: " + path);
}
newProjectChain = Lists.newArrayList();
newProjectChain.addAll(projectChain);
newProjectChain.add(projectPath);
}
addDependency(
selected,
configDependencies,
nestedLibraries,
nestedJars,
alreadyFoundLibraries,
alreadyFoundJars,
artifacts,
reverseMap,
currentUnresolvedDependencies,
testedProjectPath,
newProjectChain,
indent + 1);
} else if (dependencyResult instanceof UnresolvedDependencyResult) {
ComponentSelector attempted = ((UnresolvedDependencyResult) dependencyResult).getAttempted();
if (attempted != null) {
currentUnresolvedDependencies.add(attempted.toString());
}
}
}
if (DEBUG_DEPENDENCY) {
printIndent(indent, "BACK2: " + moduleVersion.getName());
printIndent(indent, "NESTED LIBS: " + nestedLibraries.size());
printIndent(indent, "NESTED JARS: " + nestedJars.size());
}
// now loop on all the artifact for this modules.
List moduleArtifacts = artifacts.get(moduleVersion);
ComponentIdentifier id = resolvedComponentResult.getId();
String gradlePath = (id instanceof ProjectComponentIdentifier) ?
((ProjectComponentIdentifier) id).getProjectPath() : null;
if (moduleArtifacts != null) {
for (ResolvedArtifact artifact : moduleArtifacts) {
if (EXT_LIB_ARCHIVE.equals(artifact.getExtension())) {
if (DEBUG_DEPENDENCY) {
printIndent(indent, "TYPE: AAR");
}
if (libsForThisModule == null) {
libsForThisModule = Lists.newArrayList();
alreadyFoundLibraries.put(moduleVersion, libsForThisModule);
}
String path = computeArtifactPath(moduleVersion, artifact);
String name = computeArtifactName(moduleVersion, artifact);
if (DEBUG_DEPENDENCY) {
printIndent(indent, "NAME: " + name);
printIndent(indent, "PATH: " + path);
}
//def explodedDir = project.file("$project.rootProject.buildDir/${FD_INTERMEDIATES}/exploded-aar/$path")
File explodedDir = project.file(project.getBuildDir() + "/" + FD_INTERMEDIATES + "/exploded-aar/" + path);
@SuppressWarnings("unchecked")
LibInfo libInfo = new LibInfo(
artifact.getFile(),
explodedDir,
(List) (List) nestedLibraries,
nestedJars,
name,
artifact.getClassifier(),
gradlePath,
null /*requestedCoordinates*/,
new MavenCoordinatesImpl(artifact));
libsForThisModule.add(libInfo);
outLibraries.add(libInfo);
reverseMap.put(libInfo, configDependencies);
} else if (EXT_JAR.equals(artifact.getExtension())) {
if (DEBUG_DEPENDENCY) {
printIndent(indent, "TYPE: JAR");
}
// check this jar does not have a dependency on an library, as this would not work.
if (!nestedLibraries.isEmpty()) {
if (testedProjectPath != null && testedProjectPath.equals(gradlePath)) {
// TODO: make sure this is a direct dependency and not a transitive one.
// add nested libs as optional somehow...
for (LibInfo lib : nestedLibraries) {
lib.setIsOptional(true);
}
outLibraries.addAll(nestedLibraries);
} else {
configDependencies.getChecker()
.addSyncIssue(extraModelInfo.handleSyncError(
new MavenCoordinatesImpl(artifact).toString(),
SyncIssue.TYPE_JAR_DEPEND_ON_AAR,
String.format(
"Module '%s' depends on one or more Android Libraries but is a jar",
moduleVersion)));
}
}
if (jarsForThisModule == null) {
jarsForThisModule = Lists.newArrayList();
alreadyFoundJars.put(moduleVersion, jarsForThisModule);
}
JarInfo jarInfo = new JarInfo(
artifact.getFile(),
new MavenCoordinatesImpl(artifact),
gradlePath,
nestedJars);
if (DEBUG_DEPENDENCY) {
printIndent(indent, "JAR-INFO: " + jarInfo.toString());
}
jarsForThisModule.add(jarInfo);
outJars.add(jarInfo);
} else if (EXT_ANDROID_PACKAGE.equals(artifact.getExtension())) {
String name = computeArtifactName(moduleVersion, artifact);
configDependencies.getChecker().addSyncIssue(extraModelInfo.handleSyncError(
name,
SyncIssue.TYPE_DEPENDENCY_IS_APK,
String.format(
"Dependency %s on project %s resolves to an APK archive " +
"which is not supported as a compilation dependency. File: %s",
name, project.getName(), artifact.getFile())));
} else if ("apklib".equals(artifact.getExtension())) {
String name = computeArtifactName(moduleVersion, artifact);
configDependencies.getChecker().addSyncIssue(extraModelInfo.handleSyncError(
name,
SyncIssue.TYPE_DEPENDENCY_IS_APKLIB,
String.format(
"Packaging for dependency %s is 'apklib' and is not supported. " +
"Only 'aar' libraries are supported.", name)));
} else {
String name = computeArtifactName(moduleVersion, artifact);
logger.warning(String.format(
"Unrecognized dependency: '%s' (type: '%s', extension: '%s')",
name, artifact.getType(), artifact.getExtension()));
}
}
}
if (DEBUG_DEPENDENCY) {
printIndent(indent, "DONE: " + moduleVersion.getName());
}
}
}
@NonNull
private String computeArtifactPath(
@NonNull ModuleVersionIdentifier moduleVersion,
@NonNull ResolvedArtifact artifact) {
StringBuilder pathBuilder = new StringBuilder();
pathBuilder.append(normalize(logger, moduleVersion, moduleVersion.getGroup()))
.append('/')
.append(normalize(logger, moduleVersion, moduleVersion.getName()))
.append('/')
.append(normalize(logger, moduleVersion,
moduleVersion.getVersion()));
if (artifact.getClassifier() != null && !artifact.getClassifier().isEmpty()) {
pathBuilder.append('/').append(normalize(logger, moduleVersion,
artifact.getClassifier()));
}
return pathBuilder.toString();
}
@NonNull
private static String computeArtifactName(
@NonNull ModuleVersionIdentifier moduleVersion,
@NonNull ResolvedArtifact artifact) {
StringBuilder nameBuilder = new StringBuilder();
nameBuilder.append(moduleVersion.getGroup())
.append(':')
.append(moduleVersion.getName())
.append(':')
.append(moduleVersion.getVersion());
if (artifact.getClassifier() != null && !artifact.getClassifier().isEmpty()) {
nameBuilder.append(':').append(artifact.getClassifier());
}
return nameBuilder.toString();
}
/**
* Normalize a path to remove all illegal characters for all supported operating systems.
* {@see http://en.wikipedia.org/wiki/Filename#Comparison%5Fof%5Ffile%5Fname%5Flimitations}
*
* @param id the module coordinates that generated this path
* @param path the proposed path name
* @return the normalized path name
*/
static String normalize(ILogger logger, ModuleVersionIdentifier id, String path) {
if (path == null || path.isEmpty()) {
logger.info(String.format(
"When unzipping library '%s:%s:%s, either group, name or version is empty",
id.getGroup(), id.getName(), id.getVersion()));
return path;
}
// list of illegal characters
String normalizedPath = path.replaceAll("[%<>:\"/?*\\\\]", "@");
if (normalizedPath == null || normalizedPath.isEmpty()) {
// if the path normalization failed, return the original path.
logger.info(String.format(
"When unzipping library '%s:%s:%s, the normalized '%s' is empty",
id.getGroup(), id.getName(), id.getVersion(), path));
return path;
}
try {
int pathPointer = normalizedPath.length() - 1;
// do not end your path with either a dot or a space.
String suffix = "";
while (pathPointer >= 0 && (normalizedPath.charAt(pathPointer) == '.'
|| normalizedPath.charAt(pathPointer) == ' ')) {
pathPointer--;
suffix += "@";
}
if (pathPointer < 0) {
throw new RuntimeException(String.format(
"When unzipping library '%s:%s:%s, " +
"the path '%s' cannot be transformed into a valid directory name",
id.getGroup(), id.getName(), id.getVersion(), path));
}
return normalizedPath.substring(0, pathPointer + 1) + suffix;
} catch (Exception e) {
logger.error(e, String.format(
"When unzipping library '%s:%s:%s', " +
"Path normalization failed for input %s",
id.getGroup(), id.getName(), id.getVersion(), path));
return path;
}
}
private void configureBuild(VariantDependencies configurationDependencies) {
addDependsOnTaskInOtherProjects(
project.getTasks().getByName(JavaBasePlugin.BUILD_NEEDED_TASK_NAME), true,
JavaBasePlugin.BUILD_NEEDED_TASK_NAME, "compile");
addDependsOnTaskInOtherProjects(
project.getTasks().getByName(JavaBasePlugin.BUILD_DEPENDENTS_TASK_NAME), false,
JavaBasePlugin.BUILD_DEPENDENTS_TASK_NAME, "compile");
}
@NonNull
public static List getManifestDependencies(
List libraries) {
List list = Lists.newArrayListWithCapacity(libraries.size());
for (LibraryDependency lib : libraries) {
// get the dependencies
List children = getManifestDependencies(lib.getDependencies());
list.add(new ManifestDependencyImpl(lib.getName(), lib.getManifest(), children));
}
return list;
}
/**
* Adds a dependency on tasks with the specified name in other projects. The other projects
* are determined from project lib dependencies using the specified configuration name.
* These may be projects this project depends on or projects that depend on this project
* based on the useDependOn argument.
*
* @param task Task to add dependencies to
* @param useDependedOn if true, add tasks from projects this project depends on, otherwise
* use projects that depend on this one.
* @param otherProjectTaskName name of task in other projects
* @param configurationName name of configuration to use to find the other projects
*/
private static void addDependsOnTaskInOtherProjects(final Task task, boolean useDependedOn,
String otherProjectTaskName,
String configurationName) {
Project project = task.getProject();
final Configuration configuration = project.getConfigurations().getByName(
configurationName);
task.dependsOn(configuration.getTaskDependencyFromProjectDependency(
useDependedOn, otherProjectTaskName));
}
/**
* Compute a version-less key representing the given coordinates.
* @param coordinates the coordinate
* @return the key.
*/
@NonNull
private static String computeVersionLessCoordinateKey(@NonNull MavenCoordinates coordinates) {
StringBuilder sb = new StringBuilder(coordinates.getGroupId());
sb.append(':').append(coordinates.getArtifactId());
if (coordinates.getClassifier() != null) {
sb.append(':').append(coordinates.getClassifier());
}
return sb.toString();
}
}