feat(kmp): Phase 2 - multiplatform :core:network foundation

- New KMP module :core:network (android + desktop) introducing the jvmShared
  intermediate source set pattern: OkHttp (a JVM library) lives in jvmShared and
  is shared by both JVM targets, while commonMain holds the platform-agnostic
  NetworkClient/NetworkResponse API + an expect httpClient() factory.
- OkHttpNetworkClient provides the JVM actual; an iOS (Kotlin/Native) target would
  add an iosMain actual (e.g. Ktor Darwin) without touching this API.
- desktopApp now performs a real HTTP GET through the shared NetworkClient.

Additive and non-invasive: the existing core:common NetworkHelper and the
source-api network ABI are untouched (migrating them onto this foundation is
follow-on work, entangled with the source-api commonMain ABI).

Co-authored-by: Cuong-Tran <cuong-tran@users.noreply.github.com>

Author: cursoragent

core/network/build.gradle.kts

@@ -0,0 +1,46 @@
+import org.jetbrains.kotlin.gradle.ExperimentalKotlinGradlePluginApi
+
+plugins {
+    id("mihon.library")
+    kotlin("multiplatform")
+}
+
+kotlin {
+    androidTarget()
+    // KMK --> Desktop (JVM) target sharing the OkHttp implementation with Android via `jvmShared`
+    jvm("desktop")
+    // KMK <--
+
+    applyDefaultHierarchyTemplate()
+
+    sourceSets {
+        val commonMain by getting {
+            dependencies {
+                api(project.dependencies.platform(kotlinx.coroutines.bom))
+                api(kotlinx.coroutines.core)
+            }
+        }
+
+        // Intermediate source set shared by the two JVM targets (Android + desktop). OkHttp is a
+        // JVM library, so its usage lives here rather than in commonMain. An iOS target would add a
+        // separate `iosMain` actual (e.g. backed by Ktor) without touching this code.
+        val jvmShared by creating {
+            dependsOn(commonMain)
+            dependencies {
+                api(libs.okhttp.core)
+            }
+        }
+
+        getByName("androidMain").dependsOn(jvmShared)
+        getByName("desktopMain").dependsOn(jvmShared)
+    }
+
+    @OptIn(ExperimentalKotlinGradlePluginApi::class)
+    compilerOptions {
+        freeCompilerArgs.add("-opt-in=kotlinx.coroutines.ExperimentalCoroutinesApi")
+    }
+}
+
+android {
+    namespace = "tachiyomi.core.network"
+}

core/network/src/commonMain/kotlin/tachiyomi/core/network/NetworkClient.kt

@@ -0,0 +1,17 @@
+package tachiyomi.core.network
+
+/**
+ * Minimal multiplatform HTTP client abstraction.
+ *
+ * The Android and desktop targets share a single OkHttp-backed implementation (see `jvmShared`).
+ * A future iOS (Kotlin/Native) target would provide its own actual, e.g. backed by Ktor's Darwin
+ * engine, without changing this common API.
+ */
+interface NetworkClient {
+    suspend fun get(url: String, headers: Map<String, String> = emptyMap()): NetworkResponse
+}
+
+/**
+ * Platform entry point that returns the default [NetworkClient] for the current target.
+ */
+expect fun httpClient(): NetworkClient

core/network/src/commonMain/kotlin/tachiyomi/core/network/NetworkResponse.kt

@@ -0,0 +1,11 @@
+package tachiyomi.core.network
+
+/**
+ * Platform-agnostic representation of an HTTP response.
+ */
+data class NetworkResponse(
+    val statusCode: Int,
+    val isSuccessful: Boolean,
+    val body: String,
+    val headers: Map<String, String>,
+)

core/network/src/jvmShared/kotlin/tachiyomi/core/network/OkHttpNetworkClient.kt

@@ -0,0 +1,53 @@
+package tachiyomi.core.network
+
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.suspendCancellableCoroutine
+import okhttp3.Call
+import okhttp3.Callback
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Response
+import java.io.IOException
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+
+/**
+ * OkHttp-backed [NetworkClient] shared by the Android and desktop (JVM) targets.
+ */
+actual fun httpClient(): NetworkClient = OkHttpNetworkClient()
+
+class OkHttpNetworkClient(
+    private val client: OkHttpClient = OkHttpClient(),
+) : NetworkClient {
+
+    override suspend fun get(url: String, headers: Map<String, String>): NetworkResponse {
+        val requestBuilder = Request.Builder().url(url)
+        headers.forEach { (name, value) -> requestBuilder.addHeader(name, value) }
+        val response = client.newCall(requestBuilder.build()).await()
+        return response.use {
+            NetworkResponse(
+                statusCode = it.code,
+                isSuccessful = it.isSuccessful,
+                body = it.body.string(),
+                headers = it.headers.toMultimap().mapValues { (_, values) -> values.joinToString(", ") },
+            )
+        }
+    }
+}
+
+@OptIn(ExperimentalCoroutinesApi::class)
+private suspend fun Call.await(): Response = suspendCancellableCoroutine { continuation ->
+    enqueue(
+        object : Callback {
+            override fun onResponse(call: Call, response: Response) {
+                continuation.resume(response)
+            }
+
+            override fun onFailure(call: Call, e: IOException) {
+                if (continuation.isCancelled) return
+                continuation.resumeWithException(e)
+            }
+        },
+    )
+    continuation.invokeOnCancellation { runCatching { cancel() } }
+}

desktopApp/build.gradle.kts

@@ -52,6 +52,7 @@ dependencies {
     // Shared Kotlin Multiplatform modules that also target Android.
     implementation(projects.i18n)
     implementation(projects.core.preference)
+    implementation(projects.core.network)
 }
 
 application {

desktopApp/src/main/kotlin/app/komikku/desktop/Main.kt

@@ -11,48 +11,60 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.window.Window
 import androidx.compose.ui.window.application
+import kotlinx.coroutines.runBlocking
 import tachiyomi.core.common.preference.DesktopPreferenceStore
 import tachiyomi.core.common.preference.PreferenceStore
+import tachiyomi.core.network.httpClient
 import tachiyomi.i18n.MR
 
 /**
- * Phase 0/1 Kotlin Multiplatform desktop entry point.
+ * Phase 0/1/2 Kotlin Multiplatform desktop entry point.
  *
- * Proves that the Compose Multiplatform desktop toolchain works inside this repo, that a shared KMP
- * module (:i18n) is consumable from desktop, and that the shared `PreferenceStore` abstraction
- * (:core:preference) persists data on desktop via its [DesktopPreferenceStore] implementation.
+ * Demonstrates the cumulative cross-platform foundation:
+ * - Phase 0: Compose Multiplatform desktop toolchain + consuming the shared :i18n module.
+ * - Phase 1: the shared `PreferenceStore` abstraction persisting data on desktop.
+ * - Phase 2: the shared multiplatform `NetworkClient` (OkHttp) performing a real HTTP request.
  */
 fun main() {
-    // Real shared domain plumbing running on desktop: persist + read back a launch counter.
+    // Phase 1: persist + read back a launch counter through the shared PreferenceStore.
     val preferenceStore: PreferenceStore = DesktopPreferenceStore()
     val launchCountPref = preferenceStore.getInt("desktop_launch_count", 0)
     val launchCount = launchCountPref.get() + 1
     launchCountPref.set(launchCount)
 
+    // Phase 2: perform a real HTTP request through the shared multiplatform NetworkClient.
+    val networkStatus = runCatching {
+        runBlocking {
+            val response = httpClient().get("https://example.com")
+            "HTTP ${response.statusCode} (${response.body.length} bytes)"
+        }
+    }.getOrElse { "failed: ${it.message}" }
+
     application {
         Window(
             onCloseRequest = ::exitApplication,
             title = "Komikku Desktop",
         ) {
-            App(launchCount)
+            App(launchCount = launchCount, networkStatus = networkStatus)
         }
     }
 }
 
 @Composable
-fun App(launchCount: Int) {
+fun App(launchCount: Int, networkStatus: String) {
     MaterialTheme {
         Column(
             modifier = Modifier.fillMaxSize(),
             horizontalAlignment = Alignment.CenterHorizontally,
             verticalArrangement = Arrangement.spacedBy(8.dp, Alignment.CenterVertically),
         ) {
-            Text(text = "Komikku — Kotlin Multiplatform desktop (Phase 1)")
-            // Reference the shared :i18n module's generated resources to prove cross-platform
-            // code/resource sharing compiles for the desktop (JVM) target.
+            Text(text = "Komikku — Kotlin Multiplatform desktop (Phase 2)")
+            // Phase 0: shared :i18n module compiled for desktop.
             Text(text = "Shared i18n resources available: ${MR.strings::class.simpleName != null}")
-            // Value persisted through the shared multiplatform PreferenceStore; increments every run.
+            // Phase 1: value persisted through the shared PreferenceStore; increments every run.
             Text(text = "Desktop launches (persisted via shared PreferenceStore): $launchCount")
+            // Phase 2: real network request via the shared OkHttp-backed NetworkClient.
+            Text(text = "Shared NetworkClient GET example.com: $networkStatus")
         }
     }
 }

settings.gradle.kts

@@ -51,6 +51,9 @@ include(":core:common")
 // KMK --> Multiplatform preference abstraction shared with desktop/iOS (Phase 1)
 include(":core:preference")
 // KMK <--
+// KMK --> Multiplatform networking foundation shared with desktop/iOS (Phase 2)
+include(":core:network")
+// KMK <--
 include(":data")
 include(":domain")
 include(":i18n")