Using a custom HTTP client
By default, Apollo Kotlin uses the following HTTP clients for different platforms/languages:
Platform | HTTP Client |
---|---|
Android/JVM | OkHttp |
JavaScript/Wasm | fetch() / Node Fetch for HTTP, Ktor for WebSockets |
iOS/MacOS | NSURLSesssion |
Ktor engine
Additionally, an optional implementation based on Ktor for all targets is available in the apollo-engine-ktor
module. To use it, add the following dependency to your project:
dependencies {// ...implementation("com.apollographql.apollo3:apollo-engine-ktor:4.0.0-beta.7")}
And configure your ApolloClient
to use the Ktor engine:
val client = ApolloClient.Builder().serverUrl("https://example.com/graphql")// Create a new Ktor engine.httpEngine(KtorHttpEngine())// Or, if you want to reuse an existing Ktor client.ktorClient(myKtorClient).build()
Implement your own HTTP engine
You can use a different HTTP client with Apollo Kotlin by creating a custom class that implements the HttpEngine
interface.
The HttpEngine interface
defines two functions: execute
and close
. Here's an example implementation that also includes a couple of helper
methods:
class MyHttpEngine(val wrappedClient: MyClient) : HttpEngine {/*** Helper function to map the Apollo requests to MyClient requests*/private fun HttpMethod.toMyClientRequest(): MyClientRequest {...}/*** And the other way around*/private fun MyClientResponse.toApolloResponse(): HttpResponse {...}override suspend fun execute(request: HttpRequest) = suspendCancellableCoroutine { continuation ->val call = wrappedClient.newCall(request.toMyClientRequest())continuation.invokeOnCancellation {// If the coroutine is cancelled, also cancel the HTTP callcall.cancel()}wrappedClient.enqueue(call,success = { myResponse ->// Success! report the responsecontinuation.resume(myResponse.toApolloResponse())},error = { throwable ->// Error. Wrap in an ApolloException and report the errorcontinuation.resumeWithException(ApolloNetworkException(throwable))})}override fun close() {// Dispose any resources here}}
This example uses an asynchronous wrappedClient
that runs the network request in a separate thread. Note that because HttpEngine.execute
itself is called from a background thread, you can safely block in execute()
.
Using your HttpEngine
After you create your HttpEngine
implementation, you can register it with your ApolloClient
instance using ApolloClient.Builder.httpEngine
:
// Use your HttpEngineval client = ApolloClient.Builder().serverUrl(serverUrl = "https://example.com/graphql").httpEngine(httpEngine = MyHttpEngine(wrappedClient)).build()
With this configuration, Apollo Kotlin sends all of its GraphQL operation requests with MyHttpEngine
.
Other HTTP customizations
Besides implementing HttpEngine
, Apollo Kotlin also supports other methods for customizing HTTP behavior:
- No runtime: You can opt out of the Apollo Kotlin runtime completely and only use generated models and parsers. Use this option if you don't need any of the runtime features (caching, batching, automatic persisted queries, etc.).
- HTTP interceptors: If you want to add HTTP headers and/or logging to your requests, HTTP interceptors enable you to do this with minimal code.