7 passos para implementar o Dagger 2 no Android

Anitaa Murthy Blocked Unblock Seguir Seguindo 23 de dezembro de 2018 Créditos da Imagem: https://unsplash.com/photos/crs2vlkSe98

Então eu finalmente tive a chance de explorar o novo Dagger 2 em um projeto recentemente. E embora existam muitos recursos on-line sobre o que é Dagger e por que o dagger 2 é necessário e como implementar o Dagger 2 , descobri que havia uma curva de aprendizado íngreme para ele. Embora eu tenha entendido por que o punhal 2 não é apenas necessário, mas necessário em alguns casos, achei a implementação prática difícil. Então eu pensei em escrever sobre as 7 etapas básicas para implementar o Dagger 2 em um aplicativo Android.

Nota: Este artigo enfoca a implementação do punhal usando a nova injeção android do punhal.

Eu escolhi construir um aplicativo de filmes simples para testar a implementação do punhal. Este é o aplicativo.

Este aplicativo exibe uma lista de filmes ou programas de TV da famosa API do TMDB . Há uma página de detalhes que exibe os vídeos do filme ou do programa de TV, as resenhas, as informações do elenco e da equipe, etc. Vamos criar uma versão simplificada deste aplicativo. Ou seja, vamos nos concentrar na criação de um aplicativo de tela única que busca uma lista de filmes da API do TMDB e a exibe no aplicativo.

Para aqueles de vocês interessados em pular o artigo, o link do GitHub é que esta implementação está aqui.

  • O ramo mestre – código em Java
  • O ramo kotlin_support – código em Kotlin

Então vamos começar!

Etapa 1: adicione as dependências necessárias ao aplicativo

Java:

Kotlin:

Acrescente suporte a kotlin primeiro em build.gradleapp / build.gradle

Etapa 2: Configurar sala

A próxima coisa que temos que fazer é configurar o banco de dados do Room no aplicativo. Isso involve:

1. Criando uma Entidade :

MovieEntity.java:

MovieEntity.kt:

2. Criando a classe Dao:

MovieDao.java:

MovieDao.kt:

3. Criando o banco de dados:

AppDatabase.java:

AppDatabase.kt:

Nota: Se você quiser saber mais sobre a Biblioteca de persistência da sala e como configurá-la, confira este artigo

Etapa 3: configurar o serviço Api:

Agora que configuramos o banco de dados local, precisamos configurar o sistema de serviço da API. Vamos usar Retrofit para isso. Isso involve:

1. Criando um modelo de resposta api:

MovieApiResponse.java:

MovieApiResponse.kt:

2. Criando um serviço de api de descanso:

MovieApiService.java:

MovieApiService.kt:

Etapa 4: Configurar a classe Repository

As classes de repositório são responsáveis por manipular as operações de dados. Por exemplo, na primeira vez em que o aplicativo é aberto, os dados serão buscados no serviço da API de back-end e armazenados localmente na sala. Mas se não houver internet ou o serviço da API estiver inativo, os dados serão buscados no cache local. Portanto, essa classe escolherá quais fontes de dados usar para obter os dados.

MovieRepository.java:

MovieRepository.kt:

Etapa 5: Configurar a classe ViewModel

Como mencionado no passo anterior:

  • A classe de repositório é responsável por buscar os dados (da API da web ou do cache local).
  • O ViewModel é responsável por atualizar a interface do usuário com as alterações de dados. O ViewModel inicializará uma instância da classe Repository e atualizará a UI baseada nesses dados.

Para isso, o ViewModel deve ter acesso ao uso da classe MovieDao e da classe MovieApiService . É aqui que entra o Dagger . MovieDao o ViewModel com a classe MovieDao e a classe MovieApiService .

Agora, vamos configurar a classe ViewModel.

MovieListViewModel.java:

MovieListViewModel.kt:

Passo 5: Configure o Dagger (finalmente!)

Agora vamos criar algumas classes do Dagger.

Em Dagger, podemos anotar classes com @Module . Essas classes são responsáveis por fornecer objetos / classes que podem ser injetados. Essas classes podem definir métodos anotados com @ Provides . Os objetos retornados desses métodos estão disponíveis para injeção de dependência.

Portanto, no nosso caso, precisamos injetar duas classes: MovieDao class e MovieApiService class. Então, vamos criar dois módulos: ApiModule e DbModule (isso pode ser feito em um único módulo, mas eu prefiro manter o serviço local e web separado).

1. classe ApiModule

ApiModule.java

ApiModule.kt

2. Classe DbModule

DbModule.java

DbModule.kt

3. Classe ViewModelFactory:

Agora precisamos injetar esses dois módulos em nosso ViewModel . ViewModelFactory classe ViewModelFactory basicamente ajuda você a criar dinamicamente ViewModels para suas atividades e fragmentos. A classe ViewModelFactory tem uma lista de provedores e pode criar qualquer ViewModel que ViewModel vinculado. Fragmentos e Atividades agora podem apenas injetar a fábrica e recuperar seu ViewModel .

ViewModelFactory.java

ViewModelFactory.kt

4. Classe ViewModelKey:

ViewModelKeys ajuda a mapear seus ViewModel classes para ViewModelFactory pode fornecer / injetá-las corretamente.

ViewModelKey.java

ViewModelKey.kt

4. Classe ViewModelModule

O ViewModelModule é usado para fornecer um mapa de modelos de exibição por meio do dagger usado pela classe ViewModelFactory .

ViewModelModule.java

ViewModelModule.kt

Então, basicamente,

  • Podemos usar o ViewModelModule para definir nossos ViewModels .
  • Nós fornecemos uma chave para cada ViewModel usando a classe ViewModelKey .
  • Em seguida, em nosso Activity / Fragment, usamos a classe ViewModelFactory para injetar o ViewModel correspondente. (Vamos olhar mais detalhadamente para isso quando estamos criando nossa atividade).

5. classe ActivityModule

Como estamos usando a biblioteca de suporte dagger-android , podemos usar o Android Injection. O ActivityModule gera o AndroidInjector (essa é a nova classe dagger-android que existe no framework dagger-android) para Atividades definidas nesta classe. Isso nos permite injetar coisas em Atividades usando o AndroidInjection.inject(this) no método onCreate() .

ActivityModule.java

ActivityModule.kt

Nota: Podemos definir todas as atividades que requerem injeção. Por exemplo, no nosso caso, isso gerará o AndroidInjector<MainActivity> .

6. Classe AppComponent

Qualquer classe com a anotação @Component define a conexão entre os módulos e as classes que precisam da dependência. Definimos uma interface @Component.Builder que será chamada a partir de nossa classe Application customizada. Isso definirá nosso objeto de aplicativo para o AppComponent . Então, dentro do AppComponent a instância do aplicativo está disponível. Portanto, essa instância de aplicativo pode ser acessada por nossos módulos, como o ApiModule quando necessário.

AppComponent.java

AppComponent.kt

Etapa 6: Configurar classe de aplicativo

Então agora nós criamos uma classe Application customizada em nosso projeto.

AppController.java

AppController.kt

Nota: Não se esqueça de adicionar essa classe de aplicativo personalizada ao AndroidManifest.xml

 <aplicação 
android: name = ". AppController"
android: allowBackup = "true"
android: icon = "@ mipmap / ic_launcher"
android: label = "@ string / app_name"
android: roundIcon = "@ mipmap / ic_launcher_round"
android: supportsRtl = "true"
android: theme = "@ style / AppTheme" />

Etapa 7: Configurar a classe MainActivity

Então, agora precisamos criar nossa classe Activity.

MainActivity.java

MainActivity.kt

Nota: Eu não estou incluindo a implementação das classes xml ou das classes do adaptador RecyclerView aqui, pois não faz parte do escopo deste artigo. Você pode conferir este projeto do Github para conhecer a implementação detalhada.

E é isso! Nós construímos e executamos nosso aplicativo e esta é a saída que devemos receber.

Nota: Se você gostaria de saber como implementar o BackgroundSwitcherView ou seja, alterar o plano de fundo da atividade quando o recyclerView é rolado, confira este link .

Bônus:

Vimos como injetar o ViewModelFactory em nossa MainActivity . Se você quiser injetar o ViewModelFactory em um Fragment, precisamos fazer as seguintes modificações:

1. Classe FragmentModule:

Crie uma nova classe chamada FragmentModule .

FragmentModule.java

FragmentModule.kt

2. Modifique a classe ActivityModule:

Adicione o FragmentModule recém-criado à atividade que você deseja injetar. ou seja, no nosso caso MainActivity .

ActivityModule.java

ActivityModule.kt

3. Modifique a classe MainActivity:

Precisamos implementar o HasSupportFragmentInjector em nossa Activity se quisermos injetar a classe ViewModelFactory em nosso fragmento. E também, mova toda a nossa implementação de RecyclerView.Adapter e ViewModel para a classe Fragment.

MainActivity.java

MainActivity.kt

4. Adicione a classe MovieFragment:

Por fim, precisamos criar nossa classe Fragment. Nós injetamos o ViewModelFactory no Fragment e inicializamos o viewModel. A implementação restante é a mesma.

MovieListFragment.java

MovieListFragment.kt

5. Adicione a classe FragmentModule ao AppComponent:

 @Componente( 
modules = [
ApiModule :: class ,
DbModule :: class ,
ViewModelModule :: class ,
ActivityModule :: class ,
FragmentModule :: class,
AndroidSupportInjectionModule :: class ]
)

Você pode verificar este commit para descobrir as diferenças entre injetar em Activity e injetar em fragmento para Java e este commit para Kotlin.