Cómo crear perfiles de Baseline

Como desarrollador de apps, puedes generar perfiles automáticamente para cada versión de la app con la biblioteca de Jetpack Macrobenchmark y BaselineProfileRule. Se recomienda usar com.android.tools.build:gradle:8.0.0, que incluye mejoras de compilación con el uso de perfiles de Baseline, o una versión posterior.

Cómo definir el generador de perfiles de Baseline

Sigue estos pasos para crear perfiles de Baseline con la biblioteca de Macrobenchmark:

  1. Configura un módulo de Macrobenchmark en tu proyecto de Gradle.

  2. Define una prueba nueva llamada BaselineProfileGenerator:

    class BaselineProfileGenerator {
        @get:Rule
        val baselineProfileRule = BaselineProfileRule()
    
        @Test
        fun startup() = baselineProfileRule.collectBaselineProfile(
            packageName = "com.example.app",
            profileBlock = {
                startActivityAndWait()
            }
        )
    }
    

    El generador puede contener interacciones con tu app más allá del inicio de la app. Esto te permite optimizar el rendimiento del tiempo de ejecución de tu app, por ejemplo, desplazarse por listas, ejecutar animaciones y navegar dentro de Activity. Consulta otros ejemplos de pruebas que usan @BaselineProfileRule para mejorar los recorridos críticos del usuario.

  3. (Opcional) Cuando generes perfiles de Baseline, inhabilita la ofuscación. Puedes hacerlo creando otro archivo ProGuard en el módulo de tu app y agregando -dontobfuscate solo para tu tipo de compilación benchmark responsable de generar los perfiles.

Kotlin

buildTypes {
    val benchmark by creating {
        // Only use benchmark Proguard rules.
        proguardFiles("benchmark-rules.pro")
        // ...
    }
}

Groovy

buildTypes {
    benchmark {
        // Only use benchmark Proguard rules.
        proguardFiles 'benchmark-rules.pro'
        // ...
    }
}

Genera el Perfil de Baseline

Ejecuta el generador como una prueba de instrumentación en un dispositivo físico con derechos de administrador, un emulador o un dispositivo administrado por Gradle. Para configurar un dispositivo administrado, abre tu archivo build.gradle.kts. En el bloque de configuración testOptions, agrega managedDevices y devices. Luego, crea una definición del emulador. Usa aosp como systemImageSource, ya que necesitas acceso raíz al generador de perfiles de Baseline.

Kotlin

testOptions {
    managedDevices {
        devices {
            create ("pixel6Api31", ManagedVirtualDevice::class) {
                device = "Pixel 6"
                apiLevel = 31
                systemImageSource = "aosp"
            }
        }
    }
}

Groovy

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

Gradle crea las tareas requeridas según el nombre del dispositivo seleccionado y las variantes de compilación disponibles en el módulo. Su formato es [emulator_name][flavor][build type]AndroidTest. Puedes ejecutar esta tarea desde una terminal:

./gradlew :benchmark:pixel6Api31BenchmarkAndroidTest

Captura todas las instrucciones de código obligatorias

Las dos métricas clave para medir los tiempos de inicio de la app son el tiempo para la visualización inicial (TTID) y el tiempo para la visualización completa (TTFD). TTID es el tiempo que lleva mostrar el primer fotograma de la IU de la aplicación. TTFD también incluye el tiempo para mostrar contenido que se carga, de forma asíncrona, después de que se muestra el fotograma inicial.

El TTFD se informa una vez que se llama al método reportFullyDrawn() de ComponentActivity. Si nunca se llama a reportFullyDrawn(), se informa el TTID en su lugar. Es posible que debas retrasar el momento en que se llama a reportFullyDrawn() hasta que se complete la carga asíncrona. Por ejemplo, si la IU contiene una lista dinámica, como RecyclerView, o una lista diferida, esto podría propagarse con un tarea en segundo plano que se completa después de que se dibuja la lista por primera vez y, por lo tanto, después de que la IU se marca como dibujada por completo. En esos casos, el código que se ejecuta después de que la IU alcanza el estado dibujado por completo no se incluye en el perfil de Baseline.

Para incluir la propagación de la lista como parte de tu perfil de Baseline, obtén FullyDrawnReporter con getFullyDrawnReporter() y agrégale un generador de informes en el código de la app. Lanza el generador de informes una vez que la tarea en segundo plano termine de propagar la lista. FullyDrawnReporter no llama al método reportFullyDrawn() hasta que se lanzan todos los generadores de informes. De esta manera, el perfil de Baseline incluye las instrucciones de código necesarias para propagar la lista. Esto no cambia el comportamiento de la app para el usuario, pero permite que el perfil de Baseline incluya todos las instrucciones de código necesarias.

Si tu app usa Jetpack Compose, usa las siguientes APIs para indicar el estado dibujado por completo:

  • ReportDrawn: Indica que el elemento componible está listo de inmediato para interactuar.
  • ReportDrawnWhen: Toma un predicado, como list.count > 0, para indicar cuándo el elemento componible está listo para interactuar.
  • ReportDrawnAfter: Toma un método de suspensión que, cuando se completa, indica que el elemento componible está listo para la interacción.

Complemento de Gradle para el Perfil de Baseline

El complemento de Gradle para el Perfil de Baseline facilita la generación y el mantenimiento de los Perfiles de Baseline. Realiza los pasos necesarios para generar un perfil de Baseline y, luego, instalarlo en el módulo de tu aplicación.

Para usar el complemento, agrega un módulo de prueba instrumentado a tu proyecto y define un conjunto de pruebas que naveguen por tu app para simular los recorridos críticos del usuario. Cuando ejecutas la prueba instrumentada, el complemento de Gradle para el perfil de Baseline realiza un seguimiento de todas las clases y todos los métodos que se ejecutan durante estos recorridos del usuario y genera un perfil de Baseline en función en estas clases y estos métodos. Luego, copia el perfil de Baseline generado en el módulo de la aplicación.

El módulo de prueba instrumentada es el generador de perfiles. El módulo de la app es el consumidor de perfiles.

Las principales áreas en las que debes enfocarte son la configuración inicial y la creación de pruebas para simular los recorridos críticos del usuario.

Requisitos para usar el plugin

Usa el complemento

En el siguiente ejemplo, se asume la existencia de un módulo de aplicación llamado :app.

Hay 2 módulos en el siguiente ejemplo:

  • Consumidor de perfiles: Es el módulo de la aplicación para el que se genera el perfil. En el siguiente ejemplo, es :app.
  • Generador de perfiles: Es el módulo de prueba del perfil de Baseline que contiene las pruebas de instrumentación para generar el perfil. En el siguiente ejemplo, se llama :baseline-profile.

Para usar el complemento, sigue estos pasos:

  1. Crea un módulo com.android.test nuevo, por ejemplo, :baseline-profile.
  2. Configura build.gradle para :baseline-profile:
    1. Aplica el complemento androidx.baselineprofile.
    2. Asegúrate de que targetProjectPath apunte al módulo :app.
    3. De manera opcional, agrega un GMD. En el siguiente ejemplo, es pixel6Api31. Si no se especifica, el complemento usa un dispositivo conectado, ya sea emulado o físico.
    4. Aplica la configuración que desees, como se muestra en el siguiente ejemplo.

    Kotlin

    plugins {
        id("com.android.test")
        id("androidx.baselineprofile")
    }
    
    android {
    
        // There are no changes here. It's documented for completeness.
        defaultConfig {
            ...
        }
    
        // This must point to the app module.
        targetProjectPath = ":app"
    
        // This is the optional managed device.
        testOptions.managedDevices.devices {
            pixel6Api31(com.android.build.api.dsl.ManagedVirtualDevice) {
                device = "Pixel 6"
                apiLevel = 31
                systemImageSource = "aosp"
            }
        }
    }
    
    // There are no changes here. It's documented for completeness.
    dependencies { ... }
    
    // This is the plugin configuration. Everything is optional. Defaults are in the
    // comments. In this example, you use the GMD added earlier and disable
    // connected devices.
    baselineProfile {
    
        // This specifies the managed devices to use that you run the tests on. The
        // default is none.
        managedDevices += "pixel6Api31"
    
        // This enables using connected devices to generate profiles. The default is
        // true. When using connected devices, they must be rooted or API 33 and
        // higher.
        useConnectedDevices = false
    }
    

    Groovy

    plugins {
        id 'com.android.test'
        id 'androidx.baselineprofile'
    }
    
    android {
    
        // There are no changes here. It's documented for completeness.
        defaultConfig {
            ...
        }
    
        // This must point to the app module.
        targetProjectPath ':app'
    
        // This is the optional managed device.
        testOptions.managedDevices.devices {
            pixel6Api31(com.android.build.api.dsl.ManagedVirtualDevice) {
                device 'Pixel 6'
                apiLevel 31
                systemImageSource 'aosp'
            }
        }
    }
    
        // There are no changes here. It's documented for completeness.
    dependencies { ... }
    
    // This is the plugin configuration. Everything is optional. Defaults are in the
    // comments. In this example, you use the GMD added earlier and disable
    // connected devices.
    baselineProfile {
    
        // This specifies the managed devices to use that you run the tests on. The
        // default is none.
        managedDevices ['pixel6Api31']
    
        // This enables using connected devices to generate profiles. The default is
        // true. When using connected devices, they must be rooted or API 33 and
        // higher.
        useConnectedDevices false
    }
    
  3. Crea una prueba de perfil de Baseline en el módulo de prueba de :baseline-profile. El siguiente ejemplo es una prueba que inicia la app y espera el estado inactivo.
  4. Kotlin

    class BaselineProfileGenerator {
    
        @get:Rule
        val baselineRule = BaselineProfileRule()
    
        @Test
        fun startupBaselineProfile() {
            baselineRule.collectBaselineProfile("com.myapp") {
                startActivityAndWait()
            }
        }
    }
    

    Java

    public class BaselineProfileGenerator {
    
        @Rule
        Public BaselineProfileRule baselineRule = new BaselineProfileRule();
    
        @Test
        Public void startupBaselineProfile() {
            baselineRule.collectBaselineProfile(
                "com.myapp",
                (scope -> {
                    scope.startActivityAndWait();
                    Return Unit.INSTANCE;
                })
            }
        }
    }
    
  5. Actualiza la configuración en build.gradle, en el módulo de la app :app.
    1. Aplica el complemento androidx.baselineprofile.
    2. Agrega una dependencia baselineProfile al módulo :baseline-profile.

    Kotlin

    plugins {
        id("com.android.application")
        id("androidx.baselineprofile")
    }
    
    android {
        // There are no changes to the `android` block.
        ...
    }
    
    dependencies {
        ...
        // Add a baselineProfile dependency to the :baseline-profile module.
        baselineProfile(project(":baseline-profile"))
    }
    

    Groovy

    plugins {
        id 'com.android.application'
        id 'androidx.baselineprofile'
    }
    
    android {
        // No changes to the `android` block.
        ...
    }
    
    dependencies {
        ...
        // Add a baselineProfile dependency to the :baseline-profile module.
        baselineProfile ':baseline-profile"'
    }
    
  6. Ejecuta el siguiente código para generar el perfil: ./gradlew :app:generateBaselineProfile.

Al final de la tarea de generación, el perfil de Baseline se almacena en app/src/release/generated/baselineProfiles.

Genera un perfil de Baseline para una biblioteca

En el siguiente ejemplo, el módulo de la biblioteca se llama :library, y el módulo de la aplicación se llama :sample-app, que contiene una app que usa la biblioteca.

En este ejemplo, necesitas tres módulos:

  • Objetivo de la app: Un módulo de la aplicación que contiene una app de ejemplo. En el siguiente ejemplo, es :sample-app.
  • Consumidor de perfiles: Es el módulo de la biblioteca para el que se genera el perfil. En el siguiente ejemplo, es :library.
  • Generador de perfiles: Es el módulo de prueba del perfil de Baseline que contiene las pruebas de instrumentación para generar el módulo.

Para generar un perfil de Baseline para una biblioteca, sigue estos pasos:

  1. Crea un módulo com.android.test nuevo, por ejemplo, :baseline-profile.
  2. Configura build.gradle para :baseline-profile:
    1. Aplica el complemento androidx.baselineprofile.
    2. Asegúrate de que targetProjectPath apunte al módulo :sample-app.
    3. De manera opcional, agrega un GMD. En el siguiente ejemplo, es pixel6Api31.
    4. Aplica la configuración que desees, como se muestra en el siguiente ejemplo.

    Kotlin

    plugins {
        id("com.android.test")
        id("androidx.baselineprofile")
    }
    
    android {
    
        // There are no changes here. It's reported for completeness.
        defaultConfig {
            minSdkVersion 23
            testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
        }
    
        // This must point to the app module.
        targetProjectPath = ":app"
    
        // This is the optional managed device.
        testOptions.managedDevices.devices {
            create("pixel6Api31") {
                device = "Pixel 6"
                apiLevel = 31
                systemImageSource = "aosp"
            }
        }
    }
    
    // There's nothing to change here.
    dependencies { ... }
    
    // This is the plugin configuration. Everything is optional. Defaults are in the
    // comments. In this example, you use the GMD added earlier and disable
    // connected devices.
    baselineProfile {
    
        // This specifies the managed devices to use that you run the tests on. The
        // default is none.
        managedDevices += "pixel6Api31"
    
        // This enables using connected devices to generate profiles. The default is
        // true. When using connected devices, they must be rooted or API 33 and
        // higher.
        useConnectedDevices = false
    }
    

    Groovy

    plugins {
        id 'com.android.test'
        id 'androidx.baselineprofile'
    }
    
    android {
    
        // There are no changes here. It's reported for completeness.
        defaultConfig {
            ...
        }
    
        // This must point to the app module.
        targetProjectPath ':app'
    
        // This is the optional managed device.
        testOptions.managedDevices.devices {
            pixel6Api31(com.android.build.api.dsl.ManagedVirtualDevice) {
                device 'Pixel 6'
                apiLevel 31
                systemImageSource 'aosp'
            }
        }
    }
    
    // There's nothing to change here.
    dependencies { ... }
    
    // This is the plugin configuration. Everything is optional. Defaults are in the
    // comments. In this example, you use the GMD added earlier and disable
    // connected devices.
    baselineProfile {
    
        // This specifies the managed devices to use that you run the tests on. The
        // default is none.
        managedDevices ['pixel6Api31']
    
        // This enables using connected devices to generate profiles. The default is
        // true. When using connected devices, they must be rooted or API 33 and
        // higher.
        useConnectedDevices false
    }
    
  3. Crea una prueba de perfil de Baseline en el módulo de prueba de :baseline-profile. Debe ser específico de la app de ejemplo y debe usar todas las funciones de la biblioteca.
  4. Actualiza la configuración en build.gradle en el módulo de la biblioteca :library.
    1. Aplica el complemento androidx.baselineprofile.
    2. Agrega una dependencia baselineProfile al módulo :baseline-profile.
    3. Aplica la configuración del plugin de consumidor que desees, como se muestra en el siguiente ejemplo.

    Kotlin

    plugins {
        id("com.android.library")
        id("androidx.baselineprofile")
    }
    
    // There are no changes to the android block.
    android { ... }
    
    dependencies {
        ...
        // Add a baselineProfile dependency to the :baseline-profile module.
        baselineProfile(project(":baseline-profile"))
    }
    
    // This is the plugin configuration.
    baselineProfile {
    
        // This filters the generated profile rules. In this example, you keep
        // all the classes in com.library and in all the subpackages.
        filter {
            include "com.mylibrary.**"
        }
    }
    

    Groovy

    plugins {
        id 'com.android.library'
        id 'androidx.baselineprofile'
    }
    
    // There are no changes to the android block.
    android { ... }
    
    dependencies {
        ...
        // Add a baselineProfile dependency to the :baseline-profile module.
        baselineProfile ':baseline-profile'
    }
    
    // This is the plugin configuration.
    baselineProfile {
    
        // This filters the generated profile rules. In this example, you keep
        // all the classes in com.library and in all the subpackages.
        filter {
            include 'com.mylibrary.**'
        }
    }
    
  5. Actualiza la configuración en build.gradle en el módulo de la app :sample-app y agrega el complemento androidx.baselineprofile.
  6. Kotlin

    plugins {
        ...
        id("androidx.baselineprofile")
    }
    // There are no other changes to the configuration.
    

    Groovy

    plugins {
        ...
        id 'androidx.baselineprofile'
    }
    // There are no other changes to the configuration.
    
  7. Ejecuta el siguiente código para generar el perfil: ./gradlew :library:generateBaselineProfile.

Al final de la tarea de generación, el perfil de Baseline se almacena en library/src/main/generated/baselineProfiles.

DSL

Si bien, en esta documentación, se hace referencia al complemento de Gradle para el perfil de Baseline como un solo plugin, en realidad, existen tres complementos que realizan tareas diferentes, según el módulo al que se apliquen. El ID del complemento en esta documentación es androidx.baselineprofile y es un acceso directo para los tres complementos.

Para comprender mejor este concepto, consulta los siguientes módulos que necesitas para generar un perfil de Baseline:

  • Aplicación para ejecutar las pruebas del Perfil de Baseline. Este es un módulo de la aplicación para Android en el que se aplicó com.android.application. Cuando se genera un perfil para una biblioteca, puede ser una app de ejemplo. Cuando se genera un perfil para una aplicación, es la misma aplicación. En el siguiente ejemplo, el complemento androidx.baselineprofile aplica androidx.baselineprofile.apptarget de forma interna.
  • Un módulo de prueba del perfil de Baseline que contiene las pruebas que se ejecutarán. Este es un módulo de prueba de Android en el que se aplicó com.android.test. En el siguiente ejemplo, el complemento androidx.baselineprofile aplica androidx.baselineprofile.producer de forma interna.
  • Un módulo que, en última instancia, consume el perfil de Baseline en el proceso de compilación. Este es un módulo com.android.application de la biblioteca o com.android.library de una aplicación para Android. En el siguiente ejemplo, el complemento androidx.baselineprofile aplica androidx.baselineprofile.consumer de forma interna.

Objetivo de la app (androidx.baselineprofile.apptarget)

No tiene ninguna configuración.

Generador de perfiles (androidx.baselineprofile.producer)

Compatibilidad con dispositivos administrados por Gradle

Para usar un dispositivo administrado por Gradle, agrega uno en la configuración build.gradle del módulo del generador de perfiles, como se muestra en el siguiente ejemplo:

Kotlin

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

Groovy

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

Luego, puedes usar el GMD creado para generar perfiles de Baseline agregándolo al siguiente fragmento de código:

Kotlin

baselineProfile {
    managedDevices += "pixel6Api31"
}

Groovy

baselineProfile {
    managedDevices = ['pixel6Api31']
}

Los siguientes ejemplos son opciones adicionales disponibles para habilitar o inhabilitar los dispositivos conectados para generar perfiles de Baseline.

Kotlin

baselineProfile {
    ...
    useConnectedDevices = true
}

Groovy

baselineProfile {
    ...
    useConnectedDevices true
}

Consumidor de perfiles (androidx.baselineprofile.consumer)

Genera perfiles por tipo y uno para todas las variantes

Puedes generar perfiles por variante, por tipo o como un solo archivo para usar en todas las variantes. Puedes controlar este comportamiento a través de la configuración de combinación, como se muestra en el siguiente ejemplo.

Kotlin

baselineProfile {
    mergeIntoMain = true / false
}

Groovy

baselineProfile {
    mergeIntoMain true / false
}
  • Establece mergeIntoMain como true para combinar todos los perfiles generados de cada variante en un solo perfil. No es posible generar perfiles de Baseline por variante cuando esta configuración es true, por lo que solo existe una tarea de generación única que se llama generateBaselineProfile. El resultado del perfil es src/main/generated/baselineProfiles.
  • Establece mergeIntoMain como false para inhabilitar la combinación y tener un perfil por variante. En el siguiente ejemplo, se pueden generar perfiles de Baseline por variante, por lo que existen varias tareas de generación, una por variante. Por ejemplo, cuando existen dos tipos (por ejemplo, gratuita y pagada) y un tipo de compilación de lanzamiento, las tareas generadas son las siguientes:
    • generateFreeReleaseBaselineProfile
    • generatePaidReleaseBaselineProfile
    • generateReleaseBaselineProfile

De forma predeterminada, esta configuración es true para bibliotecas y false para aplicaciones.

También puedes especificar este comportamiento por variante:

Kotlin

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

Groovy

baselineProfile {
    variants {
        freeRelease {
            mergeIntoMain true / false
        }
    }
}

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.

Genera un perfil de Baseline automáticamente cuando se compila una versión nueva

Puedes activar, de forma manual, la generación de perfiles de Baseline mediante la tarea generateBaselineProfile o automáticamente cuando se compila una versión. Esto se controla mediante la siguiente marca:

Kotlin

baselineProfile {
    automaticallyGenerateDuringBuild = true / false
}

Groovy

baselineProfile {
    automaticallyGenerateDuringBuild true / false
}

Establecer esta marca como true activa un nuevo perfil de Baseline para que se genere en cada compilación. De esta manera, se incluirá el perfil más actualizado en la compilación. Es decir, ejecutar una tarea de compilación de lanzamiento, como ./gradlew:app:assembleRelease, también activa :app:generateReleaseBaselineProfile. Esto también inicia las pruebas de instrumentación del perfil de Baseline y genera la compilación del perfil de Baseline en la que se ejecutan. Si bien esto ayuda a garantizar que los usuarios obtengan el mejor beneficio de rendimiento, también aumenta el tiempo de compilación debido a las pruebas de instrumentación y de compilación doble.

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

Kotlin

baselineProfile {
    variants {
        freeRelease {
            automaticallyGenerateDuringBuild = true / false
        }
    }
}

Groovy

baselineProfile {
    variants {
        freeRelease {
            automaticallyGenerateDuringBuild true / false
        }
    }
}

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.

Almacena perfiles de Baseline en fuentes

Puedes almacenar perfiles de Baseline en el directorio del código fuente a través de la marca saveInSrc:

  • 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.

Kotlin

baselineProfile {
    saveInSrc = true / false
}

Groovy

baselineProfile {
    saveInSrc true / false
}

También puedes especificar este comportamiento por variante:

Kotlin

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

Groovy

baselineProfile {
    variants {
        freeRelease {
            saveInSrc true / false
        }
    }
}
Filtra las reglas del perfil

Puedes filtrar las reglas del perfil de Baseline generadas a través de la configuración del complemento. Esto es muy útil para las bibliotecas si deseas 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 especificar, incluir y excluir paquetes y clases. 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.foo y com.example.foo.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.foo, pero no con com.example.foo.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:

Kotlin

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

Groovy

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

Los filtros también admiten variantes, y puedes expresarlas de la siguiente manera:

Kotlin

// 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.**")
            }
        }
    }
}

Groovy

// 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.**'
            }
        }
    }
}

Cómo aplicar manualmente las reglas generadas

El generador de Perfiles de Baseline crea un archivo de texto con formato legible por humanos (HRF) en el dispositivo y lo copia en la máquina anfitrión. Sigue estos pasos para aplicar el perfil generado a tu código:

  1. Ubica el archivo HRF en la carpeta de compilación del módulo en el que generas el perfil: [module]/build/outputs/managed_device_android_test_additional_output/[device].

    Los perfiles siguen el patrón de nomenclatura [class name]-[test method name]-baseline-prof.txt, que tiene este aspecto: BaselineProfileGenerator-startup-baseline-prof.txt.

  2. Copia el perfil generado en src/flavor/baselineProfiles en el módulo de tu app para cualquier variante. Para aplicar el perfil a todas las variantes, cópialo en src/main/baselineProfiles.

  3. Agrega una dependencia a la biblioteca de ProfileInstaller en el archivo build.gradle.kts de tu app para habilitar la compilación de perfiles de Baseline locales donde no estén disponibles los perfiles de Cloud. Esta es la única manera de transferir un perfil de Baseline de forma local.

    dependencies {
         implementation("androidx.profileinstaller:profileinstaller:1.3.1")
    }
    
  4. Compila la versión de producción de tu app mientras que las reglas de HRF aplicadas se compilan en formato binario y se incluyen en el APK o el AAB. Luego, distribuye tu app como de costumbre.

.

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 si lo ubicas 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

Analiza en detalle las macrocomparativas para medir el rendimiento.
Genera un Perfil de Baseline personalizado y adaptado a una app para Android, y verifica su eficacia.