How to use

getGroup

method

in

org.gradle.api.artifacts.ModuleVersionSelector

private boolean isGoogleOwnedDependency(ModuleVersionSelector selector) {
  return selector.getGroup().startsWith(SdkConstants.ANDROID_SUPPORT_ARTIFACT_PREFIX)
      || selector.getGroup().startsWith(SdkConstants.GOOGLE_SUPPORT_ARTIFACT_PREFIX)
      || selector.getGroup().startsWith(SdkConstants.FIREBASE_ARTIFACT_PREFIX);
}

  /**
   * @param selector the selector to get coordinates from
   * @return the coordinates in the form of "<group>:<name>"
   */
  protected String getCoord(ModuleVersionSelector selector) {
    return selector.getGroup() + ":" + selector.getName();
  }
}

/**
 * @param details the details to get coordinates from
 * @return the coordinates in the form of "<group>:<name>", taken from details.requested.
 */
protected String getCoord(DependencyResolveDetails details) {
  ModuleVersionSelector requested = details.getRequested();
  return requested.getGroup() + ":" + requested.getName();
}

private static boolean isInSameGroup(final DependencyResolveDetails dependency, final Project project) {
  return isInSameGroup(dependency.getRequested().getGroup(), project);
}

  public boolean isSatisfiedBy(ModuleVersionIdentifier candidate) {
    return candidate.getName().equals(selector.getName())
        && candidate.getGroup().equals(selector.getGroup())
        && candidate.getVersion().equals(selector.getVersion());
  }
}

/**
 * Returns the path of an artifact SDK repository.
 * @param selector the selector of an artifact.
 * @return a {@code String} containing the path.
 */
private static String getRepositoryPath(ModuleVersionSelector selector) {
  return DetailsTypes.MavenType.getRepositoryPath(
      selector.getGroup(), selector.getName(), selector.getVersion());
}

private boolean isDirectDependency(DependencyResolveDetails details) {
  if (this.directDependencies == null) {
    Set<String> directDependencies = new HashSet<String>();
    for (Dependency dependency : this.configuration.getAllDependencies()) {
      directDependencies.add(dependency.getGroup() + ":" + dependency.getName());
    }
    this.directDependencies = directDependencies;
  }
  return this.directDependencies.contains(details.getRequested().getGroup() + ":"
      + details.getRequested().getName());
}

Dependency(final DependencyResolveDetails dep, final String version) {
  this.group = dep.getRequested().getGroup();
  this.name = dep.getRequested().getName();
  this.version = version;
}

private boolean isDependencyOnLocalProject(Project project,
                      DependencyResolveDetails details) {
  return getAllLocalProjectNames(project.getRootProject()).contains(details.getRequested()
      .getGroup() + ":" + details.getRequested().getName());
}

  /**
   * Look for recommended versions in a project and each of its ancestors in order until one is found or the root is reached
   *
   * @param project    the gradle <code>Project</code>
   * @param mvSelector the module to lookup
   * @return the recommended version or <code>null</code>
   */
  protected String getRecommendedVersionRecursive(Project project, ModuleVersionSelector mvSelector) {
    String version = project.getExtensions().getByType(RecommendationProviderContainer.class)
        .getRecommendedVersion(mvSelector.getGroup(), mvSelector.getName());
    if (version != null)
      return version;
    if (project.getParent() != null)
      return getRecommendedVersionRecursive(project.getParent(), mvSelector);
    return null;
  }
}

public void useNativesForRunningPlatform() {
  project.getConfigurations().all(config -> {
    config.getResolutionStrategy().eachDependency(details -> {
      ModuleVersionSelector req = details.getRequested();
      if (req.getName().contains($_OSGI_PLATFORM)) {
        String running = SwtPlatform.getRunning().toString();
        details.useTarget(req.getGroup() + ":" + req.getName().replace($_OSGI_PLATFORM, running) + ":" + req.getVersion());
      }
    });
  });
}

@Override
public void execute(DependencyResolveDetails details) {
  logger.debug("Processing dependency '{}'", details.getRequested());
  if (isDependencyOnLocalProject(this.project, details)) {
    logger.debug("'{}' is a local project dependency. Dependency management has not " +
        "been applied", details.getRequested());
    return;
  }
  if (isDirectDependency(details) && Versions.isDynamic(details.getRequested().getVersion())) {
    logger.debug("'{}' is a direct dependency and has a dynamic version. Dependency management has not been "
        + "applied", details.getRequested());
    return;
  }
  String version = this.dependencyManagementContainer
      .getManagedVersion(this.configuration, details.getRequested().getGroup(),
          details.getRequested().getName());
  if (version != null) {
    logger.debug("Using version '{}' for dependency '{}'", version,
        details.getRequested());
    details.useVersion(version);
  }
  else {
    logger.debug("No dependency management for dependency '{}'", details.getRequested());
  }
}

@Override
public void execute(DependencyResolveDetails dependencyResolveDetails) {
  String group = dependencyResolveDetails.getTarget().getGroup();
  String name = dependencyResolveDetails.getTarget().getName();
  if (aetherPlugin.getVersionMap().containsKey(group) && aetherPlugin.getVersionMap().get(group).containsKey(name)) {
    Artifact artifact = new DefaultArtifact(dependencyResolveDetails.getTarget().getGroup()
        + ":" + dependencyResolveDetails.getTarget().getName()
        + ":" + dependencyResolveDetails.getTarget().getVersion());

private static void overwriteDependencies(final Configuration conf, final DependencyOverwrites dependencyOverwrites,
                     final XRepoConfiguration config, final Project project) {
  conf.getResolutionStrategy().eachDependency(dependency -> {
    if (isInSameGroup(dependency, project)) {
      final String overwrittenVersion = suffixed(dependency, config.getVersionSuffix());
      if (dependencyOverwrites.contains(dependency, overwrittenVersion)) {
        info(project, "Using overwritten dependency {}:{}:{}",
            dependency.getRequested().getGroup(), dependency.getRequested().getName(), overwrittenVersion);
        dependency.useVersion(overwrittenVersion);
      } else {
        final String fallbackSuffix = config.getFallbackSuffix();
        if (!fallbackSuffix.isEmpty()
            && !versionEndsWith(dependency, config.getVersionSuffix())
            && !versionEndsWith(dependency, fallbackSuffix)) {
          final String fallbackVersion = suffixed(dependency, fallbackSuffix);
          info(project, "Using fallback dependency {}:{}:{}",
              dependency.getRequested().getGroup(), dependency.getRequested().getName(), fallbackVersion);
          dependency.useVersion(fallbackVersion);
        }
      }
    }
  });
}

private static void useSuffixedVersions(final Configuration groupDeps, final XRepoConfiguration config, final Project project) {
  groupDeps.getResolutionStrategy().eachDependency(dependency -> {
    if (isInSameGroup(dependency, project) && !versionEndsWith(dependency, config.getVersionSuffix())) {
      debug(project, "Will look for version suffixed {} for {}:{}:{}", config.getVersionSuffix(),
          dependency.getRequested().getGroup(), dependency.getRequested().getName(), dependency.getRequested().getVersion());
      dependency.useVersion(suffixed(dependency, config.getVersionSuffix()));
    }
  });
}