we are using in our project KOIN like DI library.
in some cases, when ViewModel instance not refreshing when Koin context is killing and recreating again. We need to implement feature like 'reassembling dependency graph in runtime', and this issue very critical for us.
I have ViewModel module like this:
object ViewModelModule {
val module by lazy {
module {
viewModel { AppLauncherViewModel(get(), get(), get(), get()) }
viewModel { AuthLoginPasswordViewModel(get(), get()) }
viewModel { SettingsViewModel(get(), get()) }
// some others
}
}
}
And my graph is assembling in android application by this way:
private fun assembleGraph() {
val graph = listOf(
AppModule.module,
StorageModule.module,
DatabaseConfigModule.module,
RepositoryModule.module,
InteractorModule.module,
ViewModelModule.module
)
application.startKoin(application, platformGraph)
}
fun reassembleGraph() {
stopKoin()
assembleGraph()
}
And when reassembleGraph() is calling - all good, another instances in graph are refreshing, but ViewModels, that injected in activity - are not, and they are keeping old references. I guess, that viewmodel is attached to activity lifecycle, and could help activity recreation, but i think it's not the best solution.
Has anyone the same problems? And help me please with advice, how to solve it, please.
You can do it with the use of scope in KOIN.
1) Define your ViewModels in scope
scope(named("ViewModelScope")){
viewModel {
AppLauncherViewModel(get(), get(), get(), get())
AuthLoginPasswordViewModel(get(), get())
SettingsViewModel(get(), get())
}
}
2) Create that particular scope with the use of below line in your application class.
val viewModelScope = getKoin().getOrCreateScope("ViewModelScope")
Above code is used to get ViewModel. And when you want to recreate scope you just need to close scope and recreate again. To close scope use below code.
val viewModelScopeSession = getKoin().getOrCreateScope("ViewModelScope")
viewModelScopeSession.close()
Once the scope is closed then after whenever you request to create or get scope at that time it will return new instance as per your requirement.
For further reference, you can see below link (8th Point).
Koin documentation
Related
Is it possible to get lifecycle of passed Application or Context?
I need to run background service using Coroutines but already I do simple while(true) which doesn't support lifecycle of my app.
this.applicationContext?.let {
CoroutineScope(Dispatchers.Default).launch {
while (true) {
val fetchedLocation = LocationProvider.getLocationOrNull(it)
fetchedLocation?.let { location = it }
delay(1.toDuration(DurationUnit.MINUTES))
}
}
}
lifecycleScope is an extension function on LifecycleOwner, it is defined like the following:
public val LifecycleOwner.lifecycleScope: LifecycleCoroutineScope
get() = lifecycle.coroutineScope
where lifecycle is an instance of Lifecycle.
Only Activities and Fragments implement LifecycleOwner, so the lifecycleScope instance can be retrieved only from Activities or Fragments.
You can create your own implementation of LifecycleOwner and retrieve an instance of lifecycleScope from it.
I'm maintaining a large app (mostly) using a "one feature one activity"-architecture.
Now i'd like to scope a usecase, so it lives as long as the activity, something like this:
// koin module
scope<MyFeatureActivity> {
viewModel { MyFeatureActivityViewModel() }
viewModel { MyFeatureFragmentAViewModel(usecase = get()) }
viewModel { MyFeatureFragmentBViewModel(usecase = get()) }
scoped { MyFeatureUseCase() }
}
// fragments
class FeatureAFragment: AppCompatDialogFragment(){
private val viewModel by viewModel<MyFeatureFragmentAViewModel>()
....
}
// activity
class MyFeatureActivity : ScopeActivity() { ... }
However, this doesn't work. When launching MyFeatureFragmentA from MyFeatureActivity it's throwing an Exception:
org.koin.core.error.NoBeanDefFoundException:
|- No definition found for class:'MyFeatureAViewModel'. Check your definitions!
What am i doing wrong?
Please note: I would not like to just skip scopes and make the usecase a single (or a factory), since it actually stores some data relevant to only this activity: The data should be kept while we're in this feature, but dismissed when leaving it.
I have a repository where a chain of network requests is calling. The repository is accessed from the interactor. And interactor is accessed from viewModel. The view model is attached to activity A. If I go to activity B, which has its own viewModel, then the request chain in the repository of activity A does not complete its execution.
Is it possible to make a repository whose life cycle will be equal to the life cycle of the application. I need all requests to complete even if I go to a new activity.
Please, help me.
This is covered in the Coroutines guide on developer.android.com
class ArticlesRepository(
private val articlesDataSource: ArticlesDataSource,
private val externalScope: CoroutineScope,
private val defaultDispatcher: CoroutineDispatcher = Dispatchers.Default
) {
// As we want to complete bookmarking the article even if the user moves
// away from the screen, the work is done creating a new coroutine
// from an external scope
suspend fun bookmarkArticle(article: Article) {
externalScope.launch(defaultDispatcher) {
articlesDataSource.bookmarkArticle(article)
}
.join() // Wait for the coroutine to complete
}
}
Here externalScope is defined like this (for a scope with application lifetime):
class MyApplication : Application() {
// No need to cancel this scope as it'll be torn down with the process
val applicationScope = CoroutineScope(SupervisorJob() + otherConfig)
}
You should create a singleton Repository class, then access its instance anywhere you want.
object Repository {
val instance: Repository
get() {
return this
}
}
You can create create its object in ViewModel for A and create object in ViewModel for B.
Both will have same instance for Repository class, so in this way you can achieve what you need.
I have a single activity and multiple fragments styled application using the navigation component.
I am using Koin for my DI. I was wanting to create a Navigator class in my application as per the postulates of clean architecture.
This hypothetical class would look like :
class Navigator(private val navHostFragment: NavHostFragment)
{
fun toStudentsProfile():Unit
{
val action = HomeFragmentDirections.toStudentsProfile()
navHostFragment.findNavController().navigate(action)
}
fun toTeachersProfile():Unit
{
val action = HomeFragmentDirections.toTeachersProfile()
navHostFragment.findNavController().navigate(action)
}
}
My problem now is how should I create this under the Koin container ?
val platformModule = module {
single { Navigator("WHAT CAN BE DONE HERE") }
single { Session(get()) }
single { CoroutineScope(Dispatchers.IO + Job()) }
}
Furthermore, the Koin component would get ready before the navhostfragment is ready hence it won't be able to satisfy the dependency, to begin with.
Is there a way to provide Koin with an instance of a class and then subsequently start using it?
Koin allows to use parameters on injection
val platformModule = module {
factory { (navHostFragment: NavHostFragment) -> Navigator(navHostFragment) }
single { Session(get()) }
single { CoroutineScope(Dispatchers.IO + Job()) }
}
I have declared the dependency as factory, i guess it could be scoped to the activity as well. Declaring it as single will lead to misbehavior, as if the activity (therefore the navhostFragment) is re-created, the Navigator object will be referencing the destroyed navhostFragment.
As the fragments will be navhostFragment children, you can obtain the Navigator object in the fragments this way:
val navigator: Navigator by inject { parametersOf(requireParentFragment()) }
I just started using MVVM architecture on Android. I have a service which basically fetches some data and updates the UI and this is what I understood from MVVM:
Activity should not know anything about the data and should take care of the views
ViewModels should not know about activity
Repository is responsible for getting the data
Now as ViewModels should not know anything about the activity and Activities should not do anything other than handling views, Can anyone please tell where should I start a service?
In MVVM, ideally, the methods to start a service should be defined in Repository since it has the responsibility to interact with Data Source. ViewModel keeps an instance of Repository and is responsible for calling the Repository methods and updating its own LiveData which could be a member of ViewModel. View keeps an instance of ViewModel and it observes LiveData of ViewModel and makes changes to UI accordingly. Here is some pseudo-code to give you a better picture.
class SampleRepository {
fun getInstance(): SampleRepository {
// return instance of SampleRepository
}
fun getDataFromService(): LiveData<Type> {
// start some service and return LiveData
}
}
class SampleViewModel {
private val sampleRepository = SampleRepository.getInstance()
private var sampleLiveData = MutableLiveData<Type>()
// getter for sampleLiveData
fun getSampleLiveData(): LiveData<Type> = sampleLiveData
fun startService() {
sampleLiveData.postValue(sampleRepository.getDataFromService())
}
}
class SampleView {
private var sampleViewModel: SampleViewModel
// for activities, this sampleMethod is often their onCreate() method
fun sampleMethod() {
// instantiate sampleViewModel
sampleViewModel = ViewModelProviders.of(this).get(SampleViewModel::class.java)
// observe LiveData of sampleViewModel
sampleViewModel.getSampleLiveData().observe(viewLifecycleOwner, Observer<Type> { newData ->
// update UI here using newData
}
}
As far as I know, Services are Android related so, they could be started from View (Activity/Fragment/Lifecycleowner).