How to Cache API response in Kotlin

anchit

25 September 2024

Caching is key to boosting app performance by reducing network requests and speeding up data retrieval. In this article, we’ll explore how to implement various caching techniques in Kotlin using popular libraries like Retrofit, Volley, Apollo etc., helping you optimize API performance and improve the user experience.

While there are many other Api Client libraries in Android and Kotlin, we will be focusing on the three most popular listed below

Library	Type	Features	Use Case
Retrofit	REST	Popular, supports OkHttp, Coroutines, RxJava, JSON/XML	REST APIs
Volley	REST	Built-in caching, image loading, retry policies	REST APIs(Android-specific)
Apollo	GraphQL	Strongly typed GraphQL queries, caching, Kotlin coroutines	GraphQL APIs

Now, we’ll explore how we can cache response using these libraries along with basic code examples.

Retrofit

Retrofit, by far the most popular API client library for REST APIs in Android provides support for caching via OkHttp.
You can configure OkHttpClient with a disk cache, and Retrofit will automatically cache responses based on HTTP cache headers like Cache-Control.

Example ->

val cacheSize = 10 * 1024 * 1024 // 10 MB cache
val cache = Cache(applicationContext.cacheDir, cacheSize.toLong())

val okHttpClient = OkHttpClient.Builder()
    .cache(cache) // Enable caching
    .addInterceptor { chain -&gt;
        var request = chain.request()
        request = if (hasNetwork(applicationContext))
            request.newBuilder().header("Cache-Control", "public, max-age=60").build()
        else
            request.newBuilder().header("Cache-Control", "public, only-if-cached, max-stale=2419200").build()
        chain.proceed(request)
    }
    .build()

val retrofit = Retrofit.Builder()
    .client(okHttpClient)
    .baseUrl("https://api.example.com/")
    .build()

val cacheSize = 10 * 1024 * 1024 // 10 MB cache

val cache = Cache(applicationContext.cacheDir, cacheSize.toLong())

val okHttpClient = OkHttpClient.Builder()

.cache(cache) // Enable caching

.addInterceptor { chain ->

var request = chain.request()

request = if (hasNetwork(applicationContext))

request.newBuilder().header("Cache-Control", "public, max-age=60").build()

else

request.newBuilder().header("Cache-Control", "public, only-if-cached, max-stale=2419200").build()

chain.proceed(request)

}

.build()

val retrofit = Retrofit.Builder()

.client(okHttpClient)

.baseUrl("https://api.example.com/")

.build()

Volley

Volley is an HTTP library developed by Google that makes networking for Android apps easier and faster. Volley has built-in support for caching HTTP responses to disk. By default, it caches responses in memory and can store responses on disk based on HTTP headers (Cache-Control, Expires).

Example ->

// Function to initialize Volley RequestQueue with caching
fun createRequestQueue(cacheDir: File): RequestQueue {
    val cache = DiskBasedCache(cacheDir, 10 * 1024 * 1024) // 10 MB cache
    val network = BasicNetwork(HurlStack())
    return RequestQueue(cache, network).apply {
        start() // Start the request queue
    }
}

// Function to make a GET request
fun fetchData(requestQueue: RequestQueue, url: String) {
    val stringRequest = StringRequest(Request.Method.GET, url,
        Response.Listener&lt;String&gt; { response -&gt;
            // Handle successful response
            println("Response: $response")
        },
        Response.ErrorListener { error -&gt;
            // Handle error response
            println("Error: ${error.message}")
        }
    )

    // Add the request to the RequestQueue
    requestQueue.add(stringRequest)
}

// Usage example
val requestQueue = createRequestQueue(applicationContext.cacheDir)
fetchData(requestQueue, "https://api.example.com/data")

// Function to initialize Volley RequestQueue with caching

fun createRequestQueue(cacheDir: File): RequestQueue {

val cache = DiskBasedCache(cacheDir, 10 * 1024 * 1024) // 10 MB cache

val network = BasicNetwork(HurlStack())

return RequestQueue(cache, network).apply {

start() // Start the request queue

}

// Function to make a GET request

fun fetchData(requestQueue: RequestQueue, url: String) {

val stringRequest = StringRequest(Request.Method.GET, url,

Response.Listener<String> { response ->

// Handle successful response

println("Response: $response")

Response.ErrorListener { error ->

// Handle error response

println("Error: ${error.message}")

}

)

// Add the request to the RequestQueue

requestQueue.add(stringRequest)

}

// Usage example

val requestQueue = createRequestQueue(applicationContext.cacheDir)

fetchData(requestQueue, "https://api.example.com/data")

Apollo

Apollo is a powerful GraphQL client for Android that simplifies data fetching and management by generating strongly typed models from GraphQL queries. Apollo provides two major ways to cache any API response namely Normalized Cache and HTTP Response Cache.

Normalized Cache stores GraphQL responses in a normalized form in memory or SQLite, so it can cache individual objects and fields.
HTTP Cache: Similar to OkHttp caching for raw HTTP responses.

Normalized Cache Example ->

val cacheFactory = MemoryCacheFactory(context, "apollo_cache.db")
val apolloClient = ApolloClient.Builder()
    .serverUrl("https://api.example.com/graphql")
    .normalizedCache(cacheFactory) // Use normalized cache
    .build()

// Using cache policy
val response = apolloClient.query(MyQuery())
    .cachePolicy(CacheFirst)
    .execute()

val cacheFactory = MemoryCacheFactory(context, "apollo_cache.db")

val apolloClient = ApolloClient.Builder()

.serverUrl("https://api.example.com/graphql")

.normalizedCache(cacheFactory) // Use normalized cache

.build()

// Using cache policy

val response = apolloClient.query(MyQuery())

.cachePolicy(CacheFirst)

.execute()

HTTP Cache Example ->

val apolloClient = ApolloClient.Builder()
    .httpCache(
      directory = File(pathToCacheDirectory),
      maxSize = 100 * 1024 * 1024
    )
    .build()

val apolloClient = ApolloClient.Builder()

.httpCache(

directory = File(pathToCacheDirectory),

maxSize = 100 * 1024 * 1024

)

.build()

This is how we can cache API responses in popular API client Libraries of Android in Kotlin Language.
Hope this helps you.
Keep coding and keep