Démarrage des applications Inclus dans Android Jetpack.

La bibliothèque App Startup offre un moyen simple et performant d'initialiser au démarrage de l'application. Les développeurs de bibliothèques et d'applications vous pouvez utiliser le démarrage de l'application pour simplifier les séquences de démarrage et définir explicitement l'ordre de l'initialisation.

Au lieu de définir des fournisseurs de contenu distincts pour chaque composant, vous devez le démarrage de l'application vous permet de définir des initialiseurs de composants qui partagent avec un seul fournisseur de contenu. Cela peut considérablement améliorer le temps de démarrage de l'application.

Configuration

Pour utiliser Jetpack Startup dans votre bibliothèque ou votre application, ajoutez ce qui suit à votre Gradle :

dependencies {
    implementation "androidx.startup:startup-runtime:1.2.0"
}

dependencies {
    implementation("androidx.startup:startup-runtime:1.2.0")
}

Initialiser les composants au démarrage de l'application

Les applications et les bibliothèques reposent souvent sur l'initialisation immédiate des composants l'application démarre. Pour répondre à ce besoin, vous pouvez faire appel à des fournisseurs initialisera chaque dépendance, mais l'instanciation des fournisseurs de contenu coûte cher. et peut ralentir inutilement la séquence de démarrage. En outre, Android initialise les fournisseurs de contenu dans un ordre indéterminé. App Startup offre un plus efficace d'initialiser les composants au démarrage de l'application et d'initialiser définir leurs dépendances.

Pour utiliser le démarrage de l'application afin d'initialiser automatiquement les composants au démarrage, vous devez : définir un initialiseur de composant pour chaque composant dont l'application a besoin initialiser.

Implémenter des initialiseurs de composants

Pour définir chaque initialiseur de composant, créez une classe qui implémente la classe Initializer<T>. Cette interface définit deux méthodes importantes:

• La méthode create(), qui contient toutes les opérations nécessaires pour initialisez le composant et renvoie une instance de T.
• La méthode dependencies(), qui renvoie une liste des autres Objets Initializer<T> dont dépend l'initialiseur. Vous pouvez utiliser cette pour contrôler l'ordre dans lequel l'application exécute les initialiseurs au démarrage.

Par exemple, supposons que votre application dépende WorkManager et doit et l'initialiser au démarrage. Définissez une classe WorkManagerInitializer qui implémente Initializer<WorkManager>:

// Initializes WorkManager.
class WorkManagerInitializer : Initializer<WorkManager> {
    override fun create(context: Context): WorkManager {
        val configuration = Configuration.Builder().build()
        WorkManager.initialize(context, configuration)
        return WorkManager.getInstance(context)
    }
    override fun dependencies(): List<Class<out Initializer<*>>> {
        // No dependencies on other libraries.
        return emptyList()
    }
}

// Initializes WorkManager.
class WorkManagerInitializer implements Initializer<WorkManager> {

    @Override
    public WorkManager create(Context context) {
        Configuration configuration = Configuration.Builder().build();
        WorkManager.initialize(context, configuration);
        return WorkManager.getInstance(context);
    }

    @Override
    public List<Class<Initializer<?>>> dependencies() {
        // No dependencies on other libraries.
        return emptyList();
    }

}

La méthode dependencies() renvoie une liste vide, car WorkManager n'a pas dépendent de toute autre bibliothèque.

Supposons que votre application dépend également d'une bibliothèque appelée ExampleLogger, qui, dans dépend de WorkManager. Cette dépendance signifie que vous devez vous assurer que le démarrage de l'application initialise WorkManager en premier. Définissez une ExampleLoggerInitializer qui implémente Initializer<ExampleLogger>:

// Initializes ExampleLogger.
class ExampleLoggerInitializer : Initializer<ExampleLogger> {
    override fun create(context: Context): ExampleLogger {
        // WorkManager.getInstance() is non-null only after
        // WorkManager is initialized.
        return ExampleLogger(WorkManager.getInstance(context))
    }

    override fun dependencies(): List<Class<out Initializer<*>>> {
        // Defines a dependency on WorkManagerInitializer so it can be
        // initialized after WorkManager is initialized.
        return listOf(WorkManagerInitializer::class.java)
    }
}

// Initializes ExampleLogger.
class ExampleLoggerInitializer implements Initializer<ExampleLogger> {

    @Override
    public ExampleLogger create(Context context) {
        // WorkManager.getInstance() is non-null only after
        // WorkManager is initialized.
        return ExampleLogger(WorkManager.getInstance(context));
    }

    @Override
    public List<Class<Initializer<?>>> dependencies() {
        // Defines a dependency on WorkManagerInitializer so it can be
        // initialized after WorkManager is initialized.
        return Arrays.asList(WorkManagerInitializer.class);
    }
}

Étant donné que vous incluez WorkManagerInitializer dans la méthode dependencies(), Le démarrage initialise WorkManager avant ExampleLogger.

Configurer des entrées de fichier manifeste

App Startup inclut un fournisseur de contenu spécial appelé InitializationProvider qu'il utilise pour détecter et appeler les initialiseurs de composants. Démarrage des applications découvre les initialiseurs de composants en recherchant d'abord une entrée <meta-data> sous l'entrée du fichier manifeste InitializationProvider. Ensuite, le démarrage de l'application appelle dependencies() pour tous les initialiseurs qu'il a déjà découverts.

Cela signifie que pour qu'un initialiseur de composant soit visible par l'application, Au démarrage, l'une des conditions suivantes doit être remplie:

• L'initialiseur de composant possède une entrée <meta-data> correspondante sous la section Entrée du fichier manifeste InitializationProvider.
• L'initialiseur du composant est répertorié dans la méthode dependencies() à partir d'une d'un initialiseur déjà visible.

Reprenons l'exemple avec WorkManagerInitializer. ExampleLoggerInitializer Pour s'assurer que le démarrage de l'application détecte ces d'initialisation, ajoutez ce qui suit au fichier manifeste:

<provider
    android:name="androidx.startup.InitializationProvider"
    android:authorities="${applicationId}.androidx-startup"
    android:exported="false"
    tools:node="merge">
    <!-- This entry makes ExampleLoggerInitializer discoverable. -->
    <meta-data  android:name="com.example.ExampleLoggerInitializer"
          android:value="androidx.startup" />
</provider>

Vous n'avez pas besoin d'ajouter une entrée <meta-data> pour WorkManagerInitializer. car WorkManagerInitializer est une dépendance de ExampleLoggerInitializer. Cela signifie que si ExampleLoggerInitializer est visible, il l'est aussi WorkManagerInitializer

L'attribut tools:node="merge" garantit que l'outil de fusion des fichiers manifestes résout correctement les entrées en conflit.

Exécuter des vérifications lint

La bibliothèque App Startup inclut un ensemble de règles lint que vous pouvez utiliser pour vérifier si vous avez correctement défini les initialiseurs de composants. Vous pouvez effectuer ces vérifications lint en exécutant ./gradlew :app:lintDebug à partir de la ligne de commande.

Initialiser manuellement les composants

Habituellement, lorsque vous utilisez le démarrage de l'application, l'objet InitializationProvider utilise une entité appelée De AppInitializer à pour détecter et exécuter automatiquement les initialiseurs de composants au démarrage de l'application. Toutefois, vous pouvez également utiliser AppInitializer directement pour initialisez les composants dont votre application n'a pas besoin au démarrage. C'est ce qu'on appelle l'initialisation différée, et peut contribuer à réduire les coûts de démarrage.

Vous devez d'abord désactiver l'initialisation automatique pour les composants que vous souhaitez pour s'initialiser manuellement.

Désactiver l'initialisation automatique pour un composant individuel

Pour désactiver l'initialisation automatique pour un seul composant, supprimez le paramètre Entrée <meta-data> pour l'initialiseur de ce composant à partir du fichier manifeste.

Par exemple, l'ajout de ce qui suit au fichier manifeste désactive l'automatisation initialisation pour ExampleLogger:

<provider
    android:name="androidx.startup.InitializationProvider"
    android:authorities="${applicationId}.androidx-startup"
    android:exported="false"
    tools:node="merge">
    <meta-data android:name="com.example.ExampleLoggerInitializer"
              tools:node="remove" />
</provider>

Vous utilisez tools:node="remove" dans l'entrée au lieu de simplement la supprimer. afin de vous assurer que l'outil de fusion supprime également l'entrée de toutes les autres des fichiers manifestes fusionnés.

Désactiver l'initialisation automatique pour tous les composants

Pour désactiver toute initialisation automatique, supprimez l'intégralité de l'entrée pour InitializationProvider du fichier manifeste:

<provider
    android:name="androidx.startup.InitializationProvider"
    android:authorities="${applicationId}.androidx-startup"
    tools:node="remove" />

Appeler manuellement les initialiseurs de composants

Si l'initialisation automatique est désactivée pour un composant, vous pouvez utiliser AppInitializer pour initialiser manuellement ce composant et ses dépendances.

Par exemple, le code suivant appelle AppInitializer et initialise manuellement ExampleLogger:

AppInitializer.getInstance(context)
    .initializeComponent(ExampleLoggerInitializer::class.java)

AppInitializer.getInstance(context)
    .initializeComponent(ExampleLoggerInitializer.class);

Par conséquent, le démarrage de l'application initialise également WorkManager, car WorkManager est une dépendance de ExampleLogger.

Envoyer des commentaires

Faites-nous part de vos commentaires et de vos idées via les ressources suivantes :

Issue Tracker

Signalez les problèmes pour que nous puissions corriger les bugs.