Jetpack Compose: Kotlinx serialization ignore unknown keys

Introduction

In modern Android development, handling JSON data with unknown fields is common, especially when dealing with dynamic or third-party data sources. Parsing such data without flexibility can lead to errors, particularly when the JSON structure includes fields not defined in your data model. This article demonstrates how to use Kotlin's kotlinx.serialization library in an Android Jetpack Compose app to decode JSON while ignoring unknown keys. This feature is especially useful in applications where only specific fields are required, allowing developers to parse data efficiently and handle unexpected or extra fields gracefully.

In this example, we build a simple Jetpack Compose UI that displays user information parsed from a JSON string. The code leverages Kotlinx Serialization with the ignoreUnknownKeys feature to skip over unrecognized fields in the JSON string without throwing errors. This approach ensures that the app remains robust and user-friendly, even when the JSON input has an unexpected structure.

Code Explanation

Setting Up the MainActivity
The MainActivity class extends ComponentActivity and overrides the onCreate method to set up the UI content. Using Jetpack Compose, setContent is called to set the main UI structure, wrapped in a custom theme called ComposeNetworkTheme. Inside this theme, a Scaffold component is used, which organizes the layout with a top app bar and a central content area. The TopAppBar displays a title, "Serialization Ignore Unknown Keys," introducing the main functionality of the app.
MainContent Composable Function
The MainContent composable function is where the JSON parsing and UI presentation happen. It first defines a JSON format using the Json object from Kotlinx Serialization. Here, isLenient is set to true to allow more relaxed JSON parsing, while ignoreUnknownKeys = true ensures that any unknown keys in the JSON data are ignored, preventing parse errors.
Defining and Decoding JSON Data
Inside MainContent, a JSON string userString is defined, representing a user object. This string includes known fields like firstName, lastName, and age, but also contains unknown fields such as middleName and class. These additional fields are not present in the User data class, so without the ignoreUnknownKeys setting, an error would be thrown during parsing. However, with ignoreUnknownKeys = true, these unknown fields are skipped, allowing the userString to be successfully decoded into an instance of the User class using decodeFromString<User>(userString).
Displaying User Information
The decoded User object, userFromJsonString, is used to display the user's first name, last name, and age. This information is presented in a Column composable with padding and fills the available screen space. The Text composable then renders the parsed data, formatted using the MaterialTheme.typography.h5 style for better readability and a more visually appealing display.
Data Class and Serialization Annotations
The User data class represents the structure of the JSON data the app expects. It is annotated with @Serializable, making it compatible with Kotlinx Serialization. The class includes only three fields: firstName, lastName, and age. Because ignoreUnknownKeys is enabled, fields outside of these specified fields in the JSON input do not cause issues during parsing.

Build Configuration

To enable Kotlinx Serialization, several build configuration steps are needed. First, the build.gradle files are updated to include the required serialization dependencies. In build.gradle [project], the kotlin-serialization plugin version is specified, while in build.gradle [app], the serialization plugin itself is applied. Additionally, the required library dependency kotlinx-serialization-json is added to support JSON format handling. These configurations ensure that Kotlinx Serialization works seamlessly in the Android project.

Summary

This example illustrates a straightforward yet powerful approach to parsing JSON data in an Android application using Kotlinx Serialization. By enabling the ignoreUnknownKeys setting, developers can easily handle JSON structures with unknown fields, making the code more adaptable and resilient. This is especially beneficial for applications interacting with external or evolving data sources, as it ensures that unknown fields do not disrupt functionality.

Overall, this approach offers a clean, flexible solution for JSON parsing in Android, allowing developers to focus on building robust applications without worrying about mismatched data structures. With Jetpack Compose providing an intuitive UI framework, this example demonstrates how to combine modern UI components with flexible JSON handling for an efficient and user-friendly experience.

MainActivity.kt


package com.cfsuman.composenetwork

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.*
import androidx.compose.material.*
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import com.cfsuman.composenetwork.ui.theme.ComposeNetworkTheme
import kotlinx.serialization.Serializable
import kotlinx.serialization.decodeFromString
import kotlinx.serialization.json.Json


class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            ComposeNetworkTheme {
                Scaffold(
                    topBar = {
                        TopAppBar(
                            title = {
                                Text("Serialization Ignore Unknown Keys")
                            }
                        )
                    },
                    content = { MainContent()}
                )
            }
        }
    }
}


@Composable
fun MainContent() {
    val format = Json{
        isLenient = true
        ignoreUnknownKeys = true
    }

    val userString = "{" +
            "firstName: Anamika," +
            "middleName: Khan," +
            "lastName:Rahman,age:\"23\"," +
            "class:Eight}"
    val userFromJsonString = format.decodeFromString<User>(userString)

    Column(Modifier.fillMaxSize().padding(24.dp)) {
        Text(
            text = userFromJsonString.firstName +
                    " ${userFromJsonString.lastName}" +
                    "\nAge ${userFromJsonString.age}",
            style = MaterialTheme.typography.h5
        )
    }
}


@Serializable
data class User(
    val firstName: String,
    val lastName: String,
    val age: Int
)

build.gradle [project]


buildscript {
    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-serialization:1.6.10"
    }
}

build.gradle [app]


plugins {
    id 'kotlinx-serialization'
}


dependencies {
    implementation 'org.jetbrains.kotlinx:kotlinx-serialization-json:1.3.0'
}