public boolean hasNonOptionalLibraries() { // non optional libraries mean that there is some libraries in the package // dependencies // TODO this will go away when the user of this is removed. return packageGraph.getDependencies().stream() .anyMatch(node -> node.getNodeType() == DependencyNode.NodeType.ANDROID); }
private List<AndroidDependency> computeFlatLibraryList() { List<AndroidDependency> flatAndroidLibraries = Lists.newArrayList(); final List<DependencyNode> androidNodes = atomNode.getDependencies().stream() .filter(node -> node.getNodeType() == DependencyNode.NodeType.ANDROID) .collect(Collectors.toList()); computeFlatLibraryList(androidNodes, flatAndroidLibraries); return flatAndroidLibraries; }
private static boolean containsDirectDependency( @NonNull List<DependencyNode> dependencies, @NonNull NodeType nodeType) { return dependencies.stream().anyMatch( dependencyNode -> dependencyNode.getNodeType() == nodeType); }
@Nullable private AtomDependency getBaseAtom() { // search for the base atom. This is normally the single atom from which all other // depends. // first collect the direct level atom dependencies, since only atom can depend on atoms, // looking at other types on the direct dependencies is not needed. List<DependencyNode> atomList = dependencies.stream() .filter(node -> node.getNodeType() == NodeType.ATOM) .collect(Collectors.toList()); if (atomList.isEmpty()) { return null; } List<AtomDependency> baseAtoms = Lists.newArrayList(); collectAtomLeaves(atomList, baseAtoms); // TODO: Change this to a sync error. assert baseAtoms.size() == 1; return baseAtoms.get(0); }
private void computeFlatLibraryList( List<DependencyNode> androidDependencies, List<AndroidDependency> outFlatAndroidDependencies) { for (DependencyNode node : androidDependencies) { AndroidDependency androidDependency = (AndroidDependency) dependencyMap .get(node.getAddress()); if (outFlatAndroidDependencies.contains(androidDependency)) { continue; } final List<DependencyNode> androidNodes = node.getDependencies().stream() .filter(n -> n.getNodeType() == DependencyNode.NodeType.ANDROID) .collect(Collectors.toList()); computeFlatLibraryList(androidNodes, outFlatAndroidDependencies); outFlatAndroidDependencies.add(androidDependency); } } }
private void collectAtomLeaves(@NonNull Collection<DependencyNode> nodes, @NonNull List<AtomDependency> outLeaves) { for (DependencyNode node : nodes) { // collect the atom-only dependencies List<DependencyNode> atomList = node.getDependencies().stream() .filter(n -> n.getNodeType() == NodeType.ATOM) .collect(Collectors.toList()); if (atomList.isEmpty()) { outLeaves.add((AtomDependency) dependencyMap.get(node.getAddress())); } else { collectAtomLeaves(atomList, outLeaves); } } }
private static void addDependencyToSet( @NonNull Dependency dependency, @NonNull DependencyNode node, @NonNull Set<Dependency> outFlatDependencies, @Nullable List<JavaDependency> testedLocalJars) { //noinspection SuspiciousMethodCalls if (testedLocalJars == null || node.getNodeType() != NodeType.JAVA || !testedLocalJars.contains(dependency)) { outFlatDependencies.add(dependency); } } }
@NonNull private List<AndroidLibrary> cloneAndroidLibraries( @NonNull List<DependencyNode> nodes) { List<AndroidLibrary> results = Lists.newArrayListWithCapacity(nodes.size()); for (DependencyNode node : nodes) { if (node.getNodeType() != NodeType.ANDROID) { continue; } AndroidDependency androidDependency = (AndroidDependency) dependencyContainer.getDependencyMap().get(node.getAddress()); AndroidLibrary lib = sLibCache.get(factory.create(androidDependency, node)); if (lib != null) { results.add(lib); } } // resize to right size return Lists.newArrayList(results); }
private AndroidTask<PackageAtom> createAtomPackagingTasks( @NonNull TaskFactory tasks, @NonNull VariantScope variantScope) { // Get the single output. final VariantOutputScope variantOutputScope = variantScope.getVariantData().getMainOutput().getScope(); final DependencyContainer packageDependencies = variantScope.getVariantConfiguration() .getPackageDependencies(); ImmutableList<DependencyNode> directNodes = packageDependencies.getDependencies(); // filter this to only the direct atoms. List<DependencyNode> atomNodes = directNodes.stream() .filter(node -> node.getNodeType() == DependencyNode.NodeType.ATOM) .collect(Collectors.toList()); AndroidTask<PackageAtom> previousPackagingTask = null; final ArrayList<AtomDependency> previousAtoms = new ArrayList<>(); for (DependencyNode atomNode : atomNodes) { previousPackagingTask = createAtomPackagingTasks( tasks, variantOutputScope, atomNode, packageDependencies.getDependencyMap(), previousAtoms, previousPackagingTask); } return previousPackagingTask; }
@NonNull private static AndroidLibraryImpl createSerializableAndroidLibrary( @NonNull DependencyItem<AndroidDependency> dependencyItem) { AndroidDependency androidDependency = dependencyItem.dependency; DependencyNode dependencyNode = dependencyItem.getOther(); List<DependencyNode> deps = dependencyNode.getDependencies(); List<AndroidLibrary> clonedDeps = Lists.newArrayListWithCapacity(deps.size()); for (DependencyNode childNode : deps) { if (childNode.getNodeType() != NodeType.ANDROID) { continue; } AndroidDependency childDependency = (AndroidDependency) dependencyItem.getMap().get(childNode.getAddress()); DependencyItem<AndroidDependency> childDepItem = dependencyItem .create(childDependency, childNode); AndroidLibrary clonedLib = sLibCache.get(childDepItem); if (clonedLib != null) { clonedDeps.add(clonedLib); } } // compute local jar even if the bundle isn't exploded. Collection<File> localJarOverride = findLocalJar(androidDependency); return new AndroidLibraryImpl( androidDependency, dependencyItem.isProvided(), dependencyItem.isSkipped(), clonedDeps, ImmutableList.of(), localJarOverride); }
private void cloneJavaLibraries( @NonNull List<DependencyNode> nodes, @NonNull Set<JavaLibrary> outLibraries) { for (DependencyNode node : nodes) { Dependency dependency = dependencyContainer.getDependencyMap().get(node.getAddress()); if (dependency.getProjectPath() != null) { continue; } switch (node.getNodeType()) { case JAVA: JavaDependency javaDep = (JavaDependency) dependency; outLibraries.add(sJarCache.get(factory.create(javaDep))); // intended fall-through case ANDROID: // dont convert but go recursively for potential java dependencies. cloneJavaLibraries(node.getDependencies(), outLibraries); break; case ATOM: // do nothing break; } } }
.filter(node -> node.getNodeType() == DependencyNode.NodeType.ATOM) .collect(Collectors.toList()); for (DependencyNode atom : childrenAtoms) {