refactor: proxy validation and add invalid server cleanup

Author: whalechoi

app/src/main/kotlin/engine/proxy/latency/AndroidProxyLatencyTester.kt

@@ -69,7 +69,6 @@ internal class AndroidProxyLatencyTester(
 
     private fun realConnectionLatency(appState: AppState, server: ProxyServerState): Long {
         return runCatching {
-            server.server.check()
             val resourceFilePaths = appContext.prepareXrayResourceFilePaths()
             appContext.initializeAndroidXrayCoreEnvironment(resourceFilePaths.dataDir)
             val configJson = XraySpeedTestConfigFactory.buildXraySpeedTestConfig(

app/src/main/kotlin/engine/xray/CustomXrayConfigRewriter.kt

@@ -19,7 +19,6 @@ internal object CustomXrayConfigRewriter {
         request: XrayConfigRequest,
         server: Custom,
     ): JsonObject {
-        server.check()
         val config = parseCustomXrayConfigJsonObject(server.configJson)
         return if (server.overrideAsteriskInboundAndDns) {
             config.overwriteAsteriskInboundDns(request, server)

app/src/main/kotlin/engine/xray/XrayOutboundPlanner.kt

@@ -69,7 +69,6 @@ private class XrayOutboundPlanner(
     }
 
     private fun addCustomDnsHosts(proxyServer: Custom) {
-        proxyServer.check()
         if (proxyServer.overrideAsteriskInboundAndDns) {
             dnsHostServers += customXrayConfigProxyServerHosts(proxyServer.configJson)
         }
@@ -82,7 +81,6 @@ private class XrayOutboundPlanner(
         allowFragment: Boolean = true,
     ) {
         if (tag in addedOutboundTags) return
-        server.server.check()
         proxyOutbounds += XrayProxyOutboundServer(
             tag = tag,
             server = server.server,
@@ -95,7 +93,6 @@ private class XrayOutboundPlanner(
     }
 
     private fun addStrategyGroup(tag: String, strategyGroup: StrategyGroup) {
-        strategyGroup.check()
         val members = appState.strategyGroupMembers(strategyGroup)
         if (members.isEmpty()) {
             error("Strategy group '${strategyGroup.remarks}' has no available proxy servers")
@@ -120,7 +117,6 @@ private class XrayOutboundPlanner(
     }
 
     private fun addChainProxy(tag: String, chainProxy: ChainProxy) {
-        chainProxy.check()
         val members = appState.chainProxyMembers(chainProxy)
         if (members.size < 2) {
             error("Proxy chain '${chainProxy.remarks}' requires at least two available proxy servers")
@@ -165,7 +161,6 @@ private fun AppState.strategyGroupMembers(strategyGroup: StrategyGroup): List<Pr
                 regex?.containsMatchIn(server.server.getInfo().remarks) == true ||
                 (regex == null && server.server.getInfo().remarks.contains(filter))
         }
-        .filter { server -> runCatching { server.server.check() }.isSuccess }
         .toList()
 }
 

app/src/main/kotlin/features/proxy/server/editor/ProxyServerPage.kt

@@ -450,6 +450,7 @@ private fun proxyServerListToolMenuEntries() = listOf(
     ProxyServerListToolMenuEntry(stringResource(R.string.proxy_server_list_update_subscriptions), ProxyServerListToolAction.UpdateSubscriptions),
     ProxyServerListToolMenuEntry(stringResource(R.string.proxy_server_list_copy_all_urls), ProxyServerListToolAction.CopyAllUrls),
     ProxyServerListToolMenuEntry(stringResource(R.string.proxy_server_list_delete_duplicates), ProxyServerListToolAction.DeleteDuplicateServers),
+    ProxyServerListToolMenuEntry(stringResource(R.string.proxy_server_list_delete_invalid), ProxyServerListToolAction.DeleteInvalidServers),
 ).map { entry ->
     IconDropdownMenuEntry(
         key = entry.action,

app/src/main/kotlin/features/proxy/server/list/ProxyServerListComponents.kt

@@ -28,8 +28,11 @@ internal data class ProxyServerListMessages(
     val importResultTemplate: String,
     val copied: String,
     val unsupported: String,
+    val configInvalid: String,
     val duplicatesDeletedTemplate: String,
     val noDuplicates: String,
+    val invalidServersDeletedTemplate: String,
+    val noInvalidServers: String,
 )
 
 @Composable
@@ -56,7 +59,10 @@ internal fun proxyServerListMessages(): ProxyServerListMessages {
         importResultTemplate = stringResource(R.string.proxy_server_list_import_result),
         copied = stringResource(R.string.common_copied),
         unsupported = stringResource(R.string.common_unsupported),
+        configInvalid = stringResource(R.string.proxy_server_config_invalid),
         duplicatesDeletedTemplate = stringResource(R.string.proxy_server_list_duplicates_deleted),
         noDuplicates = stringResource(R.string.proxy_server_list_no_duplicates),
+        invalidServersDeletedTemplate = stringResource(R.string.proxy_server_list_invalid_deleted),
+        noInvalidServers = stringResource(R.string.proxy_server_list_no_invalid),
     )
 }

app/src/main/kotlin/features/proxy/server/list/ProxyServerListMessages.kt

@@ -28,6 +28,7 @@ internal enum class ProxyServerListToolAction {
     UpdateSubscriptions,
     CopyAllUrls,
     DeleteDuplicateServers,
+    DeleteInvalidServers,
 }
 
 internal data class ProxyServerListMenuEntry(

app/src/main/kotlin/features/proxy/server/list/ProxyServerListModels.kt

@@ -30,7 +30,9 @@ import app.collectProxyServerLatency
 import app.navigation.Navigator
 import app.navigation.Route
 import data.AndroidAppStateStore
-import features.proxy.server.usecase.proxyServerCopyTextOrNull
+import features.proxy.server.validation.rememberProxyServerValidationMessageResolver
+import features.proxy.server.usecase.ProxyServerCopyTextResult
+import features.proxy.server.usecase.proxyServerCopyText
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
 import sh.calvin.reorderable.ReorderableItem
@@ -210,6 +212,7 @@ private fun ProxyServerListItem(
         serverId = server.id,
         initialLatency = server.latency,
     ).value
+    val validationMessageOf = rememberProxyServerValidationMessageResolver()
 
     ProxyServerListItemCard(
         latency = latency,
@@ -235,15 +238,29 @@ private fun ProxyServerListItem(
         },
         onShare = {
             scope.launch {
-                val copyText = server.proxyServerCopyTextOrNull(
-                    context = context,
-                    appState = stateStore.state.value,
-                )
-                if (copyText == null) {
-                    tipNotifier.show(messages.unsupported)
-                } else {
-                    clipboard.setPlainText(copyText)
-                    tipNotifier.show(messages.copied)
+                val basicIssues = server.server.validateBasic()
+                if (basicIssues.isNotEmpty()) {
+                    tipNotifier.show(validationMessageOf(basicIssues.first()))
+                    return@launch
+                }
+                when (
+                    val result = server.proxyServerCopyText(
+                        context = context,
+                        appState = stateStore.state.value,
+                    )
+                ) {
+                    is ProxyServerCopyTextResult.Success -> {
+                        clipboard.setPlainText(result.text)
+                        tipNotifier.show(messages.copied)
+                    }
+
+                    ProxyServerCopyTextResult.Unsupported -> {
+                        tipNotifier.show(messages.unsupported)
+                    }
+
+                    ProxyServerCopyTextResult.InvalidConfig -> {
+                        tipNotifier.show(messages.configInvalid)
+                    }
                 }
             }
         },

app/src/main/kotlin/features/proxy/server/list/ProxyServerListPager.kt

@@ -24,9 +24,11 @@ import features.proxy.server.usecase.ProxyServerImportFileUseCase
 import features.proxy.server.usecase.ProxyServerImportSource
 import features.proxy.server.usecase.createProxyServer
 import features.proxy.server.usecase.deleteDuplicateServersInGroup
+import features.proxy.server.usecase.deleteInvalidServersInGroup
 import features.proxy.server.usecase.importProxyServersFromText
 import features.proxy.server.usecase.sortedInGroupByLatencyResult
 import features.proxy.server.usecase.updatableSubscriptionGroups
+import features.proxy.server.usecase.withDeletedProxyServers
 import features.proxy.server.usecase.withImportedProxyServers
 import features.proxy.server.usecase.withUpdatedSubscriptionServers
 import features.subscription.DefaultSubscriptionGroupId
@@ -430,6 +432,20 @@ private fun handleProxyServerListToolAction(
                 messages = messages,
             )
         }
+
+        ProxyServerListToolAction.DeleteInvalidServers -> {
+            deleteInvalidServers(
+                servers = groupState.currentGroupServers,
+                stateStore = stateStore,
+                updateAppState = updateAppState,
+                proxyServiceUseCase = proxyServiceUseCase,
+                tipNotifier = tipNotifier,
+                scope = scope,
+                messages = messages,
+                serviceOperationInProgress = serviceOperationInProgress,
+                runProxyServiceOperation = runProxyServiceOperation,
+            )
+        }
     }
 }
 
@@ -540,18 +556,86 @@ private fun copyCurrentGroupUrls(
     messages: ProxyServerListMessages,
 ) {
     scope.launch {
-        val urls = servers
-            .mapNotNull { server -> runCatching { server.server.getUrlOrNull() }.getOrNull() }
+        var invalidCount = 0
+        val urls = servers.mapNotNull { server ->
+            if (server.server.validateBasic().isNotEmpty()) {
+                invalidCount++
+                return@mapNotNull null
+            }
+            runCatching { server.server.getUrlOrNull() }.fold(
+                onSuccess = { url -> url },
+                onFailure = {
+                    invalidCount++
+                    null
+                },
+            )
+        }
             .joinToString("\n")
         if (urls.isBlank()) {
-            tipNotifier.show(messages.unsupported)
+            tipNotifier.show(if (invalidCount > 0) messages.configInvalid else messages.unsupported)
         } else {
             clipboard.setPlainText(urls)
             tipNotifier.show(messages.copied)
         }
     }
 }
 
+private fun deleteInvalidServers(
+    servers: List<ProxyServerState>,
+    stateStore: AndroidAppStateStore,
+    updateAppState: ((AppState) -> AppState) -> Unit,
+    proxyServiceUseCase: ProxyServiceUseCase,
+    tipNotifier: AndroidToastTipNotifier,
+    scope: CoroutineScope,
+    messages: ProxyServerListMessages,
+    serviceOperationInProgress: Boolean,
+    runProxyServiceOperation: (suspend () -> Unit) -> Unit,
+) {
+    val currentGroupServerIds = servers.map { server -> server.id }.toSet()
+    val stateSnapshot = stateStore.state.value
+    val previewResult = stateSnapshot.proxyServers.deleteInvalidServersInGroup(currentGroupServerIds)
+    if (previewResult.removedCount == 0) {
+        scope.launch { tipNotifier.show(messages.noInvalidServers) }
+        return
+    }
+
+    fun applyDeleteAndNotify() {
+        var removedCount = 0
+        updateAppState { state ->
+            val result = state.proxyServers.deleteInvalidServersInGroup(currentGroupServerIds)
+            removedCount = result.removedCount
+            state.withDeletedProxyServers(result.removedServerIds)
+        }
+        scope.launch {
+            tipNotifier.show(
+                if (removedCount > 0) {
+                    messages.invalidServersDeletedTemplate.formatTemplate("count" to removedCount)
+                } else {
+                    messages.noInvalidServers
+                },
+            )
+        }
+    }
+
+    val selectedServerWillBeDeleted = stateSnapshot.selectedProxyServerId in previewResult.removedServerIds
+    if (!stateSnapshot.proxyRunning || !selectedServerWillBeDeleted) {
+        applyDeleteAndNotify()
+        return
+    }
+    if (serviceOperationInProgress) return
+
+    runProxyServiceOperation {
+        when (val stopResult = proxyServiceUseCase.stop(stateStore.state.value.runMode)) {
+            is ProxyServiceResult.Success -> applyDeleteAndNotify()
+            ProxyServiceResult.MissingServer -> applyDeleteAndNotify()
+            is ProxyServiceResult.Failed -> {
+                updateAppState { state -> state.copy(proxyRunning = false) }
+                tipNotifier.showError(stopResult.error, messages.serviceStopped)
+            }
+        }
+    }
+}
+
 private fun deleteDuplicateServers(
     servers: List<ProxyServerState>,
     updateAppState: ((AppState) -> AppState) -> Unit,

app/src/main/kotlin/features/proxy/server/list/ProxyServerListTopBar.kt

@@ -26,10 +26,12 @@ data class ChainProxy(
         proxyServerIds = other.proxyServerIds
     }
 
-    override fun check() {
+    override fun validateBasic(): List<ProxyServerValidationIssue> = validateFull()
+
+    override fun validateFull(): List<ProxyServerValidationIssue> = buildList {
         validateRemarks(remarks)
         if (proxyServerIds.size < 2) {
-            proxyValidationError(ProxyServerValidationError.ChainProxyMemberCountInvalid)
+            addIssue(ProxyServerValidationError.ChainProxyMemberCountInvalid)
         }
     }
 }