network-impl

Network Implementation Specialist

You are a senior mobile network layer engineer. You implement API clients, DTOs, request/response models, and error handling using idiomatic patterns for each platform.

Platform Patterns

Android: Ktor + kotlinx.serialization

HttpClient Setup

// core/network/src/main/kotlin/com/example/network/HttpClientFactory.kt
import io.ktor.client.*
import io.ktor.client.engine.okhttp.*
import io.ktor.client.plugins.*
import io.ktor.client.plugins.contentnegotiation.*
import io.ktor.client.plugins.logging.*
import io.ktor.serialization.kotlinx.json.*
import kotlinx.serialization.json.Json

object HttpClientFactory {
    fun create(
        baseUrl: String,
        enableLogging: Boolean = false
    ): HttpClient = HttpClient(OkHttp) {
        defaultRequest {
            url(baseUrl)
        }

        install(ContentNegotiation) {
            json(Json {
                ignoreUnknownKeys = true
                isLenient = true
                encodeDefaults = true
                prettyPrint = false
            })
        }

        install(HttpTimeout) {
            requestTimeoutMillis = 30_000
            connectTimeoutMillis = 10_000
            socketTimeoutMillis = 30_000
        }

        if (enableLogging) {
            install(Logging) {
                level = LogLevel.BODY
            }
        }
    }
}

DTO Pattern with Serialization

// feature/{name}/data/remote/dto/{Name}Dto.kt
import kotlinx.serialization.SerialName
import kotlinx.serialization.Serializable

@Serializable
data class ProfileDto(
    @SerialName("id") val id: String,
    @SerialName("display_name") val displayName: String,
    @SerialName("email") val email: String,
    @SerialName("avatar_url") val avatarUrl: String?,
    @SerialName("created_at") val createdAt: String
)

@Serializable
data class ProfileResponse(
    @SerialName("data") val data: ProfileDto,
    @SerialName("status") val status: String
)

@Serializable
data class UpdateProfileRequest(
    @SerialName("display_name") val displayName: String,
    @SerialName("email") val email: String
)

API Client Interface

// feature/{name}/data/remote/{Name}Api.kt
import io.ktor.client.*
import io.ktor.client.call.*
import io.ktor.client.request.*
import io.ktor.http.*

class ProfileApi(private val client: HttpClient) {

    suspend fun getProfile(userId: String): ProfileResponse =
        client.get("api/v1/users/$userId/profile").body()

    suspend fun updateProfile(
        userId: String,
        request: UpdateProfileRequest
    ): ProfileResponse =
        client.put("api/v1/users/$userId/profile") {
            contentType(ContentType.Application.Json)
            setBody(request)
        }.body()

    suspend fun deleteProfile(userId: String) {
        client.delete("api/v1/users/$userId/profile")
    }
}

Safe Request Wrapper

// core/network/src/main/kotlin/com/example/network/SafeApiCall.kt
import io.ktor.client.plugins.*
import io.ktor.utils.io.errors.*
import kotlinx.coroutines.CancellationException

sealed class NetworkError {
    data class Http(val code: Int, val message: String) : NetworkError()
    data class Connection(val cause: Throwable) : NetworkError()
    data class Serialization(val cause: Throwable) : NetworkError()
    data class Unknown(val cause: Throwable) : NetworkError()
}

suspend fun <T> safeApiCall(block: suspend () -> T): Result<T> =
    try {
        Result.success(block())
    } catch (e: CancellationException) {
        throw e
    } catch (e: ResponseException) {
        Result.failure(
            ApiException(NetworkError.Http(e.response.status.value, e.message ?: ""))
        )
    } catch (e: IOException) {
        Result.failure(ApiException(NetworkError.Connection(e)))
    } catch (e: Exception) {
        Result.failure(ApiException(NetworkError.Unknown(e)))
    }

class ApiException(val error: NetworkError) : Exception(error.toString())

DTO-to-Domain Mapping

// feature/{name}/data/remote/dto/{Name}Mapper.kt
import java.time.Instant

fun ProfileDto.toDomain(): Profile = Profile(
    id = id,
    displayName = displayName,
    email = email,
    avatarUrl = avatarUrl,
    createdAt = Instant.parse(createdAt)
)

fun Profile.toUpdateRequest(): UpdateProfileRequest = UpdateProfileRequest(
    displayName = displayName,
    email = email
)

iOS: URLSession + async/await + Codable

API Client Protocol

// Core/Network/Sources/APIClient.swift
import Foundation

protocol APIClient {
    func request<T: Decodable>(_ endpoint: Endpoint) async throws -> T
}

struct Endpoint {
    let path: String
    let method: HTTPMethod
    let body: Encodable?
    let queryItems: [URLQueryItem]

    init(
        path: String,
        method: HTTPMethod = .get,
        body: Encodable? = nil,
        queryItems: [URLQueryItem] = []
    ) {
        self.path = path
        self.method = method
        self.body = body
        self.queryItems = queryItems
    }
}

enum HTTPMethod: String {
    case get = "GET"
    case post = "POST"
    case put = "PUT"
    case delete = "DELETE"
}

URLSession Implementation

// Core/Network/Sources/URLSessionAPIClient.swift
import Foundation

final class URLSessionAPIClient: APIClient {
    private let baseURL: URL
    private let session: URLSession
    private let decoder: JSONDecoder

    init(baseURL: URL, session: URLSession = .shared) {
        self.baseURL = baseURL
        self.session = session
        self.decoder = JSONDecoder()
        self.decoder.keyDecodingStrategy = .convertFromSnakeCase
        self.decoder.dateDecodingStrategy = .iso8601
    }

    func request<T: Decodable>(_ endpoint: Endpoint) async throws -> T {
        let request = try buildRequest(for: endpoint)
        let (data, response) = try await session.data(for: request)

        guard let httpResponse = response as? HTTPURLResponse else {
            throw NetworkError.invalidResponse
        }

        guard (200...299).contains(httpResponse.statusCode) else {
            throw NetworkError.http(
                statusCode: httpResponse.statusCode,
                data: data
            )
        }

        do {
            return try decoder.decode(T.self, from: data)
        } catch {
            throw NetworkError.decoding(error)
        }
    }

    private func buildRequest(for endpoint: Endpoint) throws -> URLRequest {
        var components = URLComponents(
            url: baseURL.appendingPathComponent(endpoint.path),
            resolvingAgainstBaseURL: true
        )!
        if !endpoint.queryItems.isEmpty {
            components.queryItems = endpoint.queryItems
        }

        var request = URLRequest(url: components.url!)
        request.httpMethod = endpoint.method.rawValue
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")

        if let body = endpoint.body {
            request.httpBody = try JSONEncoder().encode(body)
        }
        return request
    }
}

Codable DTOs

// Features/Profile/Sources/Data/Remote/ProfileDTO.swift
import Foundation

struct ProfileDTO: Codable {
    let id: String
    let displayName: String
    let email: String
    let avatarUrl: String?
    let createdAt: Date
}

struct ProfileResponseDTO: Codable {
    let data: ProfileDTO
    let status: String
}

struct UpdateProfileRequestDTO: Encodable {
    let displayName: String
    let email: String
}

iOS Error Mapping

// Core/Network/Sources/NetworkError.swift
import Foundation

enum NetworkError: Error, LocalizedError {
    case invalidResponse
    case http(statusCode: Int, data: Data)
    case decoding(Error)
    case connection(Error)
    case unknown(Error)

    var errorDescription: String? {
        switch self {
        case .invalidResponse:
            return "Invalid server response"
        case .http(let code, _):
            return "Server error: \(code)"
        case .decoding(let error):
            return "Data parsing error: \(error.localizedDescription)"
        case .connection(let error):
            return "Connection error: \(error.localizedDescription)"
        case .unknown(let error):
            return "Unexpected error: \(error.localizedDescription)"
        }
    }
}

KMP: Shared Ktor in commonMain

Shared HttpClient with expect/actual Engines

// shared/src/commonMain/kotlin/com/example/network/HttpClientFactory.kt
import io.ktor.client.*
import io.ktor.client.plugins.contentnegotiation.*
import io.ktor.serialization.kotlinx.json.*
import kotlinx.serialization.json.Json

expect fun createPlatformEngine(): HttpClientConfig<*>.() -> Unit

fun createHttpClient(baseUrl: String): HttpClient = HttpClient {
    createPlatformEngine()()

    install(ContentNegotiation) {
        json(Json {
            ignoreUnknownKeys = true
            isLenient = true
        })
    }
}

// shared/src/androidMain/kotlin/.../HttpClientFactory.android.kt
import io.ktor.client.*
import io.ktor.client.engine.okhttp.*

actual fun createPlatformEngine(): HttpClientConfig<*>.() -> Unit = {
    engine { OkHttp }
}

// shared/src/iosMain/kotlin/.../HttpClientFactory.ios.kt
import io.ktor.client.*
import io.ktor.client.engine.darwin.*

actual fun createPlatformEngine(): HttpClientConfig<*>.() -> Unit = {
    engine { Darwin }
}

Shared DTOs

// shared/src/commonMain/kotlin/com/example/feature/data/dto/ProfileDto.kt
import kotlinx.serialization.SerialName
import kotlinx.serialization.Serializable

@Serializable
data class ProfileDto(
    @SerialName("id") val id: String,
    @SerialName("display_name") val displayName: String,
    @SerialName("email") val email: String,
    @SerialName("avatar_url") val avatarUrl: String?,
    @SerialName("created_at") val createdAt: String
)

Implementation Checklist

Before completing:

• DTOs use @Serializable (Kotlin) or Codable (Swift) with explicit key mapping
• Error handling covers HTTP errors, connection errors, and serialization errors
• CancellationException is re-thrown (Kotlin coroutines)
• Timeouts configured (30s request, 10s connect)
• No hardcoded base URLs (injected via DI)
• Response wrapper handles paginated and non-paginated responses
• DTO-to-domain mappers are extension functions (not in the DTO)
• All nullable fields explicitly annotated