Search in sources :

Example 1 with LibraryDependency

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);
}
Also used : UnresolvedDependencyResult(org.gradle.api.artifacts.result.UnresolvedDependencyResult) JarDependency(com.android.builder.dependency.JarDependency) SelfResolvingDependency(org.gradle.api.artifacts.SelfResolvingDependency) ComponentSelector(org.gradle.api.artifacts.component.ComponentSelector) DependencyResult(org.gradle.api.artifacts.result.DependencyResult) UnresolvedDependencyResult(org.gradle.api.artifacts.result.UnresolvedDependencyResult) ResolvedDependencyResult(org.gradle.api.artifacts.result.ResolvedDependencyResult) DependencyContainerImpl(com.android.builder.dependency.DependencyContainerImpl) LibraryDependency(com.android.builder.dependency.LibraryDependency) UnresolvedDependency(org.gradle.api.artifacts.UnresolvedDependency) SelfResolvingDependency(org.gradle.api.artifacts.SelfResolvingDependency) ProjectDependency(org.gradle.api.artifacts.ProjectDependency) JarDependency(com.android.builder.dependency.JarDependency) Dependency(org.gradle.api.artifacts.Dependency) ProjectDependency(org.gradle.api.artifacts.ProjectDependency) ModuleVersionIdentifier(org.gradle.api.artifacts.ModuleVersionIdentifier) MavenCoordinates(com.android.builder.model.MavenCoordinates) LibraryDependency(com.android.builder.dependency.LibraryDependency) List(java.util.List) ArrayList(java.util.ArrayList) ImmutableList(com.google.common.collect.ImmutableList) ResolvedDependencyResult(org.gradle.api.artifacts.result.ResolvedDependencyResult) File(java.io.File) NonNull(com.android.annotations.NonNull)

Example 2 with LibraryDependency

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());
        }
    }
}
Also used : UnresolvedDependencyResult(org.gradle.api.artifacts.result.UnresolvedDependencyResult) JarDependency(com.android.builder.dependency.JarDependency) ResolvedArtifact(org.gradle.api.artifacts.ResolvedArtifact) Set(java.util.Set) HashSet(java.util.HashSet) ComponentSelector(org.gradle.api.artifacts.component.ComponentSelector) DependencyResult(org.gradle.api.artifacts.result.DependencyResult) UnresolvedDependencyResult(org.gradle.api.artifacts.result.UnresolvedDependencyResult) ResolvedDependencyResult(org.gradle.api.artifacts.result.ResolvedDependencyResult) ProjectComponentIdentifier(org.gradle.api.artifacts.component.ProjectComponentIdentifier) ComponentIdentifier(org.gradle.api.artifacts.component.ComponentIdentifier) CircularReferenceException(org.gradle.api.CircularReferenceException) ModuleVersionIdentifier(org.gradle.api.artifacts.ModuleVersionIdentifier) MavenCoordinates(com.android.builder.model.MavenCoordinates) AndroidLibrary(com.android.builder.model.AndroidLibrary) LibraryDependency(com.android.builder.dependency.LibraryDependency) List(java.util.List) ArrayList(java.util.ArrayList) ImmutableList(com.google.common.collect.ImmutableList) ResolvedComponentResult(org.gradle.api.artifacts.result.ResolvedComponentResult) ProjectComponentIdentifier(org.gradle.api.artifacts.component.ProjectComponentIdentifier) ResolvedDependencyResult(org.gradle.api.artifacts.result.ResolvedDependencyResult) File(java.io.File)

Example 3 with LibraryDependency

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;
}
Also used : LibraryDependency(com.android.builder.dependency.LibraryDependency) PrepareLibraryTask(com.android.build.gradle.internal.tasks.PrepareLibraryTask)

Example 4 with LibraryDependency

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;
}
Also used : JarDependency(com.android.builder.dependency.JarDependency) MavenCoordinatesImpl(com.android.builder.dependency.MavenCoordinatesImpl) AwoDependency(com.taobao.android.builder.tasks.awo.utils.AwoDependency) LibraryDependency(com.android.builder.dependency.LibraryDependency) AndroidDependencyTree(com.taobao.android.builder.dependency.AndroidDependencyTree) AwbBundle(com.taobao.android.builder.dependency.model.AwbBundle) File(java.io.File)

Example 5 with LibraryDependency

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;
}
Also used : JarDependency(com.android.builder.dependency.JarDependency) LibraryDependency(com.android.builder.dependency.LibraryDependency) AarBundle(com.taobao.android.builder.dependency.model.AarBundle) SoLibrary(com.taobao.android.builder.dependency.model.SoLibrary)

Aggregations

LibraryDependency (com.android.builder.dependency.LibraryDependency)7 JarDependency (com.android.builder.dependency.JarDependency)6 File (java.io.File)3 MavenCoordinates (com.android.builder.model.MavenCoordinates)2 ImmutableList (com.google.common.collect.ImmutableList)2 AwbBundle (com.taobao.android.builder.dependency.model.AwbBundle)2 SoLibrary (com.taobao.android.builder.dependency.model.SoLibrary)2 ArrayList (java.util.ArrayList)2 List (java.util.List)2 ModuleVersionIdentifier (org.gradle.api.artifacts.ModuleVersionIdentifier)2 ComponentSelector (org.gradle.api.artifacts.component.ComponentSelector)2 DependencyResult (org.gradle.api.artifacts.result.DependencyResult)2 ResolvedDependencyResult (org.gradle.api.artifacts.result.ResolvedDependencyResult)2 UnresolvedDependencyResult (org.gradle.api.artifacts.result.UnresolvedDependencyResult)2 NonNull (com.android.annotations.NonNull)1 PrepareLibraryTask (com.android.build.gradle.internal.tasks.PrepareLibraryTask)1 DependencyContainerImpl (com.android.builder.dependency.DependencyContainerImpl)1 MavenCoordinatesImpl (com.android.builder.dependency.MavenCoordinatesImpl)1 AndroidLibrary (com.android.builder.model.AndroidLibrary)1 AndroidDependencyTree (com.taobao.android.builder.dependency.AndroidDependencyTree)1