Kaj je dependency injection v Androidu (Hilt, Dagger)?

Question

Accepted Answer

**Dependency injection (DI)** je vzorec, pri katerem objekti prejmejo svoje odvisnosti od zunaj, namesto da bi jih ustvarili sami — kar izboljšuje testabilnost, vzdrževljivost in fleksibilnost. V Androidu je **Hilt** (zgrajen na Daggerju) priporočeni DI okvir.

## Kaj je DI in zakaj

```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 — priporočeni Android DI okvir

```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 skrbi za ustvarjanje in zagotavljanje odvisnosti (s pravilnim obsegom/življenjskim ciklom), kar zmanjšuje ročno povezovanje in boilerplate kodo.

## Zakaj je DI pomemben za arhitekturo

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

## Zakaj je to pomembno

Razumevanje dependency injection je važna znanja na ravni starejšega razvijalca, ker je to **ključni vzorec za testabilno, vzdržljivo Android arhitekturo**, in ker je Hilt priporočeni okvir, je to dragoceno za kakovosten Android razvoj.

Osnovni koncept — objekti **prejemajo svoje odvisnosti od zunaj**, namesto da bi jih sami ustvarili — prinaša pomembne prednosti: najpomembnejše je **testabilnost** (v testih lahko injicirate mock-e ali napačne implementacije, kar omogoča izolirano enote testiranje — glavna prednost, ker razredi, ki sami ustvarjajo odvisnosti, so težko testabilni), poleg tega **odpravljanje sklopitve** (razredi niso odvisni od konkretnih implementacij), fleksibilnost (enostavna zamenjava implementacij) in centralizirano upravljanje odvisnosti.

Razumevanje **Hilta** (priporočenega Android DI okvira, zgrajenega na Daggerju) — kako avtomatično ustvari, zagotavlja in obsega odvisnosti, kar zmanjšuje ročno povezovanje — je praktično znanje za implementacijo DI v sodobnem Androidu.

Razumevanje **zakaj je DI pomemben za arhitekturo** je ključni vpogled: deluje v tandemu z vzorci, kot je MVVM (injiciranje repozitorijev v ViewModele, virov podatkov v repozitorije), da ustvarite **čiste, razdvojene, testabilne sloje** — kar naredi DI bistveno za gradnjo dobro arhitektuiranih, testabilnih aplikacij, ki jih priporočena Android arhitektura cilja.

Pravilno **obseganje** (upravljanje življenjskih ciklov odvisnosti) in zmanjšana boilerplate koda (v primerjavi z ročnim DI) naredi Hilt praktičen.

DI je temelj profesionalne Android arhitekture, ker omogoča testabilnost in odpravljanje sklopitve, ki jo zahtevajo vzdržljive aplikacije.

Ker je DI ključni vzorec za testabilno, vzdržljivo arhitekturo (njegova prednost testabilnosti je osrednja za dober Android razvoj) in ker je Hilt priporočeni okvir, ki to naredi praktično, in ker je razumevanje DI in Hilta važno za gradnjo dobro arhitektuiranih, testabilnih aplikacij, je razumevanje dependency injection v Androidu važna znanja na ravni starejšega razvijalca — temelj profesionalne Android arhitekture, ki omogoča testabilnost in odpravljanje sklopitve, deluje z vzorci, kot je MVVM, za gradnjo vzdržljivih aplikacij, in odraža arhitekturno sofisticiranost, ki se pričakuje za starejše Android vloge.