CocoaPods Plugin — bu nima, KMM uchun plagin va sozlash

CocoaPods Plugin nima?

CocoaPods Plugin (shuningdek kotlin.cocoapods nomi bilan tanilgan) — bu CocoaPods ni Kotlin Multiplatform Mobile bilan integratsiya qilish uchun JetBrains ning rasmiy plaginidir. Plagin Kotlin Gradle DSL ning bir qismidir va to'g'ridan-to'g'ri KMM modulining build.gradle.kts da sozlanadi. U Podfile yaratish va qo'llab-quvvatlash, .xcworkspace ni yaratish va pod bog'liqliklarini boshqarishni avtomatlashtiradi, dasturchini Xcode loyihasining qo'lda sozlashidan ozod qiladi.

CocoaPods Plugin paydo bo'lishidan oldin, KMM dasturchilari Podfile ni qo'lda yaratishga, pod install ni ishga tushirishga, bridge-headerlarni sozlashga va pod versiyalarini Gradle bog'liqliklaridan alohida kuzatishga majbur edilar. Bu versiyalarning desinxronizatsiyasiga va CI/CD quvurlarida qiyinchiliklarga olib keldi. Plagin bu muammolarni hal qildi, iOS bog'liqliklarini boshqarishni Android modullarida Gradle bog'liqliklarini boshqarish kabi sodda qildi.

Plagin CocoaPods Trunk dan ommaviy podlarni ham, xususiy repozitoriylardan maxsus podlarni ham qo'llab-quvvatlaydi. Mahalliy Podspec va git asosidagi repozitoriylar bilan ishlash ham qo'llab-quvvatlanadi. Plagin Kotlin 1.6.0 va undan yuqori versiyalari bilan mos keladi, shuningdek dasturchi mashinasida CocoaPods o'rnatilgan bo'lishini talab qiladi (gem install cocoapods).

CocoaPods Plugin qanday ishlaydi

CocoaPods Plugin Gradle topshiriqlar grafigi darajasida ishlaydi, CocoaPods bilan ishlash uchun ixtisoslashtirilgan topshiriqlarni qo'shadi. Asosiy topshiriqlarga podInstall (podlarni o'rnatish), podGenXcodeWorkspace (.xcworkspace yaratish) va podBuildDebugFramework (framework ning debug versiyasini qurish) kiradi. Plagin build.gradle.kts dagi cocoapods bo'limini tahlil qiladi, e'lon qilingan bog'liqliklar asosida Podfile yaratadi va kerakli parametrlar bilan pod install ni ishga tushiradi.

Plagin arxitekturasi uch komponentni o'z ichiga oladi: build.gradle.kts uchun DSL kengaytmasi, Podfile yaratish uchun Podfile Generator va .xcworkspace ni sozlash uchun Xcode integratsiya qatlami. DSL kengaytmasi bog'liqliklarni e'lon qilish uchun pod() funksiyalari, xususiy repozitoriylarni ko'rsatish uchun specRepo() va chiqish framework ni sozlash uchun framework { } bilan cocoapods { } blokini taqdim etadi. Podfile Generator bu e'lonlarni CocoaPods uchun tushunarli Ruby sintaksisiga tarjima qiladi.

kotlin {
    cocoapods {
        summary = "Shared module for iOS project"
        homepage = "https://itsectr.com"
        framework {
            baseName = "Shared"
            isStatic = true
            export(project(":core"))
        }
        pod("Alamofire") {
            version = "~> 5.9"
        }
        pod("Kingfisher") {
            version = "7.12"
        }
    }
}

podInstall topshirig'ining hayot aylanishi

podInstall bajarilganda, plagin ketma-ket: loyiha ildizida Podfile yaratadi, buyruq qatori orqali pod install ni ishga tushiradi, .xcworkspace yaratadi, pod versiyalarining e'lon qilinganlarga muvofiqligini tekshiradi va Podfile.lock ni keshlaydi. Konfiguratsiyada o'zgarishlarsiz qayta ishga tushirilganda, Podfile.lock o'zgarmagan bo'lsa, podInstall o'tkazib yuboriladi. Bu pod install toza o'rnatishda 2-3 daqiqagacha vaqt olishi mumkin bo'lgan CI/CD da vaqtni tejaydi.

KMM loyihasida CocoaPods Plugin ni sozlash

CocoaPods Plugin ni sozlash uchun bir necha qadamlarni bajarish kerak. Dasturchi mashinasida CocoaPods ni o'rnatish (gem install cocoapods) majburiy shartdir. Keyin shared modulining build.gradle.kts da framework va bog'liqliklar konfiguratsiyasi bilan cocoapods { } bloki qo'shiladi. Konfiguratsiyadan so'ng, Podfile yaratadigan va podlarni o'rnatadigan podInstall topshirig'ini bajarish kerak. Yaratilgan .xcworkspace Podfile yonidagi loyiha ildizida joylashadi.

Plagin Xcode Build Phases bilan integratsiyalanadi. iOS ilovasi qurilayotganda, Xcode embedAndSignAppleFrameworkForXcode — Kotlin/Native framework ni ilova paketiga nusxalovchi topshiriqni ishga tushiradi. CocoaPods Plugin bu qurish bosqichini .xcworkspace yaratilganda avtomatik qo'shadi. Agar .xcworkspace yaratilgan bo'lsa, pod bog'liqliklari bilan to'g'ri qurish uchun .xcodeproj o'rniga uni ochish kerak.

Kod misollari: podlarni konfiguratsiya qilish

CocoaPods Plugin da podlarni e'lon qilishning turli stsenariylarini ko'rib chiqamiz. Asosiy holat — versiyani ko'rsatgan holda CocoaPods Trunk dan ommaviy podni ulash. Murakkabroq stsenariylar maxsus podspec, mahalliy podlar va git repozitoriylaridan podlardan foydalanishni o'z ichiga oladi.

kotlin {
    iosArm64()
    iosSimulatorArm64()

    cocoapods {
        framework {
            baseName = "Shared"
            isStatic = false
        }

        // CocoaPods Trunk dan ommaviy pod
        pod("Alamofire") { version = "5.9.0" }

        // Operator bilan maxsus versiya
        pod("SnapKit") { version = "~> 5.6" }

        // Xususiy repozitoriydan pod
        specRepo("https://git.itsectr.com/specs.git",
            "internal-specs")
        pod("InternalAnalyticsPod")

        // Yo'l bilan mahalliy pod
        pod(name = "CustomPod",
            localPath = "./ios-pods/CustomPod")

        // Git repozitoriysidan pod
        pod(name = "PrivateSDK",
            git = "https://git.itsectr.com/ios/sdk.git",
            tag = "2.1.0")
    }
}

Podlarni ulash konfiguratsiyaning faqat bir qismidir. Plagin, shuningdek, boshqa Kotlin modullaridan bog'liqliklarni iOS framework ga eksport qilish imkonini beradi. export(project(":core")) funksiyasi :core modulining barcha ommaviy API lari yaratilgan framework ning Objective-C sarlavhasidan foydalanish mumkin bo'lishi kerakligini ko'rsatadi. Bu umumiy Kotlin kodi boshqa modulning sinflaridan foydalanganda va ular Swift dan foydalanish mumkin bo'lishi kerak bo'lganda zarur.

cocoapods {
    framework {
        baseName = "Shared"
        // Modullarni iOS framework ga eksport qilish
        export(project(":network"))
        export(project(":domain"))

        // Statik yoki dinamik ulash
        isStatic = true
    }

    // Eksport qilingan modullar uchun talab qilinadigan pod
    pod("Moya") { version = "15.0" }
}

Qurish va test qilish

Konfiguratsiya sozlangandan so'ng, Podfile yaratish va bog'liqliklarni o'rnatish uchun podInstall ni bajarish kerak. Keyin yaratilgan .xcworkspace Xcode da ochiladi, bu erda ilovani standart usulda qurish mumkin. CI/CD uchun qurish mashinasida CocoaPods va Ruby o'rnatilganligiga ishonch hosil qilish kerak. Plagin CI muhitida ishlash uchun --no-daemon bayrog'ini qo'llab-quvvatlaydi.

// Podlarni o'rnatish Podfile + xcworkspace yaratadi
./gradlew :shared:podInstall

// Test uchun debug framework qurish
./gradlew :shared:podBuildDebugFramework

// Buyruq qatoridan to'liq iOS qurish
xcodebuild -workspace ios-app.xcworkspace \
    -scheme ios-app -configuration Debug

CocoaPods Plugin vs Swift Package Manager

Swift Package Manager (SPM) — Apple dan muqobil bog'liqlik menejeri bo'lib, mashhurlikka erishmoqda va asta-sekin iOS hamjamiyatida CocoaPods ni siqib chiqarmoqda. Biroq CocoaPods Plugin bir necha sabablarga ko'ra dolzarb bo'lib qolmoqda: SPM KMM kontekstida dinamik framework larni qo'llab-quvvatlamaydi va Kotlin/Native framework ni SPM orqali integratsiya qilish qo'shimcha sozlashni talab qiladi. CocoaPods Plugin yetukroq va hujjatlashtirilgan integratsiya yo'lini taqdim etadi.

Taqqoslash CocoaPods Plugin va SPM orqali to'g'ridan-to'g'ri integratsiya birinchisining avtomatlashtirishda, ikkinchisining esa Apple ning mahalliy qo'llab-quvvatlashida ustun ekanligini ko'rsatadi. CocoaPods Plugin avtomatik Podfile yaratadi, versiyalarni boshqaradi va Xcode Build Phases larni sozlaydi. SPM Kotlin framework ni Package.swift orqali qo'lda ulashni talab qiladi, bu katta KMM loyihalari uchun qo'llab-quvvatlash qiyinroq. JetBrains Kotlin/Native uchun SPM qo'llab-quvvatlash ustida ishlamoqda, ammo 2025 yilgacha SPM integratsiyasi eksperimental bo'lib qolmoqda.

Oddiy muammolar va yechimlar

CocoaPods Plugin dan foydalanganda KMM dasturchilari bir necha odatiy muammolarga duch kelishadi. Pod versiyalari mojarosi — eng keng tarqalgan muammo, ikki pod bir xil bog'liqlikning turli versiyalarini talab qilganda yuzaga keladi. Yechim pod("Dependency") { version = "x.x" } orqali mojaroli bog'liqlik versiyasini aniq ko'rsatishdir. Ikkinchi keng tarqalgan holat — versiya nomuvofiqligi, pod KMM loyihasining minimal versiyasidan yangiroq iOS SDK ni talab qilganda.

.xcworkspace bilan muammolar plagin sozlangandan so'ng .xcworkspace o'rniga .xcodeproj ochilganda yuzaga keladi. Plagin bu haqda podInstall jurnallarida ogohlantiradi. Yana bir keng tarqalgan xato — dasturchi mashinasida CocoaPods ning yo'qligi. Plagin podInstall ni ishga tushirishdan oldin pod buyrug'ining mavjudligini tekshiradi va tushunarli xato xabarini ko'rsatadi. CI/CD uchun CocoaPods ni o'rnatish kerak: gem install cocoapods.

// Versiya mojarosini hal qilish
cocoapods {
    pod("Alamofire") { version = "5.9.0" }
    // Mojaroni aniq hal qilish
    pod("Alamofire") {
        version = "5.9.0"
        options[name] = mapOf("force" to true)
    }
}

// CocoaPods o'rnatilishini Gradle orqali tekshirish
tasks.register("checkCocoapods") {
    doLast {
        val result = "pod --version".runCommand()
        println("CocoaPods versiyasi: $result")
    }
}

podInstall ni tuzatish

Agar podInstall xato bilan tugasa, batafsil chiqish uchun --info bayrog'idan foydalaning: ./gradlew podInstall --info. Plagin har bir qadamni qayd qiladi: Podfile yaratish, pod install ni ishga tushirish, Podfile.lock ni tahlil qilish. Ko'pincha xatolar tarmoq muammolari (CocoaPods Trunk ga kirish imkoniyati yo'qligi) yoki Podfile ning noto'g'ri sintaksisi bilan bog'liq. Bunday hollarda, CocoaPods dan batafsil xato xabarini olish uchun loyiha ildizida pod install ni qo'lda ishga tushirishga harakat qiling.