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

private void repalceAndroidBuilder(ApplicationVariant applicationVariant) {
        try {
            if (applicationVariant instanceof ApplicationVariantImpl) {
                VariantScope variantScope = ((ApplicationVariantImpl) applicationVariant).getVariantData().getScope();
                GlobalScope globalScope = variantScope.getGlobalScope();
//                ReflectUtils.updateField(globalScope, "androidBuilder", AtlasBuildContext.androidBuilderMap.get(globalScope.getProject()));
//                Field f = ProjectOptions.class.getDeclaredField("booleanOptions");
//                f.setAccessible(true);
//                Map map = (Map) f.get(((ApplicationVariantImpl) applicationVariant).getVariantData().getScope().getGlobalScope().getProjectOptions());
//                map.put(BooleanOption.ENABLE_AAPT2, false);
                AtlasBuildContext.androidBuilderMap.get(globalScope.getProject()).initAapt(globalScope.getProjectOptions());

            }
        } catch (Exception e) {
            logger.error(e, "write globalScope androidBuilder field failed!");
        }
    }
 

@Override
@NonNull
public ApplicationVariant createVariantApi(
        @NonNull BaseVariantData<? extends BaseVariantOutputData> variantData,
        @NonNull ReadOnlyObjectProvider readOnlyObjectProvider) {
    // create the base variant object.
    ApplicationVariantImpl variant = instantiator.newInstance(
            ApplicationVariantImpl.class,
            variantData,
            androidBuilder,
            readOnlyObjectProvider);

    // now create the output objects
    createApkOutputApiObjects(instantiator, variantData, variant);

    return variant;
}
 

private File getApkFile(AndroidPublisherExtension publisherExtension) {
	String variantName = publisherExtension.getVariantName();
	DomainObjectSet<ApplicationVariant> variants = getProject().getExtensions().getByType(AppExtension.class).getApplicationVariants();
	ApplicationVariant variant = null;
	getLogger().info(String.format("Looking for %s variant in outputs", variantName));
	for (ApplicationVariant v : variants) {
		getLogger().debug(String.format("Found variant %s", v.getName()));
		if (v.getName().equals(variantName)) {
			getLogger().debug(String.format("Variant %s will be used", variantName));
			variant = v;
			break;
		}
	}
	if (variant == null) {
		throw new InvalidUserDataException(String.format(
				"Cannot find %s variant for android configuration", variantName));
	}

	for(BaseVariantOutput output : variant.getOutputs()) {
		getLogger().debug(String.format("Found output %s (%s)", output.getName(), output.getBaseName()));
		if (output!=null) {
			getLogger().debug(String.format("Output %s will be used", output.getName()));
			return output.getOutputFile();
		}
	}
	throw new InvalidUserDataException(String.format(
			"Cannot find APK output file for %s variant", variantName));
}
 

@Override
public void addVariant(BaseVariant variant) {
    applicationVariantList.add((ApplicationVariant) variant);
}
 

@Override
public Consumer<BufferedImage> apply(ApplicationVariant variant, File iconFile) {
    return new ColorRibbonFilter(variant.getBuildType().getName(), Color.decode(nm));
}
 

public Consumer<BufferedImage> grayScaleFilter(ApplicationVariant variant, File iconFile) {
    return new GrayScaleBuilder().apply(variant, iconFile);
}
 

public Consumer<BufferedImage> grayRibbonFilter(ApplicationVariant variant, File iconFile) {
    return new GrayRibbonBuilder().apply(variant, iconFile);
}
 

public Consumer<BufferedImage> yellowRibbonFilter(ApplicationVariant variant, File iconFile) {
    return new YellowRibbonBuilder().apply(variant, iconFile);
}
 

public Consumer<BufferedImage> greenRibbonFilter(ApplicationVariant variant, File iconFile) {
    return new GreenRibbonBuilder().apply(variant, iconFile);
}
 

public Consumer<BufferedImage> customColorRibbonFilter(ApplicationVariant variant, File iconFile, String nm) {
    return new CustomColorRibbonBuilder(nm).apply(variant, iconFile);
}
 

@Override
public Consumer<BufferedImage> apply(ApplicationVariant variant, File iconFile) {
    return new ColorRibbonFilter(variant.getBuildType().getName(), COLOR);
}
 

@Override
public Consumer<BufferedImage> apply(ApplicationVariant variant, File iconFile) {
    return new ColorRibbonFilter(variant.getBuildType().getName(), COLOR);
}
 

@Override
public Consumer<BufferedImage> apply(ApplicationVariant variant, File iconFile) {
    return new ColorRibbonFilter(variant.getBuildType().getName(), COLOR);
}
 

@Override
public Consumer<BufferedImage> apply(ApplicationVariant applicationVariant, File iconFile) {
    return new GrayScaleFilter();
}
 

public AppVariantContext getAppVariantContext(Project project, ApplicationVariant applicationVariant) {

        AppVariantContext appVariantContext = appVariantContextMap.get(applicationVariant);

        if (null == appVariantContext) {

            appVariantContext = create(project, (ApplicationVariantImpl)applicationVariant);

            appVariantContextMap.put(applicationVariant, appVariantContext);

        }

        return appVariantContext;

    }
 

/**
 * Returns the list of Application variants. Since the collections is built after evaluation, it
 * should be used with Gradle's <code>all</code> iterator to process future items.
 */
public DefaultDomainObjectSet<ApplicationVariant> getApplicationVariants() {
    return applicationVariantList;
}