Work Manger injection with dagger assisted inject and dagger multi binding

Question

No able to provide Map in assisted inject:

Worker:

    class SyncWorker @AssistedInject constructor(
    @Assisted appContext: Context,
    @Assisted workerParams: WorkerParameters,
    val storeCurrencyData: StoreCurrencyData,
    val requestCurrency: RequestCurrency
) :
    RxWorker(appContext, workerParams) {

    override fun createWork(): Single<Result> {
        return requestCurrency.execute(RequestCurrency.Request("abcd"))
            .singleOrError()

            .flatMap {
                return@flatMap when (it) {
                    is Failure -> Single.just(Result.success())
                    is Progress -> Single.just(Result.success())
                    is Success -> storeCurrencyData.execute(StoreCurrencyData.Request(it.value))
                        .singleOrError().map {
                            Result.success()
                        }
                }

            }
    }

    @AssistedFactory
    interface Factory : ChildWorkerFactory<SyncWorker>{

        override fun  create(appContext: Context, workerParams: WorkerParameters): SyncWorker
    }
}

ChildWorkerFactory

    interface ChildWorkerFactory< RxWorker>{
    fun  create (appContext: Context,workerParams: WorkerParameters ): androidx.work.RxWorker
}

SampleWorkerFactory

    class SampleWorkerFactory @Inject constructor(
    private val workerFactories: Map<Class<RxWorker>, @JvmSuppressWildcards Provider<ChildWorkerFactory<RxWorker>>>
) : WorkerFactory() {
    override fun createWorker(
        appContext: Context,
        workerClassName: String,
        workerParameters: WorkerParameters
    ): ListenableWorker? {
        val foundEntry =
            workerFactories.entries.find { Class.forName(workerClassName).isAssignableFrom(it.key) }
        val factoryProvider = foundEntry?.value
            ?: throw IllegalArgumentException("unknown worker class name: $workerClassName")
        return factoryProvider.get().create(appContext, workerParameters)
    }
}

WorkerBindingModule

    @Module
interface WorkerBindingModule {

    @Binds
    fun bindWorkerFactory(sample: SampleWorkerFactory): WorkerFactory

    @Binds
    @IntoMap
    @WorkerKey(SyncWorker::class)
    fun bindHelloWorldWorker(factory: SyncWorker.Factory): ChildWorkerFactory<SyncWorker>

    @MapKey
    @Target(AnnotationTarget.FUNCTION)
    @Retention(AnnotationRetention.RUNTIME)
    annotation class WorkerKey(val value: KClass<out RxWorker>)


}

Application

class App : Application(), HasAndroidInjector {

    companion object {

        var instance: App = App()
    }

    var isWorkManagerStarted: Boolean = false

    @Inject
    lateinit var context: Context

    @Inject
    lateinit var dispatchingAndroidInjector: DispatchingAndroidInjector<Any>
    @Inject lateinit var workerFactory: SampleWorkerFactory
    override fun onCreate() {
        DaggerAppComponent.builder().applicationBind(this).build().inject(this)
        super.onCreate()
        WorkManager.initialize(this, Configuration.Builder().setWorkerFactory(workerFactory).build())
        registerActivityLifecycleCallbacks(this)
    }

    
    override fun androidInjector(): AndroidInjector<Any> = dispatchingAndroidInjector
  
}

AppComponent

 @Component(
    modules = [ActivityBindingModule::class,
        AndroidInjectionModule::class,
        NetworkModule::class,
        AppModule::class,
        WorkerBindingModule::class,
        AndroidSupportInjectionModule::class,
       ],
)
interface AppComponent {

    fun inject(application: App)

    @Component.Builder
    interface Builder {

        fun build(): AppComponent

        @BindsInstance
        fun applicationBind(application: App): Builder
    }
}

Error:

error: [Dagger/MissingBinding] java.util.Map<java.lang.Class<androidx.work.RxWorker>,javax.inject.Provider<com.techcrunches.paypay.workmanagers.ChildWorkerFactory<androidx.work.RxWorker>>> cannot be provided without an @Provides-annotated method.