or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

application-setup.mdcomponents.mddependency-injection.mderror-handling.mdindex.mdmodules-and-definitions.mdqualifiers-parameters.mdscoping.md
tile.json

tessl/maven-io-insert-koin--koin-core-iossimulatorarm64

Koin Core is a pragmatic lightweight dependency injection framework for Kotlin Multiplatform with iOS Simulator ARM64 target support.

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/io.insert-koin/koin-core-iossimulatorarm64@4.1.x

To install, run

npx @tessl/cli install tessl/maven-io-insert-koin--koin-core-iossimulatorarm64@4.1.0

index.mddocs/

Koin Core - Dependency Injection Framework

Koin Core is a pragmatic lightweight dependency injection framework for Kotlin Multiplatform applications with iOS Simulator ARM64 target support. It provides a simple DSL to declare your application components and manages their lifecycle automatically.

Overview

Koin Core offers several key capabilities for dependency injection:

  • Application Setup & Configuration - Initialize and configure your Koin context
  • Core Dependency Injection - Inject dependencies throughout your application
  • Module System & Definitions - Organize dependencies into reusable modules
  • Scope Management - Manage component lifecycles with scoped dependencies
  • Component Integration - Integrate DI into your classes with component interfaces
  • Qualifiers & Parameters - Distinguish between similar dependencies and pass parameters
  • Error Handling - Comprehensive exception system for DI failures

Quick Start

import org.koin.core.Koin
import org.koin.core.KoinApplication
import org.koin.dsl.*

// Define a module
val appModule = module {
    single<Repository> { DatabaseRepository() }
    factory<UseCase> { GetDataUseCase(get()) }
}

// Start Koin
val koinApp = koinApplication {
    modules(appModule)
}

// Get dependencies
val repository: Repository = koinApp.koin.get()

Application Setup & Configuration

Koin applications are configured using KoinApplication which provides the main entry point and configuration options.

Core Application Functions

// Create and configure a Koin application
fun koinApplication(
    createEagerInstances: Boolean = true, 
    appDeclaration: KoinAppDeclaration? = null
): KoinApplication

fun koinApplication(appDeclaration: KoinAppDeclaration?): KoinApplication
fun koinApplication(configuration: KoinConfiguration?): KoinApplication
fun koinApplication(createEagerInstances: Boolean): KoinApplication

// Type aliases
typealias KoinAppDeclaration = KoinApplication.() -> Unit

KoinApplication Class

class KoinApplication {
    val koin: Koin
    
    // Module management
    fun modules(modules: Module): KoinApplication
    fun modules(vararg modules: Module): KoinApplication
    fun modules(modules: List<Module>): KoinApplication
    
    // Configuration
    fun allowOverride(override: Boolean): Unit
    fun properties(values: Map<String, Any>): KoinApplication
    fun logger(logger: Logger): KoinApplication
    fun printLogger(level: Level = Level.INFO): KoinApplication
    fun options(vararg optionValue: Pair<KoinOption, Any>): KoinApplication
    
    // Lifecycle
    fun createEagerInstances(): Unit
    fun close(): Unit
    
    companion object {
        fun init(): KoinApplication
    }
}

→ Application Setup & Configuration

Core Dependency Injection

The Koin class provides the main dependency resolution and injection capabilities.

Primary Injection Methods

class Koin {
    // Direct resolution
    inline fun <reified T : Any> get(
        qualifier: Qualifier? = null,
        noinline parameters: ParametersDefinition? = null
    ): T
    
    // Lazy injection
    inline fun <reified T : Any> inject(
        qualifier: Qualifier? = null,
        mode: LazyThreadSafetyMode = KoinPlatformTools.defaultLazyMode(),
        noinline parameters: ParametersDefinition? = null
    ): Lazy<T>
    
    // Nullable variants
    inline fun <reified T : Any> getOrNull(/* ... */): T?
    inline fun <reified T : Any> injectOrNull(/* ... */): Lazy<T?>
    
    // Non-reified variants
    fun <T> get(clazz: KClass<*>, qualifier: Qualifier?, parameters: ParametersDefinition?): T
    fun <T> getOrNull(clazz: KClass<*>, qualifier: Qualifier?, parameters: ParametersDefinition?): T?
    
    // Collections
    inline fun <reified T> getAll(): List<T>
    
    // Instance declaration
    inline fun <reified T> declare(
        instance: T,
        qualifier: Qualifier? = null,
        secondaryTypes: List<KClass<*>> = emptyList(),
        allowOverride: Boolean = true
    )
    
    // Property management
    fun <T : Any> getProperty(key: String, defaultValue: T): T
    fun <T : Any> getProperty(key: String): T?
    fun setProperty(key: String, value: Any)
    fun deleteProperty(key: String)
    
    // Scope management
    fun deleteScope(scopeId: ScopeID)
    fun getScopeOrNull(scopeId: ScopeID): Scope?
    
    // Module management
    fun loadModules(modules: List<Module>, allowOverride: Boolean = true, createEagerInstances: Boolean = false)
    fun unloadModules(modules: List<Module>)
}

→ Core Dependency Injection

Module System & Definitions

Modules organize your dependencies using a simple DSL for defining singletons, factories, and scoped instances.

Module Creation

// Create module
fun module(createdAtStart: Boolean = false, moduleDeclaration: ModuleDeclaration): Module

typealias ModuleDeclaration = Module.() -> Unit

Definition DSL

class Module {
    val id: String
    val isLoaded: Boolean
    var eagerInstances: LinkedHashSet<SingleInstanceFactory<*>>
    
    // Core definitions
    inline fun <reified T> single(
        qualifier: Qualifier? = null,
        createdAtStart: Boolean = false,
        definition: Definition<T>
    ): KoinDefinition<T>
    
    inline fun <reified T> factory(
        qualifier: Qualifier? = null,
        definition: Definition<T>
    ): KoinDefinition<T>
    
    // Scope definitions  
    fun scope(qualifier: Qualifier, scopeSet: ScopeDSL.() -> Unit)
    inline fun <reified T> scope(scopeSet: ScopeDSL.() -> Unit)
    
    // Module composition
    fun includes(vararg module: Module)
    fun includes(module: Collection<Module>)
    operator fun plus(module: Module): List<Module>
}

// Type aliases
typealias Definition<T> = Scope.(ParametersHolder) -> T

→ Module System & Definitions

Scope Management

Scopes provide lifecycle management for dependencies, allowing you to create and destroy sets of related instances.

Scope Class

class Scope {
    val scopeQualifier: Qualifier
    val id: ScopeID
    val isRoot: Boolean
    val closed: Boolean
    
    // Resolution methods
    inline fun <reified T : Any> inject(/* ... */): Lazy<T>
    inline fun <reified T : Any> get(/* ... */): T
    inline fun <reified T : Any> getAll(): List<T>
    
    // Scope operations
    fun linkTo(vararg scopes: Scope)
    fun unlink(vararg scopes: Scope)
    fun close()
}

typealias ScopeID = String

Scope DSL

class ScopeDSL {
    inline fun <reified T> scoped(
        qualifier: Qualifier? = null,
        definition: Definition<T>
    ): KoinDefinition<T>
    
    inline fun <reified T> factory(
        qualifier: Qualifier? = null,
        definition: Definition<T>
    ): KoinDefinition<T>
}

→ Scope Management

Component Integration

Component interfaces provide automatic dependency injection capabilities to your classes.

Core Component Interfaces

interface KoinComponent {
    fun getKoin(): Koin
}

interface KoinScopeComponent : KoinComponent {
    val scope: Scope
}

// Extension functions for KoinComponent
inline fun <reified T : Any> KoinComponent.get(/* ... */): T
inline fun <reified T : Any> KoinComponent.inject(/* ... */): Lazy<T>

// Extension functions for KoinScopeComponent  
fun <T : Any> T.getScopeId(): String
fun <T : Any> T.getScopeName(): TypeQualifier
fun <T : KoinScopeComponent> T.createScope(/* ... */): Scope

→ Component Integration

Qualifiers & Parameters

Qualifiers distinguish between different instances of the same type, while parameters allow passing runtime values during injection.

Qualifier System

interface Qualifier {
    val value: QualifierValue
}

typealias QualifierValue = String

// Qualifier creation functions
fun named(name: String): StringQualifier
fun <E : Enum<E>> named(enum: Enum<E>): Qualifier
fun qualifier(name: String): StringQualifier
inline fun <reified T> named(): TypeQualifier
fun _q(name: String): StringQualifier

// Qualifier implementations
class StringQualifier : Qualifier
class TypeQualifier : Qualifier

Parameter System

class ParametersHolder {
    val values: List<Any?>
    var index: Int
    
    // Access methods
    operator fun <T> get(i: Int): T
    inline fun <reified T : Any> get(): T
    inline operator fun <reified T> component1(): T // through component5()
    
    // Utility methods
    fun size(): Int
    fun isEmpty(): Boolean
    fun add(value: Any): ParametersHolder
}

// Parameter creation functions
fun parametersOf(vararg parameters: Any?): ParametersHolder
fun emptyParametersHolder(): ParametersHolder

typealias ParametersDefinition = () -> ParametersHolder

→ Qualifiers & Parameters

Error Handling

Koin provides comprehensive exception handling for dependency injection failures.

Core Exception Types

// Resolution failures
class NoDefinitionFoundException : RuntimeException
class InstanceCreationException : RuntimeException
class NoParameterFoundException : RuntimeException

// Scope failures  
class ClosedScopeException : RuntimeException
class ScopeNotCreatedException : RuntimeException
class ScopeAlreadyCreatedException : RuntimeException
class NoScopeDefFoundException : RuntimeException
class MissingScopeValueException : RuntimeException

// Configuration failures
class DefinitionOverrideException : RuntimeException
class DefinitionParameterException : RuntimeException
class MissingPropertyException : RuntimeException
class NoPropertyFileFoundException : RuntimeException
class KoinApplicationAlreadyStartedException : RuntimeException

→ Error Handling

Platform Integration

// Platform-specific utilities
object KoinPlatformTools {
    fun defaultLazyMode(): LazyThreadSafetyMode
    fun generateId(): String
}

// Thread-local storage
expect class ThreadLocal<T>

// Time utilities  
class KoinPlatformTimeTools

This comprehensive framework enables clean, testable dependency injection across your Kotlin Multiplatform applications with minimal boilerplate and maximum flexibility.