İlk Kotlin Multiplatform Projeni Kurmak

# Komut satırı araçlarını kur
sudo xcode-select --install

# Lisansı kabul et
sudo xcodebuild -license accept

# kdoctor'ı kur
brew install kdoctor

# Kontrolü çalıştır
kdoctor

java -version           # 17+ gerekli
xcode-select --version  # Xcode CLT kurulu mu

MyKmpApp/
├── shared/                         ← PAYLAŞILAN MODÜL
│   ├── build.gradle.kts            ← Hedefleri ve bağımlılıkları yapılandırır
│   └── src/
│       ├── commonMain/             ← HER YERDE çalışan kod
│       │   └── kotlin/
│       │       ├── Platform.kt     ← expect bildirimi
│       │       └── Greeting.kt    ← paylaşılan iş mantığı
│       ├── commonTest/             ← Paylaşılan kod için testler
│       │   └── kotlin/
│       ├── androidMain/            ← Android'e özgü kod
│       │   └── kotlin/
│       │       └── Platform.android.kt  ← Android için actual
│       └── iosMain/                ← iOS'a özgü kod
│           └── kotlin/
│               └── Platform.ios.kt      ← iOS için actual
│
├── composeApp/                     ← UYGULAMA MODÜLÜ
│   ├── build.gradle.kts
│   └── src/
│       ├── commonMain/             ← Paylaşılan Compose UI
│       │   └── kotlin/
│       │       └── App.kt         ← Ana uygulama composable'ı
│       ├── androidMain/            ← Android giriş noktası
│       │   └── kotlin/
│       │       └── MainActivity.kt
│       │   └── AndroidManifest.xml
│       └── iosMain/                ← iOS giriş noktası
│
├── iosApp/                         ← iOS XCODE PROJESİ
│   └── iosApp/
│       ├── ContentView.swift       ← SwiftUI sarmalayıcı
│       └── iOSApp.swift            ← iOS uygulama giriş noktası
│
├── build.gradle.kts                ← Kök derleme yapılandırması
├── settings.gradle.kts             ← Modül bildirimleri
├── gradle.properties               ← Proje özellikleri
└── gradle/
    └── libs.versions.toml          ← Bağımlılık sürümleri

// commonMain: NEYE ihtiyacımız olduğunu bildirir
// "expect" şu anlama gelir: her platform kendi uygulamasını sağlamalı
expect fun getPlatformName(): String

// androidMain: Android yanıtını sağlar
actual fun getPlatformName(): String = "Android ${android.os.Build.VERSION.SDK_INT}"

// iosMain: iOS yanıtını sağlar
import platform.UIKit.UIDevice

actual fun getPlatformName(): String = UIDevice.currentDevice.systemName() +
    " " + UIDevice.currentDevice.systemVersion

class Greeting {
    fun greet(): String {
        return "Hello from ${getPlatformName()}!"
    }
}

./gradlew :composeApp:assembleDebug
./gradlew :composeApp:installDebug

./gradlew :shared:linkDebugFrameworkIosSimulatorArm64

./gradlew :composeApp:run

package com.ornek.mykmpapp.models

// Bu data class Android, iOS, Desktop ve Web'de çalışır
// Bir kez tanımla, her yerde kullan

data class User(
    val id: String,
    val name: String,
    val email: String,
    val joinedYear: Int = 2026
) {
    // Doğrulama mantığı: tüm platformlarda paylaşılır
    fun isValid(): Boolean {
        return name.isNotBlank() &&
            email.contains("@") &&
            email.contains(".")
    }

    // Biçimlendirme mantığı: her platformda aynı
    fun displayName(): String {
        return if (name.isNotBlank()) name
        else email.substringBefore("@")
    }

    // İş mantığı: her yerde tutarlı
    fun membershipYears(): Int {
        return 2026 - joinedYear
    }
}

package com.ornek.mykmpapp.utils

// Tüm platformlarda kullanılabilir yardımcı fonksiyonlar

object StringUtils {

    fun capitalizeWords(text: String): String {
        return text.split(" ")
            .joinToString(" ") { word ->
                word.replaceFirstChar { it.uppercase() }
            }
    }

    fun truncate(text: String, maxLength: Int, suffix: String = "..."): String {
        return if (text.length <= maxLength) text
        else text.take(maxLength - suffix.length) + suffix
    }

    fun isValidEmail(email: String): Boolean {
        return email.contains("@") &&
            email.contains(".") &&
            email.indexOf("@") < email.lastIndexOf(".")
    }

    fun slugify(text: String): String {
        return text.lowercase()
            .replace(Regex("[^a-z0-9\\s-]"), "")
            .replace(Regex("\\s+"), "-")
            .trim('-')
    }
}

package com.ornek.mykmpapp.repository

import com.ornek.mykmpapp.models.User

// Repository deseni: paylaşılan veri erişim mantığı
// Gerçek bir uygulamada bu bir API veya veritabanı çağırırdı
// Şimdilik bellek içi veri kullanıyoruz

class UserRepository {

    private val users = mutableListOf(
        User("1", "Alex", "alex@example.com", 2023),
        User("2", "Sam", "sam@example.com", 2024),
        User("3", "Jordan", "jordan@example.com", 2025),
        User("4", "Taylor", "taylor@example.com", 2026),
    )

    fun getAllUsers(): List<User> = users.toList()

    fun getUserById(id: String): User? = users.find { it.id == id }

    fun searchUsers(query: String): List<User> {
        val lowerQuery = query.lowercase()
        return users.filter {
            it.name.lowercase().contains(lowerQuery) ||
                it.email.lowercase().contains(lowerQuery)
        }
    }

    fun addUser(user: User): Boolean {
        if (!user.isValid()) return false
        if (users.any { it.email == user.email }) return false
        users.add(user)
        return true
    }

    fun deleteUser(id: String): Boolean {
        return users.removeAll { it.id == id }
    }

    fun getUserCount(): Int = users.size
}

@Composable
fun App() {
    val repository = remember { UserRepository() }
    var users by remember { mutableStateOf(repository.getAllUsers()) }
    var searchQuery by remember { mutableStateOf("") }

    MaterialTheme {
        Column(modifier = Modifier.fillMaxSize().padding(16.dp)) {
            Text(
                "Users (${repository.getUserCount()})",
                style = MaterialTheme.typography.headlineMedium
            )

            // Arama çubuğu
            OutlinedTextField(
                value = searchQuery,
                onValueChange = {
                    searchQuery = it
                    users = if (it.isEmpty()) repository.getAllUsers()
                    else repository.searchUsers(it)
                },
                label = { Text("Search") },
                modifier = Modifier.fillMaxWidth()
            )

            Spacer(modifier = Modifier.height(16.dp))

            // Kullanıcı listesi
            LazyColumn {
                items(users) { user ->
                    Column(modifier = Modifier.padding(vertical = 8.dp)) {
                        Text(user.displayName(), fontWeight = FontWeight.Bold)
                        Text(user.email, fontSize = 14.sp)
                        Text(
                            "Member for ${user.membershipYears()} year(s)",
                            fontSize = 12.sp,
                            color = Color.Gray
                        )
                    }
                }
            }
        }
    }
}

// Projede hangi modüllerin var olduğunu bildirir
rootProject.name = "MyKmpApp"
include(":shared")        // Paylaşılan Kotlin modülü
include(":composeApp")    // Uygulama modülü (Android/iOS/Desktop)

kotlin {
    // Android hedefi
    androidTarget {
        compilations.all {
            kotlinOptions {
                jvmTarget = "17"
            }
        }
    }

    // iOS hedefleri: tam uyumluluk için üçü de gerekli
    listOf(
        iosX64(),              // Intel Mac simülatörleri
        iosArm64(),            // Gerçek iOS cihazları
        iosSimulatorArm64()    // Apple Silicon Mac simülatörleri
    ).forEach {
        it.binaries.framework {
            baseName = "Shared"   // iOS framework'ünün adı
            isStatic = true
        }
    }

    // Kaynak setleri: bağımlılıkların gittiği yer
    sourceSets {
        commonMain.dependencies {
            // TÜM platformlar için bağımlılıklar
            // örneğin kotlinx-coroutines, kotlinx-serialization
        }

        androidMain.dependencies {
            // Sadece Android bağımlılıkları
        }

        iosMain.dependencies {
            // Sadece iOS bağımlılıkları
        }

        commonTest.dependencies {
            // Paylaşılan kod için test bağımlılıkları
            implementation(kotlin("test"))
        }
    }
}

# Gradle daemon için bellek
org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8

# Kotlin kod stili
kotlin.code.style=official

# Compose Multiplatform'u etkinleştir
kotlin.mpp.applyDefaultHierarchyTemplate=true

// Kotlin (shared/commonMain)
object Calculator {
    fun add(a: Double, b: Double): Double = a + b
}

// Swift (iosApp)
import Shared

let result = Calculator.shared.add(a: 10.0, b: 5.0)
print(result) // 15.0

package com.ornek.mykmpapp

import com.ornek.mykmpapp.models.User
import com.ornek.mykmpapp.utils.StringUtils
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertFalse
import kotlin.test.assertTrue

class UserTest {

    @Test
    fun validUserShouldReturnTrue() {
        val user = User("1", "Alex", "alex@example.com")
        assertTrue(user.isValid())
    }

    @Test
    fun invalidEmailShouldReturnFalse() {
        val user = User("1", "Alex", "not-an-email")
        assertFalse(user.isValid())
    }

    @Test
    fun emptyNameShouldReturnFalse() {
        val user = User("1", "", "alex@example.com")
        assertFalse(user.isValid())
    }

    @Test
    fun displayNameShouldUseEmailWhenNameIsBlank() {
        val user = User("1", "", "alex@example.com")
        assertEquals("alex", user.displayName())
    }

    @Test
    fun membershipYearsShouldCalculateCorrectly() {
        val user = User("1", "Alex", "alex@example.com", 2024)
        assertEquals(2, user.membershipYears())
    }
}

class StringUtilsTest {

    @Test
    fun capitalizeWordsShouldWork() {
        assertEquals("Hello World", StringUtils.capitalizeWords("hello world"))
    }

    @Test
    fun truncateShouldAddSuffix() {
        assertEquals("Hello...", StringUtils.truncate("Hello World", 8))
    }

    @Test
    fun isValidEmailShouldWork() {
        assertTrue(StringUtils.isValidEmail("alex@example.com"))
        assertFalse(StringUtils.isValidEmail("not-email"))
        assertFalse(StringUtils.isValidEmail("@example.com"))
    }

    @Test
    fun slugifyShouldWork() {
        assertEquals("hello-world", StringUtils.slugify("Hello World!"))
    }
}

# Tüm platformlar için testleri çalıştır
./gradlew :shared:allTests

# Sadece Android için testleri çalıştır
./gradlew :shared:testDebugUnitTest

# Sadece iOS için testleri çalıştır
./gradlew :shared:iosSimulatorArm64Test

// KÖTÜ: bu iOS'ta çöker çünkü Android API'ları orada yok
// shared/src/commonMain/kotlin/
import android.util.Log  // Bu iOS için derlenmez!

fun logMessage(msg: String) {
    Log.d("TAG", msg)  // Sadece Android API'sı
}

// İYİ: platforma özgü API'lar için expect/actual kullan
// shared/src/commonMain/kotlin/
expect fun logMessage(msg: String)

// shared/src/androidMain/kotlin/
actual fun logMessage(msg: String) {
    android.util.Log.d("TAG", msg)
}

// shared/src/iosMain/kotlin/
actual fun logMessage(msg: String) {
    platform.Foundation.NSLog(msg)
}

commonMain şunu görebilir: sadece commonMain
androidMain şunu görebilir: commonMain + androidMain
iosMain şunu görebilir: commonMain + iosMain

commonMain ŞUNU GÖREMEZ: androidMain veya iosMain

# Framework'ü manuel derle
./gradlew :shared:linkDebugFrameworkIosSimulatorArm64