Day 48: Kotlin Multiplatform Caching Strategies — Efficient Offline Storage & Data Management 💾

Welcome to Day 48 of your Kotlin Multiplatform learning journey! 👋 Yesterday, in **Day 47, you explored Kotlin Multiplatform Networking with Ktor** — making API calls from shared code for Android and iOS.

Non-Member can access from the below link:

https://medium.com/@info.shaludroid/f9dcd3c4639c?source=friends_link&sk=edf9065eebb02327980d9681a6426919

Today, you’ll focus on Caching Strategies — storing and retrieving data efficiently in shared code to enable offline functionality and improve performance.

Why Caching Matters in KMP

• Reduces repeated network calls.
• Improves app responsiveness and user experience.
• Enables offline access for critical data.
• Works seamlessly across Android and iOS.

1️⃣ In-Memory Caching (Simple & Fast)

object MemoryCache {
    private val cache = mutableMapOf<String, Any>()

    fun <T> put(key: String, value: T) {
        cache[key] = value as Any
    }

    @Suppress("UNCHECKED_CAST")
    fun <T> get(key: String): T? = cache[key] as? T
}

// Usage
MemoryCache.put("users", listOf("Alice", "Bob"))
val users: List<String>? = MemoryCache.get("users")

✅ Fast access, but data is lost when the app restarts.

2️⃣ File-based Caching (Persistent)

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import kotlinx.serialization.encodeToString
import kotlinx.serialization.decodeFromString
import kotlinx.serialization.json.Json
import okio.FileSystem
import okio.Path.Companion.toPath

object FileCache {
    private val file = "cache.json".toPath()

    suspend fun <T> save(data: T) = withContext(Dispatchers.Default) {
        val jsonData = Json.encodeToString(data)
        FileSystem.SYSTEM.write(file) { writeUtf8(jsonData) }
    }

    suspend fun <T> load(): T? = withContext(Dispatchers.Default) {
        if(!FileSystem.SYSTEM.exists(file)) return@withContext null
        val jsonData = FileSystem.SYSTEM.read(file) { readUtf8() }
        Json.decodeFromString<T>(jsonData)
    }
}

✅ Persistent storage across app restarts, works on both Android & iOS.

3️⃣ Combining Network & Cache (Offline-first)

suspend fun fetchUsers(): List<String> {
    val cached = FileCache.load<List<String>>()
    if(cached != null) return cached

    // Simulate network call
    val networkData = listOf("Alice", "Bob", "Charlie")
    FileCache.save(networkData)
    return networkData
}

• Tries cache first → reduces network calls.
• Falls back to network if cache is empty.

4️⃣ Best Practices for KMP Caching ✅

• Always serialize data in a platform-agnostic format (JSON or Proto).
• Use memory cache for fast temporary data.
• Use file or database cache for persistent offline storage.
• Keep cache consistent with server data — consider expiration policies.
• Test caching behavior on both Android and iOS.

Practice Challenge Solutions ✅

@Serializable
data class User(val id: Int, val name: String)

object UserCache {
    private val file = "users.json".toPath()

    suspend fun save(users: List<User>) {
        val jsonData = Json.encodeToString(users)
        FileSystem.SYSTEM.write(file) { writeUtf8(jsonData) }
    }

    suspend fun load(): List<User>? {
        if(!FileSystem.SYSTEM.exists(file)) return null
        val jsonData = FileSystem.SYSTEM.read(file) { readUtf8() }
        return Json.decodeFromString(jsonData)
    }
}

suspend fun fetchUsers(): List<User> {
    UserCache.load()?.let { return it } // Return cached users

    // Simulate network fetch
    val usersFromNetwork = listOf(User(1, "Alice"), User(2, "Bob"))
    UserCache.save(usersFromNetwork)
    return usersFromNetwork
}

✅ Offline-first caching ensures fast app responsiveness and reduces unnecessary network requests.

📬 Enjoyed this article? Hit the ❤️ button, follow me for more dev-focused content, and subscribe for deeper dives into Kotlin and Android development!

✍️ Written by SHALU GUPTA — Android Developer, Kotlin enthusiast, and tech content creator.

What’s Next?

Tomorrow in Day 49, you’ll explore Kotlin Multiplatform Analytics & Logging — track user events, app performance, and errors in a shared KMP module.