Creare profili di riferimento

I profili di base sono essenziali per massimizzare le prestazioni di Jetpack Compose. La precompilazione dei percorsi utente critici contribuisce a garantire il rendering fluido della tua UI Compose.

Genera automaticamente profili per ogni release dell'app utilizzando la libreria Jetpack Macrobenchmark e BaselineProfileRule. Ti consigliamo di utilizzare com.android.tools.build:gradle:8.0.0 o versioni successive per sfruttare i miglioramenti della build quando utilizzi i profili di base.

Ecco i passaggi generali per creare un nuovo profilo di baseline:

1. Configura il modulo Profilo di baseline.
2. Definisci il test JUnit che consente di generare profili di base.
3. Aggiungi i Critical User Journey (CUJ) che vuoi ottimizzare.
4. Genera il profilo di baseline.

Dopo aver generato il profilo di baseline, esegui il benchmark utilizzando un dispositivo fisico per misurare i miglioramenti della velocità.

Crea un nuovo profilo di baseline con AGP 8.2 o versioni successive

Il modo più semplice per creare un nuovo profilo di baseline è utilizzare il modello di modulo del profilo di baseline, disponibile a partire da Android Studio Iguana e dal plug-in Android per Gradle (AGP) 8.2.

Il modello di modulo Android Studio Baseline Profile Generator automatizza la creazione di un nuovo modulo per generare e benchmark i profili di baseline. L'esecuzione del template genera la maggior parte della configurazione di compilazione tipica, la generazione del profilo di baseline e il codice di verifica. Il modello crea codice per generare e confrontare i profili di base per misurare l'avvio dell'app.

Configurare il modulo Profilo di base

Per eseguire il modello di modulo profilo di baseline, segui questi passaggi:

1. Seleziona File > Nuovo > Nuovo modulo.
2. Seleziona il modello Generatore di profili di baseline nel riquadro Modelli e configuralo:

   

   I campi nel modello sono i seguenti:
   • Applicazione di destinazione: l'app per cui viene generato il profilo di baseline. Se nel progetto è presente un solo modulo dell'app, in questo elenco è presente un solo elemento.
   • Nome modulo: il nome che vuoi assegnare al modulo del profilo di baseline che verrà creato.
   • Nome pacchetto: il nome del pacchetto che vuoi per il modulo del profilo di baseline.
   • Lingua: se vuoi che il codice generato sia Kotlin o Java.
   • Linguaggio di configurazione della build: indica se vuoi utilizzare Kotlin Script (KTS) o Groovy per gli script di configurazione della build.
   • Utilizza il dispositivo gestito da Gradle: indica se utilizzi dispositivi gestiti da Gradle per testare la tua app.
3. Fai clic su Fine e il nuovo modulo viene creato. Se utilizzi il controllo del codice sorgente, potrebbe esserti chiesto di aggiungere i file del modulo appena creato al controllo del codice sorgente.

Definisci il generatore di profili di baseline

Il modulo appena creato contiene test per generare e valutare il profilo di baseline e testare solo l'avvio di base dell'app. Ti consigliamo di ampliare questi elementi per includere i CUJ e i workflow di avvio avanzati. Assicurati che tutti i test relativi all'avvio dell'app si trovino in un blocco rule con includeInStartupProfile impostato su true; al contrario, per un rendimento ottimale, assicurati che tutti i test non relativi all'avvio dell'app non siano inclusi in un profilo di avvio. Le ottimizzazioni dell'avvio dell'app vengono utilizzate per definire una parte speciale di un profilo di baseline chiamata profilo di avvio.

Aiuta a mantenere la manutenibilità se estrai questi CUJ al di fuori del codice del profilo di baseline e del benchmark generati, in modo che possano essere utilizzati per entrambi. Ciò significa che le modifiche alle tue CUJ vengono utilizzate in modo coerente.

Genera e installa il profilo di baseline

Il modello di modulo Baseline Profile aggiunge una nuova configurazione di esecuzione per generare il profilo di baseline. Se utilizzi le varianti di prodotto, Android Studio crea più configurazioni di esecuzione in modo da poter generare profili di base separati per ogni variante.

Al termine della configurazione di esecuzione Generate Baseline Profile, viene copiata la baseline del profilo generata nel file src/variant/generated/baselineProfiles/baseline-prof.txt nel modulo di cui viene eseguito il profiling. Le opzioni di variante sono il tipo di build di rilascio o una variante di build che include il tipo di build di rilascio.

Il profilo di baseline generato è stato creato originariamente in build/outputs. Il percorso completo è determinato dalla variante o dal flavor dell'app di cui viene eseguito il profiling e se utilizzi un dispositivo gestito da Gradle o un dispositivo connesso per il profiling. Se utilizzi i nomi utilizzati dalle configurazioni di codice e di compilazione generate dal template, il profilo di baseline viene creato nel file build/outputs/managed_device_android_test_additional_output/nonminifiedrelease/pixel6Api31/BaselineProfileGenerator_generate-baseline-prof.txt. Probabilmente non dovrai interagire direttamente con questa versione del profilo di baseline generato, a meno che tu non la stia copiando manualmente nei moduli di destinazione (non consigliato).

Crea un nuovo profilo di baseline con AGP 8.1

Se non riesci a utilizzare il modello di modulo del profilo di baseline, utilizza il modello di modulo Macrobenchmark e il plug-in Gradle del profilo di baseline per creare un nuovo profilo di baseline. Ti consigliamo di utilizzare questi strumenti a partire da Android Studio Giraffe e AGP 8.1.

Ecco i passaggi per creare un nuovo profilo di baseline utilizzando il modello di modulo Macrobenchmark e il plug-in Gradle per i profili di baseline:

1. Configura un modulo Macrobenchmark nel progetto Gradle.

2. Definisci una nuova classe chiamata BaselineProfileGenerator:

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

   Il generatore può contenere interazioni con la tua app oltre all'avvio dell'app. In questo modo puoi ottimizzare le prestazioni di runtime della tua app, ad esempio scorrere gli elenchi, eseguire animazioni e navigare all'interno di un Activity. Visualizza altri esempi di test che utilizzano @BaselineProfileRule per migliorare i percorsi utente critici.

3. Aggiungi il plug-in Gradle per i profili di baseline (libs.plugins.androidx.baselineprofile). Il plug-in semplifica la generazione e la manutenzione dei profili di baseline in futuro.

4. Per generare il profilo di baseline, esegui i task Gradle :app:generateBaselineProfile o :app:generateVariantBaselineProfile nel terminale.

   Esegui il generatore come test strumentato su un dispositivo fisico con accesso root, un emulatore o un dispositivo gestito da Gradle. Se utilizzi un dispositivo gestito da Gradle, imposta aosp come systemImageSource, perché hai bisogno dell'accesso root per il generatore di profili di baseline.

   Al termine dell'attività di generazione, il profilo di baseline viene copiato in app/src//generated/baselineProfiles.

Crea un nuovo profilo di baseline senza modelli

Ti consigliamo di creare un profilo di baseline utilizzando il modello di modulo del profilo di baseline (preferito) o il modello Macrobenchmark di Android Studio, ma puoi anche utilizzare il plug-in Gradle del profilo di baseline da solo. Per saperne di più sul plug-in Gradle per i profili di baseline, consulta Configurare la generazione dei profili di baseline.

Ecco come creare un profilo di baseline utilizzando direttamente il plug-in Gradle per i profili di baseline:

1. Crea un nuovo modulo com.android.test, ad esempio :baseline-profile.

2. Configura il file build.gradle.kts per :baseline-profile:

   1. Applica il plug-in androidx.baselineprofile.
   2. Assicurati che targetProjectPath punti al modulo :app.
   3. (Facoltativo) Aggiungi un dispositivo gestito da Gradle (GMD). Nell'esempio seguente, è pixel6Api31. Se non specificato, il plug-in utilizza un dispositivo connesso, emulato o fisico.
   4. Applica la configurazione che preferisci, come mostrato nell'esempio seguente.

   Kotlin

   plugins {
       id("com.android.test")
       id("androidx.baselineprofile")
   }
   
   android {
       defaultConfig {
           ...
       }
   
       // Point to the app module, the module that you're generating the Baseline Profile for.
       targetProjectPath = ":app"
       // Configure a GMD (optional).
       testOptions.managedDevices.devices {
           pixel6Api31(com.android.build.api.dsl.ManagedVirtualDevice) {
               device = "Pixel 6"
               apiLevel = 31
               systemImageSource = "aosp"
           }
       }
   }
   
   dependencies { ... }
   
   // Baseline Profile Gradle plugin configuration. Everything is optional. This
   // example uses the GMD added earlier and disables connected devices.
   baselineProfile {
       // Specifies the GMDs to run the tests on. The default is none.
       managedDevices += "pixel6Api31"
       // 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
   }

   Alla moda

   plugins {
       id 'com.android.test'
       id 'androidx.baselineprofile'
   }
   
   android {
       defaultConfig {
           ...
       }
   
       // Point to the app module, the module that you're generating the Baseline Profile for.
       targetProjectPath ':app'
       // Configure a GMD (optional).
       testOptions.managedDevices.devices {
           pixel6Api31(com.android.build.api.dsl.ManagedVirtualDevice) {
               device 'Pixel 6'
               apiLevel 31
               systemImageSource 'aosp'
           }
       }
   }
   
   dependencies { ... }
   
   // Baseline Profile Gradle plugin configuration. Everything is optional. This
   // example uses the GMD added earlier and disables connected devices.
   baselineProfile {
       // Specifies the GMDs to run the tests on. The default is none.
       managedDevices ['pixel6Api31']
       // 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 un test del profilo di baseline nel modulo di test :baseline-profile. L'esempio seguente è un test che genera un profilo di baseline per l'avvio dell'app.

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

4. Aggiorna il file build.gradle.kts nel modulo dell'app, ad esempio :app.

   1. Applica il plug-in androidx.baselineprofile.
   2. Aggiungi una dipendenza baselineProfile al modulo :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 on the `:baseline-profile` module.
       baselineProfile(project(":baseline-profile"))
   }

   Alla moda

   plugins {
       id 'com.android.application'
       id 'androidx.baselineprofile'
   }
   
   android {
       // No changes to the `android` block.
       ...
   }
   
   dependencies {
       ...
       // Add a `baselineProfile` dependency on the `:baseline-profile` module.
       baselineProfile ':baseline-profile'
   }

5. Genera il profilo eseguendo le attività Gradle :app:generateBaselineProfile o :app:generateVariantBaselineProfile.

6. Al termine dell'attività di generazione, il profilo di baseline viene copiato in app/src/variant/generated/baselineProfiles.

Benchmark del profilo di baseline

Per eseguire il benchmark del profilo di baseline, crea una nuova configurazione di esecuzione del test strumentato Android dall'azione di gutter che esegue i benchmark definiti nel file StartupBenchmarks.kt. Per saperne di più sui test di benchmarking, consulta Creare una classe Macrobenchmark e Benchmark dei profili di base con la libreria Macrobenchmark.

Quando esegui questa operazione in Android Studio, l'output della build contiene i dettagli dei miglioramenti della velocità forniti dal profilo di baseline:

StartupBenchmarks_startupCompilationBaselineProfiles
timeToInitialDisplayMs   min 161.8,   median 178.9,   max 194.6
StartupBenchmarks_startupCompilationNone
timeToInitialDisplayMs   min 184.7,   median 196.9,   max 202.9

Acquisire tutti i percorsi di codice richiesti

Le due metriche chiave per misurare i tempi di avvio delle app sono le seguenti:

• Tempo di attesa per la prima schermata (TTID): il tempo necessario per visualizzare il primo frame della UI dell'applicazione.

• Tempo di attesa per la visualizzazione completa (TTFD): TTID più il tempo necessario per visualizzare i contenuti caricati in modo asincrono dopo la visualizzazione del frame iniziale.

TTFD viene segnalato una volta chiamato il metodo reportFullyDrawn di ComponentActivity. Se reportFullyDrawn non viene mai chiamato, viene segnalato l'ID TTID. Potrebbe essere necessario ritardare la chiamata di reportFullyDrawn fino al completamento del caricamento asincrono. Ad esempio, se l'interfaccia utente contiene un elenco pigro dinamico, l'elenco potrebbe essere compilato da un'attività in background che viene completata dopo il primo disegno dell'elenco e, pertanto, dopo che l'interfaccia utente è contrassegnata come completamente disegnata. In questi casi, il codice eseguito dopo che la UI raggiunge lo stato completamente disegnato non è incluso nel profilo di baseline.

Per includere il popolamento dell'elenco nel profilo di baseline, recupera FullyDrawnReporter utilizzando getFullyDrawnReporter e aggiungi un reporter nel codice dell'app. Rilascia il reporter una volta che l'attività in background ha terminato di compilare l'elenco. FullyDrawnReporter non chiama il metodo reportFullyDrawn finché non vengono rilasciati tutti i reporter. In questo modo, Il profilo di baseline include i percorsi del codice necessari per compilare l'elenco. Questa non modifica il comportamento dell'app per l'utente, ma consente al profilo di baseline di includere tutti i percorsi del codice necessari.

Per indicare lo stato completamente disegnato, utilizza le seguenti API Compose:

• ReportDrawn indica che il tuo componente componibile è immediatamente pronto per l'interazione.
• ReportDrawnWhen accetta un predicato, ad esempio list.count > 0, per indicare quando il composable è pronto per l'interazione.
• ReportDrawnAfter accetta un metodo di sospensione che, al termine, indica che il composable è pronto per l'interazione.