org.gradle.api.artifacts.result.ResolutionResult Java Examples

private Set<String> getCompileArtifactsForAgp2x() {
    Set<String> compileLibs = new HashSet<>();

    Configuration configuration = project.getConfigurations().getByName("compile");
    if (configuration.isCanBeResolved()) {
        ResolvableDependencies incoming = configuration.getIncoming();
        ResolutionResult resolutionResult = incoming.getResolutionResult();
        Set<ResolvedComponentResult> components = resolutionResult.getAllComponents();

        for (ResolvedComponentResult result : components) {
            ModuleVersionIdentifier identifier = result.getModuleVersion();
            if (identifier != null && !"unspecified".equals(identifier.getVersion())) {
                compileLibs.add(
                        String.join(":", identifier.getGroup(), identifier.getName(), identifier.getVersion()));
            }
        }
    }

    return compileLibs;
}
 

public void resolve(ConfigurationInternal configuration,
                    List<? extends ResolutionAwareRepository> repositories,
                    ModuleMetadataProcessor metadataProcessor,
                    ResolverResults results) throws ResolveException {
    try {
        dependencyResolver.resolve(configuration, repositories, metadataProcessor, results);
    } catch (final Throwable e) {
        results.failed(new BrokenResolvedConfiguration(e, configuration), wrapException(e, configuration));
        return;
    }
    ResolvedConfiguration wrappedConfiguration = new ErrorHandlingResolvedConfiguration(results.getResolvedConfiguration(), configuration);
    ResolutionResult wrappedResult = new ErrorHandlingResolutionResult(results.getResolutionResult(), configuration);
    results.resolved(wrappedConfiguration, wrappedResult);
}
 

public void resolve(ConfigurationInternal configuration,
                    List<? extends ResolutionAwareRepository> repositories,
                    GlobalDependencyResolutionRules metadataHandler,
                    ResolverResults results) throws ResolveException {
    if (configuration.getAllDependencies().isEmpty()) {
        ModuleVersionIdentifier id = DefaultModuleVersionIdentifier.newId(configuration.getModule());
        ComponentIdentifier componentIdentifier = componentIdentifierFactory.createComponentIdentifier(configuration.getModule());
        ResolutionResult emptyResult = new DefaultResolutionResultBuilder().start(id, componentIdentifier).complete();
        results.resolved(new EmptyResolvedConfiguration(), emptyResult);
    } else {
        dependencyResolver.resolve(configuration, repositories, metadataHandler, results);
    }
}
 

public void resolve(ConfigurationInternal configuration,
                    List<? extends ResolutionAwareRepository> repositories,
                    GlobalDependencyResolutionRules metadataHandler,
                    ResolverResults results) throws ResolveException {
    try {
        dependencyResolver.resolve(configuration, repositories, metadataHandler, results);
    } catch (final Throwable e) {
        results.failed(new BrokenResolvedConfiguration(e, configuration), wrapException(e, configuration));
        return;
    }
    ResolvedConfiguration wrappedConfiguration = new ErrorHandlingResolvedConfiguration(results.getResolvedConfiguration(), configuration);
    ResolutionResult wrappedResult = new ErrorHandlingResolutionResult(results.getResolutionResult(), configuration);
    results.resolved(wrappedConfiguration, wrappedResult);
}
 

public ResolutionResult complete() {
    store.write(new BinaryStore.WriteAction() {
        public void write(Encoder encoder) throws IOException {
            encoder.writeByte(DONE);
        }
    });
    BinaryStore.BinaryData data = store.done();
    RootFactory rootSource = new RootFactory(data, failures, cache);
    return new DefaultResolutionResult(rootSource);
}
 

public ResolutionResult getResolutionResult() {
    assertHasResult();
    if (fatalFailure != null) {
        throw fatalFailure;
    }
    return resolutionResult;
}
 

public ResolutionResult getResolutionResult() {
    assertHasResult();
    if (fatalFailure != null) {
        throw fatalFailure;
    }
    return resolutionResult;
}
 

public ResolutionResult complete() {
    store.write(new BinaryStore.WriteAction() {
        public void write(Encoder encoder) throws IOException {
            encoder.writeByte(DONE);
        }
    });
    BinaryStore.BinaryData data = store.done();
    RootFactory rootSource = new RootFactory(data, failures, cache);
    return new DefaultResolutionResult(rootSource);
}
 

public void resolve(ConfigurationInternal configuration,
                    List<? extends ResolutionAwareRepository> repositories,
                    ModuleMetadataProcessor metadataProcessor,
                    ResolverResults results) throws ResolveException {
    if (configuration.getAllDependencies().isEmpty()) {
        ModuleVersionIdentifier id = DefaultModuleVersionIdentifier.newId(configuration.getModule());
        ComponentIdentifier componentIdentifier = componentIdentifierFactory.createComponentIdentifier(configuration.getModule());
        ResolutionResult emptyResult = new DefaultResolutionResultBuilder().start(id, componentIdentifier).complete();
        results.resolved(new EmptyResolvedConfiguration(), emptyResult);
    } else {
        dependencyResolver.resolve(configuration, repositories, metadataProcessor, results);
    }
}
 

public void resolve(ConfigurationInternal configuration,
                    List<? extends ResolutionAwareRepository> repositories,
                    ModuleMetadataProcessor metadataProcessor,
                    ResolverResults results) throws ResolveException {
    try {
        dependencyResolver.resolve(configuration, repositories, metadataProcessor, results);
    } catch (final Throwable e) {
        results.failed(new BrokenResolvedConfiguration(e, configuration), wrapException(e, configuration));
        return;
    }
    ResolvedConfiguration wrappedConfiguration = new ErrorHandlingResolvedConfiguration(results.getResolvedConfiguration(), configuration);
    ResolutionResult wrappedResult = new ErrorHandlingResolutionResult(results.getResolutionResult(), configuration);
    results.resolved(wrappedConfiguration, wrappedResult);
}
 

public void resolve(ConfigurationInternal configuration,
                    List<? extends ResolutionAwareRepository> repositories,
                    ModuleMetadataProcessor metadataProcessor,
                    ResolverResults results) throws ResolveException {
    if (configuration.getAllDependencies().isEmpty()) {
        ModuleVersionIdentifier id = DefaultModuleVersionIdentifier.newId(configuration.getModule());
        ComponentIdentifier componentIdentifier = componentIdentifierFactory.createComponentIdentifier(configuration.getModule());
        ResolutionResult emptyResult = new DefaultResolutionResultBuilder().start(id, componentIdentifier).complete();
        results.resolved(new EmptyResolvedConfiguration(), emptyResult);
    } else {
        dependencyResolver.resolve(configuration, repositories, metadataProcessor, results);
    }
}
 

public ResolutionResult complete() {
    store.write(new BinaryStore.WriteAction() {
        public void write(Encoder encoder) throws IOException {
            encoder.writeByte(DONE);
        }
    });
    BinaryStore.BinaryData data = store.done();
    RootFactory rootSource = new RootFactory(data, failures, cache);
    return new DefaultResolutionResult(rootSource);
}
 

public ResolutionResult getResolutionResult() {
    assertHasResult();
    if (fatalFailure != null) {
        throw fatalFailure;
    }
    return resolutionResult;
}
 

public ResolutionResult getResolutionResult() {
    assertHasResult();
    if (fatalFailure != null) {
        throw fatalFailure;
    }
    return resolutionResult;
}
 

public ResolutionResult complete() {
    store.write(new BinaryStore.WriteAction() {
        public void write(Encoder encoder) throws IOException {
            encoder.writeByte(DONE);
        }
    });
    BinaryStore.BinaryData data = store.done();
    RootFactory rootSource = new RootFactory(data, failures, cache);
    return new DefaultResolutionResult(rootSource);
}
 

public void resolve(ConfigurationInternal configuration,
                    List<? extends ResolutionAwareRepository> repositories,
                    GlobalDependencyResolutionRules metadataHandler,
                    ResolverResults results) throws ResolveException {
    if (configuration.getAllDependencies().isEmpty()) {
        ModuleVersionIdentifier id = DefaultModuleVersionIdentifier.newId(configuration.getModule());
        ComponentIdentifier componentIdentifier = componentIdentifierFactory.createComponentIdentifier(configuration.getModule());
        ResolutionResult emptyResult = new DefaultResolutionResultBuilder().start(id, componentIdentifier).complete();
        results.resolved(new EmptyResolvedConfiguration(), emptyResult);
    } else {
        dependencyResolver.resolve(configuration, repositories, metadataHandler, results);
    }
}
 

public void resolve(ConfigurationInternal configuration,
                    List<? extends ResolutionAwareRepository> repositories,
                    GlobalDependencyResolutionRules metadataHandler,
                    ResolverResults results) throws ResolveException {
    try {
        dependencyResolver.resolve(configuration, repositories, metadataHandler, results);
    } catch (final Throwable e) {
        results.failed(new BrokenResolvedConfiguration(e, configuration), wrapException(e, configuration));
        return;
    }
    ResolvedConfiguration wrappedConfiguration = new ErrorHandlingResolvedConfiguration(results.getResolvedConfiguration(), configuration);
    ResolutionResult wrappedResult = new ErrorHandlingResolutionResult(results.getResolutionResult(), configuration);
    results.resolved(wrappedConfiguration, wrappedResult);
}
 

public ErrorHandlingResolutionResult(ResolutionResult resolutionResult, Configuration configuration) {
    this.resolutionResult = resolutionResult;
    this.configuration = configuration;
}
 

public ErrorHandlingResolutionResult(ResolutionResult resolutionResult, Configuration configuration) {
    this.resolutionResult = resolutionResult;
    this.configuration = configuration;
}
 

public ResolutionResult getResolutionResult() {
    DefaultConfiguration.this.resolveNow();
    return DefaultConfiguration.this.cachedResolverResults.getResolutionResult();
}
 

public void render(Configuration configuration) throws IOException {
    ResolutionResult result = configuration.getIncoming().getResolutionResult();
    RenderableDependency root = new RenderableModuleResult(result.getRoot());
    renderNow(root);
}
 

public void render(Configuration configuration) throws IOException {
    ResolutionResult result = configuration.getIncoming().getResolutionResult();
    RenderableDependency root = new RenderableModuleResult(result.getRoot());
    renderNow(root);
}
 

public void resolved(ResolvedConfiguration resolvedConfiguration, ResolutionResult resolutionResult) {
    this.resolvedConfiguration = resolvedConfiguration;
    this.resolutionResult = resolutionResult;
    this.fatalFailure = null;
}
 

public ResolutionResult getResolutionResult() {
    DefaultConfiguration.this.resolveNow();
    return DefaultConfiguration.this.cachedResolverResults.getResolutionResult();
}
 

public void resolved(ResolvedConfiguration resolvedConfiguration, ResolutionResult resolutionResult) {
    this.resolvedConfiguration = resolvedConfiguration;
    this.resolutionResult = resolutionResult;
    this.fatalFailure = null;
}
 

@Override
public void afterResolve(ResolvableDependencies resolvableDependencies) {
  String taskName = resolvableDependencies.getName();

  // Use of Product Flavors can change task names so skip tasks without compile in the name (case
  // in-sensitive).
  if (!taskName.contains("ompile")) {
    return;
  }

  // Phase 1: register all the dependency information from the project globally.
  logger.info("Registered task dependencies: " + projectName + ":" + taskName);
  if (resolvableDependencies.getResolutionResult() != null &&
      resolvableDependencies.getResolutionResult().getAllDependencies() != null) {
    registerDependencies(resolvableDependencies, projectName, taskName);
  }

  // Phase 2: take the resolved versions of Artifacts, go get the dependencies that
  // apply to those specific versions, and then ensure all are being honored.
  logger.info("Starting dependency analysis");
  ResolutionResult resolutionResult = resolvableDependencies.getResolutionResult();

  // Create an Artifact to ArtifactVersion mapping for resolved components.
  HashMap<Artifact, ArtifactVersion> resolvedVersions = new HashMap<>();
  for (ResolvedComponentResult resolvedComponentResult :
      resolutionResult.getAllComponents()) {
    ArtifactVersion version = ArtifactVersion.Companion.fromGradleRefOrNull(
        resolvedComponentResult.getId().toString());
    if (version != null) {
      resolvedVersions.put(version.getArtifact(), version);
    }
  }

  // Quick no-op when no versions.
  if (resolvedVersions.size() < 1) {
    return;
  }

  // Retrieve dependencies that apply to the resolved dep set.
  Collection<Dependency> activeDeps = dependencyAnalyzer.getActiveDependencies(
      resolvedVersions.values());
  // Validate each of the dependencies that should apply.
  for (Dependency dep : activeDeps) {
    ArtifactVersion resolvedVersion = resolvedVersions.get(dep.getToArtifact());

    // Check whether dependency is still valid.
    if (!dep.isVersionCompatible(resolvedVersion.getVersion())) {
      // This means a resolved version failed a dependency rule.

      logger.warn("Dependency resolved to an incompatible version: " + dep);

      // TODO: Warn, not fail, when the Major version boundaries are breached.
      // TODO: Experiment with collecting all issues and reporting them at once.
      Collection<Node> depsPaths = dependencyAnalyzer.getPaths(
          resolvedVersion.getArtifact());

      // Print extended path information at INFO level.
      logger.info("Dependency Resolution Help: Displaying all currently known " +
          "paths to any version of the dependency: " + dep.getToArtifact());
      logger.info("NOTE: com.google.android.gms translated to c.g.a.g for brevity. " +
          "Same for com.google.firebase -> c.g.f");
      // TODO: The depPaths nodes need to be consolidated prior to display.
      for (Node n : depsPaths) {
        printNode(1, n);
      }

      throw new GradleException(getErrorMessage(dep, resolvedVersion, depsPaths));
    }
  }
}
 

public ResolutionResult getResolutionResult() {
    DefaultConfiguration.this.resolveNow();
    return DefaultConfiguration.this.cachedResolverResults.getResolutionResult();
}
 

public void resolved(ResolvedConfiguration resolvedConfiguration, ResolutionResult resolutionResult) {
    this.resolvedConfiguration = resolvedConfiguration;
    this.resolutionResult = resolutionResult;
    this.fatalFailure = null;
}
 

public void render(Configuration configuration) throws IOException {
    ResolutionResult result = configuration.getIncoming().getResolutionResult();
    RenderableDependency root = new RenderableModuleResult(result.getRoot());
    renderNow(root);
}
 

public void render(Configuration configuration) throws IOException {
    ResolutionResult result = configuration.getIncoming().getResolutionResult();
    RenderableDependency root = new RenderableModuleResult(result.getRoot());
    renderNow(root);
}