Kotlin Multiplatform for Android Developers: Sharing Code Without Losing Native Quality

// shared/build.gradle.kts
plugins {
    id("org.jetbrains.kotlin.multiplatform")
    id("com.android.kotlin.multiplatform.library")
}

kotlin {
    // The Android target is configured inside the kotlin block
    android {
        namespace = "com.myapp.shared"
        compileSdk = 36
        minSdk = 26
    }

    iosArm64() // 64-bit iPhones

    sourceSets {
        commonMain {
            dependencies {
                // Shared dependencies
            }
        }
        androidMain {
            dependencies {
                // Android-only dependencies
            }
        }
    }
}

// shared/src/commonMain/kotlin/Platform.kt
interface Platform {
    val name: String
}

// An expected FUNCTION, not an expected class
expect fun getPlatform(): Platform

// shared/src/androidMain/kotlin/Platform.android.kt
private class AndroidPlatform : Platform {
    override val name: String = "Android"
}

actual fun getPlatform(): Platform = AndroidPlatform()

// shared/src/iosMain/kotlin/Platform.ios.kt
private class IosPlatform : Platform {
    override val name: String = "iOS"
}

actual fun getPlatform(): Platform = IosPlatform()

// shared/src/commonTest/kotlin/FakePlatform.kt
class FakePlatform(override val name: String = "Test") : Platform

// shared/build.gradle.kts
kotlin {
    sourceSets {
        commonMain {
            dependencies {
                api("io.ktor:ktor-client-engine-defaults:3.6.0")
                implementation("io.ktor:ktor-serialization-kotlinx-json:3.6.0")
            }
        }
    }
}

// shared/src/commonMain/kotlin/api/HttpClientFactory.kt
// No expect/actual: the engine is chosen per platform automatically
fun createHttpClient(): HttpClient = HttpClient {
    install(ContentNegotiation) {
        json(Json { ignoreUnknownKeys = true })
    }
}

// shared/src/commonMain/kotlin/api/TaskApi.kt
class TaskApi(private val client: HttpClient) {

    suspend fun getTasks(): List<TaskDto> =
        client.get("https://api.example.com/tasks").body()

    suspend fun createTask(request: CreateTaskRequest): TaskDto =
        client.post("https://api.example.com/tasks") {
            contentType(ContentType.Application.Json)
            setBody(request)
        }.body()
}

-- shared/src/commonMain/sqldelight/com/myapp/db/Task.sq
CREATE TABLE TaskEntity (
    id TEXT NOT NULL PRIMARY KEY,
    title TEXT NOT NULL,
    description TEXT NOT NULL DEFAULT '',
    isCompleted INTEGER NOT NULL DEFAULT 0,
    createdAt INTEGER NOT NULL,
    updatedAt INTEGER NOT NULL
);

selectAll:
SELECT * FROM TaskEntity
ORDER BY createdAt DESC;

insertOrReplace:
INSERT OR REPLACE INTO TaskEntity(
    id, title, description, isCompleted, createdAt, updatedAt
) VALUES (?, ?, ?, ?, ?, ?);

markCompleted:
UPDATE TaskEntity SET isCompleted = 1,
    updatedAt = ? WHERE id = ?;

deleteById:
DELETE FROM TaskEntity WHERE id = ?;

// shared/src/commonTest/kotlin/TaskRepositoryTest.kt
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertTrue

class TaskRepositoryTest {

    private val fakeApi = FakeTaskApi()
    private val fakeDb = FakeTaskDatabase()
    private val repository = TaskRepository(fakeApi, fakeDb)

    @Test
    fun fetchTasks_cachesLocally() = runTest {
        fakeApi.respondWith(
            listOf(TaskDto("1", "Write tests", false))
        )

        val tasks = repository.getTasks()

        assertEquals(1, tasks.size)
        assertEquals("Write tests", tasks.first().title)
        assertEquals(1, fakeDb.getAllTasks().size)
    }

    @Test
    fun createTask_rejectsAnEmptyTitle() = runTest {
        val result = repository.createTask(title = "")

        assertTrue(result.isFailure)
    }
}