O que é injeção de dependência em Android (Hilt, Dagger)?

Question

Accepted Answer

**Injeção de dependência (DI)** é um padrão onde objetos recebem suas dependências de fora em vez de criá-las — melhorando testabilidade, manutenibilidade e flexibilidade. No Android, **Hilt** (construído sobre Dagger) é o framework DI recomendado.

## O que é DI e por que

```text
WITHOUT DI: a class CREATES its own dependencies (tightly coupled, hard to test/change):
  class UserRepo { val api = ApiService() }   // creates its own dependency — rigid
WITH DI: dependencies are PROVIDED from outside (injected):
  class UserRepo(val api: ApiService)          // receives it → flexible, testable
→ Benefits: TESTABILITY (inject mocks/fakes in tests), DECOUPLING, easier to swap
  implementations, centralized dependency management, less boilerplate (with a framework).
```

## Hilt — o framework DI recomendado para Android

```kotlin
// Hilt (built on Dagger) generates/manages dependency wiring for you
@HiltAndroidApp class MyApp : Application()      // set up Hilt

@AndroidEntryPoint class MainActivity : AppCompatActivity() {
  @Inject lateinit var repository: UserRepository  // Hilt INJECTS this automatically
}

// tell Hilt how to provide things
@Module @InstallIn(SingletonComponent::class)
object AppModule {
  @Provides fun provideApi(): ApiService = Retrofit.Builder()...create()
}
```

Hilt cuida de criar e fornecer dependências (com scoping/ciclos de vida apropriados), reduzindo o boilerplate de fiação manual.

## Por que DI importa para arquitetura

```text
✓ TESTABILITY — inject test doubles (mocks/fakes) → unit-test in isolation (the big win)
✓ Works with architecture (MVVM): inject repositories into ViewModels, data sources into
  repositories → clean, decoupled, testable layers
✓ SCOPING — manage dependency lifecycles (singleton, per-activity, etc.)
✓ Less boilerplate than manual DI; standardized; Google-recommended (Hilt)
```

## Por que isso importa

Entender injeção de dependência é conhecimento importante de nível sênior porque é um **padrão-chave para arquitetura Android testável e manutenível**, e Hilt é o framework recomendado, então é valioso para desenvolvimento Android de qualidade.

O conceito central — objetos **recebendo suas dependências de fora** em vez de criá-las — oferece benefícios significativos: mais importante, **testabilidade** (você pode injetar mocks ou fakes em testes, permitindo testes unitários isolados — o maior benefício, já que classes que criam suas próprias dependências são difíceis de testar), além de **desacoplamento** (classes não dependem de implementações concretas), flexibilidade (fácil trocar implementações) e gerenciamento centralizado de dependências.

Entender **Hilt** (o framework DI recomendado para Android, construído sobre Dagger) — como ele cria, fornece e faz escoping automático de dependências, reduzindo o boilerplate de fiação manual — é o conhecimento prático para implementar DI no Android moderno.

Entender **por que DI importa para arquitetura** é o insight-chave: funciona junto com padrões como MVVM (injetando repositórios em ViewModels, fontes de dados em repositórios) para criar **camadas limpas, desacopladas e testáveis** — tornando DI essencial para construir apps bem-arquitetados e testáveis que a arquitetura Android recomendada visa.

O **scoping** apropriado (gerenciando ciclos de vida de dependências) e o boilerplate reduzido (vs DI manual) tornam Hilt prático.

DI é uma pedra angular da arquitetura Android profissional porque permite a testabilidade e o desacoplamento que apps manuteníveis exigem.

Já que DI é um padrão-chave para arquitetura testável e manutenível (sendo seu benefício de testabilidade central para o bom desenvolvimento Android) e Hilt é o framework recomendado que o torna prático, e já que entender DI e Hilt é importante para construir apps bem-arquitetados e testáveis, entender injeção de dependência em Android é conhecimento importante de nível sênior — uma pedra angular da arquitetura Android profissional que permite testabilidade e desacoplamento, funcionando com padrões como MVVM para construir apps manuteníveis, e refletindo a sofisticação arquitetônica esperada para papéis Android sênior.