რა არის dependency injection Android-ში (Hilt, Dagger)?

Question

Accepted Answer

**Dependency injection (DI)** არის ნიმუში, სადაც ობიექტები იღებენ მათ დამოკიდებულებებს გარედან იმის ნაცვლად, რომ თავად შექმნან ისინი — გაუმჯობესებს testability-ს, maintainability-ს და flexibility-ს. Android-ში, **Hilt** (Dagger-ზე აგებული) არის რეკომენდირებული DI framework.

## რა არის DI და რატომ

```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 — რეკომენდირებული Android DI framework

```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 ზრუნავს დამოკიდებულებების შექმნასა და მიწოდებაზე (სათანადო scoping/lifecycles-ით), მცირდება ხელით wiring boilerplate-ი.

## რატომ მნიშვნელოვანია DI არქიტექტურისთვის

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

## რატომ ეს მნიშვნელოვანია

Dependency injection-ის გაგება მნიშვნელოვანი senior-level ცოდნაა, რადგან ეს არის **მთავარი ნიმუში testable, maintainable Android architecture-ისთვის**, და Hilt არის რეკომენდირებული framework, ამიტომ ღირებული ხარისხიანი Android development-ისთვის.

ძირითადი კონცეფცია — ობიექტები **იღებენ მათ დამოკიდებულებებს გარედან** იმის ნაცვლად, რომ შექმნან ისინი — იძლევა მნიშვნელოვან სარგებელს: ყველაზე მნიშვნელოვანი **testability** (შეგიძლიათ ჩანერგოთ mocks ან fakes ტესტებში, რაც საშუალებას იძლევა isolated unit testing-ს — მთავარი სარგებელი, რადგან კლასები, რომლებიც თავიანთ დამოკიდებულებებს ქმნიან, რთული ტესტირებაა), პლუს **decoupling** (კლასები არ არიან დამოკიდებული concrete implementations-ზე), flexibility (ადვილი ამ implementations-ის შეცვლა), და centralized dependency management.

**Hilt**-ის გაგება (რეკომენდირებული Android DI framework, Dagger-ზე აგებული) — თუ როგორ ქმნის, მიწოდებს და scopes-ითგან დამოკიდებულებებს, ხელით wiring boilerplate-ის მცირებას — არის პრაქტიკული ცოდნა DI-ს იმპლემენტაციისთვის თანამედროვე Android-ში.

**რატომ მნიშვნელოვანია DI არქიტექტურისთვის**-ის გაგება არის მთავარი insight: ის მუშაობს ხელუხლებლად ნიმუშებთან, როგორიცაა MVVM (repositories-ის ჩანერგვა ViewModels-ში, data sources repositories-ში), რათა შექმნას **clean, decoupled, testable layers** — DI-ს აუცილებელ აქცევს well-architected, testable apps-ის აგებისთვის, რომელიც რეკომენდირებული Android architecture-ი მიზნად აქვს.

სათანადო **scoping** (dependency lifecycles-ის მართვა) და შემცირებული boilerplate (vs manual DI) აქცევს Hilt-ს პრაქტიკულს.

DI არის პროფესიონალური Android architecture-ის საფუძველი, რადგან ის ხელმისაწვდომს აქცევს testability-ს და decoupling-ს, რომელიც maintainable apps-ს სჭირდება.

მას შემდეგ, რაც DI არის მთავარი ნიმუში testable, maintainable architecture-ისთვის (მისი testability სარგებელი ცენტრალური რომელიმე კარგი Android development-ისთვის) და Hilt არის რეკომენდირებული framework, რაც მას პრაქტიკულს აქცევს, და რადგან DI და Hilt-ის გაგება მნიშვნელოვანია well-architected, testable apps-ის აგებისთვის, dependency injection-ის გაგება Android-ში არის მნიშვნელოვანი senior-level ცოდნა — პროფესიონალური Android architecture-ის საფუძველი, რაც ხელმისაწვდომს აქცევს testability-ს და decoupling-ს, მუშაობს MVVM-ის მსგავს ნიმუშებთან maintainable apps-ის აგებისთვის, და ასახავს არქიტექტურული დახვეწას, რომელიც senior Android roles-ისთვის ელოდება.