Android / KMP Dependency Injection (Koin)

Principles

• One Koin module per feature layer — create it only if there are dependencies to provide.
• Modules are assembled in :app, never in feature modules themselves.
• In Compose root composables, always inject ViewModels via koinViewModel().

Module Definitions

Prefer the constructor-reference overloads (singleOf, viewModelOf, factoryOf) — they are more concise and let Koin resolve parameters automatically. Only fall back to the lambda overloads (single { ... }, viewModel { ... }, factory { ... }) when constructor injection alone is not enough, e.g. when you need to call a factory method, pass a named/qualified dependency, or do post-construction setup.

Data layer module

// feature:notes:data
val notesDataModule = module {
    singleOf(::RoomNoteRepository) { bind<NoteRepository>() }
}

Presentation layer module

// feature:notes:presentation
val notesPresentationModule = module {
    viewModelOf(::NoteListViewModel)
    viewModelOf(::NoteDetailViewModel)
}

Core data module (example)

// core:data
val coreDataModule = module {
    // singleOf works when the class has a single injectable constructor
    singleOf(::SessionPreferences)

    // Lambda overload needed here — calling a factory method, not a constructor
    single { HttpClientFactory.create(get()) }
    single { createDataStore(get()) }
}

Assembly in :app

Register all modules in the Application class:

class App : Application() {
    override fun onCreate() {
        super.onCreate()
        startKoin {
            androidContext(this@App)
            modules(
                // core
                coreDataModule,
                // features
                notesDataModule,
                notesPresentationModule,
                authDataModule,
                authPresentationModule,
                // ...
            )
        }
    }
}

Injecting in Composables

Always use koinViewModel() in Root composables:

@Composable
fun NoteListRoot(
    onNavigateToDetail: (String) -> Unit,
    viewModel: NoteListViewModel = koinViewModel()
) { ... }

Never pass ViewModels down the composable tree — inject at the Root level only.

Scoping Rules

Use the *Of constructor-reference form by default. Only use the lambda form when you cannot express the binding with a constructor reference (factory methods, named qualifiers, manual setup).

Naming Conventions

Worker DI

For WorkManager Worker injection, see android-background skill — covers KoinWorkerFactory setup, disabling the default initializer, and the worker { } scope.

Checklist: Adding DI for a New Feature

• Define val <feature>DataModule = module { ... } in feature:data
• Define val <feature>PresentationModule = module { ... } in feature:presentation
• Register both modules in :app's startKoin { modules(...) }
• Use koinViewModel() in all Root composables