| /* |
| * Copyright (C) 2015 The Android Open Source Project |
| * |
| * 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.android.build.gradle; |
| |
| import com.android.annotations.NonNull; |
| import com.android.annotations.Nullable; |
| import com.android.build.api.transform.Transform; |
| import com.android.build.api.variant.VariantFilter; |
| import com.android.build.gradle.api.AndroidSourceSet; |
| import com.android.build.gradle.api.BaseVariantOutput; |
| import com.android.build.gradle.internal.CompileOptions; |
| import com.android.build.gradle.internal.coverage.JacocoOptions; |
| import com.android.build.gradle.internal.dsl.AaptOptions; |
| import com.android.build.gradle.internal.dsl.AdbOptions; |
| import com.android.build.gradle.internal.dsl.CoreBuildType; |
| import com.android.build.gradle.internal.dsl.CoreProductFlavor; |
| import com.android.build.gradle.internal.dsl.DexOptions; |
| import com.android.build.gradle.internal.dsl.LintOptions; |
| import com.android.build.gradle.internal.dsl.PackagingOptions; |
| import com.android.build.gradle.internal.dsl.Splits; |
| import com.android.build.gradle.internal.dsl.TestOptions; |
| import com.android.build.gradle.internal.model.CoreExternalNativeBuild; |
| import com.android.builder.core.LibraryRequest; |
| import com.android.builder.model.DataBindingOptions; |
| import com.android.builder.model.SigningConfig; |
| import com.android.builder.testing.api.DeviceProvider; |
| import com.android.builder.testing.api.TestServer; |
| import com.android.repository.Revision; |
| import java.io.File; |
| import java.util.Collection; |
| import java.util.List; |
| import org.gradle.api.Action; |
| import org.gradle.api.Incubating; |
| import org.gradle.api.NamedDomainObjectContainer; |
| import org.gradle.api.tasks.Internal; |
| |
| /** |
| * User configuration settings for all android plugins. |
| * |
| * <p>DO NOT ADD ANYTHING THERE. |
| * |
| * @deprecated Use {@link BaseExtension} instead. |
| */ |
| @Deprecated |
| public interface AndroidConfig { |
| |
| |
| /** |
| * Specifies the version of the <a |
| * href="https://developer.android.com/studio/releases/build-tools.html">SDK Build Tools</a> to |
| * use when building your project. |
| * |
| * <p>When using Android plugin 3.0.0 or later, configuring this property is optional. By |
| * default, the plugin uses the minimum version of the build tools required by the <a |
| * href="https://developer.android.com/studio/releases/gradle-plugin.html#revisions">version of |
| * the plugin</a> you're using. To specify a different version of the build tools for the plugin |
| * to use, specify the version as follows: |
| * |
| * <pre> |
| * // Specifying this property is optional. |
| * buildToolsVersion "26.0.0" |
| * </pre> |
| * |
| * <p>For a list of build tools releases, read <a |
| * href="https://developer.android.com/studio/releases/build-tools.html#notes">the release |
| * notes</a>. |
| * |
| * <p>Note that the value assigned to this property is parsed and stored in a normalized form, |
| * so reading it back may give a slightly different result. |
| */ |
| String getBuildToolsVersion(); |
| |
| /** |
| * Specifies the API level to compile your project against. The Android plugin requires you to |
| * configure this property. |
| * |
| * <p>This means your code can use only the Android APIs included in that API level and lower. |
| * You can configure the compile sdk version by adding the following to the <code>android</code> |
| * block: <code>compileSdkVersion 26</code>. |
| * |
| * <p>You should generally <a |
| * href="https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels">use |
| * the most up-to-date API level</a> available. If you are planning to also support older API |
| * levels, it's good practice to <a |
| * href="https://developer.android.com/studio/write/lint.html">use the Lint tool</a> to check if |
| * you are using APIs that are not available in earlier API levels. |
| * |
| * <p>The value you assign to this property is parsed and stored in a normalized form, so |
| * reading it back may return a slightly different value. |
| */ |
| String getCompileSdkVersion(); |
| |
| /** |
| * This property is for internal use only. |
| * |
| * <p>To specify the version of the <a |
| * href="https://developer.android.com/studio/releases/build-tools.html">SDK Build Tools</a> |
| * that the Android plugin should use, use <a |
| * href="com.android.build.gradle.BaseExtension.html#com.android.build.gradle.BaseExtension:buildToolsVersion">buildToolsVersion</a> |
| * instead. |
| */ |
| @Internal |
| Revision getBuildToolsRevision(); |
| |
| /** |
| * Specifies the version of the module to publish externally. This property is generally useful |
| * only to library modules that you intend to publish to a remote repository, such as Maven. |
| * |
| * <p>If you don't configure this property, the Android plugin publishes the release version of |
| * the module by default. If the module configures <a |
| * href="https://developer.android.com/studio/build/build-variants.html#product-flavors">product |
| * flavors</a>, you need to configure this property with the name of the variant you want the |
| * plugin to publish, as shown below: |
| * |
| * <pre> |
| * // Specifies the 'demoDebug' build variant as the default variant |
| * // that the plugin should publish to external consumers. |
| * defaultPublishConfig 'demoDebug' |
| * </pre> |
| * |
| * <p>If you plan to only consume your library module locally, you do not need to configure this |
| * property. Android plugin 3.0.0 and higher use <a |
| * href="https://developer.android.com/studio/build/gradle-plugin-3-0-0-migration.html#variant_aware">variant-aware |
| * dependency resolution</a> to automatically match the variant of the producer to that of the |
| * consumer. That is, when publishing a module to another local module, the plugin no longer |
| * respects this property when determining which version of the module to publish to the |
| * consumer. |
| */ |
| String getDefaultPublishConfig(); |
| |
| /** |
| * Specifies variants the Android plugin should include or remove from your Gradle project. |
| * |
| * <p>By default, the Android plugin creates a build variant for every possible combination of |
| * the product flavors and build types that you configure, and adds them to your Gradle project. |
| * However, there may be certain build variants that either you do not need or do not make sense |
| * in the context of your project. You can remove certain build variant configurations by <a |
| * href="https://developer.android.com/studio/build/build-variants.html#filter-variants">creating |
| * a variant filter</a> in your module-level <code>build.gradle</code> file. |
| * |
| * <p>The following example tells the plugin to ignore all variants that combine the "dev" |
| * product flavor, which you can configure to <a |
| * href="https://developer.android.com/studio/build/optimize-your-build.html#create_dev_variant">optimize |
| * build speeds</a> during development, and the "release" build type: |
| * |
| * <pre> |
| * android { |
| * ... |
| * variantFilter { variant -> |
| * |
| * def buildTypeName = variant.buildType*.name |
| * def flavorName = variant.flavors*.name |
| * |
| * if (flavorName.contains("dev") && buildTypeName.contains("release")) { |
| * // Tells Gradle to ignore each variant that satisfies the conditions above. |
| * setIgnore(true) |
| * } |
| * } |
| * } |
| * </pre> |
| * |
| * <p>During subsequent builds, Gradle ignores any build variants that meet the conditions you |
| * specify. If you're using <a href="https://developer.android.com/studio/index.html">Android |
| * Studio</a>, those variants no longer appear in the drop down menu when you click <b>Build |
| * > Select Build Variant</b> from the menu bar. |
| * |
| * @see com.android.build.gradle.internal.api.VariantFilter |
| */ |
| Action<VariantFilter> getVariantFilter(); |
| |
| /** |
| * Specifies APK install options for the <a |
| * href="https://developer.android.com/studio/command-line/adb.html">Android Debug Bridge |
| * (ADB)</a>. |
| * |
| * @see com.android.build.gradle.internal.dsl.AdbOptions |
| */ |
| AdbOptions getAdbOptions(); |
| |
| /** |
| * Specifies the module's resource prefix to Android Studio for editor features, such as Lint |
| * checks. This property is useful only when using Android Studio. |
| * |
| * <p>Including unique prefixes for module resources helps avoid naming collisions with |
| * resources from other modules. For example, when creating a library with String resources, you |
| * may want to name each resource with a unique prefix, such as <code>"mylib_"</code> to avoid |
| * naming collisions with similar resources that the consumer defines. You can then specify this |
| * prefix, as shown below, so that Android Studio expects this prefix when you name module |
| * resources: |
| * |
| * <pre> |
| * // This property is useful only when developing your project in Android Studio. |
| * resourcePrefix 'mylib_' |
| * </pre> |
| */ |
| String getResourcePrefix(); |
| |
| /** |
| * Specifies the names of product flavor dimensions for this project. |
| * |
| * <p>To configure flavor dimensions, use <a |
| * href="com.android.build.gradle.BaseExtension.html#com.android.build.gradle.BaseExtension:flavorDimensions(java.lang.String[])"> |
| * <code>flavorDimensions</code></a>. To learn more, read <a |
| * href="https://developer.android.com/studio/build/build-variants.html#flavor-dimensions">combine |
| * multiple product flavors</a>. |
| */ |
| List<String> getFlavorDimensionList(); |
| |
| /** |
| * Specifies whether to build APK splits or multiple APKs from configurations in the {@link |
| * com.android.build.gradle.internal.dsl.Splits splits} block. |
| * |
| * <p>When you set this property to <code>true</code>, the Android plugin generates each object |
| * in the {@link com.android.build.gradle.internal.dsl.Splits splits} block as a portion of a |
| * whole APK, called an <em>APK split</em>. Compared to building multiple APKs, each APK split |
| * includes only the components that each ABI or screen density requires. Generating APK splits |
| * is an incubating feature, which requires you to set {@link |
| * com.android.build.gradle.internal.dsl.BaseFlavor#minSdkVersion(int)} to <code>21</code> or |
| * higher, and is currently supported only when publishing <a |
| * href="https://d.android.com/instant-apps">Android Instant Apps</a>. |
| * |
| * <p>When you do not configure this property or set it to <code>false</code> (default), the |
| * Android plugin builds separate APKs for each object you configure in the {@link |
| * com.android.build.gradle.internal.dsl.Splits splits} block that you can deploy to a device. |
| * To learn more about building different versions of your app that each target a different <a |
| * href="https://developer.android.com/ndk/guides/abis.html">Application Binary Interfaces</a> |
| * or screen density, read <a |
| * href="https://developer.android.com/studio/build/configure-apk-splits.html">Build Multiple |
| * APKs</a>. |
| */ |
| @Incubating |
| boolean getGeneratePureSplits(); |
| |
| /** |
| * Specifies defaults for variant properties that the Android plugin applies to all build |
| * variants. |
| * |
| * <p>You can override any <code>defaultConfig</code> property when <a |
| * href="https://developer.android.com/studio/build/build-variants.html#product-flavors">configuring |
| * product flavors</a>. |
| * |
| * @see com.android.build.gradle.internal.dsl.ProductFlavor |
| */ |
| CoreProductFlavor getDefaultConfig(); |
| |
| /** |
| * Specifies options for the Android Asset Packaging Tool (AAPT). |
| * |
| * @see com.android.build.gradle.internal.dsl.AaptOptions |
| */ |
| AaptOptions getAaptOptions(); |
| |
| /** |
| * Specifies Java compiler options, such as the language level of the Java source code and |
| * generated bytecode. |
| * |
| * @see com.android.build.gradle.internal.CompileOptions |
| */ |
| CompileOptions getCompileOptions(); |
| |
| /** |
| * Specifies options for the DEX tool, such as enabling library pre-dexing. |
| * |
| * <p>Experimenting with DEX options tailored for your workstation may improve build |
| * performance. To learn more, read <a |
| * href="https://developer.android.com/studio/build/optimize-your-build.html#dex_options">Optimize |
| * your build</a>. |
| * |
| * @see com.android.build.gradle.internal.dsl.DexOptions |
| */ |
| DexOptions getDexOptions(); |
| |
| /** |
| * Configure JaCoCo version that is used for offline instrumentation and coverage report. |
| * |
| * <p>To specify the version of JaCoCo you want to use, add the following to <code>build.gradle |
| * </code> file: |
| * |
| * <pre> |
| * android { |
| * jacoco { |
| * version "<jacoco-version>" |
| * } |
| * } |
| * </pre> |
| */ |
| JacocoOptions getJacoco(); |
| |
| /** |
| * Specifies options for the lint tool. |
| * |
| * <p>Android Studio and the Android SDK provide a code scanning tool called lint that can help |
| * you to identify and correct problems with the structural quality of your code without having |
| * to execute the app or write test cases. Each problem the tool detects is reported with a |
| * description message and a severity level, so that you can quickly prioritize the critical |
| * improvements that need to be made. |
| * |
| * <p>This property allows you to configure certain lint options, such as which checks to run or |
| * ignore. If you're using Android Studio, you can <a |
| * href="https://developer.android.com/studio/write/lint.html#cis">configure similar lint |
| * options</a> from the IDE. To learn more about using and running lint, read <a |
| * href="https://developer.android.com/studio/write/lint.html">Improve Your Code with Lint</a>. |
| * |
| * @see com.android.build.gradle.internal.dsl.LintOptions |
| */ |
| LintOptions getLintOptions(); |
| |
| /** |
| * Specifies options for external native build using <a href="https://cmake.org/">CMake</a> or |
| * <a href="https://developer.android.com/ndk/guides/ndk-build.html">ndk-build</a>. |
| * |
| * <p>When using <a href="https://developer.android.com/studio/index.html">Android Studio 2.2 or |
| * higher</a> with <a |
| * href="https://developer.android.com/studio/releases/gradle-plugin.html">Android plugin 2.2.0 |
| * or higher</a>, you can compile C and C++ code into a native library that Gradle packages into |
| * your APK. |
| * |
| * <p>To learn more, read <a |
| * href="https://developer.android.com/studio/projects/add-native-code.html">Add C and C++ Code |
| * to Your Project</a>. |
| * |
| * @see com.android.build.gradle.internal.dsl.ExternalNativeBuild |
| * @since 2.2.0 |
| */ |
| CoreExternalNativeBuild getExternalNativeBuild(); |
| |
| /** |
| * Specifies options and rules that determine which files the Android plugin packages into your |
| * APK. |
| * |
| * <p>For example, the following example tells the plugin to avoid packaging files that are |
| * intended only for testing: |
| * |
| * <pre> |
| * packagingOptions { |
| * // Tells the plugin to not include any files in the 'testing-data/' directory, |
| * // which is specified as an absolute path from the root of the APK archive. |
| * // The exclude property includes certain defaults paths to help you avoid common |
| * // duplicate file errors when building projects with multiple dependencies. |
| * exclude "/testing-data/**" |
| * } |
| * </pre> |
| * |
| * <p>To learn more about how to specify rules for packaging, merging, and excluding files, see |
| * {@link PackagingOptions} |
| * |
| * @see com.android.build.gradle.internal.dsl.PackagingOptions |
| */ |
| PackagingOptions getPackagingOptions(); |
| |
| /** |
| * Specifies configurations for <a |
| * href="https://developer.android.com/studio/build/configure-apk-splits.html">building multiple |
| * APKs</a> or APK splits. |
| * |
| * <p>To generate APK splits, you need to also set <a |
| * href="com.android.build.gradle.BaseExtension.html#com.android.build.gradle.BaseExtension:generatePureSplits"> |
| * <code>generatePureSplits</code></a> to <code>true</code>. However, generating APK splits is |
| * an incubating feature, which requires you to set {@link |
| * com.android.build.gradle.internal.dsl.BaseFlavor#minSdkVersion(int)} to <code>21</code> or |
| * higher, and is currently supported only when publishing <a |
| * href="https://d.android.com/instant-apps">Android Instant Apps</a>. |
| * |
| * @see com.android.build.gradle.internal.dsl.Splits |
| */ |
| Splits getSplits(); |
| |
| /** |
| * Specifies options for how the Android plugin should run local and instrumented tests. |
| * |
| * <p>To learn more, read <a |
| * href="https://developer.android.com/studio/test/index.html#test_options">Configure Gradle |
| * test options</a>. |
| * |
| * @see com.android.build.gradle.internal.dsl.TestOptions |
| */ |
| TestOptions getTestOptions(); |
| |
| /** List of device providers */ |
| @NonNull |
| List<DeviceProvider> getDeviceProviders(); |
| |
| /** List of remote CI servers. */ |
| @NonNull |
| List<TestServer> getTestServers(); |
| |
| @NonNull |
| List<Transform> getTransforms(); |
| @NonNull |
| List<List<Object>> getTransformsDependencies(); |
| |
| /** |
| * Encapsulates all product flavors configurations for this project. |
| * |
| * <p>Product flavors represent different versions of your project that you expect to co-exist |
| * on a single device, the Google Play store, or repository. For example, you can configure |
| * 'demo' and 'full' product flavors for your app, and each of those flavors can specify |
| * different features, device requirements, resources, and application ID's--while sharing |
| * common source code and resources. So, product flavors allow you to output different versions |
| * of your project by simply changing only the components and settings that are different |
| * between them. |
| * |
| * <p>Configuring product flavors is similar to <a |
| * href="https://developer.android.com/studio/build/build-variants.html#build-types">configuring |
| * build types</a>: add them to the <code>productFlavors</code> block of your module's <code> |
| * build.gradle</code> file and configure the settings you want. Product flavors support the |
| * same properties as the {@link com.android.build.gradle.internal.dsl.DefaultConfig} |
| * block--this is because <code>defaultConfig</code> defines a {@link |
| * com.android.build.gradle.internal.dsl.ProductFlavor} object that the plugin uses as the base |
| * configuration for all other flavors. Each flavor you configure can then override any of the |
| * default values in <code>defaultConfig</code>, such as the <a |
| * href="https://d.android.com/studio/build/application-id.html"><code>applicationId</code></a>. |
| * |
| * <p>When using Android plugin 3.0.0 and higher, <em>each flavor must belong to a <a |
| * href="com.android.build.gradle.BaseExtension.html#com.android.build.gradle.BaseExtension:flavorDimensions(java.lang.String[])"> |
| * <code>flavorDimensions</code></a> value</em>. By default, when you specify only one |
| * dimension, all flavors you configure belong to that dimension. If you specify more than one |
| * flavor dimension, you need to manually assign each flavor to a dimension. To learn more, read |
| * <a |
| * href="https://developer.android.com/studio/build/gradle-plugin-3-0-0-migration.html#variant_aware"> |
| * Use Flavor Dimensions for variant-aware dependency management</a>. |
| * |
| * <p>When you configure product flavors, the Android plugin automatically combines them with |
| * your {@link com.android.build.gradle.internal.dsl.BuildType} configurations to <a |
| * href="https://developer.android.com/studio/build/build-variants.html">create build |
| * variants</a>. If the plugin creates certain build variants that you don't want, you can <a |
| * href="https://developer.android.com/studio/build/build-variants.html#filter-variants">filter |
| * variants</a>. |
| * |
| * @see com.android.build.gradle.internal.dsl.ProductFlavor |
| */ |
| Collection<? extends CoreProductFlavor> getProductFlavors(); |
| |
| /** |
| * Encapsulates all build type configurations for this project. |
| * |
| * <p>Unlike using {@link com.android.build.gradle.internal.dsl.ProductFlavor} to create |
| * different versions of your project that you expect to co-exist on a single device, build |
| * types determine how Gradle builds and packages each version of your project. Developers |
| * typically use them to configure projects for various stages of a development lifecycle. For |
| * example, when creating a new project from Android Studio, the Android plugin configures a |
| * 'debug' and 'release' build type for you. By default, the 'debug' build type enables |
| * debugging options and signs your APK with a generic debug keystore. Conversely, The 'release' |
| * build type strips out debug symbols and requires you to <a |
| * href="https://developer.android.com/studio/publish/app-signing.html#sign-apk">create a |
| * release key and keystore</a> for your app. You can then combine build types with product |
| * flavors to <a href="https://developer.android.com/studio/build/build-variants.html">create |
| * build variants</a>. |
| * |
| * @see com.android.build.gradle.internal.dsl.BuildType |
| */ |
| Collection<? extends CoreBuildType> getBuildTypes(); |
| |
| /** |
| * Encapsulates signing configurations that you can apply to {@link |
| * com.android.build.gradle.internal.dsl.BuildType} and {@link |
| * com.android.build.gradle.internal.dsl.ProductFlavor} configurations. |
| * |
| * <p>Android requires that all APKs be digitally signed with a certificate before they can be |
| * installed onto a device. When deploying a debug version of your project from Android Studio, |
| * the Android plugin automatically signs your APK with a generic debug certificate. However, to |
| * build an APK for release, you must <a |
| * href="https://developer.android.com/studio/publish/app-signing.html">sign the APK</a> with a |
| * release key and keystore. You can do this by either <a |
| * href="https://developer.android.com/studio/publish/app-signing.html#sign-apk">using the |
| * Android Studio UI</a> or manually <a |
| * href="https://developer.android.com/studio/publish/app-signing.html#gradle-sign">configuring |
| * your <code>build.gradle</code> file</a>. |
| * |
| * @see com.android.build.gradle.internal.dsl.SigningConfig |
| */ |
| Collection<? extends SigningConfig> getSigningConfigs(); |
| |
| /** |
| * Encapsulates source set configurations for all variants. |
| * |
| * <p>The Android plugin looks for your project's source code and resources in groups of |
| * directories called <i><a |
| * href="https://developer.android.com/studio/build/index.html#sourcesets">source sets</a></i>. |
| * Each source set also determines the scope of build outputs that should consume its code and |
| * resources. For example, when creating a new project from Android Studio, the IDE creates |
| * directories for a <code>main/</code> source set that contains the code and resources you want |
| * to share between all your build variants. |
| * |
| * <p>You can then define basic functionality in the <code>main/</code> source set, but use |
| * product flavor source sets to change only the branding of your app between different clients, |
| * or include special permissions and logging functionality to only "debug" versions of your |
| * app. |
| * |
| * <p>The Android plugin expects you to organize files for source set directories a certain way, |
| * similar to the <code>main/</code> source set. For example, Gradle expects Java class files |
| * that are specific to your "debug" build type to be located in the <code>src/debug/java/ |
| * </code> directory. |
| * |
| * <p>Gradle provides a useful task to shows you how to organize your files for each build |
| * type-, product flavor-, and build variant-specific source set. you can run this task from the |
| * command line as follows: |
| * |
| * <pre>./gradlew sourceSets</pre> |
| * |
| * <p>The following sample output describes where Gradle expects to find certain files for the |
| * "debug" build type: |
| * |
| * <pre> |
| * ------------------------------------------------------------ |
| * Project :app |
| * ------------------------------------------------------------ |
| * |
| * ... |
| * |
| * debug |
| * ---- |
| * Compile configuration: compile |
| * build.gradle name: android.sourceSets.debug |
| * Java sources: [app/src/debug/java] |
| * Manifest file: app/src/debug/AndroidManifest.xml |
| * Android resources: [app/src/debug/res] |
| * Assets: [app/src/debug/assets] |
| * AIDL sources: [app/src/debug/aidl] |
| * RenderScript sources: [app/src/debug/rs] |
| * JNI sources: [app/src/debug/jni] |
| * JNI libraries: [app/src/debug/jniLibs] |
| * Java-style resources: [app/src/debug/resources] |
| * </pre> |
| * |
| * <p>If you have sources that are not organized into the default source set directories that |
| * Gradle expects, as described in the sample output above, you can use the <code>sourceSet |
| * </code> block to change where Gradle looks to gather files for each component of a given |
| * source set. You don't need to relocate the files; you only need to provide Gradle with the |
| * path(s), relative to the module-level <code>build.gradle</code> file, where Gradle should |
| * expect to find files for each source set component. |
| * |
| * <p><b>Note:</b> You should specify only static paths whenever possible. Specifying dynamic |
| * paths reduces build speed and consistency. |
| * |
| * <p>The following code sample maps sources from the <code>app/other/</code> directory to |
| * certain components of the <code>main</code> source set and changes the root directory of the |
| * <code>androidTest</code> source set: |
| * |
| * <pre> |
| * android { |
| * ... |
| * sourceSets { |
| * // Encapsulates configurations for the main source set. |
| * main { |
| * // Changes the directory for Java sources. The default directory is |
| * // 'src/main/java'. |
| * java.srcDirs = ['other/java'] |
| * |
| * // If you list multiple directories, Gradle uses all of them to collect |
| * // sources. Because Gradle gives these directories equal priority, if |
| * // you define the same resource in more than one directory, you get an |
| * // error when merging resources. The default directory is 'src/main/res'. |
| * res.srcDirs = ['other/res1', 'other/res2'] |
| * |
| * // Note: You should avoid specifying a directory which is a parent to one |
| * // or more other directories you specify. For example, avoid the following: |
| * // res.srcDirs = ['other/res1', 'other/res1/layouts', 'other/res1/strings'] |
| * // You should specify either only the root 'other/res1' directory, or only the |
| * // nested 'other/res1/layouts' and 'other/res1/strings' directories. |
| * |
| * // For each source set, you can specify only one Android manifest. |
| * // By default, Android Studio creates a manifest for your main source |
| * // set in the src/main/ directory. |
| * manifest.srcFile 'other/AndroidManifest.xml' |
| * ... |
| * } |
| * |
| * // Create additional blocks to configure other source sets. |
| * androidTest { |
| * // If all the files for a source set are located under a single root |
| * // directory, you can specify that directory using the setRoot property. |
| * // When gathering sources for the source set, Gradle looks only in locations |
| * // relative to the root directory you specify. For example, after applying the |
| * // configuration below for the androidTest source set, Gradle looks for Java |
| * // sources only in the src/tests/java/ directory. |
| * setRoot 'src/tests' |
| * ... |
| * } |
| * } |
| * } |
| * </pre> |
| * |
| * @see com.android.build.gradle.internal.dsl.AndroidSourceSetFactory |
| */ |
| NamedDomainObjectContainer<AndroidSourceSet> getSourceSets(); |
| |
| /** build outputs for all variants */ |
| Collection<BaseVariantOutput> getBuildOutputs(); |
| |
| /** Whether to package build config class file. */ |
| Boolean getPackageBuildConfig(); |
| |
| /** Aidl files to package in the aar. */ |
| Collection<String> getAidlPackageWhiteList(); |
| |
| Collection<LibraryRequest> getLibraryRequests(); |
| |
| /** |
| * Specifies options for the <a |
| * href="https://developer.android.com/topic/libraries/data-binding/index.html">Data Binding |
| * Library</a>. |
| * |
| * <p>Data binding helps you write declarative layouts and minimize the glue code necessary to |
| * bind your application logic and layouts. |
| */ |
| DataBindingOptions getDataBinding(); |
| |
| /** Whether the feature module is the base feature. */ |
| Boolean getBaseFeature(); |
| |
| /** |
| * Name of the build type that will be used when running Android (on-device) tests. |
| * |
| * <p>Defaults to "debug". |
| * |
| * <p>FIXME this should not be here, but it has to be because of gradle-core not knowing |
| * anything besides this interface. This will be fixed with the new gradle-api based extension |
| * interfaces. |
| */ |
| @Nullable |
| String getTestBuildType(); |
| |
| /** |
| * Name of the NDK version that will be used when building native code. |
| * |
| * <p>The value null means that no particular NDK version is requested. In this case, the latest |
| * available NDK will be used. |
| */ |
| @Nullable |
| String getNdkVersion(); |
| |
| /** Returns the list of files that form bootClasspath used for compilation. */ |
| List<File> getBootClasspath(); |
| } |
