grpc-native: Add gradle configuration for cInterop and grpcpp_c library

Signed-off-by: Johannes Zottele <[email protected]>

Author: Jozott00

gradle-conventions/src/main/kotlin/util/cInterop.kt

@@ -0,0 +1,80 @@
+/*
+ * Copyright 2023-2025 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package util
+
+
+import org.gradle.kotlin.dsl.assign
+import org.gradle.kotlin.dsl.getValue
+import org.gradle.kotlin.dsl.provideDelegate
+import org.gradle.kotlin.dsl.withType
+import org.jetbrains.dokka.gradle.tasks.DokkaGeneratePublicationTask
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+import org.jetbrains.kotlin.gradle.plugin.mpp.DefaultCInteropSettings
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
+import org.jetbrains.kotlin.gradle.tasks.KotlinNativeCompile
+
+
+/**
+ * Creates a CInterop configuration for all Native targets using the given [sourceSet]
+ * in a Kotlin Multiplatform project.
+ *
+ * The [name] defines the CInterop configuration name. Definition file is expected to be located
+ * at `[sourceSet]/interop/[name].def` by default, but can be customized via [definitionFilePath].
+ * Additional configuration can be provided through [configure] block.
+ *
+ * Simple usage:
+ * ```
+ * kotlin {
+ *     createCInterop("ssl", "posix")
+ * }
+ * ```
+ *
+ * Advanced usage with a separate definition for each target and additional configuration:
+ * ```
+ * kotlin {
+ *     createCInterop(
+ *         name = "ssl",
+ *         sourceSet = "posix",
+ *         definitionFilePath = { target -> "$target/interop/ssl.def" },
+ *         configure = { target ->
+ *             includeDirs("$target/interop/include")
+ *             compilerOpts("-DUSE_SSL")
+ *         }
+ *     )
+ * }
+ * ```
+ */
+@Suppress("UnstableApiUsage")
+fun KotlinMultiplatformExtension.createCInterop(
+    name: String,
+    sourceSet: String,
+    definitionFilePath: (String) -> String = { "$sourceSet/interop/$name.def" },
+    configure: DefaultCInteropSettings.(String) -> Unit = {}
+) {
+
+    val cinteropTargets = grpcNativeTargets().map { it.name }
+    val projectDirectory = project.isolated.projectDirectory
+
+    targets.named { it in cinteropTargets }
+        .all {
+            check(this is KotlinNativeTarget) { "Can't create cinterop for non-native target $targetName" }
+
+            val main by compilations
+            main.cinterops.create(name) {
+                definitionFile = projectDirectory.file(definitionFilePath(targetName))
+                configure(targetName)
+            }
+        }
+
+    // Disable configuration cache for compile[target]MainKotlinMetadata tasks
+    project.tasks.withType<KotlinNativeCompile>()
+        .named { it.endsWith("MainKotlinMetadata") }
+        .configureEach { notCompatibleWithConfigurationCache("Workaround for KT-76147") }
+
+    // The problem with compile*MainKotlinMetadata tasks also affects Dokka tasks
+    project.tasks.withType<DokkaGeneratePublicationTask>()
+        .named { it == "dokkaGeneratePublicationHtml" }
+        .configureEach { notCompatibleWithConfigurationCache("Workaround for KT-76147") }
+}

gradle-conventions/src/main/kotlin/util/nativeTargets.kt

@@ -0,0 +1,11 @@
+/*
+ * Copyright 2023-2025 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package util
+
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
+
+
+fun KotlinMultiplatformExtension.grpcNativeTargets(): Set<KotlinNativeTarget> = setOf(macosArm64())

grpc/grpc-core/build.gradle.kts

@@ -2,6 +2,9 @@
  * Copyright 2023-2025 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
  */
 
+import org.gradle.internal.extensions.stdlib.capitalized
+import util.createCInterop
+
 plugins {
     alias(libs.plugins.conventions.kmp)
     alias(libs.plugins.kotlinx.rpc)
@@ -28,4 +31,45 @@ kotlin {
             }
         }
     }
+
+    val grpcppCLib = projectDir.resolve("../grpcpp-c")
+
+    fun findProgram(name: String) = org.gradle.internal.os.OperatingSystem.current().findInPath(name)
+    val checkBazel by tasks.registering {
+        doLast {
+            val bazelPath = findProgram("bazel")
+            if (bazelPath != null) {
+                println("bazel: $bazelPath")
+            } else {
+                throw GradleException("'bazel' not found on PATH. Please install Bazel (https://bazel.build/).")
+            }
+        }
+    }
+
+    val buildGrpcppCLib = tasks.register<Exec>("buildGrpcppCLib") {
+        group = "build"
+        workingDir = grpcppCLib
+        commandLine("bash", "-c", "bazel build :grpcpp_c_static --config=release")
+        inputs.files(fileTree(grpcppCLib) { exclude("bazel-*/**") })
+        outputs.dir(grpcppCLib.resolve("bazel-bin"))
+
+        dependsOn(checkBazel)
+    }
+
+    createCInterop("libgrpcpp_c", sourceSet = "src/nativeMain") { target ->
+        includeDirs(grpcppCLib.resolve("include"))
+        extraOpts(
+            "-libraryPath", "${grpcppCLib.resolve("bazel-out/darwin_arm64-opt/bin")}"
+        )
+        includeDirs(
+            grpcppCLib.resolve("include"),
+            grpcppCLib.resolve("bazel-grpcpp-c/external/grpc+/include")
+        )
+
+        tasks.named("cinteropLibgrpcpp_c${target.capitalized()}") {
+            dependsOn(buildGrpcppCLib)
+        }
+
+    }
+
 }

grpc/grpc-core/src/nativeMain/interop/libgrpcpp_c.def

@@ -0,0 +1,7 @@
+headers = grpcpp_c.h
+headerFilter= grpcpp_c.h grpc/slice.h grpc/byte_buffer.h
+
+noStringConversion = grpc_slice_from_copied_buffer my_grpc_slice_from_copied_buffer
+
+linkerOpts.osx = -lgrpcpp_c_static
+#staticLibraries = libgrpcpp_c_static.a