update core & broadcast on loaded & stop on load failure

core/src/main/java/com/github/kr328/clash/core/model/General.kt

@@ -8,23 +8,19 @@ import kotlinx.serialization.*
 @Serializable
 data class General(val mode: Mode, val http: Int, val socks: Int, val redirect: Int) : Parcelable {
     @Serializable
-    enum class Mode {
-        DIRECT, GLOBAL, RULE;
+    enum class Mode(val string: String) {
+        DIRECT("Direct"), GLOBAL("Global"), RULE("Rule");
 
         override fun toString(): String {
-            return when (this) {
-                DIRECT -> "Direct"
-                GLOBAL -> "Global"
-                RULE -> "Rule"
-            }
+            return string
         }
 
         companion object {
             fun fromString(mode: String): Mode {
                 return when (mode) {
-                    "Direct" -> DIRECT
-                    "Global" -> GLOBAL
-                    "Rule" -> RULE
+                    DIRECT.string -> DIRECT
+                    GLOBAL.string -> GLOBAL
+                    RULE.string -> RULE
                     else -> throw IllegalArgumentException("Invalid mode $mode")
                 }
             }

core/src/main/java/com/github/kr328/clash/core/model/Proxy.kt

@@ -8,71 +8,49 @@ data class Proxy(
     val type: Type,
     val delay: Long
 ) {
-    enum class Type {
-        SELECT,
-        URL_TEST,
-        FALLBACK,
-        DIRECT,
-        REJECT,
-        SHADOWSOCKS,
-        SNELL,
-        SOCKS5,
-        HTTP,
-        VMESS,
-        LOAD_BALANCE,
-        UNKNOWN;
+    enum class Type(val text: String, val group: Boolean) {
+        DIRECT("Direct", false),
+        REJECT("Reject", false),
+
+        SHADOWSOCKS("Shadowsocks", false),
+        SNELL("Snell", false),
+        SOCKS5("Socks5", false),
+        HTTP("Http", false),
+        VMESS("Vmess", false),
+        TROJAN("Trojan", false),
+
+        RELAY("Relay", true),
+        SELECT("Selector", true),
+        FALLBACK("Fallback", true),
+        URL_TEST("URLTest", true),
+        LOAD_BALANCE("LoadBalance", true),
+
+        UNKNOWN("Unknown", false);
 
         override fun toString(): String {
-            return when (this) {
-                SELECT -> TYPE_SELECT
-                URL_TEST -> TYPE_URL_TEST
-                FALLBACK -> TYPE_FALLBACK
-                DIRECT -> TYPE_DIRECT
-                REJECT -> TYPE_REJECT
-                SHADOWSOCKS -> TYPE_SHADOWSOCKS
-                SNELL -> TYPE_SNELL
-                SOCKS5 -> TYPE_SOCKS5
-                HTTP -> TYPE_HTTP
-                VMESS -> TYPE_VMESS
-                LOAD_BALANCE -> TYPE_LOAD_BALANCE
-                UNKNOWN -> TYPE_UNKNOWN
-            }
+            return text
         }
 
         companion object {
             fun fromString(type: String): Type {
                 return when (type) {
-                    TYPE_SELECT -> SELECT
-                    TYPE_URL_TEST -> URL_TEST
-                    TYPE_FALLBACK -> FALLBACK
-                    TYPE_DIRECT -> DIRECT
-                    TYPE_REJECT -> REJECT
-                    TYPE_SHADOWSOCKS -> SHADOWSOCKS
-                    TYPE_SNELL -> SNELL
-                    TYPE_SOCKS5 -> SOCKS5
-                    TYPE_HTTP -> HTTP
-                    TYPE_VMESS -> VMESS
-                    TYPE_LOAD_BALANCE -> LOAD_BALANCE
-                    TYPE_UNKNOWN -> UNKNOWN
+                    DIRECT.text -> DIRECT
+                    REJECT.text -> REJECT
+                    SHADOWSOCKS.text -> SHADOWSOCKS
+                    SNELL.text -> SNELL
+                    SOCKS5.text -> SOCKS5
+                    HTTP.text -> HTTP
+                    VMESS.text -> VMESS
+                    TROJAN.text -> TROJAN
+                    RELAY.text -> RELAY
+                    SELECT.text -> SELECT
+                    FALLBACK.text -> FALLBACK
+                    URL_TEST.text -> URL_TEST
+                    LOAD_BALANCE.text -> LOAD_BALANCE
+                    UNKNOWN.text -> UNKNOWN
                     else -> UNKNOWN
                 }
             }
         }
     }
-
-    companion object {
-        private const val TYPE_SELECT = "Selector"
-        private const val TYPE_URL_TEST = "URLTest"
-        private const val TYPE_FALLBACK = "Fallback"
-        private const val TYPE_DIRECT = "Direct"
-        private const val TYPE_REJECT = "Reject"
-        private const val TYPE_SHADOWSOCKS = "Shadowsocks"
-        private const val TYPE_SNELL = "Snell"
-        private const val TYPE_SOCKS5 = "Socks5"
-        private const val TYPE_HTTP = "Http"
-        private const val TYPE_VMESS = "Vmess"
-        private const val TYPE_LOAD_BALANCE = "LoadBalance"
-        private const val TYPE_UNKNOWN = "Unknown"
-
-    }
 }

service/src/main/java/com/github/kr328/clash/service/ClashService.kt

@@ -11,6 +11,7 @@ import com.github.kr328.clash.service.clash.module.StaticNotificationModule
 import com.github.kr328.clash.service.settings.ServiceSettings
 import com.github.kr328.clash.service.util.broadcastClashStarted
 import com.github.kr328.clash.service.util.broadcastClashStopped
+import com.github.kr328.clash.service.util.broadcastProfileLoaded
 import kotlinx.coroutines.launch
 
 class ClashService : BaseService() {
@@ -33,6 +34,16 @@ class ClashService : BaseService() {
             val settings = ServiceSettings(service)
 
             runtime.install(ReloadModule(service)) {
+                onLoaded {
+                    if ( it != null ) {
+                        reason = it.message
+
+                        stopSelf()
+                    }
+                    else {
+                        broadcastProfileLoaded()
+                    }
+                }
                 onEmpty {
                     reason = "No profile selected"
 

service/src/main/java/com/github/kr328/clash/service/TunService.kt

@@ -6,10 +6,7 @@ import com.github.kr328.clash.core.Clash
 import com.github.kr328.clash.service.clash.ClashRuntime
 import com.github.kr328.clash.service.clash.module.*
 import com.github.kr328.clash.service.settings.ServiceSettings
-import com.github.kr328.clash.service.util.asSocketAddressText
-import com.github.kr328.clash.service.util.broadcastClashStarted
-import com.github.kr328.clash.service.util.broadcastClashStopped
-import com.github.kr328.clash.service.util.broadcastNetworkChanged
+import com.github.kr328.clash.service.util.*
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.MainScope
 import kotlinx.coroutines.cancel
@@ -50,6 +47,18 @@ class TunService : VpnService(), CoroutineScope by MainScope() {
             val dnsInject = DnsInjectModule()
 
             runtime.install(ReloadModule(service)) {
+                onLoaded {
+                    if ( it != null ) {
+                        reason = it.message
+
+                        stopSelf()
+
+                        TunModule.requestStop()
+                    }
+                    else {
+                        broadcastProfileLoaded()
+                    }
+                }
                 onEmpty {
                     launch {
                         reason = "No selected profile"

service/src/main/java/com/github/kr328/clash/service/clash/module/ReloadModule.kt

@@ -8,12 +8,14 @@ import com.github.kr328.clash.service.data.ClashDatabase
 import com.github.kr328.clash.service.util.resolveBase
 import com.github.kr328.clash.service.util.resolveProfile
 import kotlinx.coroutines.sync.Mutex
+import java.lang.Exception
 
 class ReloadModule(private val context: Context) : Module() {
     override val receiveBroadcasts: Set<String>
         get() = setOf(Intents.INTENT_ACTION_NETWORK_CHANGED, Intents.INTENT_ACTION_PROFILE_CHANGED)
     private val reloadMutex = Mutex()
     private var emptyCallback: () -> Unit = {}
+    private var loadedCallback: (Exception?) -> Unit = {}
 
     override suspend fun onStart() {
         reload()
@@ -36,6 +38,10 @@ class ReloadModule(private val context: Context) : Module() {
         emptyCallback = callback
     }
 
+    fun onLoaded(callback: (Exception?) -> Unit) {
+        loadedCallback = callback
+    }
+
     private suspend fun reload() {
         val database = ClashDatabase.getInstance(context).openClashProfileDao()
 
@@ -46,6 +52,12 @@ class ReloadModule(private val context: Context) : Module() {
             return
         }
 
+        try {
             Clash.loadProfile(resolveProfile(id), resolveBase(id))
+            loadedCallback(null)
+        }
+        catch (e: Exception) {
+            loadedCallback(e)
+        }
     }
 }