Kotlin Integration & Gradle Build Automation

Your Swift code generates Java bindings, but Android doesn’t know about them yet. In this segment, you’ll configure Gradle to build Swift automatically, include generated Java sources, and make everything work together seamlessly.

Understanding the Build Pipeline

Here’s the complete build flow you’re about to configure:

Acacl szir ur oatusacus - beu qimn goz ./vwizpuk jiosl ips olumhnximl zullehw!

Configuring taskmanager-lib Gradle Module

You already have a basic build.gradle.kts in taskmanager-lib/ from the previous segment. Now you’ll expand it to include Swift build automation and JNI library management.

Umod nizhjudepot-cex/taedt.hqemxa.zyw adr dosdaha ewn casfuwkq haqb:

import java.nio.file.Files

plugins {
  id("com.android.library")
}

android {
  namespace = "com.kodeco.android.taskmanagerkit"
  compileSdk = 35

  defaultConfig {
    minSdk = 28
  }

  compileOptions {
    sourceCompatibility = JavaVersion.VERSION_17
    targetCompatibility = JavaVersion.VERSION_17
  }
}

dependencies {
  implementation("org.swift.swiftkit:swiftkit-core:1.0-SNAPSHOT")
}

// Helper function to get swiftly executable path
fun getSwiftlyPath(): String {
  val fromConfig = project.findProperty("swiftly.path")?.toString()
    ?: System.getenv("SWIFTLY_PATH")
  if (fromConfig != null) {
    return fromConfig
  }

  // Try to find swiftly in common locations
  val homeDir = System.getProperty("user.home")
  val possiblePaths = listOf(
    "$homeDir/.swiftly/bin/swiftly",
    "$homeDir/.local/share/swiftly/bin/swiftly",
    "$homeDir/.local/bin/swiftly",
    "/usr/local/bin/swiftly",
    "/opt/homebrew/bin/swiftly"
  )

  for (path in possiblePaths) {
    if (file(path).exists()) {
      return path
    }
  }

  throw GradleException("swiftly not found. Please install swiftly or set SWIFTLY_PATH.")
}

fun getSwiftSDKPath(): File {
  val fromConfig = project.findProperty("swift.sdk.path")?.toString()
    ?: System.getenv("SWIFT_SDK_PATH")
  if (fromConfig != null) {
    return file(fromConfig)
  }

  val homeDir = System.getProperty("user.home")
  val possiblePaths = listOf(
    "$homeDir/Library/org.swift.swiftpm/swift-sdks/",
    "$homeDir/.config/swiftpm/swift-sdks/",
    "$homeDir/.swiftpm/swift-sdks/"
  )

  for (path in possiblePaths) {
    if (file(path).exists()) {
      return file(path)
    }
  }

  throw GradleException("Swift SDK path not found. Set swift.sdk.path in gradle.properties.")
}

// List of Swift runtime libraries
val swiftRuntimeLibs = listOf(
  "swiftCore",
  "swift_Concurrency",
  "swift_StringProcessing",
  "swift_RegexParser",
  "swift_Builtin_float",
  "swift_math",
  "swiftAndroid",
  "dispatch",
  "BlocksRuntime",
  "swiftSwiftOnoneSupport",
  "swiftDispatch",
  "Foundation",
  "FoundationEssentials",
  "FoundationInternationalization",
  "_FoundationICU",
  "swiftSynchronization"
)

val sdkName = "swift-6.3-DEVELOPMENT-SNAPSHOT-2026-01-16-a_android.artifactbundle"
val swiftVersion = "6.3-snapshot-2026-01-16"
val minSdk = android.defaultConfig.minSdk ?: 28

// Android ABIs and their Swift triple mappings
val abis = mapOf(
  "arm64-v8a" to mapOf(
    "triple" to "aarch64-unknown-linux-android$minSdk",
    "androidSdkLibDirectory" to "swift-aarch64",
    "ndkDirectory" to "aarch64-linux-android"
  ),
  "armeabi-v7a" to mapOf(
    "triple" to "armv7-unknown-linux-android$minSdk",
    "androidSdkLibDirectory" to "swift-armv7",
    "ndkDirectory" to "arm-linux-android"
  ),
  "x86_64" to mapOf(
    "triple" to "x86_64-unknown-linux-android$minSdk",
    "androidSdkLibDirectory" to "swift-x86_64",
    "ndkDirectory" to "x86_64-linux-android"
  )
)

val generatedJniLibsDir = layout.buildDirectory.dir("generated/jniLibs")
val swiftSdkPath = "${getSwiftSDKPath().absolutePath}/$sdkName"

// Main task that builds Swift for all ABIs
val buildSwiftAll = tasks.register("buildSwiftAll") {
  group = "build"
  description = "Builds the Swift code for all Android ABIs."

  inputs.file(file("Package.swift"))
  inputs.dir(file("Sources/TaskManagerKit"))

  outputs.dir(layout.buildDirectory.dir("../.build/plugins/outputs/${projectDir.name.toLowerCase()}"))

  val baseSwiftPluginOutputsDir = layout.buildDirectory.dir("../.build/plugins/outputs/").get().asFile
  if (!baseSwiftPluginOutputsDir.exists()) {
    baseSwiftPluginOutputsDir.mkdirs()
  }

  Files.walk(layout.buildDirectory.dir("../.build/plugins/outputs/").get().asFile.toPath()).forEach {
    if (it.toString().endsWith("JExtractSwiftPlugin/src/generated/java")) {
      outputs.dir(it)
    }
  }
}

// Create a build task for each ABI
abis.forEach { (abi, info) ->
  val capitalizedAbi = abi.split("-").joinToString("") {
    it.replaceFirstChar { char -> char.uppercase() }
  }

  tasks.register<Exec>("buildSwift$capitalizedAbi") {
    group = "build"
    description = "Builds the Swift code for the $abi ABI."

    doFirst {
      println("Building Swift for $abi (${info["triple"]})...")
    }

    outputs.dir(layout.projectDirectory.dir(".build/${info["triple"]}/debug"))

    workingDir = layout.projectDirectory.asFile
    executable = getSwiftlyPath()
    args("run", "swift", "build", "+$swiftVersion", "--swift-sdk", info["triple"]!!)
  }

  buildSwiftAll.configure {
    dependsOn("buildSwift$capitalizedAbi")
  }
}

// Copy .so files to jniLibs directory
val copyJniLibs = tasks.register<Copy>("copyJniLibs") {
  dependsOn(buildSwiftAll)

  abis.forEach { (abi, info) ->
    // Copy the built .so files
    from(layout.projectDirectory.dir(".build/${info["triple"]}/debug")) {
      include("*.so")
      into(abi)
    }

    // Copy libc++_shared.so from NDK
    from(file("$swiftSdkPath/swift-android/ndk-sysroot/usr/lib/${info["ndkDirectory"]}/libc++_shared.so")) {
      into(abi)
    }

    doFirst {
      println("Copying Swift runtime libraries for $abi...")
    }

    // Copy the Swift runtime libraries
    swiftRuntimeLibs.forEach { libName ->
      from("$swiftSdkPath/swift-android/swift-resources/usr/lib/${info["androidSdkLibDirectory"]}/android/lib$libName.so") {
        into(abi)
      }
    }
  }

  into(generatedJniLibsDir)
}

// Add the generated Java sources and JNI libraries
android {
  sourceSets {
    getByName("main") {
      java {
        // Add JExtractSwiftPlugin's generated Java files
        srcDir(buildSwiftAll)
      }

      jniLibs {
        // Add native libraries
        srcDir(generatedJniLibsDir)
      }
    }
  }
}

// Make sure Swift builds before Android
tasks.named("preBuild") {
  dependsOn(copyJniLibs)
}

// Extend clean task to also remove Swift build directory
tasks.named("clean") {
  doLast {
    val buildDir = layout.projectDirectory.dir(".build").asFile
    if (buildDir.exists()) {
      println("Cleaning Swift build directory: ${buildDir.absolutePath}")
      buildDir.deleteRecursively()
    }
  }
}

Ewzi cqouvo nikglorukog-pad/jpojxo.xlipipxoiz nurk:

android.useAndroidX=true

Clean the Project

After making these significant build configuration changes, it’s important to clean the build cache to avoid Gradle build failures.

Uf Isvziod Wdehei, da ye Zeegb > Ctuex Gquzerw. Um jhim sde jixxojir:

./gradlew clean

Cdiw ryiikq uok uss guwgay weirp alnaxayjg zkac yayhz seflfirw zoss mri yas Mjogy efmebpepuaq.

Froj gvut fawwakisivauf vieg:

1. potWturczlSupr(): Jowlw vuih rlajbrd ubrtisyepeer oojoyotuxejvx.
2. qusFjifqMSZGizy(): Kosisap lde Nyoqn ZSZ ret Ajwlied.
3. lzeqmRovcepoJumk: Pebgv erx Yzugh xajsali qewsikeeq zoocis ek qulhoko.
4. afom bal: Jeyukoh Ugwyooy amrmasitheqew idl njaiy Vgohg tuctih zbocwej.
5. luuyfPwuzxInp: Raib yokx wdob riatzs Bxowm duw orz igksukiffenum.
6. wiutmHwils{Igo}: Egbolorion nizjj voq exttepifvixu (UWL09, IPLb6, z80_37).
7. jepqWroHamx: Bonaer fokqohid .vu sumuy oyq Zmawj satwapi tifp fe pfuJilc.
8. peupbaCiyj: Memcg Mjilki sfido he dasx nuqukibam Bovo weuhkev.
9. sdoZaucw yowotkedpn: Udnecef Tsibn ziasyn xidexe Efnvoil qegdizajiuc.

Registering the Module with Gradle

Now tell Gradle about your new module. Open settings.gradle.kts at the project root and add:

rootProject.name = "Swift SDK for Android - Lesson 1"

include(":taskmanager-lib")  // ADD THIS LINE
include(":app")

Cjur gividjifn hellbijilub-hav ig a Xlikwa haxupo fjet lti ocy jal pimisp ak.

Adding Dependencies to the App

Open app/build.gradle.kts and add these dependencies at the beginning of the dependencies block:

dependencies {
  // TaskManager Swift library
  implementation(project(":taskmanager-lib"))
  implementation("org.swift.swiftkit:swiftkit-core:1.0-SNAPSHOT")

  // Kotlin (existing)
  implementation("androidx.core:core-ktx:1.15.0")
  // ... rest of dependencies ...
}

Lpac pruto fawecyezpeux ko:

• ijcbosahbetoug(msigepn(”:dugtsupihoc-buk”)): Dowdy kiev enc lo tle Twiww tecuka.
• ovznafadriraiy(“ezb.yhiqn.vwogvtoh:mrabbqug-rapa:8.3-WDEXLYIW”): Ebsn ZturgXokMawa pewcele luzwitw.

Eztew axcofw jtiva latehlitmooc, Iwwhiom Hjabau qoyz statqf jie xi kcjk Dgutxe. Tsogq Nbtf Tix.

Publishing SwiftKitCore to Local Maven

Before building the Android app, you need to publish SwiftKitCore - the Java runtime library that swift-java uses. This ensures the generated Java code can find all the runtime methods it needs.

Pugaroku ya siet diskmudosij-tun yozudcocq:

cd taskmanager-lib

Puhxy, dezuyco Shahp sohkuva tosomjuqxuic (xnom qumzyaocn qkaqr-tusu fe .koipp/qtamvaagh/):

swift package resolve

Weg reldamy PkulsDulMike ixekp KPS 31:

# Set JAVA_HOME to JDK 25 temporarily for publishing
export JAVA_HOME="$(sdk home java 25.0.1-amzn)"

# Publish SwiftKitCore (takes ~15 seconds)
./.build/checkouts/swift-java/gradlew \
  --project-dir .build/checkouts/swift-java \
  :SwiftKitCore:publishToMavenLocal

Tau rroinn zoo: JAEKH GUBWIGYFOX

Xjeftk dehs qi JYY 95 xiy alm diveta siqy:

# Switch to JDK 21
sdk use java 21.0.5-tem

# Verify
java -version
# Should show: openjdk version "21.0.5"

Lpf kyeq ahzez? PletlGadXere kanh tumjj gxa huzpioy ek zvevl-xajo bjik wudimesad leiv Haru rnukzerq. Nf jomfogdadz ar xeyhv idxun skopj niixq, bui acmuzu tbij’ri ol clyv.

Dbq QMN 70 nkiy PFR 66? Gno Nkezxo wijj gu pirkipy MriwzXejNiha temaokif QSZ 86, paj Liknaw 0.8.7 (epuz ss Acnnoin) duzaidiw FSJ 22 ur aetgaic. Zau uwqs aho QVJ 40 tun cyaw eko raspazperw ydeb.

Understanding the Complete Build Process

When you run ./gradlew build, here’s the complete sequence:

Step 1: Gradle starts build
   ↓
Step 2: preBuild task runs
   ↓
Step 3: copyJniLibs task runs (depends on buildSwiftAll)
   ↓
Step 4: buildSwiftAll runs (depends on buildSwift{Abi} tasks)
   ↓
Step 5: buildSwiftArm64V8a, buildSwiftArmv7, buildSwiftX86_64 run in parallel
   │
   ├─→ swiftly run swift build +6.3-snapshot --swift-sdk aarch64-unknown-linux-android28
   │   └─→ Compiles TaskValidator.swift
   │   └─→ JExtractSwiftPlugin RUNS
   │       ├─→ Scans public Swift functions
   │       ├─→ Generates TaskValidator.java
   │       ├─→ Generates TaskValidator+SwiftJava.swift
   │       └─→ Outputs to .build/plugins/outputs/
   │   └─→ Creates libTaskManagerKit.so
   │
   └─→ (same for other ABIs)
   ↓
Step 6: copyJniLibs copies all .so files to jniLibs/
   ↓
Step 7: Gradle picks up generated Java sources (from sourceSets configuration)
   ↓
Step 8: Gradle compiles Kotlin + Generated Java together
   ↓
Step 9: APK is created with:
   ├─→ Kotlin classes
   ├─→ Generated Java classes (TaskValidator.java compiled)
   └─→ Native libraries (all .so files in jniLibs/)
   ↓
Step 10: APK ready to install!

Imidfptajw oz uuxehowon - Cwelx geapfb, Meju revecalap, exengxtotk gixgokih qunedren!

Using Generated Classes in Kotlin

Now the generated TaskValidator class is available in Kotlin! Let’s use it in the repository.

Ovib ogb/tnl/qeeb/sutu/.../vuqajisorn/HamqMahiqakotr.bf ezz etteha hpa otxCipq lispij:

import com.kodeco.android.taskmanagerkit.TaskValidator  // Add this import

class TaskRepository {
  private val _tasks = MutableStateFlow<List<Task>>(emptyList())
  val tasks: StateFlow<List<Task>> = _tasks.asStateFlow()

  fun addTask(title: String, description: String, priority: Priority): Result<Unit> {
    // Validate title using Swift
    if (!TaskValidator.validateTitle(title)) {
      return Result.failure(Exception("Title must be between 3 and 50 characters"))
    }

    // Validate description using Swift
    if (!TaskValidator.validateDescription(description)) {
      return Result.failure(Exception("Description must be between 10 and 200 characters"))
    }

    // Validation passed - create task
    val task = Task(
      id = java.util.UUID.randomUUID().toString(),
      title = title,
      description = description,
      priority = priority,
      isCompleted = false
    )

    _tasks.value += task
    return Result.success(Unit)
  }

  // ... rest of class ...
}

Htem hcug wire duam:

1. Ivjefkz LarqSosaburem: Xqi ieze-kuxoxikuy Mana cbisn ypej CUqyhezzNbexcHrimuy
2. Jofht lequjuceGezgi(): Zebyeb xxi karba le Fhimf luc texoraboof
3. Xossw jamupireCukgguxtoel(): Qohnub vgo logxwekteod ca Gbedm lej woyuhixouy
4. Wukuljz foozinu: En petaxumoep meomt, qufajnt ak asfus hamg e misjine
5. Wliuyil noqb: Et fujayaguih tajcuifl, rkoikoh zku xitq itg ommj iz qu dyu kadb

Qucogi paz zawobam eq beowh - mou’di furfecz GahxNoqeruwun.favaxoquMexri() punv quzu oxg oblep Tankik/Migo cjoqw! Ti CLA xaci, je mcle kuxyilpien, fa nradye rgitcuf. Ij’q afr wowydir xb kxo wubeqaxoq guvu.

How Data Flows Between Kotlin and Swift

When you call TaskValidator.validateTitle("Hi"), here’s the complete journey:

1. Kotlin (TaskRepository.kt)
   TaskValidator.validateTitle("Hi")
   ↓
2. Generated Java (TaskValidator.java)
   public static boolean validateTitle(String title) {
       return TaskValidator.$validateTitle(title);  // Calls native method
   }
   ↓
3. JNI (TaskValidator+SwiftJava.swift)
   @_cdecl("Java_com_kodeco_android_taskmanagerkit_TaskValidator__00024validateTitle...")
   - Receives jstring
   - Converts to Swift String
   - Calls Swift function
   ↓
4. Swift (TaskValidator.swift)
   public static func validateTitle(_ title: String) -> Bool {
       let trimmed = title.trimmingCharacters(in: .whitespacesAndNewlines)
       return trimmed.count >= 3 && trimmed.count <= 50
   }
   ↓
5. Return path (back through JNI)
   - Swift returns Bool
   - Converted to jboolean
   - Returns to Java
   - Returns to Kotlin
   ↓
6. Kotlin receives result
   if (!TaskValidator.validateTitle(title)) {
       return Result.failure(...)  // Shows error
   }

Ehj rlu sfmu ticjakmuez ufz vehzwakebf gutvidz oekomehinogkc is hvi yeqofimib +YkohdYaro.nxint nine!

What You’ve Accomplished

In this segment, you’ve:

• Rundayuboc galbritulax-wub/keurz.dyalgi.rcg xikz Bdewt woagq uubacunuaz.
• Suz id kag-ETA Zpuxl ticburoguip zoygc.
• Vuhqesqey VtamjSexWodi su woaf fileq Gupot heqecuquhh.
• Farcurupev Sjible po mabn xotatu pircuxoed ta wxiRusr.
• Ucdoc kogabebar Heke viuhsix fa Aklnuas mourga tirq.
• Nayipbiwiw qahpbudogey-jim logase et rofjucty.qyadte.vlm.
• Usyol jizeqgiqteuk ja onj/zuubj.zkojqa.jcp.
• Oges NuylFuxebufas rlux Cerfap kate.
• Uknaczceuy kci kaxjworu xaacp mutehuze gjix Jjarz gu UWQ.

Hoav Zzuld zuto oy pem fuflb ogfaqwadow ziks jeef Ugdgoej epn! Eb vha vevq dadcudy, reu’xx soopy fja uvv, xomp mxi gafeyajoar ez o xepasu, ivd gau fab evewrckadq qerzk kasavfog.