Possible solution for Arch ViewModel dynamic parameters

[cashapp]

Possible solution for Arch ViewModel dynamic parameters

[JakeWharton]

This functionality is going to be covered by the upcoming Hilt tool in Jetpack which integrates Dagger with view models and work manager.

[Ethan1983]

You might want to check @InflationInject @InflationModule which is used to avoid that another level of factories (LayoutInflator.Factory).

[eerikk]

@mtiidla have you found more elegant solution to this?

[mtiidla]

@mtiidla have you found more elegant solution to this?

@eerikk No, unfortunately not. I have recently switched projects and am currently not using Dagger2, but Koin instead. Koin solves this exact issue as you can see here. However, I personally care much more about Dagger2 and I am planning to look into the LayoutInflater Factory solution mentioned by Ethan1983, but haven't gotten around to it yet.

[alashow]

My solution was to have a callback on ViewModel creation in ViewModelFactory:
https://gist.github.com/alashow/67cc52c606ddc7637e75185673b7f9a6

[mtiidla]

My solution was to have a callback on ViewModel creation in ViewModelFactory:
https://gist.github.com/alashow/67cc52c606ddc7637e75185673b7f9a6

Thanks for proposing your solution, however it is not solving the problem. The main idea is to avoid an init method on the viewmodel and use constructor to injection arguments. Otherwise we could very well write an init method on every viewmodel and just call it (which you have just abstracted away).

[alashow]

Yeah, the reason why I abstracted it is to init the ViewModel on creation.

[evant]

I made https://github.com/evant/injectedvmprovider to try to deal with this, it lets you skip the ViewModelFactory. While we aren't currently using it with AssistedInject, we are using it with manual factories and it's working pretty well. Your example would be:

The ViewModel

class WordDetailViewModel  @AssistedInject constructor(
    private val repository: WordRepository,
    @Assisted argument: WordDetailScreenArg
) : ViewModel() {

    val wordDetail: LiveData<Word> = repository.word(argument.word)

    fun onDeleteWordClicked() {
        wordDetail.value?.let {
            repository.deleteWord(it.word)
        }
    }

    @AssistedInject.Factory
    interface Factory {
        fun create(argument: WordDetailScreenArg): WordDetailViewModel
    }
}

Injection

@Inject
lateinit var viewModelFactory: WordDetailViewModel.Factory;

override fun onAttach(context: Context?) {
    super.onAttach(context)

    val arguments: WordDetailScreenArg = ...
    Injection.appComponent.inject(this)

    viewModel = InjectedViewModelProviders.of(this).get(viewModelFactory, f -> f.create(arguments))
}

[Mayank-Bhatnagar]

Well with this approach are we not gonna end with each individual ViewModel mapped to its own ViewModelFactory. Thus, we are sacrificing the cost of loosing a generic ViewModelFactory. Please correct me if I misunderstood.

[permenko]

https://github.com/tfcporciuncula/dagger-journey

[eerikk]

We've started to use this kind of solution in our project. Dagger helps us out here 👇

1. Generic code that lets us inject into Fragment and ViewModel. Important part here is the code inside companion object. We make fragment argument available for ViewModel.

@Module
interface ExampleModule {

    @PerFragment
    @ContributesAndroidInjector(modules = [ExampleViewModelModule::class])
    fun contributesExampleFragment(): ExampleFragment

    @Module(includes = [ViewModelFactoryModule::class])
    abstract class ExampleViewModelModule {

        @Binds
        @IntoMap
        @ViewModelKey(ExampleViewModel::class)
        abstract fun bindExampleViewModel(viewModel: ExampleViewModel): ViewModel

        @Module
        companion object {
            @Provides
            @JvmStatic
            fun providesExampleParam(fragment: ExampleFragment): String {
                return fragment.requireArguments()
                    .getString(ExampleFragment.ARG_EXAMPLE_STRING)!!
            }
        }
    }

}

This way we can inject the param simply to our ViewModel

class ExampleViewModel @Inject constructor(
    private val exampleString: String
): ViewModel{}

---

If you have multiple parameters with same type, you can use @Named annotation to prevent type conflicts. 👇

            @Provides
            @Named(ExampleFragment.EXAMPLE_STRING)
            @JvmStatic
            fun providesExampleParam(fragment: ExampleFragment): String {
                return fragment.requireArguments()
                    .getString(ExampleFragment.ARG_EXAMPLE_STRING)!!
            }

...and now you can simply access it from ViewModel

class ExampleViewModel @Inject constructor(
    @Named(ExampleFragment.EXAMPLE_STRING) private val exampleString: String
): ViewModel{}

[hansenji]

This library uses Assisted Inject and SavedStateHandle to pass arguments into your viewmodel
https://github.com/hansenji/ViewModelInject.