ahmed3elshaer/everything-claude-code-mobile/kmp-di

// build.gradle.kts (shared module)
sourceSets {
    val commonMain by getting {
        dependencies {
            implementation("io.insert-koin:koin-core:${koinVersion}")
            implementation("io.insert-koin:koin-test:${koinVersion}")
        }
    }
    val androidMain by getting {
        dependencies {
            implementation("io.insert-koin:koin-android:${koinVersion}")
        }
    }
}

// commonMain/kotlin/di/AppModule.kt
val sharedModule = module {
    // ViewModels (Android) / ScreenModels (multiplatform)
    factory { HomeViewModel(get(), get()) }
    factory { DetailViewModel(get()) }
 
    // Use Cases
    factory { GetUsersUseCase(get()) }
    factory { GetUserDetailUseCase(get()) }
 
    // Repositories
    single<UserRepository> { UserRepositoryImpl(get(), get()) }
 
    // Data Sources
    single { UserApi(get()) }
    single { createDatabase(get()) }
}

// androidMain/kotlin/di/PlatformModule.kt
val androidPlatformModule = module {
    includes(sharedModule)
 
    // Android-specific dependencies
    single { android.content.Context() }
    single { PlatformConnectivityMonitor(get()) }
    single { PlatformFileService(get()) }
}
 
// iosMain/kotlin/di/PlatformModule.kt
val iosPlatformModule = module {
    includes(sharedModule)
 
    // iOS-specific dependencies
    single { PlatformConnectivityMonitor() }
    single { PlatformFileService() }
}

// androidMain/kotlin/MyApp.kt
class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        startKoin {
            androidContext(this@MyApp)
            modules(androidPlatformModule)
        }
    }
}

// iosMain/kotlin/di/KoinInit.kt
fun initKoin() {
    startKoin {
        modules(iosPlatformModule)
    }
}
 
// Called from Swift
// KotlinKMMSharedKt.doInitKoin()

// commonMain/kotlin/Main.kt
fun main() {
    startKoin {
        modules(sharedModule)
    }
 
    App()
}

// androidMain/kotlin/ui/HomeScreen.kt
@Composable
fun HomeScreen(
    viewModel: HomeViewModel = koinViewModel()
) {
    val state by viewModel.state.collectAsStateWithLifecycle()
    HomeContent(state)
}

// commonMain/kotlin/ui/HomeScreen.kt
@Composable
fun HomeScreen() {
    val model = getScreenModel<HomeScreenModel>()
    val state by model.state.collectAsState()
 
    HomeContent(state)
}

// ✅ factory - creates new instance each time
factory { HomeViewModel(get(), get()) }
 
// ✅ single - shared instance
single<UserRepository> { UserRepositoryImpl(get(), get()) }
 
// ✅ scoped - tied to component lifetime
scoped(HomeScope.homeScope) { HomeData(get()) }

// ✅ Named dependencies
module {
    single(named("default")) { DefaultLogger() }
    single(named("analytics")) { AnalyticsLogger() }
 
    factory { MyRepository(logger = get(named("default"))) }
}

// commonMain/kotlin/di/ServiceLocator.kt
object ServiceLocator {
    private val services = mutableMapOf<String, Any>()
 
    fun <T> get(key: String): T {
        return services[key] as T
    }
 
    fun register(key: String, service: Any) {
        services[key] = service
    }
 
    fun init() {
        register("repository", UserRepositoryImpl())
        register("api", UserApi())
    }
}

// commonMain/kotlin/di/AppContainer.kt
class AppContainer(
    private val platformService: PlatformService
) {
    val api: UserApi = UserApi()
    val database: AppDatabase = createDatabase()
 
    val userRepository: UserRepository by lazy {
        UserRepositoryImpl(api, database)
    }
 
    val homeViewModel: HomeViewModel by lazy {
        HomeViewModel(userRepository, platformService)
    }
}

// commonTest/kotlin/di/TestModule.kt
val testModule = module {
    single<MockUserService> { MockUserService() }
    single<UserService>(override = true) { get<MockUserService>() }
}
 
// In tests
@BeforeTest
fun setup() {
    startKoin { modules(testModule) }
}
 
@AfterTest
fun tearDown() {
    stopKoin()
}