"App-release.apk", wie man diesen standardmäßig generierten apk-Namen ändert

Immer wenn ich in Android Studio eine signierte apk generiere , gibt sie standardmäßig den Namen app-release.apk ...

Können wir irgendwelche Einstellungen vornehmen, damit es mich auffordert und mich nach dem Namen fragt, der der apk zugewiesen werden muss (wie es in Eclipse der Fall ist)?

Was ich tue ist - benenne die apk um, nachdem sie generiert wurde. Dies gibt keine Fehler, aber es gibt einen echten Weg, so dass ich Änderungen an den Einstellungen vornehmen kann, um eine Eingabeaufforderung zu erhalten.

Hinweis::

Während der Generierung von apk gibt mir android studio die Aufforderung, den Ort auszuwählen (nur)

Ja, wir können das ändern, aber mit etwas mehr Aufmerksamkeit

Fügen Sie dies nun in Ihr build.gradle in Ihrem Projekt ein, während Sie sicherstellen, dass Sie die Build-Variante Ihres Projekts wie folgt überprüft haben. release or Debug Hier habe ich meine Build-Variante als festgelegt, releaseaber Sie können auch Debug auswählen.

    buildTypes {
            release {
                minifyEnabled false
                proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
                signingConfig getSigningConfig()
                applicationVariants.all { variant ->
                    variant.outputs.each { output ->
                        def date = new Date();
                        def formattedDate = date.format('yyyyMMddHHmmss')
                        output.outputFile = new File(output.outputFile.parent,
                                output.outputFile.name.replace("-release", "-" + formattedDate)
    //for Debug use output.outputFile = new File(output.outputFile.parent,
   //                             output.outputFile.name.replace("-debug", "-" + formattedDate)
                        )
                    }
                }
            }
        }

Sie können es mit einem anderen Ansatz wie diesem tun

 defaultConfig {
        applicationId "com.myapp.status"
        minSdkVersion 16
        targetSdkVersion 23
        versionCode 1
        versionName "1.0"
        setProperty("archivesBaseName", "COMU-$versionName")
    }

Verwenden der Set-Eigenschaftsmethode in build.gradle und Vergessen Sie nicht, den Gradle zu synchronisieren, bevor Sie die Projekte ausführen. Hoffe, es wird Ihr Problem lösen :)

Ein neuer Ansatz, um dies zu handhaben, der kürzlich von Google Update hinzugefügt wurde. Sie können Ihren Build jetzt nach Geschmack oder Variantenausgabe umbenennen. // Die folgende Quelle stammt aus der Entwickler-Android-Dokumentation . Weitere Informationen finden Sie unter dem obigen Dokumentationslink. Die
Verwendung der Varianten-API zum Bearbeiten von Variantenausgaben ist fehlerhaft mit dem neuen Plugin. Es funktioniert weiterhin für einfache Aufgaben, z. B. das Ändern des APK-Namens während der Erstellungszeit, wie unten gezeigt:

// If you use each() to iterate through the variant objects,
// you need to start using all(). That's because each() iterates
// through only the objects that already exist during configuration time—
// but those object don't exist at configuration time with the new model.
// However, all() adapts to the new model by picking up object as they are
// added during execution.
android.applicationVariants.all { variant ->
    variant.outputs.all {
        outputFileName = "${variant.name}-${variant.versionName}.apk"
    }
}

Umbenennen des .aab-Bundles Dies wird von David Medenjak gut beantwortet

tasks.whenTaskAdded { task ->
    if (task.name.startsWith("bundle")) {
        def renameTaskName = "rename${task.name.capitalize()}Aab"
        def flavor = task.name.substring("bundle".length()).uncapitalize()
        tasks.create(renameTaskName, Copy) {
            def path = "${buildDir}/outputs/bundle/${flavor}/"
            from(path)
            include "app.aab"
            destinationDir file("${buildDir}/outputs/renamedBundle/")
            rename "app.aab", "${flavor}.aab"
        }

        task.finalizedBy(renameTaskName)
    }
//@credit to David Medenjak for this block of code
}

Wird der obige Code benötigt?

Was ich in der neuesten Version des Android Studio 3.3.1 beobachtet habe

Das Umbenennen des .aab-Bundles erfolgt durch den vorherigen Code. Es ist keine Aufgabe erforderlich, ein All umzubenennen.

Hoffe es wird euch helfen. :) :)

Möglicherweise wird der Fehler mit dem neuesten Android Gradle Plugin ( 3.0 ) angezeigt :

Der Wert der schreibgeschützten Eigenschaft 'outputFile' kann nicht festgelegt werden.

Laut dem Migrationsleitfaden sollten wir jetzt den folgenden Ansatz verwenden:

applicationVariants.all { variant ->
    variant.outputs.all {
        outputFileName = "${applicationName}_${variant.buildType.name}_${defaultConfig.versionName}.apk"
    }
}

Anmerkung 2 Hauptänderungen hier:

1. allwird jetzt verwendet, anstatt eachüber die Variantenausgaben zu iterieren.
2. outputFileName Eigenschaft wird verwendet, anstatt eine Dateireferenz zu mutieren.

Ich habe die Antwort von @Abhishek Chaubey geändert, um den gesamten Dateinamen zu ändern:

buildTypes {
    release {
        minifyEnabled false
        proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        applicationVariants.all { variant ->
            variant.outputs.each { output ->
                project.ext { appName = 'MyAppName' }
                def formattedDate = new Date().format('yyyyMMddHHmmss')
                def newName = output.outputFile.name
                newName = newName.replace("app-", "$project.ext.appName-") //"MyAppName" -> I set my app variables in the root project
                newName = newName.replace("-release", "-release" + formattedDate)
                //noinspection GroovyAssignabilityCheck
                output.outputFile = new File(output.outputFile.parent, newName)
            }
        }
    }
    debug {
    }
}

Dies erzeugt einen Dateinamen wie: MyAppName-release20150519121617.apk

(BEARBEITET für Android Studio 3.0 und Gradle 4)

Ich suchte nach einer komplexeren Option zum Umbenennen von Apk-Dateinamen und schrieb diese Lösung, die die Apk mit den folgenden Daten umbenennt:

• Geschmack
• Build-Typ
• Ausführung
• Datum

Sie würden eine solche apk erhalten: myProject_dev_debug_1.3.6_131016_1047.apk .

Die vollständige Antwort finden Sie hier . Ich hoffe es hilft!

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

Hier ist ein viel kürzerer Weg:

defaultConfig {
    ...
    applicationId "com.blahblah.example"
    versionCode 1
    versionName "1.0"
    setProperty("archivesBaseName", applicationId + "-v" + versionCode + "(" + versionName + ")")
    //or so
    archivesBaseName = "$applicationId-v$versionCode($versionName)"
}

Es gibt Ihnen den Namen com.blahblah.example-v1 (1.0) -debug.apk (im Debug-Modus)

Android Studio fügt versionNameSuffix standardmäßig nach Buildtyp hinzu. Wenn Sie dies überschreiben möchten, gehen Sie wie folgt vor:

buildTypes {
    debug {
        ...
        versionNameSuffix "-MyNiceDebugModeName"
    }
    release {
        ...
    }
}

Ausgabe im Debug-Modus: com.blahblah.example-v1 (1.0) -MyNiceDebugModeName.apk

Ich habe eine universellere Lösung basierend auf @Fer Antwort geschrieben.

Es sollte auch mit Geschmack und Buildtyp - basierter Konfiguration von Arbeit applicationId, versionName, versionCode.

In der build.gradle:

android {
    ...
    applicationVariants.all { variant ->
        variant.outputs.each { output ->
            def appId = variant.applicationId
            def versionName = variant.versionName
            def versionCode = variant.versionCode
            def flavorName = variant.flavorName // e. g. free
            def buildType = variant.buildType // e. g. debug
            def variantName = variant.name // e. g. freeDebug

            def apkName = appId + '_' + variantName + '_' + versionName + '_' + versionCode + '.apk';
            output.outputFile = new File(output.outputFile.parentFile, apkName)
        }
    }
}

Beispiel apk name: com.example.app_freeDebug_1.0_1.apk

Weitere Informationen zu variantVariablen finden Sie unter Definition der Schnittstellen ApkVariant und BaseVariant .

android.applicationVariants.allFügen Sie einen Block wie unten in Ihrem App-Level-Gradle hinzu

buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
            lintOptions {
                disable 'MissingTranslation'
            }
            signingConfig signingConfigs.release
            android.applicationVariants.all { variant ->
                variant.outputs.all {
                    outputFileName = "${applicationId}_${versionCode}_${variant.flavorName}_${variant.buildType.name}.apk"
                }
            }
        }
        debug {
            applicationIdSuffix '.debug'
            versionNameSuffix '_debug'
        }
    }

verfügbar am 25.03.2019

Nicht umbenennen, aber vielleicht würde es helfen, den Namen überhaupt richtig zu generieren? Ändern Sie den apk-Namen mit Gradle

Benennen Sie zuerst Ihr Modul von App in SurveyApp um

Zweitens fügen Sie dies Ihrem Projekt-Tople (Root-Projekt) hinzu. Es funktioniert mit Gradle 3.0

//rename apk for all sub projects
subprojects {
    afterEvaluate { project ->
        if (project.hasProperty("android")) {
            android.applicationVariants.all { variant ->
                variant.outputs.all {
                    outputFileName = "${project.name}-${variant.name}-${variant.versionName}.apk"
                }
            }
        }
    }
}

Fügen Sie den folgenden Code in build.gradle hinzu (Modul: App)

android {
    ......
    ......
    ......
    buildTypes {
        release {
            ......
            ......
            ......
            /*The is the code fot the template of release name*/
            applicationVariants.all { variant ->
                variant.outputs.each { output ->
                    def formattedDate = new Date().format('yyyy-MM-dd HH-mm')
                    def newName = "Your App Name " + formattedDate
                    output.outputFile = new File(output.outputFile.parent, newName)
                }
            }
        }
    }
}

Der Name des Release- Builds lautet Your App Name 2018-03-31 12-34

Meine Lösung kann auch jemandem helfen.

Getestet und funktioniert auf IntelliJ 2017.3.2 mit Gradle 4.4

Szenario:

Ich habe 2 Geschmacksrichtungen in meiner Anwendung und wollte daher, dass jede Version entsprechend jeder Geschmacksrichtung entsprechend benannt wird.

Der folgende Code wird in Ihre Modul-Gradle-Build-Datei eingefügt, die sich befindet in:

{app-root}/app/build.gradle

Gradle-Code, der zum android{ }Block hinzugefügt werden soll :

android {
    // ...

    defaultConfig {
        versionCode 10
        versionName "1.2.3_build5"
    }

    buildTypes {
        // ...

        release {
            // ...

            applicationVariants.all { 
                variant.outputs.each { output ->
                    output.outputFile = new File(output.outputFile.parent, output.outputFile.name.replace(output.outputFile.name, variant.flavorName + "-" + defaultConfig.versionName + "_v" + defaultConfig.versionCode + ".apk"))
                }
            }

        }
    }

    productFlavors {
        myspicyflavor {
            applicationIdSuffix ".MySpicyFlavor"
            signingConfig signingConfigs.debug
        }

        mystandardflavor {
            applicationIdSuffix ".MyStandardFlavor"
            signingConfig signingConfigs.config
        }
    }
}

Das Obige bietet die folgenden APKs in {app-root}/app/:

myspicyflavor-release-1.2.3_build5_v10.apk
mystandardflavor-release-1.2.3_build5_v10.apk

Hoffe, es kann jemandem von Nutzen sein.

Weitere Informationen finden Sie in den anderen in der Frage genannten Antworten

Ich denke, das wird hilfreich sein.

buildTypes {
    release {
        shrinkResources true
        minifyEnabled true
        proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        applicationVariants.all { variant ->
            variant.outputs.each { output ->
                project.ext { appName = 'MyAppName' }
                def formattedDate = new Date().format('yyyyMMddHHmmss')
                def newName = output.outputFile.name
                newName = newName.replace("app-", "$project.ext.appName-")
                newName = newName.replace("-release", "-release" + formattedDate)
                output.outputFile = new File(output.outputFile.parent, newName)
            }
        }
    }
}
productFlavors {
    flavor1 {
    }
    flavor2 {
        proguardFile 'flavor2-rules.pro'
    }
}