renombrar - cambiar package android studio

Cómo cambiar el nombre del archivo de mapeo proguard en gradle para proyecto Android

Question

Tengo un proyecto de Android basado en gradle y quiero cambiar el nombre del archivo mapping.txt después de que se genere para mi compilación. ¿Cómo puede hacerse esto?

upd

¿Cómo se puede hacer en build.gradle? Como tengo acceso a mis sabores y otros tipos rígidos, me gustaría crear un nombre de archivo de mapeo basado en la versión variante de sabor / compilación.

Answer 1

Desde la última actualización variant.mappingFile ya no está disponible. (Uso ProGuard versión 4.7, AndroidStudio 2.0)

Este es (parte de) mi archivo build.gradle:

import java.util.regex.Matcher
import java.util.regex.Pattern

def getCurrentFlavor() {
    Gradle gradle = getGradle()
    String  tskReqStr = gradle.getStartParameter().getTaskRequests().toString()

    Pattern pattern;

    if( tskReqStr.contains( "assemble" ) )
        pattern = Pattern.compile("assemble(//w+)(Release|Debug)")
    else
        pattern = Pattern.compile("generate(//w+)(Release|Debug)")

    Matcher matcher = pattern.matcher( tskReqStr )

    if( matcher.find() )
        return matcher.group(1).toLowerCase()
    else
    {
        println "NO MATCH FOUND"
        return "";
    }
}

buildTypes {
    release {
        proguardFiles getDefaultProguardFile(''proguard-android.txt''), ''proguard-rules.txt''
        minifyEnabled true

        applicationVariants.all { variant ->
            variant.outputs.each { output ->
                output.outputFile = new File(output.outputFile.parent, "${variant.name}_v${variant.versionName}.apk")
            }
            def mappingFile = "${rootDir}//app//build//outputs//mapping//${getCurrentFlavor()}//release//mapping.txt"
            println("mappingFile:  ${mappingFile}")
            if (variant.getBuildType().isMinifyEnabled()) {
                variant.assemble.doLast {
                    copy {
                        from "${mappingFile}"
                        into "${rootDir}"
                        rename { String fileName ->
                            "mapping-${variant.name}.txt"
                        }
                    }
                }
            }
        }

    }

    debug {
        minifyEnabled false
        useProguard false

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

}

Answer 2

Esta es una variación de la respuesta de igorpst, pero cambia el nombre de mapping.txt para que coincida exactamente con el nombre del apk, incluido el nombre de la versión de la aplicación. Combiné esto con el código para nombrar el APK con un número de versión como se describe en esta respuesta . Tuve que espiar el código fuente de Gradle para encontrar $variant.baseName

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"
    }
    applicationVariants.all { variant ->
        if (variant.getBuildType().isMinifyEnabled()) {
            variant.assemble.doLast {
                (new File(variant.mappingFile.parent, "$archivesBaseName-$variant.baseName-mapping.txt")).delete();
                variant.mappingFile.renameTo(variant.mappingFile.parent +
                        "/$archivesBaseName-$variant.baseName-mapping.txt")
            }
        }
    }
}

Answer 3

La solución anterior de Pinhassi funciona muy bien y se ajusta a los últimos cambios de Gradle. Sin embargo, hay un par de cosas que tuve que cambiar:

1. El nombre del módulo está codificado ("aplicación"), lo que no es ideal ya que en muchos casos (incluido el mío) eso no será cierto. Es mejor detectar dinámicamente el nombre del módulo.
2. El archivo de mapeo también solo se ajusta al sistema de archivos de Windows al tener barras diagonales escapadas ("/"). Si está en un sistema * NIX como Linux o Mac, debe reemplazarlos con barras diagonales sin escape ("/")
3. Cambió un poco el cambio de nombre del archivo .apk para incluir el nombre del proyecto y agregó una marca de fecha / hora al final.

Aquí está el código terminado:

import java.util.regex.Matcher
import java.util.regex.Pattern

buildTypes {
        release {
        debuggable false
        minifyEnabled true
        proguardFiles ''proguard.cfg''

        // Rename the apk file and copy the ProGuard mapping file to the root of the project
        applicationVariants.all { variant ->
            if (variant.getBuildType().name.equals("release")) {
                def formattedDate = new Date().format(''yyyyMMddHHmmss'')
                def projectName = ""
                variant.outputs.each { output ->
                    def fullName = output.outputFile.name
                    projectName = fullName.substring(0, fullName.indexOf(''-''))
                    // ${variant.name} has the value of "paidRelease"
                    output.outputFile = new File((String) output.outputFile.parent, (String) output.outputFile.name.replace(".apk", "-v${variant.versionName}-${formattedDate}.apk"))
                }
                def mappingFile = "${rootDir}/${projectName}/build/outputs/mapping/${getCurrentFlavor()}/release/mapping.txt"
                println("mappingFile:  ${mappingFile}")
                if (variant.getBuildType().isMinifyEnabled()) {
                    variant.assemble.doLast {
                        copy {
                            from "${mappingFile}"
                            into "${rootDir}"
                            rename { String fileName ->
                                "mapping-${variant.name}.txt"
                            }
                        }
                    }
                }
            }
        }
    }

        debug {
            debuggable true
        }
    }

def getCurrentFlavor() {
    Gradle gradle = getGradle()
    String  tskReqStr = gradle.getStartParameter().getTaskRequests().toString()
    Pattern pattern;

    if( tskReqStr.contains( "assemble" ) )
        pattern = Pattern.compile("assemble(//w+)(Release|Debug)")
    else
        pattern = Pattern.compile("generate(//w+)(Release|Debug)")

    Matcher matcher = pattern.matcher( tskReqStr )

    if( matcher.find() )
        return matcher.group(1).toLowerCase()
    else {
        println "NO MATCH FOUND"
        return "";
    }
}

Answer 4

Muchas gracias a Sergii Pechenizkyi que me ayudó a encontrar esta buena solución.

Para implementar la copia de los archivos de mapeo de proguard para cada sabor podemos crear la tarea "raíz" copyProguardMappingTask y el número de tareas dinámicas para cada sabor

def copyProguardMappingTask = project.tasks.create("copyProguardMapping")
applicationVariants.all { variant ->
    variant.outputs.each { output ->
        ...
        if (variant.getBuildType().isMinifyEnabled()) {
            def copyProguardMappingVariantTask = project.tasks.create("copyProguardMapping${variant.name.capitalize()}", Copy)

            def fromPath = variant.mappingFile;
            def intoPath = output.outputFile.parent;

            copyProguardMappingVariantTask.from(fromPath)
            copyProguardMappingVariantTask.into(intoPath)
            copyProguardMappingVariantTask.rename(''mapping.txt'', "mapping-${variant.name}.txt")

            copyProguardMappingVariantTask.mustRunAfter variant.assemble
            copyProguardMappingTask.dependsOn copyProguardMappingVariantTask
        }
    }
}

luego debemos ejecutar esta tarea después de ensamblar nuestro proyecto. Yo uso jenkins y mi opción de tareas parece

gradle clean assembleProjectName copyProguardMapping

Funciona a las mil maravillas.

Answer 5

Solución más simple.

applicationVariants.all { variant ->
        if (variant.getBuildType().isMinifyEnabled()) {
            variant.assemble.doLast {
                copy {
                    from variant.mappingFile
                    into "${rootDir}/proguardTools"
                    rename { String fileName ->
                        "mapping-${variant.name}.txt"
                    }
                }
            }
        }
    }

Answer 6

Todas estas respuestas utilizan copia para cambiar el nombre del archivo. Sin embargo, no quería mover el archivo, solo quería cambiar su nombre, teniendo en cuenta el tipo de compilación y el sabor.

Me basé en el código de los otros carteles aquí y lo cambié un poco. Como Minify puede ser falso, mientras sigo usando proguard, solo verifico si el archivo está presente.

El siguiente código logra exactamente eso.

android {
    applicationVariants.all { variant ->
        variant.assemble.doLast {
            def mappingFolderUrl = "${project.buildDir.path}/outputs/mapping/"

            if (variant.buildType.name) {
                mappingFolderUrl += variant.buildType.name + "/"
            }

            if (variant.flavorName) {
                mappingFolderUrl += variant.flavorName + "/"
            }

            def mappingFileUrl = mappingFolderUrl + "mapping.txt"
            logger.lifecycle("mappingFile path: ${mappingFileUrl}")

            File mappingFile = file(mappingFileUrl)
            if (mappingFile.exists()) {
                def newFileName = mappingFolderUrl + "mapping-${variant.name}.txt"
                mappingFile.renameTo(newFileName)
            }
        }
    }
}

NOTA

Probablemente también podría usar este código para mover el archivo.

el método .renameTo () espera una ruta completa. Si cambia la ruta, supongo que efectivamente mueve el archivo a otro lugar.

Answer 7

Use este comando en su archivo proguard-rules.pro:

-printmapping path/to/your/file/file_name.txt

el archivo se escribirá en la parte {root}/path/to/your/file con file_name.txt nombre.

Si desea tener una configuración diferente para diferentes sabores, puede definir muchas reglas de protección para ellos

Encontré una idea más, pero no estoy seguro de que sea la forma correcta.

Puedes definir tu camino en sabores:

productFlavors {
    test1 {
        applicationId "com.android.application.test"
        project.ext."${name}Path" = ''path/one/mapp.txt''
    }
    test2 {
        project.ext."${name}Path" = ''path/two/mapp.txt''
    }
}

Y a continuación, puede definir una nueva tarea antes de la tarea $asseble{variant.name.capitalize()} como se muestra a continuación:

android.applicationVariants.all { variant ->
    def envFlavor = variant.productFlavors.get(0).name

    def modifyProguardPath = tasks.create(name: "modifyProguardFor${variant.name.capitalize()}", type: Exec) {
        def pathToMap = project."${envFlavor}Test1"
        doFirst {
            println "==== Edit start: $pathToMap ===="
        }
        doLast {
            println "==== Edit end: $pathToMap ===="
        }
        executable "${rootDir}/utils/test.bash"
        args pathToMap
    }

    project.tasks["assemble${variant.name.capitalize()}"].dependsOn(modifyProguardPath);
}

y en el script ${root}/utils/test.bash : puede modificar proguard-rules.pro .

Pero creo que existe una mejor solución.

Answer 8

variant.assemble ahora está en desuso, solución sugerida que incorpora modificaciones anteriores:

archivesBaseName = "MyCompany-MyAppName-$versionName"
...
applicationVariants.all { variant ->
    variant.assembleProvider.get().doLast {
        if (variant.mappingFile != null && variant.mappingFile.exists()) {
            def mappingFilename = "$archivesBaseName-$variant.baseName-mapping.txt"
        (new File(variant.mappingFile.parent, mappingFilename)).delete()
        variant.mappingFile.renameTo(variant.mappingFile.parent +
                "/" + mappingFilename)
        }
    }
}

Si usa el paquete de aplicaciones (aab) en lugar de apk, agregue esto después de la sección de Android:

afterEvaluate {
    bundleRelease.doLast {
        android.applicationVariants.all { variant ->
            if (variant.buildType.name == ''release'') {
                tasks.create(name: "renameMappingFile") {
                    if (variant.mappingFile != null && variant.mappingFile.exists()) {
                        variant.mappingFile.renameTo(variant.mappingFile.parent + "/$variant.baseName-$versionName-${new Date().format(''yyyy-MM-dd_HHmm'')}-mapping.txt")
                    }
                }
            }
        }
    }
}

Intercambie bundleRelease para assembleRelease para apks en el último ejemplo también.

Actualización: Sin embargo, eso último no funciona si intentas crear una depuración normal directamente en tu teléfono. Error:

No se pudo obtener la propiedad desconocida ''bundleRelease'' para el proyecto '': aplicación'' del tipo org.gradle.api.Project.

Answer 9

Nuevo para Android Studio Gradle Plugin Versión 3.3.0 (enero de 2019) Esto supera los problemas anteriores en los que Android 3.0 / Android Gradle Plugin 3.0 desaprobaba BuildType.isMinifyEnabled() y el complemento Gradle desaprobaba variant.getAssemble () .

applicationVariants.all { variant ->
    variant.assembleProvider.get().doLast {
        if (variant.mappingFile != null && variant.mappingFile.exists()) {
            def mappingFilename = "$archivesBaseName-$variant.baseName-mapping.txt"
            (new File(variant.mappingFile.parent, mappingFilename)).delete()
            variant.mappingFile.renameTo(variant.mappingFile.parent +
                    "/" + mappingFilename)
        }
    }
}

Answer 10

applicationVariants.all { variant ->
    variant.outputs.each { output ->
        if (variant.getBuildType().isMinifyEnabled()) {
            variant.assemble.doLast{
                copy {
                    from variant.mappingFile
                    into "${rootDir}/mapping"
                    rename { String fileName ->
                        "mapping-${variant.name}-${new Date().format(''yyyy_MM_dd'')}.txt"
                    }
                }
            }
        }
    }
}