use of com.android.builder.dependency.LibraryDependency in project atlas by alibaba.
the class TDependencyManager method gatherDependencies.
@NonNull
private DependencyContainer gatherDependencies(@NonNull Configuration configuration, @NonNull final VariantDependencies variantDeps, @NonNull Multimap<AndroidLibrary, Configuration> reverseLibMap, @NonNull Set<String> currentUnresolvedDependencies, @Nullable String testedProjectPath, @NonNull Set<String> artifactSet, @NonNull ScopeType scopeType) {
// collect the artifacts first.
Map<ModuleVersionIdentifier, List<ResolvedArtifact>> artifacts = Maps.newHashMap();
configuration = collectArtifacts(configuration, artifacts);
// keep a map of modules already processed so that we don't go through sections of the
// graph that have been seen elsewhere.
Map<ModuleVersionIdentifier, List<LibraryDependency>> foundLibraries = Maps.newHashMap();
Map<ModuleVersionIdentifier, List<JarDependency>> foundJars = Maps.newHashMap();
// get the graph for the Android and Jar dependencies. This does not include
// local jars.
List<LibraryDependency> libraryDependencies = Lists.newArrayList();
List<JarDependency> jarDependencies = Lists.newArrayList();
Set<? extends DependencyResult> dependencyResultSet = configuration.getIncoming().getResolutionResult().getRoot().getDependencies();
for (DependencyResult dependencyResult : dependencyResultSet) {
if (dependencyResult instanceof ResolvedDependencyResult) {
addDependency(((ResolvedDependencyResult) dependencyResult).getSelected(), variantDeps, configuration, libraryDependencies, jarDependencies, foundLibraries, foundJars, artifacts, reverseLibMap, currentUnresolvedDependencies, testedProjectPath, Collections.emptyList(), artifactSet, scopeType, false, /*forceProvided*/
0);
} else if (dependencyResult instanceof UnresolvedDependencyResult) {
ComponentSelector attempted = ((UnresolvedDependencyResult) dependencyResult).getAttempted();
if (attempted != null) {
currentUnresolvedDependencies.add(attempted.toString());
}
}
}
// 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.
List<JarDependency> localJars = Lists.newArrayList();
for (Dependency dependency : configuration.getAllDependencies()) {
if (dependency instanceof SelfResolvingDependency && !(dependency instanceof ProjectDependency)) {
Set<File> files = ((SelfResolvingDependency) dependency).resolve();
for (File localJarFile : files) {
if (DEBUG_DEPENDENCY) {
System.out.println("LOCAL " + configuration.getName() + ": " + localJarFile.getName());
}
// only accept local jar, no other types.
if (!localJarFile.getName().toLowerCase(Locale.getDefault()).endsWith(DOT_JAR)) {
variantDeps.getChecker().handleIssue(localJarFile.getAbsolutePath(), SyncIssue.TYPE_NON_JAR_LOCAL_DEP, SyncIssue.SEVERITY_ERROR, String.format("Project %s: Only Jar-type local dependencies are supported. Cannot handle: %s", project.getName(), localJarFile.getAbsolutePath()));
} else {
JarDependency localJar;
switch(scopeType) {
case PACKAGE:
localJar = new JarDependency(localJarFile);
artifactSet.add(computeVersionLessCoordinateKey(localJar.getResolvedCoordinates()));
break;
case COMPILE:
MavenCoordinates coord = JarDependency.getCoordForLocalJar(localJarFile);
boolean provided = !artifactSet.contains(computeVersionLessCoordinateKey(coord));
localJar = new JarDependency(localJarFile, ImmutableList.of(), coord, null, provided);
break;
case COMPILE_ONLY:
// if we only have the compile scope, ignore computation of the
// provided bits.
localJar = new JarDependency(localJarFile);
break;
default:
throw new RuntimeException("unsupported ProvidedComputationAction");
}
localJars.add(localJar);
}
}
}
}
return new DependencyContainerImpl(libraryDependencies, jarDependencies, localJars);
}
use of com.android.builder.dependency.LibraryDependency in project atlas by alibaba.
the class TDependencyManager method addDependency.
private void addDependency(@NonNull ResolvedComponentResult resolvedComponentResult, @NonNull VariantDependencies configDependencies, @NonNull Configuration configuration, @NonNull Collection<LibraryDependency> outLibraries, @NonNull List<JarDependency> outJars, @NonNull Map<ModuleVersionIdentifier, List<LibraryDependency>> alreadyFoundLibraries, @NonNull Map<ModuleVersionIdentifier, List<JarDependency>> alreadyFoundJars, @NonNull Map<ModuleVersionIdentifier, List<ResolvedArtifact>> artifacts, @NonNull Multimap<AndroidLibrary, Configuration> reverseLibMap, @NonNull Set<String> currentUnresolvedDependencies, @Nullable String testedProjectPath, @NonNull List<String> projectChain, @NonNull Set<String> artifactSet, @NonNull ScopeType scopeType, boolean forceProvided, int indent) {
ModuleVersionIdentifier moduleVersion = resolvedComponentResult.getModuleVersion();
if (configDependencies.getChecker().checkForExclusion(moduleVersion)) {
return;
}
if (moduleVersion.getName().equals("support-annotations") && moduleVersion.getGroup().equals("com.android.support")) {
configDependencies.setAnnotationsPresent(true);
}
List<LibraryDependency> libsForThisModule = alreadyFoundLibraries.get(moduleVersion);
List<JarDependency> jarsForThisModule = alreadyFoundJars.get(moduleVersion);
if (libsForThisModule != null) {
if (DEBUG_DEPENDENCY) {
printIndent(indent, "FOUND LIB: " + moduleVersion.getName());
}
outLibraries.addAll(libsForThisModule);
for (AndroidLibrary lib : libsForThisModule) {
reverseLibMap.put(lib, configuration);
}
} 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 associated gradlepath
ComponentIdentifier id = resolvedComponentResult.getId();
String gradlePath = (id instanceof ProjectComponentIdentifier) ? ((ProjectComponentIdentifier) id).getProjectPath() : null;
// check if this is a tested app project (via a separate test module).
// In which case, all the dependencies must become provided.
boolean childForceProvided = forceProvided;
if (scopeType == ScopeType.COMPILE && testedProjectPath != null && testedProjectPath.equals(gradlePath)) {
childForceProvided = true;
}
// get the nested components first.
List<LibraryDependency> nestedLibraries = Lists.newArrayList();
List<JarDependency> nestedJars = Lists.newArrayList();
Set<? extends DependencyResult> dependencies = resolvedComponentResult.getDependencies();
for (DependencyResult dependencyResult : dependencies) {
if (dependencyResult instanceof ResolvedDependencyResult) {
ResolvedComponentResult selected = ((ResolvedDependencyResult) dependencyResult).getSelected();
List<String> 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, configuration, nestedLibraries, nestedJars, alreadyFoundLibraries, alreadyFoundJars, artifacts, reverseLibMap, currentUnresolvedDependencies, testedProjectPath, newProjectChain, artifactSet, scopeType, childForceProvided, 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<ResolvedArtifact> moduleArtifacts = artifacts.get(moduleVersion);
if (moduleArtifacts != null) {
for (ResolvedArtifact artifact : moduleArtifacts) {
MavenCoordinates mavenCoordinates = createMavenCoordinates(artifact);
boolean provided = forceProvided;
String coordKey = computeVersionLessCoordinateKey(mavenCoordinates);
if (scopeType == ScopeType.PACKAGE) {
artifactSet.add(coordKey);
} else if (scopeType == ScopeType.COMPILE) {
provided |= !artifactSet.contains(coordKey);
}
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);
}
File explodedDir = project.file(project.getBuildDir() + "/" + FD_INTERMEDIATES + "/exploded-aar/" + path);
@SuppressWarnings("unchecked") LibraryDependency LibraryDependency = new LibraryDependency(artifact.getFile(), explodedDir, nestedLibraries, nestedJars, name, artifact.getClassifier(), gradlePath, null, /*requestedCoordinates*/
mavenCoordinates, provided);
libsForThisModule.add(LibraryDependency);
outLibraries.add(LibraryDependency);
reverseLibMap.put(LibraryDependency, configuration);
} else if (EXT_JAR.equals(artifact.getExtension())) {
if (DEBUG_DEPENDENCY) {
printIndent(indent, "TYPE: JAR");
}
nestedLibraries.clear();
// check this jar does not have a dependency on an library, as this would not work.
if (!nestedLibraries.isEmpty()) {
// can detect this an accept it.
if (testedProjectPath != null && testedProjectPath.equals(gradlePath)) {
// if this is a package scope, then skip the dependencies.
if (scopeType == ScopeType.PACKAGE) {
recursiveLibSkip(nestedLibraries);
} else {
// if it's compile scope, make it optional.
provided = true;
}
outLibraries.addAll(nestedLibraries);
} else {
configDependencies.getChecker().handleIssue(createMavenCoordinates(artifact).toString(), SyncIssue.TYPE_JAR_DEPEND_ON_AAR, SyncIssue.SEVERITY_ERROR, 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);
}
JarDependency jarDependency = new JarDependency(artifact.getFile(), nestedJars, mavenCoordinates, gradlePath, provided);
// app module then skip it.
if (scopeType == ScopeType.PACKAGE && testedProjectPath != null && testedProjectPath.equals(gradlePath)) {
jarDependency.skip();
//noinspection unchecked
recursiveJavaSkip((List<JarDependency>) jarDependency.getDependencies());
}
if (DEBUG_DEPENDENCY) {
printIndent(indent, "JAR-INFO: " + jarDependency.toString());
}
jarsForThisModule.add(jarDependency);
outJars.add(jarDependency);
} else if (EXT_ANDROID_PACKAGE.equals(artifact.getExtension())) {
String name = computeArtifactName(moduleVersion, artifact);
configDependencies.getChecker().handleIssue(name, SyncIssue.TYPE_DEPENDENCY_IS_APK, SyncIssue.SEVERITY_ERROR, 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().handleIssue(name, SyncIssue.TYPE_DEPENDENCY_IS_APKLIB, SyncIssue.SEVERITY_ERROR, String.format("Packaging for dependency %s is 'apklib' and is not supported. " + "Only 'aar' libraries are supported.", name));
} else if ("awb".equals(artifact.getExtension())) {
break;
} else if ("solib".equals(artifact.getExtension())) {
break;
} 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());
}
}
}
use of com.android.builder.dependency.LibraryDependency in project atlas by alibaba.
the class TDependencyManager method maybeCreatePrepareLibraryTask.
/**
* 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 AndroidLibrary library, @NonNull Project project) {
LibraryDependency lib = (LibraryDependency) library;
// 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 AbstractBundleDependency (no dependencies) from the LibraryDependency to
// make the map key that doesn't take into account the dependencies.
String key = library.getResolvedCoordinates().toString();
PrepareLibraryTask prepareLibraryTask = prepareLibTaskMap.get(key);
if (prepareLibraryTask == null) {
String bundleName = GUtil.toCamelCase(lib.getName().replaceAll("\\:", " "));
prepareLibraryTask = project.getTasks().create("prepare" + bundleName + "Library", PrepareLibraryTask.class);
prepareLibraryTask.setDescription("Prepare " + lib.getName());
prepareLibraryTask.setBundle(lib.getBundle());
prepareLibraryTask.setExplodedDir(lib.getFolder());
prepareLibraryTask.setVariantName("");
prepareLibTaskMap.put(key, prepareLibraryTask);
}
return prepareLibraryTask;
}
use of com.android.builder.dependency.LibraryDependency in project atlas by alibaba.
the class AtlasLibTaskManager method createAwbBundle.
private AwbBundle createAwbBundle(LibVariantContext libVariantContext, String variantName) throws IOException {
AndroidDependencyTree libDependencyTree = AtlasBuildContext.libDependencyTrees.get(variantName);
if (null == libDependencyTree) {
dependencyManager.resolveDependencyForConfig(libVariantContext.getVariantDependency(), true);
libDependencyTree = AtlasBuildContext.libDependencyTrees.get(variantName);
}
String groupName = (String) project.getGroup();
String name = "";
String version = (String) project.getVersion();
if (project.hasProperty("archivesBaseName")) {
name = (String) project.getProperties().get("archivesBaseName");
} else {
name = project.getName();
}
File explodedDir = project.file(project.getBuildDir().getAbsolutePath() + "/" + FD_INTERMEDIATES + "/exploded-awb/" + computeArtifactPath(groupName, name, version));
FileUtils.deleteDirectory(explodedDir);
AwbBundle awbBundle = new AwbBundle(libVariantContext.getBundleTask().getArchivePath(), explodedDir, new ArrayList<LibraryDependency>(), new ArrayList<JarDependency>(), groupName + ":" + name, libVariantContext.getVariantName(), project.getPath(), null, new MavenCoordinatesImpl(groupName, name, version));
new AwoDependency(libVariantContext).parseDependency(libDependencyTree, awbBundle);
return awbBundle;
}
use of com.android.builder.dependency.LibraryDependency in project atlas by alibaba.
the class DependencyConvertUtils method toAarBundle.
/**
* 将依赖类型转换为LibraryDependencyImpl
*
* @param resolvedDependencyInfo
* @return
*/
private static AarBundle toAarBundle(ResolvedDependencyInfo resolvedDependencyInfo, boolean containChild) {
assertType(Type.AAR, resolvedDependencyInfo);
List<LibraryDependency> dependencies = Lists.newArrayList();
Collection<JarDependency> jarDependencies = Lists.newArrayList();
List<SoLibrary> soLibraries = Lists.newArrayList();
if (containChild) {
collectChildren(resolvedDependencyInfo, dependencies, jarDependencies, soLibraries);
}
AarBundle aarBundle = new AarBundle(resolvedDependencyInfo.getResolvedArtifact().getFile(), resolvedDependencyInfo.getExplodedDir(), dependencies, jarDependencies, resolvedDependencyInfo.getGroup() + "-" + resolvedDependencyInfo.getName(), resolvedDependencyInfo.getVariantName(), resolvedDependencyInfo.getGradlePath(), null, convert(resolvedDependencyInfo.getResolvedArtifact()));
aarBundle.setSoLibraries(soLibraries);
return aarBundle;
}
Aggregations