feat(network): Refactor ProxyConfig to a sealed class and add system proxy support

rainxchzed · rainxchzed · commit c033c87d8d63 · 2026-02-25T20:34:24.000+05:00
This commit refines the proxy configuration model and enhances how the application handles network proxies across Android and JVM platforms. The previous `ProxyConfig` data class has been replaced with a sealed class hierarchy to explicitly support "None", "System", "HTTP", and "SOCKS" configurations.

- **feat(domain)**: Refactored `ProxyConfig` into a sealed class with `None`, `System`, `Http`, and `Socks` subtypes.
- **feat(data)**: Added support for automatic system proxy detection in `HttpClientFactory` for both Android (using `ProxySelector`) and JVM (via `java.net.ProxySelector`).
- **feat(data)**: Improved `ProxyManager` with dedicated methods for setting different proxy types (`setNoProxy`, `setSystemProxy`, `setHttpProxy`, `setSocksProxy`).
- **refactor(data)**: Updated `GitHubClientProvider` to use a more robust thread-safe mechanism (using `Mutex`) for recreating the `HttpClient` when proxy settings change.
- **fix(android)**: Added support for SOCKS proxy authentication on Android using `java.net.Authenticator`.
- **fix(jvm)**: Implemented manual system proxy resolution in the CIO engine by selecting the appropriate proxy for GitHub API URIs.
diff --git a/core/data/src/androidMain/kotlin/zed/rainxch/core/data/network/HttpClientFactory.android.kt b/core/data/src/androidMain/kotlin/zed/rainxch/core/data/network/HttpClientFactory.android.kt
@@ -6,32 +6,67 @@ import java.net.InetSocketAddress
 import java.net.Proxy
 import okhttp3.Credentials
 import zed.rainxch.core.domain.model.ProxyConfig
+import java.net.PasswordAuthentication
+import java.net.ProxySelector
 
-actual fun createPlatformHttpClient(proxyConfig: ProxyConfig?): HttpClient {
+actual fun createPlatformHttpClient(proxyConfig: ProxyConfig): HttpClient {
     return HttpClient(OkHttp) {
         engine {
-            proxyConfig?.let { config ->
-                val javaProxyType = when (config.type) {
-                    ProxyConfig.ProxyType.HTTP -> Proxy.Type.HTTP
-                    ProxyConfig.ProxyType.SOCKS -> Proxy.Type.SOCKS
+            when (proxyConfig) {
+                is ProxyConfig.None -> {
+                    proxy = Proxy.NO_PROXY
                 }
-                proxy = Proxy(javaProxyType, InetSocketAddress(config.host, config.port))
 
-                if (config.username != null) {
+                is ProxyConfig.System -> {
                     config {
-                        proxyAuthenticator { _, response ->
-                            response.request.newBuilder()
-                                .header(
-                                    "Proxy-Authorization",
-                                    Credentials.basic(
-                                        config.username!!,
-                                        config.password.orEmpty()
+                        proxySelector(ProxySelector.getDefault())
+                    }
+                }
+
+                is ProxyConfig.Http -> {
+                    proxy = Proxy(
+                        Proxy.Type.HTTP,
+                        InetSocketAddress(proxyConfig.host, proxyConfig.port)
+                    )
+                    if (proxyConfig.username != null) {
+                        config {
+                            proxyAuthenticator { _, response ->
+                                response.request.newBuilder()
+                                    .header(
+                                        "Proxy-Authorization",
+                                        Credentials.basic(
+                                            proxyConfig.username!!,
+                                            proxyConfig.password.orEmpty()
+                                        )
                                     )
-                                )
-                                .build()
+                                    .build()
+                            }
                         }
                     }
                 }
+
+                is ProxyConfig.Socks -> {
+                    proxy = Proxy(
+                        Proxy.Type.SOCKS,
+                        InetSocketAddress(proxyConfig.host, proxyConfig.port)
+                    )
+
+                    if (proxyConfig.username != null) {
+                        java.net.Authenticator.setDefault(object : java.net.Authenticator() {
+                            override fun getPasswordAuthentication(): PasswordAuthentication? {
+                                if (requestingHost == proxyConfig.host &&
+                                    requestingPort == proxyConfig.port
+                                ) {
+                                    return PasswordAuthentication(
+                                        proxyConfig.username,
+                                        proxyConfig.password.orEmpty().toCharArray()
+                                    )
+                                }
+                                return null
+                            }
+                        })
+                    }
+                }
             }
         }
     }
diff --git a/core/data/src/commonMain/kotlin/zed/rainxch/core/data/network/GitHubClientProvider.kt b/core/data/src/commonMain/kotlin/zed/rainxch/core/data/network/GitHubClientProvider.kt
@@ -4,50 +4,57 @@ import io.ktor.client.HttpClient
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 import zed.rainxch.core.data.data_source.TokenStore
 import zed.rainxch.core.domain.model.ProxyConfig
 import zed.rainxch.core.domain.repository.RateLimitRepository
 
 class GitHubClientProvider(
     private val tokenStore: TokenStore,
     private val rateLimitRepository: RateLimitRepository,
-    proxyConfigFlow: Flow<ProxyConfig?>
+    proxyConfigFlow: StateFlow<ProxyConfig>
 ) {
-    private val _client = MutableStateFlow<HttpClient?>(null)
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+    private var currentClient: HttpClient? = null
+    private val mutex = Mutex()
 
-    val client: Flow<HttpClient> = proxyConfigFlow
-        .distinctUntilChanged()
+    private val _client: StateFlow<HttpClient> = proxyConfigFlow
         .map { proxyConfig ->
-            _client.value?.close()
-
-            val newClient = createGitHubHttpClient(
-                tokenStore = tokenStore,
-                rateLimitRepository = rateLimitRepository,
-                proxyConfig = proxyConfig
-            )
-            _client.value = newClient
-            newClient
+            mutex.withLock {
+                currentClient?.close()
+                val newClient = createGitHubHttpClient(
+                    tokenStore = tokenStore,
+                    rateLimitRepository = rateLimitRepository,
+                    proxyConfig = proxyConfig
+                )
+                currentClient = newClient
+                newClient
+            }
         }
         .stateIn(
-            scope = CoroutineScope(SupervisorJob() + Dispatchers.Default),
-            started = SharingStarted.Lazily,
-            initialValue = createGitHubHttpClient(tokenStore, rateLimitRepository)
+            scope = scope,
+            started = SharingStarted.Eagerly,
+            initialValue = createGitHubHttpClient(
+                tokenStore = tokenStore,
+                rateLimitRepository = rateLimitRepository,
+                proxyConfig = proxyConfigFlow.value
+            ).also { currentClient = it }
         )
 
-    fun currentClient(): HttpClient {
-        return _client.value
-            ?: createGitHubHttpClient(tokenStore, rateLimitRepository).also {
-                _client.value = it
-            }
-    }
+    /** Get the current HttpClient (always up to date with proxy settings) */
+    val client: HttpClient get() = _client.value
 
     fun close() {
-        _client.value?.close()
+        currentClient?.close()
+        scope.cancel()
     }
 }
diff --git a/core/data/src/commonMain/kotlin/zed/rainxch/core/data/network/HttpClientFactory.kt b/core/data/src/commonMain/kotlin/zed/rainxch/core/data/network/HttpClientFactory.kt
@@ -19,20 +19,19 @@ import zed.rainxch.core.domain.repository.RateLimitRepository
 import java.io.IOException
 import kotlin.coroutines.cancellation.CancellationException
 
-expect fun createPlatformHttpClient(proxyConfig: ProxyConfig? = null): HttpClient
+expect fun createPlatformHttpClient(proxyConfig: ProxyConfig): HttpClient
 
 fun createGitHubHttpClient(
     tokenStore: TokenStore,
     rateLimitRepository: RateLimitRepository,
-    proxyConfig: ProxyConfig? = null
+    proxyConfig: ProxyConfig = ProxyConfig.None
 ): HttpClient {
     val json = Json {
         ignoreUnknownKeys = true
         isLenient = true
     }
 
     return createPlatformHttpClient(proxyConfig).config {
-
         install(RateLimitInterceptor) {
             this.rateLimitRepository = rateLimitRepository
         }
diff --git a/core/data/src/commonMain/kotlin/zed/rainxch/core/data/network/ProxyManager.kt b/core/data/src/commonMain/kotlin/zed/rainxch/core/data/network/ProxyManager.kt
@@ -1,17 +1,37 @@
 package zed.rainxch.core.data.network
 
 import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.update
 import zed.rainxch.core.domain.model.ProxyConfig
 
 object ProxyManager {
-    private val _proxyConfig = MutableStateFlow<ProxyConfig?>(null)
-    val currentProxyConfig = _proxyConfig.asStateFlow()
+    private val _proxyConfig = MutableStateFlow<ProxyConfig>(ProxyConfig.None)
+    val currentProxyConfig: StateFlow<ProxyConfig> = _proxyConfig.asStateFlow()
 
-    fun setProxyConfig(
-        config: ProxyConfig?
+    fun setNoProxy() {
+        _proxyConfig.value = ProxyConfig.None
+    }
+
+    fun setSystemProxy() {
+        _proxyConfig.value = ProxyConfig.System
+    }
+
+    fun setHttpProxy(
+        host: String,
+        port: Int,
+        username: String? = null,
+        password: String? = null
+    ) {
+        _proxyConfig.value = ProxyConfig.Http(host, port, username, password)
+    }
+
+    fun setSocksProxy(
+        host: String,
+        port: Int,
+        username: String? = null,
+        password: String? = null
     ) {
-        _proxyConfig.update { config }
+        _proxyConfig.value = ProxyConfig.Socks(host, port, username, password)
     }
 }
diff --git a/core/data/src/jvmMain/kotlin/zed/rainxch/core/data/network/HttpClientFactory.jvm.kt b/core/data/src/jvmMain/kotlin/zed/rainxch/core/data/network/HttpClientFactory.jvm.kt
@@ -5,18 +5,40 @@ import io.ktor.client.engine.ProxyBuilder
 import io.ktor.client.engine.cio.CIO
 import io.ktor.http.Url
 import zed.rainxch.core.domain.model.ProxyConfig
+import java.net.ProxySelector
+import java.net.URI
 
-actual fun createPlatformHttpClient(proxyConfig: ProxyConfig?): HttpClient {
+actual fun createPlatformHttpClient(proxyConfig: ProxyConfig): HttpClient {
     return HttpClient(CIO) {
         engine {
-            proxy = proxyConfig?.let { config ->
-                when (config.type) {
-                    ProxyConfig.ProxyType.HTTP -> ProxyBuilder.http(
-                        Url("http://${config.host}:${config.port}")
-                    )
-                    ProxyConfig.ProxyType.SOCKS -> ProxyBuilder.socks(
-                        config.host, config.port
-                    )
+            proxy = when (proxyConfig) {
+                is ProxyConfig.None -> null
+
+                is ProxyConfig.System -> {
+                    val systemProxy = ProxySelector.getDefault()
+                        ?.select(URI("https://api.github.com"))
+                        ?.firstOrNull { it.type() != java.net.Proxy.Type.DIRECT }
+
+                    if (systemProxy != null) {
+                        val addr = systemProxy.address() as? java.net.InetSocketAddress
+                        if (addr != null) {
+                            when (systemProxy.type()) {
+                                java.net.Proxy.Type.HTTP ->
+                                    ProxyBuilder.http(Url("http://${addr.hostString}:${addr.port}"))
+                                java.net.Proxy.Type.SOCKS ->
+                                    ProxyBuilder.socks(addr.hostString, addr.port)
+                                else -> null
+                            }
+                        } else null
+                    } else null
+                }
+
+                is ProxyConfig.Http -> {
+                    ProxyBuilder.http(Url("http://${proxyConfig.host}:${proxyConfig.port}"))
+                }
+
+                is ProxyConfig.Socks -> {
+                    ProxyBuilder.socks(proxyConfig.host, proxyConfig.port)
                 }
             }
         }
diff --git a/core/domain/src/commonMain/kotlin/zed/rainxch/core/domain/model/ProxyConfig.kt b/core/domain/src/commonMain/kotlin/zed/rainxch/core/domain/model/ProxyConfig.kt
@@ -1,11 +1,21 @@
 package zed.rainxch.core.domain.model
 
-data class ProxyConfig(
-    val type: ProxyType,
-    val host: String,
-    val port: Int,
-    val username: String? = null,
-    val password: String? = null,
-) {
-    enum class ProxyType { HTTP, SOCKS }
+sealed class ProxyConfig {
+    data object None : ProxyConfig()
+
+    data object System : ProxyConfig()
+
+    data class Http(
+        val host: String,
+        val port: Int,
+        val username: String? = null,
+        val password: String? = null,
+    ) : ProxyConfig()
+
+    data class Socks(
+        val host: String,
+        val port: Int,
+        val username: String? = null,
+        val password: String? = null,
+    ) : ProxyConfig()
 }
