mcpField
K
koin-patterns

koin-patterns

github.com/ahmed3elshaerDevelopment6642 installsUpdated 19w ago
Repository

About koin-patterns

koin-patterns is a Kotlin skill describing dependency injection with Koin. It covers module setup, lifecycle scopes, ViewModel injection, qualifiers, and testing for Android application developers.

Key features

  1. 01Koin module setup
  2. 02Singleton and factory definitions
  3. 03Scoped dependencies and qualifiers
  4. 04ViewModel injection in Compose
  5. 05Koin-based testing

Use cases

  1. 01Organizing application dependencies
  2. 02Providing lifecycle-scoped objects
  3. 03Injecting ViewModels into Compose screens
  4. 04Testing code with Koin modules

Install

Copy the command and run it in a terminal.

$npx skills add https://github.com/ahmed3elshaer/everything-claude-code-mobile --skill koin-patterns

After installing, type/koin-patternsin Claude Code to confirm it loaded.

Details

From the project README

Koin Dependency Injection

Pragmatic DI for Kotlin with Koin.

Module Setup

// AppModule.kt
val appModule = module {
    // Singletons
    single<AppDatabase> { Room.databaseBuilder(...).build() }
    single { get<AppDatabase>().userDao() }
    
    // Factories (new instance each time)
    factory { DateFormatter() }
}

// NetworkModule.kt
val networkModule = module {
    single<HttpClient> {
        HttpClient(OkHttp) {
            install(ContentNegotiation) {
                json(Json { ignoreUnknownKeys = true })
            }
        }
    }
    
    single<AuthApi> { AuthApiImpl(get()) }
    single<UserApi> { UserApiImpl(get()) }
}

// FeatureModule.kt
val homeModule = module {
    // Repository
    single<HomeRepository> { HomeRepositoryImpl(get(), get()) }
    
    // Use Cases
    factory { GetItemsUseCase(get()) }
    factory { GetItemUseCase(get()) }
    
    // ViewModel
    viewModel { HomeViewModel(get()) }
}

Application Setup

class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        
        startKoin {
            androidContext(this@MyApp)
            modules(
                appModule,
                networkModule,
                homeModule,
                detailModule
            )
        }
    }
}

ViewModel Injection

// In Compose
@Composable
fun HomeScreen(viewModel: HomeViewModel = koinViewModel()) {
    val state by viewModel.state.collectAsStateWithLifecycle()
    // ...
}

// With parameters
@Composable
fun DetailScreen(itemId: String) {
    val viewModel: DetailViewModel = koinViewModel { parametersOf(itemId) }
    // ...
}

// ViewModel definition with params
viewModel { params ->
    DetailViewModel(
        itemId = params.get(),
        repository = get()
    )
}

Scopes

// Activity scope
val activityModule = module {
    scope<MainActivity> {
        scoped { NavigationController() }
    }
}

// Usage
class MainActivity : AppCompatActivity(), KoinScopeComponent {
    override val scope: Scope by activityScope()
    
    val nav: NavigationController by inject()
}

Qualifiers

val networkModule = module {
    single(named("auth")) { createAuthClient() }
    single(named("default")) { createDefaultClient() }
}

// Usage
class UserApi(
    @Named("auth") private val client: HttpClient
)

Testing

class HomeViewModelTest : KoinTest {
    
    @get:Rule
    val koinRule = KoinTestRule.create {
        modules(testModule)
    }
    
    private val testModule = module {
        single<HomeRepository> { mockk() }
        viewModel { HomeViewModel(get()) }
    }
    
    private val viewModel: HomeViewModel by inject()
    private val repository: HomeRepository by inject()
    
    @Test
    fun `loads items`() = runTest {
        coEvery { repository.getItems() } returns Result.success(listOf())
        // ...
    }
}

Remember: Koin is pragmatic. Keep modules organized, use scopes for lifecycle.

Comments

Markdown supported