Pourquoi devrait-on utiliser l'annotation @Binds plutôt que l'annotation @Provides?

L'annotation @Binds est utilisée pour indiquer à Dagger quelle implémentation spécifique d'une interface il doit fournir lorsque l'interface elle-même est demandée.

Les avantages d'utiliser @Binds plutôt que @Provides dans ce cas sont :

• Performance : @Binds est plus performant, car Dagger génère moins de code. Il relie simplement l'interface à un type concret sans créer une nouvelle instance du module.
• Lisibilité : Le code devient plus clair, car il est évident quelle classe implémente quelle interface.
• Réduction du boilerplate : En utilisant @Binds, il n'est pas nécessaire d'écrire une méthode supplémentaire avec @Provides qui retourne simplement une instance de l'implémentation.

Exemple :

Au lieu de :

@Module
class MyModule {

    @Provides
    fun provideMyInterface(implementation: MyInterfaceImpl): MyInterface {
        return implementation;
    }
}

interface MyInterface {
    // ...
}

class MyInterfaceImpl : MyInterface {
    // ...
}

Il est préférable d'utiliser :

@Module
abstract class MyModule { // Le module doit être abstrait

    @Binds
    abstract fun bindMyInterface(implementation: MyInterfaceImpl): MyInterface; // La méthode doit être abstraite

}

interface MyInterface {
    // ...
}

class MyInterfaceImpl : MyInterface {
    // ...
}

L'annotation @Provides reste nécessaire pour fournir des objets qui ne sont pas des implémentations d'interfaces ou qui nécessitent une logique d'instanciation plus complexe (par exemple, créer des objets via des constructeurs, fournir des objets de bibliothèques externes, fournir des dépendances qui ne peuvent pas être injectées via le constructeur).