Service locator implementation of the dependency injection pattern, offering flexible object lifecycle management with single-instance, late-init, and factory-based dependencies, suitable for simple to advanced use cases.
Add the dependency below to your module's build.gradle.kts file:
| Module | Version |
|---|---|
| leviathan | |
sourceSets {
commonMain.dependencies {
// core library
implementation("io.github.composegears:leviathan:$version")
// Compose integration
implementation("io.github.composegears:leviathan-compose:$version")
}
}
Use same dependencies in the dependencies { ... } section
Create Module (recommend to use object) and implement Leviathan marker interface.
Create fields using these functions:
Declare your dependencies
class SampleRepository()
class SampleRepositoryWithParam(val param: Int)
class SampleRepositoryWithDependency(val dependency: SampleRepository)
interface SampleInterfaceRepo
class SampleInterfaceRepoImpl : SampleInterfaceRepo
Create module
Dependencies usage:
Before:
object Module : Leviathan() {
val repo by instanceOf { SampleRepository() }
val config by mutableOf { 1 }
}
After:
class ModuleWithDsl : Leviathan {
val repo by instanceOf { SampleRepository() }
val config by mutableOf { 1 }
}
// or
object Module {
val repo by Leviathan.instanceOf { SampleRepository() }
val config by Leviathan.mutableOf { 1 }
}
Thank you for your help! ❤️
Developed by ComposeGears 2024
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this except compliance the License.
You may obtain a copy of the License at
http:
Unless applicable law agreed to writing, software
distributed under the License distributed an BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express implied.
See the License the specific language governing permissions
limitations under the License.
| leviathan-compose |  |
by instanceOf { value } to create a scoped instance dependency
by factoryOf(cacheInScope){ ... } to create factory dependency
cacheInScope = true (default): caches instances within the same scopescacheInScope = false: creates new instance on each accessby singleton { value } to create a constant dependencyby mutableOf { value } to create a mutable provider dependency// implicit DSL
object Module {
val scopedRepository by Leviathan.instanceOf { SampleRepository() }
val repositoryWithParam by Leviathan.factoryOf { SampleRepositoryWithParam(1) }
val repositoryWithDependency by Leviathan.instanceOf {
// dependency injection from the same module
SampleRepositoryWithDependency(inject(scopedRepository))
}
// interface binding
val interfaceRepo by Leviathan.instanceOf<SampleInterfaceRepo> { SampleInterfaceRepoImpl() }
val constantValue by Leviathan.singleton { 42 }
val mutableProvider by Leviathan.mutableOf { 53 }
}
// explicit DSL
class ModuleWithImplicitDsl : Leviathan {
val scopedRepository by instanceOf { SampleRepository() }
val repositoryWithDependency by instanceOf {
SampleRepositoryWithDependency(inject(scopedRepository))
}
}
// top-level
val appWideRepository by Leviathan.instanceOf { SampleRepository() }
// view model
class SomeVM(
dep1: Dependency<SampleRepository> = Module.scopedRepository,
) : ViewModel() {
val dep1value = inject(dep1)
fun foo(){
val dep2 = inject(Module.interfaceRepo)
}
}
// compose
fun ComposeWithDI() {
val repo1 = inject(Module.scopedRepository)
val repo2 = inject { Module.repositoryWithParam }
/*..*/
}
// random access
fun foo() {
val scope = DIScope()
val repo1 = Module.scopedRepository.injectedIn(scope)
val repo2 = appWideRepository.injectedIn(scope)
// update mutable values
Module.mutableProvider.provides { 21 }
/*..*/
scope.close()
}
Surfaced from shared tags and platforms — no rankings paid for.