com.android.build.gradle.internal.dsl.DexOptions Java Examples

public AtlasMultiDexListTransform(VariantScope variantScope, DexOptions dexOptions) {
    super(variantScope);
    this.variantScope = variantScope;
    mainDexListFile = variantScope.getMainDexListFile();
    this.manifestKeepListProguardFile = variantScope.getManifestKeepListProguardFile();
    this.userMainDexKeepProguard = variantScope.getVariantConfiguration().getMultiDexKeepProguard();
    this.userMainDexKeepFile = variantScope.getVariantConfiguration().getMultiDexKeepFile();

}
 

public static void configure(
        @NonNull AndroidConfig model,
        @NonNull Instantiator instantiator) {
    model.setDefaultPublishConfig(BuilderConstants.RELEASE);
    model.setPublishNonDefault(false);
    model.setGeneratePureSplits(false);
    model.setPreProcessingOptions(instantiator.newInstance(PreprocessingOptions.class));
    model.setAaptOptions(instantiator.newInstance(AaptOptions.class));
    model.setDexOptions(instantiator.newInstance(DexOptions.class));
    model.setLintOptions(instantiator.newInstance(LintOptions.class));
    model.setCompileOptions(instantiator.newInstance(CompileOptions.class));
    model.setPackagingOptions(instantiator.newInstance(PackagingOptions.class));
    model.setSplits(instantiator.newInstance(Splits.class, instantiator));
    model.setLibraryRequests(Lists.<LibraryRequest>newArrayList());
}
 

public AndroidExtension(Project project, ToolingModelBuilderRegistry registry) {
    this.project = project;

    this.extraModelInfo = new ExtraModelInfo(new ProjectOptions(project), project.getLogger());

    this.signingConfig = project.getExtensions().create("signingConfig", SigningConfig.class, "signing");
    this.packagingOptions = project.getExtensions().create("packagingOptions", PackagingOptions.class);
    this.dexOptions = project.getExtensions().create("dexOptions", DexOptions.class, extraModelInfo);

    try {
        this.buildCache = FileCache.getInstanceWithMultiProcessLocking(new File(AndroidLocation.getFolder(), "build-cache"));
    } catch (AndroidLocation.AndroidLocationException e) {
        throw new RuntimeException(e);
    }

    LoggerWrapper loggerWrapper = new LoggerWrapper(project.getLogger());

    this.sdkHandler = new SdkHandler(project, loggerWrapper);
    this.androidBuilder = new AndroidBuilder(
            project == project.getRootProject() ? project.getName() : project.getPath(),
            "JavaFX Mobile",
            new GradleProcessExecutor(project),
            new GradleJavaProcessExecutor(project),
            extraModelInfo,
            loggerWrapper,
            false);

    this.androidTaskRegistry = new AndroidTaskRegistry();
    this.taskFactory = new TaskContainerAdaptor(project.getTasks());

    installDirectory = new File(project.getBuildDir(), "javafxports/android");
    project.getLogger().info("Android install directory: " + installDirectory);

    temporaryDirectory = new File(project.getBuildDir(), "javafxports/tmp/android");
    project.getLogger().info("Android temporary output directory: " + temporaryDirectory);

    resourcesDirectory = new File(temporaryDirectory, "resources");
    resourcesDirectory.mkdirs();
    project.getLogger().info("Resources directory: " + resourcesDirectory);

    multidexOutputDirectory = new File(temporaryDirectory, "multi-dex");
    multidexOutputDirectory.mkdirs();
    project.getLogger().info("Multi-dex output directory: " + multidexOutputDirectory);

    dexOutputDirectory = new File(temporaryDirectory, "dex");
    dexOutputDirectory.mkdirs();
    project.getLogger().info("Dex output directory: " + dexOutputDirectory);
}
 

public DexOptions getDexOptions() {
    return dexOptions;
}
 

@Nested
public DexOptions getDexOptions() {
    return dexOptions;
}
 

public void setDexOptions(DexOptions dexOptions) {
    this.dexOptions = dexOptions;
}
 

public DexOptions getDexOptions() {
    return dexOptions;
}
 

public void setDexOptions(DexOptions dexOptions) {
    this.dexOptions = dexOptions;
}
 

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 dex options.
 */
public void dexOptions(Action<DexOptions> action) {
    checkWritability();
    action.execute(dexOptions);
}
 

/**
 * {@inheritDoc}
 */
@Override
public DexOptions getDexOptions() {
    return dexOptions;
}
 

@Override
public DexOptions getDexOptions() {
    return model.getDexOptions();
}
 

/**
 * Dex options.
 */
DexOptions getDexOptions();
 

/**
 * Dex options.
 */

DexOptions getDexOptions();
 

void setDexOptions(DexOptions dexOptions);