Kotlin Multiplatform 1.1 Stable: Production Case Study 2026

1// shared/build.gradle.kts
2kotlin {
3    androidTarget {
4        compilations.all {
5            kotlinOptions {
6                jvmTarget = "17"
7            }
8        }
9    }
10 
11    listOf(
12        iosX64(),
13        iosArm64(),
14        iosSimulatorArm64()
15    ).forEach { iosTarget ->
16        iosTarget.binaries.framework {
17            baseName = "Shared"
18            isStatic = true
19            // KMP 1.1: Daha iyi Swift name mangling
20            freeCompilerArgs += "-Xbinary=bundleId=com.example.shared"
21        }
22    }
23 
24    sourceSets {
25        commonMain.dependencies {
26            implementation(libs.kotlinx.coroutines.core)
27            implementation(libs.ktor.client.core)
28            implementation(libs.sqldelight.runtime)
29            implementation(libs.koin.core)
30            implementation(libs.kotlinx.serialization.json)
31            implementation(libs.kotlinx.datetime)
32        }
33 
34        androidMain.dependencies {
35            implementation(libs.ktor.client.android)
36            implementation(libs.sqldelight.android.driver)
37            implementation(libs.koin.android)
38        }
39 
40        iosMain.dependencies {
41            implementation(libs.ktor.client.darwin)
42            implementation(libs.sqldelight.native.driver)
43        }
44 
45        commonTest.dependencies {
46            implementation(libs.kotlin.test)
47            implementation(libs.kotlinx.coroutines.test)
48            implementation(libs.turbine)
49        }
50    }
51}

1// commonMain/platform/Platform.kt
2expect class Platform {
3    val name: String
4    val version: String
5    val isDebug: Boolean
6}
7 
8expect fun generateUUID(): String
9 
10expect class PlatformLogger {
11    fun log(tag: String, message: String, level: LogLevel)
12}
13 
14// androidMain/platform/Platform.android.kt
15actual class Platform {
16    actual val name: String = "Android"
17    actual val version: String = android.os.Build.VERSION.RELEASE
18    actual val isDebug: Boolean = BuildConfig.DEBUG
19}
20 
21actual fun generateUUID(): String = java.util.UUID.randomUUID().toString()
22 
23actual class PlatformLogger {
24    actual fun log(tag: String, message: String, level: LogLevel) {
25        when (level) {
26            LogLevel.DEBUG -> android.util.Log.d(tag, message)
27            LogLevel.ERROR -> android.util.Log.e(tag, message)
28            LogLevel.INFO -> android.util.Log.i(tag, message)
29        }
30    }
31}
32 
33// iosMain/platform/Platform.ios.kt
34actual class Platform {
35    actual val name: String = UIDevice.currentDevice.systemName()
36    actual val version: String = UIDevice.currentDevice.systemVersion()
37    actual val isDebug: Boolean = NSBundle.mainBundle.objectForInfoDictionaryKey("DEBUG") != null
38}
39 
40actual fun generateUUID(): String = NSUUID().UUIDString()
41 
42actual class PlatformLogger {
43    actual fun log(tag: String, message: String, level: LogLevel) {
44        // iOS'ta unified logging
45        NSLog("[$tag] $message")
46    }
47}

1// commonMain/data/remote/ApiClient.kt
2class ApiClient(
3    private val baseUrl: String,
4    private val tokenProvider: TokenProvider
5) {
6    private val client = HttpClient {
7        install(ContentNegotiation) {
8            json(Json {
9                ignoreUnknownKeys = true
10                isLenient = true
11                encodeDefaults = false
12            })
13        }
14 
15        install(Auth) {
16            bearer {
17                loadTokens {
18                    BearerTokens(
19                        accessToken = tokenProvider.getAccessToken() ?: "",
20                        refreshToken = tokenProvider.getRefreshToken() ?: ""
21                    )
22                }
23                refreshTokens {
24                    val refreshResponse: TokenResponse = client.post("$baseUrl/auth/refresh") {
25                        markAsRefreshTokenRequest()
26                        setBody(RefreshRequest(oldTokens?.refreshToken ?: ""))
27                    }.body()
28                    tokenProvider.saveTokens(
29                        access = refreshResponse.accessToken,
30                        refresh = refreshResponse.refreshToken
31                    )
32                    BearerTokens(refreshResponse.accessToken, refreshResponse.refreshToken)
33                }
34            }
35        }
36 
37        install(HttpRequestRetry) {
38            retryOnServerErrors(maxRetries = 3)
39            exponentialDelay()
40        }
41 
42        install(Logging) {
43            level = LogLevel.HEADERS
44            logger = object : Logger {
45                override fun log(message: String) {
46                    // KMP logger'a yönlendir
47                    kmpLogger.log("KtorClient", message, LogLevel.DEBUG)
48                }
49            }
50        }
51 
52        defaultRequest {
53            url(baseUrl)
54            contentType(ContentType.Application.Json)
55            accept(ContentType.Application.Json)
56        }
57    }
58 
59    suspend fun  get(endpoint: String, responseType: KSerializer): Result =
60        runCatching {
61            client.get(endpoint).body()
62        }
63 
64    suspend fun  post(
65        endpoint: String,
66        body: B,
67        bodySerializer: KSerializer,
68        responseType: KSerializer
69    ): Result = runCatching {
70        client.post(endpoint) {
71            setBody(body, bodySerializer)
72        }.body()
73    }
74}

1// androidMain/di/NetworkModule.android.kt
2actual fun createHttpClientEngine(): HttpClientEngine = Android.create {
3    connectTimeout = 30_000
4    socketTimeout = 30_000
5}
6 
7// iosMain/di/NetworkModule.ios.kt
8actual fun createHttpClientEngine(): HttpClientEngine = Darwin.create {
9    configureRequest {
10        setTimeoutInterval(30.0)
11        setAllowsCellularAccess(true)
12    }
13}

1-- commonMain/sqldelight/com/example/ProductQueries.sq
2CREATE TABLE Product (
3    id TEXT NOT NULL PRIMARY KEY,
4    name TEXT NOT NULL,
5    price REAL NOT NULL,
6    categoryId TEXT NOT NULL,
7    imageUrl TEXT,
8    isFavorite INTEGER AS Boolean NOT NULL DEFAULT 0,
9    lastUpdated INTEGER NOT NULL
10);
11 
12selectAll:
13SELECT * FROM Product ORDER BY name ASC;
14 
15selectByCategory:
16SELECT * FROM Product WHERE categoryId = ? ORDER BY name ASC;
17 
18selectFavorites:
19SELECT * FROM Product WHERE isFavorite = 1;
20 
21upsert:
22INSERT OR REPLACE INTO Product(id, name, price, categoryId, imageUrl, isFavorite, lastUpdated)
23VALUES (?, ?, ?, ?, ?, ?, ?);
24 
25updateFavorite:
26UPDATE Product SET isFavorite = ? WHERE id = ?;
27 
28deleteById:
29DELETE FROM Product WHERE id = ?;

1// commonMain/data/local/ProductLocalDataSource.kt
2class ProductLocalDataSource(database: AppDatabase) {
3    private val queries = database.productQueries
4 
5    fun getAllProducts(): Flow> =
6        queries.selectAll().asFlow().mapToList(Dispatchers.Default)
7 
8    fun getFavorites(): Flow> =
9        queries.selectFavorites().asFlow().mapToList(Dispatchers.Default)
10 
11    suspend fun upsertProduct(product: ProductEntity) {
12        withContext(Dispatchers.Default) {
13            queries.upsert(
14                id = product.id,
15                name = product.name,
16                price = product.price,
17                categoryId = product.categoryId,
18                imageUrl = product.imageUrl,
19                isFavorite = product.isFavorite,
20                lastUpdated = Clock.System.now().toEpochMilliseconds()
21            )
22        }
23    }
24 
25    suspend fun toggleFavorite(productId: String, isFavorite: Boolean) {
26        withContext(Dispatchers.Default) {
27            queries.updateFavorite(isFavorite = isFavorite, id = productId)
28        }
29    }
30}

1// commonMain/di/AppModule.kt
2val networkModule = module {
3    single { ApiClient(baseUrl = BuildConfig.BASE_URL, tokenProvider = get()) }
4    single { TokenProviderImpl(secureStorage = get()) }
5}
6 
7val databaseModule = module {
8    single { createDatabase(get()) } // platform-specific factory
9    single { ProductLocalDataSource(database = get()) }
10    single { UserLocalDataSource(database = get()) }
11}
12 
13val repositoryModule = module {
14    single {
15        ProductRepositoryImpl(
16            remote = get(),
17            local = get()
18        )
19    }
20}
21 
22val useCaseModule = module {
23    factory { GetProductsUseCase(repository = get()) }
24    factory { ToggleFavoriteUseCase(repository = get()) }
25    factory { SyncProductsUseCase(repository = get()) }
26}
27 
28// Android'de Activity/ViewModel scope'ları eklenir
29// iOS'ta viewModelDefinition yerine factory kullanılır

1// iOS Swift tarafı — KMP shared module kullanımı
2import Shared
3 
4class ProductListViewModel: ObservableObject {
5    @Published var products: [ProductEntity] = []
6    @Published var isLoading = false
7    @Published var error: String?
8 
9    private let getProductsUseCase: GetProductsUseCase
10    private var cancellable: Kotlinx_coroutines_coreJob?
11 
12    init() {
13        // Koin'den resolve et
14        self.getProductsUseCase = KoinHelper.shared.getProductsUseCase()
15    }
16 
17    func loadProducts() {
18        isLoading = true
19 
20        // KMP Flow'u Swift'e köprüle — FlowCollector wrapper
21        cancellable = FlowUtils.collect(
22            flow: getProductsUseCase.execute(),
23            onEach: { [weak self] products in
24                DispatchQueue.main.async {
25                    self?.products = products as! [ProductEntity]
26                    self?.isLoading = false
27                }
28            },
29            onError: { [weak self] error in
30                DispatchQueue.main.async {
31                    self?.error = error.message
32                    self?.isLoading = false
33                }
34            },
35            onComplete: {}
36        )
37    }
38 
39    deinit {
40        cancellable?.cancel(cause: nil)
41    }
42}

1// Shared Compose component — commonMain'de
2@Composable
3fun ProductCard(
4    product: ProductEntity,
5    onFavoriteToggle: (String) -> Unit,
6    modifier: Modifier = Modifier
7) {
8    Card(
9        modifier = modifier
10            .fillMaxWidth()
11            .padding(horizontal = 16.dp, vertical = 8.dp),
12        elevation = CardDefaults.cardElevation(defaultElevation = 2.dp),
13        shape = RoundedCornerShape(12.dp)
14    ) {
15        Row(
16            modifier = Modifier.padding(12.dp),
17            verticalAlignment = Alignment.CenterVertically
18        ) {
19            AsyncImage(
20                model = product.imageUrl,
21                contentDescription = product.name,
22                modifier = Modifier
23                    .size(72.dp)
24                    .clip(RoundedCornerShape(8.dp)),
25                contentScale = ContentScale.Crop
26            )
27 
28            Spacer(modifier = Modifier.width(12.dp))
29 
30            Column(modifier = Modifier.weight(1f)) {
31                Text(
32                    text = product.name,
33                    style = MaterialTheme.typography.titleMedium,
34                    maxLines = 2,
35                    overflow = TextOverflow.Ellipsis
36                )
37                Text(
38                    text = "${product.price} TL",
39                    style = MaterialTheme.typography.bodyMedium,
40                    color = MaterialTheme.colorScheme.primary
41                )
42            }
43 
44            IconButton(onClick = { onFavoriteToggle(product.id) }) {
45                Icon(
46                    imageVector = if (product.isFavorite) {
47                        Icons.Filled.Favorite
48                    } else {
49                        Icons.Outlined.FavoriteBorder
50                    },
51                    contentDescription = "Favori",
52                    tint = if (product.isFavorite) Color.Red else Color.Gray
53                )
54            }
55        }
56    }
57}

1// commonMain
2expect class BackgroundTaskScheduler {
3    fun scheduleSync(intervalMinutes: Long)
4    fun cancelAll()
5}
6 
7// iosMain — BGTaskScheduler wrap
8actual class BackgroundTaskScheduler {
9    actual fun scheduleSync(intervalMinutes: Long) {
10        val request = BGAppRefreshTaskRequest("com.example.sync")
11        request.earliestBeginDate = NSDate(timeIntervalSinceNow = intervalMinutes * 60.0)
12        BGTaskScheduler.sharedScheduler.submitTaskRequest(request, error = null)
13    }
14    actual fun cancelAll() {
15        BGTaskScheduler.sharedScheduler.cancelAllTaskRequests()
16    }
17}

1// commonMain/domain/PushNotificationHandler.kt — SHARED
2class PushNotificationHandler {
3    fun parsePayload(json: String): NotificationPayload {
4        return Json.decodeFromString(NotificationPayload.serializer(), json)
5    }
6 
7    fun shouldShowInApp(payload: NotificationPayload): Boolean {
8        return payload.priority == "high" && payload.type != "silent"
9    }
10}

1// commonMain
2interface SecureStorage {
3    suspend fun save(key: String, value: String)
4    suspend fun load(key: String): String?
5    suspend fun delete(key: String)
6}
7 
8// iosMain — Keychain wrapper
9actual class SecureStorageImpl : SecureStorage {
10    actual override suspend fun save(key: String, value: String) {
11        val query = mapOf(
12            kSecClass to kSecClassGenericPassword,
13            kSecAttrAccount to key,
14            kSecValueData to value.encodeToByteArray().toNSData()
15        )
16        SecItemDelete(query as CFDictionary)
17        SecItemAdd(query as CFDictionary, null)
18    }
19    // ...
20}

1// gradle.properties
2org.gradle.caching=true
3org.gradle.parallel=true
4org.gradle.configureondemand=true
5kotlin.native.cacheKind.iosSimulatorArm64=static
6kotlin.native.cacheKind.iosArm64=static
7kotlin.incremental=true
8kotlin.incremental.multiplatform=true
9 
10// Configuration cache (Gradle 8.x)
11org.gradle.configuration-cache=true
12org.gradle.configuration-cache.problems=warn

1- name: Build KMP Shared Framework
2  run: ./gradlew :shared:assembleXCFramework --build-cache
3 
4- name: Cache Kotlin Native
5  uses: actions/cache@v4
6  with:
7    path: |
8      ~/.konan
9      .gradle/caches
10    key: kmp-${{ runner.os }}-${{ hashFiles('**/*.gradle.kts', '**/libs.versions.toml') }}

1// commonMain/monitoring/CrashReporter.kt
2expect class CrashReporter {
3    fun setUserId(userId: String)
4    fun setCustomKey(key: String, value: String)
5    fun recordException(throwable: Throwable, context: Map)
6    fun log(message: String)
7}
8 
9// commonMain/monitoring/CrashContext.kt — SHARED
10class CrashContext(private val reporter: CrashReporter) {
11    fun recordApiError(endpoint: String, statusCode: Int, message: String) {
12        reporter.setCustomKey("last_api_endpoint", endpoint)
13        reporter.setCustomKey("last_status_code", statusCode.toString())
14        reporter.log("API Error: $endpoint -> $statusCode: $message")
15    }
16 
17    fun recordDatabaseError(query: String, error: Throwable) {
18        reporter.setCustomKey("failed_query", query.take(100))
19        reporter.recordException(error, mapOf("source" to "database"))
20    }
21}

1// settings.gradle.kts
2rootProject.name = "MyApp"
3include(":shared")
4include(":androidApp")
5 
6// iosApp Xcode projesi ayrı root açar, shared framework build sonrası kullanır

1@OptIn(ExperimentalNativeApi::class)
2@CName("processImageBuffer")
3fun processImageBuffer(buffer: CPointer, length: Int): Int {
4    // Direct memory access — no boxing, no bridge overhead
5    return buffer.readBytes(length).filter { it > 128.toByte() }.size
6}