Este artigo é o resultado de uma pesquisa, cujo subproduto foi a personificação de uma ideia de longa data em um aplicativo Android muito útil e que faltava uma vez - o My Location Notifier , projetado para notificar automaticamente o destinatário da chegada de um usuário (consulte a descrição detalhada por referência ).Então,
na primeira parte, construímos o esqueleto principal do aplicativo Android de acordo com a arquitetura MVP. Agora vamos começar a aparafusar o Dagger 2 nele.
2.1 PredefiniçãoPara começar, acesse o arquivo build.gradle (Projeto: mymvcapp) e inclua a seguinte linha na seção buildscript:
ext.dagger2_version = "2.8"
No momento da redação deste artigo, esta é a versão mais recente do Dagger 2. Em seguida, acesse o arquivo build.gradle (Módulo: app) e adicione a linha ao início:
apply plugin: 'kotlin-kapt'
Isso é necessário para que no Dagger 2 ele possa gerar seu código na compilação. Mais tarde você entenderá o porquê.
Agora adicione as dependências necessárias:
implementation "com.google.dagger:dagger:$dagger2_version" kapt "com.google.dagger:dagger-compiler:$dagger2_version"
2.2 Preparação de injeçãoVamos sincronizar o projeto e retornar ao componente MainScreen. Crie uma classe di.MainScreenModule no pacote de bastidores e marque-a com a anotação
Módulo . Na nova classe, declaramos e implementamos o método fornecePresenter (): MainScreenPresenter = MainScreenPresenter e o marcamos com anotações
Fornece e
Singleton . Então agora nossa classe terá a seguinte aparência:
@Module class MainScreenModule { @Provides @Singleton fun providesPresenter(): MainScreenPresenter = MainScreenPresenter() }
Agora iremos para a classe MainScreenCompatActivity e substituiremos os modificadores da variável apresentador por lateinit var, excluiremos a atribuição de valor e marcaremos com a anotação
Inject :
class MainScreen : BaseCompatActivity(), MainScreenContract.View { @Inject lateinit var presenter: MainScreenPresenter override fun init(savedInstanceState: Bundle?) { setContentView(R.layout.activity_main_screen) presenter.attach(this) } }
Observe que agora não precisamos de um ponto de interrogação ao acessar esta variável.
Pode parecer que tudo está injetado, a tarefa está concluída. Mas não. Agora precisamos que o Dagger gere o código necessário para injetar nossa primeira dependência. Por isso, adicionamos o plugin kotlin-kapt ao script de construção acima. No pacote com.caesar84mx.mymvcapp, crie o pacote di.config no qual criaremos a interface AppDiComponent.
Agora, vamos declarar a interface um componente e um singleton
e um miserável , registrar nosso módulo nele e declarar o método inject (mainScreenActivity: MainScreen) dentro da interface:
@Component( modules = [ MainScreenModule::class ] ) @Singleton interface AppDiComponent { fun inject(mainScreenActivity: MainScreen) }
E agora, você deve finalmente fazer o Dagger gerar todo o código necessário. Para fazer isso, criaremos a classe MyMvpApp no pacote config.di, herdaremos da classe Application, registraremos a classe no AndroidManifest.xml, escrevendo a linha android: name = ". Config.di.MyMvpApp" na tag do aplicativo. Em seguida, declare a variável lateinit var injector: AppDiComponent, defina-a como um setter privado e redefina o método onCreate (). E comece a mágica:
class MyMvpApp: Application() { lateinit var injector: AppDiComponent private set override fun onCreate() { super.onCreate() injector = DaggerAppDiComponent.builder() .mainScreenModule(MainScreenModule()) .build() } }
Como você pode ver, a classe DaggerAppDiComponent ainda não existe, será gerada quando o aplicativo for construído. Bem como a implementação do nosso componente. O nome da turma é composto da palavra "Adaga" + o nome da interface marcada como um componente. O método mainScreenModule () também será gerado durante a construção do projeto. O nome deve ser composto pelo nome da classe do módulo injetado em lowerCamelCase.
Montamos o projeto (Compilar → Criar projeto). Aproveite a geração automática de código e continue.
2.3 InjeçãoAtenção: além disso, serão apresentadas algumas danças com pandeiro com elementos pornográficos. A solicitação para remover crianças e pessoas nervosas da tela.
Para injeções bem-sucedidas, precisaremos de uma referência à variável do injetor. Concorde, criar uma instância do MyMvpApp em cada classe em que injetamos não é a melhor solução. Portanto, faremos o seguinte:
class MyMvpApp: Application() { lateinit var injector: AppDiComponent private set override fun onCreate() { super.onCreate() INSTANCE = this injector = DaggerAppDiComponent.builder() .mainScreenModule(MainScreenModule()) .build() } companion object { private var INSTANCE: MyMvpApp? = null @JvmStatic fun get(): MyMvpApp = INSTANCE!! } }
Exalado, retornado à classe MainScreen. Agora, injete nosso apresentador no método init (). Não esqueça que esta ação deve ser executada antes do primeiro acesso à variável injetada. Então agora nossa classe se parece com:
class MainScreen : BaseCompatActivity(), MainScreenContract.View { @Inject lateinit var presenter: MainScreenPresenter override fun init(savedInstanceState: Bundle?) { setContentView(R.layout.activity_main_screen) MyMvpApp.get().injector.inject(this) presenter.attach(this) } }
E aqui está toda a estrutura básica de nossa aplicação:
2.4 ConclusãoPortanto, estamos prontos para a estrutura mínima do aplicativo, na qual resta apenas pendurar os elementos. Precisa de uma nova atividade? Representamos isso como um componente, separando a interface do usuário dos bastidores, para cada componente determinamos quais dependências precisamos (mínimo, o apresentador em atividade ou talvez no próprio apresentador a API para interagir com um serviço remoto ou, por exemplo, a API do repositório para trabalhar com o banco de dados), registre o módulo com dependências, registre o módulo no componente, registre-se no construtor, reconstrua o projeto, injete dependências sempre que necessário, repita a iteração para cada novo componente.
Obviamente, a questão pode surgir: por que precisamos do Dagger? Afinal, eles fizeram um excelente trabalho, certo? Ótimo, enquanto o aplicativo é pequeno. Quando crescer, com dezenas de atividades, fragmentos, adaptadores, solicitações de servidor, armazenamento em cache de dados e outras maravilhas, haverá muitas dependências que são difíceis de rastrear em um aplicativo grande, se você não usar a Injeção de Dependência. A estrutura DI do Dagger ajuda a simplificar a tarefa de implementá-los e rastreá-los.