Monitor the network state to reduce latency

Network Monitor APIs are currently experimental in Apollo Kotlin. If you have feedback on them, please let us know via GitHub issues or in the Kotlin Slack community.

Android and Apple targets provide APIs to monitor the network state of your device:

ConnectivityManager on Android targets.
NWPathMonitor on Apple targets.

You can configure your ApolloClient to use these APIs to improve latency of your requests using the NetworkMonitor API:

1
// androidMain
2
val networkMonitor = NetworkMonitor(context)
3

4
// appleMain
5
val networkMonitor = NetworkMonitor()
6

7
// commonMain
8
val apolloClient = ApolloClient.Builder()
9
    .serverUrl("https://example.com/graphql")
10
    .networkMonitor(networkMonitor)
11
    .build()

`failFastIfOffline`

When a NetworkMonitor is configured, you can use failFastIfOffline to avoid trying out request if the device is offline:

1
// Opt-in `failFastIfOffline` on all queries
2
val apolloClient = ApolloClient.Builder()
3
    .serverUrl("https://example.com/graphql")
4
    .failFastIfOffline(true)
5
    .build()
6

7
val response = apolloClient.query(myQuery).execute()
8
println(response.exception?.message)
9
// "The device is offline"
10

11
// Opt-out `failFastIfOffline` on a single query
12
val response = apolloClient.query(myQuery).failFastIfOffline(false).execute()

When a NetworkMonitor is configured, retryOnError uses NetworkMonitor.waitForNetwork() instead of the default exponential backoff algorithm in order to reconnect faster when connectivity is back.

Customizing the retry algorithm

You can customize the retry algorithm further by defining you won interceptor. Make sure to:

add your interceptor last, so that it wraps the network call and doesn't get cache misses or any other errors that may be emitted by upstream interceptors.
call retryOnError(false) when forwarding the request downstream so that the retry is not made twice.

1
internal class MyRetryInterceptor(private val networkMonitor: NetworkMonitor?): ApolloInterceptor {
2
  override fun <D : Operation.Data> intercept(request: ApolloRequest<D>, chain: ApolloInterceptorChain): Flow<ApolloResponse<D>> {
3
    // Disable Apollo's built-in retry mechanism
4
    val newRequest = request.newBuilder().retryOnError(false).build()
5
    return chain.proceed(newRequest)
6
        .onEach { 
7
          if (it.exception != null && it.exception.shouldRetry()) {
8
            throw RetryException
9
          }
10
        }.retryWhen { cause, _-> 
11
          if (cause is RetryException) {
12
            // Add your logic here
13
            true
14
          } else {
15
            // Programming error, re-throw it
16
            false
17
          }
18
        }
19
  }
20
}

Uploading files

Handling nullability