Solo tengo que cambiar el nombre de la versión en un solo lugar. El código también es simple.

Los siguientes ejemplos crearán archivos apk llamados named MyCompany-MyAppName-1.4.8-debug.apk or MyCompany-MyAppName-1.4.8-release.apk dependiendo de la variante de compilación seleccionada.

Consulta también: Cómo cambiar el nombre del archivo de asignación proguard en el proyecto gradle para Android

Solución para el complemento Gradle Reciente

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 solución anterior ha sido probada con las siguientes versiones de Android Gradle Plugin:

• 3.1.0 (marzo de 2018)
• 3.0.1 (noviembre de 2017)
• 3.0.0 (octubre de 2017)
• 2.3.2 (mayo de 2017)
• 2.3.1 (abril de 2017)
• 2.3.0 (febrero de 2017)
• 2.2.3 (diciembre de 2016)
• 2.2.2
• 2.2.0 (Septiembre de 2016)
• 2.1.3 (Agosto de 2016)
• 2.1.2
• 2.0.0 (abril de 2016)
• 1.5.0 (2015/11/12)
• 1.4.0-beta6 (2015/10/05)
• 1.3.1 (2015/08/11)

Actualizaré este post a medida que salgan nuevas versiones.

Solución Probada Solo en las versiones 1.1.3-1.3.0

La siguiente solución se ha probado con las siguientes versiones de Android Gradle Plugin:

• 1.3.0 (2015/07/30) - No funciona, error programado para ser corregido en 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 (2015/03/25)
• 1.1.3 (2015/03/06)

Archivo de aplicación gradle:

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

(EDITADO para trabajar con Android Studio 3.0 y Gradle 4)

Estaba buscando una opción de cambio de nombre de archivo apk más compleja y escribí esta con la esperanza de que sea útil para cualquier otra persona. Cambia el nombre del apk con los siguientes datos:

• sabor
• tipo de construcción
• versión
• fecha

Me llevó un poco de investigación en las clases de gradle y un poco de copiar/pegar de otras respuestas. Yo he utilizado gradle 3.1.3.

En la compilación.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)
        }
    }
}

Si compila hoy (13-10-2016) a las 10: 47, obtendrá los siguientes nombres de archivo dependiendo del tipo y tipo de compilación que haya elegido:

• 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.0_131016_1047.apk
• prod release : myProject_ prod_release_1.2.0_131016_1047.apk

Nota: el nombre apk de la versión no alineada sigue siendo el predeterminado.

Si no especificas versionName en el bloque defaultConfig entonces defaultConfig.versionName resultará en null

Para obtener el nombre de la versión del manifiesto, puede escribir el siguiente código en build.gradle:

import com.android.builder.DefaultManifestParser

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

Para resumir, para aquellos que no saben cómo importar paquetes en build.gradle (como yo), use lo siguiente 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 =====

Si pones tu versionCode y versionName en tu archivo build.gradle así:

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

Deberías ponerlo así: {[12]]}

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

====== EDITAR con Android Studio 1.0 ======

Si está utilizando Android Studio 1.0, obtendrá un error como este:

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

Debes cambiar la parte build.Types a esto:

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

En mi caso, solo quería encontrar una manera de automatizar la generación de diferentes apk nombre para release y debug variantes. Me las arreglé para hacer esto fácilmente poniendo este fragmento como un hijo de 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)
    }
}

Para el nuevo Android gradle plugin 3.0.0 se puede hacer algo así:

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

Esto produce algo como: My_nice_name_3.2.31_dbg.apk

Otra alternativa es usar lo siguiente:

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
}

Esto establecerá "appname-1.0.0" a todas sus salidas apk.

Gradle 4

La sintaxis ha cambiado un poco en Gradle 4 (Android Studio 3+) (de output.outputFile a outputFileName, idea de esta respuesta es ahora:

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

Hay muchas respuestas que son correctas, ya sea en su totalidad o después de algunas modificaciones. Pero voy a agregar el mío de todos modos ya que estaba teniendo el problema con todos ellos porque estaba usando scripts para generar versionName y versionCode dinámicamente conectándome a la tarea preBuild.

Si está utilizando algún enfoque similar, este es el código que funcionará:

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

Para explicar: Ya que estoy sobreescribiendo el código de la versión y el nombre en la primera acción de preBuild Tengo que agregar el archivo cambiar el nombre al final de esta tarea. Entonces, lo que gradle hará en este caso es:

Inyectar código de versión / nombre - > hacer acciones precompiladas - > reemplazar nombre para apk

La forma correcta de renombrar apk, según @Jon answer

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

U otra forma de lograr los mismos resultados con

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

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

En mi caso resuelvo este error de esta manera

Agregar un SUFIJO a la versión de depuración, en este caso agrego el texto "-DEBUG" a mi deploy de depuración

 buildTypes {
        release {

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


        }
        debug {

            defaultConfig {
                debuggable true

                versionNameSuffix "-DEBUG"
            }
        }
    }

Para las últimas versiones de gradle puedes usar el siguiente fragmento de código:

Establezca primero la ubicación del manifiesto de su aplicación

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

Y más adelante en 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"))
    }
}

Ajuste si tiene diferentes manifiestos por tipo de compilación. pero ya que tengo el único-funciona perfectamente para mí.

A partir de Android Studio 1.1.0, encontré que esta combinación funcionaba en el android cuerpo del archivo build.gradle. Esto es si no puede averiguar cómo importar los datos del archivo xml del manifiesto. Me gustaría que fuera más compatible con Android Studio, pero solo juegue con los valores hasta que obtenga la salida del nombre APK deseado:

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