使用存储库进行延迟初始化

Question

I checked out the Android Sunflower best practices app. And i kinda struggle to understand why the initialization of the PlantDetailsViewModel is working. The class is defined as follows

class PlantDetailViewModel @AssistedInject constructor(
    plantRepository: PlantRepository,
    private val gardenPlantingRepository: GardenPlantingRepository,
    @Assisted private val plantId: String
) : ViewModel() {
    
val isPlanted = gardenPlantingRepository.isPlanted(plantId)
val plant = plantRepository.getPlant(plantId)
        
    ....

@AssistedInject.Factory
interface AssistedFactory {
    fun create(plantId: String): PlantDetailViewModel
}

companion object {
    fun provideFactory(
        assistedFactory: AssistedFactory,
        plantId: String
    ): ViewModelProvider.Factory = object : ViewModelProvider.Factory {
        @Suppress("UNCHECKED_CAST")
        override fun <T : ViewModel?> create(modelClass: Class<T>): T {
            return assistedFactory.create(plantId) as T
        }
    }
}

}

here the gardenPlantingRepository and plantRepository give access to a Room Database . I wonder that this works because normally it is not possible to access a room database on the main thread. The Viemodel is used in the PlantDetailFragment and lazy initialized.

@Inject
lateinit var plantDetailViewModelFactory: PlantDetailViewModel.AssistedFactory

private val plantDetailViewModel: PlantDetailViewModel by viewModels {
    PlantDetailViewModel.provideFactory(
        plantDetailViewModelFactory,
        args.plantId
    )
}

if i try something that is quite the same i always get the problem that it is not possible to access the database on the main thread. so i tried to init my variables in the init function with a coroutine and Dispatchers.IO but the problem with this is that when i access member variables of my viewmodel they are not initialized. so how is the behaviour of the sunflower app reproducible

Answer 1

Repository uses Dao methods that return LiveData

The Room persistence library supports observable queries, which return LiveData objects. Observable queries are written as part of a Database Access Object (DAO).

Room generates all the necessary code to update the LiveData object when a database is updated. The generated code runs the query asynchronously on a background thread when needed. This pattern is useful for keeping the data displayed in a UI in sync with the data stored in a database. https://developer.android.com/topic/libraries/architecture/livedata#use_livedata_with_room

If you want to use coroutines then you should create and expose LiveData in your ViewModel

class ViewModel(
    val repository: Repository
) : ViewModel() {

    private val _liveData = MutableLiveData<SomeType>()
    val liveData: LiveData<SomeType> get() = _liveData

    init {
        viewModelScope.launch(Dispatchers.IO) {
            _liveData.postValue(repository.getSomeData())
        }
    }

}

Then you should observe this liveData in your activity / fragment