Cómo configurar la generación de Perfiles de Baseline

El complemento de Gradle para perfiles de Baseline facilita la generación y el mantenimiento de los perfiles de Baseline. Te ayuda a realizar las siguientes tareas:

• Crear Perfiles de Baseline nuevos para tu app
• Crear Perfiles de Baseline nuevos para tu biblioteca
• Personalizar la generación de tu perfil de Baseline

En esta página, se explica cómo usar el complemento de Gradle para el perfil de Baseline con el objetivo de personalizar su generación.

Requisitos del complemento

• AGP 8.0 o versiones posteriores
• Dependencia de la versión más reciente del complemento de Gradle

Cómo usar dispositivos administrados por Gradle para generar perfiles de Baseline

Si quieres usar un dispositivo administrado por Gradle (GMD) para generar tu perfil de Baseline, agrega uno en la configuración build.gradle.kts del módulo del productor de perfiles (probablemente el módulo de prueba :baselineprofile) como se muestra en el siguiente ejemplo:

android {
   testOptions.managedDevices.devices {
       create<com.android.build.api.dsl.ManagedVirtualDevice>("pixel6Api31") {
           device = "Pixel 6"
           apiLevel = 31
           systemImageSource = "aosp"
       }
   }
}

android {
   testOptions.managedDevices.devices {
       pixel6Api31(ManagedVirtualDevice) {
           device 'Pixel 6'
           apiLevel = 31
           systemImageSource 'aosp'
       }
   }
}

Usa el GMD para generar perfiles de Baseline agregándolo al perfil de Baseline. de la configuración del complemento de Gradle de la siguiente manera, en el archivo build.gradle.kts de la Módulo de prueba de :baselineprofile:

baselineProfile {
    managedDevices += "pixel6Api31"
}

baselineProfile {
    managedDevices = ['pixel6Api31']
}

Cuando uses un GMD para generar perfiles de Baseline, establece useConnectedDevices en false, en tu módulo de prueba :baselineprofile:

baselineProfile {
    ...
    useConnectedDevices = false
}

baselineProfile {
    ...
    useConnectedDevices false
}

Cómo generar perfiles de Baseline para diferentes variantes

Puedes generar perfiles de Baseline por variante, por tipo o como un solo archivo para usarlos en todas las variantes. Controlar este comportamiento a través de la configuración de fusión, como se muestra en el siguiente ejemplo, en el elemento build.gradle.kts de la o módulo de biblioteca.

baselineProfile {
    mergeIntoMain = true
}

baselineProfile {
    mergeIntoMain true
}

Para combinar los perfiles generados para todas las variantes en un solo perfil, establece mergeIntoMain en true. No es posible generar Perfiles de Baseline por variante cuando este parámetro de configuración es true, por lo que hay una sola tarea de Gradle llamada generateBaselineProfile. El perfil se entrega en src/main/generated/baselineProfiles.

Para inhabilitar la combinación y tener un perfil por variante, establece mergeIntoMain en false. En este caso, existen múltiples tareas de Gradle específicas de variantes. Por ejemplo, cuando existen dos tipos (como sin cargo y pagada) y un tipo de compilación de lanzamiento, las tareas son las siguientes:

* `generateFreeReleaseBaselineProfile`
* `generatePaidReleaseBaselineProfile`
* `generateReleaseBaselineProfile`

Para especificar el comportamiento de combinación por variante, usa el siguiente código:

baselineProfile {
    variants {
        freeRelease {
            mergeIntoMain = true
        }
    }
}

baselineProfile {
    variants {
        freeRelease {
            mergeIntoMain true
        }
    }
}

En el ejemplo anterior, las variantes en las que la marca se establece como true se combinan en src/main/generated/baselineProfiles, mientras que los perfiles de las variantes en las que la marca se establece como false se mantienen en la carpeta src/<variant>/generated/baselineProfiles.

De forma predeterminada, mergeIntoMain se configura como true para bibliotecas y false para apps.

Cómo generar perfiles de Baseline automáticamente cuando se compila una versión nueva

Puedes configurar los perfiles de Baseline para que se generen automáticamente con cada compilación de lanzamiento, en lugar de usar la tarea generateBaselineProfile de forma manual. Con la generación automática, el perfil más actualizado se incluye en la compilación de lanzamiento.

Para habilitar la generación automática de compilaciones de lanzamiento, usa la marca automaticGenerationDuringBuild:

baselineProfile {
    automaticGenerationDuringBuild = true
}

baselineProfile {
    automaticGenerationDuringBuild true
}

Si estableces la marca automaticGenerationDuringBuild en true, se activa la generación de un perfil de Baseline nuevo para cada versión de lanzamiento. Esto significa que ejecutar una tarea de compilación de lanzamiento, como ./gradlew:app:assembleRelease, también activa :app:generateReleaseBaselineProfile, inicia las pruebas de instrumentación del perfil de Baseline y realiza la compilación del perfil de Baseline en la que se ejecutan. Si bien la generación automática ayuda a los usuarios a obtener el mejor beneficio de rendimiento, también aumenta el tiempo de compilación debido a las pruebas de instrumentación y de compilación dobles.

También puedes especificar este comportamiento por variante, como se muestra en el siguiente ejemplo:

baselineProfile {
    variants {
        freeRelease {
            automaticGenerationDuringBuild = true
        }
    }
}

baselineProfile {
    variants {
        freeRelease {
            automaticGenerationDuringBuild true
        }
    }
}

En el ejemplo anterior, la tarea generateFreeReleaseBaselineProfile se ejecuta cuando se inicia assembleFreeRelease. Esto ayuda cuando el usuario desea tener, por ejemplo, un release para la compilación de distribución que siempre genere el perfil cuando se compile y una compilación releaseWithoutProfile para las pruebas internas.

Cómo almacenar perfiles de Baseline en fuentes

Puedes almacenar perfiles de Baseline en el directorio del código fuente a través de saveInSrc. marca en el build.gradle.kts de la aplicación o del módulo de biblioteca:

• true: El perfil de Baseline se almacena en src/<variant>/generated/baselineProfiles. Esto te permite confirmar el último perfil generado con tus fuentes.
• false: El perfil de Baseline se almacena en los archivos intermedios del directorio de compilación. De esta manera, cuando confirmas tu código, no guardas el último perfil generado.

baselineProfile {
    saveInSrc = true
}

baselineProfile {
    saveInSrc true
}

También puedes especificar este comportamiento por variante:

baselineProfile {
    variants {
        freeRelease {
            saveInSrc = true
        }
    }
}

baselineProfile {
    variants {
        freeRelease {
            saveInSrc true
        }
    }
}

Cómo filtrar las reglas del perfil

El complemento de Gradle para el perfil de Baseline te permite filtrar las reglas del perfil de Baseline que se generan. Esto es útil para las bibliotecas si quieres excluir las reglas del perfil para clases y métodos que forman parte de otras dependencias de la misma app de ejemplo o de la misma biblioteca. Los filtros pueden incluir y excluir paquetes y clases específicos. Cuando solo especificas exclusiones, solo se excluyen las reglas del perfil de Baseline que coincidan, y se incluye todo lo demás.

Se pueden especificar filtros de cualquiera de las siguientes maneras:

• El nombre del paquete que termina con comodines dobles debe coincidir con el paquete especificado y todos los subpaquetes. Por ejemplo, com.example.** coincide con com.example.method y com.example.method.bar.
• El nombre del paquete que termina con un comodín debe coincidir solo con el paquete especificado. Por ejemplo, com.example.* coincide con com.example.method, pero no con com.example.method.bar.
• Los nombres de clases deben coincidir con una clase específica, por ejemplo, com.example.MyClass.

En los siguientes ejemplos, se muestra cómo incluir y excluir paquetes específicos:

baselineProfile {
    filter {
        include("com.somelibrary.widget.grid.**")
        exclude("com.somelibrary.widget.grid.debug.**")
        include("com.somelibrary.widget.list.**")
        exclude("com.somelibrary.widget.list.debug.**")
        include("com.somelibrary.widget.text.**")
        exclude("com.somelibrary.widget.text.debug.**")
    }
}

baselineProfile {
    filter {
        include 'com.somelibrary.widget.grid.**'
        exclude 'com.somelibrary.widget.grid.debug.**'
        include 'com.somelibrary.widget.list.**'
        exclude 'com.somelibrary.widget.list.debug.**'
        include 'com.somelibrary.widget.text.**'
        exclude 'com.somelibrary.widget.text.debug.**'
    }
}

Personaliza las reglas de filtrado para diferentes variantes de la siguiente manera:

// Non-specific filters applied to all the variants.
baselineProfile {
    filter { include("com.myapp.**") }
}

// Flavor-specific filters.
baselineProfile {
    variants {
        free {
            filter {
                include("com.myapp.free.**")
            }
        }
        paid {
            filter {
                include("com.myapp.paid.**")
            }
        }
    }
}

// Build-type-specific filters.
baselineProfile {
    variants {
        release {
            filter {
                include("com.myapp.**")
            }
        }
    }
}

// Variant-specific filters.
baselineProfile {
    variants {
        freeRelease {
            filter {
                include("com.myapp.**")
            }
        }
    }
}

// Non-specific filters applied to all the variants.
baselineProfile {
    filter { include 'com.myapp.**' }
}

// Flavor-specific filters.
baselineProfile {
    variants {
        free {
            filter {
                include 'com.myapp.free.**'
            }
        }
        paid {
            filter {
                include 'com.myapp.paid.**'
            }
        }
    }
}

// Build-type specific filters.
baselineProfile {
    variants {
        release {
            filter {
                include 'com.myapp.**'
            }
        }
    }
}

// Variant-specific filters.
baselineProfile {
    variants {
        freeRelease {
            filter {
                include 'com.myapp.**'
            }
        }
    }
}

También puedes filtrar las reglas con el argumento filterPredicate en BaselineProfileRule.collect(), pero te recomendamos que uses el complemento de Gradle para filtrar porque proporciona una forma más sencilla de filtrar subpaquetes y un solo lugar para configurar todo el módulo.

Cómo personalizar los tipos de compilación de perfiles de Baseline y de comparativas

El complemento de Gradle para perfiles de Baseline crea tipos de compilación adicionales para generar los perfiles y ejecutar comparativas. Estos tipos de compilación tienen el prefijo benchmark y nonMinified. Por ejemplo, para el tipo de compilación release, el plugin crea los tipos de compilación benchmarkRelease y nonMinifiedRelease. Estos tipos de compilación se configuran automáticamente para el caso de uso específico y, por lo general, no necesitan ninguna personalización. Pero hay casos en los que podría ser útil aplicar algunas opciones personalizadas, como aplicar un configuración de firma diferente.

Puedes personalizar los tipos de compilación generados automáticamente con un subconjunto de propiedades de tipo de compilación. Las propiedades que no se pueden usar se anulan. En el siguiente ejemplo, se muestra cómo personalizar los tipos de compilación adicionales y qué propiedades se anulan:

android {
    buildTypes {
        release {
            ...
        }
        create("benchmarkRelease") {
            // Customize properties for the `benchmarkRelease` build type here.
            // For example, you can change the signing config (by default
            // it's the same as for the `release` build type).
            signingConfig = signingConfigs.getByName("benchmarkRelease")
        }
        create("nonMinifiedRelease") {
            // Customize properties for the `nonMinifiedRelease` build type here.
            signingConfig = signingConfigs.getByName("nonMinifiedRelease")

            // From Baseline Profile Gradle plugin 1.2.4 and higher, you can't
            // customize the following properties, which are always overridden to
            // avoid breaking Baseline Profile generation:
            //
            // isJniDebuggable = false
            // isDebuggable = false
            // isMinifyEnabled = false
            // isShrinkResources = false
            // isProfileable = true
            // enableAndroidTestCoverage = false
            // enableUnitTestCoverage = false
        }
    }
}

android {
    buildTypes {
        release {
            ...
        }
        benchmarkRelease {
            // Customize properties for the `benchmarkRelease` build type here.
            // For example, you can change the signing config (by default it's the
            // same as for the `release` build type.)
            signingConfig = signingConfigs.benchmarkRelease
        }
        nonMinifiedRelease {
            // Customize properties for the `nonMinifiedRelease` build type here.
            signingConfig = signingConfigs.nonMinifiedRelease

            // From Baseline Profile Gradle plugin 1.2.4 and higher, you can't use
            // the following properties, which are always overridden to avoid breaking
            // Baseline Profile generation:
            //
            // isJniDebuggable = false
            // isDebuggable = false
            // isMinifyEnabled = false
            // isShrinkResources = false
            // isProfileable = true
            // enableAndroidTestCoverage = false
            // enableUnitTestCoverage = false       
        }
    }
}

Notas adicionales

Cuando crees perfiles de Baseline, ten en cuenta lo siguiente:

• Los perfiles de Baseline compilados deben tener un tamaño inferior a 1.5 MB (esto no se aplica al formato de texto de tus archivos de origen, que suele ser mucho más grande antes de la compilación). Verifica el tamaño de tu Perfil de Baseline binario ubicándolo en el artefacto de salida en assets/dexopt/baseline.prof para APK o BUNDLE-METADATA/com.android.tools.build.profiles/baseline.prof para AAB.

• Las reglas amplias que compilan demasiadas aplicaciones pueden ralentizar el inicio debido al aumento del acceso al disco. Si recién comienzas a usar los perfiles de Baseline, no te preocupes por eso. Sin embargo, según tu app, el tamaño y la cantidad de recorridos, agregar muchos recorridos puede generar un rendimiento deficiente. Para comprobar el rendimiento de la app, prueba diferentes perfiles y verifica que el rendimiento no disminuya con las incorporaciones.

Codelabs