Android Academy · Leçon

Démarrage et profils de référence

Accélérez les démarrages à froid.

Démarrage et profils de référence est une leçon Android Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Android Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Android Academy comprend 4 leçons au total.

Première impression : démarrage de l’application

Le temps de démarrage est la première chose que chaque utilisateur remarque. Google Play signale même les démarrages lents comme un problème de qualité. Un démarrage à froid rapide donne une impression de qualité ; un démarrage lent fait partir les utilisateurs.

Dans cette leçon, vous apprendrez les trois types de démarrage, les causes de ralentissement et les outils modernes — App Startup et les Baseline Profiles — qui accélèrent considérablement les démarrages à froid.

Démarrage à froid, tiède et à chaud

Android définit trois scénarios de démarrage, du plus lent au plus rapide :

Démarrage à froid : le processus n’existe pas. Android le crée, exécute Application, puis affiche votre premier écran. C’est le plus lent et le plus important à optimiser.
Démarrage tiède : le processus est actif, mais l’activité doit être recréée.
Démarrage à chaud : l’activité est toujours en mémoire ; il suffit de la ramener au premier plan. C’est presque instantané.

Les efforts d’optimisation se concentrent sur le démarrage à froid, car c’est celui que rencontrent le plus souvent les nouveaux utilisateurs et ceux qui reviennent dans l’application.

Mesurer le temps de démarrage

Vous ne pouvez pas améliorer ce que vous ne mesurez pas. Voici deux méthodes simples :

Logcat : le système consigne une ligne Displayed avec le délai jusqu’à la première image.
Macrobenchmark : StartupTimingMetric fournit des mesures de démarrage à froid stables et reproductibles.

Exécutez la commande adb ci-dessous et recherchez la ligne 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"

Alléger Application.onCreate

Tout ce qui se trouve dans Application.onCreate() s’exécute sur le thread principal avant votre première image. Une initialisation lourde à cet endroit retarde directement le démarrage.

La mauvaise version ci-dessous initialise plusieurs bibliothèques immédiatement. Différez ou exécutez en arrière-plan tout ce qui n’est pas nécessaire au premier écran.

// 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 bibliothèque Jetpack App Startup

La bibliothèque App Startup remplace plusieurs fournisseurs de contenu de bibliothèques (qui prennent chacun du temps) par un seul fournisseur partagé, et vous permet d’exprimer clairement l’ordre d’initialisation et les dépendances.

Vous implémentez un Initializer par composant ; App Startup les exécute une fois, dans l’ordre des dépendances.

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.

Initialisation différée et en arrière-plan

Il vaut mieux encore que d’ordonner le travail immédiat : en effectuer moins au démarrage. Deux stratégies :

Différée : construisez les objets lourds lors de leur première utilisation avec by lazy de Kotlin.
En arrière-plan : déplacez l’initialisation qui ne concerne pas l’interface utilisateur hors du thread principal.

La première image n’est alors pas bloquée par un travail dont l’utilisateur n’a pas encore besoin.

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 contre JIT : pourquoi le premier lancement est lent

Par défaut, Android exécute le bytecode de votre application en combinant interprétation et compilation juste-à-temps (JIT). La première fois que le code fréquemment exécuté est lancé, il est interprété (lentement) ; ce n’est que plus tard que l’environnement d’exécution le compile en code natif.

C’est précisément pourquoi le démarrage à froid et le premier défilement semblent plus lents. Les Baseline Profiles corrigent cela en indiquant à l’appareil de compiler à l’avance (AOT) le code important lors de l’installation.

Qu’est-ce qu’un Baseline Profile ?

Un Baseline Profile est une liste des classes et méthodes utilisées pendant vos parcours essentiels (démarrage, premier défilement). Vous l’intégrez à l’application ; lors de l’installation, l’appareil compile ces méthodes à l’avance (AOT), afin qu’elles s’exécutent à la vitesse du code natif dès le tout premier lancement.

Google fait souvent état d’améliorations du démarrage de l’ordre de 20 à 40 %, sans aucune modification du code de vos fonctionnalités — seul le profil est nécessaire.

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

Générer un Baseline Profile

Vous générez le profil en écrivant un petit test qui exécute votre parcours essentiel sur un appareil ; les outils enregistrent les méthodes exécutées et écrivent le fichier de profil. Vous l’intégrez ensuite au projet et effectuez une nouvelle compilation.

Voici un générateur type qui capture le démarrage et un défilement.

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

Vérifier le gain

Confirmez toujours l’amélioration avec une mesure comparative, en comparant le démarrage avec et sans l’application du profil (CompilationMode.None contre Partial avec le profil).

Si vous ne mesurez pas, vous ne pouvez pas prouver que le profil a été utile — et un profil obsolète peut même nuire aux performances. Régénérez-le chaque fois que vos parcours essentiels changent de manière importante.

@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()
}

Plan d’optimisation du démarrage

Rassemblez ces éléments dans un plan reproductible :

Mesurez le démarrage à froid avec Macrobenchmark et adb am start -W.
Allégez Application.onCreate : différez avec by lazy et déplacez le travail hors du thread principal.
Utilisez App Startup pour regrouper les fournisseurs de contenu et ordonner l’initialisation.
Intégrez un Baseline Profile pour compiler à l’avance le parcours essentiel.
Vérifiez le résultat avec une mesure et maintenez le profil à jour.

Résultat : une première image réactive que les utilisateurs remarquent.

Vérification rapide

Vous intégrez un Baseline Profile à votre application. Quelle est principalement son action pour améliorer le démarrage ?

Récapitulatif : rapide dès la première image

Vous avez appris à optimiser le démarrage, la mesure de performances la plus visible :

Optimisez le démarrage à froid ; mesurez-le avec Macrobenchmark et adb am start -W.
Gardez Application.onCreate léger : initialisation différée et travail en arrière-plan pour ce qui ne concerne pas l’interface utilisateur.
Utilisez la bibliothèque App Startup pour regrouper les fournisseurs et ordonner les initialisateurs.
Intégrez un Baseline Profile afin que le code fréquemment exécuté soit compilé à l’avance lors de l’installation et s’exécute à la vitesse native dès le premier lancement.
Vérifiez toujours le gain avec une mesure et maintenez le profil à jour.

La partie Optimisation et profilage des performances est terminée : vous pouvez désormais mesurer, maîtriser la recomposition, corriger les fuites et accélérer le démarrage.

Questions Fréquemment Posées

La leçon « Démarrage et profils de référence » est-elle gratuite ?

Oui — le texte complet de « Démarrage et profils de référence » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Android Academy, passe à CoddyKit PRO. Le cours Android Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Démarrage et profils de référence » ?

Accélérez les démarrages à froid. Tu pratiques Android Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Android Academy ?

Aucune expérience préalable n'est requise. Android Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Démarrage et profils de référence » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Android Academy ?

Oui. Chaque leçon Android Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Android Academy