Inicialização de aplicativo: um novo componente de arquitetura

Uma solução simples para diminuir o tempo de inicialização do seu aplicativo

A lição deste artigo

Neste artigo, você aprenderá como e por que precisamos usar o App Startup – a nova biblioteca Jetpack. Você também aprenderá a usar o App Startup Initializer se o aplicativo tiver várias dependências que precisam de provedores de conteúdo e como invocá-los manualmente.

Introdução

Os usuários esperam que os aplicativos sejam responsivos e rápidos. Quando seu aplicativo não atende a esses requisitos básicos, os usuários costumam classificá-lo com avaliações ruins na Play Store ou, pior ainda, podem desinstalar o aplicativo.

De qualquer forma, não é bom para os negócios. Ultimamente, a equipe do Android está focada em fornecer ferramentas melhores como Hilt (para implementar DI), CameraX (para lidar com vários problemas relacionados à câmera) e Paging3 (para implementar paging confortavelmente com o Kotlin Flow).

Agora existe a biblioteca App Startup – uma nova criança no quarteirão. É hora de otimizar o tempo de inicialização do aplicativo. A biblioteca App Startup fornece uma maneira direta e simples de inicializar componentes na inicialização do aplicativo.

Tanto os desenvolvedores de bibliotecas quanto os desenvolvedores de aplicativos podem usar o App Startup para otimizar as sequências de inicialização e definir explicitamente a ordem de inicialização. Isso economizará muito tempo para os desenvolvedores, para que possam se concentrar no que é importante.

Como funciona?

Ambos os aplicativos e bibliotecas contam com os componentes que são criados imediatamente quando o aplicativo é iniciado. Normalmente, isso é feito com provedores de conteúdo e eles são a principal razão por trás do longo tempo de inicialização.

Os provedores de conteúdo são caros e, se você tiver várias bibliotecas no projeto que exijam provedores de conteúdo na inicialização, obviamente o tempo de inicialização do aplicativo será mais longo do que o normal se eles criarem provedores de conteúdo individuais.

Em vez de criar provedores de conteúdo separados para cada componente de que você precisa para inicializar o App Startup, ele permite defini  o componente initializers que compartilham um único provedor de conteúdo. Isso pode melhorar o tempo de inicialização do aplicativo.

Se você já usou provedores de conteúdo para inicializar componentes no aplicativo, certifique-se de removê-los ao implementar o App Startup.

Integração

Para integrar a biblioteca de inicialização do aplicativo em seu projeto, adicione a seguinte linha sob o nó de dependências no arquivo build.gradle de nível de aplicativo:

dependencies {
    implementation "androidx.startup:startup-runtime:1.0.0-alpha01"
}

Inicialização do Componente

Para começar de forma simples, vamos considerar que seu projeto possui apenas uma biblioteca. Agora precisamos definir o inicializador aqui. Dar uma olhada:

class SimpleInitializer: Initializer<OneDependency> {

    override fun create(context: Context): OneDependency {
        val oneDependency: OneDependency = /* Place your configuration logic here*/
        return oneDependency
    }

    override fun dependencies() = emptyList<>()
    
}

Precisamos criar um inicializador para cada componente estendendo com a interface Initializer <T>. Tem duas funções vitais:

• A função create(), que contém todas as operações necessárias para inicializar o componente e retorna uma instância da dependência
• A função dependencies(), que retorna uma lista dos outros objetos Initializer <T> dos quais o Initializer depende. Você pode usar este método para controlar a ordem em que o aplicativo executa os inicializadores na inicialização.

Como não temos várias dependências, estamos retornando uma lista vazia. Agora, vamos ver outro exemplo com várias dependências. Dar uma olhada:

class DependencyOneInitializer: Initializer<DependencyOne> {

    override fun create(context: Context): DependencyOne {
        val dependencyOne: DependencyOne = /* Place your configuration logic here*/
        return dependencyOne
    }

    override fun dependencies(): List<Class<out Initializer<*>>> {
        return listOf(DependencyTwoInitializer::class.java,
                      DependencyThreeInitializer::class.java)
    }
    
}

Se tivermos várias dependências, precisamos criar um inicializador para cada dependência. Na função de dependências, podemos definir a ordem de inicialização das dependências.

Entradas do Manifest

O App StartUp fornece um novo provedor de conteúdo chamado InitializationProvider. Com isso, podemos inicializar automaticamente os componentes mencionando os metadados. Dar uma olhada:

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

Observação: não precisamos mencionar metadados para todos os componentes do manifest. Isso porque, quando mencionamos metadados de dependência de nível superior, o App Startup torna os componentes subjacentes detectáveis.

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

Nem todas as dependências precisam ser chamadas no início do aplicativo, portanto, seria melhor ignorá-las. Para isso, precisamos usar as ferramentas:node= “remove” nos metadados desse componente. Dar uma olhada:

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

Nota: Desativar a inicialização automática para um componente também desativa a inicialização automática para os componentes abaixo dele.

Inicializar manualmente um componente

Se você não quiser inicializar os componentes por meio de metadados no arquivo de manifest, podemos usar manualmente o AppInitializer. Essa opção de inicialização lenta é útil quando queremos invocar um componente de dependência em um determinado momento. Vamos ver como invocar componentes manualmente:

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

É tudo por agora; Espero que você tenha aprendido algo útil. Obrigado pela leitura.