.getTasks() .create( "generate" + capitalize(variant.getName()) + "HensonNavigator", GenerateHensonNavigatorTask.class); generateHensonNavigatorTask.hensonNavigatorPackageName = hensonNavigatorPackageName;
@Nullable private Configuration getConfigurationFromVariant(@Nullable BaseVariant variant) { @Var Configuration configuration = null; if (isKapt) { configuration = getProject() .getConfigurations() .getByName("kapt" + StringUtils.capitalize(getBaseVariant().getName())); } else if (variant != null) { configuration = variant.getAnnotationProcessorConfiguration(); } return configuration; }
public BaseVariant getVariant(Context context) { String variantName = context.getVariantName(); for (BaseVariant variant : variants) { if (variant.getName().equals(variantName)) { return variant; } } return null; }
protected boolean publishVariant(BaseVariant variant) { if (variant instanceof TestVariant || variant instanceof UnitTestVariant) { return false; } return getAndroidExtension().getDefaultPublishConfig().equals(variant.getName()); }
@Nullable private static BaseVariant findVariant(List<BaseVariant> candidates, @Nullable String testBuildType, @Nullable String userConfiguredBuildVariantName) { if (candidates.isEmpty()) { return null; } if (userConfiguredBuildVariantName == null) { // Take first "test" buildType when there is no provided variant name // Release variant may be obfuscated using proguard. Also unit tests and coverage reports are usually collected in debug mode. Optional<BaseVariant> firstDebug = candidates.stream().filter(v -> testBuildType != null && testBuildType.equals(v.getBuildType().getName())).findFirst(); // No debug variant? Then use first variant whatever is the type BaseVariant result = firstDebug.orElse(candidates.get(0)); LOGGER.info("No variant name specified to be used by SonarQube. Default to '{}'", result.getName()); return result; } else { Optional<BaseVariant> result = candidates.stream().filter(v -> userConfiguredBuildVariantName.equals(v.getName())).findFirst(); if (result.isPresent()) { return result.get(); } else { throw new IllegalArgumentException("Unable to find variant '" + userConfiguredBuildVariantName + "' to use for SonarQube analysis. Candidates are: " + candidates.stream().map(BaseVariant::getName).collect(Collectors.joining(", "))); } } }
@Nullable private static BaseVariant findVariant(List<BaseVariant> candidates, @Nullable String testBuildType, @Nullable String userConfiguredBuildVariantName) { if (candidates.isEmpty()) { return null; } if (userConfiguredBuildVariantName == null) { // Take first "test" buildType when there is no provided variant name // Release variant may be obfuscated using proguard. Also unit tests and coverage reports are usually collected in debug mode. Optional<BaseVariant> firstDebug = candidates.stream().filter(v -> testBuildType != null && testBuildType.equals(v.getBuildType().getName())).findFirst(); // No debug variant? Then use first variant whatever is the type BaseVariant result = firstDebug.orElse(candidates.get(0)); LOGGER.info("No variant name specified to be used by SonarQube. Default to '{}'", result.getName()); return result; } else { Optional<BaseVariant> result = candidates.stream().filter(v -> userConfiguredBuildVariantName.equals(v.getName())).findFirst(); if (result.isPresent()) { return result.get(); } else { throw new IllegalArgumentException("Unable to find variant '" + userConfiguredBuildVariantName + "' to use for SonarQube analysis. Candidates are: " + candidates.stream().map(BaseVariant::getName).collect(Collectors.joining(", "))); } } }
/** * Returns the name of a task for this source set. * * @param verb The action, may be null. * @param target The target, may be null * @return The task name, generally of the form ${verb}${name}${noun} * @see SourceSet#getTaskName(String, String) */ protected static String getTaskName(BaseVariant variant, String verb, String target) { return new ClassDirectoryBinaryNamingScheme(variant.getName()).getTaskName(verb, target); }
@Override protected void configureForVariant(final BaseVariant variant, FindBugs task) { task.setDescription("Run FindBugs analysis for " + variant.getName() + " classes"); task.setSource(getAllJava(variant)); task.dependsOn(variant.getJavaCompiler()); ConventionMapping taskMapping = task.getConventionMapping(); taskMapping.map("classes", () -> { // the simple "classes = sourceSet.output" may lead to non-existing resources directory // being passed to FindBugs Ant task, resulting in an error List<String> generatedClasses = new LinkedList<>(); getJavaCompile(variant).getSource().visit(fileVisitDetails -> { if (!fileVisitDetails.isDirectory() && fileVisitDetails.getPath().endsWith(".java") && fileVisitDetails.getFile().getAbsolutePath().startsWith(project.getBuildDir().getAbsolutePath())) { generatedClasses.add(fileVisitDetails.getPath().replace(".java", "")); } }); return getOutput(variant) .filter(file -> generatedClasses.parallelStream().noneMatch(generatedClass -> file.getAbsolutePath().endsWith(generatedClass + ".class") || file.getAbsolutePath().contains(generatedClass + "$"))); }); taskMapping.map("classpath", () -> getCompileClasspath(variant)); } }
LOGGER.warn("Unable to find Java compiler on variant '{}'. Is Jack toolchain used? SonarQube analysis will be less accurate without bytecode.", variant.getName());
LOGGER.warn("Unable to find Java compiler on variant '{}'. Is Jack toolchain used? SonarQube analysis will be less accurate without bytecode.", variant.getName());
private void configureTask(SonarQubeTask sonarQubeTask, Project project) { ConventionMapping conventionMapping = sonarQubeTask.getConventionMapping(); // this will call the SonarPropertyComputer to populate the properties of the task just before running it conventionMapping.map("properties", () -> new SonarPropertyComputer(actionBroadcastMap, project) .computeSonarProperties()); Callable<Iterable<? extends Task>> testTasks = () -> project.getAllprojects().stream() .filter(p -> p.getPlugins().hasPlugin(JavaPlugin.class) && !p.getExtensions().getByType(SonarQubeExtension.class).isSkipProject()) .map(p -> p.getTasks().getByName(JavaPlugin.TEST_TASK_NAME)) .collect(Collectors.toList()); sonarQubeTask.dependsOn(testTasks); Callable<Iterable<? extends Task>> compileTasks = () -> project.getAllprojects().stream() .filter(p -> isAndroidProject(p) && !p.getExtensions().getByType(SonarQubeExtension.class).isSkipProject()) .map(p -> { BaseVariant variant = AndroidUtils.findVariant(p, p.getExtensions().getByType(SonarQubeExtension.class).getAndroidVariant()); List<Task> allCompileTasks = new ArrayList<>(); boolean unitTestTaskDepAdded = addTaskByName(p, "compile" + capitalize(variant.getName()) + "UnitTestJavaWithJavac", allCompileTasks); boolean androidTestTaskDepAdded = addTaskByName(p, "compile" + capitalize(variant.getName()) + "AndroidTestJavaWithJavac", allCompileTasks); // unit test compile and android test compile tasks already depends on main code compile so don't add a useless dependency // that would lead to run main compile task several times if (!unitTestTaskDepAdded && !androidTestTaskDepAdded) { addTaskByName(p, "compile" + capitalize(variant.getName()) + "JavaWithJavac", allCompileTasks); } return allCompileTasks; }) .flatMap(List::stream) .collect(Collectors.toList()); sonarQubeTask.dependsOn(compileTasks); }
private void configureTask(SonarQubeTask sonarQubeTask, Project project) { ConventionMapping conventionMapping = sonarQubeTask.getConventionMapping(); // this will call the SonarPropertyComputer to populate the properties of the task just before running it conventionMapping.map("properties", () -> new SonarPropertyComputer(actionBroadcastMap, project) .computeSonarProperties()); Callable<Iterable<? extends Task>> testTasks = () -> project.getAllprojects().stream() .filter(p -> p.getPlugins().hasPlugin(JavaPlugin.class) && !p.getExtensions().getByType(SonarQubeExtension.class).isSkipProject()) .map(p -> p.getTasks().getByName(JavaPlugin.TEST_TASK_NAME)) .collect(Collectors.toList()); sonarQubeTask.dependsOn(testTasks); Callable<Iterable<? extends Task>> compileTasks = () -> project.getAllprojects().stream() .filter(p -> isAndroidProject(p) && !p.getExtensions().getByType(SonarQubeExtension.class).isSkipProject()) .map(p -> { BaseVariant variant = AndroidUtils.findVariant(p, p.getExtensions().getByType(SonarQubeExtension.class).getAndroidVariant()); List<Task> allCompileTasks = new ArrayList<>(); boolean unitTestTaskDepAdded = addTaskByName(p, "compile" + capitalize(variant.getName()) + "UnitTestJavaWithJavac", allCompileTasks); boolean androidTestTaskDepAdded = addTaskByName(p, "compile" + capitalize(variant.getName()) + "AndroidTestJavaWithJavac", allCompileTasks); // unit test compile and android test compile tasks already depends on main code compile so don't add a useless dependency // that would lead to run main compile task several times if (!unitTestTaskDepAdded && !androidTestTaskDepAdded) { addTaskByName(p, "compile" + capitalize(variant.getName()) + "JavaWithJavac", allCompileTasks); } return allCompileTasks; }) .flatMap(List::stream) .collect(Collectors.toList()); sonarQubeTask.dependsOn(compileTasks); }
private BaseVariant getVariant(Context context) throws TransformException { TransformTask transformTask = (TransformTask)context; Project project = transformTask.getProject(); List<BaseVariant> variants = new ArrayList<>(); if (project.getPlugins().hasPlugin(LibraryPlugin.class)) { LibraryExtension android = project.getExtensions().getByType(LibraryExtension.class); variants.addAll(android.getLibraryVariants()); variants.addAll(android.getTestVariants()); variants.addAll(android.getUnitTestVariants()); } else if (project.getPlugins().hasPlugin(AppPlugin.class)) { AppExtension android = project.getExtensions().getByType(AppExtension.class); variants.addAll(android.getApplicationVariants()); variants.addAll(android.getTestVariants()); variants.addAll(android.getUnitTestVariants()); } else if (project.getPlugins().hasPlugin(TestPlugin.class)) { TestExtension android = project.getExtensions().getByType(TestExtension.class); variants.addAll(android.getApplicationVariants()); } else { throw new TransformException(project.getName() + " isn't an Android project"); } Optional<BaseVariant> variant = variants.stream().filter(v -> transformTask.getVariantName().equals(v.getName())).findFirst(); if (!variant.isPresent()) { throw new TransformException("Variant not found: " + project.getName() + " / " + transformTask.getVariantName()); } return variant.get(); }
@Override protected void withAndroid(TestedExtension extension) { super.withAndroid(extension); getAndroidVariants().all(variant -> { Jar sourcesJarTask = getProject().getTasks().create("sources" + capitalize((CharSequence) variant.getName()) + "Jar", Jar.class, jar -> { jar.setDescription("Generate the sources jar for the " + variant.getName() + " variant"); jar.setGroup("jar"); jar.setClassifier("sources"); jar.setAppendix(variant.getName()); jar.from(variant.getJavaCompiler().property("source")); }); allSourcesJarTask.dependsOn(sourcesJarTask); if (publishVariant(variant)) { getProject().getArtifacts().add(Dependency.ARCHIVES_CONFIGURATION, sourcesJarTask); } }); } }
public void registerJavaArtifact( @NonNull String name, @NonNull BaseVariant variant, @NonNull String assembleTaskName, @NonNull String javaCompileTaskName, @NonNull Collection<File> generatedSourceFolders, @NonNull Iterable<String> ideSetupTaskNames, @NonNull Configuration configuration, @NonNull File classesFolder, @NonNull File javaResourcesFolder, @Nullable SourceProvider sourceProvider) { ArtifactMetaData artifactMetaData = extraArtifactMap.get(name); if (artifactMetaData == null) { throw new IllegalArgumentException(String.format( "Artifact with name %1$s is not yet registered. Use registerArtifactType()", name)); } if (artifactMetaData.getType() != ArtifactMetaData.TYPE_JAVA) { throw new IllegalArgumentException( String.format("Artifact with name %1$s is not of type JAVA", name)); } JavaArtifact artifact = new JavaArtifactImpl( name, assembleTaskName, javaCompileTaskName, ideSetupTaskNames, generatedSourceFolders, classesFolder, javaResourcesFolder, null, new ConfigurationDependencies(configuration), sourceProvider, null); extraJavaArtifacts.put(variant.getName(), artifact); }
@Override public VariantScope create(BaseVariant v) { ConfigurationContainer configurations = project.getConfigurations(); // the actual configuration Configuration configuration = getByVariant(v.getName()); // attributes match AttributeContainer attributes = configuration.getAttributes(); attributes .attribute(ARTIFACT_TYPE, ArtifactTypeDefinition.JAR_TYPE) .attribute(BuildTypeAttr.ATTRIBUTE, project.getObjects().named(BuildTypeAttr.class, v.getBuildType().getName())) .attribute(Usage.USAGE_ATTRIBUTE, project.getObjects().named(Usage.class, Usage.JAVA_RUNTIME)); v.getProductFlavors().forEach(p -> attributes.attribute(Attribute.of(p.getDimension(), ProductFlavorAttr.class), project.getObjects().named(ProductFlavorAttr.class, p.getName()))); configuration.setDescription("Resolved configuration for capt for variant: " + v.getName()); configuration.setVisible(false); configuration.setCanBeConsumed(false); configuration.getResolutionStrategy().sortArtifacts(ResolutionStrategy.SortOrder.CONSUMER_FIRST); v.getSourceSets().stream() .map(SourceProvider::getName) .map(VariantManager::sourceSetToConfigurationName) .map(configurations::getByName) .forEach(configuration::extendsFrom); return new VariantScope(v.getName(), configuration, global); }
public Javadoc getJavadocTask(Project project, BaseVariant variant) { if (!javadocTasks.containsKey(variant.getName())) { Javadoc task = project.getTasks().create("javadoc" + capitalize((CharSequence) variant.getName()), Javadoc.class, javadoc -> { javadoc.setDescription("Generate Javadoc for the " + variant.getName() + " variant"); javadoc.setGroup(JavaBasePlugin.DOCUMENTATION_GROUP); }); javadocTasks.put(variant.getName(), task); return javadocTasks.get(variant.getName());
public void registerJavaArtifact( @NonNull String name, @NonNull BaseVariant variant, @NonNull String assembleTaskName, @NonNull String javaCompileTaskName, @NonNull Collection<File> generatedSourceFolders, @NonNull Iterable<String> ideSetupTaskNames, @NonNull Configuration configuration, @NonNull File classesFolder, @NonNull File javaResourcesFolder, @Nullable SourceProvider sourceProvider) { ArtifactMetaData artifactMetaData = extraArtifactMap.get(name); if (artifactMetaData == null) { throw new IllegalArgumentException(String.format( "Artifact with name %1$s is not yet registered. Use registerArtifactType()", name)); } if (artifactMetaData.getType() != ArtifactMetaData.TYPE_JAVA) { throw new IllegalArgumentException( String.format("Artifact with name %1$s is not of type JAVA", name)); } JavaArtifact artifact = new JavaArtifactImpl( name, assembleTaskName, javaCompileTaskName, ideSetupTaskNames, generatedSourceFolders, classesFolder, javaResourcesFolder, null, new ConfigurationDependencies(configuration), new ConfigurationDependencyGraphs(configuration), sourceProvider, null); extraJavaArtifacts.put(variant.getName(), artifact); }
@Override protected void withAndroid(TestedExtension extension) { super.withAndroid(extension); getAndroidVariants().all(variant -> { AndroidJavadocPlugin androidJavadocPlugin = getProject().getPlugins().findPlugin(AndroidJavadocPlugin.class); Javadoc javadocTask = androidJavadocPlugin.getJavadocTask(getProject(), variant); Jar javadocJarTask = getProject().getTasks().create("javadoc" + capitalize((CharSequence) variant.getName()) + "Jar", Jar.class, jar -> { jar.dependsOn(javadocTask); jar.setDescription("Generate the javadoc jar for the " + variant.getName() + " variant"); jar.setGroup("jar"); jar.setAppendix(variant.getName()); jar.setClassifier("javadoc"); jar.from(javadocTask.getDestinationDir()); }); allJavadocJarTask.dependsOn(javadocJarTask); if (publishVariant(variant)) { getProject().getArtifacts().add(Dependency.ARCHIVES_CONFIGURATION, javadocJarTask); } }); } }
String delombokName = "delombok" + capitalize((CharSequence)variant.getName());