class F1 : F{
val b = DepB()

val a = DepA(b)
val c = DepC(b)
}

class F2 : F{
val b = DepB()

val a = DepA(b)
val c = DepC(b)
}

F<x>

F

F1

F2

class Outer(val middle: Middle?)
class Middle(val inner: Inner)
interface Inner
module {
    factory { Outer(getOrNull()) }
    factoryOf(::Middle)
}

Inner

Inner

Middle

Outer

Inner

Middle

Outer

Inner

Middle

Inner

Outer

null

getOrNull

@Factory
class ****Adapter(private val imageLoader: ImageLoader) :
    RecyclerView.Adapter<****Adapter.ItemViewHolder>()

koinViewModel()

:desktop:jvmMain: Could not resolve io.insert-koin:koin-core:3.2.0.

:common:build.gradle.kts

sourceSets {

    val commonMain by getting {
        dependencies {

            ...

            // Koin
            api("io.insert-koin:koin-core:3.2.0")
            api("io.insert-koin:koin-android:3.2.0")

        }
    }

settings.gradle.kts

pluginManagement {
    repositories {
        google()
        gradlePluginPortal()
        mavenCentral()
        maven(url = "<https://maven.pkg.jetbrains.space/public/p/compose/dev>")
        maven(url = "<https://jitpack.io>")
    }

    plugins {
        kotlin("multiplatform") version "1.6.10"
        kotlin("android") version "1.6.10"
        kotlin("jvm") version "1.6.10"
        kotlin("plugin.serialization") version "1.6.20"
        id("com.android.application") version "7.0.4"
        id("com.android.library") version "7.0.4"
        id("org.jetbrains.compose") version "1.1.0"
        id("org.jetbrains.dokka") version "1.6.20"
        id("com.github.johnrengelman.shadow") version "7.1.2"
    }
}

build.gradle.kts

allprojects {
    repositories {
        google()
        gradlePluginPortal()
        mavenCentral()
        maven(url = "<https://maven.pkg.jetbrains.space/public/p/compose/dev>")
        maven(url = "<https://jitpack.io>")
    }
}

plugins {
    kotlin("multiplatform") apply false
    kotlin("android") apply false
    kotlin("jvm") apply false
    kotlin("plugin.serialization") apply false
    id("com.android.application") apply false
    id("com.android.library") apply false
    id("org.jetbrains.compose") apply false
    id("org.jetbrains.dokka") apply false
    id("com.github.johnrengelman.shadow") apply false
}

buildscript

"Not allow logging in with incorrect api key" {
                // given
                val payload = JsonObject(
                    mapOf(
                        "apikey" to JsonPrimitive("wrong"),
                        "username" to JsonPrimitive("jamma"),
                    )
                )
                // when
                testApplication {
                    application { Application::testModule }
                    environment {
                        config = ApplicationConfig("test-application.conf")
                    }
                    val client = createClient { install(ContentNegotiation) { json() } }

                    val response = <http://client.post|client.post>("api/login") {
                        contentType(ContentType.Application.Json)
                        setBody(payload)
                    }

                    // then
                    response shouldHaveStatus HttpStatusCode.Unauthorized
                }
            }

override fun extensions(): List<Extension> =
        listOf(KoinExtension(listOf(testDbModule, testHttpModule, RepositoryModule)))

getKoin().declare(MyObject())

class MyObject(val source: Map<String, Any> = emptyMap())

getKoin().declare(MyObject(mapOf("key" to value), allowOverride = true))

class Api : KoinComponent {
  val myObject: MyObject by inject()
}

getKoin().get<DeviceContext>()

api.myObject

single<Element>(createdAtStart = true)

loadKoinModules

singleOf(::Element) { createdAtStart() }

3.1.5

3.2.0

single { }

singleOf()

viewModel { }

viewModelOf()

java.lang.NoClassDefFoundError: Failed resolution of: Lorg/koin/dsl/ModuleKt;
        at com.metamap.sdk_components.di.AppModuleKt.<clinit>(AppModule.kt:26)
        at com.metamap.sdk_components.di.AppModuleKt.getApplicationModule(AppModule.kt:26)
        at com.metamap.metamap_sdk.SdkStartUpProvider.<init>(SdkStartUpProvider.kt:25)
        at java.lang.Class.newInstance(Native Method)
        at android.app.AppComponentFactory.instantiateProvider(AppComponentFactory.java:121)
        at androidx.core.app.CoreComponentFactory.instantiateProvider(CoreComponentFactory.java:67)
        at android.app.ActivityThread.installProvider(ActivityThread.java:6380)
        at android.app.ActivityThread.installContentProviders(ActivityThread.java:5938)
        at android.app.ActivityThread.handleBindApplication(ActivityThread.java:5853)
        at android.app.ActivityThread.access$1100(ActivityThread.java:199)
        at android.app.ActivityThread$H.handleMessage(ActivityThread.java:1650)
        at android.os.Handler.dispatchMessage(Handler.java:106)
        at android.os.Looper.loop(Looper.java:193)
        at android.app.ActivityThread.main(ActivityThread.java:6669)
        at java.lang.reflect.Method.invoke(Native Method)
        at com.android.internal.os.RuntimeInit$MethodAndArgsCaller.run(RuntimeInit.java:493)
        at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:858)
     Caused by: java.lang.ClassNotFoundException: Didn't find class "org.koin.dsl.ModuleKt" on path:

MockProviderRule

3.1.6

java.lang.IllegalStateException: Compose Runtime internal error. Unexpected or incorrect use of the Compose internal runtime API (Start/end imbalance

scope.close()

scoped<DateResolver> { (r: CurrentReservation) -> DateResolverFactory(r) }
        scoped<DateResolver> { (pd: ProductDetail) -> DateResolverFactory(pd) }

class A(b: B(), c: C())

class B(d: D())

class C()

A

class ATest : KoinTest {

    @JvmField
    @RegisterExtension
    val koinTestExtension = KoinTestExtension.create {
        val serviceModules = module {
            factory { B(get()) } 
        }

        val daoModules = module {
            factory { C() }
        }

        val httpClient = module {
            factory { D() }
        }

        modules(httpClient, daoModules, serviceModules)
    }

    @JvmField
    @RegisterExtension
    val mockProvider = MockProviderExtension.create { clazz ->
        mockkClass(clazz)
    }

    @Test
    fun doTest(koin: Koin) = runBlocking {
        declareMock<B> {
            coEvery { something(any()) } returns Either.Right("response")
        }
        declareMock<C> {
            coEvery { fetchDoc(any()) } returns Either.Right(GetItemResponse {
                item = mapOf("key" to AttributeValue.S("value"))
            })
        }

        val a = A(
            b = koin.get<B>(),
            c = koin.get<C>()
        )

        val resp = a.doSomething(request)
        assertEquals(resp.isLeft(), false)

    }
}

C

A

Koin

Kotlin

Kotlin

Kotlin

1.6

Koin

1.7

@Single

BuildConfig

scope(named("CONNECTED")) {  }

fun appModule() = listOf(AppModule().module)

@Module
@ComponentScan("com.makswin.bifrost")
class AppModule

class DependencyInjection : KoinComponent {
    val listTrainingsViewModel: ListTrainingsViewModel by inject()
    val getLastTrainingViewModel: GetLastTrainingViewModel by inject()
    val addFeedbackViewModel: AddFeedbackViewModel by inject()
    val insuranceViewModel: InsuranceViewModel by inject()
    val authViewModel: AuthViewModel by inject()
}

fun initKoin() {
    startKoin {
        modules(appModule())
    }
}

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    AppModuleKt.doInitKoin()
    return true
  }

class ObservableListTrainingViewModel : ObservableObject {
  @Published var state: ListTrainingsState?
   
  var viewModel: ListTrainingsViewModel?
   
  init(viewModel: ListTrainingsViewModel) {
    self.viewModel = viewModel
    asPublisher(viewModel.state)
      .compactMap { $0 }
      .receive(on: DispatchQueue.main)
      .assign(to: &state)
  }
}

struct ContentView : View {
   
  @Environment(\.presentationMode) var presentationMode
   
  @ObservedObject var viewModel: ObservableListTrainingViewModel

  init() {
    viewModel = ObservableListTrainingViewModel(viewModel: DependencyInjection().listTrainingsViewModel)
  }
   
  var body: some View {
     
      VStack {
        if let state = viewModel.state {
          Button("Button") {
            if state.trainings.isEmpty {
              self.viewModel.viewModel?.getTrainings(type: .next) // api call
            } else {
              presentationMode.wrappedValue.dismiss() // close the page
            }
          }
          if state.isLoading {
            Text("LOADING")
          }
          if !state.trainings.isEmpty {
            Text("\(state.trainings.first?.title ?? "NONE")")
          }
        }
      }
  }
}

@Single
class ListTrainingsViewModel(val listTrainingsUseCase: ListTrainingsUseCase) : ViewModel() {

    private val _state: MutableStateFlow<ListTrainingsState> = MutableStateFlow(ListTrainingsState())
    val state: CommonFlow<ListTrainingsState> = _state.asCommonFlow()

    fun getTrainings(type: TrainingListTimeType) {

        listTrainingsUseCase(type).collectCommon { result ->
            when (result) {
                is Resource.Error -> {
                    _state.value = ListTrainingsState(error = result.message ?: "")
                }
                is Resource.Loading -> {
                    _state.value = ListTrainingsState(isLoading = true)
                }
                is Resource.Success -> {
                    _state.value = ListTrainingsState(
                        trainings = result.data ?: emptyList(),
                        isLoading = false
                    )
                }
            }
        }

    }

}

fun <T> Flow<T>.collectCommon(
    coroutineScope: CoroutineScope? = null,
    callback: (T) -> Unit,
): Job {
    return onEach {
        callback(it)
    }.launchIn(coroutineScope ?: CoroutineScope(Dispatchers.Main))
}

viewModelOf

package com.vivek.sportsresult.di

import org.koin.androidx.viewmodel.dsl.viewModelOf
import org.koin.dsl.module

val appModule = module {
    viewModelOf(::MainActivityViewModel)
}