wip

Author: Piasy

gradle/libs.versions.toml

@@ -11,7 +11,7 @@ permissionsDispatcher = "4.9.2"
 [libraries]
 kotlin-stdlib-js = { module = "org.jetbrains.kotlin:kotlin-stdlib-js", version.ref = "kotlin" }
 kotlinx-serialization-json = "org.jetbrains.kotlinx:kotlinx-serialization-json:1.8.0"
-kmpXlog = "com.piasy:kmp-xlog:1.3.5"
+kmpXlog = "com.piasy:kmp-xlog:1.4.1"
 kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test", version.ref = "kotlin" }
 
 androidx-appcompat = "androidx.appcompat:appcompat:1.7.0"

kmp-webrtc/build.gradle.kts

@@ -67,14 +67,33 @@ kotlin {
         binaries {
             all {
                 linkerOpts.addAll(listOf("-L${rootProject.projectDir}/libs/windows/x64", "-lwin_pc_client.dll"))
+                //freeCompilerArgs = listOf("-Xadd-light-debug=enable")
             }
             sharedLib {
                 baseName = "kmp_webrtc"
             }
         }
     }
 
-//    linuxX64 {}
+    linuxX64 {
+        compilations.getByName("main").cinterops {
+            val webrtc by creating {
+                definitionFile.set(project.file("src/cppCommon/cinterop/WebRTC.def"))
+                includeDirs {
+                    allHeaders("${rootProject.projectDir}/libs/windows_linux/include")
+                }
+            }
+        }
+        binaries {
+            all {
+                linkerOpts.addAll(listOf("-L${rootProject.projectDir}/libs/linux/x64", "-llinux_pc_client"))
+                //freeCompilerArgs = listOf("-Xadd-light-debug=enable")
+            }
+            sharedLib {
+                baseName = "kmp_webrtc"
+            }
+        }
+    }
 
     applyDefaultHierarchyTemplate()
     sourceSets {
@@ -116,9 +135,9 @@ kotlin {
             dependsOn(commonMain.get())
         }
 
-//        linuxMain {
-//            dependsOn(cppCommon)
-//        }
+        linuxMain {
+            dependsOn(cppCommon)
+        }
         mingwMain {
             dependsOn(cppCommon)
         }

kmp-webrtc/src/androidMain/kotlin/com/piasy/kmp/webrtc/utils/Platform.android.kt

@@ -32,6 +32,15 @@ private fun pcClientCallbackOnPreferCodecs(
         return null
     }
 
+    // this function is designed to be called from cpp code,
+    // and cpp code needs to access the returned string,
+    // so we need to make sure the cstr still lives after
+    // the function returns, so we use nativeHeap.allocArray
+    // and nativeHeap.free (in freeKString above).
+    // but when kotlin code calls cpp code, when we want to pass
+    // cstr to cpp code, we can just use memScoped, because the
+    // whole cpp function call lifetime is inside the memScoped
+    // block (in CppUtils.kt).
     val refinedSdp = opaque.asStableRef<PeerConnectionClientCallback>()
         .get()
         .onPreferCodecs(peerUid, sdp)

kmp-webrtc/src/commonMain/kotlin/com/piasy/kmp/webrtc/utils/Platform.kt

@@ -0,0 +1,22 @@
+package com.piasy.kmp.webrtc
+
+import kotlinx.cinterop.COpaquePointer
+
+/**
+ * Created by Piasy{github.com/Piasy} on 2025-03-02.
+ */
+class LinuxPeerConnectionClient(
+    peerUid: String,
+    dir: Int,
+    needCaptureVideo: Boolean,
+    videoMaxBitrate: Int,
+    videoCaptureFps: Int,
+    callback: PeerConnectionClientCallback
+) : CppPeerConnectionClient(peerUid, dir, needCaptureVideo, videoMaxBitrate, videoCaptureFps, callback) {
+
+    override fun addRemoteTrackRenderer(renderer: Any) {
+//        if (renderer is COpaquePointer) {
+//            WebRTC.PCClientAddRemoteRenderer(realClient, renderer)
+//        }
+    }
+}

kmp-webrtc/src/cppCommon/kotlin/com/piasy/kmp/webrtc/CppPeerConnectionClient.kt

@@ -0,0 +1,33 @@
+package com.piasy.kmp.webrtc
+
+import kotlinx.cinterop.COpaquePointer
+
+/**
+ * Created by Piasy{github.com/Piasy} on 2025-03-05.
+ */
+data class LinuxPrivateConfig(
+    internal val hwnd: COpaquePointer,
+    internal val disableEncryption: Boolean,
+) : PeerConnectionClientFactory.PrivateConfig()
+
+class LinuxPeerConnectionClientFactory(
+    config: Config,
+    errorHandler: (Int, String) -> Unit,
+) : CppPeerConnectionClientFactory(config, errorHandler) {
+
+    override fun createPeerConnectionClient(
+        peerUid: String, dir: Int, hasVideo: Boolean,
+        videoMaxBitrateBps: Int, videoMaxFrameRate: Int,
+        callback: PeerConnectionClientCallback
+    ) = LinuxPeerConnectionClient(peerUid, dir, hasVideo, videoMaxBitrateBps, videoMaxFrameRate, callback)
+}
+
+actual fun createPeerConnectionClientFactory(
+    config: PeerConnectionClientFactory.Config,
+    errorHandler: (Int, String) -> Unit,
+): PeerConnectionClientFactory {
+    val privateConfig = config.privateConfig as LinuxPrivateConfig
+    val disableEncryption = if (privateConfig.disableEncryption) 1 else 0
+    WebRTC.PCClientCreatePeerConnectionFactory(privateConfig.hwnd, disableEncryption, 0, 0)
+    return LinuxPeerConnectionClientFactory(config, errorHandler)
+}

kmp-webrtc/src/iosMain/kotlin/com/piasy/kmp/webrtc/utils/Platform.ios.kt

@@ -0,0 +1,25 @@
+package com.piasy.kmp.webrtc.utils
+
+import com.piasy.kmp.webrtc.PeerConnectionClient
+import com.piasy.kmp.webrtc.PeerConnectionClientFactory
+import com.piasy.kmp.webrtc.LinuxPrivateConfig
+import kotlinx.cinterop.COpaquePointer
+
+/**
+ * Created by Piasy{github.com/Piasy} on 2025-03-06.
+ *
+ * Utility functions used by cpp example code.
+ */
+
+fun createPcClientFactoryConfig(
+    config: PeerConnectionClientFactory.Config, privateConfig: LinuxPrivateConfig
+): PeerConnectionClientFactory.Config {
+    return PeerConnectionClientFactory.Config(
+        config.videoCaptureImpl, config.videoCaptureWidth, config.videoCaptureHeight, config.videoCaptureFps,
+        config.initCameraFace, privateConfig
+    )
+}
+
+fun addRemoteTrackRenderer(client: PeerConnectionClient, renderer: COpaquePointer) {
+    client.addRemoteTrackRenderer(renderer)
+}