Tengo las siguientes definiciones:
@Module class WeaverDataModule { // Provide the three pumps from providers // All of them still explicitly mark 'Pump' as their return type @Provides @IntoSet fun providesPump(thermosiphon: Thermosiphon) : Pump = thermosiphon @Provides @IntoSet fun providesAnotherPump(suctionBased: SuctionBased) : Pump = suctionBased @Provides @IntoSet fun providesGenericPump(genericPump: GenericPump) : Pump = genericPump } @Component(modules = [WeaverDataModule::class]) interface WeaverData { // Get the CoffeeMaker fun coffeeMaker(): CoffeeMaker // Get the list of pumps fun getPumps() : Set<Pump> } interface Pump // The three pumps class Thermosiphon @Inject constructor(val heater: Heater) : Pump class SuctionBased @Inject constructor() : Pump class GenericPump @Inject constructor() : Pump // Some random heater class Heater @Inject constructor()En mi código, cuando hago lo siguiente:
val cm = DaggerWeaverData.builder().build().getPumps()Obtengo las tres bombas como se esperaba. Sin embargo, cuando intento inyectarlo en alguna otra clase:
class CoffeeMaker @Inject constructor( private val heater: Heater, private val pump: Set<Pump> ) { fun makeCoffee() = "Making coffee with heater ${heater::class.java} and using pumps" + " ${pump.map { it::class.java }.joinToString(",")}" }Obtuve el siguiente error:
e: .../WeaverData.java:7: error: [Dagger/MissingBinding] java.util.Set<? extends weaver.Pump> cannot be provided without an @Provides-annotated method. public abstract interface WeaverData { ^ java.util.Set<? extends weaver.Pump> is injected at weaver.CoffeeMaker(…, pump) weaver.CoffeeMaker is provided at weaver.WeaverData.coffeeMaker() También intenté inyectar Collection<Pump> , pero sigo recibiendo un error similar. En los documentos de dagger sobre multibinding , el ejemplo (en Java) muestra lo siguiente:
class Bar { @Inject Bar(Set<String> strings) { assert strings.contains("ABC"); assert strings.contains("DEF"); assert strings.contains("GHI"); } }que es exactamente lo que estoy haciendo. Y para la inyección basada en el constructor, funciona bien en Kotlin, porque lo siguiente se compila y ejecuta como se esperaba:
class CoffeeMaker @Inject constructor( private val heater: Heater ) { fun makeCoffee() = "Making coffee with heater ${heater::class.java}" }Así que no sé cómo hago para que funcione este enlace múltiple.
Entonces resulta que lo que tienes que hacer es:
class CoffeeMaker @Inject constructor( private val heater: Heater, private val pumps: Set<@JvmSuppressWildcards Pump> ) { fun makeCoffee() = "Making coffee with heater ${heater::class.java} with pumps ${pumps.map { it::class.java }.joinToString(",")}" } Esto se debe a que Set se define en Kotlin como Set<out E> , que se traduce en Java como Set<? extends Pump> . Desde la perspectiva de la teoría de tipos, Set<? extends Pump> es diferente de Set<Pump> y, por lo tanto, Dagger (probablemente) se niega a ver a Set<Pump> como un inyectable para Set<? extends Pump> , que es justo y el comportamiento correcto.
El problema que tenemos es que para cualquiera de estas colecciones, dado que son inmutables por defecto, una declaración de tipo Set<X> se traducirá a Set<? extends X> , ya que una colección inmutable solo tiene referencias al tipo resuelto en las devoluciones y, por lo tanto, es covariante. Para verificar esta teoría, lo siguiente también funciona:
class CoffeeMaker @Inject constructor( private val heater: Heater, private val pumps: MutableSet<Pump> ) { fun makeCoffee() = "Making coffee with heater ${heater::class.java} with pumps ${pumps.map { it::class.java }.joinToString(",")}" } Tenga en cuenta el uso de MutableSet , que se define como MutableSet<E> : Set<E> ... . Esto probablemente no sea algo que uno deba usar porque dudo que este conjunto sea realmente mutable. Entonces, lo que necesitamos es que el compilador de kotlin trate Set<out E> como Set<E> (la capacidad de asignación es válida en este caso, pero no al revés). Entonces hágalo, usamos la anotación @JvmSuppressWildcards . Espero que esto ayude a alguien más que enfrenta problemas similares.