Inicio de apps Parte de Android Jetpack.

La biblioteca de App Startup proporciona una forma sencilla y eficaz de inicializar de seguridad cuando se inicia la aplicación. Desarrolladores de bibliotecas y desarrolladores de apps Puede usar App Startup para optimizar las secuencias de inicio y establecer el orden de forma explícita de la inicialización.

En lugar de definir proveedores de contenido independientes para cada componente, debes inicializar, App Startup te permite definir inicializadores de componentes que comparten un único proveedor de contenido. Esto puede acelerar en gran medida el tiempo de inicio de la app.

Configuración

Para usar Jetpack Startup en tu biblioteca o app, agrega lo siguiente a tu Gradle archivo:

Groovy

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

Kotlin

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

Cómo inicializar componentes cuando se inicia la app

Las apps y las bibliotecas a menudo dependen de que los componentes se inicialicen de inmediato cuando se inicia la app. Puedes satisfacer esta necesidad usando proveedores de contenido para inicializan cada dependencia, pero la creación de instancias de los proveedores de contenido es costoso. y puede ralentizar la secuencia de inicio de forma innecesaria. Además, Android inicializa los proveedores de contenido en un orden indeterminado. App Startup proporciona una y con mejor rendimiento de inicializar componentes cuando se abre la app y de manera explícita definen sus dependencias.

Para usar App Startup para inicializar componentes automáticamente en el inicio, debes hacer lo siguiente: definir un inicializador de componentes para cada componente que la app necesite inicializar.

Cómo implementar inicializadores de componentes

Para definir cada inicializador de componentes, crea una clase que implemente el Initializer<T>. Esta interfaz define dos métodos importantes:

  • El método create(), que contiene todas las operaciones necesarias para inicializamos el componente y muestra una instancia de T.
  • El método dependencies(), que muestra una lista de las otras Objetos Initializer<T> de los que depende el inicializador. Puedes usar esta para controlar el orden en el que la app ejecuta los inicializadores en el inicio.

Por ejemplo, supongamos que tu app depende de WorkManager y debe y, luego, inicializarlo al inicio. Define una clase WorkManagerInitializer que implementa Initializer<WorkManager>:

Kotlin

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

Java

// 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();
    }

}

El método dependencies() muestra una lista vacía porque WorkManager no. depender de otras bibliotecas.

Supongamos que tu app también depende de una biblioteca llamada ExampleLogger, que en Girar depende de WorkManager. Esta dependencia significa que debes asegurarte que App Startup inicialice WorkManager primero. Define un Clase ExampleLoggerInitializer que implementa Initializer<ExampleLogger>:

Kotlin

// 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)
    }
}

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);
    }
}

Como incluyes WorkManagerInitializer en el método dependencies(), la app El inicio inicializa WorkManager antes del ExampleLogger.

Cómo configurar entradas del manifiesto

App Startup incluye un proveedor de contenido especial llamado InitializationProvider que usa para descubrir y llamar a los inicializadores de tus componentes. Inicio de apps descubre inicializadores de componentes verificando primero una entrada <meta-data>. en la entrada del manifiesto InitializationProvider. Luego, App Startup llama a dependencies() para cualquier inicializador que ya haya descubierto.

Esto significa que, para que la App pueda detectar el inicializador de un componente, Para el inicio, se debe cumplir una de las siguientes condiciones:

  • El inicializador del componente tiene una entrada <meta-data> correspondiente en el Entrada de manifiesto de InitializationProvider.
  • El inicializador del componente aparece en el método dependencies() de un inicializador que ya es detectable.

Considera nuevamente el ejemplo con WorkManagerInitializer y ExampleLoggerInitializer Para garantizar que App Startup pueda detectar estos inicializadores, agrega lo siguiente al archivo de manifiesto:

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

No es necesario que agregues una entrada <meta-data> para WorkManagerInitializer, porque WorkManagerInitializer es una dependencia de ExampleLoggerInitializer. Esto significa que si ExampleLoggerInitializer es detectable, también lo es WorkManagerInitializer

El atributo tools:node="merge" garantiza que la combinación del manifiesto la herramienta resuelve correctamente cualquier entrada en conflicto.

Cómo ejecutar comprobaciones de lint

La biblioteca de App Startup incluye un conjunto de reglas de lint que puedes usar para comprobar si definiste los inicializadores de componentes correctamente. Puedes realizar estas comprobaciones de lint ejecutando ./gradlew :app:lintDebug desde la línea de comandos.

Inicializa los componentes de forma manual

Por lo general, cuando usas App Startup, el objeto InitializationProvider usa un entidad llamada AppInitializer a descubrir y ejecutar automáticamente inicializadores de componentes cuando se inicia la aplicación. Sin embargo, también puedes usar AppInitializer directamente para inicializar componentes que tu app no necesita en el inicio. Esto se denomina inicialización diferida y puede ayudar a minimizar los costos de inicio.

Primero debes inhabilitar la inicialización automática para los componentes que desees. para inicializarse de forma manual.

Inhabilita la inicialización automática para un componente individual

Para inhabilitar la inicialización automática de un solo componente, quita el elemento Entrada <meta-data> para el inicializador de ese componente desde el manifiesto

Por ejemplo, si agregas lo siguiente al archivo de manifiesto, se inhabilitan las actualizaciones automáticas inicialización de 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>

Usa tools:node="remove" en la entrada en lugar de solo quitarla para asegurarte de que la herramienta de fusión también elimine la entrada de todos los demás archivos de manifiesto combinados.

Inhabilita la inicialización automática para todos los componentes

Para inhabilitar toda la inicialización automática, quita toda la entrada durante InitializationProvider del manifiesto:

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

Cómo llamar manualmente a inicializadores de componentes

Si la inicialización automática está inhabilitada para un componente, puedes usar AppInitializer para inicializar de forma manual ese componente y sus dependencias

Por ejemplo, el siguiente código llama a AppInitializer y se inicializa de forma manual ExampleLogger

Kotlin

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

Java

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

Como resultado, App Startup también inicializa WorkManager porque WorkManager es una dependencia de ExampleLogger.

Envía comentarios

Usa estos recursos para compartir tus comentarios y tus ideas con nosotros:

Herramienta de seguimiento de errores
Informa los problemas para que podamos corregir los errores.