Example usage for org.apache.maven.project MavenProject getArtifact

List of usage examples for org.apache.maven.project MavenProject getArtifact

  1. HOME
  2. Java
  3. org.apache.maven
  4. org.apache.maven.project.*
  5. MavenProject
  6. getArtifact

Introduction

In this page you can find the example usage for org.apache.maven.project MavenProject getArtifact.

Prototype

public Artifact getArtifact()

Source Link

Usage

From source file:com.github.zhve.ideaplugin.ArtifactDependencyResolver.java

License:Apache License

public Map<MavenProject, DependencyData> findDependencies(List<MavenProject> reactorProjects)
        throws InvalidVersionSpecificationException {
    // collect ids
    Set<Artifact> reactorArtifacts = new HashSet<Artifact>();
    log.info("");
    log.info("Reactor Artifacts");
    log.info("");
    for (MavenProject reactorProject : reactorProjects) {
        log.info(reactorProject.getArtifact().getId());
        reactorArtifacts.add(reactorProject.getArtifact());
    }//  w  w w .j  ava2  s.c  o  m

    // Resolve reactor dependencies
    Map<MavenProject, DependencyData> dependencyDataMap = findDependencies(log, artifactFactory,
            reactorArtifacts, reactorProjects);

    // Resolve remote dependency transitively
    Map<MavenProject, DependencyData> dependencyDataNewMap = new LinkedHashMap<MavenProject, DependencyData>();
    for (Map.Entry<MavenProject, DependencyData> entry : dependencyDataMap.entrySet()) {
        MavenProject project = entry.getKey();
        log.info("");
        log.info("Resolve Transitively: " + project.getArtifact().getId());
        log.info("");
        DependencyData dependencyData = entry.getValue();
        List<Artifact> remoteData = new ArrayList<Artifact>();
        List<Artifact> reactorData = new ArrayList<Artifact>(dependencyData.getReactorList());
        List<Artifact> remoteUnresolvedList = new ArrayList<Artifact>(dependencyData.getRemoteList());
        tryResolve(project, reactorArtifacts, remoteData, reactorData, remoteUnresolvedList);
        dependencyDataNewMap.put(project, new DependencyData(remoteData, reactorData));
    }

    return dependencyDataNewMap;
}

From source file:com.github.zhve.ideaplugin.ArtifactDependencyResolver.java

License:Apache License

/**
 * Transitive resolve all dependencies for reactor projects
 *
 * @param artifactFactory standard Maven's factory to create artifacts
 * @param reactorArtifacts reactor artifacts
 * @param reactorProjects reactor projects
 * @return dependency map: reactor project -> dependency data
 * @throws InvalidVersionSpecificationException error
 *///  w w  w . j  av  a  2 s .c  o  m
private Map<MavenProject, DependencyData> findDependencies(Log log, ArtifactFactory artifactFactory,
        Set<Artifact> reactorArtifacts, List<MavenProject> reactorProjects)
        throws InvalidVersionSpecificationException {
    // artifact -> all transitive dependencies
    Map<Artifact, DependencyData> dependencyMap = new HashMap<Artifact, DependencyData>();
    log.info("");
    log.info("Detect Dependencies");
    for (MavenProject project : reactorProjects) {
        log.info("");
        log.info(project.getId());
        List<Artifact> remoteData = new ArrayList<Artifact>();
        List<Artifact> reactorData = new ArrayList<Artifact>();
        for (Object object : project.getDependencies()) {
            Dependency dependency = (Dependency) object;
            Artifact dependencyArtifact = toDependencyArtifact(artifactFactory, dependency);
            boolean reactor = reactorArtifacts.contains(dependencyArtifact);
            String id = dependencyArtifact.getId() + ":" + dependencyArtifact.getScope();
            if ("jar".equals(dependencyArtifact.getType())) {
                if (reactor) {
                    log.info("R " + id);
                    reactorData.add(dependencyArtifact);
                } else {
                    log.info("  " + id);
                    remoteData.add(dependencyArtifact);
                }
            } else {
                log.info("O " + id + " (type=" + dependencyArtifact.getType() + ")");
            }
        }

        // save dependency data for project
        dependencyMap.put(project.getArtifact(), new DependencyData(remoteData, reactorData));
    }

    log.info("");
    log.info("Resolve Dependencies");
    Map<MavenProject, DependencyData> result = new LinkedHashMap<MavenProject, DependencyData>();
    for (MavenProject project : reactorProjects) {
        log.info("");
        log.info(project.getId());
        Map<String, Artifact> reactorData = new LinkedHashMap<String, Artifact>();
        Map<String, Artifact> remoteData = new LinkedHashMap<String, Artifact>();

        Queue<Artifact> queue = new LinkedList<Artifact>();
        queue.add(project.getArtifact());
        while (!queue.isEmpty()) {
            Artifact artifact = queue.poll();
            log.info("# " + artifact.getId() + ":" + artifact.getScope());
            DependencyData artifactDependencyData = dependencyMap.get(artifact);

            // analyze all remote dependencies for given level
            for (Artifact dependency : artifactDependencyData.getRemoteList()) {
                String dependencyConflictId = dependency.getDependencyConflictId();
                Artifact dependencyArtifact = toDependencyArtifact(artifactFactory, dependency,
                        artifact.getScope());
                if (dependencyArtifact != null) {
                    String fullName = dependencyArtifact.getId() + ":" + dependencyArtifact.getScope();
                    Artifact prevArtifact = remoteData.get(dependencyConflictId);
                    if (prevArtifact == null) {
                        // new remote dependency
                        log.info("  " + fullName);
                        remoteData.put(dependencyConflictId, dependencyArtifact);
                    } else {
                        // we have already added this remote dependency
                        if (prevArtifact.getId().equals(dependencyArtifact.getId())) {
                            log.info("D " + fullName);
                        } else {
                            log.info("C " + fullName);
                            log.info("  " + project.getArtifact().getId());
                            log.info("  " + "+-" + prevArtifact.getId() + ":" + prevArtifact.getScope());
                            log.info("  " + "+-" + artifact.getId() + ":" + artifact.getScope());
                            log.info("  " + "  \\-" + fullName);
                        }
                    }
                } else {
                    log.info("O " + dependency.getId() + ":" + dependency.getScope() + " (inherit="
                            + artifact.getId() + ":" + artifact.getScope() + ")");
                }
            }

            // analyze all reactor dependencies for given level
            for (Artifact dependency : artifactDependencyData.getReactorList()) {
                String dependencyConflictId = dependency.getDependencyConflictId();
                Artifact dependencyArtifact = toDependencyArtifact(artifactFactory, dependency,
                        artifact.getScope());
                if (dependencyArtifact != null) {
                    String fullName = dependencyArtifact.getId() + ":" + dependencyArtifact.getScope();
                    Artifact prevArtifact = reactorData.get(dependencyConflictId);
                    if (prevArtifact == null) {
                        // new reactor dependency
                        log.info("R " + fullName);
                        reactorData.put(dependencyConflictId, dependencyArtifact);
                        // go deep
                        queue.add(dependencyArtifact);
                    } else {
                        // we have already added this remote dependency
                        if (prevArtifact.getId().equals(dependencyArtifact.getId())) {
                            log.info("D " + fullName);
                        } else {
                            log.info("C " + fullName);
                            log.info("  " + project.getArtifact().getId());
                            log.info("  " + "+-" + prevArtifact.getId() + ":" + prevArtifact.getScope());
                            log.info("  " + "+-" + artifact.getId() + ":" + artifact.getScope());
                            log.info("  " + "  \\-" + fullName);
                        }
                    }
                } else {
                    log.info("O " + dependency.getId() + ":" + dependency.getScope() + " (inherit="
                            + artifact.getId() + ":" + artifact.getScope() + ")");
                }
            }
        }
        result.put(project, new DependencyData(new ArrayList<Artifact>(remoteData.values()),
                new ArrayList<Artifact>(reactorData.values())));
    }
    return result;
}

From source file:com.github.zhve.ideaplugin.ArtifactDependencyResolver.java

License:Apache License

private void tryResolve(MavenProject project, Set<Artifact> reactorArtifacts, List<Artifact> remoteData,
        List<Artifact> reactorData, List<Artifact> remoteUnresolvedList) {
    // search/*  w ww .ja  va 2s .c o  m*/
    ArtifactResolutionResult resolutionResult;
    log.info("Before:");
    for (Artifact a : remoteUnresolvedList)
        log.info("  " + a.getId() + ":" + a.getScope());
    log.info("");
    try {
        resolutionResult = artifactResolver.resolveTransitively(
                new LinkedHashSet<Artifact>(remoteUnresolvedList), project.getArtifact(),
                project.getManagedVersionMap(), localRepository, project.getRemoteArtifactRepositories(),
                artifactMetadataSource);
        // save search result
        log.info("After:");
        for (Object resolutionNode : resolutionResult.getArtifactResolutionNodes()) {
            Artifact art = ((ResolutionNode) resolutionNode).getArtifact();
            if (reactorArtifacts.contains(art)) {
                if (!reactorData.contains(art)) {
                    reactorData.add(art);
                    log.info("R " + art.getId() + ":" + art.getScope());
                } else {
                    log.info("D " + art.getId() + ":" + art.getScope());
                }
            } else {
                log.info("  " + art.getId() + ":" + art.getScope());
                remoteData.add(art);
            }
        }
        // clear unresolved
        remoteUnresolvedList.clear();
    } catch (ArtifactResolutionException e) {
        log.error(e.getMessage());
        remoteData.addAll(remoteUnresolvedList);
    } catch (ArtifactNotFoundException e) {
        throw new RuntimeException(e.getMessage(), e);
    }
}

From source file:com.github.zhve.ideaplugin.ArtifactHolder.java

License:Apache License

public ArtifactHolder(Log log, ArtifactDependencyResolver resolver, List<MavenProject> reactorProjects)
        throws MojoExecutionException {
    // collect//from   w w w .  java  2s. c o  m
    reactorArtifacts = new HashSet<Artifact>();
    for (MavenProject reactorProject : reactorProjects)
        reactorArtifacts.add(reactorProject.getArtifact());
    reactorArtifacts = Collections.unmodifiableSet(reactorArtifacts);

    // Resolve
    Map<MavenProject, ArtifactDependencyResolver.DependencyData> dependencyDataNewMap;
    try {
        dependencyDataNewMap = resolver.findDependencies(reactorProjects);
    } catch (InvalidVersionSpecificationException e) {
        throw new MojoExecutionException(e.getMessage(), e);
    }

    // Find common dependencies
    Set<Artifact> fullSet = new HashSet<Artifact>();
    for (ArtifactDependencyResolver.DependencyData data : dependencyDataNewMap.values())
        fullSet.addAll(data.getRemoteList());

    // Save allDependencies
    allDependencies = new ArrayList<Artifact>(fullSet);
    Collections.sort(allDependencies, ArtifactComparator.INSTANCE);
    allDependencies = Collections.unmodifiableList(allDependencies);

    log.info("");
    log.info("Full Dependencies");
    log.info("");
    for (Artifact artifact : allDependencies)
        log.info("  " + artifact.getId());

    // Save dependencyMap

    this.dependencyMap = new HashMap<MavenProject, List<Artifact>>();
    for (Map.Entry<MavenProject, ArtifactDependencyResolver.DependencyData> entry : dependencyDataNewMap
            .entrySet()) {
        MavenProject project = entry.getKey();
        // Remove commonSet from dependencies
        List<Artifact> remoteList = new ArrayList<Artifact>(entry.getValue().getRemoteList());
        List<Artifact> reactorList = new ArrayList<Artifact>(entry.getValue().getReactorList());
        Collections.sort(remoteList, ArtifactComparator.INSTANCE);
        Collections.sort(reactorList, ArtifactComparator.INSTANCE);
        List<Artifact> artifacts = new ArrayList<Artifact>();
        artifacts.addAll(reactorList);
        artifacts.addAll(remoteList);
        this.dependencyMap.put(project, Collections.unmodifiableList(artifacts));
    }
}

From source file:com.google.code.play.PlayDependenciesMojo.java

License:Apache License

protected void internalExecute() throws MojoExecutionException, MojoFailureException, IOException {
    if (dependenciesSkip) {
        getLog().info("Dependencies extraction skipped");
        return;//w  ww . j a v a2s .  c  om
    }

    File baseDir = project.getBasedir();

    try {
        if (dependenciesClean) {
            if (!dependenciesSkipJars) {
                FileUtils.deleteDirectory(new File(baseDir, "lib"));
            }
            FileUtils.deleteDirectory(new File(baseDir, "modules"));
        }

        Set<?> projectArtifacts = project.getArtifacts();

        Set<Artifact> excludedArtifacts = new HashSet<Artifact>();
        Artifact playSeleniumJunit4Artifact = getDependencyArtifact(projectArtifacts,
                "com.google.code.maven-play-plugin", "play-selenium-junit4", "jar");
        if (playSeleniumJunit4Artifact != null) {
            excludedArtifacts.addAll(getDependencyArtifacts(projectArtifacts, playSeleniumJunit4Artifact));
        }

        Set<Artifact> filteredArtifacts = new HashSet<Artifact>(); // TODO-rename to filteredClassPathArtifacts
        for (Iterator<?> iter = projectArtifacts.iterator(); iter.hasNext();) {
            Artifact artifact = (Artifact) iter.next();
            if (artifact.getArtifactHandler().isAddedToClasspath()
                    && !Artifact.SCOPE_PROVIDED.equals(artifact.getScope())
                    && !excludedArtifacts.contains(artifact)) {
                // TODO-add checkPotentialReactorProblem( artifact );
                filteredArtifacts.add(artifact);
            }
        }

        // modules/*/lib
        File modulesDir = new File(baseDir, "modules");

        Map<String, Artifact> moduleArtifacts = findAllModuleArtifacts(true);
        for (Map.Entry<String, Artifact> moduleArtifactEntry : moduleArtifacts.entrySet()) {
            String moduleName = moduleArtifactEntry.getKey();
            Artifact moduleZipArtifact = moduleArtifactEntry.getValue();

            if (!Artifact.SCOPE_PROVIDED.equals(moduleZipArtifact.getScope())) {
                boolean foundInReactor = false;
                for (MavenProject reactorProject : reactorProjects) {
                    if (reactorProject != project) {
                        Artifact reactorProjectArtifact = reactorProject.getArtifact();

                        if (reactorProjectArtifact.getGroupId().equals(moduleZipArtifact.getGroupId())
                                && reactorProjectArtifact.getArtifactId()
                                        .equals(moduleZipArtifact.getArtifactId())
                                && reactorProjectArtifact.getVersion().equals(moduleZipArtifact.getVersion())) {
                            File reactorProjectBasedir = reactorProject.getBasedir();
                            String relativePath = PathTool.getRelativeFilePath(baseDir.getAbsolutePath(),
                                    reactorProjectBasedir.getAbsolutePath());
                            File moduleLinkFile = new File(modulesDir,
                                    String.format("%s-%s", reactorProject.getArtifact().getArtifactId(),
                                            reactorProject.getArtifact().getVersion()));
                            if (moduleLinkFile.isDirectory()) {
                                getLog().info(String.format("Deleting \"%s\" directory", moduleLinkFile)); // TODO-more descriptive message
                                FileUtils.deleteDirectory(moduleLinkFile);
                            } else if (!moduleLinkFile.getParentFile().exists()) {
                                if (!moduleLinkFile.getParentFile().mkdirs()) {
                                    throw new IOException(String.format("Cannot create \"%s\" directory",
                                            moduleLinkFile.getParentFile().getCanonicalPath()));
                                }
                            }

                            if (dependenciesForceCopy) {
                                org.apache.commons.io.FileUtils.copyDirectory(reactorProjectBasedir,
                                        moduleLinkFile);
                            } else {
                                writeToFile(moduleLinkFile, relativePath);
                            }
                            buildContext.refresh(moduleLinkFile);
                            foundInReactor = true;
                            getLog().info(String.format(
                                    "Play! module dependency found in reactor, relative path is \"%s\"",
                                    relativePath));
                            break;
                        }
                    }
                }

                if (foundInReactor) {
                    continue;
                }
                //already not needed checkPotentialReactorProblem( moduleZipArtifact );

                File moduleZipFile = moduleZipArtifact.getFile();
                String moduleSubDir = String.format("%s-%s", moduleName, moduleZipArtifact.getBaseVersion());
                File moduleDirectory = new File(modulesDir, moduleSubDir);
                createModuleDirectory(moduleDirectory,
                        dependenciesOverwrite || moduleDirectory.lastModified() < moduleZipFile.lastModified());
                if (moduleDirectory.list().length == 0) {
                    UnArchiver zipUnArchiver = archiverManager.getUnArchiver("zip");
                    zipUnArchiver.setSourceFile(moduleZipFile);
                    zipUnArchiver.setDestDirectory(moduleDirectory);
                    zipUnArchiver.setOverwrite(false/* ??true */ );
                    zipUnArchiver.extract();
                    moduleDirectory.setLastModified(System.currentTimeMillis());
                    buildContext.refresh(moduleDirectory);
                    // Scala module hack
                    if ("scala".equals(moduleName)) {
                        scalaHack(moduleDirectory, filteredArtifacts);
                    }
                    if (!dependenciesSkipJars) {
                        Set<Artifact> dependencySubtree = getModuleDependencyArtifacts(filteredArtifacts,
                                moduleZipArtifact);

                        if (!dependencySubtree.isEmpty()) {
                            File moduleLibDir = new File(moduleDirectory, "lib");
                            createLibDirectory(moduleLibDir);

                            for (Artifact classPathArtifact : dependencySubtree) {
                                File jarFile = classPathArtifact.getFile();
                                if (dependenciesOverwrite) {
                                    FileUtils.copyFileToDirectory(jarFile, moduleLibDir);
                                } else {
                                    if (jarFile == null) {
                                        getLog().info("null file"); // TODO-???
                                    }
                                    FileUtils.copyFileToDirectoryIfModified(jarFile, moduleLibDir);
                                }
                                filteredArtifacts.remove(classPathArtifact);
                            }
                        }
                    }
                } else // just remove dependency tree from "filteredArtifacts" collection 
                {
                    if (!dependenciesSkipJars) {
                        Set<Artifact> dependencySubtree = getModuleDependencyArtifacts(filteredArtifacts,
                                moduleZipArtifact);
                        for (Artifact classPathArtifact : dependencySubtree) {
                            filteredArtifacts.remove(classPathArtifact);
                        }
                    }
                }
            }
        }

        // lib
        if (!dependenciesSkipJars && !filteredArtifacts.isEmpty()) {
            File libDir = new File(baseDir, "lib");
            createLibDirectory(libDir);
            for (Iterator<?> iter = filteredArtifacts.iterator(); iter.hasNext();) {
                Artifact classPathArtifact = (Artifact) iter.next();
                File jarFile = classPathArtifact.getFile();
                // In a reactor (multi-module) build if "play" module depends on "jar" module,
                // "jar" module artifact's file can be a directory instead of a file.
                // This happens when "compile" lifecycle phase or any phase between "compile"
                // and "package" has ben executed before "play:dependencies" mojo
                // (for example "mvn compile play:dependencies").
                // How to solve this problem?
                // Dependency "jar" artifact has to be installed first ("mvn install" for "jar"
                // module only) or at least "package" phase has to be executed for the whole reactor
                // before "play:dependencies" ("mvn package play:dependencies").
                checkPotentialReactorProblem(classPathArtifact);
                if (dependenciesOverwrite) {
                    FileUtils.copyFileToDirectory(jarFile, libDir);
                    buildContext.refresh(new File(libDir, jarFile.getName()));
                } else {
                    if (FileUtils.copyFileIfModified(jarFile, new File(libDir, jarFile.getName()))) {
                        buildContext.refresh(new File(libDir, jarFile.getName()));
                    }
                }
            }
        }
    } catch (ArchiverException e) {
        // throw new MojoExecutionException( "Error unpacking file [" + file.getAbsolutePath() + "]" + "to ["
        // + unpackDirectory.getAbsolutePath() + "]", e );
        throw new MojoExecutionException("?", e);
    } catch (DependencyTreeBuilderException e) {
        throw new MojoExecutionException("?", e);
    } catch (NoSuchArchiverException e) {
        throw new MojoExecutionException("?", e);
    }
}

From source file:com.google.code.sbt.compiler.plugin.SBTCompileMojo.java

License:Apache License

/**
 * {@inheritDoc}/* w  w  w  . ja  v a  2 s  .c  o m*/
 */
@Override
protected Map<File, File> getAnalysisCacheMap() {
    HashMap<File, File> map = new HashMap<File, File>();
    for (MavenProject reactorProject : reactorProjects) {
        if (reactorProject != project) {
            File analysisCacheFile = defaultAnalysisCacheFile(reactorProject);
            if (analysisCacheFile.isFile()) {
                File reactorProjectArtifactFile = reactorProject.getArtifact().getFile();
                if (reactorProjectArtifactFile != null) {
                    map.put(reactorProjectArtifactFile.getAbsoluteFile(), analysisCacheFile.getAbsoluteFile());
                }
            }
        }
    }
    return map;
}

From source file:com.google.code.sbt.compiler.plugin.SBTTestCompileMojo.java

License:Apache License

/**
 * {@inheritDoc}//from   ww  w. j a  v a 2  s  .  c o m
 */
@Override
protected Map<File, File> getAnalysisCacheMap() {
    HashMap<File, File> map = new HashMap<File, File>();
    for (MavenProject reactorProject : reactorProjects) {
        File analysisCacheFile = defaultAnalysisCacheFile(reactorProject);
        if (analysisCacheFile.isFile()) {
            File reactorProjectArtifactFile = reactorProject.getArtifact().getFile();
            if (reactorProjectArtifactFile != null) {
                map.put(reactorProjectArtifactFile.getAbsoluteFile(), analysisCacheFile.getAbsoluteFile());
            }
        }

        if (reactorProject != project) {
            File testAnalysisCacheFile = defaultTestAnalysisCacheFile(reactorProject);
            if (testAnalysisCacheFile.isFile()) {
                List<Artifact> reactorProjectattachedArtifacts = reactorProject.getAttachedArtifacts();
                for (Artifact artifact : reactorProjectattachedArtifacts) {
                    if ("tests".equals(artifact.getClassifier())) {
                        map.put(artifact.getFile().getAbsoluteFile(), testAnalysisCacheFile.getAbsoluteFile());
                        break;
                    }
                }
            }
        }
    }
    return map;
}

From source file:com.googlecode.japi.checker.maven.plugin.RuntimeDependencyResolver.java

License:Apache License

/**
 * Download (if necessary) a pom, and load it as a MavenProject, transitively resolving any
 * dependencies therein./*from  ww  w  . jav a2  s  .  com*/
 * 
 * @param projectBuilder
 * @param groupId
 * @param artifactId
 * @param versionId
 * @return a Set of Artifacts representing the transitively resolved dependencies.
 * @throws MalformedURLException
 * @throws ProjectBuildingException
 * @throws InvalidDependencyVersionException
 * @throws ArtifactResolutionException
 * @throws ArtifactNotFoundException
 */
public Set<Artifact> transitivelyResolvePomDependencies(MavenProjectBuilder projectBuilder, String groupId,
        String artifactId, String versionId, boolean resolveProjectArtifact)
        throws MalformedURLException, ProjectBuildingException, InvalidDependencyVersionException,
        ArtifactResolutionException, ArtifactNotFoundException {

    Artifact pomArtifact = getPomArtifact(groupId, artifactId, versionId);
    MavenProject project = loadPomAsProject(projectBuilder, pomArtifact);
    @SuppressWarnings("rawtypes")
    List dependencies = project.getDependencies();

    @SuppressWarnings("unchecked")
    Set<Artifact> dependencyArtifacts = MavenMetadataSource.createArtifacts(artifactFactory, dependencies, null,
            null, null);
    dependencyArtifacts.add(project.getArtifact());

    @SuppressWarnings("rawtypes")
    List listeners = Collections.EMPTY_LIST;

    ArtifactResolutionResult result = artifactResolver.resolveTransitively(dependencyArtifacts, pomArtifact,
            Collections.EMPTY_MAP, localRepository, remoteRepositories, metadataSource, null, listeners);

    @SuppressWarnings("unchecked")
    Set<Artifact> artifacts = result.getArtifacts();

    LOGGER.fine("RESOLVED " + artifacts.size() + " ARTIFACTS");
    Iterator<Artifact> itor = artifacts.iterator();
    while (itor.hasNext()) {
        Artifact a = (Artifact) itor.next();
        LOGGER.fine(a.getFile().toURI().toURL().toString());
    }
    return artifacts;
}

From source file:com.jayway.maven.plugins.android.phase_prebuild.AarMavenLifecycleParticipant.java

License:Open Source License

@Override
public void afterProjectsRead(MavenSession session) throws MavenExecutionException {
    log.debug("");
    log.debug("AMLP afterProjectsRead");
    log.debug("");

    log.debug("CurrentProject=" + session.getCurrentProject());
    final List<MavenProject> projects = session.getProjects();

    for (MavenProject project : projects) {
        log.debug("");
        log.debug("project=" + project.getArtifact());

        final BuildHelper helper = new BuildHelper(repoSystem, session.getRepositorySession(), project, log);

        final Collection<Artifact> artifacts = getProjectsArtifacts(session, project);
        log.debug("projects deps: : " + artifacts);
        for (Artifact artifact : artifacts) {
            final String type = artifact.getType();
            if (type.equals(AndroidExtension.AAR)) {
                // An AAR lib contains a classes jar that needs to be added to the classpath.
                // Create a placeholder classes.jar and add it to the compile classpath.
                // It will replaced with the real classes.jar by GenerateSourcesMojo.
                addClassesToClasspath(helper, project, artifact);
            } else if (type.equals(AndroidExtension.APK)) {
                // The only time that an APK will likely be a dependency is when this an an APK test project.
                // So add a placeholder (we cannot resolve the actual dep pre build) to the compile classpath.
                // The placeholder will be replaced with the real APK jar later.
                addClassesToClasspath(helper, project, artifact);
            }/*from  www .j a v a2 s. co m*/
        }
    }
}

From source file:com.jayway.maven.plugins.android.phase_prebuild.AarMavenLifecycleParticipant.java

License:Open Source License

private Collection<Artifact> getProjectsArtifacts(MavenSession session, MavenProject project)
        throws MavenExecutionException {
    final DependencyResolver resolver = new DependencyResolver(log, repoSystem, session.getRepositorySession(),
            project.getRemoteProjectRepositories(), artifactHandler);

    try {/*from  w  w w.  j a  v a 2  s. c om*/
        return resolver.getDependenciesFor(project.getArtifact());
    } catch (MojoExecutionException e) {
        throw new MavenExecutionException("Could not resolve dependencies for " + project.getArtifact(), e);
    }
}