Gradle e il plug-in Android per Gradle offrono un modo flessibile per compilare, compilare e pacchettizzare la tua app o libreria Android. Questa pagina raccoglie alcuni suggerimenti e configurazioni utili per aiutarti a ottenere il massimo da ogni build. Se vuoi scoprire come velocizzare le build, consulta Ottimizzare la velocità di compilazione.
Se non hai mai utilizzato Gradle, scopri le nozioni di base leggendo l'articolo Configurare la build. Puoi anche consultare la documentazione di riferimento del linguaggio DSL del plug-in Android per saperne di più sulle proprietà utilizzate in questa pagina.
Gestire progetti e origini
Di seguito sono riportate alcune configurazioni per gestire i moduli del progetto e le relative origini. Per scoprire di più sulla creazione e sulla gestione di progetti e moduli, consulta la Panoramica dei progetti.
Modificare le configurazioni degli insiemi di origini predefinite
Puoi utilizzare il blocco
sourceSets nel file build.gradle
a livello di modulo per modificare la posizione in cui Gradle cerca di raccogliere i file per ogni componente di un
set di origine.
Groovy
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']
// When you list multiple directories, Gradle uses all of them to collect
// sources. You should avoid specifying a directory which is a parent to one
// or more other directories you specify.
res.srcDirs = ['other/res1', 'other/res2']
// For each source set, you can specify only one Android manifest.
// The following points Gradle to a different manifest for this source set.
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'
...
}
}
}
...
Kotlin
android {
...
sourceSets {
// Encapsulates configurations for the main source set.
getByName("main") {
// Changes the directory for Java sources. The default directory is
// 'src/main/java'.
java.setSrcDirs("other/java")
// When you list multiple directories, Gradle uses all of them to collect
// sources. You should avoid specifying a directory which is a parent to one
// or more other directories you specify.
res.setSrcDirs("other/res1", "other/res2")
// For each source set, you can specify only one Android manifest.
// The following points Gradle to a different manifest for this source set.
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")
...
}
}
}
...
Gestire librerie e dipendenze
Gradle fornisce un meccanismo affidabile per gestire le dipendenze, che si tratti di librerie remote o di moduli di librerie locali.
Scegli come target build specifiche con configurazioni delle dipendenze
Se vuoi una dipendenza solo per un insieme di origini della variante di compilazione o dell'insieme di origini di test specifico, scrivi in maiuscolo il nome della configurazione della dipendenza e anteponi il nome della variante di compilazione o dell'insieme di origini di test.
Groovy
android {...}
// Creates Gradle dependency configurations to use in the dependencies block.
configurations {
// For variants that combine a product flavor and build type, you need to
// intitialize a placeholder for its dependency configuration.
freeDebugRuntimeOnly{}
...
}
dependencies {
// Adds an implementation dependency only to the "free" product flavor.
freeImplementation 'com.google.firebase:firebase-ads:21.5.1'
// Adds a runtimeOnly dependency only to the "freeDebug" build variant.
freeDebugRuntimeOnly fileTree(dir: 'libs', include: ['*.jar'])
// Adds a remote binary dependency only for local tests.
testImplementation 'junit:junit:4.12'
// Adds a remote binary dependency only for the instrumented test APK.
androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.6.1'
}
Kotlin
android {...}
dependencies {
// Use ""() notation for custom flavors and build types
// Adds an implementation dependency only to the "free" product flavor.
"freeImplementation"("com.google.firebase:firebase-ads:21.5.1")
// Adds a runtimeOnly dependency only to the "freeDebug" build variant.
"freeDebugRuntimeOnly"(fileTree("dir" to "libs", "include" to "*.jar"))
// Adds a remote binary dependency only for local tests.
testImplementation("junit:junit:4.12")
// Adds a remote binary dependency only for the instrumented test APK.
androidTestImplementation("com.android.support.test.espresso:espresso-core:3.6.1")
}
Creare versioni diverse dell'app
Gradle e il plug-in Android ti consentono di creare diverse versioni della tua app da un singolo modulo configurando le varianti di build.
Configurare i codici di versione dinamici
Per impostazione predefinita, quando Gradle genera gli APK per il progetto, ogni APK ha le stesse informazioni sulla versione, come specificato nel file build.gradle a livello di modulo.
Poiché Google Play Store non consente più APK per la stessa app con le stesse informazioni sulla versione, devi assicurarti che ogni APK abbia il proprio versionCode univoco prima di caricarlo sul Play Store.
Puoi farlo con una logica di compilazione personalizzata che assegna un codice di versione diverso a ogni APK al momento della compilazione. Ad esempio, quando crei APK separati per ogni ABI, la versione automatica dell'APK ha il seguente aspetto:
Groovy
android {
...
defaultConfig {
...
versionCode 4
}
splits {
...
}
}
// Map for the version code that gives each ABI a value.
ext.abiCodes = ['armeabi-v7a':1, mips:2, x86:3]
// For per-density APKs, create a similar map like this:
// ext.densityCodes = ['hdpi': 1, 'xhdpi': 2, 'xxhdpi': 3, 'xxxhdpi': 4]
import com.android.build.OutputFile
// For each APK output variant, override versionCode with a combination of
// ext.abiCodes * 1000 + variant.versionCode. In this example, variant.versionCode
// is equal to defaultConfig.versionCode. If you configure product flavors that
// define their own versionCode, variant.versionCode uses that value instead.
android.applicationVariants.all { variant ->
// Assigns a different version code for each output APK
// other than the universal APK.
variant.outputs.each { output ->
// Stores the value of ext.abiCodes that is associated with the ABI for this variant.
def baseAbiVersionCode =
// Determines the ABI for this variant and returns the mapped value.
project.ext.abiCodes.get(output.getFilter(OutputFile.ABI))
// Because abiCodes.get() returns null for ABIs that are not mapped by ext.abiCodes,
// the following code does not override the version code for universal APKs.
// However, because we want universal APKs to have the lowest version code,
// this outcome is desirable.
if (baseAbiVersionCode != null) {
// Assigns the new version code to versionCodeOverride, which changes the version code
// for only the output APK, not for the variant itself. Skipping this step simply
// causes Gradle to use the value of variant.versionCode for the APK.
output.versionCodeOverride =
baseAbiVersionCode * 1000 + variant.versionCode
}
}
}
Kotlin
android {
...
defaultConfig {
...
versionCode = 4
}
splits {
...
}
}
// Map for the version code that gives each ABI a value.
val abiCodes = mapOf("armeabi-v7a" to 1, "mips" to 2, "x86" to 3)
// For per-density APKs, create a similar map like this:
// val densityCodes = mapOf("hdpi" to 1, "xhdpi" to 2, "xxhdpi" to 3, "xxxhdpi" to 4)
import com.android.build.api.variant.FilterConfiguration.FilterType.*
// For each APK output variant, override versionCode with a combination of
// abiCodes * 1000 + variant.versionCode. In this example, variant.versionCode
// is equal to defaultConfig.versionCode. If you configure product flavors that
// define their own versionCode, variant.versionCode uses that value instead.
androidComponents {
onVariants { variant ->
// Assigns a different version code for each output APK
// other than the universal APK.
variant.outputs.forEach { output ->
val name = output.filters.find { it.filterType == ABI }?.identifier
// Stores the value of abiCodes that is associated with the ABI for this variant.
val baseAbiCode = abiCodes[name]
// Because abiCodes.get() returns null for ABIs that are not mapped by ext.abiCodes,
// the following code does not override the version code for universal APKs.
// However, because we want universal APKs to have the lowest version code,
// this outcome is desirable.
if (baseAbiCode != null) {
// Assigns the new version code to output.versionCode, which changes the version code
// for only the output APK, not for the variant itself.
output.versionCode.set(baseAbiCode * 1000 + (output.versionCode.get() ?: 0))
}
}
}
}
Combinare più varianti di prodotto
In alcuni casi, potresti voler combinare le configurazioni di più versioni del prodotto. A tale scopo, il plug-in Android per Gradle consente di creare gruppi di varianti di prodotto, chiamate dimensioni di varianti.
Il seguente esempio di codice utilizza la proprietà
flavorDimensions per creare una dimensione del tipo "mode" per raggruppare le versioni del prodotto "full" e "demo" e una dimensione del tipo "api" per raggruppare le configurazioni delle versioni del prodotto in base al livello dell'API. Gradle combina quindi i gusti dei prodotti della dimensione "mode" con quelli della dimensione "api".
Groovy
android {
...
buildTypes {
debug {...}
release {...}
}
// Specifies the flavor dimensions you want to use. The order in which you
// list each dimension determines its priority, from highest to lowest,
// when Gradle merges variant sources and configurations. You must assign
// each product flavor you configure to one of the flavor dimensions.
flavorDimensions "api", "mode"
productFlavors {
demo {
// Assigns this product flavor to the "mode" flavor dimension.
dimension "mode"
...
}
full {
dimension "mode"
...
}
// Configurations in the "api" product flavors override those in "mode"
// flavors and the defaultConfig block. Gradle determines the priority
// between flavor dimensions based on the order in which they appear next
// to the flavorDimensions property above--the first dimension has a higher
// priority than the second, and so on.
minApi24 {
dimension "api"
minSdkVersion '24'
// To ensure the target device receives the version of the app with
// the highest compatible API level, assign version codes in increasing
// value with API level. To learn more about assigning version codes to
// support app updates and uploading to Google Play, read Multiple APK Support
versionCode 30000 + android.defaultConfig.versionCode
versionNameSuffix "-minApi24"
...
}
minApi23 {
dimension "api"
minSdkVersion '23'
versionCode 20000 + android.defaultConfig.versionCode
versionNameSuffix "-minApi23"
...
}
minApi21 {
dimension "api"
minSdkVersion '21'
versionCode 10000 + android.defaultConfig.versionCode
versionNameSuffix "-minApi21"
...
}
}
}
...
Kotlin
android {
...
buildTypes {
getByName("debug") {...}
getByName("release") {...}
}
// Specifies the flavor dimensions you want to use. The order in which you
// list each dimension determines its priority, from highest to lowest,
// when Gradle merges variant sources and configurations. You must assign
// each product flavor you configure to one of the flavor dimensions.
flavorDimensions += listOf("api", "mode")
productFlavors {
create("demo") {
// Assigns this product flavor to the "mode" flavor dimension.
dimension = "mode"
...
}
create("full") {
dimension = "mode"
...
}
// Configurations in the "api" product flavors override those in "mode"
// flavors and the defaultConfig block. Gradle determines the priority
// between flavor dimensions based on the order in which they appear next
// to the flavorDimensions property above--the first dimension has a higher
// priority than the second, and so on.
create("minApi24") {
dimension = "api"
minSdkVersion(24)
// To ensure the target device receives the version of the app with
// the highest compatible API level, assign version codes in increasing
// value with API level. To learn more about assigning version codes to
// support app updates and uploading to Google Play, read Multiple APK Support
versionCode = 30000 + android.defaultConfig.versionCode
versionNameSuffix = "-minApi24"
...
}
create("minApi23") {
dimension = "api"
minSdkVersion(23)
versionCode = 20000 + android.defaultConfig.versionCode
versionNameSuffix = "-minApi23"
...
}
create("minApi21") {
dimension = "api"
minSdkVersion(21)
versionCode = 10000 + android.defaultConfig.versionCode
versionNameSuffix = "-minApi21"
...
}
}
}
...
Filtrare le varianti
Puoi filtrare le varianti di compilazione che non vuoi utilizzando il blocco
variantFilter nel file build.gradle del modulo. Il
seguente codice di esempio indica a Gradle di non creare varianti che combinano
i tipi di prodotto "minApi21" e "demo":
Groovy
android {
...
buildTypes {...}
flavorDimensions "api", "mode"
productFlavors {
demo {...}
full {...}
minApi24 {...}
minApi23 {...}
minApi21 {...}
}
variantFilter { variant ->
def names = variant.flavors*.name
// To check for a certain build type, use variant.buildType.name == "<buildType>"
if (names.contains("minApi21") && names.contains("demo")) {
// Gradle ignores any variants that satisfy the conditions above.
setIgnore(true)
}
}
}
...
Kotlin
android {
...
buildTypes {...}
flavorDimensions "api", "mode"
productFlavors {
create("demo") {...}
create("full") {...}
create("minApi24") {...}
create("minApi23") {...}
create("minApi21") {...}
}
}
androidComponents {
beforeVariants { variantBuilder ->
// To check for a certain build type, use variantBuilder.buildType == "<buildType>"
if (variantBuilder.productFlavors.containsAll(listOf("api" to "minApi21", "mode" to "demo"))) {
// Gradle ignores any variants that satisfy the conditions above.
variantBuilder.enabled = false
}
}
}
...
Testa la tua app
Per scoprire di più sull'esecuzione di test di unità locali e integrati, leggi l'articolo Testare l'app.
Configurare le opzioni di lint
Puoi configurare determinate opzioni di lint utilizzando il blocco
lintOptions nel file build.gradle a livello di modulo. Per approfondire l'utilizzo di lint per il tuo progetto Android, leggi l'articolo Migliorare il codice con Lint.
Groovy
android {
...
lintOptions {
// Turns off checks for the issue IDs you specify.
disable 'TypographyFractions','TypographyQuotes'
// Turns on checks for the issue IDs you specify. These checks are in
// addition to the default lint checks.
enable 'RtlHardcoded','RtlCompat', 'RtlEnabled'
// To enable checks for only a subset of issue IDs and ignore all others,
// list the issue IDs with the 'check' property instead. This property overrides
// any issue IDs you enable or disable using the properties above.
checkOnly 'NewApi', 'InlinedApi'
// If set to true, turns off analysis progress reporting by lint.
quiet true
// if set to true (default), stops the build if errors are found.
abortOnError false
// if true, only report errors.
ignoreWarnings true
}
}
...
Kotlin
android {
...
lintOptions {
// Turns off checks for the issue IDs you specify.
disable("TypographyFractions")
disable("TypographyQuotes")
// Turns on checks for the issue IDs you specify. These checks are in
// addition to the default lint checks.
enable("RtlHardcoded")
enable("RtlCompat")
enable("RtlEnabled")
// To enable checks for only a subset of issue IDs and ignore all others,
// list the issue IDs with the 'check' property instead. This property overrides
// any issue IDs you enable or disable using the properties above.
checkOnly("NewApi", "InlinedApi")
// If set to true, turns off analysis progress reporting by lint.
quiet = true
// if set to true (default), stops the build if errors are found.
abortOnError = false
// if true, only report errors.
ignoreWarnings = true
}
}
...
Configurare le impostazioni del manifest di misurazione
Quando Gradle compila l'APK di test, genera automaticamente il file AndroidManifest.xml e lo configura con il nodo <instrumentation>. Puoi modificare alcune delle impostazioni di questo nodo creando un altro file manifest nell'insieme di origini di test o configurando il file build.gradle a livello di modulo, come mostrato nel seguente esempio di codice.
Groovy
android {
...
// Each product flavor you configure can override properties in the
// defaultConfig block. To learn more, go to Configure Product Flavors.
defaultConfig {
...
// Specifies the application ID for the test APK.
testApplicationId "com.test.foo"
// Specifies the fully-qualified class name of the test instrumentation runner.
testInstrumentationRunner "android.test.InstrumentationTestRunner"
// If set to 'true', enables the instrumentation class to start and stop profiling.
// If set to false (default), profiling occurs the entire time the instrumentation
// class is running.
testHandleProfiling true
// If set to 'true', indicates that the Android system should run the instrumentation
// class as a functional test. The default value is 'false'
testFunctionalTest true
}
}
...
Kotlin
android {
...
// Each product flavor you configure can override properties in the
// defaultConfig block. To learn more, go to Configure Product Flavors.
defaultConfig {
...
// Specifies the application ID for the test APK.
testApplicationId = "com.test.foo"
// Specifies the fully-qualified class name of the test instrumentation runner.
testInstrumentationRunner = "android.test.InstrumentationTestRunner"
// If set to 'true', enables the instrumentation class to start and stop profiling.
// If set to false (default), profiling occurs the entire time the instrumentation
// class is running.
testHandleProfiling = true
// If set to 'true', indicates that the Android system should run the instrumentation
// class as a functional test. The default value is 'false'
testFunctionalTest = true
}
}
...
Modificare il tipo di build di test
Per impostazione predefinita, tutti i test vengono eseguiti sul tipo di compilazione di debug. Puoi impostare un altro tipo di compilazione utilizzando la proprietà testBuildType nel file build.gradle a livello di modulo. Ad esempio, se vuoi eseguire i test sul tipo di compilazione "preparazione", modifica il file come mostrato nel seguente snippet.
Groovy
android {
...
testBuildType "staging"
}
Kotlin
android {
...
testBuildType "staging"
}
Configurare le opzioni di test di Gradle
Per specificare opzioni che modificano il modo in cui Gradle esegue tutti i test, configura il blocco
testOptions a livello di modulo build.gradle.
Groovy
android {
...
// Encapsulates options for running tests.
testOptions {
// Changes the directory where Gradle saves test reports. By default, Gradle saves test reports
// in the path_to_your_project/module_name/build/outputs/reports/ directory.
// '$rootDir' sets the path relative to the root directory of the current project.
reportDir "$rootDir/test-reports"
// Changes the directory where Gradle saves test results. By default, Gradle saves test results
// in the path_to_your_project/module_name/build/outputs/test-results/ directory.
// '$rootDir' sets the path relative to the root directory of the current project.
resultsDir "$rootDir/test-results"
}
}
Kotlin
android {
...
// Encapsulates options for running tests.
testOptions {
// Changes the directory where Gradle saves test reports. By default, Gradle saves test reports
// in the path_to_your_project/module_name/build/outputs/reports/ directory.
// '$rootDir' sets the path relative to the root directory of the current project.
reportDir "$rootDir/test-reports"
// Changes the directory where Gradle saves test results. By default, Gradle saves test results
// in the path_to_your_project/module_name/build/outputs/test-results/ directory.
// '$rootDir' sets the path relative to the root directory of the current project.
resultsDir "$rootDir/test-results"
}
}
Per specificare le opzioni solo per i test di unità locali, configura il blocco
testOptions.unitTests.
Groovy
android {
...
testOptions {
...
// Encapsulates options for local unit tests.
unitTests {
// By default, local unit tests throw an exception any time the code you are testing tries to access
// Android platform APIs (unless you mock Android dependencies yourself or with a testing
// framework like Mockito). However, you can enable the following property so that the test
// returns either null or zero when accessing platform APIs, rather than throwing an exception.
returnDefaultValues true
// Encapsulates options for controlling how Gradle executes local unit tests. For a list
// of all the options you can specify, read Gradle's reference documentation.
all {
// Sets JVM argument(s) for the test JVM(s).
jvmArgs '-XX:MaxPermSize=256m'
// You can also check the task name to apply options to only the tests you specify.
if (it.name == 'testDebugUnitTest') {
systemProperty 'debug', 'true'
}
}
}
}
}
Kotlin
android {
...
testOptions {
...
// Encapsulates options for local unit tests.
unitTests {
// By default, local unit tests throw an exception any time the code you are testing tries to access
// Android platform APIs (unless you mock Android dependencies yourself or with a testing
// framework like Mockito). However, you can enable the following property so that the test
// returns either null or zero when accessing platform APIs, rather than throwing an exception.
returnDefaultValues true
// Encapsulates options for controlling how Gradle executes local unit tests. For a list
// of all the options you can specify, read Gradle's reference documentation.
all {
// Sets JVM argument(s) for the test JVM(s).
jvmArgs '-XX:MaxPermSize=256m'
// You can also check the task name to apply options to only the tests you specify.
if (it.name == 'testDebugUnitTest') {
systemProperty 'debug', 'true'
}
}
}
}
}
Ottimizza la compilazione
Questa sezione fornisce alcune configurazioni per velocizzare le compilazioni complete e incrementali. Per scoprire di più, consulta Ottimizzare la velocità di compilazione.
Riduci il codice
Android Studio utilizza R8, che utilizza i file delle regole di ProGuard, per ridurre il codice. Per i nuovi progetti, Android Studio utilizza un file di impostazioni predefinite (proguard-android.txt) da tools/proguard/folder dell'SDK Android. Per ridurre ulteriormente il codice, prova il
proguard-android-optimize.txt file nella stessa posizione.
Groovy
android {
buildTypes {
release {
minifyEnabled true
proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'),
'proguard-rules.pro'
}
}
...
}
...
Kotlin
android {
buildTypes {
release {
minifyEnabled true
proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'),
'proguard-rules.pro'
}
}
...
}
...
Per aggiungere regole specifiche per ogni variante di build, configura un'ulteriore proprietà
proguardFiles per ogni flavor. Ad esempio, il
seguente esempio aggiunge flavor2-rules.pro a "flavor2". Ora la versione release di "flavor2" utilizza tutti e tre i file delle regole perché vengono applicati anche quelli del blocco release.
Groovy
android {
...
buildTypes {
release {
minifyEnabled true
proguardFiles getDefaultProguardFile('proguard-android.txt'),
'proguard-rules.pro'
}
}
productFlavors {
flavor1 {
...
}
flavor2 {
proguardFile 'flavor2-rules.pro'
}
}
}
...
Kotlin
android {
...
buildTypes {
release {
minifyEnabled true
proguardFiles getDefaultProguardFile('proguard-android.txt'),
'proguard-rules.pro'
}
}
productFlavors {
flavor1 {
...
}
flavor2 {
proguardFile 'flavor2-rules.pro'
}
}
}
...
Pubblicare un'app
Per scoprire di più sulla pubblicazione della tua app su Google Play, leggi l'articolo Pubblicare l'app.
Firma la tua app
Sebbene Android Studio offra un modo semplice per configurare la firma per le build di release dall'interfaccia utente, puoi configurare manualmente il blocco
signingConfigs nel file build.gradle del modulo:
Groovy
android {
...
defaultConfig { ... }
// Encapsulates signing configurations.
signingConfigs {
// Creates a signing configuration called "release".
release {
// Specifies the path to your keystore file.
storeFile file("my-release-key.jks")
// Specifies the password for your keystore.
storePassword "password"
// Specifies the identifying name for your key.
keyAlias "my-alias"
// Specifies the password for your key.
keyPassword "password"
}
}
buildTypes {
release {
// Adds the "release" signing configuration to the release build type.
signingConfig signingConfigs.release
...
}
}
}
...
Kotlin
android {
...
defaultConfig { ... }
// Encapsulates signing configurations.
signingConfigs {
// Creates a signing configuration called "release".
release {
// Specifies the path to your keystore file.
storeFile file("my-release-key.jks")
// Specifies the password for your keystore.
storePassword "password"
// Specifies the identifying name for your key.
keyAlias "my-alias"
// Specifies the password for your key.
keyPassword "password"
}
}
buildTypes {
release {
// Adds the "release" signing configuration to the release build type.
signingConfig signingConfigs.release
...
}
}
}
...
Rimuovere le informazioni di firma privata dal progetto
Per impostazione predefinita, le configurazioni di firma vengono registrate in testo normale nel file build.gradle del modulo. Se collabori con un team o un progetto open source, puoi spostare queste informazioni sensibili dai file di compilazione procedendo nel seguente modo.
- Crea un file denominato
keystore.propertiesnella directory principale del progetto e includi le seguenti informazioni:storePassword=myStorePassword keyPassword=myKeyPassword keyAlias=myKeyAlias storeFile=myStoreFileLocation
- Nel file
build.gradle, carica il filekeystore.propertiescome segue (deve essere prima del blocco Android):Groovy
// Creates a variable called keystorePropertiesFile, and initializes it to the // keystore.properties file. def keystorePropertiesFile = rootProject.file("keystore.properties") // Initializes a new Properties() object called keystoreProperties. def keystoreProperties = new Properties() // Loads the keystore.properties file into the keystoreProperties object. keystoreProperties.load(new FileInputStream(keystorePropertiesFile)) android { ... } ...Kotlin
// Creates a variable called keystorePropertiesFile, and initializes it to the // keystore.properties file. def keystorePropertiesFile = rootProject.file("keystore.properties") // Initializes a new Properties() object called keystoreProperties. def keystoreProperties = new Properties() // Loads the keystore.properties file into the keystoreProperties object. keystoreProperties.load(new FileInputStream(keystorePropertiesFile)) android { ... } ... - Inserisci le informazioni di firma memorizzate nell'oggetto
keystorePropertiesGroovy
android { signingConfigs { config { keyAlias keystoreProperties['keyAlias'] keyPassword keystoreProperties['keyPassword'] storeFile file(keystoreProperties['storeFile']) storePassword keystoreProperties['storePassword'] } } ... } ...Kotlin
android { signingConfigs { config { keyAlias keystoreProperties['keyAlias'] keyPassword keystoreProperties['keyPassword'] storeFile file(keystoreProperties['storeFile']) storePassword keystoreProperties['storePassword'] } } ... } ... - Fai clic su Sincronizza ora nella barra delle notifiche.
Per scoprire di più sulla firma dell'app, leggi l'articolo Firmare l'app.
Semplifica lo sviluppo delle app
I seguenti suggerimenti ti aiutano a semplificare lo sviluppo della tua app per Android.
Condividere campi e valori delle risorse personalizzati con il codice dell'app
In fase di compilazione, Gradle genera la classe BuildConfig in modo che il codice dell'app possa ispezionare le informazioni sulla build corrente. Puoi anche aggiungere
campi personalizzati alla classe BuildConfig dal file di configurazione della compilazione Gradle
utilizzando il metodo buildConfigField() e accedere
a questi valori nel codice di runtime dell'app. Analogamente, puoi aggiungere valori delle risorse dell'app con resValue().
Groovy
android {
...
buildTypes {
release {
// These values are defined only for the release build, which
// is typically used for full builds and continuous builds.
buildConfigField("String", "BUILD_TIME", "\"${minutesSinceEpoch}\"")
resValue("string", "build_time", "${minutesSinceEpoch}")
...
}
debug {
// Use static values for incremental builds to ensure that
// resource files and BuildConfig aren't rebuilt with each run.
// If these rebuild dynamically, they can interfere with
// Apply Changes as well as Gradle UP-TO-DATE checks.
buildConfigField("String", "BUILD_TIME", "\"0\"")
resValue("string", "build_time", "0")
}
}
}
...
Kotlin
android {
...
buildTypes {
release {
// These values are defined only for the release build, which
// is typically used for full builds and continuous builds.
buildConfigField("String", "BUILD_TIME", "\"${minutesSinceEpoch}\"")
resValue("string", "build_time", "${minutesSinceEpoch}")
...
}
debug {
// Use static values for incremental builds to ensure that
// resource files and BuildConfig aren't rebuilt with each run.
// If these rebuild dynamically, they can interfere with
// Apply Changes as well as Gradle UP-TO-DATE checks.
buildConfigField("String", "BUILD_TIME", "\"0\"")
resValue("string", "build_time", "0")
}
}
}
...
Nel codice dell'app, puoi accedere alle proprietà come segue:
Kotlin
... Log.i(TAG, BuildConfig.BUILD_TIME) Log.i(TAG, getString(R.string.build_time))
Java
... Log.i(TAG, BuildConfig.BUILD_TIME); Log.i(TAG, getString(R.string.build_time));
Condividere le proprietà con il manifest
In alcuni casi, potrebbe essere necessario dichiarare la stessa proprietà sia nel manifest sia nel codice (ad esempio, quando si dichiarano le autorità per un FileProvider).
Anziché aggiornare la stessa proprietà in più posizioni per riflettere una variazione, definisci una singola proprietà nel file build.gradle del modulo per renderla disponibile sia nel manifest sia nel codice, come mostrato nell'esempio seguente. Per scoprire di più, leggi Eseguire l'iniezione di variabili di compilazione nel manifest.
Groovy
android {
// For settings specific to a product flavor, configure these properties
// for each flavor in the productFlavors block.
defaultConfig {
// Creates a property for the FileProvider authority.
def filesAuthorityValue = applicationId + ".files"
// Creates a placeholder property to use in the manifest.
manifestPlaceholders =
[filesAuthority: filesAuthorityValue]
// Adds a new field for the authority to the BuildConfig class.
buildConfigField("String",
"FILES_AUTHORITY",
"\"${filesAuthorityValue}\"")
}
...
}
...
Kotlin
android {
// For settings specific to a product flavor, configure these properties
// for each flavor in the productFlavors block.
defaultConfig {
// Creates a property for the FileProvider authority.
val filesAuthorityValue = applicationId + ".files"
// Creates a placeholder property to use in the manifest.
manifestPlaceholders["filesAuthority"] = filesAuthorityValue
// Adds a new field for the authority to the BuildConfig class.
buildConfigField("String",
"FILES_AUTHORITY",
"\"${filesAuthorityValue}\"")
}
...
}
...
Nel manifest, accedi al segnaposto come segue:
<manifest>
...
<application>
...
<provider
android:name="android.support.v4.content.FileProvider"
android:authorities="${filesAuthority}"
android:exported="false"
android:grantUriPermissions="true">
...
</provider>
</application>
</manifest>
L'accesso al campo FILES_AUTHORITY nel codice dell'app è simile al seguente:
Kotlin
... val contentUri: Uri = FileProvider.getUriForFile(context, BuildConfig.FILES_AUTHORITY, myFile)
Java
... Uri contentUri = FileProvider.getUriForFile(getContext(), BuildConfig.FILES_AUTHORITY, myFile);