/app/application/AppComponent.java:8: error: [Dagger/MissingBinding] java.util.Map<java.lang.Class<? extends androidx.fragment.app.Fragment>,javax.inject.Provider<app.dagger.fragment.FragmentComponentBuilder<?,?>>> cannot be provided without an @Provides-annotated method.
public abstract interface AppComponent {
               ^
  A binding with matching key exists in component: app.CaComponent
     java.util.Map<java.lang.Class<? extends androidx.fragment.app.Fragment>,javax.inject.Provider<app.dagger.fragment.FragmentComponentBuilder<?,?>>> is injected at
         app.DevicesActivity.fragmentComponentBuilders
     app.DevicesActivity is injected at
         app.application.AppComponent.inject(app.DevicesActivity)
  It is also requested at:
     app.DevicesActivity.fragmentComponentBuilders
  The following other entry points also depend on it:
     dagger.MembersInjector.injectMembers(T) [app.application.AppComponent → app.DevicesActivityComponent]

class DevicesActivity: InjectableActivity(), CaView, HasFragmentSubComponentBuilders{
       [USER=264617]@INJECT[/USER]
       lateinit var fragmentComponentBuilders: Map<Class<out Fragment>, @JvmSuppressWildcards Provider<FragmentComponentBuilder<*, *>>>
 
       var caModel: CaModel? = null
       private val devicesFragment = DevicesFragment.newInstance()
       companion object {
           val kCaModel = "CA_MODEL_KEY"
           fun create(context: Context, caModel: CaModel) : Intent {
               val intent = Intent(context, DevicesActivity::class.java)
               intent.putExtra(kCaModel, caModel)
               return intent
           }
       }
 
       override fun injectActivity(hasActivitySubComponentBuilders: HasActivitySubcomponentBuilders): ActivityComponent<DevicesActivity> {
           val builder = hasActivitySubComponentBuilders.getBuilder(DevicesActivity::class.java)
           val componentBuilder = builder as DevicesActivityComponent.Builder
           val component = componentBuilder.activityModule(DevicesActivityModule())?.build()
           component!!.injectMembers(this)
           return component
       }
 
       override fun onStart(){
           super.onStart()
           supportFragmentManager.beginTransaction().replace(android.R.id.content, devicesFragment).commit()
       }
 
       override fun getBuilder(fragmentClass: Class<out Fragment>): FragmentComponentBuilder<*, *> =
               fragmentComponentBuilders.getValue(fragmentClass).get()
 
       override fun onLoggedOut(wasLoggedOutDueToInactivity: Boolean, wasLoggedOutDueToBadCreds: Boolean) {
       }
   }

@Retention(AnnotationRetention.RUNTIME)
annotation class DevicesScope

@DevicesScope
@Subcomponent(modules = [DevicesActivityModule::class])
interface DevicesActivityComponent : ActivityComponent<DevicesActivity> {

   @Subcomponent.Builder
   interface  Builder : ActivityComponentBuilder<DevicesActivityModule, DevicesActivityComponent>
}

@Module
class DevicesActivityModule : ActivityModule<DevicesActivity>() {
   @Provides
   fun presenter(caSubject: CaSubject, interactor: ST)
           : DevicesPresenter = DevicesPresenter(caSubject, interactor)

   @Provides
   fun interactor(schedulerProvider: SchedulerProvider) : ST =
          ST(schedulerProvider)
}

class DevicesFragment : MvpScopedFragment<DevicesView, DevicesPresenter>(), DevicesView {


   lateinit var binding : DevicesBinding
   private lateinit var adapter : DevicesAdapter
   lateinit var devicesDialog: AlertDialog

   companion object {
       fun newInstance() : DevicesFragment = DevicesFragment()
   }

   override fun inject(hasFragmentSubComponentBuilders: HasFragmentSubComponentBuilders): DevicesPresenter {
       val builder = hasFragmentSubComponentBuilders.getBuilder(DevicesFragment::class.java)
       val componentBuilder = builder as DevicesFragmentComponent.Builder
       val component = componentBuilder.module(DevicesFragmentModule(this)).build()
       return component.presenter()
   }

   override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
       binding = DataBindingUtil.inflate(inflater, R.layout.respec_devices, container, false)
       return binding.root
   }

   override fun onActivityCreated(savedInstanceState: Bundle?) {
       super.onActivityCreated(savedInstanceState)

       presenter.caModel.screen = CaScreen.DEVICES
       presenter.save()
       binding.header.caModel = presenter.caModel
       binding.caModel = presenter.caModel
       presenter.setDelegate()
       if(presenter.pm.hasProfile()) {
           presenter.profile = presenter.pm.getProfile()!!
       }
   }

@Retention(AnnotationRetention.RUNTIME)
annotation class CaScope

@CaScope
@Subcomponent(modules = [CaModule::class, FragmentBindingModule::class])
interface CaComponent : ActivityComponent<CaActivity> {

   fun presenter() : CaPresenter

   @Subcomponent.Builder
   interface Builder : ActivityComponentBuilder<CaModule, CaComponent>

}

interface FragmentComponentBuilder<M : FragmentModule<*>, C : FragmentComponent<*>> {

   fun module(activiyModule: M) : FragmentComponentBuilder<M, C>

   fun build() : C

}

interface ActivityComponentBuilder<M : ActivityModule<*>, C : ActivityComponent<*>> {

   fun activityModule(activityModule: M): ActivityComponentBuilder<M, C>?

   fun build(): C

}

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

   fun inject(app: App)

   fun inject(printingService: PrintingService)

   fun context() : Context

   fun preferenceFactory() : PreferenceFactory

   fun inject(devicesActivity: DevicesActivity)
}