Come impostare versionName nel nome file APK utilizzando gradle?

Sto provando a impostare un numero di versione specifico nel nome file APK generato automaticamente da gradle.

Adesso gradle genera myapp-release.apk ma voglio che assomigli a myapp-release-1.0.apk .

Ho provato a rinominare le opzioni che sembrano disordinate. C’è un modo semplice per fare questo?

 buildTypes { release { signingConfig signingConfigs.release applicationVariants.each { variant -> def file = variant.outputFile variant.outputFile = new File(file.parent, file.name.replace(".apk", "-" + defaultConfig.versionName + ".apk")) } } 

Ho provato il codice sopra senza fortuna. Eventuali suggerimenti? (usando gradle 1.6)

Devo solo cambiare il nome della versione in un posto. Anche il codice è semplice.

Gli esempi seguenti creeranno i file apk denominati MyCompany-MyAppName-1.4.8-debug.apk o MyCompany-MyAppName-1.4.8-release.apk in base alla variante di build selezionata.

Vedi anche: Come cambiare il nome del file di mapping proguard in gradle per il progetto Android

Soluzione per il plugin Gradle recenti

 android { compileSdkVersion 22 buildToolsVersion "22.0.1" defaultConfig { applicationId "com.company.app" minSdkVersion 13 targetSdkVersion 21 versionCode 14 // increment with every release versionName '1.4.8' // change with every release setProperty("archivesBaseName", "MyCompany-MyAppName-$versionName") } } 

La soluzione di cui sopra è stata testata con le seguenti versioni di Android Gradle Plugin:

  • 3.1.0 (marzo 2018)
  • 3.0.1 (novembre 2017)
  • 3.0.0 (ottobre 2017)
  • 2.3.2 (maggio 2017)
  • 2.3.1 (aprile 2017)
  • 2.3.0 (febbraio 2017)
  • 2.2.3 (dicembre 2016)
  • 2.2.2
  • 2.2.0 (settembre 2016)
  • 2.1.3 (agosto 2016)
  • 2.1.2
  • 2.0.0 (aprile 2016)
  • 1.5.0 (2015/11/12)
  • 1.4.0-beta6 (2015/10/05)
  • 1.3.1 (2015/08/11)

Aggiornerò questo post man mano che escono nuove versioni.

Soluzione testata Solo sulle versioni 1.1.3-1.3.0

La seguente soluzione è stata testata con le seguenti versioni di Android Gradle Plugin:

  • 1.3.0 (2015/07/30) – Non funzionante, bug programmato per essere corretto in 1.3.1
  • 1.2.3 (2015/07/21)
  • 1.2.2 (2015/04/28)
  • 1.2.1 (2015/04/27)
  • 1.2.0 (2015/04/26)
  • 1.2.0-beta1 (25/03/2015)
  • 1.1.3 (2015/03/06)

file gradle app:

 apply plugin: 'com.android.application' android { compileSdkVersion 21 buildToolsVersion "21.1.2" defaultConfig { applicationId "com.company.app" minSdkVersion 13 targetSdkVersion 21 versionCode 14 // increment with every release versionName '1.4.8' // change with every release archivesBaseName = "MyCompany-MyAppName-$versionName" } } 

Questo ha risolto il mio problema: l’uso di applicationVariants.all invece di applicationVariants.each

 buildTypes { release { signingConfig signingConfigs.release applicationVariants.all { variant -> def file = variant.outputFile variant.outputFile = new File(file.parent, file.name.replace(".apk", "-" + defaultConfig.versionName + ".apk")) } } } 

Aggiornare:

Quindi sembra che questo non funzioni con le versioni 0.14+ del plugin Android Studio Gradle.

Questo fa il trucco (riferimento da questa domanda ):

 android { applicationVariants.all { variant -> variant.outputs.each { output -> output.outputFile = new File( output.outputFile.parent, output.outputFile.name.replace(".apk", "-${variant.versionName}.apk")) } } } 

(MODIFICATO per funzionare con Android Studio 3.0 e Gradle 4)

Stavo cercando un’opzione di ridenominazione del nome file apk più complessa e l’ho scritto nella speranza che sia utile per chiunque altro. Rinomina l’apk con i seguenti dati:

  • gusto
  • tipo di costruzione
  • versione
  • Data

Mi ci è voluto un po ‘di ricerca nelle classi di gradle e un po’ di copia / incolla da altre risposte. Sto usando gradle 3.1.3 .

Nel build.gradle:

 android { ... buildTypes { release { minifyEnabled true ... } debug { minifyEnabled false } } productFlavors { prod { applicationId "com.feraguiba.myproject" versionCode 3 versionName "1.2.0" } dev { applicationId "com.feraguiba.myproject.dev" versionCode 15 versionName "1.3.6" } } applicationVariants.all { variant -> variant.outputs.all { output -> def project = "myProject" def SEP = "_" def flavor = variant.productFlavors[0].name def buildType = variant.variantData.variantConfiguration.buildType.name def version = variant.versionName def date = new Date(); def formattedDate = date.format('ddMMyy_HHmm') def newApkName = project + SEP + flavor + SEP + buildType + SEP + version + SEP + formattedDate + ".apk" outputFileName = new File(newApkName) } } } 

Se compili oggi (13-10-2016) alle 10:47, ottieni i seguenti nomi di file a seconda del tipo di aroma e di costruzione che hai scelto:

  • debug di debug : myProject_ dev_debug_1.3.6 _131016_1047.apk
  • versione di sviluppo : myProject_ dev_release_1.3.6 _131016_1047.apk
  • prod debug : myProject_ prod_debug_1.2.0 _131016_1047.apk
  • prod versione : myProject_ prod_release_1.2.0 _131016_1047.apk

Nota: il nome apk della versione non allineata è ancora quello predefinito.

Se non si specifica versionName nel blocco defaultConfig.versionName , defaultConfig.versionName risulterà null

per ottenere versionName da manifest puoi scrivere il seguente codice in build.gradle:

 import com.android.builder.DefaultManifestParser def manifestParser = new DefaultManifestParser() println manifestParser.getVersionName(android.sourceSets.main.manifest.srcFile) 

Per riassumere, per coloro che non sanno come importare il pacchetto in build.gradle (come me), utilizzare i seguenti buildTypes ,

 buildTypes { release { signingConfig signingConfigs.release applicationVariants.all { variant -> def file = variant.outputFile def manifestParser = new com.android.builder.core.DefaultManifestParser() variant.outputFile = new File(file.parent, file.name.replace(".apk", "-" + manifestParser.getVersionName(android.sourceSets.main.manifest.srcFile) + ".apk")) } } } 

===== EDIT =====

Se imposti il ​​tuo versionCode e versionName nel tuo file build.gradle questo modo:

 defaultConfig { minSdkVersion 15 targetSdkVersion 19 versionCode 1 versionName "1.0.0" } 

Dovresti impostarlo in questo modo:

 buildTypes { release { signingConfig signingConfigs.releaseConfig applicationVariants.all { variant -> def file = variant.outputFile variant.outputFile = new File(file.parent, file.name.replace(".apk", "-" + defaultConfig.versionName + ".apk")) } } } 

====== EDIT con Android Studio 1.0 ======

Se utilizzi Android Studio 1.0, riceverai un errore come questo:

 Error:(78, 0) Could not find property 'outputFile' on com.android.build.gradle.internal.api.ApplicationVariantImpl_Decorated@67e7625f. 

Dovresti cambiare la parte build.Types a questo:

 buildTypes { release { signingConfig signingConfigs.releaseConfig applicationVariants.all { variant -> variant.outputs.each { output -> output.outputFile = new File(output.outputFile.parent, output.outputFile.name.replace(".apk", "-" + defaultConfig.versionName + ".apk")) } } } } 

Nel mio caso, volevo solo trovare un modo per automatizzare la generazione di un nome apk diverso per le varianti di release e debug . Sono riuscito a farlo facilmente inserendo questo frammento come figlio di android :

 applicationVariants.all { variant -> variant.outputs.each { output -> def appName = "My_nice_name_" def buildType = variant.variantData.variantConfiguration.buildType.name def newName if (buildType == 'debug'){ newName = "${appName}${defaultConfig.versionName}_dbg.apk" } else { newName = "${appName}${defaultConfig.versionName}_prd.apk" } output.outputFile = new File(output.outputFile.parent, newName) } } 

Per il nuovo Android gradle plugin 3.0.0 puoi fare qualcosa del genere:

  applicationVariants.all { variant -> variant.outputs.all { def appName = "My_nice_name_" def buildType = variant.variantData.variantConfiguration.buildType.name def newName if (buildType == 'debug'){ newName = "${appName}${defaultConfig.versionName}_dbg.apk" } else { newName = "${appName}${defaultConfig.versionName}_prd.apk" } outputFileName = newName } } 

Questo produce qualcosa come: My_nice_name_3.2.31_dbg.apk

Un’altra alternativa è usare il seguente:

 String APK_NAME = "appname" int VERSION_CODE = 1 String VERSION_NAME = "1.0.0" project.archivesBaseName = APK_NAME + "-" + VERSION_NAME; android { compileSdkVersion 21 buildToolsVersion "21.1.1" defaultConfig { applicationId "com.myapp" minSdkVersion 15 targetSdkVersion 21 versionCode VERSION_CODE versionName VERSION_NAME } .... // Rest of your config } 

Questo imposterà “appname-1.0.0” a tutte le uscite degli apk.

Grado 4

La syntax è leggermente cambiata in Gradle 4 (Android Studio 3+) (da output.outputFile a outputFileName , l’idea di questa risposta è ora:

 android { applicationVariants.all { variant -> variant.outputs.each { output -> def newName = outputFileName newName.replace(".apk", "-${variant.versionName}.apk") outputFileName = new File(newName) } } } 

Ci sono molte risposte che sono corrette per intero o dopo alcune modifiche. Ma aggiungerò il mio perché ho avuto il problema con tutti loro perché stavo usando script per generare VersionName e VersionCode dynamicmente agganciando l’attività di preBuild .

Se stai usando un approccio simile, questo è il codice che funzionerà:

 project.android.applicationVariants.all { variant -> variant.preBuild.doLast { variant.outputs.each { output -> output.outputFile = new File( output.outputFile.parent, output.outputFile.name.replace(".apk", "-${variant.versionName}@${variant.versionCode}.apk")) } } } 

Per spiegare: Poiché sto sovrascrivendo il codice e il nome della versione nella prima azione di preBuild devo aggiungere il nome del file alla fine di questa attività. Quindi, cosa farà il gradle in questo caso:

Inietta codice versione / nome-> fai azioni prebild -> sostituisci nome per apk

Nel mio caso risolvo questo errore in questo modo

aggiungendo un SUFFIX alla versione Debug, in questo caso aggiungo il testo “-DEBUG” alla mia distribuzione Debug

  buildTypes { release { signingConfig signingConfigs.release minifyEnabled false proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' } debug { defaultConfig { debuggable true versionNameSuffix "-DEBUG" } } } 
  applicationVariants.all { variant -> variant.outputs.all { output -> output.outputFileName = output.outputFileName.replace(".apk", "-${variant.versionName}.apk") } } 

Per le ultime versioni di gradle puoi usare il seguente frammento:

Imposta prima la posizione del manifest dell’applicazione

  sourceSets { main { manifest.srcFile 'src/main/AndroidManifest.xml' { } 

E più avanti in build.gradle

 import com.android.builder.core.DefaultManifestParser def getVersionName(manifestFile) { def manifestParser = new DefaultManifestParser(); return manifestParser.getVersionName(manifestFile); } def manifestFile = file(android.sourceSets.main.manifest.srcFile); def version = getVersionName(manifestFile) buildTypes { release { signingConfig signingConfigs.release applicationVariants.each { variant -> def file = variant.outputFile variant.outputFile = new File(file.parent, file.name.replace(".apk", "-" + versionName + ".apk")) } } 

Regola se hai manifesti diversi per tipo di build. ma dal momento che ho il singolo, funziona perfettamente per me.

A partire da Android Studio 1.1.0, ho trovato questa combinazione funzionante nel corpo Android del file build.gradle . Questo è se non riesci a capire come importare i dati del file manifest xml. Vorrei che fosse più supportato da Android Studio, ma solo giocare con i valori fino a ottenere l’output del nome apk desiderato:

 defaultConfig { applicationId "com.package.name" minSdkVersion 14 targetSdkVersion 21 versionCode 6 versionName "2" } signingConfigs { release { keyAlias = "your key name" } } buildTypes { release { minifyEnabled true proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' signingConfig signingConfigs.release applicationVariants.all { variant -> variant.outputs.each { output -> output.outputFile = new File(output.outputFile.parent, output.outputFile.name.replace("app-release.apk", "appName_" + versionName + ".apk")) } } } }