error: [Dagger/MissingBinding] java.util.Map<java.lang.Class<? extends androidx.lifecycle.ViewModel>,javax.inject.Provider<androidx.lifecycle.ViewModel>> cannot be provided without an @Provides-annotated method.
public abstract interface AppComponent {
            ^
  java.util.Map<java.lang.Class<? extends androidx.lifecycle.ViewModel>,javax.inject.Provider<androidx.lifecycle.ViewModel>> is injected at
      reporter.awaaz.live.di.module.CustomViewModelFactory(creators)
  reporter.awaaz.live.di.module. CustomViewModelFactory is injected at
      reporter.awaaz.live.ui.fragment.dashboard.ItemCreateFragment.viewModelFactory
  reporter.awaaz.live.ui.fragment.dashboard.ItemCreateFragment is injected at
      dagger.android.AndroidInjector.inject(T) [reporter.awaaz.live.di.component.AppComponent → reporter.awaaz.live.di.module.FragmentModule_ItemCreateFragment$app_debug.ItemCreateFragmentSubcomponent]

@Singleton
@Component(modules = [AndroidInjectionModule::class,
ActivityModule::class, FragmentModule::class, NetworkModule::class,
AppModule::class ])
interface AppComponent {

@Component.Builder
interface Builder {

    @BindsInstance
    fun application(application: Application): Builder

    fun build(): AppComponent
}

fun inject(awaazApplication: AwaazApplication)
}

@Module(includes = [ViewModelModule::class])
internal class AppModule {

@Singleton
@Provides
fun provideRoomDatabase(app: Application): AppDatabase {
    return Room.databaseBuilder(app, AppDatabase::class.java, "awaaz-partner.db").build()
}

@Singleton
@Provides
fun provideItemDao(db: AppDatabase): itemDao {
    return db.itemDao()
}
}

@Module
abstract class ActivityModule {

@ContributesAndroidInjector
internal abstract fun registerActivity(): RegisterActivity

@ContributesAndroidInjector
internal abstract fun dashboardActivity(): DashboardActivity
}

CustomViewModelFactory @Inject constructor(private val creators:
Map<Class<out ViewModel>, @JvmSuppressWildcards Provider<ViewModel>>):
ViewModelProvider.Factory {
override fun <T : ViewModel> create(modelClass: Class<T>): T {
    var creator: Provider<out ViewModel>? = creators.get(modelClass)
    if (creator == null) {
        for (entry in creators.entries) {
            if (modelClass.isAssignableFrom(entry.key)) {
                creator = entry.value
                break
            }
        }
    }
    if (creator == null) {
        throw IllegalArgumentException("unknown model class $modelClass")
    }

    try {
        return creator.get() as T
    } catch (e: Exception) {
        throw RuntimeException(e)
    }
}
}

@Module
abstract class FragmentModule {

@ContributesAndroidInjector
internal abstract fun itemCreateFragment(): ItemCreateFragment
}

@Module
class NetworkModule {

@Provides
@Singleton
fun provideApolloClient(context: Context): ApolloClient {
    return repository.getApolloClient(context)
}
}

@MustBeDocumented
@Target(
        AnnotationTarget.FUNCTION,
        AnnotationTarget.PROPERTY_GETTER,
        AnnotationTarget.PROPERTY_SETTER
)
@Retention(AnnotationRetention.RUNTIME)
@MapKey
internal annotation class ViewModelKey(val value: KClass<out ViewModel>)

@Module
internal abstract class ViewModelModule {

    @Binds
    @IntoMap
    @ViewModelKey(ItemViewModel::class)
    abstract fun bindItemViewModel(itemViewModel: itemViewModel): ViewModel
  }

class ItemViewModel @Inject constructor(apolloClient: ApolloClient) : ViewModel() {
  //Some methods
  }

class ItemCreateFragment : Fragment() {

@Inject
lateinit var viewModelFactory: CustomViewModelFactory
private lateinit var itemsViewModel: ItemViewModel
override fun onAttach(context: Context) {
    AndroidSupportInjection.inject(this)
    super.onAttach(context)
    this.mContext = context
}
override fun onActivityCreated(savedInstanceState: Bundle?) {
    super.onActivityCreated(savedInstanceState)
    itemsViewModel = ViewModelProviders.of(this, viewModelFactory)[ItemViewModel::class.java]
    itemsViewModel.getStatus().observe(this, Observer { Util.showToast(mContext, "Statues $it") })
}

class CustomApplication : Application(), HasActivityInjector, HasSupportFragmentInjector {

    override fun activityInjector(): AndroidInjector<Activity> = activityInjector

    override fun supportFragmentInjector(): AndroidInjector<Fragment> = fragmentInjector

    @Inject
    lateinit var activityInjector: DispatchingAndroidInjector<Activity>

    @Inject
    lateinit var fragmentInjector: DispatchingAndroidInjector<Fragment>

    override fun onCreate() {
        super.onCreate()

        DaggerAppComponent.builder().application(this).build().inject(this)

    }
   }