up 2.1.7

https://github.com/2dust/v2rayNG/issues/5623

V2rayNG/app/build.gradle.kts

@@ -12,8 +12,8 @@ android {
         applicationId = "com.v2ray.ang"
         minSdk = 24
         targetSdk = 36
-        versionCode = 725
-        versionName = "2.1.5"
+        versionCode = 727
+        versionName = "2.1.7"
         multiDexEnabled = true
 
         val abiFilterList = (properties["ABI_FILTERS"] as? String)?.split(';')

V2rayNG/app/src/main/java/com/v2ray/ang/core/CoreConfigContextBuilder.kt

@@ -97,8 +97,7 @@ object CoreConfigContextBuilder {
                 .filter { it.configType != EConfigType.POLICYGROUP }
                 .filter { it.configType != EConfigType.PROXYCHAIN }
                 .toList()
-        }
-        catch (e: Exception) {
+        } catch (e: Exception) {
             LogUtil.e(AppConfig.TAG, "Failed to resolve policy group profiles for config '${config.remarks}'", e)
             return listOf(config)
         }
@@ -120,8 +119,8 @@ object CoreConfigContextBuilder {
                 .filter { it.configType != EConfigType.POLICYGROUP }
                 .filter { it.configType != EConfigType.PROXYCHAIN }
                 .toList()
-        }
-        catch (e: Exception) {
+                .reversed()
+        } catch (e: Exception) {
             LogUtil.e(AppConfig.TAG, "Failed to resolve proxy chain profiles for config '${config.remarks}'", e)
             return listOf(config)
         }

V2rayNG/app/src/main/java/com/v2ray/ang/core/CoreNativeManager.kt

@@ -43,6 +43,15 @@ object CoreNativeManager {
         }
     }
 
+    fun reconcileBrowserDialer(dialerAddr: String) {
+        try {
+            Libv2ray.reconcileBrowserDialer(dialerAddr)
+            LogUtil.i(AppConfig.TAG, "Browser dialer reconciled successfully with address: $dialerAddr")
+        } catch (e: Exception) {
+            LogUtil.e(AppConfig.TAG, "Failed to reconcile browser dialer with address: $dialerAddr", e)
+        }
+    }
+
 
     /**
      * Get V2Ray core version.

V2rayNG/app/src/main/java/com/v2ray/ang/core/CoreOutboundBuilder.kt

@@ -1,6 +1,5 @@
 package com.v2ray.ang.core
 
-import android.text.TextUtils
 import com.google.gson.JsonArray
 import com.google.gson.JsonObject
 import com.v2ray.ang.AppConfig
@@ -73,41 +72,6 @@ object CoreOutboundBuilder {
                 outbound.mux?.concurrency = -1
             }
 
-            if (protocol.equals(EConfigType.WIREGUARD.name, true)) {
-                var localTunAddr = if (outbound.settings?.address == null) {
-                    listOf(AppConfig.WIREGUARD_LOCAL_ADDRESS_V4)
-                } else {
-                    outbound.settings?.address as List<*>
-                }
-                if (MmkvManager.decodeSettingsBool(AppConfig.PREF_IPV6_ENABLED) != true) {
-                    localTunAddr = listOf(localTunAddr.first())
-                }
-                outbound.settings?.address = localTunAddr
-            }
-
-            if (outbound.streamSettings?.network == AppConfig.DEFAULT_NETWORK
-                && outbound.streamSettings?.tcpSettings?.header?.type == AppConfig.HEADER_TYPE_HTTP
-            ) {
-                val path = outbound.streamSettings?.tcpSettings?.header?.request?.path
-                val host = outbound.streamSettings?.tcpSettings?.header?.request?.headers?.Host
-
-                val requestString: String by lazy {
-                    """{"version":"1.1","method":"GET","headers":{"User-Agent":["Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.6478.122 Mobile Safari/537.36"],"Accept-Encoding":["gzip, deflate"],"Connection":["keep-alive"],"Pragma":["no-cache"]}}"""
-                }
-                outbound.streamSettings?.tcpSettings?.header?.request = JsonUtil.fromJson(
-                    requestString,
-                    OutboundBean.StreamSettingsBean.TcpSettingsBean.HeaderBean.RequestBean::class.java
-                )
-                outbound.streamSettings?.tcpSettings?.header?.request?.path =
-                    if (path.isNullOrEmpty()) {
-                        listOf("/")
-                    } else {
-                        path
-                    }
-                outbound.streamSettings?.tcpSettings?.header?.request?.headers?.Host = host
-            }
-
-
         } catch (e: Exception) {
             LogUtil.e(AppConfig.TAG, "Failed to update outbound with global settings", e)
             return false
@@ -291,9 +255,23 @@ object CoreOutboundBuilder {
     private fun toOutboundWireguard(profileItem: ProfileItem): OutboundBean? {
         val outboundBean = createInitOutbound(EConfigType.WIREGUARD)
 
+        val rawAddresses = profileItem.localAddress
+            ?.split(",")
+            ?.map { it.trim() }
+            ?.filter { it.isNotEmpty() }
+            ?.ifEmpty { null }
+            ?: listOf(AppConfig.WIREGUARD_LOCAL_ADDRESS_V4)
+
+        val addresses = if (MmkvManager.decodeSettingsBool(AppConfig.PREF_IPV6_ENABLED) == true) {
+            rawAddresses
+        } else {
+            val ipv4Addresses = rawAddresses.filter { !it.contains(":") }
+            ipv4Addresses.ifEmpty { listOf(AppConfig.WIREGUARD_LOCAL_ADDRESS_V4) }
+        }
+
         outboundBean?.settings?.let { wireguard ->
             wireguard.secretKey = profileItem.secretKey
-            wireguard.address = (profileItem.localAddress ?: AppConfig.WIREGUARD_LOCAL_ADDRESS_V4).split(",")
+            wireguard.address = addresses
             wireguard.peers?.firstOrNull()?.let { peer ->
                 peer.publicKey = profileItem.publicKey.orEmpty()
                 peer.preSharedKey = profileItem.preSharedKey?.nullIfBlank()
@@ -328,6 +306,23 @@ object CoreOutboundBuilder {
         return outboundBean
     }
 
+    private fun createTcpHttpRequest(
+        host: String?,
+        path: String?
+    ): OutboundBean.StreamSettingsBean.TcpSettingsBean.HeaderBean.RequestBean {
+        val requestString =
+            """{"version":"1.1","method":"GET","headers":{"User-Agent":["Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.6478.122 Mobile Safari/537.36"],"Accept-Encoding":["gzip, deflate"],"Connection":["keep-alive"],"Pragma":"no-cache"}}"""
+        val request = JsonUtil.fromJson(
+            requestString,
+            OutboundBean.StreamSettingsBean.TcpSettingsBean.HeaderBean.RequestBean::class.java
+        ) ?: OutboundBean.StreamSettingsBean.TcpSettingsBean.HeaderBean.RequestBean()
+
+        val parsedHost = host.orEmpty().split(",").map { it.trim() }.filter { it.isNotEmpty() }
+        request.headers.Host = parsedHost.ifEmpty { null }
+        request.path = path.orEmpty().split(",").map { it.trim() }.filter { it.isNotEmpty() }.ifEmpty { listOf("/") }
+        return request
+    }
+
     /**
      * Configures transport settings for an outbound connection.
      *
@@ -358,13 +353,9 @@ object CoreOutboundBuilder {
                 val tcpSetting = OutboundBean.StreamSettingsBean.TcpSettingsBean()
                 if (headerType == AppConfig.HEADER_TYPE_HTTP) {
                     tcpSetting.header.type = AppConfig.HEADER_TYPE_HTTP
-                    if (!TextUtils.isEmpty(host) || !TextUtils.isEmpty(path)) {
-                        val requestObj = OutboundBean.StreamSettingsBean.TcpSettingsBean.HeaderBean.RequestBean()
-                        requestObj.headers.Host = host.orEmpty().split(",").map { it.trim() }.filter { it.isNotEmpty() }
-                        requestObj.path = path.orEmpty().split(",").map { it.trim() }.filter { it.isNotEmpty() }
-                        tcpSetting.header.request = requestObj
-                        sni = requestObj.headers.Host?.getOrNull(0)
-                    }
+                    val requestObj = createTcpHttpRequest(host, path)
+                    tcpSetting.header.request = requestObj
+                    sni = requestObj.headers.Host?.getOrNull(0)
                 } else {
                     tcpSetting.header.type = "none"
                     sni = host

V2rayNG/app/src/main/java/com/v2ray/ang/core/CoreServiceManager.kt

@@ -22,6 +22,9 @@ import com.v2ray.ang.handler.SettingsManager
 import com.v2ray.ang.handler.SpeedtestManager
 import com.v2ray.ang.service.CoreProxyOnlyService
 import com.v2ray.ang.service.CoreVpnService
+import com.v2ray.ang.service.DialerNativeService
+import com.v2ray.ang.service.DialerWebviewService
+import com.v2ray.ang.service.IDialerService
 import com.v2ray.ang.util.LogUtil
 import com.v2ray.ang.util.MessageUtil
 import com.v2ray.ang.util.Utils
@@ -40,6 +43,7 @@ object CoreServiceManager {
     private val mMsgReceive = ReceiveMessageHandler()
     private var currentConfig: ProfileItem? = null
     private var processFinder: XrayProcessFinder? = null
+    private var browserDialer: IDialerService? = null
 
     var serviceControl: SoftReference<ServiceControl>? = null
         set(value) {
@@ -62,7 +66,13 @@ object CoreServiceManager {
             context.toast(R.string.app_tile_first_use)
             return false
         }
-        startContextService(context)
+        try {
+            startContextService(context)
+        } catch (e: Exception) {
+            LogUtil.e(AppConfig.TAG, "StartCore-Manager: ${e.message}", e)
+            context.toast(e.message ?: e.javaClass.simpleName)
+            return false
+        }
         return true
     }
 
@@ -78,7 +88,12 @@ object CoreServiceManager {
             MmkvManager.setSelectServer(guid)
         }
 
-        startContextService(context)
+        try {
+            startContextService(context)
+        } catch (e: Exception) {
+            LogUtil.e(AppConfig.TAG, "StartCore-Manager: ${e.message}", e)
+            context.toast(e.message ?: e.javaClass.simpleName)
+        }
     }
 
     /**
@@ -106,7 +121,11 @@ object CoreServiceManager {
      * Starts the context service for V2Ray.
      * Chooses between VPN service or Proxy-only service based on user settings.
      * @param context The context from which the service is started.
+     * @throws IllegalStateException if the core is already running, no server is selected,
+     *   server config cannot be decoded, or server configuration is invalid.
+     * @throws Exception if the foreground service fails to start.
      */
+    @Throws(Exception::class)
     private fun startContextService(context: Context) {
         if (coreController.isRunning) {
             LogUtil.w(AppConfig.TAG, "StartCore-Manager: Core already running")
@@ -114,16 +133,16 @@ object CoreServiceManager {
         }
 
         val guid = MmkvManager.getSelectServer()
-        if (guid == null) {
-            LogUtil.e(AppConfig.TAG, "StartCore-Manager: No server selected")
-            return
-        }
+            ?: run {
+                LogUtil.e(AppConfig.TAG, "StartCore-Manager: No server selected")
+                error(context.getString(R.string.app_tile_first_use))
+            }
 
         val config = MmkvManager.decodeServerConfig(guid)
-        if (config == null) {
-            LogUtil.e(AppConfig.TAG, "StartCore-Manager: Failed to decode server config")
-            return
-        }
+            ?: run {
+                LogUtil.e(AppConfig.TAG, "StartCore-Manager: Failed to decode server config")
+                error(context.getString(R.string.toast_config_file_invalid))
+            }
 
         if (config.configType != EConfigType.CUSTOM
             && config.configType != EConfigType.POLICYGROUP
@@ -132,13 +151,14 @@ object CoreServiceManager {
             && !Utils.isPureIpAddress(config.server.orEmpty())
         ) {
             LogUtil.e(AppConfig.TAG, "StartCore-Manager: Invalid server configuration")
-            return
+            error(context.getString(R.string.toast_config_file_invalid))
         }
+
         // refresh socks port when enabled dynamic socks port
         SettingsManager.refreshRuntimeSocksPort()
 
 //        val result = V2rayConfigUtil.getV2rayConfig(context, guid)
-//        if (!result.status) return
+//        if (!result.status) error(result.errorMessage.ifBlank { "Failed to get V2Ray config" })
 
         if (MmkvManager.decodeSettingsBool(AppConfig.PREF_PROXY_SHARING)) {
             context.toast(R.string.toast_warning_pref_proxysharing_short)
@@ -155,11 +175,7 @@ object CoreServiceManager {
             Intent(context.applicationContext, CoreProxyOnlyService::class.java)
         }
 
-        try {
-            ContextCompat.startForegroundService(context, intent)
-        } catch (e: Exception) {
-            LogUtil.e(AppConfig.TAG, "StartCore-Manager: Failed to start service", e)
-        }
+        ContextCompat.startForegroundService(context, intent)
     }
 
     /**
@@ -179,67 +195,70 @@ object CoreServiceManager {
             return false
         }
 
-        val guid = MmkvManager.getSelectServer()
-        if (guid == null) {
-            LogUtil.e(AppConfig.TAG, "StartCore-Manager: No server selected")
+        try {
+            doStartCoreLoop(service, vpnInterface)
+            return true
+        } catch (e: Exception) {
+            val message = e.message?.takeUnless { it.isBlank() } ?: e.javaClass.simpleName
+            LogUtil.e(AppConfig.TAG, "StartCore-Manager: $message", e)
+            MessageUtil.sendMsg2UI(service, AppConfig.MSG_STATE_START_FAILURE, message)
+            NotificationManager.cancelNotification()
             return false
         }
+    }
 
-        val config = MmkvManager.decodeServerConfig(guid)
-        if (config == null) {
-            LogUtil.e(AppConfig.TAG, "StartCore-Manager: Failed to decode server config")
-            return false
-        }
+    @Throws(Exception::class)
+    private fun doStartCoreLoop(service: Service, vpnInterface: ParcelFileDescriptor?) {
+        val guid = MmkvManager.getSelectServer() ?: error("No server selected")
+        val config = MmkvManager.decodeServerConfig(guid) ?: error("Failed to decode server config")
 
         LogUtil.i(AppConfig.TAG, "StartCore-Manager: Starting core loop for ${config.remarks}")
         val result = CoreConfigManager.getV2rayConfig(service, guid)
         LogUtil.d(AppConfig.TAG, result.content)
         if (!result.status) {
-            LogUtil.e(AppConfig.TAG, "StartCore-Manager: Failed to get V2Ray config")
-            return false
+            error(result.errorMessage.ifBlank { "Failed to get V2Ray config" })
         }
 
-        try {
-            val mFilter = IntentFilter(AppConfig.BROADCAST_ACTION_SERVICE)
-            mFilter.addAction(Intent.ACTION_SCREEN_ON)
-            mFilter.addAction(Intent.ACTION_SCREEN_OFF)
-            mFilter.addAction(Intent.ACTION_USER_PRESENT)
-            ContextCompat.registerReceiver(service, mMsgReceive, mFilter, Utils.receiverFlags())
-        } catch (e: Exception) {
-            LogUtil.e(AppConfig.TAG, "StartCore-Manager: Failed to register receiver", e)
-            return false
-        }
+        val mFilter = IntentFilter(AppConfig.BROADCAST_ACTION_SERVICE)
+        mFilter.addAction(Intent.ACTION_SCREEN_ON)
+        mFilter.addAction(Intent.ACTION_SCREEN_OFF)
+        mFilter.addAction(Intent.ACTION_USER_PRESENT)
+        ContextCompat.registerReceiver(service, mMsgReceive, mFilter, Utils.receiverFlags())
 
         currentConfig = config
         var tunFd = vpnInterface?.fd ?: 0
+        val dialerAddr = if (currentConfig?.browserDialerMode.isNullOrEmpty()) {
+            ""
+        } else {
+            "127.0.0.1:${Utils.findRandomFreePort()}"
+        }
         if (SettingsManager.isUsingHevTun()) {
             tunFd = 0
         }
 
-        try {
-            NotificationManager.showNotification(currentConfig)
-            coreController.startLoop(result.content, tunFd)
-        } catch (e: Exception) {
-            LogUtil.e(AppConfig.TAG, "StartCore-Manager: Failed to start core loop", e)
-            return false
+        NotificationManager.showNotification(currentConfig)
+        CoreNativeManager.reconcileBrowserDialer(dialerAddr)
+        coreController.startLoop(result.content, tunFd)
+
+        if (!coreController.isRunning) {
+            error("Core failed to start")
         }
 
-        if (coreController.isRunning == false) {
-            LogUtil.e(AppConfig.TAG, "StartCore-Manager: Core failed to start")
-            MessageUtil.sendMsg2UI(service, AppConfig.MSG_STATE_START_FAILURE, "")
-            NotificationManager.cancelNotification()
-            return false
+        if (browserDialer != null) {
+            browserDialer!!.stop()
+            browserDialer = null
+        }
+        if (config.browserDialerMode == "OkHttp") {
+            browserDialer = DialerNativeService()
+            browserDialer!!.start(service, dialerAddr)
+        } else if (config.browserDialerMode == "WebView") {
+            browserDialer = DialerWebviewService()
+            browserDialer!!.start(service, dialerAddr)
         }
 
-        try {
-            MessageUtil.sendMsg2UI(service, AppConfig.MSG_STATE_START_SUCCESS, "")
-            NotificationManager.startSpeedNotification(currentConfig)
-            LogUtil.i(AppConfig.TAG, "StartCore-Manager: Core started successfully")
-        } catch (e: Exception) {
-            LogUtil.e(AppConfig.TAG, "StartCore-Manager: Failed to complete startup", e)
-            return false
-        }
-        return true
+        MessageUtil.sendMsg2UI(service, AppConfig.MSG_STATE_START_SUCCESS, "")
+        NotificationManager.startSpeedNotification(currentConfig)
+        LogUtil.i(AppConfig.TAG, "StartCore-Manager: Core started successfully")
     }
 
     /**
@@ -260,6 +279,13 @@ object CoreServiceManager {
             }
         }
 
+        // Close existing browser dialer
+        CoreNativeManager.reconcileBrowserDialer("")
+        if (browserDialer != null) {
+            browserDialer!!.stop()
+            browserDialer = null
+        }
+
         MessageUtil.sendMsg2UI(service, AppConfig.MSG_STATE_STOP_SUCCESS, "")
         NotificationManager.cancelNotification()
 
@@ -406,7 +432,7 @@ object CoreServiceManager {
                 //LogUtil.d(AppConfig.TAG, "ProcessFinder: Find $network connection from $srcIP:$srcPort to $destIP:$destPort, uid=$uid,${PackageUidResolver.uidToPackageName(uid.toString())}")
 
                 uid
-            } catch (e: Exception) {
+            } catch (_: Exception) {
                 -1L
             }
         }

V2rayNG/app/src/main/java/com/v2ray/ang/dto/ConfigResult.kt

@@ -4,5 +4,6 @@ data class ConfigResult(
     var status: Boolean,
     var guid: String? = null,
     var content: String = "",
+    var errorMessage: String = "",
 )
 

V2rayNG/app/src/main/java/com/v2ray/ang/dto/ProfileItem.kt

@@ -71,6 +71,8 @@ data class ProfileItem(
     var policyGroupFilter: String? = null,
     var proxyChainProfiles: String? = null,
 
+    var browserDialerMode: String? = null,
+
     ) {
     companion object {
         fun create(configType: EConfigType): ProfileItem {

V2rayNG/app/src/main/java/com/v2ray/ang/dto/V2rayConfig.kt

@@ -181,7 +181,7 @@ data class V2rayConfig(
                             @SerializedName("Accept-Encoding")
                             val acceptEncoding: List<String>? = null,
                             val Connection: List<String>? = null,
-                            val Pragma: String? = null
+                            val Pragma: Any? = null
                         )
                     }
                 }
@@ -344,19 +344,19 @@ data class V2rayConfig(
             if (protocol.equals(EConfigType.VMESS.name, true)
                 || protocol.equals(EConfigType.VLESS.name, true)
             ) {
-                return settings?.vnext?.first()?.address
+                return settings?.vnext?.firstOrNull()?.address ?: settings?.address as? String
             } else if (protocol.equals(EConfigType.SHADOWSOCKS.name, true)
                 || protocol.equals(EConfigType.SOCKS.name, true)
                 || protocol.equals(EConfigType.HTTP.name, true)
                 || protocol.equals(EConfigType.TROJAN.name, true)
             ) {
-                return settings?.servers?.first()?.address
+                return settings?.servers?.firstOrNull()?.address
             } else if (protocol.equals(EConfigType.WIREGUARD.name, true)) {
-                return settings?.peers?.first()?.endpoint?.substringBeforeLast(":")
+                return settings?.peers?.firstOrNull()?.endpoint?.substringBeforeLast(":")
             } else if (protocol.equals(EConfigType.HYSTERIA2.name, true)
                 || protocol.equals(EConfigType.HYSTERIA.name, true)
             ) {
-                return settings?.address as String?
+                return settings?.address as? String
             }
             return null
         }
@@ -365,15 +365,15 @@ data class V2rayConfig(
             if (protocol.equals(EConfigType.VMESS.name, true)
                 || protocol.equals(EConfigType.VLESS.name, true)
             ) {
-                return settings?.vnext?.first()?.port
+                return settings?.vnext?.firstOrNull()?.port ?: settings?.port
             } else if (protocol.equals(EConfigType.SHADOWSOCKS.name, true)
                 || protocol.equals(EConfigType.SOCKS.name, true)
                 || protocol.equals(EConfigType.HTTP.name, true)
                 || protocol.equals(EConfigType.TROJAN.name, true)
             ) {
-                return settings?.servers?.first()?.port
+                return settings?.servers?.firstOrNull()?.port
             } else if (protocol.equals(EConfigType.WIREGUARD.name, true)) {
-                return settings?.peers?.first()?.endpoint?.substringAfterLast(":")?.toInt()
+                return settings?.peers?.firstOrNull()?.endpoint?.substringAfterLast(":")?.toInt()
             } else if (protocol.equals(EConfigType.HYSTERIA2.name, true)
                 || protocol.equals(EConfigType.HYSTERIA.name, true)
             ) {

V2rayNG/app/src/main/java/com/v2ray/ang/fmt/CustomFmt.kt

@@ -20,7 +20,7 @@ object CustomFmt : FmtBase() {
 
         config.remarks = fullConfig?.remarks ?: System.currentTimeMillis().toString()
         config.server = outbound?.getServerAddress()
-        config.serverPort = outbound?.getServerPort().toString()
+        config.serverPort = outbound?.getServerPort()?.toString()
 
         return config
     }

V2rayNG/app/src/main/java/com/v2ray/ang/fmt/FmtBase.kt

@@ -4,7 +4,6 @@ import com.v2ray.ang.AppConfig
 import com.v2ray.ang.dto.ProfileItem
 import com.v2ray.ang.enums.NetworkType
 import com.v2ray.ang.extension.nullIfBlank
-import com.v2ray.ang.handler.MmkvManager
 import com.v2ray.ang.util.HttpUtil
 import com.v2ray.ang.util.Utils
 import java.net.URI

V2rayNG/app/src/main/java/com/v2ray/ang/handler/SpeedtestManager.kt

@@ -1,8 +1,6 @@
 package com.v2ray.ang.handler
 
-import android.os.SystemClock
 import com.v2ray.ang.AppConfig
-import com.v2ray.ang.R
 import com.v2ray.ang.dto.IPAPIInfo
 import com.v2ray.ang.util.HttpUtil
 import com.v2ray.ang.util.JsonUtil

V2rayNG/app/src/main/java/com/v2ray/ang/handler/SubscriptionUpdater.kt

@@ -14,9 +14,9 @@ import com.v2ray.ang.AngApplication
 import com.v2ray.ang.AppConfig
 import com.v2ray.ang.R
 import com.v2ray.ang.dto.SubscriptionCache
+import com.v2ray.ang.enums.NotificationChannelType
 import com.v2ray.ang.util.LogUtil
 import com.v2ray.ang.util.NotificationHelper
-import com.v2ray.ang.enums.NotificationChannelType
 import java.util.concurrent.TimeUnit
 
 object SubscriptionUpdater {

V2rayNG/app/src/main/java/com/v2ray/ang/handler/UpdateCheckerManager.kt

@@ -1,6 +1,5 @@
 package com.v2ray.ang.handler
 
-import android.content.Context
 import android.os.Build
 import com.v2ray.ang.AppConfig
 import com.v2ray.ang.BuildConfig
@@ -12,8 +11,6 @@ import com.v2ray.ang.util.JsonUtil
 import com.v2ray.ang.util.LogUtil
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
-import java.io.File
-import java.io.FileOutputStream
 
 object UpdateCheckerManager {
     suspend fun checkForUpdate(includePreRelease: Boolean = false): CheckUpdateResult = withContext(Dispatchers.IO) {

V2rayNG/app/src/main/java/com/v2ray/ang/receiver/BootReceiver.kt

@@ -4,9 +4,9 @@ import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
 import com.v2ray.ang.AppConfig
+import com.v2ray.ang.core.CoreServiceManager
 import com.v2ray.ang.handler.MmkvManager
 import com.v2ray.ang.handler.SubscriptionUpdater
-import com.v2ray.ang.core.CoreServiceManager
 import com.v2ray.ang.util.LogUtil
 
 class BootReceiver : BroadcastReceiver() {

V2rayNG/app/src/main/java/com/v2ray/ang/service/CoreProxyOnlyService.kt

@@ -6,8 +6,8 @@ import android.content.Intent
 import android.os.IBinder
 import com.v2ray.ang.AppConfig
 import com.v2ray.ang.contracts.ServiceControl
-import com.v2ray.ang.handler.SettingsManager
 import com.v2ray.ang.core.CoreServiceManager
+import com.v2ray.ang.handler.SettingsManager
 import com.v2ray.ang.util.LogUtil
 import com.v2ray.ang.util.MyContextWrapper
 import java.lang.ref.SoftReference

V2rayNG/app/src/main/java/com/v2ray/ang/service/CoreTestService.kt

@@ -5,15 +5,15 @@ import android.content.Intent
 import android.os.IBinder
 import com.v2ray.ang.AppConfig
 import com.v2ray.ang.R
+import com.v2ray.ang.core.CoreNativeManager
 import com.v2ray.ang.dto.RealPingEvent
 import com.v2ray.ang.dto.TestServiceMessage
+import com.v2ray.ang.enums.NotificationChannelType
 import com.v2ray.ang.extension.serializable
 import com.v2ray.ang.handler.MmkvManager
-import com.v2ray.ang.core.CoreNativeManager
 import com.v2ray.ang.util.LogUtil
 import com.v2ray.ang.util.MessageUtil
 import com.v2ray.ang.util.NotificationHelper
-import com.v2ray.ang.enums.NotificationChannelType
 import java.util.Collections
 
 class CoreTestService : Service() {
@@ -68,7 +68,9 @@ class CoreTestService : Service() {
         when (message.key) {
             AppConfig.MSG_MEASURE_CONFIG_START -> handleMeasureStart(message, startId)
             AppConfig.MSG_MEASURE_CONFIG_CANCEL -> handleMeasureCancel()
-            else -> { NotificationHelper.stopForeground(this); stopSelf(startId) }
+            else -> {
+                NotificationHelper.stopForeground(this); stopSelf(startId)
+            }
         }
         return START_NOT_STICKY
     }
@@ -94,7 +96,7 @@ class CoreTestService : Service() {
             worker = RealPingWorkerService(
                 context = this,
                 guids = guidsList,
-                onEvent = { event -> handleWorkerEvent(event) { activeWorkers.remove(worker) }  }
+                onEvent = { event -> handleWorkerEvent(event) { activeWorkers.remove(worker) } }
             )
             activeWorkers.add(worker)
             worker.start()
@@ -114,10 +116,12 @@ class CoreTestService : Service() {
                 )
                 MessageUtil.sendMsg2UI(this, AppConfig.MSG_MEASURE_CONFIG_NOTIFY, event.text)
             }
+
             is RealPingEvent.Result -> {
                 MmkvManager.encodeServerTestDelayMillis(event.guid, event.delayMillis)
                 MessageUtil.sendMsg2UI(this, AppConfig.MSG_MEASURE_CONFIG_SUCCESS, event.guid)
             }
+
             is RealPingEvent.Finish -> {
                 MessageUtil.sendMsg2UI(this, AppConfig.MSG_MEASURE_CONFIG_FINISH, event.status)
                 onWorkerDone()

V2rayNG/app/src/main/java/com/v2ray/ang/service/CoreVpnService.kt

@@ -20,10 +20,10 @@ import com.v2ray.ang.AppConfig.LOOPBACK
 import com.v2ray.ang.BuildConfig
 import com.v2ray.ang.contracts.ServiceControl
 import com.v2ray.ang.contracts.Tun2SocksControl
+import com.v2ray.ang.core.CoreServiceManager
 import com.v2ray.ang.handler.MmkvManager
 import com.v2ray.ang.handler.NotificationManager
 import com.v2ray.ang.handler.SettingsManager
-import com.v2ray.ang.core.CoreServiceManager
 import com.v2ray.ang.util.LogUtil
 import com.v2ray.ang.util.MyContextWrapper
 import com.v2ray.ang.util.Utils
@@ -113,6 +113,7 @@ class CoreVpnService : VpnService(), ServiceControl {
 
     override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
         LogUtil.i(AppConfig.TAG, "StartCore-VPN: Service command received")
+        NotificationManager.showNotification(null)
         setupVpnService()
         startService()
         return START_STICKY

V2rayNG/app/src/main/java/com/v2ray/ang/service/DialerNativeService.kt

@@ -0,0 +1,730 @@
+package com.v2ray.ang.service
+
+import android.content.Context
+import com.v2ray.ang.AppConfig
+import com.v2ray.ang.util.LogUtil
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+import okhttp3.Call
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+import okhttp3.Response
+import okhttp3.WebSocket
+import okhttp3.WebSocketListener
+import okio.Buffer
+import okio.ByteString
+import okio.ByteString.Companion.toByteString
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.EOFException
+import java.net.SocketException
+import java.net.URI
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicInteger
+import java.util.concurrent.atomic.AtomicLong
+
+// This class is responsible for forwarding xray's HTTP/WS requests through okhttp,
+// so that its TLS and traffic characteristics are okhttp instead of golang/utls.
+// Only WS and xhttp package-up are supported for now.
+// ws:
+// DialerNativeService connects to the control WebSocket provided by the xray core.
+// Then xray sends a task message with method "WS" and the server URL to the control WebSocket.
+// DialerNativeService opens a WebSocket connection to the server URL, and forwards messages between the control WebSocket and the target WebSocket.
+// xhttp(package-up):
+// A task message with streaming down (method == "GET" and streamResponse == true), let's call it Task A.
+// A task message with unary down (streamResponse == false), let's call it Task B.
+// 1. DialerNativeService connects to the control WebSocket provided by the xray core.
+// 2. Xray sends Task A, DialerNativeService sends "ok" and connects to the target URL, then sends the "GET" request to the server; let's call this "Connection A".
+// 3. Xray sends a Task B, called B_1. DialerNativeService sends "ok" and sends the data body to the target URL. Whatever the response is, DialerNativeService sends "ok" or "fail" back to the control WebSocket and closes the connection for Task B_1.
+// 4. The server returns the response for Task B_1 through Connection A, and DialerNativeService forwards the response body to the control WebSocket.
+// 5. Xray sends another Task B, called B_2.
+// ...
+// Finally, the xray client core sends all data through the B_1, B_2, ... tasks.
+// The server closes Connection A, and DialerNativeService closes Task A.
+// The above is a complete cycle.
+class DialerNativeService : IDialerService {
+    companion object {
+        private const val DEBUG_LOG = false
+        private val NEXT_SOCKET_ID = AtomicLong(0L)
+
+        private const val CONTROL_SOCKET_IDLE = 0
+        private const val CONTROL_SOCKET_OPENING = 1
+        private const val CONTROL_LOOP_DELAY_MS = 1000L
+        private const val UNARY_BODY_WAIT_TIMEOUT_MS = 15_000L
+        private val TOKEN_REGEX = Regex("""/websocket\?token=([^"'\s]+)""")
+        private val METHODS_WITHOUT_BODY = setOf("GET", "HEAD")
+    }
+
+    @Volatile
+    private var serviceJob = SupervisorJob()
+
+    @Volatile
+    private var scope = CoroutineScope(serviceJob + Dispatchers.IO)
+    private val running = AtomicBoolean(false)
+    private val controlSocketState = AtomicInteger(CONTROL_SOCKET_IDLE)
+    private val controlSockets = ConcurrentHashMap.newKeySet<WebSocket>()
+
+    @Volatile
+    private var controlUrl: String? = null
+    private var loopJob: Job? = null
+    private var client: OkHttpClient? = null
+
+    @Suppress("UNUSED_PARAMETER")
+    override fun start(context: Context, dialerAddr: String) {
+        stop()
+        serviceJob = SupervisorJob()
+        scope = CoroutineScope(serviceJob + Dispatchers.IO)
+        if (dialerAddr.isEmpty()) return
+
+        val nativeClient = OkHttpClient.Builder()
+            .retryOnConnectionFailure(true)
+            .pingInterval(25, TimeUnit.SECONDS)
+            .connectTimeout(30, TimeUnit.SECONDS)
+            .writeTimeout(60, TimeUnit.SECONDS)
+            .readTimeout(0, TimeUnit.SECONDS)  // Disable read timeout for long-running streams
+            .build()
+
+        client = nativeClient
+        running.set(true)
+        loopJob = scope.launch {
+            val resolvedControlUrl = resolveControlWsUrl(dialerAddr, nativeClient)
+            if (resolvedControlUrl == null) {
+                debug(
+                    "BrowserDialer: failed to resolve control url from dialer endpoint: $dialerAddr"
+                )
+                running.set(false)
+                return@launch
+            }
+            controlUrl = resolvedControlUrl
+            debug("BrowserDialer: started dialerAddr=$dialerAddr controlUrl=$resolvedControlUrl idleGate=${controlSocketState.get()}")
+            maintainControlSocketPool()
+            while (isActive && running.get()) {
+                maintainControlSocketPool()
+                delay(CONTROL_LOOP_DELAY_MS)
+            }
+        }
+    }
+
+    override fun stop() {
+        running.set(false)
+        loopJob?.cancel()
+        loopJob = null
+        serviceJob.cancel()
+
+        debug("BrowserDialer: stopping ${poolState()} controlUrl=$controlUrl")
+
+        controlSockets.toTypedArray().forEach { socket ->
+            runCatching { socket.close(1000, "stopped") }
+        }
+        controlSockets.clear()
+
+        controlSocketState.set(CONTROL_SOCKET_IDLE)
+        controlUrl = null
+
+        serviceJob = SupervisorJob()
+        scope = CoroutineScope(serviceJob + Dispatchers.IO)
+
+        val oldClient = client
+        client = null
+        oldClient?.dispatcher?.cancelAll()
+        oldClient?.connectionPool?.evictAll()
+    }
+
+    private fun maintainControlSocketPool() {
+        debug("BrowserDialer: maintaining single idle control socket ${poolState()}")
+        openControlSocket()
+    }
+
+    private fun openControlSocket(): Boolean {
+        val localClient = client ?: return false
+        if (!running.get()) return false
+        val url = controlUrl ?: return false
+        if (!controlSocketState.compareAndSet(
+                CONTROL_SOCKET_IDLE,
+                CONTROL_SOCKET_OPENING
+            )
+        ) return false
+
+        val request = Request.Builder().url(url).build()
+        return runCatching {
+            val socket = localClient.newWebSocket(request, ControlSocketListener(url))
+            controlSockets.add(socket)
+            debug("BrowserDialer: opening control socket url=$url ${poolState()}")
+            true
+        }.getOrElse {
+            controlSocketState.set(CONTROL_SOCKET_IDLE)
+            debug("BrowserDialer: failed to open control socket", it)
+            false
+        }
+    }
+
+    private fun poolState(): String {
+        return "idleGate=${controlSocketState.get()} liveSockets=${controlSockets.size}"
+    }
+
+    private fun debug(message: String, throwable: Throwable? = null) {
+        @Suppress("KotlinConstantConditions")
+        if (!DEBUG_LOG) return
+        if (throwable == null) {
+            LogUtil.d(AppConfig.TAG, message)
+        } else {
+            LogUtil.d(AppConfig.TAG, message, throwable)
+        }
+    }
+
+    private fun resolveControlWsUrl(rawAddr: String, probeClient: OkHttpClient): String? {
+        val uri = parseDialerUri(rawAddr) ?: return null
+        val probeUrl = buildDialerProbeUrl(rawAddr) ?: return null
+        val request = Request.Builder().url(probeUrl).get().build()
+        val token = runCatching {
+            probeClient.newCall(request).execute().use { response ->
+                if (!response.isSuccessful) return null
+                extractControlToken(response.body.string())
+            }
+        }.getOrNull() ?: return null
+        val host = uri.host ?: return null
+        return URI(
+            "ws",
+            uri.userInfo,
+            host,
+            uri.port,
+            "/websocket",
+            "token=$token",
+            null
+        ).toString()
+    }
+
+    private fun buildDialerProbeUrl(rawAddr: String): String? {
+        val normalized = rawAddr.trim()
+        if (normalized.isEmpty()) return null
+
+        val uri = parseDialerUri(normalized) ?: return null
+        val host = uri.host ?: return null
+        val probeScheme = when (uri.scheme?.lowercase()) {
+            "https", "wss" -> "https"
+            else -> "http"
+        }
+        return URI(probeScheme, uri.userInfo, host, uri.port, "/", null, null).toString()
+    }
+
+    private fun parseDialerUri(rawAddr: String): URI? {
+        val normalized = rawAddr.trim()
+        if (normalized.isEmpty()) return null
+        return runCatching {
+            if (normalized.contains("://")) URI(normalized) else URI("http://$normalized")
+        }.getOrNull()
+    }
+
+    private fun extractControlToken(html: String): String? {
+        val match = TOKEN_REGEX.find(html) ?: return null
+        return match.groupValues.getOrNull(1)?.takeIf { it.isNotBlank() }
+    }
+
+    private inner class ControlSocketListener(
+        private val controlUrl: String
+    ) : WebSocketListener() {
+        private val socketId = if (DEBUG_LOG) NEXT_SOCKET_ID.incrementAndGet() else 0L
+        private val taskAccepted = AtomicBoolean(false)
+        private val closed = AtomicBoolean(false)
+        private val taskStartedAtMs = AtomicLong(0L)
+
+        @Volatile
+        private var taskKind = "none"
+        private var upstreamSocket: WebSocket? = null
+        private var upstreamCall: Call? = null
+        private var timeoutJob: Job? = null
+        private var binaryHandler: ((ByteArray) -> Unit)? = null
+        private var textHandler: ((String) -> Unit)? = null
+
+        override fun onOpen(webSocket: WebSocket, response: Response) {
+            debug("BrowserDialer: control socket opened socketId=$socketId url=$controlUrl ${poolState()}")
+        }
+
+        override fun onMessage(webSocket: WebSocket, text: String) {
+            if (taskAccepted.compareAndSet(false, true)) {
+                controlSocketState.set(CONTROL_SOCKET_IDLE)
+                debug(
+                    "BrowserDialer: control socket accepted task socketId=$socketId url=$controlUrl textSize=${text.length} ${poolState()}"
+                )
+                tryOpenNextControlSocket()
+                handleTask(webSocket, BrowserDialerTask.parse(text))
+                return
+            }
+            textHandler?.invoke(text)
+        }
+
+        override fun onMessage(webSocket: WebSocket, bytes: ByteString) {
+            if (!taskAccepted.get()) {
+                failAndClose(webSocket, 1002, "task must be text json")
+                return
+            }
+            binaryHandler?.invoke(bytes.toByteArray())
+        }
+
+        override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
+            cleanup(webSocket)
+        }
+
+        override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
+            val status = response?.code?.toString() ?: "no-http-response"
+            val stateText = "${poolState()} accepted=${taskAccepted.get()} closed=${closed.get()}"
+            if (isExpectedControlFailure(t, status)) {
+                debug(
+                    "BrowserDialer: control socket closed socketId=$socketId url=$controlUrl status=$status cause=${t.javaClass.simpleName} $stateText"
+                )
+                debug(
+                    "BrowserDialer: control socket failure detail socketId=$socketId url=$controlUrl status=$status $stateText",
+                    t
+                )
+            } else {
+                debug(
+                    "BrowserDialer: control socket failure socketId=$socketId url=$controlUrl status=$status $stateText",
+                    t
+                )
+            }
+            cleanup(webSocket)
+        }
+
+        private fun isExpectedControlFailure(t: Throwable, status: String): Boolean {
+            if (!running.get() || closed.get()) return true
+            if (status != "no-http-response") return false
+            if (t is EOFException) return true
+            if (t is SocketException) {
+                val message = t.message.orEmpty().lowercase()
+                if ("socket closed" in message || "software caused connection abort" in message) {
+                    return true
+                }
+            }
+            val message = t.message.orEmpty().lowercase()
+            return "canceled" in message || "cancelled" in message
+        }
+
+
+        private fun tryOpenNextControlSocket() {
+            scope.launch {
+                if (running.get()) maintainControlSocketPool()
+            }
+        }
+
+        private fun cleanup(webSocket: WebSocket) {
+            if (!closed.compareAndSet(false, true)) return
+            val removed = controlSockets.remove(webSocket)
+            if (!taskAccepted.get()) {
+                controlSocketState.set(CONTROL_SOCKET_IDLE)
+                tryOpenNextControlSocket()
+            }
+            val started = taskStartedAtMs.get()
+            val duration =
+                if (started > 0L) (System.currentTimeMillis() - started).coerceAtLeast(0L) else -1L
+            debug(
+                "BrowserDialer: cleanup socketId=$socketId url=$controlUrl task=$taskKind taskAccepted=${taskAccepted.get()} removed=$removed durationMs=$duration ${poolState()}"
+            )
+            binaryHandler = null
+            textHandler = null
+            timeoutJob?.cancel()
+            timeoutJob = null
+            upstreamCall?.cancel()
+            upstreamCall = null
+            upstreamSocket?.close(1000, "control closed")
+            upstreamSocket = null
+            taskKind = "closed"
+            taskStartedAtMs.set(0L)
+        }
+
+        private fun handleTask(webSocket: WebSocket, task: BrowserDialerTask?) {
+            if (task == null) {
+                failAndClose(webSocket, 1007, "invalid task")
+                return
+            }
+
+            taskStartedAtMs.set(System.currentTimeMillis())
+            taskKind = when {
+                task.method == "WS" -> "ws"
+                task.method == "GET" && task.streamResponse -> "streaming_get"
+                !task.streamResponse -> "unary_${task.method.lowercase()}"
+                else -> "unsupported"
+            }
+
+            when {
+                task.method == "WS" -> handleWsTask(webSocket, task)
+                task.method == "GET" && task.streamResponse -> handleStreamingGetTask(
+                    webSocket,
+                    task
+                )
+
+                !task.streamResponse -> handleUnaryTask(webSocket, task)
+                else -> {
+                    failAndClose(webSocket, 1003, "unsupported task")
+                }
+            }
+        }
+
+        private fun handleWsTask(controlSocket: WebSocket, task: BrowserDialerTask) {
+            val localClient = client ?: run {
+                failAndClose(controlSocket, 1011, "client unavailable")
+                return
+            }
+            debug("BrowserDialer: handling WS task socketId=$socketId url=${task.url} protocols=${task.extra.protocols.size}")
+            val requestBuilder = Request.Builder().url(task.url)
+            if (task.extra.protocols.isNotEmpty()) {
+                requestBuilder.header(
+                    "Sec-WebSocket-Protocol",
+                    task.extra.protocols.joinToString(",")
+                )
+            }
+
+            val opened = AtomicBoolean(false)
+            upstreamSocket =
+                localClient.newWebSocket(requestBuilder.build(), object : WebSocketListener() {
+                    override fun onOpen(webSocket: WebSocket, response: Response) {
+                        opened.set(true)
+                        try {
+                            controlSocket.send("ok")
+                        } catch (e: Exception) {
+                            debug(
+                                "BrowserDialer: failed to send ok for WS task",
+                                e
+                            )
+                            webSocket.close(1000, "control failed")
+                        }
+                    }
+
+                    override fun onMessage(webSocket: WebSocket, text: String) {
+                        try {
+                            controlSocket.send(text)
+                        } catch (e: Exception) {
+                            debug(
+                                "BrowserDialer: control socket closed during WS message transfer socketId=$socketId",
+                                e
+                            )
+                            webSocket.close(1000, "control closed")
+                        }
+                    }
+
+                    override fun onMessage(webSocket: WebSocket, bytes: ByteString) {
+                        try {
+                            controlSocket.send(bytes)
+                        } catch (e: Exception) {
+                            debug(
+                                "BrowserDialer: control socket closed during WS binary transfer socketId=$socketId",
+                                e
+                            )
+                            webSocket.close(1000, "control closed")
+                        }
+                    }
+
+                    override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
+                        try {
+                            controlSocket.close(1000, "upstream closed")
+                        } catch (_: Exception) {
+                            debug("BrowserDialer: control socket already closed")
+                        }
+                    }
+
+                    override fun onFailure(
+                        webSocket: WebSocket,
+                        t: Throwable,
+                        response: Response?
+                    ) {
+                        if (!opened.get()) {
+                            try {
+                                controlSocket.send("fail")
+                            } catch (e: Exception) {
+                                debug(
+                                    "BrowserDialer: control socket send failed socketId=$socketId",
+                                    e
+                                )
+                            }
+                        }
+                        try {
+                            controlSocket.close(1011, "upstream failure")
+                        } catch (_: Exception) {
+                            debug(
+                                "BrowserDialer: control socket already closed socketId=$socketId"
+                            )
+                        }
+                    }
+                })
+
+            textHandler = { message ->
+                try {
+                    upstreamSocket?.send(message)
+                } catch (e: Exception) {
+                    debug(
+                        "BrowserDialer: upstream socket send failed socketId=$socketId",
+                        e
+                    )
+                }
+            }
+            binaryHandler = { data ->
+                try {
+                    upstreamSocket?.send(data.toByteString())
+                } catch (e: Exception) {
+                    debug(
+                        "BrowserDialer: upstream socket binary send failed socketId=$socketId",
+                        e
+                    )
+                }
+            }
+        }
+
+        private fun handleStreamingGetTask(controlSocket: WebSocket, task: BrowserDialerTask) {
+            val localClient = client ?: run {
+                failAndClose(controlSocket, 1011, "client unavailable")
+                return
+            }
+            debug("BrowserDialer: handling streaming GET task socketId=$socketId url=${task.url}")
+            val request = buildRequest(task, null)
+
+            try {
+                controlSocket.send("ok")
+            } catch (e: Exception) {
+                debug(
+                    "BrowserDialer: failed to send ok for streaming GET socketId=$socketId",
+                    e
+                )
+                return
+            }
+
+            scope.launch {
+                val call = localClient.newCall(request)
+                upstreamCall = call
+                try {
+                    call.execute().use { response ->
+                        val source = response.body.source()
+                        val buffer = Buffer()
+                        while (running.get() && !closed.get()) {
+                            try {
+                                val read = source.read(buffer, DEFAULT_BUFFER_SIZE.toLong())
+                                if (read < 0) break
+
+                                // Send data, catch exception if WebSocket is closed
+                                try {
+                                    controlSocket.send(buffer.readByteString())
+                                } catch (e: Exception) {
+                                    debug(
+                                        "BrowserDialer: WebSocket send failed during streaming, stopping stream socketId=$socketId",
+                                        e
+                                    )
+                                    break
+                                }
+                            } catch (_: Exception) {
+                                // Error reading from source, stop streaming
+                                break
+                            }
+                        }
+                    }
+                } catch (e: Exception) {
+                    debug(
+                        "BrowserDialer: streaming GET failed socketId=$socketId",
+                        e
+                    )
+                    try {
+                        controlSocket.send("fail")
+                    } catch (_: Exception) {
+                        // WebSocket may already be closed
+                    }
+                } finally {
+                    upstreamCall = null
+                    try {
+                        controlSocket.close(1000, "streaming done")
+                    } catch (_: Exception) {
+                        debug(
+                            "BrowserDialer: WebSocket already closed socketId=$socketId"
+                        )
+                    }
+                }
+            }
+        }
+
+        private fun handleUnaryTask(controlSocket: WebSocket, task: BrowserDialerTask) {
+            val localClient = client ?: run {
+                failAndClose(controlSocket, 1011, "client unavailable")
+                return
+            }
+            debug("BrowserDialer: handling unary task socketId=$socketId method=${task.method} url=${task.url}")
+
+            try {
+                controlSocket.send("ok")
+            } catch (e: Exception) {
+                debug(
+                    "BrowserDialer: failed to send ok for unary task socketId=$socketId",
+                    e
+                )
+                return
+            }
+
+            val done = AtomicBoolean(false)
+
+            timeoutJob = scope.launch {
+                delay(UNARY_BODY_WAIT_TIMEOUT_MS)
+                if (done.compareAndSet(false, true)) {
+                    binaryHandler = null
+                    textHandler = null
+                    debug("BrowserDialer: unary task timed out waiting for payload socketId=$socketId method=${task.method} url=${task.url}")
+                    failAndClose(controlSocket, 1000, "unary payload timeout")
+                }
+            }
+
+            val executeRequest: (ByteArray?) -> Unit = { payload ->
+                if (done.compareAndSet(false, true)) {
+                    timeoutJob?.cancel()
+                    timeoutJob = null
+                    binaryHandler = null
+                    textHandler = null
+                    scope.launch {
+                        val request = buildRequest(task, payload)
+                        val call = localClient.newCall(request)
+                        upstreamCall = call
+                        try {
+                            call.execute().use { response ->
+                                try {
+                                    controlSocket.send(if (response.isSuccessful) "ok" else "fail")
+                                } catch (e: Exception) {
+                                    debug(
+                                        "BrowserDialer: WebSocket send failed for unary response socketId=$socketId",
+                                        e
+                                    )
+                                }
+                            }
+                        } catch (e: Exception) {
+                            debug(
+                                "BrowserDialer: unary request failed socketId=$socketId",
+                                e
+                            )
+                            try {
+                                controlSocket.send("fail")
+                            } catch (_: Exception) {
+                                // WebSocket may already be closed
+                            }
+                        } finally {
+                            upstreamCall = null
+                            try {
+                                controlSocket.close(1000, "request done")
+                            } catch (_: Exception) {
+                                debug(
+                                    "BrowserDialer: WebSocket already closed socketId=$socketId"
+                                )
+                            }
+                        }
+                    }
+                }
+            }
+
+            binaryHandler = { body -> executeRequest(body.takeIf { it.isNotEmpty() }) }
+            textHandler = { body -> executeRequest(body.toByteArray().takeIf { it.isNotEmpty() }) }
+        }
+
+        private fun buildRequest(task: BrowserDialerTask, payload: ByteArray?): Request {
+            val requestBuilder = Request.Builder().url(task.url)
+            // task.extra.headers.forEach { (key, value) -> requestBuilder.header(key, value) }
+            // Just set no cache headers
+            requestBuilder.header("Cache-Control", "no-cache, no-store, must-revalidate")
+            task.extra.referrer?.takeIf { it.isNotBlank() }
+                ?.let { requestBuilder.header("Referer", it) }
+
+            val method = task.method.uppercase()
+            val methodAllowsBody = method !in METHODS_WITHOUT_BODY
+            val body = when {
+                methodAllowsBody && payload != null && payload.isNotEmpty() -> payload.toRequestBody(null)
+                methodAllowsBody -> ByteArray(0).toRequestBody(null)
+                else -> null
+            }
+            requestBuilder.method(method, body)
+            return requestBuilder.build()
+        }
+
+        private fun failAndClose(socket: WebSocket, code: Int, reason: String) {
+            try {
+                socket.send("fail")
+            } catch (e: Exception) {
+                debug("BrowserDialer: failed to send fail message", e)
+            }
+            try {
+                socket.close(code, reason)
+            } catch (e: Exception) {
+                debug("BrowserDialer: failed to close socket", e)
+            }
+        }
+    }
+
+    private data class BrowserDialerTask(
+        val method: String,
+        val url: String,
+        val streamResponse: Boolean,
+        val extra: Extra
+    ) {
+        data class Extra(
+            // val headers: Map<String, String> = emptyMap(),
+            // val cookies: Map<String, String> = emptyMap(),
+            val protocols: List<String> = emptyList(),
+            val referrer: String? = null
+        )
+
+        companion object {
+            fun parse(payload: String): BrowserDialerTask? {
+                return runCatching {
+                    val root = JSONObject(payload)
+                    val method = root.optString("method")
+                    val url = root.optString("url")
+                    if (method.isBlank() || url.isBlank()) return null
+
+                    val streamResponse = root.optBoolean("streamResponse", false)
+                    val extraObject = root.optJSONObject("extra")
+                    // val headers = extraObject.optStringMap("headers")
+                    // val cookies = extraObject.optStringMap("cookies")
+                    val referrer = extraObject?.optString("referrer")?.takeIf { it.isNotBlank() }
+                    val protocols = extraObject.optProtocols()
+
+                    BrowserDialerTask(
+                        method = method,
+                        url = url,
+                        streamResponse = streamResponse,
+                        extra = Extra(
+                            // headers = headers,
+                            // cookies = cookies,
+                            protocols = protocols,
+                            referrer = referrer
+                        )
+                    )
+                }.getOrNull()
+            }
+
+            // private fun JSONObject?.optStringMap(name: String): Map<String, String> {
+            //     val child = this?.optJSONObject(name) ?: return emptyMap()
+            //     val map = LinkedHashMap<String, String>()
+            //     val iter = child.keys()
+            //     while (iter.hasNext()) {
+            //         val key = iter.next()
+            //         map[key] = child.optString(key)
+            //     }
+            //     return map
+            // }
+
+            private fun JSONObject?.optProtocols(): List<String> {
+                val raw = this?.opt("protocol") ?: return emptyList()
+                return when (raw) {
+                    is String -> raw.takeIf { it.isNotBlank() }?.let { listOf(it) } ?: emptyList()
+                    is JSONArray -> buildList {
+                        for (i in 0 until raw.length()) {
+                            val item = raw.optString(i)
+                            if (item.isNotBlank()) {
+                                add(item)
+                            }
+                        }
+                    }
+
+                    else -> emptyList()
+                }
+            }
+        }
+    }
+}

V2rayNG/app/src/main/java/com/v2ray/ang/service/DialerWebviewService.kt

@@ -0,0 +1,73 @@
+package com.v2ray.ang.service
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.os.Handler
+import android.os.Looper
+import android.webkit.WebSettings
+import android.webkit.WebView
+import android.webkit.WebViewClient
+
+class DialerWebviewService : IDialerService {
+    private var webView: WebView? = null
+    private val handler = Handler(Looper.getMainLooper())
+    private val keepAliveInterval = 30_000L // 30 seconds
+
+    private val keepAliveRunnable = object : Runnable {
+        override fun run() {
+            webView?.let {
+                it.resumeTimers()
+                it.onResume()
+            }
+            handler.postDelayed(this, keepAliveInterval)
+        }
+    }
+
+
+    /**
+     * Starts the WebView.
+     * @param context Service context
+     */
+    @SuppressLint("SetJavaScriptEnabled")
+    override fun start(context: Context, dialerAddr: String) {
+        if (webView != null) stop()
+        if (dialerAddr.isEmpty()) return
+        val dialerUrl = "http://$dialerAddr/"
+
+        webView = WebView(context.applicationContext).apply {
+            settings.apply {
+                javaScriptEnabled = true
+                domStorageEnabled = true
+                // Allow JS to run even if not triggered by user
+                mediaPlaybackRequiresUserGesture = false
+                // Prevent aggressive caching issues
+                cacheMode = WebSettings.LOAD_DEFAULT
+            }
+
+            webViewClient = object : WebViewClient() {
+                override fun onPageFinished(view: WebView?, url: String?) {
+                    super.onPageFinished(view, url)
+                    view?.onResume()
+                    view?.resumeTimers()
+                }
+            }
+
+            loadUrl(dialerUrl)
+        }
+
+        handler.post(keepAliveRunnable)
+    }
+
+    override fun stop() {
+        handler.removeCallbacks(keepAliveRunnable)
+        webView?.apply {
+            stopLoading()
+            pauseTimers()
+            // Important to call onPause to stop internal Chromium threads properly
+            onPause()
+            destroy()
+        }
+        webView = null
+    }
+
+}

V2rayNG/app/src/main/java/com/v2ray/ang/service/IDialerService.kt

@@ -0,0 +1,8 @@
+package com.v2ray.ang.service
+
+import android.content.Context
+
+interface IDialerService {
+    fun start(context: Context, dialerAddr: String)
+    fun stop()
+}

V2rayNG/app/src/main/java/com/v2ray/ang/service/RealPingWorkerService.kt

@@ -1,10 +1,10 @@
 package com.v2ray.ang.service
 
 import android.content.Context
+import com.v2ray.ang.core.CoreConfigManager
+import com.v2ray.ang.core.CoreNativeManager
 import com.v2ray.ang.dto.RealPingEvent
 import com.v2ray.ang.handler.SettingsManager
-import com.v2ray.ang.core.CoreNativeManager
-import com.v2ray.ang.core.CoreConfigManager
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineName
 import kotlinx.coroutines.CoroutineScope

V2rayNG/app/src/main/java/com/v2ray/ang/ui/AboutActivity.kt

@@ -4,8 +4,8 @@ import android.os.Bundle
 import com.v2ray.ang.AppConfig
 import com.v2ray.ang.BuildConfig
 import com.v2ray.ang.R
-import com.v2ray.ang.databinding.ActivityAboutBinding
 import com.v2ray.ang.core.CoreNativeManager
+import com.v2ray.ang.databinding.ActivityAboutBinding
 import com.v2ray.ang.util.Utils
 
 class AboutActivity : BaseActivity() {

V2rayNG/app/src/main/java/com/v2ray/ang/ui/AppPickerActivity.kt

@@ -14,7 +14,6 @@ import com.v2ray.ang.databinding.ActivityAppPickerBinding
 import com.v2ray.ang.dto.AppInfo
 import com.v2ray.ang.util.AppManagerUtil
 import com.v2ray.ang.util.LogUtil
-import com.v2ray.ang.util.PackageUidResolver
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext

V2rayNG/app/src/main/java/com/v2ray/ang/ui/CheckUpdateActivity.kt

@@ -6,6 +6,7 @@ import androidx.lifecycle.lifecycleScope
 import com.v2ray.ang.AppConfig
 import com.v2ray.ang.BuildConfig
 import com.v2ray.ang.R
+import com.v2ray.ang.core.CoreNativeManager
 import com.v2ray.ang.databinding.ActivityCheckUpdateBinding
 import com.v2ray.ang.dto.CheckUpdateResult
 import com.v2ray.ang.extension.toast
@@ -13,7 +14,6 @@ import com.v2ray.ang.extension.toastError
 import com.v2ray.ang.extension.toastSuccess
 import com.v2ray.ang.handler.MmkvManager
 import com.v2ray.ang.handler.UpdateCheckerManager
-import com.v2ray.ang.core.CoreNativeManager
 import com.v2ray.ang.util.LogUtil
 import com.v2ray.ang.util.Utils
 import kotlinx.coroutines.launch

V2rayNG/app/src/main/java/com/v2ray/ang/ui/GroupServerFragment.kt

@@ -5,6 +5,7 @@ import android.os.Bundle
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
+import androidx.activity.result.contract.ActivityResultContracts
 import androidx.appcompat.app.AlertDialog
 import androidx.fragment.app.activityViewModels
 import androidx.lifecycle.lifecycleScope
@@ -23,6 +24,7 @@ import com.v2ray.ang.extension.toastError
 import com.v2ray.ang.extension.toastSuccess
 import com.v2ray.ang.handler.AngConfigManager
 import com.v2ray.ang.handler.MmkvManager
+import com.v2ray.ang.handler.SettingsChangeManager
 import com.v2ray.ang.helper.SimpleItemTouchHelperCallback
 import com.v2ray.ang.util.LogUtil
 import com.v2ray.ang.viewmodel.MainViewModel
@@ -44,6 +46,11 @@ class GroupServerFragment : BaseFragment<FragmentGroupServerBinding>(),
     private val share_method_more: Array<out String> by lazy {
         ownerActivity.resources.getStringArray(R.array.share_method_more)
     }
+    private val launcher = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) {
+        if (SettingsChangeManager.consumeRestartService() && mainViewModel.isRunning.value == true) {
+            ownerActivity.restartV2Ray()
+        }
+    }
 
     companion object {
         private const val ARG_SUB_ID = "subscriptionId"
@@ -168,27 +175,20 @@ class GroupServerFragment : BaseFragment<FragmentGroupServerBinding>(),
      * @param profile The server configuration
      */
     private fun editServer(guid: String, profile: ProfileItem) {
-        val intent = Intent().putExtra("guid", guid)
+        val activityClass = when (profile.configType) {
+            EConfigType.CUSTOM -> ServerCustomConfigActivity::class.java
+            EConfigType.POLICYGROUP -> ServerGroupActivity::class.java
+            EConfigType.PROXYCHAIN -> ServerProxyChainActivity::class.java
+            else -> ServerActivity::class.java
+        }
+
+        val intent = Intent(ownerActivity, activityClass)
+            .putExtra("guid", guid)
             .putExtra("isRunning", mainViewModel.isRunning.value)
             .putExtra("createConfigType", profile.configType.value)
             .putExtra("subscriptionId", subId)
-        when (profile.configType) {
-            EConfigType.CUSTOM -> {
-                ownerActivity.startActivity(intent.setClass(ownerActivity, ServerCustomConfigActivity::class.java))
-            }
 
-            EConfigType.POLICYGROUP -> {
-                ownerActivity.startActivity(intent.setClass(ownerActivity, ServerGroupActivity::class.java))
-            }
-
-            EConfigType.PROXYCHAIN -> {
-                ownerActivity.startActivity(intent.setClass(ownerActivity, ServerProxyChainActivity::class.java))
-            }
-
-            else -> {
-                ownerActivity.startActivity(intent.setClass(ownerActivity, ServerActivity::class.java))
-            }
-        }
+        launcher.launch(intent)
     }
 
     /**

V2rayNG/app/src/main/java/com/v2ray/ang/ui/MainActivity.kt

@@ -22,6 +22,7 @@ import com.google.android.material.navigation.NavigationView
 import com.google.android.material.tabs.TabLayoutMediator
 import com.v2ray.ang.AppConfig
 import com.v2ray.ang.R
+import com.v2ray.ang.core.CoreServiceManager
 import com.v2ray.ang.databinding.ActivityMainBinding
 import com.v2ray.ang.enums.EConfigType
 import com.v2ray.ang.enums.PermissionType
@@ -32,7 +33,6 @@ import com.v2ray.ang.handler.MmkvManager
 import com.v2ray.ang.handler.SettingsChangeManager
 import com.v2ray.ang.handler.SettingsManager
 import com.v2ray.ang.handler.SubscriptionUpdater
-import com.v2ray.ang.core.CoreServiceManager
 import com.v2ray.ang.util.LogUtil
 import com.v2ray.ang.util.Utils
 import com.v2ray.ang.viewmodel.MainViewModel

V2rayNG/app/src/main/java/com/v2ray/ang/ui/ServerActivity.kt

@@ -29,6 +29,7 @@ import com.v2ray.ang.extension.toast
 import com.v2ray.ang.extension.toastSuccess
 import com.v2ray.ang.handler.AngConfigManager
 import com.v2ray.ang.handler.MmkvManager
+import com.v2ray.ang.handler.SettingsChangeManager
 import com.v2ray.ang.util.JsonUtil
 import com.v2ray.ang.util.Utils
 
@@ -84,6 +85,9 @@ class ServerActivity : BaseActivity() {
     private val xhttpMode: Array<out String> by lazy {
         resources.getStringArray(R.array.xhttp_mode)
     }
+    private val browserDialerModes: Array<out String> by lazy {
+        resources.getStringArray(R.array.browser_dialer_mode)
+    }
 
 
     // Kotlin synthetics was used, but since it is removed in 1.8. We switch to old manual approach.
@@ -139,6 +143,8 @@ class ServerActivity : BaseActivity() {
     private val container_ech_config_list: LinearLayout? by lazy { findViewById(R.id.lay_ech_config_list) }
     private val et_pinned_ca256: EditText? by lazy { findViewById(R.id.et_pinned_ca256) }
     private val container_pinned_ca256: LinearLayout? by lazy { findViewById(R.id.lay_pinned_ca256) }
+    private val layout_browser_dialer: LinearLayout? by lazy { findViewById(R.id.layout_browser_dialer) }
+    private val sp_browser_dialer_mode: Spinner? by lazy { findViewById(R.id.sp_browser_dialer_mode) }
 
 
     override fun onCreate(savedInstanceState: Bundle?) {
@@ -254,6 +260,13 @@ class ServerActivity : BaseActivity() {
                         NetworkType.XHTTP.type -> View.VISIBLE
                         else -> View.GONE
                     }
+
+                layout_browser_dialer?.visibility =
+                    when (networks[position]) {
+                        NetworkType.WS.type -> View.VISIBLE
+                        NetworkType.XHTTP.type -> View.VISIBLE
+                        else -> View.GONE
+                    }
             }
 
             override fun onNothingSelected(parent: AdapterView<*>?) {
@@ -411,6 +424,12 @@ class ServerActivity : BaseActivity() {
         if (network >= 0) {
             sp_network?.setSelection(network)
         }
+
+        val browserDialerMode = Utils.arrayFind(browserDialerModes, config.browserDialerMode.orEmpty())
+        if (browserDialerMode >= 0) {
+            sp_browser_dialer_mode?.setSelection(browserDialerMode)
+        }
+
         return true
     }
 
@@ -439,6 +458,7 @@ class ServerActivity : BaseActivity() {
         et_local_address?.text =
             Utils.getEditable(WIREGUARD_LOCAL_ADDRESS_V4)
         et_local_mtu?.text = Utils.getEditable(WIREGUARD_LOCAL_MTU)
+        sp_browser_dialer_mode?.setSelection(0)
         return true
     }
 
@@ -507,6 +527,9 @@ class ServerActivity : BaseActivity() {
         }
         //LogUtil.i(AppConfig.TAG, JsonUtil.toJsonPretty(config) ?: "")
         MmkvManager.encodeServerConfig(editGuid, config)
+        if (isRunning) {
+            SettingsChangeManager.makeRestartService()
+        }
         toastSuccess(R.string.toast_success)
         finish()
         return true
@@ -568,6 +591,16 @@ class ServerActivity : BaseActivity() {
         profileItem.finalMask = et_fm?.text?.toString()?.trim()?.nullIfBlank()
         profileItem.kcpMtu = et_kcp_mtu?.text?.toString()?.toIntOrNull()
         profileItem.kcpTti = et_kcp_tti?.text?.toString()?.toIntOrNull()
+        if (networks[network] == NetworkType.WS.type || networks[network] == NetworkType.XHTTP.type) {
+            val browserDialerMode = browserDialerModes[sp_browser_dialer_mode?.selectedItemPosition ?: 0]
+            if (browserDialerMode != browserDialerModes[0]) {
+                profileItem.browserDialerMode = browserDialerMode
+            } else {
+                profileItem.browserDialerMode = null
+            }
+        } else {
+            profileItem.browserDialerMode = null
+        }
     }
 
     private fun saveTls(config: ProfileItem) {
@@ -656,17 +689,9 @@ class ServerActivity : BaseActivity() {
 
     override fun onCreateOptionsMenu(menu: Menu): Boolean {
         menuInflater.inflate(R.menu.action_server, menu)
-        val delButton = menu.findItem(R.id.del_config)
-        val saveButton = menu.findItem(R.id.save_config)
 
-        if (editGuid.isNotEmpty()) {
-            if (isRunning) {
-                delButton?.isVisible = false
-                saveButton?.isVisible = false
-            }
-        } else {
-            delButton?.isVisible = false
-        }
+        val delButton = menu.findItem(R.id.del_config)
+        delButton?.isVisible = editGuid.isNotEmpty() && !isRunning
 
         return super.onCreateOptionsMenu(menu)
     }

V2rayNG/app/src/main/java/com/v2ray/ang/ui/ServerCustomConfigActivity.kt

@@ -17,6 +17,7 @@ import com.v2ray.ang.extension.toastSuccess
 import com.v2ray.ang.fmt.CustomFmt
 import com.v2ray.ang.handler.AngConfigManager
 import com.v2ray.ang.handler.MmkvManager
+import com.v2ray.ang.handler.SettingsChangeManager
 import com.v2ray.ang.util.LogUtil
 import com.v2ray.ang.util.Utils
 
@@ -94,6 +95,9 @@ class ServerCustomConfigActivity : BaseActivity() {
 
         MmkvManager.encodeServerConfig(editGuid, config)
         MmkvManager.encodeServerRaw(editGuid, binding.editor.text.toString())
+        if (isRunning) {
+            SettingsChangeManager.makeRestartService()
+        }
         toastSuccess(R.string.toast_success)
         finish()
         return true
@@ -119,17 +123,9 @@ class ServerCustomConfigActivity : BaseActivity() {
 
     override fun onCreateOptionsMenu(menu: Menu): Boolean {
         menuInflater.inflate(R.menu.action_server, menu)
-        val delButton = menu.findItem(R.id.del_config)
-        val saveButton = menu.findItem(R.id.save_config)
 
-        if (editGuid.isNotEmpty()) {
-            if (isRunning) {
-                delButton?.isVisible = false
-                saveButton?.isVisible = false
-            }
-        } else {
-            delButton?.isVisible = false
-        }
+        val delButton = menu.findItem(R.id.del_config)
+        delButton?.isVisible = editGuid.isNotEmpty() && !isRunning
 
         return super.onCreateOptionsMenu(menu)
     }

V2rayNG/app/src/main/java/com/v2ray/ang/ui/ServerGroupActivity.kt

@@ -14,6 +14,7 @@ import com.v2ray.ang.extension.isNotNullEmpty
 import com.v2ray.ang.extension.toast
 import com.v2ray.ang.extension.toastSuccess
 import com.v2ray.ang.handler.MmkvManager
+import com.v2ray.ang.handler.SettingsChangeManager
 import com.v2ray.ang.util.Utils
 
 class ServerGroupActivity : BaseActivity() {
@@ -100,6 +101,9 @@ class ServerGroupActivity : BaseActivity() {
         config.description = "${binding.spPolicyGroupType.selectedItem} - ${binding.spPolicyGroupSubId.selectedItem} - ${config.policyGroupFilter}"
 
         MmkvManager.encodeServerConfig(editGuid, config)
+        if (isRunning) {
+            SettingsChangeManager.makeRestartService()
+        }
         toastSuccess(R.string.toast_success)
         finish()
         return true
@@ -143,17 +147,9 @@ class ServerGroupActivity : BaseActivity() {
 
     override fun onCreateOptionsMenu(menu: Menu): Boolean {
         menuInflater.inflate(R.menu.action_server, menu)
-        val delButton = menu.findItem(R.id.del_config)
-        val saveButton = menu.findItem(R.id.save_config)
 
-        if (editGuid.isNotEmpty()) {
-            if (isRunning) {
-                delButton?.isVisible = false
-                saveButton?.isVisible = false
-            }
-        } else {
-            delButton?.isVisible = false
-        }
+        val delButton = menu.findItem(R.id.del_config)
+        delButton?.isVisible = editGuid.isNotEmpty() && !isRunning
 
         return super.onCreateOptionsMenu(menu)
     }

V2rayNG/app/src/main/java/com/v2ray/ang/ui/ServerProxyChainActivity.kt

@@ -15,9 +15,10 @@ import com.v2ray.ang.dto.ProfileItem
 import com.v2ray.ang.enums.EConfigType
 import com.v2ray.ang.extension.toast
 import com.v2ray.ang.extension.toastSuccess
-import com.v2ray.ang.helper.SimpleItemTouchHelperCallback
 import com.v2ray.ang.handler.MmkvManager
+import com.v2ray.ang.handler.SettingsChangeManager
 import com.v2ray.ang.handler.SettingsManager
+import com.v2ray.ang.helper.SimpleItemTouchHelperCallback
 import com.v2ray.ang.util.Utils
 
 class ServerProxyChainActivity : BaseActivity() {
@@ -133,6 +134,9 @@ class ServerProxyChainActivity : BaseActivity() {
         }
 
         MmkvManager.encodeServerConfig(editGuid, config)
+        if (isRunning) {
+            SettingsChangeManager.makeRestartService()
+        }
         toastSuccess(R.string.toast_success)
         finish()
         return true
@@ -195,17 +199,9 @@ class ServerProxyChainActivity : BaseActivity() {
 
     override fun onCreateOptionsMenu(menu: Menu): Boolean {
         menuInflater.inflate(R.menu.action_server, menu)
-        val delButton = menu.findItem(R.id.del_config)
-        val saveButton = menu.findItem(R.id.save_config)
 
-        if (editGuid.isNotEmpty()) {
-            if (isRunning) {
-                delButton?.isVisible = false
-                saveButton?.isVisible = false
-            }
-        } else {
-            delButton?.isVisible = false
-        }
+        val delButton = menu.findItem(R.id.del_config)
+        delButton?.isVisible = editGuid.isNotEmpty() && !isRunning
 
         return super.onCreateOptionsMenu(menu)
     }

V2rayNG/app/src/main/java/com/v2ray/ang/ui/ServerProxyChainMemberAdapter.kt

@@ -1,10 +1,10 @@
 package com.v2ray.ang.ui
 
 import android.graphics.Color
-import android.widget.ArrayAdapter
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
+import android.widget.ArrayAdapter
 import androidx.recyclerview.widget.RecyclerView
 import com.v2ray.ang.contracts.BaseAdapterListener
 import com.v2ray.ang.databinding.ItemRecyclerProxyChainMemberBinding

V2rayNG/app/src/main/java/com/v2ray/ang/util/HttpUtil.kt

@@ -3,6 +3,9 @@ package com.v2ray.ang.util
 import com.v2ray.ang.AppConfig
 import com.v2ray.ang.AppConfig.LOOPBACK
 import com.v2ray.ang.BuildConfig
+import okhttp3.Credentials
+import okhttp3.OkHttpClient
+import okhttp3.Request
 import java.io.File
 import java.io.IOException
 import java.net.IDN
@@ -14,9 +17,6 @@ import java.net.Proxy
 import java.net.URI
 import java.net.URL
 import java.util.concurrent.TimeUnit
-import okhttp3.Credentials
-import okhttp3.OkHttpClient
-import okhttp3.Request
 
 object HttpUtil {
 
@@ -172,6 +172,9 @@ object HttpUtil {
                 .get()
                 .header("User-agent", finalUserAgent)
                 .header("Connection", "close")
+
+            applyEmbeddedBasicAuthHeader(currentUrl, requestBuilder)
+
             if (httpPort != 0 && !proxyUsername.isNullOrBlank() && !proxyPassword.isNullOrBlank()) {
                 requestBuilder.header("Proxy-Authorization", Credentials.basic(proxyUsername, proxyPassword))
             }
@@ -203,6 +206,20 @@ object HttpUtil {
         throw IOException("Too many redirects")
     }
 
+    private fun applyEmbeddedBasicAuthHeader(rawUrl: String, requestBuilder: Request.Builder) {
+        val parsed = runCatching { URL(rawUrl) }.getOrNull() ?: return
+        parsed.userInfo?.let { userInfo ->
+            val colon = userInfo.indexOf(':')
+            val user = runCatching {
+                Utils.decodeURIComponent(if (colon >= 0) userInfo.substring(0, colon) else userInfo)
+            }.getOrDefault(if (colon >= 0) userInfo.substring(0, colon) else userInfo)
+            val pass = runCatching {
+                Utils.decodeURIComponent(if (colon >= 0) userInfo.substring(colon + 1) else "")
+            }.getOrDefault(if (colon >= 0) userInfo.substring(colon + 1) else "")
+            requestBuilder.header("Authorization", Credentials.basic(user, pass))
+        }
+    }
+
     private fun buildOkHttpClient(
         timeout: Int,
         httpPort: Int,
@@ -290,4 +307,3 @@ object HttpUtil {
         }
     }
 }
-

V2rayNG/app/src/main/java/com/v2ray/ang/util/PackageUidResolver.kt

@@ -33,7 +33,7 @@ object PackageUidResolver {
     private fun resolveUid(context: Context, packageName: String): String? {
         // Special token for connections whose UID cannot be resolved (mapped to -1)
         if (packageName == AppConfig.UNIDENTIFIED_PACKAGE) {
-            val uid = "-1" 
+            val uid = "-1"
             LogUtil.d(AppConfig.TAG, "Special package: $packageName -> UID: $uid")
             return uid
         }

V2rayNG/app/src/main/java/com/v2ray/ang/util/Utils.kt

@@ -488,6 +488,16 @@ object Utils {
         throw IOException("no free port found")
     }
 
+    /**
+     * Find a random free port.
+     *
+     * @return A random free port.
+     * @throws IOException If no free port is found.
+     */
+    fun findRandomFreePort(): Int {
+        return ServerSocket(0).use { it.localPort }
+    }
+
     /**
      * Check if a string is a valid subscription URL.
      *

V2rayNG/app/src/main/java/com/v2ray/ang/viewmodel/MainViewModel.kt

@@ -19,7 +19,6 @@ import com.v2ray.ang.dto.SubscriptionCache
 import com.v2ray.ang.dto.SubscriptionUpdateResult
 import com.v2ray.ang.dto.TestServiceMessage
 import com.v2ray.ang.extension.matchesPattern
-import com.v2ray.ang.extension.serializable
 import com.v2ray.ang.extension.toastError
 import com.v2ray.ang.extension.toastSuccess
 import com.v2ray.ang.handler.AngConfigManager
@@ -457,7 +456,12 @@ class MainViewModel(application: Application) : AndroidViewModel(application) {
                 }
 
                 AppConfig.MSG_STATE_START_FAILURE -> {
-                    getApplication<AngApplication>().toastError(R.string.toast_services_failure)
+                    val errorMessage = intent.getStringExtra("content")
+                    if (!errorMessage.isNullOrBlank()) {
+                        getApplication<AngApplication>().toastError(errorMessage)
+                    } else {
+                        getApplication<AngApplication>().toastError(R.string.toast_services_failure)
+                    }
                     isRunning.value = false
                 }
 
@@ -471,7 +475,7 @@ class MainViewModel(application: Application) : AndroidViewModel(application) {
 
                 AppConfig.MSG_MEASURE_CONFIG_SUCCESS -> {
                     val content = intent.getStringExtra("content")
-                    updateListAction.value = getPosition(content?: "")
+                    updateListAction.value = getPosition(content ?: "")
                 }
 
                 AppConfig.MSG_MEASURE_CONFIG_NOTIFY -> {

V2rayNG/app/src/main/res/layout/layout_transport.xml

@@ -161,25 +161,54 @@
             android:minLines="4" />
     </LinearLayout>
 
-        <LinearLayout
-            android:id="@+id/layout_fm"
+    <LinearLayout
+        android:id="@+id/layout_fm"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_marginTop="@dimen/padding_spacing_dp16"
+        android:orientation="vertical">
+
+        <TextView
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="@string/server_lab_final_mask" />
+
+        <EditText
+            android:id="@+id/et_fm"
             android:layout_width="match_parent"
             android:layout_height="wrap_content"
-            android:layout_marginTop="@dimen/padding_spacing_dp16"
-            android:orientation="vertical">
+            android:gravity="top"
+            android:inputType="textMultiLine"
+            android:maxLines="20"
+            android:minLines="4" />
+    </LinearLayout>
 
-            <TextView
-                android:layout_width="wrap_content"
-                android:layout_height="wrap_content"
-                android:text="@string/server_lab_final_mask" />
+    <LinearLayout
+        android:id="@+id/layout_browser_dialer"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_marginTop="@dimen/padding_spacing_dp16"
+        android:orientation="vertical">
 
-            <EditText
-                android:id="@+id/et_fm"
-                android:layout_width="match_parent"
-                android:layout_height="wrap_content"
-                android:gravity="top"
-                android:inputType="textMultiLine"
-                android:maxLines="20"
-                android:minLines="4" />
+        <TextView
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="@string/server_lab_browser_dialer" />
+
+        <Spinner
+            android:id="@+id/sp_browser_dialer_mode"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_marginTop="@dimen/padding_spacing_dp8"
+            android:layout_marginBottom="@dimen/padding_spacing_dp16"
+            android:entries="@array/browser_dialer_mode" />
+
+        <TextView
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_marginTop="@dimen/padding_spacing_dp4"
+            android:text="@string/server_lab_browser_dialer_tip"
+            android:textColor="@android:color/darker_gray"
+            android:textSize="12sp" />
     </LinearLayout>
 </LinearLayout>

V2rayNG/app/src/main/res/values-ru/strings.xml

@@ -30,15 +30,15 @@
     <string name="menu_item_import_config_clipboard">Импорт из буфера обмена</string>
     <string name="menu_item_import_config_local">Импорт из файла</string>
     <string name="menu_item_import_config_policy_group">Добавить группу политик</string>
-    <string name="menu_item_import_config_proxy_chain">Add [Proxy chain]</string>
-    <string name="menu_item_import_config_manually_vmess">Ручной ввод VMess</string>
-    <string name="menu_item_import_config_manually_vless">Ручной ввод VLESS</string>
-    <string name="menu_item_import_config_manually_ss">Ручной ввод Shadowsocks</string>
-    <string name="menu_item_import_config_manually_socks">Ручной ввод SOCKS</string>
-    <string name="menu_item_import_config_manually_http">Ручной ввод HTTP</string>
-    <string name="menu_item_import_config_manually_trojan">Ручной ввод Trojan</string>
-    <string name="menu_item_import_config_manually_wireguard">Ручной ввод WireGuard</string>
-    <string name="menu_item_import_config_manually_hysteria2">Ручной ввод Hysteria2</string>
+    <string name="menu_item_import_config_proxy_chain">Добавить цепочку прокси</string>
+    <string name="menu_item_import_config_manually_vmess">Добавить VMess</string>
+    <string name="menu_item_import_config_manually_vless">Добавить VLESS</string>
+    <string name="menu_item_import_config_manually_ss">Добавить Shadowsocks</string>
+    <string name="menu_item_import_config_manually_socks">Добавить SOCKS</string>
+    <string name="menu_item_import_config_manually_http">Добавить HTTP</string>
+    <string name="menu_item_import_config_manually_trojan">Добавить Trojan</string>
+    <string name="menu_item_import_config_manually_wireguard">Добавить WireGuard</string>
+    <string name="menu_item_import_config_manually_hysteria2">Добавить Hysteria2</string>
     <string name="del_config_comfirm">Подтверждаете удаление?</string>
     <string name="del_invalid_config_comfirm">Выполните проверку перед удалением! Подтверждаете удаление?</string>
     <string name="server_lab_remarks">Название</string>
@@ -70,7 +70,7 @@
     <string name="server_lab_stream_security">TLS</string>
     <string name="server_lab_stream_fingerprint">Отпечаток</string>
     <string name="server_lab_stream_alpn">ALPN</string>
-    <string name="server_lab_allow_insecure">Разрешать небезопасные</string>
+    <string name="server_lab_allow_insecure">Разрешать небезопасные соединения</string>
     <string name="server_lab_sni">SNI</string>
     <string name="server_lab_address3">Адрес</string>
     <string name="server_lab_port3">Порт</string>
@@ -116,8 +116,10 @@
     <string name="server_lab_xhttp_mode">Режим XHTTP</string>
     <string name="server_lab_xhttp_extra">Необработанный JSON XHTTP Extra, формат: { XHTTPObject }</string>
     <string name="server_lab_final_mask">Необработанный JSON FinalMask, формат: { FinalMaskObject }</string>
-    <string name="server_lab_ech_config_list">EchConfigList</string>
+    <string name="server_lab_ech_config_list">ECHConfigList</string>
     <string name="server_lab_pinned_ca256">Отпечаток сертификата (SHA-256)</string>
+    <string name="server_lab_browser_dialer">Использовать переадресацию браузера</string>
+    <string name="server_lab_browser_dialer_tip">Поддерживаются только исходящие соединения XHTTP (packet-up) и WS; настройки, связанные с TLS, могут быть проигнорированы или конфликтовать</string>
 
     <!-- UserAssetActivity -->
     <string name="toast_asset_copy_failed">Невозможно скопировать файл, используйте файловый менеджер</string>
@@ -213,7 +215,7 @@
 
     <string name="title_pref_delay_test_url">Сервис проверки задержки</string>
     <string name="summary_pref_delay_test_url">URL</string>
-    <string name="title_pref_real_ping_concurrency">Параллельность теста задержки</string>
+    <string name="title_pref_real_ping_concurrency">Параллельная проверка задержки</string>
 
     <string name="title_pref_ip_api_url">Сервис проверки текущего соединения</string>
     <string name="summary_pref_ip_api_url">URL</string>
@@ -305,7 +307,7 @@
     <string name="sub_setting_pre_profile">Предыдущий профиль прокси</string>
     <string name="sub_setting_next_profile">Следующий профиль прокси</string>
     <string name="sub_setting_pre_profile_tip">Профиль должен быть уникальным</string>
-    <string name="toast_invalid_update_interval">Неверный интервал обновления. Минимум 15 минут.</string>
+    <string name="toast_invalid_update_interval">Неправильный интервал обновления. Минимум 15 минут.</string>
     <string name="title_sub_update">Обновить подписку</string>
     <string name="title_ping_all_server">Проверить профили</string>
     <string name="title_real_ping_all_server">Проверить задержку профилей</string>
@@ -343,7 +345,7 @@
     <string name="routing_settings_locked">Постоянное (сохранится при импорте правил)</string>
     <string name="routing_settings_domain">Домен</string>
     <string name="routing_settings_ip">IP</string>
-    <string name="routing_settings_process">Процесс (название пакета; поддерживается только при использовании Xray TUN, включённой функции routeOnly и ОС Android 10+)</string>
+    <string name="routing_settings_process">Процесс (название пакета; поддерживается только при использовании Xray TUN, включённой функции «Домен только для маршрутизации» и ОС Android 10+)</string>
     <string name="routing_settings_port">Порт</string>
     <string name="routing_settings_protocol">Протокол</string>
     <string name="routing_settings_protocol_tip">[http,tls,bittorrent]</string>
@@ -380,10 +382,11 @@
     <string name="title_policy_group_type">Тип группы политик</string>
     <string name="title_policy_group_subscription_id">Из группы подписки</string>
     <string name="title_policy_group_subscription_filter">Название фильтра</string>
+
     <string name="server_proxy_chain_members">Участники цепочки прокси</string>
     <string name="server_proxy_chain_pick_members">Нажмите здесь, чтобы выбрать участника</string>
-    <string name="server_proxy_chain_member_unselected">Выберите участника</string>
-    <string name="server_proxy_chain_members_unselected">Пожалуйста, выберите участника для каждой строки цепочки</string>
+    <string name="server_proxy_chain_member_unselected">Выбор участника</string>
+    <string name="server_proxy_chain_members_unselected">Выберите участника для каждого звена цепочки</string>
     <string name="server_proxy_chain_members_insufficient">Недостаточно участников</string>
     <string name="server_proxy_chain_members_invalid">Недопустимые участники цепочки: %1$s</string>
 

V2rayNG/app/src/main/res/values-zh-rCN/strings.xml

@@ -118,6 +118,8 @@
     <string name="server_lab_final_mask">FinalMask 原始 JSON 格式: { FinalMaskObject }</string>
     <string name="server_lab_ech_config_list">EchConfigList</string>
     <string name="server_lab_pinned_ca256">证书指纹 (SHA-256)</string>
+    <string name="server_lab_browser_dialer">启用浏览器转发</string>
+    <string name="server_lab_browser_dialer_tip">仅支持 xhttp (packet-up) 和 ws。与优选域名冲突，utls, alpn, ech 等 TLS 设置将被忽略</string>
 
     <!-- UserAssetActivity -->
     <string name="toast_asset_copy_failed">失败, 请使用文件管理器</string>

V2rayNG/app/src/main/res/values/arrays.xml

@@ -117,6 +117,12 @@
         <item>VPN</item>
         <item>Proxy only</item>
     </string-array>
+    
+    <string-array name="browser_dialer_mode_value" translatable="false">
+        <item>Disable</item>
+        <item>OkHttp</item>
+        <item>WebView</item>
+    </string-array>
 
     <string-array name="hev_tunnel_loglevel" translatable="false">
         <item>error</item>

V2rayNG/app/src/main/res/values/strings.xml

@@ -119,6 +119,8 @@
     <string name="server_lab_final_mask">finalMask raw JSON, format: { FinalMaskObject }</string>
     <string name="server_lab_ech_config_list">EchConfigList</string>
     <string name="server_lab_pinned_ca256">Certificate fingerprint (SHA-256)</string>
+    <string name="server_lab_browser_dialer">Enable Browser Dialer</string>
+    <string name="server_lab_browser_dialer_tip">Only supports xhttp (packet-up) and ws outbound; TLS-related settings may be ignored or conflict</string>
 
     <!-- UserAssetActivity -->
     <string name="toast_asset_copy_failed">File copy failed, please use File Manager</string>
@@ -427,6 +429,12 @@
         <item>Proxy only</item>
     </string-array>
 
+    <string-array name="browser_dialer_mode">
+        <item>Disable</item>
+        <item>OkHttp</item>
+        <item>WebView</item>
+    </string-array>
+
     <string-array name="ui_mode_night">
         <item>Follow system</item>
         <item>Light</item>

V2rayNG/gradle/libs.versions.toml

@@ -1,5 +1,5 @@
 [versions]
-agp = "9.2.0"
+agp = "9.2.1"
 desugarJdkLibs = "2.1.5"
 gradleLicensePlugin = "0.9.8"
 kotlin = "2.3.10"