CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/maven-io-insert-koin--koin-compose-jvm

Koin dependency injection integration with Jetpack Compose for Kotlin Multiplatform development.

—

Pending
Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

SecuritybySnyk

Pending

The risk profile of this skill

Overview
Eval results
Files

Koin Compose

Koin Compose provides seamless integration between the Koin dependency injection framework and Jetpack Compose for Kotlin Multiplatform development. It offers Compose-aware APIs for dependency injection, application setup, scope management, and module loading with full support for Compose lifecycle management.

Package Information

  • Package Name: koin-compose-jvm
  • Package Type: maven
  • Language: Kotlin
  • Installation: implementation("io.insert-koin:koin-compose-jvm:4.1.1")
  • Platforms: Android, JVM, JavaScript, Native (iOS/macOS), WASM-JS

Core Imports

import org.koin.compose.*

For specific functionality:

import org.koin.compose.KoinApplication
import org.koin.compose.KoinIsolatedContext
import org.koin.compose.KoinApplicationPreview
import org.koin.compose.koinInject
import org.koin.compose.getKoin
import org.koin.compose.currentKoinScope
import org.koin.compose.KoinScope
import org.koin.compose.rememberKoinScope
import org.koin.compose.rememberKoinModules

Basic Usage

@Composable
fun App() {
    KoinApplication(application = {
        // Configure Koin modules
        modules(appModule)
    }) {
        // Your Compose UI
        MainScreen()
    }
}

@Composable  
fun MainScreen() {
    // Inject dependencies directly in Composables
    val repository: UserRepository = koinInject()
    val service: ApiService = koinInject(qualifier = named("api"))
    
    // Use injected dependencies
    LaunchedEffect(Unit) {
        val users = repository.getUsers()
        // ...
    }
}

// Alternative: Using isolated context for modular features
@Composable
fun FeatureModule() {
    val isolatedApp = koinApplication {
        modules(featureModule)
    }
    
    KoinIsolatedContext(context = isolatedApp) {
        FeatureContent()
    }
}

Architecture

Koin Compose is built around several key components:

  • Application Context Management: Provides Koin application and scope contexts throughout the Compose hierarchy using Composition Locals
  • Lifecycle Integration: Automatic cleanup of scopes and modules when Compose components are forgotten or abandoned
  • Multiplatform Support: Platform-specific optimizations for Android (context injection) and other platforms
  • Experimental APIs: Advanced features for scope and module management with @KoinExperimentalAPI
  • Compose State Integration: Uses remember for state management and follows Compose recomposition patterns

Capabilities

Application Setup

Core functions for setting up Koin contexts within Compose applications, including both standard and multiplatform configurations.

@Composable
fun KoinApplication(
    application: KoinAppDeclaration,
    content: @Composable () -> Unit
)

@Composable  
@KoinExperimentalAPI
fun KoinMultiplatformApplication(
    config: KoinConfiguration,
    logLevel: Level = Level.INFO,
    content: @Composable () -> Unit
)

@Composable
fun KoinIsolatedContext(
    context: KoinApplication,
    content: @Composable () -> Unit
)

@Composable
fun KoinApplicationPreview(
    application: KoinAppDeclaration,
    content: @Composable () -> Unit
)

Application Setup

Dependency Injection

Type-safe dependency resolution functions that integrate with Compose recomposition and support parameters, qualifiers, and scopes.

@Composable
inline fun <reified T> koinInject(
    qualifier: Qualifier? = null,
    scope: Scope = currentKoinScope()
): T

@Composable
inline fun <reified T> koinInject(
    qualifier: Qualifier? = null,
    scope: Scope = currentKoinScope(),
    noinline parameters: ParametersDefinition
): T

@Composable
inline fun <reified T> koinInject(
    qualifier: Qualifier? = null,
    scope: Scope = currentKoinScope(),
    parametersHolder: ParametersHolder
): T

Dependency Injection

Context Access

Functions to retrieve current Koin application and scope contexts from anywhere in the Compose hierarchy.

@Composable
fun getKoin(): Koin

@Composable
fun currentKoinScope(): Scope

Context Access

Scope Management

Experimental APIs for creating and managing Koin scopes with automatic lifecycle management tied to Compose recomposition.

@KoinExperimentalAPI
@Composable
fun KoinScope(
    scopeDefinition: Koin.() -> Scope,
    content: @Composable () -> Unit
)

@KoinExperimentalAPI
@Composable
inline fun <reified T : Any> KoinScope(
    scopeID: ScopeID,
    noinline content: @Composable () -> Unit
)

@KoinExperimentalAPI
@Composable
fun KoinScope(
    scopeID: ScopeID,
    scopeQualifier: Qualifier,
    content: @Composable () -> Unit
)

@KoinExperimentalAPI
@Composable
fun rememberKoinScope(scope: Scope): Scope

Scope Management

Module Management

Experimental API for dynamically loading and unloading Koin modules based on Compose lifecycle events.

@KoinExperimentalAPI
@Composable
inline fun rememberKoinModules(
    unloadOnForgotten: Boolean? = null,
    unloadOnAbandoned: Boolean? = null,
    unloadModules: Boolean = false,
    crossinline modules: @DisallowComposableCalls () -> List<Module> = { emptyList() }
)

Module Management

Types

Core Types

/** Exception thrown when Koin Context is not found */
class UnknownKoinContext : Exception()

/** Parameters holder for dependency injection */
class ParametersHolder

/** Parameters definition function type */
typealias ParametersDefinition = () -> ParametersHolder

/** Scope identifier type */
typealias ScopeID = String

Composition Locals

/** Provides Koin application context throughout Compose hierarchy */
val LocalKoinApplication: ProvidableCompositionLocal<ComposeContextWrapper<Koin>>

/** Provides Koin scope context throughout Compose hierarchy */  
val LocalKoinScope: ProvidableCompositionLocal<ComposeContextWrapper<Scope>>

Error Handling

The library throws UnknownKoinContext when attempting to access Koin contexts that haven't been properly initialized through KoinApplication or related setup functions.

try {
    val koin = getKoin()
} catch (e: UnknownKoinContext) {
    // Handle missing Koin context
}

Platform-Specific Behavior

Android

  • Automatically injects LocalContext.current.applicationContext into Koin application
  • Uses Android-specific logging
  • Integrates with Android Activity/Fragment lifecycle

Other Platforms (JVM, JS, Native, WASM-JS)

  • Uses print-based logging
  • Standard Koin platform initialization
  • Full Kotlin Multiplatform compatibility

API Stability

  • Stable: Core dependency injection, application setup, context access
  • Experimental (@KoinExperimentalAPI): Scope management, module management, multiplatform application setup
  • Deprecated: KoinContext function (no longer needed with modern Compose integration)
Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/io.insert-koin/koin-compose-jvm@4.1.x
Publish Source
CLI
Badge
tessl/maven-io-insert-koin--koin-compose-jvm badge