Using Ktor in Jetpack Compose: A Comprehensive Guide.

Ktor evolves quickly, and with each major release, older applications lose relevance—sometimes leading to broken code and a fair share of frustration. What worked flawlessly in one version can turn into headache in the next. I have felt that frustration firsthand, chasing down fixes for outdated examples. A great article by Tomer Pacific zeroes in on using Ktor as an HTTP client in a Jetpack Compose app, consolidating the essentials into one reliable, up-to-date guide. Here are some of his key insight.

Setting Up Ktor

One will one need multiople libraries to get started. At minimum, on should have the following;

dependencies {
    implementation("io.ktor:ktor-client-core:2.3.12")
    implementation("io.ktor:ktor-client-android:2.3.12")
}        

• ktor-client-core - Provides the foundational client functionality.
• ktor-client-android - Supplies the Android-specific engine, which handles network requests. Ktor supports various engines for different platforms, but since we’re targeting Android, this is the one we need.

Want to work with JSON responses? Add the content negotiation library to handle serialization and deserialization.

dependencies {
    implementation("io.ktor:ktor-client-core:2.3.12")
    implementation("io.ktor:ktor-client-android:2.3.12")
    implementation("io.ktor:ktor-client-content-negotiation:2.3.12")
}        

The content-negotiation dependency enables Ktor to convert JSON data into Kotlin objects seamlessly. More on that shortly.

Creating the HttpClient

Instantiate HttpClient using the following;

import io.ktor.client.HttpClient
import io.ktor.client.engine.android.Android

val myHttpClient = HttpClient(Android)        

This creates a basic client using the Android engine. To handle JSON, we need to configure it with the ContentNegotiation plugin.

val myHttpClient = HttpClient(Android) {
    install(HttpTimeout) {
        requestTimeoutMillis = 10000 // 10 seconds
    }
    install(ContentNegotiation) {
        json()
    }
}        

The install block taps into HttpClientConfig, letting you customize the client’s behavior. For example, to set a request timeout.

val myHttpClient = HttpClient(Android) {
    install(HttpTimeout) {
        requestTimeoutMillis = 10000 // 10 seconds
    }
    install(ContentNegotiation) {
        json()
    }
}        

This flexibility makes Ktor powerful and adaptable to various use cases.

Setting Up Serialization

To deserialize JSON responses into Kotlin objects, you will need to set up serialization. This process depends on your Jetpack Compose and Kotlin versions. Here’s a quick rundown:

1. Check your Jetpack Compose version to determine the compatible Kotlin version.
2. Find a matching kotlinx-serialization library version.
3. Update your Gradle files.

In your project-level build.gradle.kts.

plugins {
    kotlin("jvm") version "1.5.0"
    kotlin("plugin.serialization") version "1.5.0"
}        

In your app-level build.gradle.kts.

plugins {
    id("org.jetbrains.kotlin.plugin.serialization")
}

dependencies {
    implementation("io.ktor:ktor-serialization-kotlinx-json:2.3.12")
    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.5.0")
}        

These steps ensure your app can serialize and deserialize JSON data effectively.

Making Requests and Handling Responses

Define a data class to model a hypothetical API response—say, details about a car.

import kotlinx.serialization.Serializable
import kotlinx.serialization.SerialName

@Serializable
data class CarDetails(
    @SerialName("car_make") val make: String,
    @SerialName("car_model") val model: String,
    @SerialName("year_of_production") val productionYear: Int
)        

Now make the GET requests

import io.ktor.client.request.get
import io.ktor.client.request.url
import io.ktor.http.URLProtocol

val httpResponse = try {
    myHttpClient.get {
        url {
            protocol = URLProtocol.HTTPS
            host = "www.example.com"
            encodedPath = "path/to/data"
        }
    }
} catch (e: Exception) {
    // Handle network errors
    throw e
}        

Alternatively, pass the full URL directly

val httpResponse = myHttpClient.get("https://www.example.com/path/to/data")        

For a POST request.

val httpResponse = myHttpClient.post("https://www.example.com/path/to/data") {
    setBody("Request body content")
}        

Processing the Response

The HttpResponse object contains a status field to check the request’s success. Here’s how to deserialize the response into our CarDetails class.

val httpResponse = myHttpClient.get("https://www.example.com/path/to/data")

when (httpResponse.status.value) {
    in 200..299 -> {
        val carDetails = httpResponse.body<CarDetails>()
        // Use carDetails.make, carDetails.model, etc.
    }
    else -> {
        // Handle errors (e.g., 404, 500)
    }
}        

The body() function, combined with the ContentNegotiation plugin, automatically converts the JSON response into our data class.

Wrapping Up

Ktor is a powerful and flexible HTTP client for Android apps, and when paired with Jetpack Compose, it simplifies network operations in modern Kotlin development. By setting up the right dependencies, configuring the HttpClient, and handling serialization, you can build robust, type-safe networking logic. This was quite comprehensive for Ktor 2.3.12, covering the essentials. However, Ktor offers much more and is bound to grow. Make sure to explore its documentation for advanced features like custom headers, logging, or multipart requests.

Read more here