You're viewing documentation for a version of this software that is in development. Switch to the latest stable version
Launch Apollo Studio

Using a custom HTTP client


By default, Apollo Android uses the following HTTP clients for different platforms/languages:

PlatformHTTP Client
AndroidOkHttp
JavaScriptKtor
iOS/MacOSNSURLSesssion

You can use a different HTTP client with Apollo Android by creating a custom class that implements the HttpEngine interface.

The HttpEngine interface

The HttpEngine interface defines two functions: execute and dispose. 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 call
      call.cancel()
    }

    wrappedClient.enqueue(
        call,
        success = { myResponse ->
          // Success! report the response
          continuation.resume(myResponse.toApolloResponse())
        },
        error = { throwable ->
          // Error. Wrap in an ApolloException and report the error
          continuation.resumeWithException(ApolloNetworkException(throwable))
        }
    )
  }

  override fun dispose() {
    // 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 HttpEngine
val client = ApolloClient.Builder()
  .serverUrl(serverUrl = "https://com.example/graphql")
  .httpEngine(httpEngine = MyHttpEngine(wrappedClient))
  .build()

With this configuration, Apollo Android sends all of its GraphQL operation requests with MyHttpEngine.

Other HTTP customizations

Besides implementing HttpEngine, Apollo Android also supports other methods for customizing HTTP behavior:

  • No runtime: You can opt out of the Apollo Android 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.
Edit on GitHub