com.android.build.gradle.api.AndroidSourceSet Java Examples

private void applyProjectSourceSet() {
    for (FunctionalSourceSet source : getSources()) {
        String name = source.getName();
        AndroidSourceSet androidSource = name.equals(BuilderConstants.MAIN) ?
                sourceSetsContainer.maybeCreate(getDefaultConfig().getName()) :
                sourceSetsContainer.maybeCreate(name);

        convertSourceFile(androidSource.getManifest(), source, "manifest");
        convertSourceSet(androidSource.getResources(), source, "resource");
        convertSourceSet(androidSource.getJava(), source, "java");
        convertSourceSet(androidSource.getRes(), source, "res");
        convertSourceSet(androidSource.getAssets(), source, "assets");
        convertSourceSet(androidSource.getAidl(), source, "aidl");
        convertSourceSet(androidSource.getJni(), source, "jni");
        convertSourceSet(androidSource.getJniLibs(), source, "jniLibs");
    }
}
 

private static void createCompoundSourceSets(
        @NonNull List<? extends ProductFlavor> productFlavorList,
        GradleVariantConfiguration variantConfig,
        NamedDomainObjectContainer<AndroidSourceSet> sourceSetsContainer) {
    if (!productFlavorList.isEmpty() && !variantConfig.getType().isSingleBuildType()) {
        DefaultAndroidSourceSet variantSourceSet =
                (DefaultAndroidSourceSet) sourceSetsContainer.maybeCreate(
                        computeSourceSetName(
                                variantConfig.getFullName(),
                                variantConfig.getType()));
        variantConfig.setVariantSourceProvider(variantSourceSet);
    }

    if (productFlavorList.size() > 1) {
        DefaultAndroidSourceSet multiFlavorSourceSet =
                (DefaultAndroidSourceSet) sourceSetsContainer.maybeCreate(
                        computeSourceSetName(
                                variantConfig.getFlavorName(),
                                variantConfig.getType()));
        variantConfig.setMultiFlavorSourceProvider(multiFlavorSourceSet);
    }
}
 

@Nullable
private static AndroidSourceSet findAndroidSourceSet(
        VariantManager variantManager,
        String name) {
    BuildTypeData buildTypeData = variantManager.getBuildTypes().get(name);
    if (buildTypeData != null) {
        return buildTypeData.getSourceSet();
    }

    ProductFlavorData productFlavorData = variantManager.getProductFlavors().get(name);
    if (productFlavorData != null) {
        return productFlavorData.getSourceSet();
    }
    return null;
}
 

public AndroidConfigAdaptor(
        AndroidConfig model,
        NamedDomainObjectContainer<AndroidSourceSet> sourceSetsContainer) {
    this.model = model;
    this.sourceSetsContainer = sourceSetsContainer;
    applyProjectSourceSet();
}
 

@Override
public void execute(@NonNull Sync processResources) {
    scope.getVariantData().processJavaResourcesTask = processResources;

    // set the input
    processResources.from(((AndroidSourceSet) scope.getVariantConfiguration().getDefaultSourceSet()).getResources().getSourceFiles());
    processResources.from(((AndroidSourceSet) scope.getVariantConfiguration().getBuildTypeSourceSet()).getResources().getSourceFiles());
    if (scope.getVariantConfiguration().hasFlavors()) {
        for (SourceProvider flavorSourceSet : scope.getVariantConfiguration().getFlavorSourceProviders()) {
            processResources.from(((AndroidSourceSet) flavorSourceSet).getResources().getSourceFiles());
        }

    }
    processResources.setDestinationDir(new File(scope.getSourceFoldersJavaResDestinationDir(), "src"));
}
 

@Override
@NonNull
public AndroidSourceSet setRoot(String path) {
    javaSource.setSrcDirs(Collections.singletonList(path + "/java"));
    javaResources.setSrcDirs(Collections.singletonList(path + "/resources"));
    res.setSrcDirs(Collections.singletonList(path + "/" + SdkConstants.FD_RES));
    assets.setSrcDirs(Collections.singletonList(path + "/" + SdkConstants.FD_ASSETS));
    manifest.srcFile(path + "/" + SdkConstants.FN_ANDROID_MANIFEST_XML);
    aidl.setSrcDirs(Collections.singletonList(path + "/aidl"));
    jni.setSrcDirs(Collections.singletonList(path + "/jni"));
    jniLibs.setSrcDirs(Collections.singletonList(path + "/jniLibs"));
    return this;
}
 

@Override
protected void generate(Project project) throws IOException {
    if (config != null) {
        for (AndroidSourceSet sourceSet : config.getSourceSets()) {
            mRenderer.getBuilder().subheading(sourceSet.getName());


            renderKeyValue("Compile configuration: ", sourceSet.getCompileConfigurationName());
            renderKeyValue("build.gradle name: ", "android.sourceSets." + sourceSet.getName());

            renderDirectorySet("Java sources", sourceSet.getJava(), project);

            renderKeyValue(
                    "Manifest file: ",
                    project.getRootProject().relativePath(
                            sourceSet.getManifest().getSrcFile()));

            renderDirectorySet("Android resources", sourceSet.getRes(), project);
            renderDirectorySet("Assets", sourceSet.getAssets(), project);
            renderDirectorySet("AIDL sources", sourceSet.getAidl(), project);
            renderDirectorySet("JNI sources", sourceSet.getJni(), project);
            renderDirectorySet("JNI libraries", sourceSet.getJniLibs(), project);

            renderDirectorySet("Java-style resources", sourceSet.getResources(), project);

            mRenderer.getTextOutput().println();
        }
    }

    mRenderer.complete();
}
 

/**
 * Computes the Java sources to use for compilation. This Object[] contains
 * {@link org.gradle.api.file.FileCollection} and {@link File} instances
 */
@NonNull
public Object[] getJavaSources() {
    if (javaSources == null) {
        // Build the list of source folders.
        List<Object> sourceList = Lists.newArrayList();

        // First the actual source folders.
        List<SourceProvider> providers = variantConfiguration.getSortedSourceProviders();
        for (SourceProvider provider : providers) {
            sourceList.add(((AndroidSourceSet) provider).getJava().getSourceFiles());
        }

        // then all the generated src folders.
        if (getScope().getGenerateRClassTask() != null) {
            sourceList.add(getScope().getRClassSourceOutputDir());
        }

        // for the other, there's no duplicate so no issue.
        if (getScope().getGenerateBuildConfigTask() != null) {
            sourceList.add(scope.getBuildConfigSourceOutputDir());
        }

        if (getScope().getAidlCompileTask() != null) {
            sourceList.add(scope.getAidlSourceOutputDir());
        }

        javaSources = sourceList.toArray();
    }

    return javaSources;
}
 

@Override
@NonNull
public AndroidSourceSet jniLibs(Closure configureClosure) {
    ConfigureUtil.configure(configureClosure, getJniLibs());
    return this;
}
 

@Override
@NonNull
public AndroidSourceSet aidl(Closure configureClosure) {
    ConfigureUtil.configure(configureClosure, getAidl());
    return this;
}
 

@Override
@NonNull
public AndroidSourceSet java(Closure configureClosure) {
    ConfigureUtil.configure(configureClosure, getJava());
    return this;
}
 

@Override
@NonNull
public AndroidSourceSet resources(Closure configureClosure) {
    ConfigureUtil.configure(configureClosure, getResources());
    return this;
}
 

public static NamedDomainObjectContainer<AndroidSourceSet> createSourceSetsContainer(
        @NonNull final Project project,
        @NonNull Instantiator instantiator,
        final boolean isLibrary) {
    NamedDomainObjectContainer<AndroidSourceSet> sourceSetsContainer = project.container(
            AndroidSourceSet.class,
            new AndroidSourceSetFactory(instantiator, project, isLibrary));

    sourceSetsContainer.whenObjectAdded(new Action<AndroidSourceSet>() {
        @Override
        public void execute(AndroidSourceSet sourceSet) {
            ConfigurationContainer configurations = project.getConfigurations();

            createConfiguration(
                    configurations,
                    sourceSet.getCompileConfigurationName(),
                    "Classpath for compiling the ${sourceSet.name} sources.");

            String packageConfigDescription;
            if (isLibrary) {
                packageConfigDescription
                        = "Classpath only used when publishing '${sourceSet.name}'.";
            } else {
                packageConfigDescription
                        = "Classpath packaged with the compiled '${sourceSet.name}' classes.";
            }
            createConfiguration(
                    configurations,
                    sourceSet.getPackageConfigurationName(),
                    packageConfigDescription);

            createConfiguration(
                    configurations,
                    sourceSet.getProvidedConfigurationName(),
                    "Classpath for only compiling the ${sourceSet.name} sources.");

            createConfiguration(
                    configurations,
                    sourceSet.getWearAppConfigurationName(),
                    "Link to a wear app to embed for object '${sourceSet.name}'.");

            sourceSet.setRoot(String.format("src/%s", sourceSet.getName()));

        }
    });
    return sourceSetsContainer;
}
 

BaseExtension(
        @NonNull final ProjectInternal project,
        @NonNull Instantiator instantiator,
        @NonNull AndroidBuilder androidBuilder,
        @NonNull SdkHandler sdkHandler,
        @NonNull NamedDomainObjectContainer<BuildType> buildTypes,
        @NonNull NamedDomainObjectContainer<ProductFlavor> productFlavors,
        @NonNull NamedDomainObjectContainer<SigningConfig> signingConfigs,
        @NonNull ExtraModelInfo extraModelInfo,
        final boolean isLibrary) {
    this.androidBuilder = androidBuilder;
    this.sdkHandler = sdkHandler;
    this.buildTypes = buildTypes;
    //noinspection unchecked
    this.productFlavors = (NamedDomainObjectContainer) productFlavors;
    this.signingConfigs = signingConfigs;
    this.extraModelInfo = extraModelInfo;
    this.project = project;

    logger = Logging.getLogger(this.getClass());

    defaultConfig = instantiator.newInstance(ProductFlavor.class, BuilderConstants.MAIN,
            project, instantiator, project.getLogger());

    aaptOptions = instantiator.newInstance(AaptOptions.class);
    dexOptions = instantiator.newInstance(DexOptions.class);
    lintOptions = instantiator.newInstance(LintOptions.class);
    compileOptions = instantiator.newInstance(CompileOptions.class);
    packagingOptions = instantiator.newInstance(PackagingOptions.class);
    preprocessingOptions = instantiator.newInstance(PreprocessingOptions.class);
    splits = instantiator.newInstance(Splits.class, instantiator);

    sourceSetsContainer = project.container(AndroidSourceSet.class,
            new AndroidSourceSetFactory(instantiator, project, isLibrary));

    sourceSetsContainer.whenObjectAdded(new Action<AndroidSourceSet>() {
        @Override
        public void execute(AndroidSourceSet sourceSet) {
            ConfigurationContainer configurations = project.getConfigurations();

            createConfiguration(
                    configurations,
                    sourceSet.getCompileConfigurationName(),
                    "Classpath for compiling the " + sourceSet.getName() + " sources.");

            String packageConfigDescription;
            if (isLibrary) {
                packageConfigDescription
                        = "Classpath only used when publishing '" + sourceSet.getName() + "'.";
            } else {
                packageConfigDescription
                        = "Classpath packaged with the compiled '" + sourceSet.getName() + "' classes.";
            }
            createConfiguration(
                    configurations,
                    sourceSet.getPackageConfigurationName(),
                    packageConfigDescription);

            createConfiguration(
                    configurations,
                    sourceSet.getProvidedConfigurationName(),
                    "Classpath for only compiling the " + sourceSet.getName() + " sources.");

            createConfiguration(
                    configurations,
                    sourceSet.getWearAppConfigurationName(),
                    "Link to a wear app to embed for object '" + sourceSet.getName() + "'.");

            sourceSet.setRoot(String.format("src/%s", sourceSet.getName()));
        }
    });

    sourceSetsContainer.create(defaultConfig.getName());
}
 

/**
 * Configures the source sets. Note that the Android plugin uses its own implementation of
 * source sets, {@link AndroidSourceSet}.
 */
public void sourceSets(Action<NamedDomainObjectContainer<AndroidSourceSet>> action) {
    checkWritability();
    action.execute(sourceSetsContainer);
}
 

/**
 * All source sets. Note that the Android plugin uses its own implementation of
 * source sets, {@link AndroidSourceSet}.
 */
@Override
public NamedDomainObjectContainer<AndroidSourceSet> getSourceSets() {
    return sourceSetsContainer;
}
 

@Override
public NamedDomainObjectContainer<AndroidSourceSet> getSourceSets() {
    return sourceSetsContainer;
}
 

@Override
@NonNull
public AndroidSourceSet jni(Closure configureClosure) {
    ConfigureUtil.configure(configureClosure, getJni());
    return this;
}
 

private static void setupApiInformationAnalysis(Project project, LibraryExtension android) {
  File metalavaOutputJarFile = new File(project.getRootProject().getBuildDir(), "metalava.jar");
  AndroidSourceSet mainSourceSet = android.getSourceSets().getByName("main");
  File outputFile =
      project
          .getRootProject()
          .file(
              Paths.get(
                  project.getRootProject().getBuildDir().getPath(),
                  "apiinfo",
                  project.getPath().substring(1).replace(":", "_")));
  File outputApiFile = new File(outputFile.getAbsolutePath() + "_api.txt");

  project
      .getTasks()
      .register(
          "getMetalavaJar",
          GetMetalavaJarTask.class,
          task -> {
            task.setOutputFile(metalavaOutputJarFile);
          });
  File apiTxt =
      project.file("api.txt").exists()
          ? project.file("api.txt")
          : project.file(project.getRootDir() + "/empty-api.txt");
  TaskProvider<ApiInformationTask> apiInfo =
      project
          .getTasks()
          .register(
              "apiInformation",
              ApiInformationTask.class,
              task -> {
                task.setApiTxt(apiTxt);
                task.setMetalavaJarPath(metalavaOutputJarFile.getAbsolutePath());
                task.setSourceSet(mainSourceSet);
                task.setOutputFile(outputFile);
                task.setBaselineFile(project.file("baseline.txt"));
                task.setOutputApiFile(outputApiFile);
                if (project.hasProperty("updateBaseline")) {
                  task.setUpdateBaseline(true);
                } else {
                  task.setUpdateBaseline(false);
                }
                task.dependsOn("getMetalavaJar");
              });

  TaskProvider<GenerateApiTxtFileTask> generateApiTxt =
      project
          .getTasks()
          .register(
              "generateApiTxtFile",
              GenerateApiTxtFileTask.class,
              task -> {
                task.setApiTxt(project.file("api.txt"));
                task.setMetalavaJarPath(metalavaOutputJarFile.getAbsolutePath());
                task.setSourceSet(mainSourceSet);
                task.setBaselineFile(project.file("baseline.txt"));
                task.setUpdateBaseline(project.hasProperty("updateBaseline"));
                task.dependsOn("getMetalavaJar");
              });

  TaskProvider<GenerateStubsTask> docStubs =
      project
          .getTasks()
          .register(
              "docStubs",
              GenerateStubsTask.class,
              task -> {
                task.setMetalavaJarPath(metalavaOutputJarFile.getAbsolutePath());
                task.setOutputDir(new File(project.getBuildDir(), "doc-stubs"));
                task.dependsOn("getMetalavaJar");

                task.setSourceSet(mainSourceSet);
              });
  project.getTasks().getByName("check").dependsOn(docStubs);

  android
      .getLibraryVariants()
      .all(
          v -> {
            if (v.getName().equals("release")) {
              FileCollection jars =
                  v.getCompileConfiguration()
                      .getIncoming()
                      .artifactView(
                          config ->
                              config.attributes(
                                  container ->
                                      container.attribute(
                                          Attribute.of("artifactType", String.class), "jar")))
                      .getArtifacts()
                      .getArtifactFiles();
              apiInfo.configure(t -> t.setClassPath(jars));
              generateApiTxt.configure(t -> t.setClassPath(jars));
              docStubs.configure(t -> t.setClassPath(jars));
            }
          });
}
 

@Override
@NonNull
public AndroidSourceSet assets(Closure configureClosure) {
    ConfigureUtil.configure(configureClosure, getAssets());
    return this;
}
 

@Override
@NonNull
public AndroidSourceSet res(Closure configureClosure) {
    ConfigureUtil.configure(configureClosure, getRes());
    return this;
}
 

@Override
@NonNull
public AndroidSourceSet manifest(Closure configureClosure) {
    ConfigureUtil.configure(configureClosure, getManifest());
    return this;
}
 

@Override
public AndroidSourceSet create(String name) {
    return instantiator.newInstance(DefaultAndroidSourceSet.class,
            name, project, isLibrary);
}
 

/**
 * Source sets for all variants
 */
NamedDomainObjectContainer<AndroidSourceSet> getSourceSets();
 

public abstract void setSourceSet(AndroidSourceSet value); 

abstract AndroidSourceSet getSourceSet(); 

public abstract void setSourceSet(AndroidSourceSet value); 

abstract AndroidSourceSet getSourceSet(); 

public abstract void setSourceSet(AndroidSourceSet sourceSet); 

public abstract AndroidSourceSet getSourceSet();