Inicialização do app Parte do Android Jetpack.

A biblioteca App Startup fornece uma maneira simples e eficiente de inicializar na inicialização do aplicativo. Desenvolvedores de bibliotecas e de apps pode usar a inicialização do app para simplificar as sequências de inicialização e definir explicitamente a ordem de inicialização.

Em vez de definir provedores de conteúdo separados para cada componente, você precisa inicializar, o recurso "Inicialização do aplicativo" permite definir inicializadores de componentes que compartilham uma um único provedor de conteúdo. Isso melhora significativamente o tempo de inicialização do app.

Configurar

Para usar o Jetpack Startup na sua biblioteca ou app, adicione o seguinte ao arquivo arquivo:

Groovy

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

Kotlin

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

Inicializar componentes na inicialização do app

Os aplicativos e bibliotecas geralmente dependem de ter componentes inicializados imediatamente quando o app é iniciado. Você pode atender a essa necessidade usando provedores de conteúdo para inicializam cada dependência, mas é caro instanciar os provedores de conteúdo e pode desacelerar a sequência de inicialização desnecessariamente. Além disso, o Android inicializa provedores de conteúdo em uma ordem indeterminada. A inicialização do app oferece melhor desempenho de inicializar componentes na inicialização do aplicativo e explicitamente definir as dependências.

Para usar a inicialização do app para definir componentes automaticamente na inicialização, você precisa: defina um inicializador de componente para cada componente que o aplicativo precisa inicializar.

Implementar inicializadores de componentes

Você define cada inicializador de componente criando uma classe que implementa o Initializer<T>. Essa interface define dois métodos importantes:

  • O método create(), que contém todas as operações necessárias para inicializar o componente e retorna uma instância de T.
  • O método dependencies(), que retorna uma lista dos outros Objetos Initializer<T> de que o inicializador depende. Você pode usar isso para controlar a ordem em que o app executa os inicializadores na inicialização.

Por exemplo, suponha que seu aplicativo dependa WorkManager e precisa inicializá-lo na inicialização. Defina uma classe 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();
    }

}

O método dependencies() retorna uma lista vazia porque WorkManager não dependem de outras bibliotecas.

Suponha que seu app também dependa de uma biblioteca chamada ExampleLogger, que, depende de WorkManager. Essa dependência significa que você precisa garantir a inicialização do app vai inicializar o WorkManager primeiro. Defina um A classe 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 você incluiu WorkManagerInitializer no método dependencies(), os apps A inicialização inicializa WorkManager antes de ExampleLogger.

Configurar entradas do manifesto

A inicialização do app inclui um provedor de conteúdo especial chamado InitializationProvider usada para descobrir e chamar os inicializadores do seu componente. Inicialização do app descobre inicializadores de componente verificando primeiro uma entrada <meta-data> na entrada InitializationProvider do manifesto. Em seguida, a inicialização do app chama o método dependencies() para qualquer inicializador que ele já tenha descoberto.

Isso significa que, para que um inicializador de componente seja detectável pelo aplicativo, Inicialização, uma das seguintes condições precisa ser atendida:

  • O inicializador do componente tem uma entrada <meta-data> correspondente na InitializationProvider.
  • O inicializador de componente é listado no método dependencies() de uma que já é detectável.

Considere novamente o exemplo com WorkManagerInitializer e ExampleLoggerInitializer. Para garantir que a Inicialização do app possa descobrir esses inicializadores, adicione o seguinte ao arquivo de manifesto:

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

Não é necessário adicionar uma entrada <meta-data> para WorkManagerInitializer. porque WorkManagerInitializer é uma dependência de ExampleLoggerInitializer. Isso significa que, se ExampleLoggerInitializer for detectável, o mesmo será WorkManagerInitializer.

O atributo tools:node="merge" garante que a combinação de manifestos ferramenta resolve corretamente todas as entradas conflitantes.

Executar verificações de lint

A biblioteca App Startup inclui um conjunto de regras de lint que podem ser usadas para verificar mesmo que você tenha definido os inicializadores do componente corretamente. É possível realizar essas verificações de lint executando ./gradlew :app:lintDebug na linha de comando.

Inicializar componentes manualmente

Normalmente, ao usar a inicialização do app, o objeto InitializationProvider usa uma entidade chamada AppInitializer para descobrir e executar automaticamente inicializadores de componentes na inicialização do aplicativo. No entanto, também é possível usar AppInitializer diretamente para fazer isso manualmente para inicializar componentes que seu app não precisa na inicialização. Isso é chamado inicialização lenta e pode ajudar a minimizar os custos de inicialização.

Primeiro, desative a inicialização automática de todos os componentes que quiser sejam inicializados manualmente.

Desativar a inicialização automática para um componente individual

Para desativar a inicialização automática de um único componente, remova o elemento Entrada <meta-data> para o inicializador desse componente no manifesto.

Por exemplo, adicionar o seguinte ao arquivo de manifesto desativa o controle Inicialização 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>

Use tools:node="remove" na entrada em vez de simplesmente remover a entrada para garantir que a ferramenta de combinação também remova a entrada de todas as outras arquivos de manifesto mesclados.

Desativar a inicialização automática para todos os componentes

Para desativar toda a inicialização automática, remova a entrada inteira de InitializationProvider do manifesto:

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

Chamar manualmente inicializadores de componentes

Se a inicialização automática estiver desativada para um componente, será possível usar AppInitializer para inicializar manualmente esse componente e as dependências dele.

Por exemplo, o código a seguir chama AppInitializer e inicializa manualmente ExampleLogger:

Kotlin

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

Java

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

Como resultado, a inicialização do app também inicializa WorkManager porque WorkManager está uma dependência de ExampleLogger.

Enviar feedback

Envie comentários e ideias usando os recursos abaixo:

Issue tracker
Informe os problemas para que possamos corrigir os bugs.
.