Android Academy · Lezione

Avvio e profili baseline

Avvii a freddo più rapidi

Lezione 4 di 413 passaggi

Avvio e profili baseline è una lezione Android Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Android Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Android Academy include 4 lezioni in totale.

La prima impressione: avvio dell’app

Il tempo di avvio è la prima cosa che ogni utente sperimenta. Google Play segnala persino gli avvii lenti come un problema di qualità. Un avvio a freddo rapido fa percepire l’app come di alta qualità; uno lento spinge gli utenti ad abbandonarla.

In questa lezione imparerete i tre tipi di avvio, che cosa lo rende lento e gli strumenti moderni — App Startup e Baseline Profiles — che rendono notevolmente più rapidi gli avvii a freddo.

Avvio a freddo, tiepido e a caldo

Android definisce tre scenari di avvio, dal più lento al più rapido:

Avvio a freddo: il processo non esiste. Android lo crea, esegue Application e poi mostra la prima schermata. È il più lento e quello più importante da ottimizzare.
Avvio tiepido: il processo è attivo, ma l’Activity deve essere ricreata.
Avvio a caldo: l’Activity è ancora in memoria; basta riportarla in primo piano. È quasi istantaneo.

Gli sforzi di ottimizzazione si concentrano sull’avvio a freddo, perché è quello che interessa più spesso gli utenti nuovi e quelli che tornano a usare l’app.

Misurare il tempo di avvio

Non potete migliorare ciò che non misurate. Ecco due metodi semplici:

Logcat: il sistema registra una riga Displayed con il tempo fino al primo frame.
Macrobenchmark: StartupTimingMetric fornisce valori stabili e ripetibili per l’avvio a freddo.

Eseguite il comando adb riportato di seguito e cercate la riga Displayed.

# Cold-start the app and log time to first frame
adb shell am start -W -S com.example.app/.MainActivity

# Output includes:
#   TotalTime: 412   <- ms to first frame
# Or filter logcat:
adb logcat | grep "Displayed com.example.app"

Mantenere leggero Application.onCreate

Tutto ciò che si trova in Application.onCreate() viene eseguito sul thread principale prima del primo frame. Un’inizializzazione pesante in questo punto ritarda direttamente l’avvio.

La versione errata riportata di seguito inizializza subito diverse librerie. Rimandate o eseguite in background tutto ciò che non è necessario per la prima schermata.

// SLOW: blocks the first frame with eager init
class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        Analytics.init(this)        // network, disk
        ImageLoader.preload(this)   // heavy
        Database.warmUp(this)       // disk I/O
    }
}
// Each of these adds milliseconds before the user sees anything.

La libreria Jetpack App Startup

La libreria App Startup sostituisce diversi content provider delle librerie (ognuno dei quali richiede tempo) con un unico provider condiviso e consente di esprimere in modo chiaro l’ordine di inizializzazione e le dipendenze.

Dovete implementare un Initializer per ogni componente; App Startup li esegue una sola volta, nell’ordine dettato dalle dipendenze.

class AnalyticsInitializer : Initializer<Analytics> {
    override fun create(context: Context): Analytics {
        return Analytics.init(context.applicationContext)
    }
    // Runs after Logger is ready
    override fun dependencies() = listOf(LoggerInitializer::class.java)
}
// Registered via a single merged provider in the manifest,
// avoiding one ContentProvider per library.

Inizializzazione lazy e in background

Meglio ancora che ordinare il lavoro eseguito subito è svolgerne meno durante l’avvio. Ecco due strategie:

Lazy: create gli oggetti pesanti al primo utilizzo con by lazy di Kotlin.
Background: spostate l’inizializzazione non relativa all’interfaccia utente fuori dal thread principale.

In questo modo il primo frame non viene bloccato da un lavoro di cui l’utente non ha ancora bisogno.

class MyApp : Application() {
    // Built only when first accessed, not during onCreate
    val imageLoader by lazy { ImageLoader.build(this) }

    override fun onCreate() {
        super.onCreate()
        // Push non-critical setup off the main thread
        CoroutineScope(Dispatchers.Default).launch {
            Analytics.init(applicationContext)
        }
    }
}

AOT e JIT: perché la prima esecuzione è lenta

Per impostazione predefinita, Android esegue il bytecode dell’app con una combinazione di interpretazione e compilazione Just-In-Time (JIT). La prima volta che viene eseguito il codice più utilizzato, questo viene interpretato (lentamente); solo in seguito il runtime lo compila in codice nativo.

È proprio per questo che l’avvio a freddo e il primo scorrimento risultano più lenti. I Baseline Profiles risolvono il problema indicando al dispositivo di compilare Ahead-Of-Time (AOT) il codice importante durante l’installazione.

Che cos’è un Baseline Profile

Un Baseline Profile è un elenco delle classi e dei metodi utilizzati durante i percorsi critici (avvio, primo scorrimento). Lo distribuite insieme all’app; durante l’installazione il dispositivo compila AOT quei metodi, che vengono così eseguiti alla velocità del codice nativo già dal primo avvio.

Google segnala spesso miglioramenti dell’avvio nell’intervallo 20–40%, senza modifiche al codice delle funzionalità: basta il profile.

// build.gradle.kts
plugins { id("androidx.baselineprofile") }

dependencies {
    baselineProfile(project(":baselineprofile"))
}
// The generated profile ships as
//   assets/dexopt/baseline.prof
// and is applied automatically at install.

Generare un Baseline Profile

Generate il profile scrivendo un piccolo test che esegue il percorso critico su un dispositivo; gli strumenti registrano quali metodi sono stati eseguiti e scrivono il file del profile. Poi eseguite il commit e ricompilate.

Ecco un generatore tipico che acquisisce l’avvio e uno scorrimento.

@RunWith(AndroidJUnit4::class)
class BaselineProfileGenerator {
    @get:Rule val rule = BaselineProfileRule()

    @Test
    fun generate() = rule.collect(packageName = "com.example.app") {
        pressHome()
        startActivityAndWait()
        // exercise the critical journey
        device.findObject(By.res("feed")).fling(Direction.DOWN)
    }
}
// Run the generateBaselineProfile Gradle task to produce the file.

Verificare il miglioramento

Confermate sempre il miglioramento con un benchmark, confrontando l’avvio con e senza il profile applicato (CompilationMode.None rispetto a Partial con il profile).

Se non misurate, non potete dimostrare che il profile abbia aiutato; inoltre, un profile obsoleto può persino peggiorare le prestazioni. Rigeneratelo ogni volta che i percorsi più utilizzati cambiano significativamente.

@Test
fun startupWithProfile() = rule.measureRepeated(
    packageName = "com.example.app",
    metrics = listOf(StartupTimingMetric()),
    iterations = 10,
    startupMode = StartupMode.COLD,
    compilationMode = CompilationMode.Partial() // uses the baseline profile
) {
    pressHome()
    startActivityAndWait()
}

Un piano per ottimizzare l’avvio

Riunite tutto in un piano ripetibile:

Misurate l’avvio a freddo con Macrobenchmark e adb am start -W.
Riducete Application.onCreate: rimandate l’inizializzazione con by lazy e spostate il lavoro fuori dal thread principale.
Usate App Startup per unire i content provider e ordinare l’inizializzazione.
Distribuite un Baseline Profile per la compilazione AOT del percorso critico.
Verificate il risultato con un benchmark e mantenete aggiornato il profile.

Il risultato è un primo frame rapido, che gli utenti noteranno.

Verifica rapida

Distribuite un Baseline Profile insieme all’app. Che cosa fa principalmente per migliorare l’avvio?

Rispondi nella lezione interattiva

Riepilogo: rapidità fin dal primo frame

Avete imparato a ottimizzare l’avvio, la metrica delle prestazioni più visibile:

Ottimizzate l’avvio a freddo; misuratelo con Macrobenchmark e adb am start -W.
Mantenete leggero Application.onCreate: inizializzazione lazy e lavoro non relativo all’interfaccia utente in background.
Usate la libreria App Startup per unire i provider e ordinare gli initializer.
Distribuite un Baseline Profile affinché il codice più utilizzato venga compilato AOT durante l’installazione e raggiunga la velocità nativa già alla prima esecuzione.
Verificate sempre il miglioramento con un benchmark e mantenete aggiornato il profile.

Con questo si conclude Performance Optimization & Profiling: ora sapete misurare, controllare la ricomposizione, risolvere le perdite di memoria e ottenere un avvio rapido.

Gratis per iniziare

Impara Kotlin con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 36
Lezioni: 152

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «Avvio e profili baseline» è gratuita?

Sì — il testo completo di «Avvio e profili baseline» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Android Academy, passa a CoddyKit PRO. Il corso Android Academy include 4 lezioni in totale.

Cosa imparerò in «Avvio e profili baseline»?

Avvii a freddo più rapidi Eserciti Android Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Android Academy?

Non è richiesta alcuna esperienza precedente. Android Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Avvio e profili baseline»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Android Academy?

Sì. Ogni lezione Android Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Android Academy