Room,Kotlin,Dagger 2.15 android.app.Application cannot be provided without an @Inject constructor or from an @Provides-annotated method

Question

I have the following implementation with dagger for Room Module. This causes an error on injecting the RoomMoule at the ViewModel class. Following is my Code:

App

class App : DaggerApplication(), HasActivityInjector {

@Inject
lateinit var activityDispatchInjector: DispatchingAndroidInjector<Activity>

override fun applicationInjector(): AndroidInjector<out DaggerApplication> {
    return DaggerAppComponent.builder().create(this)
}


override fun activityInjector(): DispatchingAndroidInjector<Activity> {
    return activityDispatchInjector
}
}

AppModule

@Module
class AppModule {

@Provides
@Singleton
fun providesContext(app: Application): Context = app
}

RoomModule

@Module
class RoomModule {

@Singleton
@Provides
fun provideAppDatabase(context: Context): AppRoomDataBase =
        Room.databaseBuilder(context,
                AppRoomDataBase::class.java, "sample.db")
                .build()


@Singleton
@Provides

fun provideRepository(appRoomDataBase: AppRoomDataBase): ResultRepository {
    return ResultRepository(appRoomDataBase)
}    

}

AppComponent

@Singleton
@Component(modules = [
(AndroidSupportInjectionModule::class),
(AppModule::class),
(ActivityModule::class),
(FragmentModule::class),
(ViewModelModule::class),
(RoomModule::class)])
interface AppComponent : AndroidInjector<App> {

@Component.Builder
abstract class Builder : AndroidInjector.Builder<App>()
}

HomeViewModel

class HomeViewModel @Inject constructor() : ViewModel() {

@Inject lateinit var resultRepository: ResultRepository

private var liveList: LiveData<List<Result>>? = null

fun getResults(): LiveData<List<Result>>? {

     liveList = resultRepository.findAll()

    return liveList
  }
}

ResultRepository

class ResultRepository(appRoomDB : AppRoomDataBase) {

val mAppDb : AppRoomDataBase = appRoomDB

fun findAll(): LiveData<List<Result>> {
    return mAppDb.resultDao().getAll()
}
}

On building this i'm getting the error as

AppComponent.java:11: error: [dagger.android.AndroidInjector.inject(T)] 
android.app.Application cannot be provided without an @Inject constructor or 
from an @Provides-annotated method.
public abstract interface AppComponent extends 
dagger.android.AndroidInjector<com.dailypay.base.App> {
            ^
  android.app.Application is injected at
      com.dailypay.di.AppModule.providesContext(app)
  android.content.Context is injected at
      com.dailypay.di.RoomModule.provideAppDatabase(context)
  com.dailypay.room.AppRoomDataBase is injected at
      com.dailypay.di.RoomModule.provideRepository(appRoomDataBase)
  com.dailypay.repo.ResultRepository is injected at
      com.dailypay.ui.home.HomeViewModel.resultRepository
  com.dailypay.ui.home.HomeViewModel is injected at
      com.dailypay.di.ViewModelModule.bindMainViewModel(mainViewModel)
  java.util.Map<java.lang.Class<? extends android.arch.lifecycle.ViewModel>,javax.inject.Provider<android.arch.lifecycle.ViewModel>> is injected at
      com.dailypay.di.ViewModelFactory.<init>(creators)
  com.dailypay.di.ViewModelFactory is injected at
      com.dailypay.di.ActivityModule.bindViewModelFactory(factory)
  android.arch.lifecycle.ViewModelProvider.Factory is injected at
      com.dailypay.ui.home.HomeFragment.viewModelFactory
  com.dailypay.ui.home.HomeFragment is injected at
      dagger.android.AndroidInjector.inject(arg0)

:app:kaptDebugKotlin FAILED

FAILURE: Build failed with an exception.

Answer 1

Your AppComponent is missing the @BindsInstance in the Builder.

@Component.Builder
interface Builder : AndroidInjector.Builder<App> {
    @BindsInstance Builder application(Application application);
    AppComponent build();
}

Answer 2

I have provided simple room DB demo using dagger 2 used below code but it is java code you can convert into kotlin easily.

Step 1: Define pojo class for table and class define @Entity annotaion. Step 2: Define into that class into database class like below ...

@Database(entities = {Hero.class, User.class}, version = 1)
public abstract class DemoDatabase extends RoomDatabase {

    public abstract HeroDao getHeroDao();

    public abstract UserDao getUserDao();

}

Step 3: Define Module class for room db..

@Module
public class RoomDbModule {

    private DemoDatabase demoDatabase;

    public RoomDbModule(Application application) {
        demoDatabase= Room.databaseBuilder(application,DemoDatabase.class,"DemoDb").allowMainThreadQueries().build();
    }

    @Provides
    @Singleton
    DemoDatabase getDemoDatabase(){
        return demoDatabase;
    }
}

Step 4: Define Dao class ..

@Dao
public interface HeroDao {
    @Insert
    void insertRecord(Hero hero);
}

Step 5 : define commpoent class..

@Singleton
@Component(modules = {AppModule.class, NetModule.class, RoomDbModule.class, DbHelperModule.class})
public interface ApiComponent {
    void injectApi(MainActivity activity);

    void roomDb(InsertActivity insertActivity);

    void roomDb(PageingActivity pageingActivity);

    void dbHelper(AppCompatActivity appCompatActivity);
}

Step 6 : Define AppActivity as application level and pass into manifest file ...

public class AppActivity extends Application {
    private ApiComponent component;

    @Override
    public void onCreate() {
        super.onCreate();
        component = DaggerApiComponent.builder()
                .appModule(new AppModule(this))
                .roomDbModule(new RoomDbModule(this))
                .dbHelperModule(new DbHelperModule(new DbHelper(this, "UserDb", 1)))
                .netModule(new NetModule("https://api.github.com")).build();
    }

    public ApiComponent getComponent() {
        return component;
    }
}

and define in manifest file in application tag used below

        android:name=".app.AppActivity" // your activity name.

Step 7: Used Room db or inject.. provide full code for insert data into table using room.

public class InsertActivity extends BaseActivity {
    private EditText mEtName,mEtRealName,mEtTeamName;
    private Button mBtnInsert;

    @Inject
    DemoDatabase demoDatabase;
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.insert_activity);
        ((AppActivity)getApplication()).getComponent().roomDb(this);
        initView();
    }

    private void initView() {
        mEtTeamName=findViewById(R.id.iaEtTeamName);
        mEtName=findViewById(R.id.iaEtName);
        mEtRealName=findViewById(R.id.iaEtRealName);
        mBtnInsert=findViewById(R.id.iaBtnInsert);
        mBtnInsert.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                insertData();
            }
        });
    }

    private void insertData() {
        Hero hero=new Hero();
        hero.setName(mEtName.getText().toString().trim());
        hero.setRealname(mEtRealName.getText().toString().trim());
        hero.setTeam(mEtTeamName.getText().toString().trim());
        demoDatabase.getHeroDao().insertRecord(hero);
        Toast.makeText(getApplicationContext(),"Insert Successfully",Toast.LENGTH_SHORT).show();
        mEtRealName.setText("");
        mEtName.setText("");
        mEtTeamName.setText("");

    }
}