// Copyright 2015 The Bazel Authors. All rights reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package com.google.devtools.build.lib.rules.android; import com.google.common.base.Ascii; import com.google.common.collect.ImmutableList; import com.google.devtools.build.lib.analysis.config.BuildOptions; import com.google.devtools.build.lib.analysis.config.CoreOptionConverters.EmptyToNullLabelConverter; import com.google.devtools.build.lib.analysis.config.CoreOptionConverters.LabelConverter; import com.google.devtools.build.lib.analysis.config.CoreOptionConverters.LabelOrderedSetConverter; import com.google.devtools.build.lib.analysis.config.Fragment; import com.google.devtools.build.lib.analysis.config.FragmentOptions; import com.google.devtools.build.lib.analysis.config.InvalidConfigurationException; import com.google.devtools.build.lib.analysis.config.RequiresOptions; import com.google.devtools.build.lib.analysis.starlark.annotations.StarlarkConfigurationField; import com.google.devtools.build.lib.cmdline.Label; import com.google.devtools.build.lib.concurrent.ThreadSafety.Immutable; import com.google.devtools.build.lib.rules.cpp.CppConfiguration.DynamicMode; import com.google.devtools.build.lib.rules.cpp.CppOptions.DynamicModeConverter; import com.google.devtools.build.lib.rules.cpp.CppOptions.LibcTopLabelConverter; import com.google.devtools.build.lib.starlarkbuildapi.android.AndroidConfigurationApi; import com.google.devtools.common.options.Converters; import com.google.devtools.common.options.EnumConverter; import com.google.devtools.common.options.Option; import com.google.devtools.common.options.OptionDocumentationCategory; import com.google.devtools.common.options.OptionEffectTag; import com.google.devtools.common.options.OptionMetadataTag; import java.util.List; import java.util.Locale; import javax.annotation.Nullable; import net.starlark.java.eval.StarlarkValue; /** Configuration fragment for Android rules. */ @Immutable @RequiresOptions(options = {AndroidConfiguration.Options.class}) public class AndroidConfiguration extends Fragment implements AndroidConfigurationApi { /** * Converter for {@link * com.google.devtools.build.lib.rules.android.AndroidConfiguration.ConfigurationDistinguisher} */ public static final class ConfigurationDistinguisherConverter extends EnumConverter { public ConfigurationDistinguisherConverter() { super(ConfigurationDistinguisher.class, "Android configuration distinguisher"); } } /** Converter for {@link ApkSigningMethod}. */ public static final class ApkSigningMethodConverter extends EnumConverter { public ApkSigningMethodConverter() { super(ApkSigningMethod.class, "apk signing method"); } } /** Converter for {@link AndroidManifestMerger} */ public static final class AndroidManifestMergerConverter extends EnumConverter { public AndroidManifestMergerConverter() { super(AndroidManifestMerger.class, "android manifest merger"); } } /** Converter for {@link ManifestMergerOrder} */ public static final class ManifestMergerOrderConverter extends EnumConverter { public ManifestMergerOrderConverter() { super(ManifestMergerOrder.class, "android manifest merger order"); } } /** * Value used to avoid multiple configurations from conflicting. * *

This is set to {@code ANDROID} in Android configurations and to {@code MAIN} otherwise. This * influences the output directory name: if it didn't, an Android and a non-Android configuration * would conflict if they had the same toolchain identifier. * *

Note that this is not just a theoretical concern: even if {@code --crosstool_top} and {@code * --android_crosstool_top} point to different labels, they may end up being redirected to the * same thing, and this is exactly what happens on OSX X. */ public enum ConfigurationDistinguisher implements StarlarkValue { MAIN(null), ANDROID("android"); private final String suffix; ConfigurationDistinguisher(String suffix) { this.suffix = suffix; } } /** * Which APK signing method to use with the debug key for rules that build APKs. * *

    *
  • V1 uses the apksigner attribute from the android_sdk and signs the APK as a JAR. *
  • V2 uses the apksigner attribute from the android_sdk and signs the APK according to the * APK Signing Schema V2 that is only supported on Android N and later. *
  • V4 uses the apksigner attribute from the android_sdk and signs the APK according to the * APK Signing Schema V4 that is only supported on Android R/build tools 30 and later. It * generates a V4 signature file alongside the APK file. *
*/ public enum ApkSigningMethod { V1(true, false), V2(false, true), V1_V2(true, true), V4(false, false, true); private final boolean signV1; private final boolean signV2; private final Boolean signV4; ApkSigningMethod(boolean signV1, boolean signV2) { this(signV1, signV2, null); } ApkSigningMethod(boolean signV1, boolean signV2, @Nullable Boolean signV4) { this.signV1 = signV1; this.signV2 = signV2; this.signV4 = signV4; } /** Whether to JAR sign the APK with the apksigner tool. */ public boolean signV1() { return signV1; } /** Whether to sign the APK with the apksigner tool with APK Signature Schema V2. */ public boolean signV2() { return signV2; } /** * Whether to sign the APK with the apksigner tool with APK Signature Schema V4. * *

If null/unset, the V4 signing flag should not be passed to apksigner. This extra level of * control is needed to support environments where older build tools may be used. */ @Nullable public Boolean signV4() { return signV4; } } /** Types of android manifest mergers. */ public enum AndroidManifestMerger { LEGACY, ANDROID, FORCE_ANDROID; public static ImmutableList getAttributeValues() { return ImmutableList.of( LEGACY.name().toLowerCase(Locale.ROOT), ANDROID.name().toLowerCase(Locale.ROOT), FORCE_ANDROID.name().toLowerCase(Locale.ROOT), getRuleAttributeDefault()); } public static String getRuleAttributeDefault() { return "auto"; } @Nullable public static AndroidManifestMerger fromString(String value) { for (AndroidManifestMerger merger : AndroidManifestMerger.values()) { if (merger.name().equalsIgnoreCase(value)) { return merger; } } return null; } } /** Orders for merging android manifests. */ public enum ManifestMergerOrder { /** Manifests are sorted alphabetically by exec path. */ ALPHABETICAL, /** Manifests are sorted alphabetically by configuration-relative path. */ ALPHABETICAL_BY_CONFIGURATION, /** Library manifests come before the manifests of their dependencies. */ DEPENDENCY; } /** Android configuration options. */ public static class Options extends FragmentOptions { @Option( name = "Android configuration distinguisher", defaultValue = "MAIN", converter = ConfigurationDistinguisherConverter.class, documentationCategory = OptionDocumentationCategory.UNDOCUMENTED, effectTags = OptionEffectTag.BAZEL_INTERNAL_CONFIGURATION, metadataTags = {OptionMetadataTag.INTERNAL, OptionMetadataTag.EXPLICIT_IN_OUTPUT_PATH}) public ConfigurationDistinguisher configurationDistinguisher; // TODO(blaze-configurability): Mark this as deprecated in favor of --android_platforms. @Option( name = "android_crosstool_top", defaultValue = "//external:android/crosstool", converter = EmptyToNullLabelConverter.class, documentationCategory = OptionDocumentationCategory.TOOLCHAIN, effectTags = { OptionEffectTag.AFFECTS_OUTPUTS, OptionEffectTag.CHANGES_INPUTS, OptionEffectTag.LOADING_AND_ANALYSIS, OptionEffectTag.LOSES_INCREMENTAL_STATE, }, help = "The location of the C++ compiler used for Android builds.") public Label androidCrosstoolTop; // TODO(blaze-configurability): Mark this as deprecated in favor of --android_platforms. @Option( name = "android_cpu", defaultValue = "armeabi-v7a", documentationCategory = OptionDocumentationCategory.OUTPUT_PARAMETERS, effectTags = { OptionEffectTag.AFFECTS_OUTPUTS, OptionEffectTag.LOADING_AND_ANALYSIS, OptionEffectTag.LOSES_INCREMENTAL_STATE, }, help = "The Android target CPU.") public String cpu; // TODO(blaze-configurability): Mark this as deprecated in favor of --android_platforms. @Option( name = "android_compiler", defaultValue = "null", documentationCategory = OptionDocumentationCategory.TOOLCHAIN, effectTags = { OptionEffectTag.AFFECTS_OUTPUTS, OptionEffectTag.LOADING_AND_ANALYSIS, OptionEffectTag.LOSES_INCREMENTAL_STATE, }, help = "The Android target compiler.") public String cppCompiler; // TODO(blaze-configurability): Mark this as deprecated in favor of the new min_sdk feature. @Option( name = "android_grte_top", defaultValue = "null", converter = LibcTopLabelConverter.class, documentationCategory = OptionDocumentationCategory.TOOLCHAIN, effectTags = { OptionEffectTag.CHANGES_INPUTS, OptionEffectTag.LOADING_AND_ANALYSIS, OptionEffectTag.LOSES_INCREMENTAL_STATE, }, help = "The Android target grte_top.") public Label androidLibcTopLabel; @Option( name = "android_dynamic_mode", defaultValue = "off", converter = DynamicModeConverter.class, documentationCategory = OptionDocumentationCategory.OUTPUT_PARAMETERS, effectTags = { OptionEffectTag.AFFECTS_OUTPUTS, OptionEffectTag.LOADING_AND_ANALYSIS, }, help = "Determines whether C++ deps of Android rules will be linked dynamically when a " + "cc_binary does not explicitly create a shared library. " + "'default' means bazel will choose whether to link dynamically. " + "'fully' means all libraries will be linked dynamically. " + "'off' means that all libraries will be linked in mostly static mode.") public DynamicMode dynamicMode; // Label of filegroup combining all Android tools used as implicit dependencies of // android_* rules // TODO(blaze-configurability): Mark this as deprecated in favor of --android_platforms. @Option( name = "android_sdk", defaultValue = "@bazel_tools//tools/android:sdk", converter = LabelConverter.class, documentationCategory = OptionDocumentationCategory.TOOLCHAIN, effectTags = { OptionEffectTag.CHANGES_INPUTS, OptionEffectTag.LOADING_AND_ANALYSIS, OptionEffectTag.LOSES_INCREMENTAL_STATE, }, help = "Specifies Android SDK/platform that is used to build Android applications.") public Label sdk; // TODO(bazel-team): Maybe merge this with --android_cpu above. // TODO(blaze-configurability): Mark this as deprecated in favor of --android_platforms. @Option( name = "fat_apk_cpu", converter = Converters.CommaSeparatedOptionSetConverter.class, defaultValue = "armeabi-v7a", documentationCategory = OptionDocumentationCategory.OUTPUT_PARAMETERS, effectTags = { OptionEffectTag.AFFECTS_OUTPUTS, OptionEffectTag.LOADING_AND_ANALYSIS, OptionEffectTag.LOSES_INCREMENTAL_STATE, }, help = "Setting this option enables fat APKs, which contain native binaries for all " + "specified target architectures, e.g., --fat_apk_cpu=x86,armeabi-v7a. If this " + "flag is specified, then --android_cpu is ignored for dependencies of " + "android_binary rules.") public List fatApkCpus; @Option( name = "android_platforms", converter = LabelOrderedSetConverter.class, documentationCategory = OptionDocumentationCategory.TOOLCHAIN, defaultValue = "", effectTags = { OptionEffectTag.CHANGES_INPUTS, OptionEffectTag.LOADING_AND_ANALYSIS, OptionEffectTag.LOSES_INCREMENTAL_STATE, }, help = "Sets the platforms that android_binary targets use. If multiple platforms are" + " specified, then the binary is a fat APKs, which contains native binaries for" + " each specified target platform.") public List

Consequently, we use this option to decide between param files or regular command line * parameters. If we're not using workers or on Windows, there's no need to always use param * files for I/O performance reasons. */ @Option( name = "internal_persistent_busybox_tools", documentationCategory = OptionDocumentationCategory.UNDOCUMENTED, effectTags = { OptionEffectTag.HOST_MACHINE_RESOURCE_OPTIMIZATIONS, OptionEffectTag.EXECUTION, }, defaultValue = "false", help = "Tracking flag for when busybox workers are enabled.") public boolean persistentBusyboxTools; @Option( name = "internal_persistent_multiplex_busybox_tools", documentationCategory = OptionDocumentationCategory.UNDOCUMENTED, effectTags = { OptionEffectTag.HOST_MACHINE_RESOURCE_OPTIMIZATIONS, OptionEffectTag.EXECUTION, }, defaultValue = "false", help = "Tracking flag for when multiplexed busybox workers are enabled.") public boolean persistentMultiplexBusyboxTools; /** * We use this option to decide when to enable workers for busybox tools. This flag is also a * guard against enabling workers using nothing but --persistent_android_resource_processor. * *

Consequently, we use this option to decide between param files or regular command line * parameters. If we're not using workers or on Windows, there's no need to always use param * files for I/O performance reasons. */ @Option( name = "internal_persistent_android_dex_desugar", documentationCategory = OptionDocumentationCategory.UNDOCUMENTED, effectTags = { OptionEffectTag.HOST_MACHINE_RESOURCE_OPTIMIZATIONS, OptionEffectTag.EXECUTION, }, defaultValue = "false", help = "Tracking flag for when dexing and desugaring workers are enabled.") public boolean persistentDexDesugar; @Option( name = "internal_persistent_multiplex_android_dex_desugar", documentationCategory = OptionDocumentationCategory.UNDOCUMENTED, effectTags = { OptionEffectTag.HOST_MACHINE_RESOURCE_OPTIMIZATIONS, OptionEffectTag.EXECUTION, }, defaultValue = "false", help = "Tracking flag for when multiplexed dexing and desugaring workers are enabled.") public boolean persistentMultiplexDexDesugar; @Option( name = "experimental_remove_r_classes_from_instrumentation_test_jar", defaultValue = "true", documentationCategory = OptionDocumentationCategory.UNDOCUMENTED, effectTags = { OptionEffectTag.CHANGES_INPUTS, }, help = "If enabled and the test instruments an application, all the R classes from the test's " + "deploy jar will be removed.") public boolean removeRClassesFromInstrumentationTestJar; @Option( name = "experimental_always_filter_duplicate_classes_from_android_test", defaultValue = "false", documentationCategory = OptionDocumentationCategory.UNDOCUMENTED, effectTags = { OptionEffectTag.CHANGES_INPUTS, }, help = "If enabled and the android_test defines a binary_under_test, the class filterering " + "applied to the test's deploy jar will always filter duplicate classes based " + "solely on matching class and package name, ignoring hash values.") public boolean alwaysFilterDuplicateClassesFromAndroidTest; @Option( name = "experimental_filter_library_jar_with_program_jar", defaultValue = "false", documentationCategory = OptionDocumentationCategory.BUILD_TIME_OPTIMIZATION, effectTags = {OptionEffectTag.ACTION_COMMAND_LINES}, help = "Filter the ProGuard ProgramJar to remove any classes also present in the LibraryJar.") public boolean filterLibraryJarWithProgramJar; @Option( name = "experimental_use_rtxt_from_merged_resources", defaultValue = "false", documentationCategory = OptionDocumentationCategory.UNDOCUMENTED, effectTags = {OptionEffectTag.CHANGES_INPUTS}, help = "Use R.txt from the merging action, instead of from the validation action.") public boolean useRTxtFromMergedResources; @Option( name = "output_library_merged_assets", defaultValue = "true", documentationCategory = OptionDocumentationCategory.UNDOCUMENTED, effectTags = {OptionEffectTag.UNKNOWN}, help = "If disabled, does not produce merged asset.zip outputs for library targets") public boolean outputLibraryMergedAssets; @Option( name = "legacy_main_dex_list_generator", // TODO(b/147692286): Update this default value to R8's GenerateMainDexList binary after // migrating usage. defaultValue = "null", converter = LabelConverter.class, documentationCategory = OptionDocumentationCategory.UNCATEGORIZED, effectTags = {OptionEffectTag.UNKNOWN}, help = "Specifies a binary to use to generate the list of classes that must be in the main" + " dex when compiling legacy multidex.") public Label legacyMainDexListGenerator; @Option( name = "optimizing_dexer", defaultValue = "null", converter = LabelConverter.class, documentationCategory = OptionDocumentationCategory.UNCATEGORIZED, effectTags = {OptionEffectTag.UNKNOWN}, help = "Specifies a binary to use to do dexing without sharding.") public Label optimizingDexer; @Option( name = "experimental_disable_instrumentation_manifest_merge", defaultValue = "false", documentationCategory = OptionDocumentationCategory.UNDOCUMENTED, effectTags = {OptionEffectTag.AFFECTS_OUTPUTS}, help = "Disables manifest merging when an android_binary has instruments set (i.e. is used " + "for instrumentation testing).") public boolean disableInstrumentationManifestMerging; @Option( name = "experimental_get_android_java_resources_from_optimized_jar", defaultValue = "false", documentationCategory = OptionDocumentationCategory.UNDOCUMENTED, effectTags = {OptionEffectTag.CHANGES_INPUTS}, help = "Get Java resources from _proguard.jar instead of _deploy.jar in android_binary when " + "bundling the final APK.") public boolean getJavaResourcesFromOptimizedJar; @Option( name = "android_include_proguard_location_references", defaultValue = "false", documentationCategory = OptionDocumentationCategory.UNDOCUMENTED, effectTags = {OptionEffectTag.AFFECTS_OUTPUTS}, help = "When using aapt2 to generate proguard configurations, include location references." + " This will make the build nondeterministic.") public boolean includeProguardLocationReferences; @Option( name = "incompatible_android_platforms_transition_updated_affected", defaultValue = "false", documentationCategory = OptionDocumentationCategory.UNDOCUMENTED, effectTags = OptionEffectTag.LOADING_AND_ANALYSIS, metadataTags = {OptionMetadataTag.INCOMPATIBLE_CHANGE}, help = "If set to true, the AndroidPlatformsTransition will also update `affected by Starlark" + " transition` with changed options to avoid potential action conflicts.") public boolean androidPlatformsTransitionsUpdateAffected; @Override public FragmentOptions getExec() { Options exec = (Options) super.getExec(); exec.hwasan = false; exec.androidCrosstoolTop = androidCrosstoolTop; exec.sdk = sdk; exec.fatApkCpus = ImmutableList.of(); // Fat APK archs don't apply to the exec platform.. exec.incompatibleUseToolchainResolution = incompatibleUseToolchainResolution; exec.androidPlatformsTransitionsUpdateAffected = androidPlatformsTransitionsUpdateAffected; exec.desugarJava8 = desugarJava8; exec.desugarJava8Libs = desugarJava8Libs; exec.checkDesugarDeps = checkDesugarDeps; exec.incrementalDexing = incrementalDexing; exec.incrementalDexingShardsAfterProguard = incrementalDexingShardsAfterProguard; exec.incrementalDexingUseDexSharder = incrementalDexingUseDexSharder; exec.incrementalDexingAfterProguardByDefault = incrementalDexingAfterProguardByDefault; exec.assumeMinSdkVersion = assumeMinSdkVersion; exec.nonIncrementalPerTargetDexopts = nonIncrementalPerTargetDexopts; exec.dexoptsSupportedInIncrementalDexing = dexoptsSupportedInIncrementalDexing; exec.dexoptsSupportedInDexMerger = dexoptsSupportedInDexMerger; exec.dexoptsSupportedInDexSharder = dexoptsSupportedInDexSharder; exec.manifestMerger = manifestMerger; exec.manifestMergerOrder = manifestMergerOrder; exec.oneVersionEnforcementUseTransitiveJarsForBinaryUnderTest = oneVersionEnforcementUseTransitiveJarsForBinaryUnderTest; exec.persistentAarExtractor = persistentAarExtractor; exec.persistentBusyboxTools = persistentBusyboxTools; exec.persistentMultiplexBusyboxTools = persistentMultiplexBusyboxTools; exec.disableNativeAndroidRules = disableNativeAndroidRules; // Unless the build was started from an Android device, exec means MAIN. exec.configurationDistinguisher = ConfigurationDistinguisher.MAIN; return exec; } } private final Label sdk; private final String cpu; private final ConfigurationDistinguisher configurationDistinguisher; private final boolean incrementalDexing; private final int incrementalDexingShardsAfterProguard; private final boolean incrementalDexingUseDexSharder; private final boolean incrementalDexingAfterProguardByDefault; private final boolean assumeMinSdkVersion; private final ImmutableList dexoptsSupportedInIncrementalDexing; private final ImmutableList targetDexoptsThatPreventIncrementalDexing; private final ImmutableList dexoptsSupportedInDexMerger; private final ImmutableList dexoptsSupportedInDexSharder; private final boolean desugarJava8; private final boolean desugarJava8Libs; private final boolean checkDesugarDeps; private final boolean useRexToCompressDexFiles; private final boolean useAndroidResourceShrinking; private final boolean useAndroidResourceCycleShrinking; private final boolean useAndroidResourcePathShortening; private final boolean useAndroidResourceNameObfuscation; private final AndroidManifestMerger manifestMerger; private final ManifestMergerOrder manifestMergerOrder; private final ApkSigningMethod apkSigningMethod; private final boolean useSingleJarApkBuilder; private final boolean compressJavaResources; private final boolean exportsManifestDefault; private final boolean useParallelDex2Oat; private final boolean breakBuildOnParallelDex2OatFailure; private final boolean omitResourcesInfoProviderFromAndroidBinary; private final boolean fixedResourceNeverlinking; private final boolean checkForMigrationTag; private final boolean oneVersionEnforcementUseTransitiveJarsForBinaryUnderTest; private final boolean dataBindingV2; private final boolean dataBindingUpdatedArgs; private final boolean dataBindingAndroidX; private final boolean persistentAarExtractor; private final boolean persistentBusyboxTools; private final boolean persistentMultiplexBusyboxTools; private final boolean persistentDexDesugar; private final boolean persistentMultiplexDexDesugar; private final boolean filterRJarsFromAndroidTest; private final boolean removeRClassesFromInstrumentationTestJar; private final boolean alwaysFilterDuplicateClassesFromAndroidTest; private final boolean filterLibraryJarWithProgramJar; private final boolean useRTxtFromMergedResources; private final boolean outputLibraryMergedAssets; private final Label legacyMainDexListGenerator; private final Label optimizingDexer; private final boolean disableInstrumentationManifestMerging; private final boolean incompatibleUseToolchainResolution; private final boolean hwasan; private final boolean getJavaResourcesFromOptimizedJar; private final boolean includeProguardLocationReferences; public AndroidConfiguration(BuildOptions buildOptions) throws InvalidConfigurationException { Options options = buildOptions.get(Options.class); this.sdk = options.sdk; this.cpu = options.cpu; this.configurationDistinguisher = options.configurationDistinguisher; this.incrementalDexing = options.incrementalDexing; this.incrementalDexingShardsAfterProguard = options.incrementalDexingShardsAfterProguard; this.incrementalDexingUseDexSharder = options.incrementalDexingUseDexSharder; this.incrementalDexingAfterProguardByDefault = options.incrementalDexingAfterProguardByDefault; this.assumeMinSdkVersion = options.assumeMinSdkVersion; this.dexoptsSupportedInIncrementalDexing = ImmutableList.copyOf(options.dexoptsSupportedInIncrementalDexing); this.targetDexoptsThatPreventIncrementalDexing = ImmutableList.copyOf(options.nonIncrementalPerTargetDexopts); this.dexoptsSupportedInDexMerger = ImmutableList.copyOf(options.dexoptsSupportedInDexMerger); this.dexoptsSupportedInDexSharder = ImmutableList.copyOf(options.dexoptsSupportedInDexSharder); this.desugarJava8 = options.desugarJava8; this.desugarJava8Libs = options.desugarJava8Libs; this.checkDesugarDeps = options.checkDesugarDeps; this.useAndroidResourceShrinking = options.useAndroidResourceShrinking || options.useExperimentalAndroidResourceShrinking; this.useAndroidResourceCycleShrinking = options.useAndroidResourceCycleShrinking; this.useAndroidResourcePathShortening = options.useAndroidResourcePathShortening; this.useAndroidResourceNameObfuscation = options.useAndroidResourceNameObfuscation; this.manifestMerger = options.manifestMerger; this.manifestMergerOrder = options.manifestMergerOrder; this.apkSigningMethod = options.apkSigningMethod; this.useSingleJarApkBuilder = options.useSingleJarApkBuilder; this.useRexToCompressDexFiles = options.useRexToCompressDexFiles; this.compressJavaResources = options.compressJavaResources; this.exportsManifestDefault = options.exportsManifestDefault; this.useParallelDex2Oat = options.useParallelDex2Oat; this.breakBuildOnParallelDex2OatFailure = options.breakBuildOnParallelDex2OatFailure; this.omitResourcesInfoProviderFromAndroidBinary = options.omitResourcesInfoProviderFromAndroidBinary; this.fixedResourceNeverlinking = options.fixedResourceNeverlinking; // use --incompatible_disable_native_android_rules, and also the old flag for backwards // compatibility this.checkForMigrationTag = options.checkForMigrationTag || options.disableNativeAndroidRules; this.oneVersionEnforcementUseTransitiveJarsForBinaryUnderTest = options.oneVersionEnforcementUseTransitiveJarsForBinaryUnderTest; this.dataBindingV2 = options.dataBindingV2; this.dataBindingUpdatedArgs = options.dataBindingUpdatedArgs; this.dataBindingAndroidX = options.dataBindingAndroidX; this.persistentAarExtractor = options.persistentAarExtractor; this.persistentBusyboxTools = options.persistentBusyboxTools; this.persistentMultiplexBusyboxTools = options.persistentMultiplexBusyboxTools; this.persistentDexDesugar = options.persistentDexDesugar; this.persistentMultiplexDexDesugar = options.persistentMultiplexDexDesugar; this.filterRJarsFromAndroidTest = options.filterRJarsFromAndroidTest; this.removeRClassesFromInstrumentationTestJar = options.removeRClassesFromInstrumentationTestJar; this.alwaysFilterDuplicateClassesFromAndroidTest = options.alwaysFilterDuplicateClassesFromAndroidTest; this.filterLibraryJarWithProgramJar = options.filterLibraryJarWithProgramJar; this.useRTxtFromMergedResources = options.useRTxtFromMergedResources; this.outputLibraryMergedAssets = options.outputLibraryMergedAssets; this.legacyMainDexListGenerator = options.legacyMainDexListGenerator; this.optimizingDexer = options.optimizingDexer; this.disableInstrumentationManifestMerging = options.disableInstrumentationManifestMerging; this.incompatibleUseToolchainResolution = options.incompatibleUseToolchainResolution; this.hwasan = options.hwasan; this.getJavaResourcesFromOptimizedJar = options.getJavaResourcesFromOptimizedJar; this.includeProguardLocationReferences = options.includeProguardLocationReferences; if (incrementalDexingShardsAfterProguard < 0) { throw new InvalidConfigurationException( "--experimental_incremental_dexing_after_proguard must be a positive number"); } if (incrementalDexingAfterProguardByDefault && incrementalDexingShardsAfterProguard == 0) { throw new InvalidConfigurationException( "--experimental_incremental_dexing_after_proguard_by_default requires " + "--experimental_incremental_dexing_after_proguard to be at least 1"); } if (desugarJava8Libs && !desugarJava8) { throw new InvalidConfigurationException( "Java 8 library support requires --desugar_java8 to be enabled."); } } @Override public String getCpu() { return cpu; } @StarlarkConfigurationField( name = "android_sdk_label", doc = "Returns the target denoted by the value of the --android_sdk flag", defaultLabel = AndroidRuleClasses.DEFAULT_SDK, defaultInToolRepository = true) public Label getSdk() { return sdk; } /** Returns whether to use incremental dexing. */ @Override public boolean useIncrementalDexing() { return incrementalDexing; } /** Returns whether to process proguarded Android binaries with incremental dexing tools. */ @Override public int incrementalDexingShardsAfterProguard() { return incrementalDexingShardsAfterProguard; } /** Whether to use a separate tool to shard classes before merging them into final dex files. */ @Override public boolean incrementalDexingUseDexSharder() { return incrementalDexingUseDexSharder; } /** Whether to use incremental dexing to build proguarded binaries by default. */ @Override public boolean incrementalDexingAfterProguardByDefault() { return incrementalDexingAfterProguardByDefault; } /** * Returns true if an -assumevalues should be generated for Proguard based on the minSdkVersion of * the merged AndroidManifest. */ @Override public boolean assumeMinSdkVersion() { return assumeMinSdkVersion; } /** dx flags supported in incremental dexing actions. */ @Override public ImmutableList getDexoptsSupportedInIncrementalDexing() { return dexoptsSupportedInIncrementalDexing; } /** dx flags supported in dexmerger actions. */ @Override public ImmutableList getDexoptsSupportedInDexMerger() { return dexoptsSupportedInDexMerger; } /** dx flags supported in dexsharder actions. */ @Override public ImmutableList getDexoptsSupportedInDexSharder() { return dexoptsSupportedInDexSharder; } /** * Incremental dexing must not be used for binaries that list any of these flags in their {@code * dexopts} attribute. */ @Override public ImmutableList getTargetDexoptsThatPreventIncrementalDexing() { return targetDexoptsThatPreventIncrementalDexing; } @Override public boolean desugarJava8() { return desugarJava8; } @Override public boolean desugarJava8Libs() { return desugarJava8Libs; } @Override public boolean checkDesugarDeps() { return checkDesugarDeps; } @Override public boolean useRexToCompressDexFiles() { return useRexToCompressDexFiles; } @Override public boolean useAndroidResourceShrinking() { return useAndroidResourceShrinking; } @Override public boolean useAndroidResourceCycleShrinking() { return useAndroidResourceCycleShrinking; } @Override public boolean useAndroidResourcePathShortening() { return useAndroidResourcePathShortening; } @Override public boolean useAndroidResourceNameObfuscation() { return useAndroidResourceNameObfuscation; } public AndroidManifestMerger getManifestMerger() { return manifestMerger; } @Override public String getManifestMergerValue() { return Ascii.toLowerCase(manifestMerger.name()); } public ManifestMergerOrder getManifestMergerOrder() { return manifestMergerOrder; } public ApkSigningMethod getApkSigningMethod() { return apkSigningMethod; } @Override public boolean apkSigningMethodV1() { return apkSigningMethod.signV1(); } @Override public boolean apkSigningMethodV2() { return apkSigningMethod.signV2(); } @Override @Nullable public Boolean apkSigningMethodV4() { return apkSigningMethod.signV4(); } @Override public boolean useSingleJarApkBuilder() { return useSingleJarApkBuilder; } @Override public boolean useParallelDex2Oat() { return useParallelDex2Oat; } @Override public boolean breakBuildOnParallelDex2OatFailure() { return breakBuildOnParallelDex2OatFailure; } @Override public boolean compressJavaResources() { return compressJavaResources; } @Override public boolean getExportsManifestDefault() { return exportsManifestDefault; } @Override public boolean omitResourcesInfoProviderFromAndroidBinary() { return this.omitResourcesInfoProviderFromAndroidBinary; } @Override public boolean fixedResourceNeverlinking() { return this.fixedResourceNeverlinking; } @Override public boolean checkForMigrationTag() { return checkForMigrationTag; } @Override public boolean getOneVersionEnforcementUseTransitiveJarsForBinaryUnderTest() { return oneVersionEnforcementUseTransitiveJarsForBinaryUnderTest; } @Override public boolean useDataBindingV2() { return dataBindingV2; } @Override public boolean useDataBindingUpdatedArgs() { return dataBindingUpdatedArgs; } @Override public boolean useDataBindingAndroidX() { return dataBindingAndroidX; } @Override public boolean persistentAarExtractor() { return persistentAarExtractor; } @Override public boolean persistentBusyboxTools() { return persistentBusyboxTools; } @Override public boolean persistentMultiplexBusyboxTools() { return persistentMultiplexBusyboxTools; } @Override public boolean persistentDexDesugar() { return persistentDexDesugar; } @Override public boolean persistentMultiplexDexDesugar() { return persistentMultiplexDexDesugar; } @Override public boolean incompatibleUseToolchainResolution() { return incompatibleUseToolchainResolution; } @Override public boolean isHwasan() { return hwasan; } @Override public String getOutputDirectoryName() { return configurationDistinguisher.suffix; } public boolean filterRJarsFromAndroidTest() { return filterRJarsFromAndroidTest; } public boolean removeRClassesFromInstrumentationTestJar() { return removeRClassesFromInstrumentationTestJar; } public boolean alwaysFilterDuplicateClassesFromAndroidTest() { return alwaysFilterDuplicateClassesFromAndroidTest; } @Override public boolean filterLibraryJarWithProgramJar() { return filterLibraryJarWithProgramJar; } boolean useRTxtFromMergedResources() { return useRTxtFromMergedResources; } public boolean disableInstrumentationManifestMerging() { return disableInstrumentationManifestMerging; } public boolean getJavaResourcesFromOptimizedJar() { return getJavaResourcesFromOptimizedJar; } public boolean includeProguardLocationReferences() { return includeProguardLocationReferences; } boolean outputLibraryMergedAssets() { return outputLibraryMergedAssets; } /** Returns the label provided with --legacy_main_dex_list_generator, if any. */ // TODO(b/147692286): Move R8's main dex list tool into tool repository. @StarlarkConfigurationField( name = "legacy_main_dex_list_generator", doc = "Returns the label provided with --legacy_main_dex_list_generator, if any.") @Nullable public Label getLegacyMainDexListGenerator() { return legacyMainDexListGenerator; } /** Returns the label provided with --optimizing_dexer, if any. */ @StarlarkConfigurationField( name = "optimizing_dexer", doc = "Returns the label provided with --optimizing_dexer, if any.") @Nullable public Label getOptimizingDexer() { return optimizingDexer; } }