Apa itu dependency injection di Android (Hilt, Dagger)?

Question

Accepted Answer

**Dependency injection (DI)** adalah pola di mana objek menerima dependensi mereka dari luar daripada membuatnya sendiri — meningkatkan testability, maintainability, dan flexibility. Di Android, **Hilt** (dibangun di atas Dagger) adalah framework DI yang direkomendasikan.

## Apa itu DI dan mengapa

```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 — framework DI Android yang direkomendasikan

```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 menangani pembuatan dan penyediaan dependensi (dengan proper scoping/lifecycles), mengurangi boilerplate wiring manual.

## Mengapa DI penting untuk arsitektur

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

## Mengapa ini penting

Memahami dependency injection adalah pengetahuan level senior yang penting karena ini adalah **pola kunci untuk arsitektur Android yang testable dan maintainable**, dan Hilt adalah framework yang direkomendasikan, sehingga valuable untuk pengembangan Android berkualitas.

Konsep inti — objek **menerima dependensi mereka dari luar** daripada membuatnya sendiri — memberikan manfaat signifikan: paling penting **testability** (Anda bisa inject mock atau fake dalam test, enabling isolated unit testing — manfaat utama, karena class yang membuat dependensi mereka sendiri sulit untuk di-test), ditambah **decoupling** (class tidak depend pada concrete implementation), flexibility (mudah swap implementation), dan centralized dependency management.

Memahami **Hilt** (framework DI Android yang direkomendasikan, dibangun di atas Dagger) — bagaimana cara otomatis membuat, menyediakan, dan scope dependensi, mengurangi boilerplate wiring manual — adalah pengetahuan praktis untuk mengimplementasikan DI di Android modern.

Memahami **mengapa DI penting untuk arsitektur** adalah insight kunci: ini bekerja hand-in-hand dengan pola seperti MVVM (inject repository ke ViewModel, data source ke repository) untuk membuat **layer yang clean, decoupled, testable** — membuat DI essential untuk membangun app yang well-architected dan testable seperti yang ditargetkan recommended Android architecture.

Proper **scoping** (managing dependency lifecycles) dan reduced boilerplate (vs manual DI) membuat Hilt praktis.

DI adalah cornerstone dari professional Android architecture karena enable testability dan decoupling yang required app maintainable.

Karena DI adalah pola kunci untuk arsitektur testable dan maintainable (manfaat testability-nya sentral untuk Android development yang baik) dan Hilt adalah framework yang direkomendasikan yang membuatnya praktis, dan karena memahami DI dan Hilt penting untuk membangun app well-architected dan testable, memahami dependency injection di Android adalah pengetahuan level senior yang penting — cornerstone dari professional Android architecture yang enable testability dan decoupling, bekerja dengan pola seperti MVVM untuk membangun app maintainable, dan reflecting architectural sophistication yang expected untuk senior Android roles.