Unresolved inject method on Dagger2 method

Question

I'm trying to inject a set of Room components into a Repository which is itself injected into a ViewModel (which is in a fragment) using Dagger2.

The code is as follows.

Fragment:

class MyFragment : Fragment() {
    private var viewModel: MyViewModel? = null

    override fun onActivityCreated(savedInstanceState: Bundle?) {
        super.onActivityCreated(savedInstanceState)
        viewModel = ViewModelProviders.of(this).get(MyViewModel::class.java)
        viewModel!!.init()
        viewModel!!.getUser().observe(this, Observer<MyClass?> {...})
    }
    ...
}

View Model:

class MyViewModel : ViewModel() {

    @Inject lateinit var myRepo: MyRepository

    private var instance: LiveData<MyClass>? = null

    fun init() {
        DaggerAppComponent.builder()
                .build().daggerInject(this)
        if (this.instance != null) {
            return
        }
        instance = myRepo.getInstance()
    }
}

My Repository:

@Singleton
class MyRepository {
    @Inject lateinit var myDao: MyDao
    @Inject lateinit var executor: Executor

    init {
        DaggerAppComponent.builder().build().daggerInject(this)
    }
}

Finally for my dagger classes I have two modules:

@Module(includes = [AndroidInjectionModule::class])
abstract class AppModule {

    @Binds
    abstract fun application(app: MyApplication): MyApplication
}


@Module
class DataModule {

    @Inject
    lateinit var application: MyApplication

    val myDatabase = Room.databaseBuilder(application, MyDatabase::class.java, "my-database").build()

    @Provides
    @Singleton
    fun provideRepository(): MyRepository {
        return MyRepository()
    }

    @Provides
    fun provideMyDao(): MyDao {
        return MyDao_Impl(myDatabase)
    }

    @Provides
    fun providesExecutor(): Executor {
        return Executors.newSingleThreadExecutor()
    }

}

And my AppComponent:

@Singleton
@Component(modules = [AppModule::class, DataModule::class])
interface AppComponent : AndroidInjector<MyApplication> {
    fun daggerInject(viewModel: MyViewModel)
    fun daggerInject(myRepo: MyRepository)

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

Dagger compiles fine, I can access the DaggerAppComponent and build it. However dataModule is inaccessible (inspecting the class shows it as private) as are the daggerInject methods I need to actually inject the dependencies. As a result I get the error:

Unresolved reference: daggerInject

How do I solve this?

What's the point of @Singleton if you create a new component for each class you're creating...? — EpicPandaForce
Yep I was confused about that as well. I've been reading a lot of highly conflicting guides to this so the code may seem a bit odd. — NDevox

EpicPandaForce EpicPandaForce · Accepted Answer · 2018-06-12T16:29:18

inline fun <reified T: ViewModel> AppCompatActivity.createViewModel(crossinline factory: () -> T): T = T::class.java.let { clazz ->
    ViewModelProviders.of(this, object: ViewModelProvider.Factory {
        override fun <T : ViewModel?> create(modelClass: Class<T>): T {
            if(modelClass == clazz) {
                @Suppress("UNCHECKED_CAST")
                return factory() as T
            }
            throw IllegalArgumentException("Unexpected argument: $modelClass")
        }
    }).get(clazz)
}

inline fun <reified T: ViewModel> Fragment.createViewModel(crossinline factory: () -> T): T = T::class.java.let { clazz ->
    ViewModelProviders.of(this, object: ViewModelProvider.Factory {
        override fun <T : ViewModel?> create(modelClass: Class<T>): T {
            if(modelClass == clazz) {
                @Suppress("UNCHECKED_CAST")
                return factory() as T
            }
            throw IllegalArgumentException("Unexpected argument: $modelClass")
        }
    }).get(clazz)
}

and Fragment:

class MyFragment : Fragment(), Injectable {
    private lateinit var viewModel: MyViewModel

    @Inject lateinit var appComponent: AppComponent 

    override fun onActivityCreated(savedInstanceState: Bundle?) {
        super.onActivityCreated(savedInstanceState)
        viewModel = createViewModel { appComponent.myViewModel() }
        viewModel.getUser().observe(this) {...}
    }
    ...
}

View Model:

class MyViewModel @Inject constructor(private val myRepo: MyRepository): ViewModel() {

    private var instance: LiveData<MyClass>? = myRepo.getInstance()
}

My Repository:

@Singleton
class MyRepository @Inject constructor(
    private val myDao: MyDao, 
    private val executor: Executor
) {
}

Finally for my dagger classes I have two modules:

@Module(includes = [AndroidInjectionModule::class])
abstract class AppModule {
    fun application(myApplication: MyApplication): Application = myApplication
}
@Module
abstract class DataModule {
    @Provides
    fun myDatabase(application: Application) = 
        Room.databaseBuilder(application, MyDatabase::class.java, "my-database").build()

    @Provides
    fun myDao(): MyDao = myDatabase.myDao()

    @Provides
    fun providesExecutor(): Executor =
        Executors.newSingleThreadExecutor()
}

And my AppComponent:

@Singleton
@Component(modules = [AppModule::class, DataModule::class])
interface AppComponent : AndroidInjector<MyApplication> {
    @Component.Builder
    abstract class Builder: AndroidInjector.Builder<MyApplication>()

    fun myViewModel(): MyViewModel
}

And AppInjector:

import android.app.Activity
import android.app.Application
import android.os.Bundle
import android.support.v4.app.Fragment
import android.support.v4.app.FragmentActivity
import android.support.v4.app.FragmentManager
import dagger.android.AndroidInjection
import dagger.android.support.AndroidSupportInjection
import dagger.android.support.HasSupportFragmentInjector

/**
 * Helper class to automatically inject fragments if they implement [Injectable].
 */
object AppInjector {
    fun init(myApp: MyApplication) {
        DaggerAppComponent.builder().application(myApp)
            .build().inject(myApp)
        myApp
            .registerActivityLifecycleCallbacks(object : Application.ActivityLifecycleCallbacks {
                override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {
                    handleActivity(activity)
                }

                override fun onActivityStarted(activity: Activity) {

                }

                override fun onActivityResumed(activity: Activity) {

                }

                override fun onActivityPaused(activity: Activity) {

                }

                override fun onActivityStopped(activity: Activity) {

                }

                override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle?) {

                }

                override fun onActivityDestroyed(activity: Activity) {

                }
            })
    }

    private fun handleActivity(activity: Activity) {
        if (activity is HasSupportFragmentInjector) {
            AndroidInjection.inject(activity)
        }
        if (activity is FragmentActivity) {
            activity.supportFragmentManager
                .registerFragmentLifecycleCallbacks(
                    object : FragmentManager.FragmentLifecycleCallbacks() {
                        override fun onFragmentCreated(
                            fm: FragmentManager,
                            f: Fragment,
                            savedInstanceState: Bundle?
                        ) {
                            if (f is Injectable) {
                                AndroidSupportInjection.inject(f)
                            }
                        }
                    }, true
                )
        }
    }
}

And

class MyApplication : Application(), HasActivityInjector {
    @Inject
    lateinit var dispatchingAndroidInjector: DispatchingAndroidInjector<Activity>

    override fun onCreate() {
        super.onCreate()
        AppInjector.init(this)
    }

    override fun activityInjector() = dispatchingAndroidInjector
}

Unresolved inject method on Dagger2 method

1 Answers