.

V2rayNG/app/src/main/kotlin/com/v2ray/ang/util/AngConfigManager.kt

@@ -0,0 +1,750 @@
+package com.v2ray.ang.util
+
+import android.content.Context
+import android.content.SharedPreferences
+import android.graphics.Bitmap
+import android.text.TextUtils
+import android.util.Log
+import androidx.preference.PreferenceManager
+import com.google.gson.Gson
+import com.tencent.mmkv.MMKV
+import com.v2ray.ang.AppConfig
+import com.v2ray.ang.AppConfig.ANG_CONFIG
+import com.v2ray.ang.AppConfig.HTTPS_PROTOCOL
+import com.v2ray.ang.AppConfig.HTTP_PROTOCOL
+import com.v2ray.ang.R
+import com.v2ray.ang.dto.*
+import com.v2ray.ang.dto.V2rayConfig.Companion.DEFAULT_SECURITY
+import com.v2ray.ang.dto.V2rayConfig.Companion.TLS
+import com.v2ray.ang.util.MmkvManager.KEY_SELECTED_SERVER
+import java.net.URI
+import java.util.*
+import com.v2ray.ang.extension.idnHost
+
+object AngConfigManager {
+    private val mainStorage by lazy { MMKV.mmkvWithID(MmkvManager.ID_MAIN, MMKV.MULTI_PROCESS_MODE) }
+    private val serverRawStorage by lazy { MMKV.mmkvWithID(MmkvManager.ID_SERVER_RAW, MMKV.MULTI_PROCESS_MODE) }
+    private val settingsStorage by lazy { MMKV.mmkvWithID(MmkvManager.ID_SETTING, MMKV.MULTI_PROCESS_MODE) }
+    private val subStorage by lazy { MMKV.mmkvWithID(MmkvManager.ID_SUB, MMKV.MULTI_PROCESS_MODE) }
+
+    /**
+     * Legacy loading config
+     */
+    fun migrateLegacyConfig(c: Context): Boolean? {
+        try {
+            val defaultSharedPreferences = PreferenceManager.getDefaultSharedPreferences(c)
+            val context = defaultSharedPreferences.getString(ANG_CONFIG, "")
+            if (context.isNullOrBlank()) {
+                return null
+            }
+            val angConfig = Gson().fromJson(context, AngConfig::class.java)
+            for (i in angConfig.vmess.indices) {
+                upgradeServerVersion(angConfig.vmess[i])
+            }
+
+            copyLegacySettings(defaultSharedPreferences)
+            migrateVmessBean(angConfig, defaultSharedPreferences)
+            migrateSubItemBean(angConfig)
+
+            defaultSharedPreferences.edit().remove(ANG_CONFIG).apply()
+            return true
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+        return false
+    }
+
+    private fun copyLegacySettings(sharedPreferences: SharedPreferences) {
+        listOf(
+            AppConfig.PREF_MODE,
+            AppConfig.PREF_REMOTE_DNS,
+            AppConfig.PREF_DOMESTIC_DNS,
+            AppConfig.PREF_LOCAL_DNS_PORT,
+            AppConfig.PREF_SOCKS_PORT,
+            AppConfig.PREF_HTTP_PORT,
+            AppConfig.PREF_LOGLEVEL,
+            AppConfig.PREF_ROUTING_DOMAIN_STRATEGY,
+            AppConfig.PREF_ROUTING_MODE,
+            AppConfig.PREF_V2RAY_ROUTING_AGENT,
+            AppConfig.PREF_V2RAY_ROUTING_BLOCKED,
+            AppConfig.PREF_V2RAY_ROUTING_DIRECT,
+        ).forEach { key ->
+            settingsStorage?.encode(key, sharedPreferences.getString(key, null))
+        }
+        listOf(
+            AppConfig.PREF_SPEED_ENABLED,
+            AppConfig.PREF_PROXY_SHARING,
+            AppConfig.PREF_LOCAL_DNS_ENABLED,
+            AppConfig.PREF_ALLOW_INSECURE,
+            AppConfig.PREF_PREFER_IPV6,
+            AppConfig.PREF_PER_APP_PROXY,
+            AppConfig.PREF_BYPASS_APPS,
+        ).forEach { key ->
+            settingsStorage?.encode(key, sharedPreferences.getBoolean(key, false))
+        }
+        settingsStorage?.encode(AppConfig.PREF_SNIFFING_ENABLED, sharedPreferences.getBoolean(AppConfig.PREF_SNIFFING_ENABLED, true))
+        settingsStorage?.encode(AppConfig.PREF_PER_APP_PROXY_SET, sharedPreferences.getStringSet(AppConfig.PREF_PER_APP_PROXY_SET, setOf()))
+    }
+
+    private fun migrateVmessBean(angConfig: AngConfig, sharedPreferences: SharedPreferences) {
+        angConfig.vmess.forEachIndexed { index, vmessBean ->
+            val type = EConfigType.fromInt(vmessBean.configType) ?: return@forEachIndexed
+            val config = ServerConfig.create(type)
+            config.remarks = vmessBean.remarks
+            config.subscriptionId = vmessBean.subid
+            if (type == EConfigType.CUSTOM) {
+                val jsonConfig = sharedPreferences.getString(ANG_CONFIG + vmessBean.guid, "")
+                val v2rayConfig = try {
+                    Gson().fromJson(jsonConfig, V2rayConfig::class.java)
+                } catch (e: Exception) {
+                    e.printStackTrace()
+                    return@forEachIndexed
+                }
+                config.fullConfig = v2rayConfig
+                serverRawStorage?.encode(vmessBean.guid, jsonConfig)
+            } else {
+                config.outboundBean?.settings?.vnext?.get(0)?.let { vnext ->
+                    vnext.address = vmessBean.address
+                    vnext.port = vmessBean.port
+                    vnext.users[0].id = vmessBean.id
+                    if (config.configType == EConfigType.VMESS) {
+                        vnext.users[0].alterId = vmessBean.alterId
+                        vnext.users[0].security = vmessBean.security
+                    } else if (config.configType == EConfigType.VLESS) {
+                        vnext.users[0].encryption = vmessBean.security
+                        vnext.users[0].flow = vmessBean.flow
+                    }
+                }
+                config.outboundBean?.settings?.servers?.get(0)?.let { server ->
+                    server.address = vmessBean.address
+                    server.port = vmessBean.port
+                    if (config.configType == EConfigType.SHADOWSOCKS) {
+                        server.password = vmessBean.id
+                        server.method = vmessBean.security
+                    } else if (config.configType == EConfigType.SOCKS) {
+                        if (TextUtils.isEmpty(vmessBean.security) && TextUtils.isEmpty(vmessBean.id)) {
+                            server.users = null
+                        } else {
+                            val socksUsersBean = V2rayConfig.OutboundBean.OutSettingsBean.ServersBean.SocksUsersBean()
+                            socksUsersBean.user = vmessBean.security
+                            socksUsersBean.pass = vmessBean.id
+                            server.users = listOf(socksUsersBean)
+                        }
+                    } else if (config.configType == EConfigType.TROJAN) {
+                        server.password = vmessBean.id
+                    }
+                }
+                config.outboundBean?.streamSettings?.let { streamSetting ->
+                    val sni = streamSetting.populateTransportSettings(vmessBean.network, vmessBean.headerType,
+                            vmessBean.requestHost, vmessBean.path, vmessBean.path, vmessBean.requestHost, vmessBean.path,
+                            vmessBean.headerType, vmessBean.path)
+                    val allowInsecure = if (vmessBean.allowInsecure.isBlank()) {
+                        settingsStorage?.decodeBool(AppConfig.PREF_ALLOW_INSECURE) ?: false
+                    } else {
+                        vmessBean.allowInsecure.toBoolean()
+                    }
+                    var fingerprint = streamSetting.tlsSettings?.fingerprint
+                    streamSetting.populateTlsSettings(vmessBean.streamSecurity, allowInsecure,
+                        vmessBean.sni.ifBlank { sni }, fingerprint, null)
+                }
+            }
+            val key = MmkvManager.encodeServerConfig(vmessBean.guid, config)
+            if (index == angConfig.index) {
+                mainStorage?.encode(KEY_SELECTED_SERVER, key)
+            }
+        }
+    }
+
+    private fun migrateSubItemBean(angConfig: AngConfig) {
+        angConfig.subItem.forEach {
+            val subItem = SubscriptionItem()
+            subItem.remarks = it.remarks
+            subItem.url = it.url
+            subItem.enabled = it.enabled
+            subStorage?.encode(it.id, Gson().toJson(subItem))
+        }
+    }
+
+    /**
+     * import config form qrcode or...
+     */
+    private fun importConfig(str: String?, subid: String, removedSelectedServer: ServerConfig?): Int {
+        try {
+            if (str == null || TextUtils.isEmpty(str)) {
+                return R.string.toast_none_data
+            }
+
+            //maybe sub
+            if (TextUtils.isEmpty(subid) && (str.startsWith(HTTP_PROTOCOL) || str.startsWith(HTTPS_PROTOCOL))) {
+                MmkvManager.importUrlAsSubscription(str)
+                return 0
+            }
+
+            var config: ServerConfig? = null
+            val allowInsecure = settingsStorage?.decodeBool(AppConfig.PREF_ALLOW_INSECURE) ?: false
+            if (str.startsWith(EConfigType.VMESS.protocolScheme)) {
+                config = ServerConfig.create(EConfigType.VMESS)
+                val streamSetting = config.outboundBean?.streamSettings ?: return -1
+
+                var fingerprint = streamSetting.tlsSettings?.fingerprint
+
+
+                if (!tryParseNewVmess(str, config, allowInsecure)) {
+                    if (str.indexOf("?") > 0) {
+                        if (!tryResolveVmess4Kitsunebi(str, config)) {
+                            return R.string.toast_incorrect_protocol
+                        }
+                    } else {
+                        var result = str.replace(EConfigType.VMESS.protocolScheme, "")
+                        result = Utils.decode(result)
+                        if (TextUtils.isEmpty(result)) {
+                            return R.string.toast_decoding_failed
+                        }
+                        val vmessQRCode = Gson().fromJson(result, VmessQRCode::class.java)
+                        // Although VmessQRCode fields are non null, looks like Gson may still create null fields
+                        if (TextUtils.isEmpty(vmessQRCode.add)
+                                || TextUtils.isEmpty(vmessQRCode.port)
+                                || TextUtils.isEmpty(vmessQRCode.id)
+                                || TextUtils.isEmpty(vmessQRCode.net)
+                        ) {
+                            return R.string.toast_incorrect_protocol
+                        }
+
+                        config.remarks = vmessQRCode.ps
+                        config.outboundBean?.settings?.vnext?.get(0)?.let { vnext ->
+                            vnext.address = vmessQRCode.add
+                            vnext.port = Utils.parseInt(vmessQRCode.port)
+                            vnext.users[0].id = vmessQRCode.id
+                            vnext.users[0].security = if (TextUtils.isEmpty(vmessQRCode.scy)) DEFAULT_SECURITY else vmessQRCode.scy
+                            vnext.users[0].alterId = Utils.parseInt(vmessQRCode.aid)
+                        }
+                        val sni = streamSetting.populateTransportSettings(vmessQRCode.net, vmessQRCode.type, vmessQRCode.host,
+                                vmessQRCode.path, vmessQRCode.path, vmessQRCode.host, vmessQRCode.path, vmessQRCode.type, vmessQRCode.path)
+
+
+                        streamSetting.populateTlsSettings(vmessQRCode.tls, allowInsecure,
+                                if (TextUtils.isEmpty(vmessQRCode.sni)) sni else vmessQRCode.sni, fingerprint, vmessQRCode.alpn)
+                    }
+                }
+            } else if (str.startsWith(EConfigType.SHADOWSOCKS.protocolScheme)) {
+                config = ServerConfig.create(EConfigType.SHADOWSOCKS)
+                if (!tryResolveResolveSip002(str, config)) {
+                    var result = str.replace(EConfigType.SHADOWSOCKS.protocolScheme, "")
+                    val indexSplit = result.indexOf("#")
+                    if (indexSplit > 0) {
+                        try {
+                            config.remarks = Utils.urlDecode(result.substring(indexSplit + 1, result.length))
+                        } catch (e: Exception) {
+                            e.printStackTrace()
+                        }
+
+                        result = result.substring(0, indexSplit)
+                    }
+
+                    //part decode
+                    val indexS = result.indexOf("@")
+                    result = if (indexS > 0) {
+                        Utils.decode(result.substring(0, indexS)) + result.substring(indexS, result.length)
+                    } else {
+                        Utils.decode(result)
+                    }
+
+                    val legacyPattern = "^(.+?):(.*)@(.+?):(\\d+?)/?$".toRegex()
+                    val match = legacyPattern.matchEntire(result) ?: return R.string.toast_incorrect_protocol
+
+                    config.outboundBean?.settings?.servers?.get(0)?.let { server ->
+                        server.address = match.groupValues[3].removeSurrounding("[", "]")
+                        server.port = match.groupValues[4].toInt()
+                        server.password = match.groupValues[2]
+                        server.method = match.groupValues[1].lowercase()
+                    }
+                }
+            } else if (str.startsWith(EConfigType.SOCKS.protocolScheme)) {
+                var result = str.replace(EConfigType.SOCKS.protocolScheme, "")
+                val indexSplit = result.indexOf("#")
+                config = ServerConfig.create(EConfigType.SOCKS)
+                if (indexSplit > 0) {
+                    try {
+                        config.remarks = Utils.urlDecode(result.substring(indexSplit + 1, result.length))
+                    } catch (e: Exception) {
+                        e.printStackTrace()
+                    }
+
+                    result = result.substring(0, indexSplit)
+                }
+
+                //part decode
+                val indexS = result.indexOf("@")
+                if (indexS > 0) {
+                    result = Utils.decode(result.substring(0, indexS)) + result.substring(indexS, result.length)
+                } else {
+                    result = Utils.decode(result)
+                }
+
+                val legacyPattern = "^(.*):(.*)@(.+?):(\\d+?)$".toRegex()
+                val match = legacyPattern.matchEntire(result) ?: return R.string.toast_incorrect_protocol
+
+                config.outboundBean?.settings?.servers?.get(0)?.let { server ->
+                    server.address = match.groupValues[3].removeSurrounding("[", "]")
+                    server.port = match.groupValues[4].toInt()
+                    val socksUsersBean = V2rayConfig.OutboundBean.OutSettingsBean.ServersBean.SocksUsersBean()
+                    socksUsersBean.user = match.groupValues[1].lowercase()
+                    socksUsersBean.pass = match.groupValues[2]
+                    server.users = listOf(socksUsersBean)
+                }
+            } else if (str.startsWith(EConfigType.TROJAN.protocolScheme)) {
+                val uri = URI(Utils.fixIllegalUrl(str))
+                config = ServerConfig.create(EConfigType.TROJAN)
+                config.remarks = Utils.urlDecode(uri.fragment ?: "")
+
+                var flow = ""
+                var fingerprint = config.outboundBean?.streamSettings?.tlsSettings?.fingerprint
+                if (uri.rawQuery != null) {
+                    val queryParam = uri.rawQuery.split("&")
+                        .associate { it.split("=").let { (k, v) -> k to Utils.urlDecode(v) } }
+
+                    val sni = config.outboundBean?.streamSettings?.populateTransportSettings(queryParam["type"] ?: "tcp", queryParam["headerType"],
+                        queryParam["host"], queryParam["path"], queryParam["seed"], queryParam["quicSecurity"], queryParam["key"],
+                        queryParam["mode"], queryParam["serviceName"])
+                    config.outboundBean?.streamSettings?.populateTlsSettings(queryParam["security"] ?: TLS, allowInsecure, queryParam["sni"] ?: sni!!, fingerprint, queryParam["alpn"])
+                    flow = queryParam["flow"] ?: ""
+                } else {
+
+                    config.outboundBean?.streamSettings?.populateTlsSettings(TLS, allowInsecure, "", fingerprint, null)
+                }
+
+                config.outboundBean?.settings?.servers?.get(0)?.let { server ->
+                    server.address = uri.idnHost
+                    server.port = uri.port
+                    server.password = uri.userInfo
+                    server.flow = flow
+                }
+            } else if (str.startsWith(EConfigType.VLESS.protocolScheme)) {
+                val uri = URI(Utils.fixIllegalUrl(str))
+                val queryParam = uri.rawQuery.split("&")
+                    .associate { it.split("=").let { (k, v) -> k to Utils.urlDecode(v) } }
+                config = ServerConfig.create(EConfigType.VLESS)
+                val streamSetting = config.outboundBean?.streamSettings ?: return -1
+                var fingerprint = streamSetting.tlsSettings?.fingerprint
+
+                config.remarks = Utils.urlDecode(uri.fragment ?: "")
+                config.outboundBean?.settings?.vnext?.get(0)?.let { vnext ->
+                    vnext.address = uri.idnHost
+                    vnext.port = uri.port
+                    vnext.users[0].id = uri.userInfo
+                    vnext.users[0].encryption = queryParam["encryption"] ?: "none"
+                    vnext.users[0].flow =queryParam["flow"] ?: ""
+                }
+
+                val sni = streamSetting.populateTransportSettings(queryParam["type"] ?: "tcp", queryParam["headerType"],
+                        queryParam["host"], queryParam["path"], queryParam["seed"], queryParam["quicSecurity"], queryParam["key"],
+                        queryParam["mode"], queryParam["serviceName"])
+                streamSetting.populateTlsSettings(queryParam["security"] ?: "", allowInsecure, queryParam["sni"] ?: sni, fingerprint, queryParam["alpn"])
+            }
+            if (config == null){
+                return R.string.toast_incorrect_protocol
+            }
+            config.subscriptionId = subid
+            val guid = MmkvManager.encodeServerConfig("", config)
+            if (removedSelectedServer != null &&
+                    config.getProxyOutbound()?.getServerAddress() == removedSelectedServer.getProxyOutbound()?.getServerAddress() &&
+                    config.getProxyOutbound()?.getServerPort() == removedSelectedServer.getProxyOutbound()?.getServerPort()) {
+                mainStorage?.encode(KEY_SELECTED_SERVER, guid)
+            }
+        } catch (e: Exception) {
+            e.printStackTrace()
+            return -1
+        }
+        return 0
+    }
+
+    private fun tryParseNewVmess(uriString: String, config: ServerConfig, allowInsecure: Boolean): Boolean {
+        return runCatching {
+            val uri = URI(uriString)
+            check(uri.scheme == "vmess")
+            val (_, protocol, tlsStr, uuid, alterId) =
+                    Regex("(tcp|http|ws|kcp|quic|grpc)(\\+tls)?:([0-9a-z]{8}-[0-9a-z]{4}-[0-9a-z]{4}-[0-9a-z]{4}-[0-9a-z]{12})")
+                            .matchEntire(uri.userInfo)?.groupValues
+                            ?: error("parse user info fail.")
+            val tls = tlsStr.isNotBlank()
+            val queryParam = uri.rawQuery.split("&")
+                .associate { it.split("=").let { (k, v) -> k to Utils.urlDecode(v) } }
+
+            val streamSetting = config.outboundBean?.streamSettings ?: return false
+            config.remarks = Utils.urlDecode(uri.fragment ?: "")
+            config.outboundBean.settings?.vnext?.get(0)?.let { vnext ->
+                vnext.address = uri.idnHost
+                vnext.port = uri.port
+                vnext.users[0].id = uuid
+                vnext.users[0].security = DEFAULT_SECURITY
+                vnext.users[0].alterId = alterId.toInt()
+            }
+            var fingerprint = streamSetting.tlsSettings?.fingerprint
+            val sni = streamSetting.populateTransportSettings(protocol, queryParam["type"],
+                    queryParam["host"]?.split("|")?.get(0) ?: "",
+                    queryParam["path"]?.takeIf { it.trim() != "/" } ?: "", queryParam["seed"], queryParam["security"],
+                    queryParam["key"], queryParam["mode"], queryParam["serviceName"])
+            streamSetting.populateTlsSettings(if (tls) TLS else "", allowInsecure, sni, fingerprint, null)
+            true
+        }.getOrElse { false }
+    }
+
+    private fun tryResolveVmess4Kitsunebi(server: String, config: ServerConfig): Boolean {
+
+        var result = server.replace(EConfigType.VMESS.protocolScheme, "")
+        val indexSplit = result.indexOf("?")
+        if (indexSplit > 0) {
+            result = result.substring(0, indexSplit)
+        }
+        result = Utils.decode(result)
+
+        val arr1 = result.split('@')
+        if (arr1.count() != 2) {
+            return false
+        }
+        val arr21 = arr1[0].split(':')
+        val arr22 = arr1[1].split(':')
+        if (arr21.count() != 2) {
+            return false
+        }
+
+        config.remarks = "Alien"
+        config.outboundBean?.settings?.vnext?.get(0)?.let { vnext ->
+            vnext.address = arr22[0]
+            vnext.port = Utils.parseInt(arr22[1])
+            vnext.users[0].id = arr21[1]
+            vnext.users[0].security = arr21[0]
+            vnext.users[0].alterId = 0
+        }
+        return true
+    }
+
+    private fun tryResolveResolveSip002(str: String, config: ServerConfig): Boolean {
+        try {
+            val uri = URI(Utils.fixIllegalUrl(str))
+            config.remarks = Utils.urlDecode(uri.fragment ?: "")
+
+            val method: String
+            val password: String
+            if (uri.userInfo.contains(":")) {
+                val arrUserInfo = uri.userInfo.split(":").map { it.trim() }
+                if (arrUserInfo.count() != 2) {
+                    return false
+                }
+                method = arrUserInfo[0]
+                password = Utils.urlDecode(arrUserInfo[1])
+            } else {
+                val base64Decode = Utils.decode(uri.userInfo)
+                val arrUserInfo = base64Decode.split(":").map { it.trim() }
+                if (arrUserInfo.count() < 2) {
+                    return false
+                }
+                method = arrUserInfo[0]
+                password = base64Decode.substringAfter(":")
+            }
+
+            config.outboundBean?.settings?.servers?.get(0)?.let { server ->
+                server.address = uri.idnHost
+                server.port = uri.port
+                server.password = password
+                server.method = method
+            }
+            return true
+        } catch (e: Exception) {
+            Log.d(AppConfig.ANG_PACKAGE, e.toString())
+            return false
+        }
+    }
+
+    /**
+     * share config
+     */
+    private fun shareConfig(guid: String): String {
+        try {
+            val config = MmkvManager.decodeServerConfig(guid) ?: return ""
+            val outbound = config.getProxyOutbound() ?: return ""
+            val streamSetting = outbound.streamSettings ?: return ""
+            return config.configType.protocolScheme + when (config.configType) {
+                EConfigType.VMESS -> {
+                    val vmessQRCode = VmessQRCode()
+                    vmessQRCode.v = "2"
+                    vmessQRCode.ps = config.remarks
+                    vmessQRCode.add = outbound.getServerAddress().orEmpty()
+                    vmessQRCode.port = outbound.getServerPort().toString()
+                    vmessQRCode.id = outbound.getPassword().orEmpty()
+                    vmessQRCode.aid = outbound.settings?.vnext?.get(0)?.users?.get(0)?.alterId.toString()
+                    vmessQRCode.scy = outbound.settings?.vnext?.get(0)?.users?.get(0)?.security.toString()
+                    vmessQRCode.net = streamSetting.network
+                    vmessQRCode.tls = streamSetting.security
+                    vmessQRCode.sni = streamSetting.tlsSettings?.serverName.orEmpty()
+                    vmessQRCode.alpn = Utils.removeWhiteSpace(streamSetting.tlsSettings?.alpn?.joinToString()).orEmpty()
+                    outbound.getTransportSettingDetails()?.let { transportDetails ->
+                        vmessQRCode.type = transportDetails[0]
+                        vmessQRCode.host = transportDetails[1]
+                        vmessQRCode.path = transportDetails[2]
+                    }
+                    val json = Gson().toJson(vmessQRCode)
+                    Utils.encode(json)
+                }
+                EConfigType.CUSTOM, EConfigType.WIREGUARD -> ""
+                EConfigType.SHADOWSOCKS -> {
+                    val remark = "#" + Utils.urlEncode(config.remarks)
+                    val pw = Utils.encode("${outbound.getSecurityEncryption()}:${outbound.getPassword()}")
+                    val url = String.format("%s@%s:%s",
+                            pw,
+                            Utils.getIpv6Address(outbound.getServerAddress()!!),
+                            outbound.getServerPort())
+                    url + remark
+                }
+                EConfigType.SOCKS -> {
+                    val remark = "#" + Utils.urlEncode(config.remarks)
+                    val pw = Utils.encode("${outbound.settings?.servers?.get(0)?.users?.get(0)?.user}:${outbound.getPassword()}")
+                    val url = String.format("%s@%s:%s",
+                        pw,
+                        Utils.getIpv6Address(outbound.getServerAddress()!!),
+                        outbound.getServerPort())
+                    url + remark
+                }
+                EConfigType.VLESS,
+                EConfigType.TROJAN -> {
+                    val remark = "#" + Utils.urlEncode(config.remarks)
+
+                    val dicQuery = HashMap<String, String>()
+                    if (config.configType == EConfigType.VLESS) {
+                        outbound.settings?.vnext?.get(0)?.users?.get(0)?.flow?.let {
+                            if (!TextUtils.isEmpty(it)) {
+                                dicQuery["flow"] = it
+                            }
+                        }
+                        dicQuery["encryption"] =
+                            if (outbound.getSecurityEncryption().isNullOrEmpty()) "none"
+                            else outbound.getSecurityEncryption().orEmpty()
+                    } else if (config.configType == EConfigType.TROJAN) {
+                        config.outboundBean?.settings?.servers?.get(0)?.flow?.let {
+                            if (!TextUtils.isEmpty(it)) {
+                                dicQuery["flow"] = it
+                            }
+                        }
+                    }
+
+                    dicQuery["security"] = streamSetting.security.ifEmpty { "none" }
+                    (streamSetting.tlsSettings?: streamSetting.xtlsSettings)?.let { tlsSetting ->
+                        if (!TextUtils.isEmpty(tlsSetting.serverName)) {
+                            dicQuery["sni"] = tlsSetting.serverName
+                        }
+                        if (!tlsSetting.alpn.isNullOrEmpty() && tlsSetting.alpn.isNotEmpty()) {
+                            dicQuery["alpn"] = Utils.removeWhiteSpace(tlsSetting.alpn.joinToString()).orEmpty()
+                        }
+                    }
+                    dicQuery["type"] = streamSetting.network.ifEmpty { V2rayConfig.DEFAULT_NETWORK }
+
+                    outbound.getTransportSettingDetails()?.let { transportDetails ->
+                        when (streamSetting.network) {
+                            "tcp" -> {
+                                dicQuery["headerType"] = transportDetails[0].ifEmpty { "none" }
+                                if (!TextUtils.isEmpty(transportDetails[1])) {
+                                    dicQuery["host"] = Utils.urlEncode(transportDetails[1])
+                                }
+                            }
+                            "kcp" -> {
+                                dicQuery["headerType"] = transportDetails[0].ifEmpty { "none" }
+                                if (!TextUtils.isEmpty(transportDetails[2])) {
+                                    dicQuery["seed"] = Utils.urlEncode(transportDetails[2])
+                                }
+                            }
+                            "ws" -> {
+                                if (!TextUtils.isEmpty(transportDetails[1])) {
+                                    dicQuery["host"] = Utils.urlEncode(transportDetails[1])
+                                }
+                                if (!TextUtils.isEmpty(transportDetails[2])) {
+                                    dicQuery["path"] = Utils.urlEncode(transportDetails[2])
+                                }
+                            }
+                            "http", "h2" -> {
+                                dicQuery["type"] = "http"
+                                if (!TextUtils.isEmpty(transportDetails[1])) {
+                                    dicQuery["host"] = Utils.urlEncode(transportDetails[1])
+                                }
+                                if (!TextUtils.isEmpty(transportDetails[2])) {
+                                    dicQuery["path"] = Utils.urlEncode(transportDetails[2])
+                                }
+                            }
+                            "quic" -> {
+                                dicQuery["headerType"] = transportDetails[0].ifEmpty { "none" }
+                                dicQuery["quicSecurity"] = Utils.urlEncode(transportDetails[1])
+                                dicQuery["key"] = Utils.urlEncode(transportDetails[2])
+                            }
+                            "grpc" -> {
+                                dicQuery["mode"] = transportDetails[0]
+                                dicQuery["serviceName"] = transportDetails[2]
+                            }
+                        }
+                    }
+                    val query = "?" + dicQuery.toList().joinToString(
+                            separator = "&",
+                            transform = { it.first + "=" + it.second })
+
+                    val url = String.format("%s@%s:%s",
+                            outbound.getPassword(),
+                            Utils.getIpv6Address(outbound.getServerAddress()!!),
+                            outbound.getServerPort())
+                    url + query + remark
+                }
+            }
+        } catch (e: Exception) {
+            e.printStackTrace()
+            return ""
+        }
+    }
+
+    /**
+     * share2Clipboard
+     */
+    fun share2Clipboard(context: Context, guid: String): Int {
+        try {
+            val conf = shareConfig(guid)
+            if (TextUtils.isEmpty(conf)) {
+                return -1
+            }
+
+            Utils.setClipboard(context, conf)
+
+        } catch (e: Exception) {
+            e.printStackTrace()
+            return -1
+        }
+        return 0
+    }
+
+    /**
+     * share2Clipboard
+     */
+    fun shareNonCustomConfigsToClipboard(context: Context, serverList: List<String>): Int {
+        try {
+            val sb = StringBuilder()
+            for (guid in serverList) {
+                val url = shareConfig(guid)
+                if (TextUtils.isEmpty(url)) {
+                    continue
+                }
+                sb.append(url)
+                sb.appendLine()
+            }
+            if (sb.count() > 0) {
+                Utils.setClipboard(context, sb.toString())
+            }
+        } catch (e: Exception) {
+            e.printStackTrace()
+            return -1
+        }
+        return 0
+    }
+
+    /**
+     * share2QRCode
+     */
+    fun share2QRCode(guid: String): Bitmap? {
+        try {
+            val conf = shareConfig(guid)
+            if (TextUtils.isEmpty(conf)) {
+                return null
+            }
+            return Utils.createQRCode(conf)
+
+        } catch (e: Exception) {
+            e.printStackTrace()
+            return null
+        }
+    }
+
+    /**
+     * shareFullContent2Clipboard
+     */
+    fun shareFullContent2Clipboard(context: Context, guid: String?): Int {
+        try {
+            if (guid == null) return -1
+            val result = V2rayConfigUtil.getV2rayConfig(context, guid)
+            if (result.status) {
+                Utils.setClipboard(context, result.content)
+            } else {
+                return -1
+            }
+        } catch (e: Exception) {
+            e.printStackTrace()
+            return -1
+        }
+        return 0
+    }
+
+    /**
+     * upgrade
+     */
+    private fun upgradeServerVersion(vmess: AngConfig.VmessBean): Int {
+        try {
+            if (vmess.configVersion == 2) {
+                return 0
+            }
+
+            when (vmess.network) {
+                "ws", "h2" -> {
+                    var path = ""
+                    var host = ""
+                    val lstParameter = vmess.requestHost.split(";")
+                    if (lstParameter.isNotEmpty()) {
+                        path = lstParameter[0].trim()
+                    }
+                    if (lstParameter.size > 1) {
+                        path = lstParameter[0].trim()
+                        host = lstParameter[1].trim()
+                    }
+                    vmess.path = path
+                    vmess.requestHost = host
+                }
+            }
+            vmess.configVersion = 2
+            return 0
+        } catch (e: Exception) {
+            e.printStackTrace()
+            return -1
+        }
+    }
+
+    fun importBatchConfig(servers: String?, subid: String, append: Boolean): Int {
+        try {
+            if (servers == null) {
+                return 0
+            }
+            val removedSelectedServer =
+                    if (!TextUtils.isEmpty(subid) && !append) {
+                        MmkvManager.decodeServerConfig(mainStorage?.decodeString(KEY_SELECTED_SERVER) ?: "")?.let {
+                            if (it.subscriptionId == subid) {
+                                return@let it
+                            }
+                            return@let null
+                        }
+                    } else {
+                        null
+                    }
+            if(!append) {
+                MmkvManager.removeServerViaSubid(subid)
+            }
+//            var servers = server
+//            if (server.indexOf("vmess") >= 0 && server.indexOf("vmess") == server.lastIndexOf("vmess")) {
+//                servers = server.replace("\n", "")
+//            }
+
+            var count = 0
+            servers.lines()
+                    .forEach {
+                        val resId = importConfig(it, subid, removedSelectedServer)
+                        if (resId == 0) {
+                            count++
+                        }
+                    }
+            return count
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+        return 0
+    }
+}

V2rayNG/app/src/main/kotlin/com/v2ray/ang/util/AppManagerUtil.kt

@@ -0,0 +1,43 @@
+package com.v2ray.ang.util
+
+import android.Manifest
+import android.content.Context
+import android.content.pm.ApplicationInfo
+import android.content.pm.PackageInfo
+import android.content.pm.PackageManager
+import com.v2ray.ang.dto.AppInfo
+import rx.Observable
+import java.util.*
+
+object AppManagerUtil {
+    fun loadNetworkAppList(ctx: Context): ArrayList<AppInfo> {
+        val packageManager = ctx.packageManager
+        val packages = packageManager.getInstalledPackages(PackageManager.GET_PERMISSIONS)
+        val apps = ArrayList<AppInfo>()
+
+        for (pkg in packages) {
+            if (!pkg.hasInternetPermission && pkg.packageName != "android") continue
+
+            val applicationInfo = pkg.applicationInfo
+
+            val appName = applicationInfo.loadLabel(packageManager).toString()
+            val appIcon = applicationInfo.loadIcon(packageManager)
+            val isSystemApp = (applicationInfo.flags and ApplicationInfo.FLAG_SYSTEM) > 0
+
+            val appInfo = AppInfo(appName, pkg.packageName, appIcon, isSystemApp, 0)
+            apps.add(appInfo)
+        }
+
+        return apps
+    }
+
+    fun rxLoadNetworkAppList(ctx: Context): Observable<ArrayList<AppInfo>> = Observable.unsafeCreate {
+        it.onNext(loadNetworkAppList(ctx))
+    }
+
+    val PackageInfo.hasInternetPermission: Boolean
+        get() {
+            val permissions = requestedPermissions
+            return permissions?.any { it == Manifest.permission.INTERNET } ?: false
+        }
+}

V2rayNG/app/src/main/kotlin/com/v2ray/ang/util/MessageUtil.kt

@@ -0,0 +1,45 @@
+package com.v2ray.ang.util
+
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import com.v2ray.ang.AppConfig
+import com.v2ray.ang.service.V2RayTestService
+import java.io.Serializable
+
+
+object MessageUtil {
+
+    fun sendMsg2Service(ctx: Context, what: Int, content: Serializable) {
+        sendMsg(ctx, AppConfig.BROADCAST_ACTION_SERVICE, what, content)
+    }
+
+    fun sendMsg2UI(ctx: Context, what: Int, content: Serializable) {
+        sendMsg(ctx, AppConfig.BROADCAST_ACTION_ACTIVITY, what, content)
+    }
+
+    fun sendMsg2TestService(ctx: Context, what: Int, content: Serializable) {
+        try {
+            val intent = Intent()
+            intent.component = ComponentName(ctx, V2RayTestService::class.java)
+            intent.putExtra("key", what)
+            intent.putExtra("content", content)
+            ctx.startService(intent)
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+    }
+
+    private fun sendMsg(ctx: Context, action: String, what: Int, content: Serializable) {
+        try {
+            val intent = Intent()
+            intent.action = action
+            intent.`package` = AppConfig.ANG_PACKAGE
+            intent.putExtra("key", what)
+            intent.putExtra("content", content)
+            ctx.sendBroadcast(intent)
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+    }
+}

V2rayNG/app/src/main/kotlin/com/v2ray/ang/util/MmkvManager.kt

@@ -0,0 +1,179 @@
+package com.v2ray.ang.util
+
+import com.google.gson.Gson
+import com.tencent.mmkv.MMKV
+import com.v2ray.ang.dto.ServerAffiliationInfo
+import com.v2ray.ang.dto.ServerConfig
+import com.v2ray.ang.dto.SubscriptionItem
+
+object MmkvManager {
+    const val ID_MAIN = "MAIN"
+    const val ID_SERVER_CONFIG = "SERVER_CONFIG"
+    const val ID_SERVER_RAW = "SERVER_RAW"
+    const val ID_SERVER_AFF = "SERVER_AFF"
+    const val ID_SUB = "SUB"
+    const val ID_SETTING = "SETTING"
+    const val KEY_SELECTED_SERVER = "SELECTED_SERVER"
+    const val KEY_ANG_CONFIGS = "ANG_CONFIGS"
+
+    private val mainStorage by lazy { MMKV.mmkvWithID(ID_MAIN, MMKV.MULTI_PROCESS_MODE) }
+    private val serverStorage by lazy { MMKV.mmkvWithID(ID_SERVER_CONFIG, MMKV.MULTI_PROCESS_MODE) }
+    private val serverAffStorage by lazy { MMKV.mmkvWithID(ID_SERVER_AFF, MMKV.MULTI_PROCESS_MODE) }
+    private val subStorage by lazy { MMKV.mmkvWithID(ID_SUB, MMKV.MULTI_PROCESS_MODE) }
+
+    fun decodeServerList(): MutableList<String> {
+        val json = mainStorage?.decodeString(KEY_ANG_CONFIGS)
+        return if (json.isNullOrBlank()) {
+            mutableListOf()
+        } else {
+            Gson().fromJson(json, Array<String>::class.java).toMutableList()
+        }
+    }
+
+    fun decodeServerConfig(guid: String): ServerConfig? {
+        if (guid.isBlank()) {
+            return null
+        }
+        val json = serverStorage?.decodeString(guid)
+        if (json.isNullOrBlank()) {
+            return null
+        }
+        return Gson().fromJson(json, ServerConfig::class.java)
+    }
+
+    fun encodeServerConfig(guid: String, config: ServerConfig): String {
+        val key = guid.ifBlank { Utils.getUuid() }
+        serverStorage?.encode(key, Gson().toJson(config))
+        val serverList = decodeServerList()
+        if (!serverList.contains(key)) {
+            serverList.add(key)
+            mainStorage?.encode(KEY_ANG_CONFIGS, Gson().toJson(serverList))
+            if (mainStorage?.decodeString(KEY_SELECTED_SERVER).isNullOrBlank()) {
+                mainStorage?.encode(KEY_SELECTED_SERVER, key)
+            }
+        }
+        return key
+    }
+
+    fun removeServer(guid: String) {
+        if (guid.isBlank()) {
+            return
+        }
+        if (mainStorage?.decodeString(KEY_SELECTED_SERVER) == guid) {
+            mainStorage?.remove(KEY_SELECTED_SERVER)
+        }
+        val serverList = decodeServerList()
+        serverList.remove(guid)
+        mainStorage?.encode(KEY_ANG_CONFIGS, Gson().toJson(serverList))
+        serverStorage?.remove(guid)
+        serverAffStorage?.remove(guid)
+    }
+
+    fun removeServerViaSubid(subid: String) {
+        if (subid.isBlank()) {
+            return
+        }
+        serverStorage?.allKeys()?.forEach { key ->
+            decodeServerConfig(key)?.let { config ->
+                if (config.subscriptionId == subid) {
+                    removeServer(key)
+                }
+            }
+        }
+    }
+
+    fun decodeServerAffiliationInfo(guid: String): ServerAffiliationInfo? {
+        if (guid.isBlank()) {
+            return null
+        }
+        val json = serverAffStorage?.decodeString(guid)
+        if (json.isNullOrBlank()) {
+            return null
+        }
+        return Gson().fromJson(json, ServerAffiliationInfo::class.java)
+    }
+
+    fun encodeServerTestDelayMillis(guid: String, testResult: Long) {
+        if (guid.isBlank()) {
+            return
+        }
+        val aff = decodeServerAffiliationInfo(guid) ?: ServerAffiliationInfo()
+        aff.testDelayMillis = testResult
+        serverAffStorage?.encode(guid, Gson().toJson(aff))
+    }
+
+    fun clearAllTestDelayResults() {
+        serverAffStorage?.allKeys()?.forEach { key ->
+            decodeServerAffiliationInfo(key)?.let { aff ->
+                aff.testDelayMillis = 0
+                serverAffStorage?.encode(key, Gson().toJson(aff))
+            }
+        }
+    }
+
+    fun importUrlAsSubscription(url: String): Int {
+        val subscriptions = decodeSubscriptions()
+        subscriptions.forEach {
+            if (it.second.url == url) {
+                return 0
+            }
+        }
+        val subItem = SubscriptionItem()
+        subItem.remarks = "import sub"
+        subItem.url = url
+        subStorage?.encode(Utils.getUuid(), Gson().toJson(subItem))
+        return 1
+    }
+
+    fun decodeSubscriptions(): List<Pair<String, SubscriptionItem>> {
+        val subscriptions = mutableListOf<Pair<String, SubscriptionItem>>()
+        subStorage?.allKeys()?.forEach { key ->
+            val json = subStorage?.decodeString(key)
+            if (!json.isNullOrBlank()) {
+                subscriptions.add(Pair(key, Gson().fromJson(json, SubscriptionItem::class.java)))
+            }
+        }
+        subscriptions.sortedBy { (_, value) -> value.addedTime }
+        return subscriptions
+    }
+
+    fun removeSubscription(subid: String) {
+        subStorage?.remove(subid)
+        removeServerViaSubid(subid)
+    }
+
+    fun removeAllServer() {
+        mainStorage?.clearAll()
+        serverStorage?.clearAll()
+        serverAffStorage?.clearAll()
+    }
+
+    fun removeInvalidServer() {
+        serverAffStorage?.allKeys()?.forEach { key ->
+            decodeServerAffiliationInfo(key)?.let { aff ->
+                if (aff.testDelayMillis <= 0L) {
+                    removeServer(key)
+                }
+            }
+        }
+    }
+
+    fun sortByTestResults( ) {
+        data class ServerDelay(var guid: String, var testDelayMillis: Long)
+
+        val serverDelays = mutableListOf<ServerDelay>()
+        val serverList = decodeServerList()
+        serverList.forEach { key ->
+            val delay = decodeServerAffiliationInfo(key)?.testDelayMillis ?: 0L
+            serverDelays.add(ServerDelay(key, if (delay <= 0L) 999999 else delay))
+        }
+        serverDelays.sortBy { it.testDelayMillis }
+
+        serverDelays.forEach {
+            serverList.remove(it.guid)
+            serverList.add(it.guid)
+        }
+
+        mainStorage?.encode(KEY_ANG_CONFIGS, Gson().toJson(serverList))
+    }
+}

V2rayNG/app/src/main/kotlin/com/v2ray/ang/util/MyContextWrapper.kt

@@ -0,0 +1,33 @@
+package com.v2ray.ang.util
+
+import android.content.Context
+import android.content.ContextWrapper
+import android.content.res.Configuration
+import android.content.res.Resources
+import android.os.Build
+import android.os.LocaleList
+import androidx.annotation.RequiresApi
+import java.util.*
+
+open class MyContextWrapper(base: Context?) : ContextWrapper(base) {
+    companion object {
+        @RequiresApi(Build.VERSION_CODES.N)
+        fun wrap(context: Context, newLocale: Locale?): ContextWrapper {
+            var mContext = context
+            val res: Resources = mContext.resources
+            val configuration: Configuration = res.configuration
+            //注意 Android 7.0 前后的不同处理方法
+            mContext = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+                configuration.setLocale(newLocale)
+                val localeList = LocaleList(newLocale)
+                LocaleList.setDefault(localeList)
+                configuration.setLocales(localeList)
+                mContext.createConfigurationContext(configuration)
+            } else {
+                configuration.setLocale(newLocale)
+                mContext.createConfigurationContext(configuration)
+            }
+            return ContextWrapper(mContext)
+        }
+    }
+}

V2rayNG/app/src/main/kotlin/com/v2ray/ang/util/QRCodeDecoder.kt

@@ -0,0 +1,100 @@
+package com.v2ray.ang.util
+
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import com.google.zxing.*
+import com.google.zxing.common.GlobalHistogramBinarizer
+import com.google.zxing.common.HybridBinarizer
+import java.util.*
+
+/**
+ * 描述:解析二维码图片
+ */
+object QRCodeDecoder {
+    val HINTS: MutableMap<DecodeHintType, Any?> = EnumMap(DecodeHintType::class.java)
+
+    /**
+     * 同步解析本地图片二维码。该方法是耗时操作，请在子线程中调用。
+     *
+     * @param picturePath 要解析的二维码图片本地路径
+     * @return 返回二维码图片里的内容 或 null
+     */
+    fun syncDecodeQRCode(picturePath: String): String? {
+        return syncDecodeQRCode(getDecodeAbleBitmap(picturePath))
+    }
+
+    /**
+     * 同步解析bitmap二维码。该方法是耗时操作，请在子线程中调用。
+     *
+     * @param bitmap 要解析的二维码图片
+     * @return 返回二维码图片里的内容 或 null
+     */
+    fun syncDecodeQRCode(bitmap: Bitmap?): String? {
+        var source: RGBLuminanceSource? = null
+        try {
+            val width = bitmap!!.width
+            val height = bitmap.height
+            val pixels = IntArray(width * height)
+            bitmap.getPixels(pixels, 0, width, 0, 0, width, height)
+            source = RGBLuminanceSource(width, height, pixels)
+            return MultiFormatReader().decode(BinaryBitmap(HybridBinarizer(source)), HINTS).text
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+        if (source != null) {
+            try {
+                return MultiFormatReader().decode(BinaryBitmap(GlobalHistogramBinarizer(source)), HINTS).text
+            } catch (e2: Throwable) {
+                e2.printStackTrace()
+            }
+        }
+        return null
+    }
+
+    /**
+     * 将本地图片文件转换成可解码二维码的 Bitmap。为了避免图片太大，这里对图片进行了压缩。感谢 https://github.com/devilsen 提的 PR
+     *
+     * @param picturePath 本地图片文件路径
+     * @return
+     */
+    private fun getDecodeAbleBitmap(picturePath: String): Bitmap? {
+        return try {
+            val options = BitmapFactory.Options()
+            options.inJustDecodeBounds = true
+            BitmapFactory.decodeFile(picturePath, options)
+            var sampleSize = options.outHeight / 400
+            if (sampleSize <= 0) {
+                sampleSize = 1
+            }
+            options.inSampleSize = sampleSize
+            options.inJustDecodeBounds = false
+            BitmapFactory.decodeFile(picturePath, options)
+        } catch (e: Exception) {
+            null
+        }
+    }
+
+    init {
+        val allFormats: List<BarcodeFormat> = arrayListOf(
+                BarcodeFormat.AZTEC
+                ,BarcodeFormat.CODABAR
+                ,BarcodeFormat.CODE_39
+                ,BarcodeFormat.CODE_93
+                ,BarcodeFormat.CODE_128
+                ,BarcodeFormat.DATA_MATRIX
+                ,BarcodeFormat.EAN_8
+                ,BarcodeFormat.EAN_13
+                ,BarcodeFormat.ITF
+                ,BarcodeFormat.MAXICODE
+                ,BarcodeFormat.PDF_417
+                ,BarcodeFormat.QR_CODE
+                ,BarcodeFormat.RSS_14
+                ,BarcodeFormat.RSS_EXPANDED
+                ,BarcodeFormat.UPC_A
+                ,BarcodeFormat.UPC_E
+                ,BarcodeFormat.UPC_EAN_EXTENSION)
+        HINTS[DecodeHintType.TRY_HARDER] = BarcodeFormat.QR_CODE
+        HINTS[DecodeHintType.POSSIBLE_FORMATS] = allFormats
+        HINTS[DecodeHintType.CHARACTER_SET] = "utf-8"
+    }
+}

V2rayNG/app/src/main/kotlin/com/v2ray/ang/util/SpeedtestUtil.kt

@@ -0,0 +1,142 @@
+package com.v2ray.ang.util
+
+import android.content.Context
+import android.os.SystemClock
+import android.text.TextUtils
+import android.util.Log
+import com.v2ray.ang.AppConfig
+import com.v2ray.ang.R
+import com.v2ray.ang.extension.responseLength
+import kotlinx.coroutines.isActive
+import libv2ray.Libv2ray
+import java.io.IOException
+import java.net.*
+import java.util.*
+import kotlin.coroutines.coroutineContext
+
+object SpeedtestUtil {
+
+    private val tcpTestingSockets = ArrayList<Socket?>()
+
+    suspend fun tcping(url: String, port: Int): Long {
+        var time = -1L
+        for (k in 0 until 2) {
+            val one = socketConnectTime(url, port)
+            if (!coroutineContext.isActive) {
+                break
+            }
+            if (one != -1L && (time == -1L || one < time)) {
+                time = one
+            }
+        }
+        return time
+    }
+
+    fun realPing(config: String): Long {
+        return try {
+            Libv2ray.measureOutboundDelay(config)
+        } catch (e: Exception) {
+            Log.d(AppConfig.ANG_PACKAGE, "realPing: $e")
+            -1L
+        }
+    }
+
+    fun ping(url: String): String {
+        try {
+            val command = "/system/bin/ping -c 3 $url"
+            val process = Runtime.getRuntime().exec(command)
+            val allText = process.inputStream.bufferedReader().use { it.readText() }
+            if (!TextUtils.isEmpty(allText)) {
+                val tempInfo = allText.substring(allText.indexOf("min/avg/max/mdev") + 19)
+                val temps = tempInfo.split("/".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
+                if (temps.count() > 0 && temps[0].length < 10) {
+                    return temps[0].toFloat().toInt().toString() + "ms"
+                }
+            }
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+        return "-1ms"
+    }
+
+    fun socketConnectTime(url: String, port: Int): Long {
+        try {
+            val socket = Socket()
+            synchronized(this) {
+                tcpTestingSockets.add(socket)
+            }
+            val start = System.currentTimeMillis()
+            socket.connect(InetSocketAddress(url, port),3000)
+            val time = System.currentTimeMillis() - start
+            synchronized(this) {
+                tcpTestingSockets.remove(socket)
+            }
+            socket.close()
+            return time
+        } catch (e: UnknownHostException) {
+            e.printStackTrace()
+        } catch (e: IOException) {
+            Log.d(AppConfig.ANG_PACKAGE, "socketConnectTime IOException: $e")
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+        return -1
+    }
+
+    fun closeAllTcpSockets() {
+        synchronized(this) {
+            tcpTestingSockets.forEach {
+                it?.close()
+            }
+            tcpTestingSockets.clear()
+        }
+    }
+
+    fun testConnection(context: Context, port: Int): String {
+        // return V2RayVpnService.measureV2rayDelay()
+        var result: String
+        var conn: HttpURLConnection? = null
+
+        try {
+            val url = URL("https",
+                    "www.google.com",
+                    "/generate_204")
+
+            conn = url.openConnection(
+                    Proxy(Proxy.Type.HTTP,
+                            InetSocketAddress("127.0.0.1", port))) as HttpURLConnection
+            conn.connectTimeout = 30000
+            conn.readTimeout = 30000
+            conn.setRequestProperty("Connection", "close")
+            conn.instanceFollowRedirects = false
+            conn.useCaches = false
+
+            val start = SystemClock.elapsedRealtime()
+            val code = conn.responseCode
+            val elapsed = SystemClock.elapsedRealtime() - start
+
+            if (code == 204 || code == 200 && conn.responseLength == 0L) {
+                result = context.getString(R.string.connection_test_available, elapsed)
+            } else {
+                throw IOException(context.getString(R.string.connection_test_error_status_code, code))
+            }
+        } catch (e: IOException) {
+            // network exception
+            Log.d(AppConfig.ANG_PACKAGE, "testConnection IOException: " + Log.getStackTraceString(e))
+            result = context.getString(R.string.connection_test_error, e.message)
+        } catch (e: Exception) {
+            // library exception, eg sumsung
+            Log.d(AppConfig.ANG_PACKAGE, "testConnection Exception: " + Log.getStackTraceString(e))
+            result = context.getString(R.string.connection_test_error, e.message)
+        } finally {
+            conn?.disconnect()
+        }
+
+        return result
+    }
+
+    fun getLibVersion(): String {
+        return Libv2ray.checkVersionX()
+    }
+
+}

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

@@ -0,0 +1,439 @@
+package com.v2ray.ang.util
+
+import android.content.ClipboardManager
+import android.content.Context
+import android.text.Editable
+import android.util.Base64
+import com.google.zxing.WriterException
+import android.graphics.Bitmap
+import com.google.zxing.BarcodeFormat
+import com.google.zxing.qrcode.QRCodeWriter
+import com.google.zxing.EncodeHintType
+import java.util.*
+import kotlin.collections.HashMap
+import android.content.ClipData
+import android.content.Intent
+import android.content.res.Configuration.UI_MODE_NIGHT_MASK
+import android.content.res.Configuration.UI_MODE_NIGHT_YES
+import android.net.Uri
+import android.os.Build
+import android.os.LocaleList
+import android.util.Log
+import android.util.Patterns
+import android.webkit.URLUtil
+import com.tencent.mmkv.MMKV
+import com.v2ray.ang.AppConfig
+import com.v2ray.ang.AppConfig.ANG_PACKAGE
+import com.v2ray.ang.BuildConfig
+import com.v2ray.ang.R
+import com.v2ray.ang.extension.toast
+import java.net.*
+import com.v2ray.ang.service.V2RayServiceManager
+import java.io.IOException
+
+object Utils {
+
+    private val mainStorage by lazy { MMKV.mmkvWithID(MmkvManager.ID_MAIN, MMKV.MULTI_PROCESS_MODE) }
+    private val settingsStorage by lazy { MMKV.mmkvWithID(MmkvManager.ID_SETTING, MMKV.MULTI_PROCESS_MODE) }
+
+    /**
+     * convert string to editalbe for kotlin
+     *
+     * @param text
+     * @return
+     */
+    fun getEditable(text: String): Editable {
+        return Editable.Factory.getInstance().newEditable(text)
+    }
+
+    /**
+     * find value in array position
+     */
+    fun arrayFind(array: Array<out String>, value: String): Int {
+        for (i in array.indices) {
+            if (array[i] == value) {
+                return i
+            }
+        }
+        return -1
+    }
+
+    /**
+     * parseInt
+     */
+    fun parseInt(str: String): Int {
+        return parseInt(str, 0)
+    }
+
+    fun parseInt(str: String?, default: Int): Int {
+        str ?: return default
+        return try {
+            Integer.parseInt(str)
+        } catch (e: Exception) {
+            e.printStackTrace()
+            default
+        }
+    }
+
+    /**
+     * get text from clipboard
+     */
+    fun getClipboard(context: Context): String {
+        return try {
+            val cmb = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
+            cmb.primaryClip?.getItemAt(0)?.text.toString()
+        } catch (e: Exception) {
+            e.printStackTrace()
+            ""
+        }
+    }
+
+    /**
+     * set text to clipboard
+     */
+    fun setClipboard(context: Context, content: String) {
+        try {
+            val cmb = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
+            val clipData = ClipData.newPlainText(null, content)
+            cmb.setPrimaryClip(clipData)
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+    }
+
+    /**
+     * base64 decode
+     */
+    fun decode(text: String): String {
+        tryDecodeBase64(text)?.let { return it }
+        if (text.endsWith('=')) {
+            // try again for some loosely formatted base64
+            tryDecodeBase64(text.trimEnd('='))?.let { return it }
+        }
+        return ""
+    }
+
+    fun tryDecodeBase64(text: String): String? {
+        try {
+            return Base64.decode(text, Base64.NO_WRAP).toString(charset("UTF-8"))
+        } catch (e: Exception) {
+            Log.i(ANG_PACKAGE, "Parse base64 standard failed $e")
+        }
+        try {
+            return Base64.decode(text, Base64.NO_WRAP.or(Base64.URL_SAFE)).toString(charset("UTF-8"))
+        } catch (e: Exception) {
+            Log.i(ANG_PACKAGE, "Parse base64 url safe failed $e")
+        }
+        return null
+    }
+
+    /**
+     * base64 encode
+     */
+    fun encode(text: String): String {
+        return try {
+            Base64.encodeToString(text.toByteArray(charset("UTF-8")), Base64.NO_WRAP)
+        } catch (e: Exception) {
+            e.printStackTrace()
+            ""
+        }
+    }
+
+    /**
+     * get remote dns servers from preference
+     */
+    fun getRemoteDnsServers(): List<String> {
+        val remoteDns = settingsStorage?.decodeString(AppConfig.PREF_REMOTE_DNS) ?: AppConfig.DNS_AGENT
+        val ret = remoteDns.split(",").filter { isPureIpAddress(it) || isCoreDNSAddress(it) }
+        if (ret.isEmpty()) {
+            return listOf(AppConfig.DNS_AGENT)
+        }
+        return ret
+    }
+
+    fun getVpnDnsServers(): List<String> {
+        val vpnDns = settingsStorage?.decodeString(AppConfig.PREF_VPN_DNS)
+                ?: settingsStorage?.decodeString(AppConfig.PREF_REMOTE_DNS)
+                ?: AppConfig.DNS_AGENT
+        return vpnDns.split(",").filter { isPureIpAddress(it) }
+        // allow empty, in that case dns will use system default
+    }
+
+    /**
+     * get remote dns servers from preference
+     */
+    fun getDomesticDnsServers(): List<String> {
+        val domesticDns = settingsStorage?.decodeString(AppConfig.PREF_DOMESTIC_DNS) ?: AppConfig.DNS_DIRECT
+        val ret = domesticDns.split(",").filter { isPureIpAddress(it) || isCoreDNSAddress(it) }
+        if (ret.isEmpty()) {
+            return listOf(AppConfig.DNS_DIRECT)
+        }
+        return ret
+    }
+
+    /**
+     * create qrcode using zxing
+     */
+    fun createQRCode(text: String, size: Int = 800): Bitmap? {
+        try {
+            val hints = HashMap<EncodeHintType, String>()
+            hints[EncodeHintType.CHARACTER_SET] = "utf-8"
+            val bitMatrix = QRCodeWriter().encode(text,
+                    BarcodeFormat.QR_CODE, size, size, hints)
+            val pixels = IntArray(size * size)
+            for (y in 0 until size) {
+                for (x in 0 until size) {
+                    if (bitMatrix.get(x, y)) {
+                        pixels[y * size + x] = 0xff000000.toInt()
+                    } else {
+                        pixels[y * size + x] = 0xffffffff.toInt()
+                    }
+
+                }
+            }
+            val bitmap = Bitmap.createBitmap(size, size,
+                    Bitmap.Config.ARGB_8888)
+            bitmap.setPixels(pixels, 0, size, 0, 0, size, size)
+            return bitmap
+        } catch (e: WriterException) {
+            e.printStackTrace()
+            return null
+        }
+    }
+
+    /**
+     * is ip address
+     */
+    fun isIpAddress(value: String): Boolean {
+        try {
+            var addr = value
+            if (addr.isEmpty() || addr.isBlank()) {
+                return false
+            }
+            //CIDR
+            if (addr.indexOf("/") > 0) {
+                val arr = addr.split("/")
+                if (arr.count() == 2 && Integer.parseInt(arr[1]) > 0) {
+                    addr = arr[0]
+                }
+            }
+
+            // "::ffff:192.168.173.22"
+            // "[::ffff:192.168.173.22]:80"
+            if (addr.startsWith("::ffff:") && '.' in addr) {
+                addr = addr.drop(7)
+            } else if (addr.startsWith("[::ffff:") && '.' in addr) {
+                addr = addr.drop(8).replace("]", "")
+            }
+
+            // addr = addr.toLowerCase()
+            val octets = addr.split('.').toTypedArray()
+            if (octets.size == 4) {
+                if (octets[3].indexOf(":") > 0) {
+                    addr = addr.substring(0, addr.indexOf(":"))
+                }
+                return isIpv4Address(addr)
+            }
+
+            // Ipv6addr [2001:abc::123]:8080
+            return isIpv6Address(addr)
+        } catch (e: Exception) {
+            e.printStackTrace()
+            return false
+        }
+    }
+
+    fun isPureIpAddress(value: String): Boolean {
+        return (isIpv4Address(value) || isIpv6Address(value))
+    }
+
+    fun isIpv4Address(value: String): Boolean {
+        val regV4 = Regex("^([01]?[0-9]?[0-9]|2[0-4][0-9]|25[0-5])\\.([01]?[0-9]?[0-9]|2[0-4][0-9]|25[0-5])\\.([01]?[0-9]?[0-9]|2[0-4][0-9]|25[0-5])\\.([01]?[0-9]?[0-9]|2[0-4][0-9]|25[0-5])$")
+        return regV4.matches(value)
+    }
+
+    fun isIpv6Address(value: String): Boolean {
+        var addr = value
+        if (addr.indexOf("[") == 0 && addr.lastIndexOf("]") > 0) {
+            addr = addr.drop(1)
+            addr = addr.dropLast(addr.count() - addr.lastIndexOf("]"))
+        }
+        val regV6 = Regex("^((?:[0-9A-Fa-f]{1,4}))?((?::[0-9A-Fa-f]{1,4}))*::((?:[0-9A-Fa-f]{1,4}))?((?::[0-9A-Fa-f]{1,4}))*|((?:[0-9A-Fa-f]{1,4}))((?::[0-9A-Fa-f]{1,4})){7}$")
+        return regV6.matches(addr)
+    }
+
+    private fun isCoreDNSAddress(s: String): Boolean {
+        return s.startsWith("https") || s.startsWith("tcp") || s.startsWith("quic")
+    }
+
+    /**
+     * is valid url
+     */
+    fun isValidUrl(value: String?): Boolean {
+        try {
+            if (value != null && Patterns.WEB_URL.matcher(value).matches() || URLUtil.isValidUrl(value)) {
+                return true
+            }
+        } catch (e: WriterException) {
+            e.printStackTrace()
+            return false
+        }
+        return false
+    }
+
+    fun startVServiceFromToggle(context: Context): Boolean {
+        if (mainStorage?.decodeString(MmkvManager.KEY_SELECTED_SERVER).isNullOrEmpty()) {
+            context.toast(R.string.app_tile_first_use)
+            return false
+        }
+        V2RayServiceManager.startV2Ray(context)
+        return true
+    }
+
+    /**
+     * stopVService
+     */
+    fun stopVService(context: Context) {
+        context.toast(R.string.toast_services_stop)
+        MessageUtil.sendMsg2Service(context, AppConfig.MSG_STATE_STOP, "")
+    }
+
+    fun openUri(context: Context, uriString: String) {
+        val uri = Uri.parse(uriString)
+        context.startActivity(Intent(Intent.ACTION_VIEW, uri))
+    }
+
+    /**
+     * uuid
+     */
+    fun getUuid(): String {
+        return try {
+            UUID.randomUUID().toString().replace("-", "")
+        } catch (e: Exception) {
+            e.printStackTrace()
+            ""
+        }
+    }
+
+    fun urlDecode(url: String): String {
+        return try {
+            URLDecoder.decode(URLDecoder.decode(url), "utf-8")
+        } catch (e: Exception) {
+            e.printStackTrace()
+            url
+        }
+    }
+
+    fun urlEncode(url: String): String {
+        return try {
+            URLEncoder.encode(url, "UTF-8")
+        } catch (e: Exception) {
+            e.printStackTrace()
+            url
+        }
+    }
+
+
+    /**
+     * readTextFromAssets
+     */
+    fun readTextFromAssets(context: Context, fileName: String): String {
+        val content = context.assets.open(fileName).bufferedReader().use {
+            it.readText()
+        }
+        return content
+    }
+
+    fun userAssetPath(context: Context?): String {
+        if (context == null)
+            return ""
+        val extDir = context.getExternalFilesDir(AppConfig.DIR_ASSETS)
+                ?: return context.getDir(AppConfig.DIR_ASSETS, 0).absolutePath
+        return extDir.absolutePath
+    }
+
+    fun getUrlContext(url: String, timeout: Int): String {
+        var result: String
+        var conn: HttpURLConnection? = null
+
+        try {
+            conn = URL(url).openConnection() as HttpURLConnection
+            conn.connectTimeout = timeout
+            conn.readTimeout = timeout
+            conn.setRequestProperty("Connection", "close")
+            conn.instanceFollowRedirects = false
+            conn.useCaches = false
+            //val code = conn.responseCode
+            result = conn.inputStream.bufferedReader().readText()
+        } catch (e: Exception) {
+            result = ""
+        } finally {
+            conn?.disconnect()
+        }
+        return result
+    }
+
+    @Throws(IOException::class)
+    fun getUrlContentWithCustomUserAgent(urlStr: String?): String {
+        val url = URL(urlStr)
+        val conn = url.openConnection()
+        conn.setRequestProperty("Connection", "close")
+        conn.setRequestProperty("User-agent", "v2rayNG/${BuildConfig.VERSION_NAME}")
+        url.userInfo?.let {
+            conn.setRequestProperty("Authorization",
+                "Basic ${encode(urlDecode(it))}")
+        }
+        conn.useCaches = false
+        return conn.inputStream.use {
+            it.bufferedReader().readText()
+        }
+    }
+
+    fun getDarkModeStatus(context: Context): Boolean {
+        val mode = context.resources.configuration.uiMode and UI_MODE_NIGHT_MASK
+        return mode == UI_MODE_NIGHT_YES
+    }
+
+    fun getIpv6Address(address: String): String {
+        return if (isIpv6Address(address)) {
+            String.format("[%s]", address)
+        } else {
+            address
+        }
+    }
+
+    fun getLocale(context: Context): Locale =
+        when (settingsStorage?.decodeString(AppConfig.PREF_LANGUAGE) ?: "auto") {
+            "auto" ->  getSysLocale()
+            "en" -> Locale("en")
+            "zh-rCN" -> Locale("zh", "CN")
+            "zh-rTW" -> Locale("zh", "TW")
+            "vi" -> Locale("vi")
+            "ru" -> Locale("ru")
+            "fa" -> Locale("fa")
+            else -> getSysLocale()
+        }
+
+    private fun getSysLocale(): Locale = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+        LocaleList.getDefault()[0]
+    } else {
+        Locale.getDefault()
+    }
+
+    fun fixIllegalUrl(str: String): String {
+        return str
+            .replace(" ","%20")
+            .replace("|","%7C")
+    }
+
+    fun removeWhiteSpace(str: String?): String? {
+        return str?.replace(" ", "")
+    }
+
+    fun idnToASCII(str: String): String {
+        val url = URL(str)
+        return URL(url.protocol, IDN.toASCII(url.host, IDN.ALLOW_UNASSIGNED), url.port, url.file)
+            .toExternalForm()
+    }
+}
+

V2rayNG/app/src/main/kotlin/com/v2ray/ang/util/V2rayConfigUtil.kt

@@ -0,0 +1,432 @@
+package com.v2ray.ang.util
+
+import android.content.Context
+import android.text.TextUtils
+import android.util.Log
+import com.google.gson.*
+import com.tencent.mmkv.MMKV
+import com.v2ray.ang.AppConfig
+import com.v2ray.ang.AppConfig.ANG_PACKAGE
+import com.v2ray.ang.dto.V2rayConfig
+import com.v2ray.ang.dto.EConfigType
+import com.v2ray.ang.dto.ERoutingMode
+import com.v2ray.ang.dto.V2rayConfig.Companion.DEFAULT_NETWORK
+import com.v2ray.ang.dto.V2rayConfig.Companion.HTTP
+
+object V2rayConfigUtil {
+    private val serverRawStorage by lazy { MMKV.mmkvWithID(MmkvManager.ID_SERVER_RAW, MMKV.MULTI_PROCESS_MODE) }
+    private val settingsStorage by lazy { MMKV.mmkvWithID(MmkvManager.ID_SETTING, MMKV.MULTI_PROCESS_MODE) }
+
+    data class Result(var status: Boolean, var content: String)
+
+    /**
+     * 生成v2ray的客户端配置文件
+     */
+    fun getV2rayConfig(context: Context, guid: String): Result {
+        try {
+            val config = MmkvManager.decodeServerConfig(guid) ?: return Result(false, "")
+            if (config.configType == EConfigType.CUSTOM) {
+                val raw = serverRawStorage?.decodeString(guid)
+                val customConfig = if (raw.isNullOrBlank()) {
+                    config.fullConfig?.toPrettyPrinting() ?: return Result(false, "")
+                } else {
+                    raw
+                }
+                Log.d(ANG_PACKAGE, customConfig)
+                return Result(true, customConfig)
+            }
+            val outbound = config.getProxyOutbound() ?: return Result(false, "")
+            val result = getV2rayNonCustomConfig(context, outbound)
+            Log.d(ANG_PACKAGE, result.content)
+            return result
+        } catch (e: Exception) {
+            e.printStackTrace()
+            return Result(false, "")
+        }
+    }
+
+    /**
+     * 生成v2ray的客户端配置文件
+     */
+    private fun getV2rayNonCustomConfig(context: Context, outbound: V2rayConfig.OutboundBean): Result {
+        val result = Result(false, "")
+        //取得默认配置
+        val assets = Utils.readTextFromAssets(context, "v2ray_config.json")
+        if (TextUtils.isEmpty(assets)) {
+            return result
+        }
+
+        //转成Json
+        val v2rayConfig = Gson().fromJson(assets, V2rayConfig::class.java) ?: return result
+
+        v2rayConfig.log.loglevel = settingsStorage?.decodeString(AppConfig.PREF_LOGLEVEL)
+                ?: "warning"
+
+        inbounds(v2rayConfig)
+
+        httpRequestObject(outbound)
+
+        v2rayConfig.outbounds[0] = outbound
+
+        routing(v2rayConfig)
+
+        fakedns(v2rayConfig)
+
+        dns(v2rayConfig)
+
+        if (settingsStorage?.decodeBool(AppConfig.PREF_LOCAL_DNS_ENABLED) == true) {
+            customLocalDns(v2rayConfig)
+        }
+        if (settingsStorage?.decodeBool(AppConfig.PREF_SPEED_ENABLED) != true) {
+            v2rayConfig.stats = null
+            v2rayConfig.policy = null
+        }
+        result.status = true
+        result.content = v2rayConfig.toPrettyPrinting()
+        return result
+    }
+
+    /**
+     *
+     */
+    private fun inbounds(v2rayConfig: V2rayConfig): Boolean {
+        try {
+            val socksPort = Utils.parseInt(settingsStorage?.decodeString(AppConfig.PREF_SOCKS_PORT), AppConfig.PORT_SOCKS.toInt())
+            val httpPort = Utils.parseInt(settingsStorage?.decodeString(AppConfig.PREF_HTTP_PORT), AppConfig.PORT_HTTP.toInt())
+
+            v2rayConfig.inbounds.forEach { curInbound ->
+                if (settingsStorage?.decodeBool(AppConfig.PREF_PROXY_SHARING) != true) {
+                    //bind all inbounds to localhost if the user requests
+                    curInbound.listen = "127.0.0.1"
+                }
+            }
+            v2rayConfig.inbounds[0].port = socksPort
+            val fakedns = settingsStorage?.decodeBool(AppConfig.PREF_FAKE_DNS_ENABLED)
+                    ?: false
+            val sniffAllTlsAndHttp = settingsStorage?.decodeBool(AppConfig.PREF_SNIFFING_ENABLED, true)
+                    ?: true
+            v2rayConfig.inbounds[0].sniffing?.enabled = fakedns || sniffAllTlsAndHttp
+            if (!sniffAllTlsAndHttp) {
+                v2rayConfig.inbounds[0].sniffing?.destOverride?.clear()
+            }
+            if (fakedns) {
+                v2rayConfig.inbounds[0].sniffing?.destOverride?.add("fakedns")
+            }
+
+            v2rayConfig.inbounds[1].port = httpPort
+
+//            if (httpPort > 0) {
+//                val httpCopy = v2rayConfig.inbounds[0].copy()
+//                httpCopy.port = httpPort
+//                httpCopy.protocol = "http"
+//                v2rayConfig.inbounds.add(httpCopy)
+//            }
+        } catch (e: Exception) {
+            e.printStackTrace()
+            return false
+        }
+        return true
+    }
+
+    private fun fakedns(v2rayConfig: V2rayConfig) {
+        if (settingsStorage?.decodeBool(AppConfig.PREF_FAKE_DNS_ENABLED) == true) {
+            v2rayConfig.fakedns = listOf(V2rayConfig.FakednsBean())
+            v2rayConfig.outbounds.filter { it.protocol == "freedom" }.forEach {
+                it.settings?.domainStrategy = "UseIP"
+            }
+        }
+    }
+
+    /**
+     * routing
+     */
+    private fun routing(v2rayConfig: V2rayConfig): Boolean {
+        try {
+            routingUserRule(settingsStorage?.decodeString(AppConfig.PREF_V2RAY_ROUTING_AGENT)
+                    ?: "", AppConfig.TAG_AGENT, v2rayConfig)
+            routingUserRule(settingsStorage?.decodeString(AppConfig.PREF_V2RAY_ROUTING_DIRECT)
+                    ?: "", AppConfig.TAG_DIRECT, v2rayConfig)
+            routingUserRule(settingsStorage?.decodeString(AppConfig.PREF_V2RAY_ROUTING_BLOCKED)
+                    ?: "", AppConfig.TAG_BLOCKED, v2rayConfig)
+
+            v2rayConfig.routing.domainStrategy = settingsStorage?.decodeString(AppConfig.PREF_ROUTING_DOMAIN_STRATEGY)
+                    ?: "IPIfNonMatch"
+            v2rayConfig.routing.domainMatcher = "mph"
+            val routingMode = settingsStorage?.decodeString(AppConfig.PREF_ROUTING_MODE) ?: ERoutingMode.GLOBAL_PROXY.value
+
+            // Hardcode googleapis.cn
+            val googleapisRoute = V2rayConfig.RoutingBean.RulesBean(
+                    type = "field",
+                    outboundTag = AppConfig.TAG_AGENT,
+                    domain = arrayListOf("domain:googleapis.cn")
+            )
+
+            when (routingMode) {
+                ERoutingMode.BYPASS_LAN.value -> {
+                    routingGeo("ip", "private", AppConfig.TAG_DIRECT, v2rayConfig)
+                }
+                ERoutingMode.BYPASS_MAINLAND.value -> {
+                    routingGeo("", "cn", AppConfig.TAG_DIRECT, v2rayConfig)
+                    v2rayConfig.routing.rules.add(0, googleapisRoute)
+                }
+                ERoutingMode.BYPASS_LAN_MAINLAND.value -> {
+                    routingGeo("ip", "private", AppConfig.TAG_DIRECT, v2rayConfig)
+                    routingGeo("", "cn", AppConfig.TAG_DIRECT, v2rayConfig)
+                    v2rayConfig.routing.rules.add(0, googleapisRoute)
+                }
+                ERoutingMode.GLOBAL_DIRECT.value -> {
+                    val globalDirect = V2rayConfig.RoutingBean.RulesBean(
+                        type = "field",
+                        outboundTag = AppConfig.TAG_DIRECT,
+                        port = "0-65535"
+                    )
+                    v2rayConfig.routing.rules.add(globalDirect)
+                }
+            }
+        } catch (e: Exception) {
+            e.printStackTrace()
+            return false
+        }
+        return true
+    }
+
+    private fun routingGeo(ipOrDomain: String, code: String, tag: String, v2rayConfig: V2rayConfig) {
+        try {
+            if (!TextUtils.isEmpty(code)) {
+                //IP
+                if (ipOrDomain == "ip" || ipOrDomain == "") {
+                    val rulesIP = V2rayConfig.RoutingBean.RulesBean()
+                    rulesIP.type = "field"
+                    rulesIP.outboundTag = tag
+                    rulesIP.ip = ArrayList()
+                    rulesIP.ip?.add("geoip:$code")
+                    v2rayConfig.routing.rules.add(rulesIP)
+                }
+
+                if (ipOrDomain == "domain" || ipOrDomain == "") {
+                    //Domain
+                    val rulesDomain = V2rayConfig.RoutingBean.RulesBean()
+                    rulesDomain.type = "field"
+                    rulesDomain.outboundTag = tag
+                    rulesDomain.domain = ArrayList()
+                    rulesDomain.domain?.add("geosite:$code")
+                    v2rayConfig.routing.rules.add(rulesDomain)
+                }
+            }
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+    }
+
+    private fun routingUserRule(userRule: String, tag: String, v2rayConfig: V2rayConfig) {
+        try {
+            if (!TextUtils.isEmpty(userRule)) {
+                //Domain
+                val rulesDomain = V2rayConfig.RoutingBean.RulesBean()
+                rulesDomain.type = "field"
+                rulesDomain.outboundTag = tag
+                rulesDomain.domain = ArrayList()
+
+                //IP
+                val rulesIP = V2rayConfig.RoutingBean.RulesBean()
+                rulesIP.type = "field"
+                rulesIP.outboundTag = tag
+                rulesIP.ip = ArrayList()
+
+                userRule.split(",").map { it.trim() }.forEach {
+                    if (Utils.isIpAddress(it) || it.startsWith("geoip:")) {
+                        rulesIP.ip?.add(it)
+                    } else if (it.isNotEmpty())
+//                                if (Utils.isValidUrl(it)
+//                                    || it.startsWith("geosite:")
+//                                    || it.startsWith("regexp:")
+//                                    || it.startsWith("domain:")
+//                                    || it.startsWith("full:"))
+                    {
+                        rulesDomain.domain?.add(it)
+                    }
+                }
+                if (rulesDomain.domain?.size!! > 0) {
+                    v2rayConfig.routing.rules.add(rulesDomain)
+                }
+                if (rulesIP.ip?.size!! > 0) {
+                    v2rayConfig.routing.rules.add(rulesIP)
+                }
+            }
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+    }
+
+    private fun userRule2Domian(userRule: String): ArrayList<String> {
+        val domain = ArrayList<String>()
+        userRule.split(",").map { it.trim() }.forEach {
+            if (it.startsWith("geosite:") || it.startsWith("domain:")) {
+                domain.add(it)
+            }
+        }
+        return domain
+    }
+
+    /**
+     * Custom Dns
+     */
+    private fun customLocalDns(v2rayConfig: V2rayConfig): Boolean {
+        try {
+            if (settingsStorage?.decodeBool(AppConfig.PREF_FAKE_DNS_ENABLED) == true) {
+                val geositeCn = arrayListOf("geosite:cn")
+                val proxyDomain = userRule2Domian(settingsStorage?.decodeString(AppConfig.PREF_V2RAY_ROUTING_AGENT)
+                        ?: "")
+                val directDomain = userRule2Domian(settingsStorage?.decodeString(AppConfig.PREF_V2RAY_ROUTING_DIRECT)
+                        ?: "")
+                // fakedns with all domains to make it always top priority
+                v2rayConfig.dns.servers?.add(0,
+                        V2rayConfig.DnsBean.ServersBean(address = "fakedns", domains = geositeCn.plus(proxyDomain).plus(directDomain)))
+            }
+
+            // DNS inbound对象
+            val remoteDns = Utils.getRemoteDnsServers()
+            if (v2rayConfig.inbounds.none { e -> e.protocol == "dokodemo-door" && e.tag == "dns-in" }) {
+                val dnsInboundSettings = V2rayConfig.InboundBean.InSettingsBean(
+                        address = if (Utils.isPureIpAddress(remoteDns.first())) remoteDns.first() else "1.1.1.1",
+                        port = 53,
+                        network = "tcp,udp")
+
+                val localDnsPort = Utils.parseInt(settingsStorage?.decodeString(AppConfig.PREF_LOCAL_DNS_PORT), AppConfig.PORT_LOCAL_DNS.toInt())
+                v2rayConfig.inbounds.add(
+                        V2rayConfig.InboundBean(
+                                tag = "dns-in",
+                                port = localDnsPort,
+                                listen = "127.0.0.1",
+                                protocol = "dokodemo-door",
+                                settings = dnsInboundSettings,
+                                sniffing = null))
+            }
+
+            // DNS outbound对象
+            if (v2rayConfig.outbounds.none { e -> e.protocol == "dns" && e.tag == "dns-out" }) {
+                v2rayConfig.outbounds.add(
+                        V2rayConfig.OutboundBean(
+                                protocol = "dns",
+                                tag = "dns-out",
+                                settings = null,
+                                streamSettings = null,
+                                mux = null))
+            }
+
+            // DNS routing tag
+            v2rayConfig.routing.rules.add(0, V2rayConfig.RoutingBean.RulesBean(
+                    type = "field",
+                    inboundTag = arrayListOf("dns-in"),
+                    outboundTag = "dns-out",
+                    domain = null)
+            )
+        } catch (e: Exception) {
+            e.printStackTrace()
+            return false
+        }
+        return true
+    }
+
+    private fun dns(v2rayConfig: V2rayConfig): Boolean {
+        try {
+            val hosts = mutableMapOf<String, String>()
+            val servers = ArrayList<Any>()
+            val remoteDns = Utils.getRemoteDnsServers()
+            val proxyDomain = userRule2Domian(settingsStorage?.decodeString(AppConfig.PREF_V2RAY_ROUTING_AGENT)
+                    ?: "")
+
+            remoteDns.forEach {
+                servers.add(it)
+            }
+            if (proxyDomain.size > 0) {
+                servers.add(V2rayConfig.DnsBean.ServersBean(remoteDns.first(), 53, proxyDomain, null))
+            }
+
+            // domestic DNS
+            val directDomain = userRule2Domian(settingsStorage?.decodeString(AppConfig.PREF_V2RAY_ROUTING_DIRECT)
+                    ?: "")
+            val routingMode = settingsStorage?.decodeString(AppConfig.PREF_ROUTING_MODE) ?: ERoutingMode.GLOBAL_PROXY.value
+            if (directDomain.size > 0 || routingMode == ERoutingMode.BYPASS_MAINLAND.value || routingMode == ERoutingMode.BYPASS_LAN_MAINLAND.value) {
+                val domesticDns = Utils.getDomesticDnsServers()
+                val geositeCn = arrayListOf("geosite:cn")
+                val geoipCn = arrayListOf("geoip:cn")
+                if (directDomain.size > 0) {
+                    servers.add(V2rayConfig.DnsBean.ServersBean(domesticDns.first(), 53, directDomain, geoipCn))
+                }
+                if (routingMode == ERoutingMode.BYPASS_MAINLAND.value || routingMode == ERoutingMode.BYPASS_LAN_MAINLAND.value) {
+                    servers.add(V2rayConfig.DnsBean.ServersBean(domesticDns.first(), 53, geositeCn, geoipCn))
+                }
+                if (Utils.isPureIpAddress(domesticDns.first())) {
+                    v2rayConfig.routing.rules.add(0, V2rayConfig.RoutingBean.RulesBean(
+                            type = "field",
+                            outboundTag = AppConfig.TAG_DIRECT,
+                            port = "53",
+                            ip = arrayListOf(domesticDns.first()),
+                            domain = null)
+                    )
+                }
+            }
+
+            val blkDomain = userRule2Domian(settingsStorage?.decodeString(AppConfig.PREF_V2RAY_ROUTING_BLOCKED)
+                    ?: "")
+            if (blkDomain.size > 0) {
+                hosts.putAll(blkDomain.map { it to "127.0.0.1" })
+            }
+
+            // hardcode googleapi rule to fix play store problems
+            hosts["domain:googleapis.cn"] = "googleapis.com"
+
+            // DNS dns对象
+            v2rayConfig.dns = V2rayConfig.DnsBean(
+                    servers = servers,
+                    hosts = hosts)
+
+            // DNS routing
+            if (Utils.isPureIpAddress(remoteDns.first())) {
+                v2rayConfig.routing.rules.add(0, V2rayConfig.RoutingBean.RulesBean(
+                        type = "field",
+                        outboundTag = AppConfig.TAG_AGENT,
+                        port = "53",
+                        ip = arrayListOf(remoteDns.first()),
+                        domain = null)
+                )
+            }
+        } catch (e: Exception) {
+            e.printStackTrace()
+            return false
+        }
+        return true
+    }
+
+    private fun httpRequestObject(outbound: V2rayConfig.OutboundBean): Boolean {
+        try {
+            if (outbound.streamSettings?.network == DEFAULT_NETWORK
+                    && outbound.streamSettings?.tcpSettings?.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 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.143 Safari/537.36","Mozilla/5.0 (iPhone; CPU iPhone OS 10_0_2 like Mac OS X) AppleWebKit/601.1 (KHTML, like Gecko) CriOS/53.0.2785.109 Mobile/14A456 Safari/601.1.46"],"Accept-Encoding":["gzip, deflate"],"Connection":["keep-alive"],"Pragma":"no-cache"}}"""
+                }
+                outbound.streamSettings?.tcpSettings?.header?.request = Gson().fromJson(
+                    requestString,
+                    V2rayConfig.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) {
+            e.printStackTrace()
+            return false
+        }
+        return true
+    }
+
+}