Linker command failed using SPM

[aleksey-ho]

What happened?

I'm trying to add MapLibre to my kmm project. It works on Android but failed for iOS. When runnig from xcode i get:

Undefined symbol: _MLNAltitudeForZoomLevel
Undefined symbol: _OBJC_CLASS_$_MLNMapCamera
Undefined symbol: _OBJC_CLASS_$_MLNOfflinePack
Linker command failed with exit code 1 (use -v to see invocation)

I'm using:

• xcode 16.4
• maplibre-compose 0.9.1
• spmForKmp 0.11.3 (tried 0.11.2)
• kotlin 2.1.21
• gradle 8.12.1
• org.jetbrains.compose 1.8.2

I also tried setting up spmForKmp like in your demo app with copyDependenciesToApp = true, exportToKotlin = true, but nothing works.
I suppose I cannot add https://github.com/maplibre/maplibre-gl-native-distribution.git using xcode spm, right?

my build.gradle file attached in Sample Code

Affected Platforms

• Android
• iOS
• Desktop (JVM)
• Browser (JS)
• Browser (Wasm)

Platform Version

macOS 15.5

Library Version

0.9.1

Sample Code

build.gradle.kts:

import java.net.URI

plugins {
    alias(libs.plugins.multiplatform)
    alias(libs.plugins.google.devtools.ksp)
    alias(libs.plugins.org.jetbrains.native.cocoapods)
    alias(libs.plugins.com.android.library)
    alias(libs.plugins.composeMultiplatform)
    alias(libs.plugins.composeCompiler)
    alias(libs.plugins.kotlin.parcelize)
    alias(libs.plugins.kotest.multiplatform)
    alias(libs.plugins.kodein.mock.mockmp)
    alias(libs.plugins.multiplatform.resources)
    alias(libs.plugins.org.jetbrains.plugin.serialization)
    alias(libs.plugins.spmForKmp)
}

mockmp {
    usesHelper = true
}

@OptIn(org.jetbrains.kotlin.gradle.ExperimentalKotlinGradlePluginApi::class)
kotlin {
    targetHierarchy.default()

    androidTarget {
        compilations.all {
            kotlinOptions {
                jvmTarget = "1.8"
            }
        }
    }

    iosX64()
    iosArm64()
    iosSimulatorArm64()

    listOf(
        iosX64(),
        iosArm64(),
        iosSimulatorArm64()
    ).forEach {
        it.compilations {
            val main by getting {
                cinterops.create("spmMaplibre")
            }
        }
    }

    cocoapods {
        summary = "Some description for the Shared Module"
        homepage = "Link to the Shared Module homepage"
        version = "1.0"
        ios.deploymentTarget = "14.1"
        framework {
            baseName = "ui"
            binaryOption("bundleId", "app.myapp.core.ui")
            isStatic = true

            export(libs.decompose)
            export(libs.decompose.lifecycle)
            export(libs.moko.resources)
            export(libs.permissions)
            export(libs.kotlinx.datetime)
            export(compose.runtime)
            export(compose.foundation)
            export(compose.material)

            export(project(":core:domain:logic"))
            export(project(":core:domain:interfaces"))
        }
    }
    
    sourceSets {
        val commonMain by getting {
            kotlin.srcDir("build/generated/ksp/metadata/commonMain/kotlin")
            dependencies {
                api(compose.runtime)
                api(compose.foundation)
                api(compose.material)
                api(compose.material3)
                api(compose.ui)

                @OptIn(org.jetbrains.compose.ExperimentalComposeLibrary::class)
                implementation(compose.components.resources)
                implementation(libs.koin.core)
                implementation(libs.koin.annotations)

                // Exported to iOS
                api(libs.decompose)
                api(libs.decompose.lifecycle)
                api(libs.moko.resources)
                api(libs.moko.resources.compose)
                api(libs.permissions)

                implementation(libs.decompose.jetbrains.extension)

                implementation(libs.datastore)
                implementation(libs.datastore.preferences)

                implementation(libs.kotlinx.datetime)

                implementation(libs.bundles.ktor.common)
                implementation(libs.coil.compose)
                implementation(libs.coil.network.ktor3)

                implementation(libs.maplibre.compose)

                api(project(":core:domain:logic"))
                api(project(":core:domain:interfaces"))
            }
        }

        val androidMain by getting {
            dependsOn(commonMain)
            dependencies {
                api(libs.androidx.activity.compose)
                api(libs.androidx.appcompat)
                api(libs.androidx.core.ktx)

                implementation(libs.koin.android)
                implementation(compose.uiTooling)

                implementation(libs.play.services.location)

                implementation(libs.chart.compose)
                implementation(libs.chart.compose.m3)

                implementation(libs.androidx.material3)

                implementation(libs.ktor.client.okhttp)
            }
        }

        val commonTest by getting {
            dependencies {
                implementation(kotlin("test"))
                implementation(libs.kotest.assertions.core)
                implementation(libs.kotest.framework.engine)
                implementation(libs.kotest.framework.datatest)
                implementation(libs.kotlinx.coroutines.test)
            }
        }

        val androidUnitTest by getting {
            dependencies {
                implementation(libs.mockk)
            }
        }

        val appleMain by getting {
            dependencies {
                implementation(libs.ktor.client.darwin)
            }
        }
    }
}

multiplatformResources {
    resourcesPackage.set("app.myapp.core.ui")
}

android {
    namespace = "app.myapp.core.ui"
    compileSdk = libs.versions.compileSdk.get().toInt()

    defaultConfig {
        minSdk = libs.versions.minSdk.get().toInt()
    }

    buildFeatures {
        compose = true
    }

    buildTypes {
        getByName("release") {
            isMinifyEnabled = true
            proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
        }
    }
}

tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
    kotlinOptions.suppressWarnings = true
    kotlinOptions.jvmTarget = JavaVersion.VERSION_1_8.toString()
}

// TODO: Extract this common part to smth on top level to embed shared logic inside all core submodules
// https://github.com/InsertKoinIO/hello-kmp/blob/annotations/shared/build.gradle.kts
dependencies {
    add("kspCommonMainMetadata", libs.koin.ksp.compiler)
}

// WORKAROUND: ADD this dependsOn("kspCommonMainKotlinMetadata") instead of above dependencies
tasks.withType<org.jetbrains.kotlin.gradle.dsl.KotlinCompile<*>>().configureEach {
    if (name != "kspCommonMainKotlinMetadata") {
        dependsOn("kspCommonMainKotlinMetadata")
    }
}

afterEvaluate {
    tasks.filter {
        it.name.contains("SourcesJar", true)
    }.forEach {
        println("SourceJarTask====>${it.name}")
        it.dependsOn("kspCommonMainKotlinMetadata")
    }
}

swiftPackageConfig {
    create("spmMaplibre") {
        dependency {
            remotePackageVersion(
                url = URI("https://github.com/maplibre/maplibre-gl-native-distribution.git"),
                products = { add("MapLibre") },
                version = "6.15.0",
            )
        }
    }
}

[sargunv]

What's the reason to combine cocoapods and SMP in the same gradle build? Unsure if that's the issue but I haven't tested that sort of setup. Have you tried adding MapLibre using cocoapods?

[aleksey-ho]

That's a very good question :)
Using pod("MapLibre", "6.15.0") worked like a charm!
Thank you for quick response!