Avvio dell'app Componente di Android Jetpack.

La libreria Avvio applicazione fornisce un modo semplice ed efficace per inizializzare i componenti all'avvio dell'applicazione. Sia gli sviluppatori di librerie che quelli di app possono usare Avvio app per semplificare le sequenze di avvio e impostare esplicitamente l'ordine di inizializzazione.

Anziché definire fornitori di contenuti distinti per ogni componente da inizializzare, Avvio app ti consente di definire inizializzatori di componenti che condividono un singolo fornitore di contenuti. Ciò può migliorare notevolmente il tempo di avvio dell'app.

Configurazione

Per utilizzare Jetpack Startup nella tua libreria o app, aggiungi quanto segue al tuo file Gradle:

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

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

Inizializza i componenti all'avvio dell'app

Le app e le librerie spesso si basano sull'inizializzazione dei componenti immediatamente all'avvio dell'app. Puoi soddisfare questa esigenza utilizzando fornitori di contenuti per inizializzare ogni dipendenza, ma i provider di contenuti sono costosi da creare e possono rallentare la sequenza di avvio inutilmente. Inoltre, Android inizializza i fornitori di contenuti in un ordine indeterminato. App Startup fornisce un modo più efficiente per inizializzare i componenti all'avvio dell'app e per definirne in modo esplicito le dipendenze.

Per utilizzare Avvio applicazione per inizializzare automaticamente i componenti all'avvio, devi definire un inizializzatore di componenti per ogni componente che l'app deve inizializzare.

Implementare gli inizializzatori dei componenti

Per definire ogni inizializzatore dei componenti, devi creare una classe che implementa l'interfaccia Initializer<T>. Questa interfaccia definisce due importanti metodi:

• Il metodo create(), che contiene tutte le operazioni necessarie per inizializzare il componente e restituisce un'istanza di T.
• Il metodo dependencies(), che restituisce un elenco degli altri oggetti Initializer<T> da cui dipende l'inizializzazione. Puoi utilizzare questo metodo per controllare l'ordine in cui l'app esegue gli inizializzatori all'avvio.

Ad esempio, supponiamo che la tua app dipenda da WorkManager e che debba essere inizializzata all'avvio. Definisci una classe WorkManagerInitializer che implementa 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();
    }

}

Il metodo dependencies() restituisce un elenco vuoto perché WorkManager non dipende da altre librerie.

Supponiamo che la tua app dipenda anche da una libreria chiamata ExampleLogger, che a sua volta dipende da WorkManager. Questa dipendenza significa che devi prima assicurarti che Avvio app inizializza WorkManager. Definisci una classe ExampleLoggerInitializer che implementa 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);
    }
}

Poiché includi WorkManagerInitializer nel metodo dependencies(), Avvio app inizializza WorkManager prima del giorno ExampleLogger.

Configurazione delle voci manifest

App Startup include un fornitore di contenuti speciale chiamato InitializationProvider, che utilizza per rilevare e chiamare gli inizializzatori dei componenti. L'Avvio app rileva gli inizializzatori dei componenti controllando innanzitutto una voce <meta-data> nella voce manifest InitializationProvider. Quindi, Avvio applicazione chiama i metodi dependencies() per tutti gli inizializzatori già rilevati.

Ciò significa che affinché un inizializzatore di componenti sia rilevabile dall'avvio dell'app, deve essere soddisfatta una delle seguenti condizioni:

• L'inizializzazione del componente ha una voce <meta-data> corrispondente nella voce manifest InitializationProvider.
• L'inizializzazione del componente è elencato nel metodo dependencies() di un inizializzatore già rilevabile.

Considera di nuovo l'esempio con WorkManagerInitializer e ExampleLoggerInitializer. Per assicurarti che l'avvio dell'app possa rilevare questi inizializzatori, aggiungi quanto segue al file manifest:

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

Non è necessario aggiungere una voce <meta-data> per WorkManagerInitializer, perché WorkManagerInitializer è una dipendenza di ExampleLoggerInitializer. Ciò significa che se ExampleLoggerInitializer è rilevabile, allora lo è anche WorkManagerInitializer.

L'attributo tools:node="merge" assicura che lo strumento manifest merger risolva correttamente le voci in conflitto.

Esegui controlli lint

La libreria Avvio applicazione include un insieme di regole lint che puoi utilizzare per verificare se hai definito correttamente gli inizializzatori dei componenti. Puoi eseguire questi controlli lint eseguendo ./gradlew :app:lintDebug dalla riga di comando.

Inizializzare manualmente i componenti

Solitamente, quando utilizzi Avvio app, l'oggetto InitializationProvider utilizza un'entità denominata AppInitializer per rilevare ed eseguire automaticamente gli inizializzatori dei componenti all'avvio dell'applicazione. Tuttavia, puoi anche usare AppInitializer direttamente per inizializzare manualmente i componenti non necessari all'avvio dell'app. Questa procedura è chiamata inizializzazione pigra e può aiutare a ridurre al minimo i costi di avvio.

Devi prima disabilitare l'inizializzazione automatica per tutti i componenti che vuoi inizializzare manualmente.

Disattivare l'inizializzazione automatica per un singolo componente

Per disattivare l'inizializzazione automatica per un singolo componente, rimuovi la voce <meta-data> per l'inizializzazione del componente in questione dal file manifest.

Ad esempio, l'aggiunta di quanto segue al file manifest disattiva l'inizializzazione automatica per 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>

Utilizza tools:node="remove" nella voce invece di rimuoverla semplicemente per assicurarti che lo strumento di unione rimuova la voce anche da tutti gli altri file manifest uniti.

Disattiva l'inizializzazione automatica per tutti i componenti

Per disabilitare del tutto l'inizializzazione automatica, rimuovi l'intera voce relativa a InitializationProvider dal file manifest:

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

Chiama manualmente gli inizializzatori dei componenti

Se l'inizializzazione automatica è disabilitata per un componente, puoi usare AppInitializer per inizializzare manualmente il componente e le sue dipendenze.

Ad esempio, il codice seguente chiama AppInitializer e inizializza manualmente ExampleLogger:

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

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

Di conseguenza, Avvio app inizializza anche WorkManager perché WorkManager è una dipendenza di ExampleLogger.

Fornisci feedback

Condividi il tuo feedback e le tue idee con noi attraverso queste risorse:

Issue Tracker

Segnala i problemi per consentirci di correggerli.