How do you keep your ktor client setup in common while having different engines per platform, while each platform has its config in the

engine { ... }

block? If it were somehow on the Engine object, then I'd get it, I'd just expect actual the Engine factory ...or do I have to expect actual both factory for Engine AND the engine block?

If we're only talking about the client, you don't need to expect-actual anything, the

HttpClient

constructor is in common

but how do I pass it the platform engine, if not for expect actual?

Do you need to?

// commonMain/kotlin/Client

fun createClient() = HttpClient {
    install(Logging) { … }
    install(ContentNegotiation) { … } 
}

This works

hm but what engine does that choose?

right, but how do I then do platform config

Ah, in that case you will need to expect-actual, yes. What you can do is to create an extension function on

HttpClientConfig<*>

which has your common configuration, and call it in your various actuals that add platform-specific config: https://gitlab.com/opensavvy/formulaide/-/blob/main/remote-client/src/commonMain/kotlin/Client.kt#L17

I see, so the other way around, extracting the common setup and calling it in platform specific code

In the example I showed you what's in the common code is just a factory, if you want to create multiple client instances you can call the factory multiple times

I know but those arent shallow copies of each other? the way

okhttp.newBuilder()

does

I don't know if that's possible, maybe send a new message in the channel so other people see it (since that's essentially a new question)

I did, no response unfortunately

Not sure what plugins you're using, but I doubt it makes any difference for normal plugins

well, probably true, my interceptors in okhttp are trivial, but main thing is okhttp threadpools and all the internal resources, same things which make you want to cache the ktor httpclient instance, not create new one per call

Didn't you say you're using

preconfigured=

? In that case, you just have to pass the same object for both calls and they share the OkHttp instance

well yes, hmm which means the engine is the heavy part, and I could just share that?

I don't know OkHttp, so maybe there's a limitation on their side, but my understanding of Ktor is that you can, yes

I mean yes it will work, but whats confusing, is that there is already a concept of the shallow copy