Add ability to inject abstract @AssistedInject

I have a use case while I have to inject the abstract class, not the implementation itself, but the implementation requires an assisted parameter to be injected, like this:

class ClassAImpl @AssistedInject constructor(
    @Assisted private val params: ClassAParams
) : ClassA {

    ....

    @AssistedFactory
    interface ClassAFactory {

        fun create(params: ClassAParams): ClassA
    }
}

I got this error:

An assisted factory's abstract method must return a type with an @AssistedInject-annotated constructor.

While it should work fine

[tbroyer]

Just because the ClassAFactory is nested into ClassAImpl does not mean Dagger will extrapolate anything from that: it sees an @AssistedFactory interface whose abstract methods returns a ClassA, whose constructor is (apparently) not annotated with @AssistedInject. Dagger has no means to know that you actually would like that factory to return a ClassAImpl instance rather than any other ClassA subclass (or ClassA itself if not abstract)

Because you don’t inject either ClassA or ClassAImpl instances, but only ClassAFactory, you can declare the method to return ClassAImpl, and then it should Just Work™.

If you don’t want to expose the detail that this will be a ClassAImpl instance, and really want injection points to only know about ClassA, then make an interface for ClassA, and then have the @AssistedFactory extend it and override the method to tighten its return type, and then finally add a binding for those interfaces so Dagger will actually inject a ClassAImplFactory whenever a ClassAFactory is needed:

// This is your "public API"
interface ClassAFactory {
    fun create(params: ClassAParams): ClassA
}

// This is an implementation detail for Dagger
interface ClassAImplFactory : ClassAFactory {
    override fun create(params: ClassParams): ClassAImpl
}

// Add that to your @Module
@Binds fun bindClassAFactory(factory: ClassAImplFactory): ClassAFactory

// This will actually receive a ClassAImplFactory, so create(params) will return a ClassAImpl instance
@Inject lateinit var classAFactory: ClassAFactory

(this should work in theory, but I haven’t tested it, so maybe there are limitations in Dagger that would prevent it from working)

[udamaster]

Yep, got it to work …that was the prob. Thanks