webentwicklung-frage-antwort-db.com.de

Wie setze ich versionName in APK filename mit gradle?

Ich versuche, eine bestimmte Versionsnummer im automatisch generierten APK-Dateinamen von Gradle festzulegen.

Jetzt erzeugt gradle myapp-release.apk aber ich möchte, dass es so aussieht wie myapp-release-1.0.apk.

Ich habe versucht, Optionen umzubenennen, die chaotisch scheinen. Gibt es eine einfache Möglichkeit, dies zu tun?

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"))
    }
}

Ich habe den obigen Code ohne Glück ausprobiert. Irgendwelche Vorschläge? (mit gradle 1.6)

158
codaR0y

Dies löste mein Problem: mit applicationVariants.all anstatt 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")) 
        }
    }       
}

Aktualisieren:

Es sieht also so aus, als würde dies mit 0.14+ Versionen von Android studio gradle plugin) nicht funktionieren.

Dies macht den Trick (Referenz von diesem Frage ):

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

Ich muss den Versionsnamen nur an einer Stelle ändern. Der Code ist auch einfach.

Die folgenden Beispiele erstellen Apk-Dateien mit dem Namen MyCompany-MyAppName-1.4.8-debug.apk oder MyCompany-MyAppName-1.4.8-release.apk abhängig von der gewählten Build-Variante.

Beachten Sie, dass diese Lösung sowohl für APK als auch für App Bundles (.aab-Dateien) funktioniert.

Siehe auch: So ändern Sie den Namen der Proguard-Zuordnungsdatei in gradle für Android project

Lösung für das neueste Gradle-Plugin

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")
    }
}

Die obige Lösung wurde mit den folgenden Android Gradle Plugin-Versionen getestet:

  • 3.3.0 (Januar 2019)
  • 3.1.0 (März 2018)
  • 3.0.1 (November 2017)
  • 3.0.0 (Oktober 2017)
  • 2.3.2 (Mai 2017)
  • 2.3.1 (April 2017)
  • 2.3.0 (Februar 2017)
  • 2.2.3 (Dezember 2016)
  • 2.2.2
  • 2.2.0 (September 2016)
  • 2.1.3 (August 2016)
  • 2.1.2
  • 2.0.0 (April 2016)
  • 1.5.0 (12.11.2015)
  • 1.4.0-beta6 (05.10.2015)
  • 1.3.1 (11.08.2015)

Ich werde diesen Beitrag aktualisieren, sobald neue Versionen herauskommen.

Getestete Lösung Nur in den Versionen 1.1.3-1.3.0

Die folgende Lösung wurde mit den folgenden Android Gradle Plugin-Versionen getestet:

app-Gradle-Datei:

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"
    }
}
205
Jon

(BEARBEITET, um mit Android Studio 3.0 und Gradle 4) zu arbeiten

Ich suchte nach einer komplexeren Umbenennungsoption für Apk-Dateinamen und schrieb diese in der Hoffnung, dass sie für alle anderen hilfreich ist. Es benennt die apk mit den folgenden Daten:

  • Geschmack
  • Build-Typ
  • version
  • Datum

Ich brauchte ein bisschen Nachforschungen in der Grundschule und ein bisschen Kopieren/Einfügen aus anderen Antworten. Ich benutze gradle 3.1..

Im 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)
        }
    }
}

Wenn Sie heute (13-10-2016) um 10:47 Uhr kompilieren, erhalten Sie die folgenden Dateinamen, abhängig von der von Ihnen gewählten Version und dem gewählten Build-Typ:

  • dev debug: myProject _dev_debug_1.3.6 _ 131016_1047.apk
  • dev release: myProject _dev_release_1.3.6 _ 131016_1047.apk
  • prod debug: myProject _prod_debug_1.2. _ 131016_1047.apk
  • prod release: myProject _prod_release_1.2. _ 131016_1047.apk

Hinweis: Der Apk-Name der nicht ausgerichteten Version ist immer noch der Standardname.

39
Fer

Zusammenfassend kann man sagen, dass diejenigen, die nicht wissen, wie man ein Paket in build.gradle (Wie ich) importiert, folgendes buildTypes verwenden:

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 =====

Wenn Sie Ihr versionCode und versionName in Ihrer build.gradle - Datei wie folgt einstellen:

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

Sie sollten es so einstellen:

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"))
            }
        }
}


====== BEARBEITEN mit =Android Studio 1.0 ======

Wenn Sie Android Studio 1.0 verwenden, wird eine Fehlermeldung wie die folgende angezeigt:

Error:(78, 0) Could not find property 'outputFile' on com.And[email protected]67e7625f.

Sie sollten den Teil build.Types Folgendermaßen ändern:

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"))
                }
            }
        }
    }
18
Wesley

Wenn Sie im defaultConfig-Block nicht versionName angeben, wird defaultConfig.versionName führt zu null

um versionName aus dem Manifest zu erhalten, können Sie folgenden Code in build.gradle schreiben:

import com.Android.builder.DefaultManifestParser

def manifestParser = new DefaultManifestParser()
println manifestParser.getVersionName(Android.sourceSets.main.manifest.srcFile)
17

In meinem Fall wollte ich nur eine Möglichkeit finden, die Generierung verschiedener apk -Namen für release- und debug -Varianten zu automatisieren. Ich habe es leicht gemacht, indem ich dieses Snippet als Kind von Android eingefügt habe:

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)
    }
}

Für das neue Android gradle plugin 3.0.0 kannst du so etwas machen:

 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
    }
}

Diese produzieren so etwas wie: My_Nice_name_3.2.31_dbg.apk

8
yshahak

Gradle 4

Die Syntax hat sich in Gradle 4 (Android Studio 3+) etwas geändert (von output.outputFile bis outputFileName, Idee von diese Antwort ist jetzt:

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

Eine andere Alternative besteht darin, Folgendes zu verwenden:

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
}

Dadurch wird "appname-1.0.0" für alle Ihre apk-Ausgaben festgelegt.

5
Marco RS

Der richtige Weg, um apk umzubenennen, wie pro @ Jon Antwort

defaultConfig {
        applicationId "com.irisvision.patientapp"
        minSdkVersion 24
        targetSdkVersion 22
        versionCode 2  // increment with every release
        versionName "0.2" // change with every release
        testInstrumentationRunner "Android.support.test.runner.AndroidJUnitRunner"
        //add this line
        archivesBaseName = "AppName-${versionName}-${new Date().format('yyMMdd')}"
    }   

Oder eine andere Möglichkeit, mit der Sie dieselben Ergebnisse erzielen können

Android {
    ...

    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }

    applicationVariants.all { variant ->
        variant.outputs.all { output ->
            def formattedDate = new Date().format('yyMMdd')
            outputFileName = "${outputFileName.replace(".apk","")}-v${defaultConfig.versionCode}-${formattedDate}.apk"
        }
    }
}
5
Qamar

Es gibt viele Antworten, die entweder vollständig oder nach einigen Änderungen richtig sind. Aber ich werde meine trotzdem hinzufügen, da ich das Problem mit allen hatte, weil ich mit Skripten Versionsname und Versionscode dynamisch generiert habe, indem ich mich in die Task preBuild eingebunden habe.

Wenn Sie einen ähnlichen Ansatz verwenden, ist dies der Code, der funktionieren wird:

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"))
        }
    }
}

Zur Erklärung: Da ich in der ersten Aktion von preBuild den Versionscode und -namen überschreibe, muss ich die Umbenennung der Datei am Ende dieser Aufgabe hinzufügen. Also, was Gradle in diesem Fall tun wird, ist:

Versionscode/Name einspritzen -> PreBuild-Aktionen ausführen -> Name für apk ersetzen

3
PSIXO
    applicationVariants.all { variant ->
        variant.outputs.all { output ->
            output.outputFileName = output.outputFileName.replace(".apk", "-${variant.versionName}.apk")
        }
    }
2
timeon

In meinem Fall löse ich diesen Fehler auf diese Weise

hinzufügen eines SUFFIX zur Debug-Version. In diesem Fall füge ich den Text "-DEBUG" zu meiner Debug-Bereitstellung hinzu

 buildTypes {
        release {

            signingConfig signingConfigs.release
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-Android.txt'), 'proguard-rules.pro'


        }
        debug {

            defaultConfig {
                debuggable true

                versionNameSuffix "-DEBUG"
            }
        }
    }
1
exequielc

Ab Android Studio 1.1.0) funktionierte diese Kombination im Android Body des build.gradle Datei. Dies ist der Fall, wenn Sie nicht herausfinden können, wie die Manifest-XML-Dateidaten importiert werden. Ich wünschte, es würde mehr von Android Studio unterstützt, aber spiele einfach mit den Werten herum, bis du den gewünschten Apk-Namen bekommst:

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"))
                }
            }
        }
    }
0
A13X

Für die neuesten Versionen von Gradle können Sie das folgende Snippet verwenden:

Legen Sie zuerst den Speicherort Ihres Anwendungsmanifests fest

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

Und später 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"))
    }
}

Passen Sie an, ob Sie unterschiedliche Manifeste pro Build-Typ haben. aber da ich die einzige habe - funktioniert das perfekt für mich.

0
Alfishe