Próbuję ustawić konkretny numer wersji w automatycznie generowanej przez Gradle nazwie pliku APK.

Teraz gradle generuje, myapp-release.apkale chcę, żeby wyglądało jak myapp-release-1.0.apk.

Próbowałem zmienić nazwy opcji, które wydają się niechlujne. Czy jest na to prosty sposób?

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

Wypróbowałem powyższy kod bez powodzenia. Jakieś sugestie? (przy użyciu klasy 1.6)

Wystarczy, że zmienię nazwę wersji w jednym miejscu. Kod też jest prosty.

Poniższe przykłady utworzą pliki apk o nazwach MyCompany-MyAppName-1.4.8-debug.apk lub MyCompany-MyAppName-1.4.8-release.apk w zależności od wybranego wariantu kompilacji.

Pamiętaj, że to rozwiązanie działa zarówno w przypadku pakietów APK, jak i pakietów aplikacji (pliki .aab) .

Zobacz też: Jak zmienić nazwę pliku mapowania proguard w Gradle dla projektu Android

Rozwiązanie dla najnowszej wtyczki Gradle

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

Powyższe rozwiązanie zostało przetestowane z następującymi wersjami wtyczek Android Gradle:

• 3.5.2 (listopad 2019 r.)
• 3.3.0 (styczeń 2019 r.)
• 3.1.0 (marzec 2018 r.)
• 3.0.1 (listopad 2017)
• 3.0.0 (październik 2017)
• 2.3.2 (maj 2017)
• 2.3.1 (kwiecień 2017)
• 2.3.0 (luty 2017)
• 2.2.3 (grudzień 2016 r.)
• 2.2.2
• 2.2.0 (wrzesień 2016 r.)
• 2.1.3 (sierpień 2016 r.)
• 2.1.2
• 2.0.0 (kwiecień 2016 r.)
• 1.5.0 (2015/11/12)
• 1.4.0-beta6 (2015/10/05)
• 1.3.1 (2015/08/11)

Zaktualizuję ten post, gdy pojawią się nowe wersje.

Rozwiązanie przetestowane tylko w wersjach 1.1.3-1.3.0

Następujące rozwiązanie zostało przetestowane z następującymi wersjami wtyczek Android Gradle:

• 1.3.0 (30.07.2015) - Nie działa, błąd zaplanowany do naprawienia w 1.3.1
• 1.2.3 (21.07.2015)
• 1.2.2 (28.04.2015)
• 1.2.1 (27.04.2015)
• 1.2.0 (26.04.2015)
• 1.2.0-beta1 (2015/03/25)
• 1.1.3 (2015/03/06)

plik oceny aplikacji:

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

To rozwiązało mój problem: używanie applicationVariants.allzamiastapplicationVariants.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")) 
        }
    }       
}

Aktualizacja:

Wygląda więc na to, że nie działa to z wersjami 0.14+ wtyczki Android Studio Gradle.

To załatwia sprawę (odniesienie do tego pytania ):

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

(ZMIENIONO do pracy z Android Studio 3.0 i Gradle 4)

Szukałem bardziej złożonej opcji zmiany nazwy pliku apk i napisałem tę w nadziei, że będzie pomocna dla każdego innego. Zmienia nazwę apk z następującymi danymi:

• smak
• typ kompilacji
• wersja
• data

Zajęło mi to trochę badań w klasach i trochę kopiowania / wklejania z innych odpowiedzi. Używam gradle 3.1.3 .

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

Jeśli skompilujesz dzisiaj (13-10-2016) o 10:47, otrzymasz następujące nazwy plików w zależności od wybranego smaku i typu kompilacji:

• dev debug : myProject_ dev_debug_1.3.6 _131016_1047.apk
• wersja deweloperska: myProject_ dev_release_1.3.6 _131016_1047.apk
• debugowanie prod : myProject_ prod_debug_1.2.0 _131016_1047.apk
• wydanie prod : myProject_ prod_release_1.2.0 _131016_1047.apk

Uwaga: niewyrównana nazwa apk wersji jest nadal domyślną.

Podsumowując, dla tych, którzy nie wiedzą, jak zaimportować paczkę build.gradle(tak jak ja), użyj następującego 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")) 
        }
    }       
}

===== EDYCJA =====

Jeśli ustawisz versionCodei versionNamew build.gradlepliku jak poniżej:

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

Powinieneś to ustawić tak:

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

====== EDYCJA w Android Studio 1.0 ======

Jeśli korzystasz z Android Studio 1.0, pojawi się następujący błąd:

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

Powinieneś zmienić build.Typesczęść na następującą:

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

Jeśli nie określisz versionName w bloku defaultConfig, defaultConfig.versionNamespowoduje tonull

aby pobrać versionName z manifestu, możesz napisać następujący kod w build.gradle:

import com.android.builder.DefaultManifestParser

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

W moim przypadku chciałem tylko znaleźć sposób na zautomatyzowanie generowania różnych apknazw releasei debugwariantów. Udało mi się to łatwo zrobić, umieszczając ten fragment jako dziecko 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)
    }
}

W przypadku nowej wtyczki Gradle dla Androida 3.0.0 możesz zrobić coś takiego:

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

To daje coś takiego: My_nice_name_3.2.31_dbg.apk

Inną alternatywą jest użycie:

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
}

Spowoduje to ustawienie „appname-1.0.0” na wszystkie wyjścia apk.

Gradle 6+

Teraz używam następujących w Android Studio 4.0 i Gradle 6.4:

android {
    defaultConfig {
        applicationId "com.mycompany.myapplication"
        minSdkVersion 21
        targetSdkVersion 29
        versionCode 15
        versionName "2.1.1"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
            applicationVariants.all { variant ->
                variant.outputs.all {
                    outputFileName = "ApplicationName-${variant.name}-${variant.versionName}.apk"
                }
            }
        }
    }
}

Gradle 4

Składnia nieco się zmieniła w Gradle 4 (Android Studio 3+) (od output.outputFiledo outputFileName, idea z tej odpowiedzi jest teraz:

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

Właściwy sposób na zmianę nazwy apk, zgodnie z odpowiedzią @Jon

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

Lub w inny sposób możesz osiągnąć te same wyniki za pomocą

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

Istnieje wiele odpowiedzi, które są poprawne w całości lub po pewnych modyfikacjach. Ale i tak mam zamiar dodać swoje, ponieważ miałem problem z nimi wszystkimi, ponieważ używałem skryptów do dynamicznego generowania VersionName i VersionCode, podłączając się dopreBuild zadania.

Jeśli używasz podobnego podejścia, oto kod, który będzie działał:

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

Wyjaśnienie: ponieważ nadpisuję kod wersji i nazwę w pierwszej akcji preBuild muszę dodać zmianę nazwy pliku na koniec tego zadania. Więc to, co zrobi gradle w tym przypadku, to:

Wstaw kod / nazwę wersji -> wykonaj akcje preBuild -> zamień nazwę na apk

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

W moim przypadku rozwiązuję ten błąd w ten sposób

dodanie SUFFIX do wersji debugowania, w tym przypadku dodam tekst "-DEBUG" do mojego wdrożenia debugowania

 buildTypes {
        release {

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


        }
        debug {

            defaultConfig {
                debuggable true

                versionNameSuffix "-DEBUG"
            }
        }
    }

W przypadku najnowszych wersji Gradle możesz użyć następującego fragmentu:

Najpierw ustaw lokalizację manifestu aplikacji

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

A później w 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"))
    }
}

Dostosuj, jeśli masz różne manifesty w zależności od typu kompilacji. ale skoro mam jedyny - u mnie działa idealnie.

Od wersji Android Studio 1.1.0 stwierdziłem, że ta kombinacja działa w treści pliku Androidabuild.gradle . Dzieje się tak, jeśli nie możesz dowiedzieć się, jak zaimportować dane pliku manifestu xml. Chciałbym, żeby był bardziej obsługiwany przez Android Studio, ale po prostu baw się wartościami, aż uzyskasz żądaną nazwę pliku APK:

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