Develop Reference

Kotlin + Hilt: Dependency cycle providing one dependence that has many other dependencies

I have a 'DownloadTests' class that has many dependencies:
class DownloadTests
#Inject constructor(
val awsTestTypeService: IAWSTestTypeService,
val awsTestSubjectService: IAWSTestSubjectService,
val awsTestService: IAWSTestService,
val imageService: IImageService,
val s3Storage: IS3StorageService,
val testService: ITestService,
val testTypeService: ITestTypeService,
val testSubjectService: ITestSubjectService,
val questionService: IQuestionService,
val answerService: IAnswerService
) {
...
And some of the 'DownloadTests' class dependencies at the same time have other dependencies, like for example:
class AWSTestTypeService
#Inject constructor(
private val awsTestTypeRepository: AWSTestTypeRepository
) : IAWSTestTypeService {
override fun getTestTypes(): List<TestTypeDTO>?
{
return awsTestTypeRepository.getTestTypes()
}
}
(I won't paste every 'DownloadTests' dependency because I don't consider it necessary)
Said that, I first tried providing 'DownloadTests' for classes that need it in the next way:
#Provides
#Singleton
fun provideDownloadTests(downloadTests: DownloadTests): DownloadTests{
return downloadTests
}
But this leads to a 'Dependency Cycle' building error:
/Users/xxx/StudioProjects/xxx/app/build/generated/hilt/component_sources/debug/com/xxx/xxx/ui/app/TMApplication_HiltComponents.java:165: error: [Dagger/DependencyCycle] Found a dependency cycle:
public abstract static class SingletonC implements xxx.xxx.xxx.common.dependencies.Dependencies.IEntryPoint,
^
xxx.xxx.xxx.background.downloadtests.DownloadTests is injected at
xxx.xxx.xxx.background.dependencies.Dependencies.provideDownloadTests(downloadTests)
xxx.xxx.xxx.background.downloadtests.DownloadTests is injected at
xxx.xxx.xxx.background.dependencies.Dependencies.provideDownloadTests(downloadTests)
...
The cycle is requested via:
xxx.xxx.xxx.background.downloadtests.DownloadTests is injected at
xxx.xxx.xxx.ui.activities.shared.BaseActivity.downloadTests
xxx.xxx.xxx.ui.activities.community.khan.KhanActivity is injected at
xxx.xxx.xxx.ui.activities.community.khan.KhanActivity_GeneratedInjector.injectKhanActivity(xxx.xxx.xxx.ui.activities.community.khan.KhanActivity) [xxx.xxx.xxx.ui.app.TMApplication_HiltComponents.SingletonC → xxx.xxx.xxx.ui.app.TMApplication_HiltComponents.ActivityRetainedC → xxx.xxx.xxx.ui.app.TMApplication_HiltComponents.ActivityC]
So, even I'm not convinced -and I'm not even sure it's the right way- I tried:
#Provides
#Singleton
fun provideDownloadTests(): DownloadTests{
return DownloadTests(
AWSTestTypeService(AWSTestTypeRepository()),
AWSTestSubjectService(AWSTestSubjectRepository()),
AWSTestService(AWSTestRepository()),
ImageService(ImageRepository()),
S3StorageService(),
TestService(AWSTestRepository(), SQLiteHelper()),
TestTypeService(),
TestSubjectService(),
QuestionService(),
AnswerService())
}
And to my surprise, this second way it just builds -and works- fine.
In this second approach I'm providing the classes instances myself, but it's too much code and I think it's Hilt responsibility to do that.
In resume, should I go with the first approach? If so, how to deal with the dependency cycle error?
If not, is my second approach really correct?

I would suggest going with the second one. First of all the first one is unscoped while the second one is singleton scoped.
The first approach you took is wrong since it creats a dependency cycle.
Look at the graph below:
The second approach can be tweaked a little. Since you have already created DI for various classes Hilt using #Inject constructor and inject them into provideDownloadTests () you can mention parameters in constructor which are required. For Example:
#Provides
#ActivityRetainedScoped
fun provideSomeClass(
application: Application,
b: B,
c: C,
d: Lazy<D>,
e: Lazy<E>,
f: F,
g: G
): SomeClass {
return SomeClass(application, b, c, d, e, f, g)
}
PS: I maybe be wrong. I started with DI just a couple of weeks back.

Android + Kotlin + Hilt: Injecting into static methods classes

I'm not very clear about the best way to inject into a static methods helper class (lets say a Custom class).
I'm kinda new to Kotlin, and as I've learnt we can access a method statically in two ways:
Object class.
Class + companion object.
To start, I'm not sure which one is the most recommended one (if there is a best practice regarding this), but my "problem" arises when needing to inject dependencies into a static method class.
Let's go with a simple example:
I have a static methods class called AWUtils (not decided if it should be an object class or a class with companion object yet though, and this will most likely depend on the injection mechanism recommended) with the next method:
fun setAmpersand2Yellow(text2Replace: String, target: String): String {
return text2Replace.replace(
target, "<span style=\"color:" +
app.drawerFooterColor + ";\">" + target + "</span>"
)
}
Here, app is the instance of my AppSettings class which holds all app configuration so, as you see setAmpersand2Yellow needs AppSettings, and of course I would't pass it as a parameter by any means, so it's a AWUtils dependence.
Using AWUtils as a class with companion object for the static methods I cannot inject directly AppSettings into company object as far as I know (at least I cannot do constructor injection, let me know if I'm wrong) and if I inject into companion object parent class (AWUtils) constructor then I don't know how to access those dependences from the companion object itself (the child).
If I use fields injection in AWUtils as a class then it complains than lateinit field has not been initialised and I don't know how to deal with this, because as far as I know lateinit fields are initialised in onCreate, which does not exist in this kind of classes.
One other possibility is to use an object with fields and set the dependencies values from caller in a static way before calling the method, for example:
object AWUtils {
var app: AppSettings? = null
fun setAmpersand2Yellow(text2Replace: String, target: String): String {
return text2Replace.replace(
target, "<span style=\"color:" +
app.drawerFooterColor + ";\">" + target + "</span>"
)
}
}
#AndroidEntryPoint
class OtherClass
#Inject constructor(private val app: AppSettings) {
fun AnyFunction() {
var mystr = "whatever"
AWUtils.app = app
var yellowStr = AWUtils.setAmpersand2Yellow(myStr)
}
}
In the end, I'm not sure on how to supply dependencies to a static methods class and which form of "static" class should I choose.
Edit 1:
Apart from my ApSettings class, I need a context, like for example in this next isTablet method:
val isTablet: String
get() {
return ((context.resources.configuration.screenLayout
and Configuration.SCREENLAYOUT_SIZE_MASK)
>= Configuration.SCREENLAYOUT_SIZE_LARGE)
}
In the end, I need a context and my AppSettings (or any other custom classes) to be injected anyway in a class with static methods.
Edit 2:
I could do (from the activity):
AWUtils.context = this
AWUtils.app = app
var isTablet = AWUtils.isTablet
And it works, but rather to be in the need of assigning a value to two fields (or more) every time I need to call a static method, I would prefer the fields to be injected in any way.
That's what dependency injection is meant for, isn't it?
Edit 3: I'm starting to be fed up with Hilt, what is supposed would have been created to simplify our life, only makes our programming life much more complicated.

As you clarified in the comments, you want to have your utils class accessible in an easy way across your codebase, so this answer will focus on that and on your original questions.
I'm kinda new to Kotlin, and as I've learnt we can access a method statically in two ways: Object class or Class + companion object.
Kotlin does not have Java-style statics. One reasoning behind it was to encourage more maintainable coding practices. Static methods and static classes are also a nightmare for testing your code.
In Kotlin you would go with an object (but a class + companion object would work in the same way)
object AWUtils {
lateinit var appContext: Context
lateinit var appSettings: AppSettings
fun initialize(
appContext: Context,
appSettings: AppSettings,
// more dependencies go here
) {
this.appContext = appContext
this.appSettings = appSettings
// and initialize them here
}
val isTablet: Boolean
get() = ((appContext.resources.configuration.screenLayout
and Configuration.SCREENLAYOUT_SIZE_MASK)
>= Configuration.SCREENLAYOUT_SIZE_LARGE)
fun setAmpersand2Yellow(text2Replace: String, target: String): String {
return text2Replace.replace(
target, "<span style=\"color:" +
appSettings.drawerFooterColor + ";\">" + target + "</span>"
)
}
}
Since this object should be accessible across the whole application it should be initialized as soon as possible, so in Application.onCreate
#HiltAndroidApp
class Application : android.app.Application() {
// you can inject other application-wide dependencies here
// #Inject
// lateinit var someOtherDependency: SomeOtherDependency
override fun onCreate() {
super.onCreate()
// initialize the utils singleton object with dependencies
AWUtils.initialize(applicationContext, AppSettings())
}
Now anywhere in your app code you can use AWUtils and AppSettings
class OtherClass { // no need to inject AppSettings anymore
fun anyFunction() {
val mystr = "whatever"
val yellowStr = AWUtils.setAmpersand2Yellow(myStr)
// This also works
if (AWUtils.isTablet) {
// and this as well
val color = AWUtils.appSettings.drawerFooterColor
}
}
}
There is another way in Kotlin to write helper/util functions, called extension functions.
Your isTablet check might be written as an extension function like this
// This isTablet() can be called on any Configuration instance
// The this. part can also be omitted
fun Configuration.isTablet() = ((this.screenLayout
and Configuration.SCREENLAYOUT_SIZE_MASK)
>= Configuration.SCREENLAYOUT_SIZE_LARGE)
// This isTablet() can be called on any Resources instance
fun Resources.isTablet() = configuration.isTablet()
// This isTablet() can be called on any Context instance
fun Context.isTablet() = resources.isTablet()
With the above extension functions in place the implementation inside AWUtils would be simplified to
val isTablet: Boolean
get() = appContext.isTablet()
Inside (or on a reference of) any class that implements Context, such as Application, Activity, Service etc., you can then simply call isTablet()
class SomeActivity : Activity() {
fun someFunction() {
if (isTablet()) {
// ...
}
}
}
And elsewhere where Context or Resources are available in some way, you can simply call resources.isTablet()
class SomeFragment : Fragment() {
fun someFunction() {
if (resources.isTablet()) {
// ...
}
}
}
Edit 3: I'm starting to be fed up with Hilt, what is supposed would have been created to simplify our life, only makes our programming life much more complicated.
Yeah, Hilt is focusing on constructor injection and can only do field injection out-of-the-box in very limited cases, afaik only inside Android classes annotated with #AndroidEntryPoint and inside the class extending the Application class when annotated with #HiltAndroidApp.
Docs for #AndroidEntryPoint say
Marks an Android component class to be setup for injection with the standard Hilt Dagger Android components. Currently, this supports activities, fragments, views, services, and broadcast receivers.
If you feel that you need a lot of field injection, because you are working with "static"-like objects in Kotlin, consider using Koin instead of Hilt for your next project.

Koin: Passing Properties between different module definitions

Was testing the following code. For brevity:
Class ActivityA {
Val aViewModel: AViewModel by viewModel()
Fun onCreate(){
val id = ….
getKoin().setProperty(“id’”, id)
loadKoinModules(aModule)
}
}
And in my modules.kt definitions:
Val aModule = modules {
viewModel { AViewModel(getProperty(“id”))} //works
}
//For ActivityB
Val bModule = modules {
viewModel { BViewModel(getProperty(“id”)} // Caused by: org.koin.core.error.MissingPropertyException: Property 'Id' not found
}
Why do I get this error when trying to create the BViewModel instance. I would have thought that getKoin() would be the same Koin Instance retrieved. But it seems to work only within the same Module definition loaded. I can’t get the property ‘id’ for module B. I have to do the same in ActivityA’s onCreate() for ActivityB.
Any explanation or links regarding this would be appreciated or do I have to use something like Koins' Scope feature for this?
Many Thanks

How to write a use case that retrieves data from Android framework with Context

I am migrating an application to MVVM and clean architecture, and I am missing one part of the puzzle.
The problem domain:
List all applications on device and display them in the Fragment / Activity
A device app is represented by its package name:
data class DeviceApp(val packageName: String)
This is how the device apps are listed:
private fun listAllApplications(context: Context): List<DeviceApp> {
val ans = mutableListOf<DeviceApp>()
val packageManager: PackageManager = context.applicationContext.packageManager
val packages = packageManager.getInstalledApplications(PackageManager.GET_META_DATA)
for (applicationInfo in packages) {
val packageName = applicationInfo.packageName
ans.add(DeviceApp(packageName))
}
return ans
}
As I understand, calling listAllApplications() should be done in a UseCase inside the 'Domain Layer', which is called by a ViewModel.
However listAllApplications receives a Context, and the Domain Layer should be plain code only.
In clean architecture / MVVM, in which layer should I put listAllApplications(context)?
And more generally, how should the ViewModel interact with Android framework APIs that require Context (location, etc.)?

Domain Layer should be plain code only.
That's correct!, but in my opinion it's partially correct. Now considering your scenario you need context at domain level. You shouldn't have context at domain level but in your need you should either choose other architecture pattern or consider it as exceptional case that you're doing this.
Considering you're using context at domain, you should always use applicationContext in spite of activity context, because earlier persists through out process.
How should the ViewModel interact with android framework APIs that require Context (location, etc.)?
Whenever you need Context at ViewModel either you can provide it from UI as method parameter (I.e. viewModel.getLocation(context)) or else use AndroidViewModel as your parent class for ViewModel (it provides getApplication() public method to access context through out ViewModel).
All I would like to point you out is that make sure you don't accidentally hold any View/Context globally inside ViewModel/Domain Layer, because it can make catastrophe like memory leaking or crashes at worse.

You can solve this problem very cleanly with dependency-injection. If you aren't already using DI, you probably want to be, as it will greatly simplify your clean-architecture endeavours.
Here's how I'd do this with Koin for DI.
First, convert your usecase from a function to a class. This allows for constructor injection:
class ListAllApplications(private val context: Context) {
...
}
You now have a reference to context inside your usecase. Great! We'll deal with actually providing the value of context in a moment.
Now you're thinking... but aren't usecases meant to use reusable functions? What's the guy on about with usecases being classes?
We can leverage the miracle that is operator funs to help us here.
class ListAllApplications(private val context: Context) {
operator fun invoke(): List<DeviceApp> {
val ans = mutableListOf<DeviceApp>()
val packageManager: PackageManager = context.applicationContext.packageManager
val packages = packageManager.getInstalledApplications(PackageManager.GET_META_DATA)
for (applicationInfo in packages) {
val packageName = applicationInfo.packageName
ans.add(DeviceApp(packageName))
}
return ans
}
}
invoke is a special function which allows an instance of a class to be invoked as if it were a function. It effectively transforms our class into a function with an injectable constructor 🤯
And this allows us to continue to invoke our usecase in the ViewModel with the standard function invocation syntax:
class MyViewModel(private val listAllApplications: ListAllApplications): ViewModel {
init {
val res = listAllApplications()
}
}
Notice that our ListAllApplications usecase is also being injected into the constructor of MyViewModel, meaning that the ViewModel remains entirely unaware of Context.
The final piece of the puzzle is wiring all this injection together with Koin:
object KoinModule {
private val useCases = module {
single { ListAllApplications(androidContext()) }
}
private val viewModels = module {
viewModel { MyViewModel(get()) }
}
}
Don't worry if you've never used Koin before, other DI libraries will let you do similar things. The key is that your ListAllApplications instance is being constructed by Koin, which provides an instance of Context with androidContext(). Your MyViewModel instance is also being constructed by Koin, which provides the instance of ListAllApplications with get().
Finally you inject MyViewModel into the Activity/Fragment which uses it. With Koin that's as simple as:
class MyFragment : Fragment {
private val viewModel: MyViewModel by viewModel()
}
Et Voilà!

org.kodein.di.Kodein$NotFoundException: 2 bindings found that match bind()

I have an interface WordsDataSource using which I have implemented two concrete classes namely WordsLocalDataSource that deals with local database and another WordsRemoteDataSource that deals with manipulating data online on the server. The problem is when I try to inject the two classes in repository class using abstract class name WordsDataSource like
DefaultWordsRepository(
private val wordsRemoteDataSource: WordsDataSource,
private val wordsLocalDataSource: WordsDataSource) {
And adding dependencies in Application class like
class WordsApplication : Application(), KodeinAware {
override val kodein = Kodein.lazy {
import(androidXModule(this#WordsApplication))
bind() from singleton { WordsDatabase.getInstance(instance()) }
bind<WordsDao>() with singleton { instance<WordsDatabase>().wordsDao() }
bind() from singleton { WordsLocalDataSource(instance()) }
bind() from singleton { WordsRemoteDataSource() }
bind<WordsRepository>() with singleton { DefaultWordsRepository(instance(), instance()) }
bind() from provider { ViewModelFactory(instance()) }
}
Then upon running the app I encounter the following issue in the logcat
org.kodein.di.Kodein$NotFoundException: 2 bindings found that match bind<WordsDataSource>() with ?<WordsFragment>().? { ? }:
bind<WordsLocalDataSource>() with singleton { WordsLocalDataSource }
bind<WordsRemoteDataSource>() with singleton { WordsRemoteDataSource }
I have tried the workaround for this by simply declaring the variables by their respective concrete class names like
DefaultWordsRepository(
private val wordsRemoteDataSource: WordsRemoteDataSource,
private val wordsLocalDataSource: WordsLocalDataSource) {
But still want to know whether or not is there any way to resolve the issue.
I am using the following dependencies for kodein
implementation "org.kodein.di:kodein-di-generic-jvm:6.3.3"
implementation "org.kodein.di:kodein-di-framework-android-x:6.3.3"

You have done it the right way by writing the explicit types:
DefaultWordsRepository(
private val wordsRemoteDataSource: WordsRemoteDataSource,
private val wordsLocalDataSource: WordsLocalDataSource)
When working with sub-types we cannot know what kind of implementation to choose. Writing
DefaultWordsRepository(
private val wordsRemoteDataSource: WordsDataSource,
private val wordsLocalDataSource: WordsDataSource)
Doesn't cannot find if you want both sub-types or twice the WordsRemoteDataSource or WordsLocalDataSource. Thus, you need to explicit define your types. Even, we could put WordsRemoteDataSource in the property wordsLocalDataSource, as we cannot rely on variable names.