.getTasks() .create( "generate" + capitalize(variant.getName()) + "HensonNavigator", GenerateHensonNavigatorTask.class); generateHensonNavigatorTask.hensonNavigatorPackageName = hensonNavigatorPackageName;
public Set<File> getJavaResources(BaseVariant variant) { return variant .getSourceSets() .stream() .map(SourceProvider::getResourcesDirectories) .flatMap(Collection::stream) .collect(Collectors.toSet()); }
static List<String> getJavaCompilerOptions(BaseVariant baseVariant) { if (baseVariant != null && baseVariant.getJavaCompiler() instanceof JavaCompile) { List<String> options = ((JavaCompile) baseVariant.getJavaCompiler()).getOptions().getCompilerArgs(); // Remove options added by apt plugin since they are handled by apt scope separately filterOptions(options, ImmutableList.of("-s", "-processorpath")); return options; } else { return ImmutableList.of(); } }
@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; }
@Nullable public String getConsumerProguardConfig() { Set<File> consumerProguardFiles = new ImmutableSet.Builder<File>() .addAll(getBaseVariant().getMergedFlavor().getConsumerProguardFiles()) .addAll(getBaseVariant().getBuildType().getConsumerProguardFiles()) .build(); if (consumerProguardFiles.size() > 0) { Optional<File> optionalFile = consumerProguardFiles.stream().findFirst(); return FileUtil.getRelativePath(getProject().getProjectDir(), optionalFile.get()); } return null; }
Strings.nullToEmpty(getBaseVariant().getMergedFlavor().getApplicationIdSuffix()) + Strings.nullToEmpty(getBaseVariant().getBuildType().getApplicationIdSuffix()); minus(minus(getBaseVariant().getApplicationId(), ".test"), applicationIdSuffix); applicationId = minus(applicationIdString, applicationIdSuffix); } else { applicationId = minus(getBaseVariant().getApplicationId(), applicationIdSuffix); versionName = getBaseVariant().getMergedFlavor().getVersionName(); versionCode = getBaseVariant().getMergedFlavor().getVersionCode(); debuggable = getBaseVariant().getBuildType().isDebuggable(); if (getBaseVariant().getMergedFlavor().getMinSdkVersion() == null || getBaseVariant().getMergedFlavor().getTargetSdkVersion() == null) { minSdk = targetSdk = DEFAULT_SDK; throw new IllegalStateException( + "` must specify minSdkVersion and targetSdkVersion in build.gradle"); } else { minSdk = getBaseVariant().getMergedFlavor().getMinSdkVersion().getApiString(); targetSdk = getBaseVariant().getMergedFlavor().getTargetSdkVersion().getApiString();
final String variantName = variant.getName(); .debug("Processing variant " + variantName + " for Eta compilation."); final JavaCompile javaCompileTask = variant.getJavaCompile(); sourceDirectorySetFactory.create("eta", variantName + " Eta source"); for (SourceProvider sourceProvider : variant.getSourceSets()) { final EtaSourceSet etaSourceSet = ExtensionHelper.getConvention(sourceProvider, EtaSourceSet.class); = project.provider(() -> variant.getCompileConfiguration().getName()); .dir(NamingScheme.getRelativeOutputDir(variant.getDirName())); variant.getPreBuild().dependsOn(installDependenciesTask); variant.registerPreJavacGeneratedBytecode (project.files(compileTask.getOutputJarFileProvider()) .builtBy(compileTask)); (() -> variant.getCompileClasspath(etaClasspathKey) .plus(project.files(AndroidHelper .getAndroidSDKClasspath(androidExtension))))); variant.getRuntimeConfiguration());
private static void populateSonarQubeProps(Map<String, Object> properties, List<File> bootClassPath, BaseVariant variant, boolean isTest) { List<File> srcDirs = variant.getSourceSets().stream().map(AndroidUtils::getFilesFromSourceSet).collect( ArrayList::new, ArrayList::addAll, LOGGER.warn("Unable to find Java compiler on variant '{}'. Is Jack toolchain used? SonarQube analysis will be less accurate without bytecode.", 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(", "))); } } }
@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); }
@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)); } }
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); javadoc.dependsOn(variant.getJavaCompiler()); javadoc.setDestinationDir(new File(javadocDir, variant.getDirName())); }); javadocTasks.put(variant.getName(), task); return javadocTasks.get(variant.getName());
public AndroidAppTarget(Project project, String name, boolean isTest) { super(project, name, isTest); minifyEnabled = getBaseVariant().getBuildType().isMinifyEnabled(); keystore = extractKeystore(); NdkCompile ndkCompile = baseVariant.getNdkCompile(); Boolean multidex = getBaseVariant().getMergedFlavor().getMultiDexEnabled(); if (multidex == null) { multidexEnabled = false; placeholders.putAll(getBaseVariant().getBuildType().getManifestPlaceholders()); placeholders.putAll(getBaseVariant().getMergedFlavor().getManifestPlaceholders());
String getBuildType() { return getBaseVariant().getBuildType().getName(); }
@Nullable private static AbstractCompile getJavaCompiler(BaseVariant variant) { return variant.getJavaCompile(); }
private void useHackedAndroidJar(BaseVariant variant) { try { System.err.println("Hacking variant " + variant); JavaCompile javaCompile = variant.getJavaCompile(); File modifiedAndroidJar = GenerateAndroidJar.getMergedJar( variant.getMergedFlavor().getMinSdkVersion().getApiLevel(), variant.getMergedFlavor().getTargetSdkVersion().getApiLevel(), true, true, true); javaCompile.getOptions().setBootClasspath(modifiedAndroidJar.getPath()); } catch (Exception e) { throw new RuntimeException(e); } } }
@Override public Scope getProvided() { return Scope.builder(getProject()) .configuration(getBaseVariant().getCompileConfiguration()) .build(); }
public final void addGeneratorTask(@NotNull BaseVariant variant, @NotNull Task objectboxTask, @NotNull File targetGenDir) { boolean writeToBuildFolder = true; if(writeToBuildFolder) { variant.registerJavaGeneratingTask(objectboxTask, new File[]{targetGenDir}); } else { variant.getJavaCompiler().dependsOn(new Object[]{objectboxTask}); } }
private static void populateSonarQubeProps(Map<String, Object> properties, List<File> bootClassPath, BaseVariant variant, boolean isTest) { List<File> srcDirs = variant.getSourceSets().stream().map(AndroidUtils::getFilesFromSourceSet).collect( ArrayList::new, ArrayList::addAll, LOGGER.warn("Unable to find Java compiler on variant '{}'. Is Jack toolchain used? SonarQube analysis will be less accurate without bytecode.", 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(", "))); } } }