micHar

createPublisher(wrapper: loadUserUseCase.loadUser(username: "noone special"))
    .sink(
        receiveCompletion: { completion in
            print("Completion: \(completion)")
        },
        receiveValue: { user in
            print("Hello from the Kotlin side \(user?.name)")
        }
    )
    .store(in: &cancellables)

micHar

func createPublisher<T>(
    wrapper: KoruSuspendWrapper<T>
) -> AnyPublisher<T?, Error> {
    var job: Kotlinx_coroutines_coreJob? = nil
    return Deferred {
        Future<T?, Error> { promise in
            job = wrapper.subscribe(
                onSuccess: { item in promise(.success(item)) },
                onThrow: { error in promise(.failure(SharedError(error))) }
            )

micHar

let loadUserUseCase = sharedComponent.provideLoadUserUseCase()
        
loadUserUseCase.loadUser(username: "nobody special").subscribe(
     onSuccess: { user in print(user?.description()) },
     onThrow: { error in print(error.description()) }
)

micHar

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
    
    let sharedComponent = IosComponent()
    
    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        IosComponentKt.doInitIosDependencies()
        return true
    }
    

micHar

fun initIosDependencies() = startKoin {
    modules(commonModule, iosModule)
}

private val iosModule = module {
    factory { LoadUserUseCaseIos(get()) }
    factory { SaveUserUseCaseIos(get()) }
    factory { ObserveUsersUseCaseIos(get()) }
}

micHar

val commonModule = module {
    single { UserService() }
    factory { LoadUserUseCase(get()) }
    factory { SaveUserUseCase(get()) }
    factory { ObserveUsersUseCase(get()) }
}

micHar

@ExportedScopeProvider
class MainScopeProvider : ScopeProvider {
    override val scope : CoroutineScope = MainScope()
}

micHar

public class SaveUserUseCaseIos(
  private val wrapped: SaveUserUseCase
) {
  public fun saveUser(user: User): SuspendWrapper<Unit> =
      SuspendWrapper(exportedScopeProvider_mainScopeProvider) { wrapped.saveUser(user) }
}

micHar

@ToNativeClass(name = "LoadUserUseCaseIos", launchOnScope = MainScopeProvider::class)
class LoadUserUseCase(private val service: UserService){

    suspend fun loadUser(username: String) : User? = service.loadUser(username)

    fun getUserBlocking(username: String) : User? = service.getUser(username)

}

@ToNativeClass(name = "ObserveUsersUseCaseIos", launchOnScope = MainScopeProvider::class)

micHar

plugins {
    kotlin("multiplatform")
    id("com.android.library")
    kotlin("kapt")
}

kotlin {
  //...
  sourceSets {