"App-release.apk" comment changer ce nom apk généré par défaut

Chaque fois que je génère un apk signé dans Android Studio, il donne par défaut le nom app-release.apk ...

Pouvons-nous faire des paramètres pour qu'il devrait me demander le nom qui doit être attribué à l'apk (comme il le fait dans eclipse)

Ce que je fais, c'est - renommer l'apk après l'avoir généré. Cela ne donne aucune erreur, mais existe-t-il un moyen authentique de faire des modifications dans les paramètres pour obtenir une invite.

Remarque::

lors de la génération d'apk android studio me donne une invite pour sélectionner l'emplacement (uniquement)

Oui on peut changer ça mais avec un peu plus d'attention

Maintenant, ajoutez ceci dans votre build.gradle dans votre projet tout en vous assurant que vous avez vérifié la variante de construction de votre projet comme release or Debug si ici j'ai défini ma variante de construction comme releasemais vous pouvez également sélectionner comme débogage.

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

Vous pouvez le faire avec une approche différente comme celle-ci

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

En utilisant la méthode Set property dans build.gradle et n'oubliez pas de synchroniser le gradle avant d'exécuter les projets J'espère que cela résoudra votre problème :)

Une nouvelle approche pour gérer cela, ajoutée récemment par Google Update Vous pouvez maintenant renommer votre build en fonction de la saveur ou de la sortie de variante // La source ci-dessous provient de la documentation Android du développeur Pour plus de détails, suivez le lien de documentation ci-dessus L'
utilisation de l'API Variant pour manipuler les sorties de variante est cassée avec le nouveau plugin. Cela fonctionne toujours pour des tâches simples, telles que la modification du nom de l'APK pendant la construction, comme indiqué ci-dessous:

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

Renommer le bundle .aab Ceci est bien répondu par David Medenjak

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
}

Y a-t-il besoin du code ci-dessus

Ce que j'ai observé dans la dernière version du studio android 3.3.1

Le changement de nom du bundle .aab est effectué par le code précédent, il ne nécessite aucun renommage de tâche.

J'espère que cela vous aidera les gars. :)

Vous pourriez obtenir l'erreur avec le dernier plugin Android Gradle ( 3.0 ):

Impossible de définir la valeur de la propriété en lecture seule 'outputFile'

Selon le guide de migration , nous devrions utiliser l'approche suivante maintenant:

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

Notez 2 principaux changements ici:

1. allest utilisé maintenant au lieu de eachpour itérer sur les sorties de variante.
2. outputFileName La propriété est utilisée au lieu de muter une référence de fichier.

J'ai modifié la réponse @Abhishek Chaubey pour changer le nom complet du fichier:

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

Cela produit un nom de fichier comme: MyAppName-release20150519121617.apk

(MODIFIÉ pour fonctionner avec Android Studio 3.0 et Gradle 4)

Je cherchais une option de changement de nom de fichier apk plus complexe et j'ai écrit cette solution qui renomme l'apk avec les données suivantes:

• saveur
• type de construction
• version
• Date

Vous obtiendrez un apk comme celui-ci: myProject_dev_debug_1.3.6_131016_1047.apk .

Vous pouvez trouver la réponse complète ici . J'espère que ça aide!

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

Voici un moyen beaucoup plus court:

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

Il vous donne le nom com.blahblah.example-v1 (1.0) -debug.apk (en mode débogage)

Android Studio ajoute la versionNameSuffix par nom de type de build par défaut, si vous voulez remplacer ceci, faites ensuite:

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

Sortie en mode débogage: com.blahblah.example-v1 (1.0) -MyNiceDebugModeName.apk

J'ai écrit une solution plus universelle basée sur la réponse @Fer.

Il devrait également fonctionner avec une configuration à base de saveur et le type de construction de applicationId, versionName, versionCode.

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

Exemple de nom apk: com.example.app_freeDebug_1.0_1.apk

Pour plus d'informations sur les variantvariables, consultez la définition des interfaces ApkVariant et BaseVariant .

ajouter un android.applicationVariants.allbloc comme ci-dessous dans votre niveau d'application

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

disponible le 25/03/2019

Ne pas le renommer, mais peut-être que générer le nom correctement en premier lieu aiderait? Changer le nom de l'apk avec Gradle

Commencez par renommer votre module de l' application à ie SurveyApp

Ensuite, ajoutez ceci au niveau supérieur de votre projet (projet racine). Cela fonctionne avec 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"
                }
            }
        }
    }
}

Ajoutez le code suivant dans build.gradle (Module: 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)
                }
            }
        }
    }
}

Et le nom de la version de la version sera le nom de votre application 2018-03-31 12-34

Ma solution peut aussi être utile à quelqu'un.

Testé et fonctionne sur IntelliJ 2017.3.2 avec Gradle 4.4

Scénario:

J'ai 2 saveurs dans mon application, donc je voulais que chaque version soit nommée de manière appropriée en fonction de chaque saveur.

Le code ci-dessous sera placé dans le fichier de construction de votre module gradle trouvé dans:

{app-root}/app/build.gradle

Code Gradle à ajouter pour android{ }bloquer:

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

Ce qui précède fournit les fichiers APK suivants trouvés dans {app-root}/app/:

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

J'espère que cela peut être utile à quelqu'un.

Pour plus d'informations, consultez les autres réponses mentionnées dans la question

Je pense que ce sera utile.

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