Quelle méthode choisir pour l'injection de dépendances

[lcubeddu]

Pour moi il y a 3 options

• Dagger/Hilt
• Koin
• DI manuelle

Le choix a ultimement assez peu de conséquences étant donné la taille du projet, donc plutôt basse priorité

Pros & Cons

• Dagger/Hilt (wrapper Hilt autour de Dagger 2 pour reduire le boilerplate)
  • Pros
    • Fait pour Android donc adapté au projet
    • Compilé
      • plus performant, mais certainement un impact négligeable pour notre app
    • Solution de DI officielle Google
    • Rapide à mettre en place grâce aux annotations
    • Error handling au moment de la compilation -> Moins de risque d'erreur
  • Cons
    • Fait pour Android donc plus couplé à cet environnement (peut être moins flexible pour les tests, etc)
    • Compilé
      • plus longs temps de Build
      • génération de code
• Koin
  • Pros
    • Utilise beaucoup des feature Kotlin
    • Pas spécifique à android
      • Meilleur pour les tests
    • Injection Runtime
      • Moins de temps de compilation
    • Setup initial facile, peu de boilerplate
  • Cons
    • Runtime errors
      • Beaucoup d'erreurs qui auraient été trouvées de manière statique vont compiler sans problème -> Plus longues itérations
• Manuelle
  • Pros
    • Pas de dépendance sur une librairie
    • Grande flexibilité
    • Tout est dans notre codebase
    • N'herite pas de la complexité d'une librairie
      • Aussi complexe qu'on en a besoin
  • Cons
    • N'herite pas de la complexité d'une librairie
      • Il faut coder les nouvelles feature
    • Bien plus de boilerplate

Examples de la syntaxe

Dagger/Hilt

// Application.kt

@HiltAndroidApp  
class ExampleApplication : Application() { ... }

// .......

// Activity.kt

@AndroidEntryPoint  
class ExampleActivity : AppCompatActivity() { ... }

// ......

// constructor of a class with IOC

class AnalyticsAdapter @Inject constructor(
    private val service: AnalyticsService  
) { ... }

// module with interface injection

@Module
@InstallIn(ActivityComponent::class)
abstract class AnalyticsModule {

  @Binds
  abstract fun bindAnalyticsService(
    analyticsServiceImpl: AnalyticsServiceImpl
  ): AnalyticsService
}

// module with instance injection

@Module
@InstallIn(ActivityComponent::class)
object AnalyticsModule {

  @Provides
  fun provideAnalyticsService(
    // Potential dependencies of this type
  ): AnalyticsService {
      return Retrofit.Builder()
               .baseUrl("https://example.com")
               .build()
               .create(AnalyticsService::class.java)
  }
}

Koin

// Module

class MyService()
class Controller()

val myModule = module {
    // declare single instance for MyService class
    single { MyService() }

    // declare factory instance for Controller class
    factory { Controller() }
}

//......
// Dependency resolution

// Presenter <- Service
class Service()
class Controller(val view : View)

val myModule = module {

    // declare Service as single instance
    single { Service() }
    // declare Controller as single instance, resolving View instance with get()
    single { Controller(get()) }
}

Manuelle

Voir la pull request suivante : https://github.com/XPEHO/XpeApp/pull/84

Notamment, les fichiers XpeApp.kt et AppModule.kt

[lcubeddu]

@mmarchal