import com.android.build.gradle.api.BaseVariant; //导入依赖的package包/类
@SuppressWarnings("WeakerAccess")
public DomainObjectSet<? extends BaseVariant> getAndroidVariants() {
    if (projectType == null) {
        throw new IllegalStateException("No android plugin found");
    }

    switch (projectType) {
        case APP:
            return ((AppExtension)androidExtension).getApplicationVariants();
        case LIBRARY:
            return ((LibraryExtension)androidExtension).getLibraryVariants();
        case FEATURE:
            return ((FeatureExtension)androidExtension).getFeatureVariants();
        default:
            throw new IllegalStateException("Unexpected project type: " + projectType);
    }
}
 

import com.android.build.gradle.api.BaseVariant; //导入依赖的package包/类
@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.getJavaCompile());
    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<>();

        variant.getJavaCompile().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));
}
 

import com.android.build.gradle.api.BaseVariant; //导入依赖的package包/类
private static Action<BaseVariant> createResourcesTaskCreator(final Project project) {
    return new Action<BaseVariant>() {
        @Override
        public void execute(final BaseVariant variant) {
            ResourcesResGeneratingTask resourcesResGeneratingTask =
                    new ResourcesResGeneratingTask(project, variant);
            ResGeneratingTask.register(resourcesResGeneratingTask);

            MergeResourcesConfigurationTask.create(project, variant, resourcesResGeneratingTask);

            DependenciesJavaGeneratingTask dependenciesJavaGeneratingTask =
                    new DependenciesJavaGeneratingTask(project, variant);
            JavaGeneratingTask.register(dependenciesJavaGeneratingTask);

            ColorsJavaGeneratingTask colorsJavaGeneratingTask =
                    new ColorsJavaGeneratingTask(project, variant, resourcesResGeneratingTask);
            JavaGeneratingTask.register(colorsJavaGeneratingTask);
        }
    };
}
 

import com.android.build.gradle.api.BaseVariant; //导入依赖的package包/类
public GeneratingTask(Project project, BaseVariant variant, String baseName, String outputDirPath,
                      boolean incremental) {
    mProject = project;
    mVariant = variant;

    if (incremental) {
        mGradleTask = project.getTasks().create(generateName(variant, baseName), GradleIncrementalTask.class);
    } else {
        mGradleTask = project.getTasks().create(generateName(variant, baseName), GradleTask.class);
    }

    // Output directory.
    mGradleTask.setOutputDir(project.file(outputDirPath));

    // Set GeneratingTask to be called by task action.
    mGradleTask.setGeneratingTask(this);
}
 

import com.android.build.gradle.api.BaseVariant; //导入依赖的package包/类
protected boolean publishVariant(BaseVariant variant) {
    if (variant instanceof TestVariant || variant instanceof UnitTestVariant) {
        return false;
    }

    return  getAndroidExtension().getDefaultPublishConfig().equals(variant.getName());
}
 

import com.android.build.gradle.api.BaseVariant; //导入依赖的package包/类
@Override
protected Callable<Collection<?>> getExtensionElementsCallable() {
    return () -> {
        ArrayList<BaseVariant> objects = new ArrayList<>();
        objects.addAll(getAndroidVariants());
        objects.addAll(getTestVariants());
        objects.addAll(getUnitTestVariants());
        return objects;
    };
}
 

import com.android.build.gradle.api.BaseVariant; //导入依赖的package包/类
private void configureForVariants(DomainObjectSet<? extends BaseVariant> variants) {
    variants.all(sourceSet -> {
        Task task = project.getTasks().create(getTaskName(sourceSet, getTaskBaseName(), null), getCastedTaskType());
        task.setGroup(JavaBasePlugin.VERIFICATION_GROUP);
        configureForVariant(sourceSet, (T)task);
    });
}
 

import com.android.build.gradle.api.BaseVariant; //导入依赖的package包/类
/**
 * @see SourceSet#getOutput()
 */
protected FileCollection getOutput(AndroidSourceSet androidSourceSet) {
    Stream<BaseVariant> testVariants = Stream.concat(getTestVariants().stream(), getUnitTestVariants().stream());
    Stream<BaseVariant> variants = Stream.concat(getAndroidVariants().stream(), testVariants);

    FileTreeInternal[] sourceTrees = variants
            .filter(variant -> variant.getJavaCompile() != null)
            .filter(variant -> variant.getSourceSets().contains(androidSourceSet))
            .map(variant -> variant.getJavaCompile().getDestinationDir())
            .map(outputDir -> (FileTreeInternal) getProject().fileTree(outputDir))
            .toArray(FileTreeInternal[]::new);
    return new UnionFileTree(sourceTrees);
}
 

import com.android.build.gradle.api.BaseVariant; //导入依赖的package包/类
public ColorsJavaGeneratingTask(Project project, BaseVariant variant,
                                ResourcesResGeneratingTask resourcesResGeneratingTask) {
    super(project, variant, NAME_BASE);

    // Depends on resources res generating task.
    addDependsOn(resourcesResGeneratingTask.getGradleTask());
    addInputFile(resourcesResGeneratingTask.getOutputDir());
}
 

import com.android.build.gradle.api.BaseVariant; //导入依赖的package包/类
public static MergeResourcesConfigurationTask create(Project project, BaseVariant variant,
                                                     ResourcesResGeneratingTask resourcesResGeneratingTask) {
    String name = String.format(NAME_BASE, AaptUtil.capitalize(variant.getName()));
    MergeResourcesConfigurationTask task = project.getTasks().create(name, MergeResourcesConfigurationTask.class);
    task.initialize(variant, resourcesResGeneratingTask);

    return task;
}
 

import com.android.build.gradle.api.BaseVariant; //导入依赖的package包/类
public void initialize(BaseVariant v, ResourcesResGeneratingTask resourcesResGeneratingTask) {
    mVariant = v;
    mVariant.getMergeResources().dependsOn(this);

    dependsOn(resourcesResGeneratingTask.getGradleTask());
    mResFiles = resourcesResGeneratingTask.getResFiles();
}
 

import com.android.build.gradle.api.BaseVariant; //导入依赖的package包/类
public DependenciesJavaGeneratingTask(Project project, BaseVariant variant) {
    super(project, variant, NAME_BASE);

    // Depends on merged resources.
    MergeResources mergeResourcesTask = variant.getMergeResources();
    addDependsOn(mergeResourcesTask);
    mMergeResourcesDir = mergeResourcesTask.getOutputDir();
    addInputFile(mMergeResourcesDir);
}
 

import com.android.build.gradle.api.BaseVariant; //导入依赖的package包/类
public void createHensonNavigatorGenerationTask(BaseVariant variant) {
  if (hensonExtension == null || hensonExtension.getNavigatorPackageName() == null) {
    throw new InvalidParameterException(
        "The property 'henson.navigatorPackageName' must be defined in your build.gradle");
  }
  String hensonNavigatorPackageName = hensonExtension.getNavigatorPackageName();
  File destinationFolder =
      project.file(
          new File(project.getBuildDir(), "generated/source/navigator/" + variant.getName()));
  taskManager.createHensonNavigatorGenerationTask(
      variant, hensonNavigatorPackageName, destinationFolder);
  variant.addJavaSourceFoldersToModel(destinationFolder);
}
 

import com.android.build.gradle.api.BaseVariant; //导入依赖的package包/类
private void setup(Project target, BaseVariant variant) {
    MergeResources mergeResourcesTask = variant.getMergeResources();
    String resizeTaskName = generateTaskName("resize", variant, "Drawables");
    HashMap<String, Object> args = new HashMap<>();
    args.put("type", ResizeDrawablesTask.class);
    args.put("description", "This task resizes current build variant drawables and saves them in project build directory");
    ResizeDrawablesTask resizeTask = (ResizeDrawablesTask) target.task(args, resizeTaskName);
    resizeTask.setBuildVariant(variant);
    mergeResourcesTask.dependsOn(resizeTask);
}
 

import com.android.build.gradle.api.BaseVariant; //导入依赖的package包/类
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());

                if (variant.getJavaCompiler() instanceof JavaCompile) {
                    JavaCompile javacTask = (JavaCompile) variant.getJavaCompiler();

                    javadoc.setSource(javacTask.getSource());

                    javadoc.setClasspath(project.files(javacTask.getDestinationDir()).plus(javacTask.getClasspath()));
                    javadoc.getOptions().setSource(javacTask.getSourceCompatibility());
                } else {
                    getProject().getLogger().warn("Failed to configure {}. Unsupported Compiler: {}", javadoc.getName(), variant.getJavaCompiler().getClass().getName());
                }

                //javadoc.exclude '**/BuildConfig.java'
                javadoc.exclude("**/R.java");

                javadoc.getOptions().encoding("UTF-8");
                javadoc.getOptions().setBootClasspath(getAndroidExtension().getBootClasspath());

                if (javadoc.getOptions() instanceof StandardJavadocDocletOptions) {
                    StandardJavadocDocletOptions realOptions = (StandardJavadocDocletOptions) javadoc.getOptions();

                    realOptions.docEncoding("UTF-8");
                    realOptions.charSet("UTF-8");

                    Serializable javaVersion = GUtil.elvis(Jvm.current().getJavaVersion().getMajorVersion(), '8');
                    realOptions.links("http://docs.oracle.com/javase/" + javaVersion + "/docs/api/");
                    realOptions.linksOffline("http://developer.android.com/reference/", getAndroidExtension().getSdkDirectory() + "/docs/reference");
                }

                javadoc.setFailOnError(false);

                File docsDir;
                if (project.hasProperty("docsDir")) {
                    docsDir = (File) project.property("docsDir");
                } else {
                    docsDir = new File(project.getBuildDir(), "docs");
                }
                File javadocDir = new File(docsDir, "javadoc");
                javadoc.setDestinationDir(new File(javadocDir, variant.getDirName()));
            });

            javadocTasks.put(variant.getName(), task);
        }

        return javadocTasks.get(variant.getName());
    }
 

import com.android.build.gradle.api.BaseVariant; //导入依赖的package包/类
public Collection<BaseVariant> getVariants() {
    return this.variants;
}
 

import com.android.build.gradle.api.BaseVariant; //导入依赖的package包/类
public void setVariants(Collection<BaseVariant> variants) {
    this.variants = variants;
}
 

import com.android.build.gradle.api.BaseVariant; //导入依赖的package包/类
/**
 * @see SourceSet#getOutput()
 */
protected FileTree getOutput(BaseVariant androidSourceSet) {
    return getProject().fileTree(androidSourceSet.getJavaCompile().getDestinationDir());
}
 

import com.android.build.gradle.api.BaseVariant; //导入依赖的package包/类
@Override
public void addVariant(BaseVariant variant) {
    applicationVariantList.add((ApplicationVariant) variant);
}
 

import com.android.build.gradle.api.BaseVariant; //导入依赖的package包/类
public void create(BaseVariantData<?> variantData) {
    if (variantData.getType().isForTesting()) {
        // Testing variants are handled together with their "owners".
        return;
    }

    BaseVariant variantApi =
            variantFactory.createVariantApi(variantData, readOnlyObjectProvider);

    if (variantFactory.hasTestScope()) {
        TestVariantData androidTestVariantData =
                ((TestedVariantData) variantData).getTestVariantData(ANDROID_TEST);

        if (androidTestVariantData != null) {
            TestVariantImpl androidTestVariant = instantiator.newInstance(
                    TestVariantImpl.class,
                    androidTestVariantData,
                    variantApi,
                    androidBuilder,
                    readOnlyObjectProvider);

            // add the test output.
            ApplicationVariantFactory.createApkOutputApiObjects(
                    instantiator,
                    androidTestVariantData,
                    androidTestVariant);

            ((TestedAndroidConfig) extension).getTestVariants().add(androidTestVariant);
            ((TestedVariant) variantApi).setTestVariant(androidTestVariant);
        }

        TestVariantData unitTestVariantData =
                ((TestedVariantData) variantData).getTestVariantData(UNIT_TEST);
        if (unitTestVariantData != null) {
            UnitTestVariantImpl unitTestVariant = instantiator.newInstance(
                    UnitTestVariantImpl.class,
                    unitTestVariantData,
                    variantApi,
                    androidBuilder,
                    readOnlyObjectProvider);

            ((TestedAndroidConfig) extension).getUnitTestVariants().add(unitTestVariant);
            ((TestedVariant) variantApi).setUnitTestVariant(unitTestVariant);
        }
    }

    // Only add the variant API object to the domain object set once it's been fully
    // initialized.
    extension.addVariant(variantApi);
}