.

V2rayNG/app/src/main/kotlin/com/v2ray/ang/ui/BaseActivity.kt

@@ -0,0 +1,53 @@
+package com.v2ray.ang.ui
+
+import android.content.Context
+import android.os.Build
+import android.os.Bundle
+import androidx.appcompat.app.AppCompatActivity
+import android.view.MenuItem
+import androidx.annotation.RequiresApi
+import com.v2ray.ang.util.MyContextWrapper
+import com.v2ray.ang.R
+import com.v2ray.ang.util.Utils
+
+abstract class BaseActivity : AppCompatActivity() {
+    override fun onOptionsItemSelected(item: MenuItem) = when (item.itemId) {
+        android.R.id.home -> {
+            onBackPressed()
+            true
+        }
+        else -> super.onOptionsItemSelected(item)
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        checkDarkMode()
+    }
+
+    private fun checkDarkMode() {
+        if (Utils.getDarkModeStatus(this)) {
+            if (this.javaClass.simpleName == "MainActivity") {
+                setTheme(R.style.AppThemeDark_NoActionBar)
+            } else {
+                setTheme(R.style.AppThemeDark)
+            }
+        } else {
+            if (this.javaClass.simpleName == "MainActivity") {
+                setTheme(R.style.AppThemeLight_NoActionBar)
+            } else {
+                setTheme(R.style.AppThemeLight)
+            }
+        }
+    }
+
+    @RequiresApi(Build.VERSION_CODES.N)
+    override fun attachBaseContext(newBase: Context?) {
+        val context = newBase?.let {
+            MyContextWrapper.wrap(newBase,  Utils.getLocale(newBase))
+        }
+        super.attachBaseContext(context)
+    }
+
+
+
+}

V2rayNG/app/src/main/kotlin/com/v2ray/ang/ui/FragmentAdapter.kt

@@ -0,0 +1,17 @@
+package com.v2ray.ang.ui
+
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.FragmentActivity
+import androidx.viewpager2.adapter.FragmentStateAdapter
+
+class FragmentAdapter(fragmentActivity: FragmentActivity, private val mFragments: List<Fragment>) :
+        FragmentStateAdapter(fragmentActivity) {
+
+    override fun createFragment(position: Int): Fragment {
+        return mFragments[position]
+    }
+
+    override fun getItemCount(): Int {
+        return mFragments.size
+    }
+}

V2rayNG/app/src/main/kotlin/com/v2ray/ang/ui/LogcatActivity.kt

@@ -0,0 +1,92 @@
+package com.v2ray.ang.ui
+
+import android.os.Handler
+import android.os.Looper
+import android.os.Bundle
+import android.text.method.ScrollingMovementMethod
+import android.view.Menu
+import android.view.MenuItem
+import android.view.View
+import androidx.lifecycle.lifecycleScope
+import com.v2ray.ang.AppConfig.ANG_PACKAGE
+import com.v2ray.ang.R
+import com.v2ray.ang.databinding.ActivityLogcatBinding
+import com.v2ray.ang.extension.toast
+import com.v2ray.ang.util.Utils
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.launch
+
+import java.io.IOException
+import java.util.LinkedHashSet
+
+class LogcatActivity : BaseActivity() {
+    private lateinit var binding: ActivityLogcatBinding
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+       binding = ActivityLogcatBinding.inflate(layoutInflater)
+       val view = binding.root
+       setContentView(view)
+
+        title = getString(R.string.title_logcat)
+
+        supportActionBar?.setDisplayHomeAsUpEnabled(true)
+        logcat(false)
+    }
+
+    private fun logcat(shouldFlushLog: Boolean) {
+
+        try {
+            binding.pbWaiting.visibility = View.VISIBLE
+
+            lifecycleScope.launch(Dispatchers.Default) {
+                if (shouldFlushLog) {
+                    val lst = LinkedHashSet<String>()
+                    lst.add("logcat")
+                    lst.add("-c")
+                    val process = Runtime.getRuntime().exec(lst.toTypedArray())
+                    process.waitFor()
+                }
+                val lst = LinkedHashSet<String>()
+                lst.add("logcat")
+                lst.add("-d")
+                lst.add("-v")
+                lst.add("time")
+                lst.add("-s")
+                lst.add("GoLog,tun2socks,${ANG_PACKAGE},AndroidRuntime,System.err")
+                val process = Runtime.getRuntime().exec(lst.toTypedArray())
+//                val bufferedReader = BufferedReader(
+//                        InputStreamReader(process.inputStream))
+//                val allText = bufferedReader.use(BufferedReader::readText)
+                val allText = process.inputStream.bufferedReader().use { it.readText() }
+                launch(Dispatchers.Main) {
+                    binding.tvLogcat.text = allText
+                    binding.tvLogcat.movementMethod = ScrollingMovementMethod()
+                    binding.pbWaiting.visibility = View.GONE
+                    Handler(Looper.getMainLooper()).post { binding.svLogcat.fullScroll(View.FOCUS_DOWN) }
+                }
+            }
+        } catch (e: IOException) {
+            e.printStackTrace()
+        }
+    }
+
+    override fun onCreateOptionsMenu(menu: Menu): Boolean {
+        menuInflater.inflate(R.menu.menu_logcat, menu)
+        return super.onCreateOptionsMenu(menu)
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem) = when (item.itemId) {
+        R.id.copy_all -> {
+            Utils.setClipboard(this, binding.tvLogcat.text.toString())
+            toast(R.string.toast_success)
+            true
+        }
+        R.id.clear_all -> {
+            logcat(true)
+            true
+        }
+        else -> super.onOptionsItemSelected(item)
+    }
+}

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

@@ -0,0 +1,658 @@
+package com.v2ray.ang.ui
+
+import android.Manifest
+import android.content.*
+import android.net.Uri
+import android.net.VpnService
+import androidx.recyclerview.widget.LinearLayoutManager
+import android.view.Menu
+import android.view.MenuItem
+import com.tbruyelle.rxpermissions.RxPermissions
+import com.v2ray.ang.R
+import android.os.Bundle
+import android.text.TextUtils
+import android.view.KeyEvent
+import com.v2ray.ang.AppConfig
+import android.content.res.ColorStateList
+import com.google.android.material.navigation.NavigationView
+import androidx.core.content.ContextCompat
+import androidx.core.view.GravityCompat
+import androidx.appcompat.app.ActionBarDrawerToggle
+import androidx.recyclerview.widget.ItemTouchHelper
+import android.util.Log
+import android.widget.Toast
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.activity.viewModels
+import androidx.appcompat.app.AlertDialog
+import androidx.lifecycle.lifecycleScope
+import com.tencent.mmkv.MMKV
+import com.v2ray.ang.AppConfig.ANG_PACKAGE
+import com.v2ray.ang.BuildConfig
+import com.v2ray.ang.databinding.ActivityMainBinding
+import com.v2ray.ang.dto.EConfigType
+import com.v2ray.ang.extension.toast
+import rx.Observable
+import rx.android.schedulers.AndroidSchedulers
+import java.util.concurrent.TimeUnit
+import com.v2ray.ang.helper.SimpleItemTouchHelperCallback
+import com.v2ray.ang.service.V2RayServiceManager
+import com.v2ray.ang.util.*
+import com.v2ray.ang.viewmodel.MainViewModel
+import kotlinx.coroutines.*
+import me.drakeet.support.toast.ToastCompat
+import java.io.File
+import java.io.FileOutputStream
+
+class MainActivity : BaseActivity(), NavigationView.OnNavigationItemSelectedListener {
+    private lateinit var binding: ActivityMainBinding
+
+    private val adapter by lazy { MainRecyclerAdapter(this) }
+    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) }
+    private val requestVpnPermission = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) {
+        if (it.resultCode == RESULT_OK) {
+            startV2Ray()
+        }
+    }
+    private var mItemTouchHelper: ItemTouchHelper? = null
+    val mainViewModel: MainViewModel by viewModels()
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        binding = ActivityMainBinding.inflate(layoutInflater)
+        val view = binding.root
+        setContentView(view)
+        title = getString(R.string.title_server)
+        setSupportActionBar(binding.toolbar)
+
+        binding.fab.setOnClickListener {
+            if (mainViewModel.isRunning.value == true) {
+                Utils.stopVService(this)
+            } else if (settingsStorage?.decodeString(AppConfig.PREF_MODE) ?: "VPN" == "VPN") {
+                val intent = VpnService.prepare(this)
+                if (intent == null) {
+                    startV2Ray()
+                } else {
+                    requestVpnPermission.launch(intent)
+                }
+            } else {
+                startV2Ray()
+            }
+        }
+        binding.layoutTest.setOnClickListener {
+            if (mainViewModel.isRunning.value == true) {
+                setTestState(getString(R.string.connection_test_testing))
+                mainViewModel.testCurrentServerRealPing()
+            } else {
+//                tv_test_state.text = getString(R.string.connection_test_fail)
+            }
+        }
+
+        binding.recyclerView.setHasFixedSize(true)
+        binding.recyclerView.layoutManager = LinearLayoutManager(this)
+        binding.recyclerView.adapter = adapter
+
+        val callback = SimpleItemTouchHelperCallback(adapter)
+        mItemTouchHelper = ItemTouchHelper(callback)
+        mItemTouchHelper?.attachToRecyclerView(binding.recyclerView)
+
+
+        val toggle = ActionBarDrawerToggle(
+                this, binding.drawerLayout, binding.toolbar, R.string.navigation_drawer_open, R.string.navigation_drawer_close)
+        binding.drawerLayout.addDrawerListener(toggle)
+        toggle.syncState()
+        binding.navView.setNavigationItemSelectedListener(this)
+        binding.version.text = "v${BuildConfig.VERSION_NAME} (${SpeedtestUtil.getLibVersion()})"
+
+        setupViewModel()
+        copyAssets()
+        migrateLegacy()
+    }
+
+    private fun setupViewModel() {
+        mainViewModel.updateListAction.observe(this) { index ->
+            if (index >= 0) {
+                adapter.notifyItemChanged(index)
+            } else {
+                adapter.notifyDataSetChanged()
+            }
+        }
+        mainViewModel.updateTestResultAction.observe(this) { setTestState(it) }
+        mainViewModel.isRunning.observe(this) { isRunning ->
+            adapter.isRunning = isRunning
+            if (isRunning) {
+                binding.fab.backgroundTintList = ColorStateList.valueOf(ContextCompat.getColor(this, R.color.colorSelected))
+                setTestState(getString(R.string.connection_connected))
+                binding.layoutTest.isFocusable = true
+            } else {
+                binding.fab.backgroundTintList = ColorStateList.valueOf(ContextCompat.getColor(this, R.color.colorUnselected))
+                setTestState(getString(R.string.connection_not_connected))
+                binding.layoutTest.isFocusable = false
+            }
+            hideCircle()
+        }
+        mainViewModel.startListenBroadcast()
+    }
+
+    private fun copyAssets() {
+        val extFolder = Utils.userAssetPath(this)
+        lifecycleScope.launch(Dispatchers.IO) {
+            try {
+                val geo = arrayOf("geosite.dat", "geoip.dat")
+                assets.list("")
+                        ?.filter { geo.contains(it) }
+                        ?.filter { !File(extFolder, it).exists() }
+                        ?.forEach {
+                            val target = File(extFolder, it)
+                            assets.open(it).use { input ->
+                                FileOutputStream(target).use { output ->
+                                    input.copyTo(output)
+                                }
+                            }
+                            Log.i(ANG_PACKAGE, "Copied from apk assets folder to ${target.absolutePath}")
+                        }
+            } catch (e: Exception) {
+                Log.e(ANG_PACKAGE, "asset copy failed", e)
+            }
+        }
+    }
+
+    private fun migrateLegacy() {
+        lifecycleScope.launch(Dispatchers.IO) {
+            val result = AngConfigManager.migrateLegacyConfig(this@MainActivity)
+            if (result != null) {
+                launch(Dispatchers.Main) {
+                    if (result) {
+                        toast(getString(R.string.migration_success))
+                        mainViewModel.reloadServerList()
+                    } else {
+                        toast(getString(R.string.migration_fail))
+                    }
+                }
+            }
+        }
+    }
+
+    fun startV2Ray() {
+        if (mainStorage?.decodeString(MmkvManager.KEY_SELECTED_SERVER).isNullOrEmpty()) {
+            return
+        }
+        showCircle()
+//        toast(R.string.toast_services_start)
+        V2RayServiceManager.startV2Ray(this)
+        hideCircle()
+    }
+
+    fun restartV2Ray() {
+        if (mainViewModel.isRunning.value == true) {
+            Utils.stopVService(this)
+        }
+        Observable.timer(500, TimeUnit.MILLISECONDS)
+                .observeOn(AndroidSchedulers.mainThread())
+                .subscribe {
+                    startV2Ray()
+                }
+    }
+
+    public override fun onResume() {
+        super.onResume()
+        mainViewModel.reloadServerList()
+    }
+
+    public override fun onPause() {
+        super.onPause()
+    }
+
+    override fun onCreateOptionsMenu(menu: Menu): Boolean {
+        menuInflater.inflate(R.menu.menu_main, menu)
+        return true
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem) = when (item.itemId) {
+        R.id.import_qrcode -> {
+            importQRcode(true)
+            true
+        }
+        R.id.import_clipboard -> {
+            importClipboard()
+            true
+        }
+        R.id.import_manually_vmess -> {
+            importManually(EConfigType.VMESS.value)
+            true
+        }
+        R.id.import_manually_vless -> {
+            importManually(EConfigType.VLESS.value)
+            true
+        }
+        R.id.import_manually_ss -> {
+            importManually(EConfigType.SHADOWSOCKS.value)
+            true
+        }
+        R.id.import_manually_socks -> {
+            importManually(EConfigType.SOCKS.value)
+            true
+        }
+        R.id.import_manually_trojan -> {
+            importManually(EConfigType.TROJAN.value)
+            true
+        }
+        R.id.import_config_custom_clipboard -> {
+            importConfigCustomClipboard()
+            true
+        }
+        R.id.import_config_custom_local -> {
+            importConfigCustomLocal()
+            true
+        }
+        R.id.import_config_custom_url -> {
+            importConfigCustomUrlClipboard()
+            true
+        }
+        R.id.import_config_custom_url_scan -> {
+            importQRcode(false)
+            true
+        }
+
+//        R.id.sub_setting -> {
+//            startActivity<SubSettingActivity>()
+//            true
+//        }
+
+        R.id.sub_update -> {
+            importConfigViaSub()
+            true
+        }
+
+        R.id.export_all -> {
+            if (AngConfigManager.shareNonCustomConfigsToClipboard(this, mainViewModel.serverList) == 0) {
+                toast(R.string.toast_success)
+            } else {
+                toast(R.string.toast_failure)
+            }
+            true
+        }
+
+        R.id.ping_all -> {
+            mainViewModel.testAllTcping()
+            true
+        }
+
+        R.id.real_ping_all -> {
+            mainViewModel.testAllRealPing()
+            true
+        }
+
+        R.id.service_restart -> {
+            restartV2Ray()
+            true
+        }
+
+        R.id.del_all_config -> {
+            AlertDialog.Builder(this).setMessage(R.string.del_config_comfirm)
+                    .setPositiveButton(android.R.string.ok) { _, _ ->
+                        MmkvManager.removeAllServer()
+                        mainViewModel.reloadServerList()
+                    }
+                    .show()
+            true
+        }
+
+        R.id.del_invalid_config -> {
+            AlertDialog.Builder(this).setMessage(R.string.del_config_comfirm)
+                .setPositiveButton(android.R.string.ok) { _, _ ->
+                    MmkvManager.removeInvalidServer()
+                    mainViewModel.reloadServerList()
+                }
+                .show()
+            true
+        }
+        R.id.sort_by_test_results -> {
+            MmkvManager.sortByTestResults()
+            mainViewModel.reloadServerList()
+            true
+        }
+        R.id.filter_config -> {
+            mainViewModel.filterConfig(this)
+            true
+        }
+
+        else -> super.onOptionsItemSelected(item)
+    }
+
+    private fun importManually(createConfigType : Int) {
+        startActivity(
+            Intent()
+                .putExtra("createConfigType", createConfigType)
+                .putExtra("subscriptionId", mainViewModel.subscriptionId)
+                .setClass(this, ServerActivity::class.java)
+        )
+    }
+
+    /**
+     * import config from qrcode
+     */
+    fun importQRcode(forConfig: Boolean): Boolean {
+//        try {
+//            startActivityForResult(Intent("com.google.zxing.client.android.SCAN")
+//                    .addCategory(Intent.CATEGORY_DEFAULT)
+//                    .addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP), requestCode)
+//        } catch (e: Exception) {
+        RxPermissions(this)
+                .request(Manifest.permission.CAMERA)
+                .subscribe {
+                    if (it)
+                        if (forConfig)
+                            scanQRCodeForConfig.launch(Intent(this, ScannerActivity::class.java))
+                        else
+                            scanQRCodeForUrlToCustomConfig.launch(Intent(this, ScannerActivity::class.java))
+                    else
+                        toast(R.string.toast_permission_denied)
+                }
+//        }
+        return true
+    }
+
+    private val scanQRCodeForConfig = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) {
+        if (it.resultCode == RESULT_OK) {
+            importBatchConfig(it.data?.getStringExtra("SCAN_RESULT"))
+        }
+    }
+
+    private val scanQRCodeForUrlToCustomConfig = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) {
+        if (it.resultCode == RESULT_OK) {
+            importConfigCustomUrl(it.data?.getStringExtra("SCAN_RESULT"))
+        }
+    }
+
+    /**
+     * import config from clipboard
+     */
+    fun importClipboard()
+            : Boolean {
+        try {
+            val clipboard = Utils.getClipboard(this)
+            importBatchConfig(clipboard)
+        } catch (e: Exception) {
+            e.printStackTrace()
+            return false
+        }
+        return true
+    }
+
+    fun importBatchConfig(server: String?, subid: String = "") {
+        val subid2 = if(subid.isNullOrEmpty()){
+            mainViewModel.subscriptionId
+        }else{
+            subid
+        }
+        val append = subid.isNullOrEmpty()
+
+        var count = AngConfigManager.importBatchConfig(server, subid2, append)
+        if (count <= 0) {
+            count = AngConfigManager.importBatchConfig(Utils.decode(server!!), subid2, append)
+        }
+        if (count > 0) {
+            toast(R.string.toast_success)
+            mainViewModel.reloadServerList()
+        } else {
+            toast(R.string.toast_failure)
+        }
+    }
+
+    fun importConfigCustomClipboard()
+            : Boolean {
+        try {
+            val configText = Utils.getClipboard(this)
+            if (TextUtils.isEmpty(configText)) {
+                toast(R.string.toast_none_data_clipboard)
+                return false
+            }
+            importCustomizeConfig(configText)
+            return true
+        } catch (e: Exception) {
+            e.printStackTrace()
+            return false
+        }
+    }
+
+    /**
+     * import config from local config file
+     */
+    fun importConfigCustomLocal(): Boolean {
+        try {
+            showFileChooser()
+        } catch (e: Exception) {
+            e.printStackTrace()
+            return false
+        }
+        return true
+    }
+
+    fun importConfigCustomUrlClipboard()
+            : Boolean {
+        try {
+            val url = Utils.getClipboard(this)
+            if (TextUtils.isEmpty(url)) {
+                toast(R.string.toast_none_data_clipboard)
+                return false
+            }
+            return importConfigCustomUrl(url)
+        } catch (e: Exception) {
+            e.printStackTrace()
+            return false
+        }
+    }
+
+    /**
+     * import config from url
+     */
+    fun importConfigCustomUrl(url: String?): Boolean {
+        try {
+            if (!Utils.isValidUrl(url)) {
+                toast(R.string.toast_invalid_url)
+                return false
+            }
+            lifecycleScope.launch(Dispatchers.IO) {
+                val configText = try {
+                    Utils.getUrlContentWithCustomUserAgent(url)
+                } catch (e: Exception) {
+                    e.printStackTrace()
+                    ""
+                }
+                launch(Dispatchers.Main) {
+                    importCustomizeConfig(configText)
+                }
+            }
+        } catch (e: Exception) {
+            e.printStackTrace()
+            return false
+        }
+        return true
+    }
+
+    /**
+     * import config from sub
+     */
+    fun importConfigViaSub()
+            : Boolean {
+        try {
+            toast(R.string.title_sub_update)
+            MmkvManager.decodeSubscriptions().forEach {
+                if (TextUtils.isEmpty(it.first)
+                        || TextUtils.isEmpty(it.second.remarks)
+                        || TextUtils.isEmpty(it.second.url)
+                ) {
+                    return@forEach
+                }
+                if (!it.second.enabled) {
+                    return@forEach
+                }
+                val url = Utils.idnToASCII(it.second.url)
+                if (!Utils.isValidUrl(url)) {
+                    return@forEach
+                }
+                Log.d(ANG_PACKAGE, url)
+                lifecycleScope.launch(Dispatchers.IO) {
+                    val configText = try {
+                        Utils.getUrlContentWithCustomUserAgent(url)
+                    } catch (e: Exception) {
+                        e.printStackTrace()
+                        launch(Dispatchers.Main) {
+                            toast("\"" + it.second.remarks + "\" " + getString(R.string.toast_failure))
+                        }
+                        return@launch
+                    }
+                    launch(Dispatchers.Main) {
+                        importBatchConfig(configText, it.first)
+                    }
+                }
+            }
+        } catch (e: Exception) {
+            e.printStackTrace()
+            return false
+        }
+        return true
+    }
+
+    /**
+     * show file chooser
+     */
+    private fun showFileChooser() {
+        val intent = Intent(Intent.ACTION_GET_CONTENT)
+        intent.type = "*/*"
+        intent.addCategory(Intent.CATEGORY_OPENABLE)
+
+        try {
+            chooseFileForCustomConfig.launch(Intent.createChooser(intent, getString(R.string.title_file_chooser)))
+        } catch (ex: ActivityNotFoundException) {
+            toast(R.string.toast_require_file_manager)
+        }
+    }
+
+    private val chooseFileForCustomConfig = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) {
+        val uri = it.data?.data
+        if (it.resultCode == RESULT_OK && uri != null) {
+            readContentFromUri(uri)
+        }
+    }
+
+    /**
+     * read content from uri
+     */
+    private fun readContentFromUri(uri: Uri) {
+        RxPermissions(this)
+                .request(Manifest.permission.READ_EXTERNAL_STORAGE)
+                .subscribe {
+                    if (it) {
+                        try {
+                            contentResolver.openInputStream(uri).use { input ->
+                                importCustomizeConfig(input?.bufferedReader()?.readText())
+                            }
+                        } catch (e: Exception) {
+                            e.printStackTrace()
+                        }
+                    } else
+                        toast(R.string.toast_permission_denied)
+                }
+    }
+
+    /**
+     * import customize config
+     */
+    fun importCustomizeConfig(server: String?) {
+        try {
+            if (server == null || TextUtils.isEmpty(server)) {
+                toast(R.string.toast_none_data)
+                return
+            }
+            mainViewModel.appendCustomConfigServer(server)
+            mainViewModel.reloadServerList()
+            toast(R.string.toast_success)
+            //adapter.notifyItemInserted(mainViewModel.serverList.lastIndex)
+        } catch (e: Exception) {
+            ToastCompat.makeText(this, "${getString(R.string.toast_malformed_josn)} ${e.cause?.message}", Toast.LENGTH_LONG).show()
+            e.printStackTrace()
+            return
+        }
+    }
+
+    fun setTestState(content: String?) {
+        binding.tvTestState.text = content
+    }
+
+//    val mConnection = object : ServiceConnection {
+//        override fun onServiceDisconnected(name: ComponentName?) {
+//        }
+//
+//        override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
+//            sendMsg(AppConfig.MSG_REGISTER_CLIENT, "")
+//        }
+//    }
+
+    override fun onKeyDown(keyCode: Int, event: KeyEvent): Boolean {
+        if (keyCode == KeyEvent.KEYCODE_BACK) {
+            moveTaskToBack(false)
+            return true
+        }
+        return super.onKeyDown(keyCode, event)
+    }
+
+    fun showCircle() {
+        binding.fabProgressCircle.show()
+    }
+
+    fun hideCircle() {
+        try {
+            Observable.timer(300, TimeUnit.MILLISECONDS)
+                    .observeOn(AndroidSchedulers.mainThread())
+                    .subscribe {
+                        try {
+                            if (binding.fabProgressCircle.isShown) {
+                                binding.fabProgressCircle.hide()
+                            }
+                        } catch (e: Exception) {
+                            Log.w(ANG_PACKAGE, e)
+                        }
+                    }
+        } catch (e: Exception) {
+            Log.d(ANG_PACKAGE, e.toString())
+        }
+    }
+
+    override fun onBackPressed() {
+        if (binding.drawerLayout.isDrawerOpen(GravityCompat.START)) {
+            binding.drawerLayout.closeDrawer(GravityCompat.START)
+        } else {
+            super.onBackPressed()
+        }
+    }
+
+    override fun onNavigationItemSelected(item: MenuItem): Boolean {
+        // Handle navigation view item clicks here.
+        when (item.itemId) {
+            //R.id.server_profile -> activityClass = MainActivity::class.java
+            R.id.sub_setting -> {
+                startActivity(Intent(this, SubSettingActivity::class.java))
+            }
+            R.id.settings -> {
+                startActivity(Intent(this, SettingsActivity::class.java)
+                        .putExtra("isRunning", mainViewModel.isRunning.value == true))
+            }
+            R.id.user_asset_setting -> {
+                startActivity(Intent(this, UserAssetActivity::class.java))
+            }
+            R.id.feedback -> {
+                Utils.openUri(this, AppConfig.v2rayNGIssues)
+            }
+            R.id.promotion -> {
+                Utils.openUri(this, "${Utils.decode(AppConfig.promotionUrl)}?t=${System.currentTimeMillis()}")
+            }
+            R.id.logcat -> {
+                startActivity(Intent(this, LogcatActivity::class.java))
+            }
+        }
+        binding.drawerLayout.closeDrawer(GravityCompat.START)
+        return true
+    }
+}

V2rayNG/app/src/main/kotlin/com/v2ray/ang/ui/MainRecyclerAdapter.kt

@@ -0,0 +1,260 @@
+package com.v2ray.ang.ui
+
+import android.content.Intent
+import android.graphics.Color
+import android.text.TextUtils
+import androidx.core.content.ContextCompat
+import androidx.recyclerview.widget.RecyclerView
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.appcompat.app.AlertDialog
+import com.google.gson.Gson
+import com.tencent.mmkv.MMKV
+import com.v2ray.ang.AppConfig
+import com.v2ray.ang.R
+import com.v2ray.ang.databinding.ItemQrcodeBinding
+import com.v2ray.ang.databinding.ItemRecyclerFooterBinding
+import com.v2ray.ang.databinding.ItemRecyclerMainBinding
+import com.v2ray.ang.dto.EConfigType
+import com.v2ray.ang.dto.SubscriptionItem
+import com.v2ray.ang.extension.toast
+import com.v2ray.ang.helper.ItemTouchHelperAdapter
+import com.v2ray.ang.helper.ItemTouchHelperViewHolder
+import com.v2ray.ang.service.V2RayServiceManager
+import com.v2ray.ang.util.AngConfigManager
+import com.v2ray.ang.util.MmkvManager
+import com.v2ray.ang.util.Utils
+import rx.Observable
+import rx.android.schedulers.AndroidSchedulers
+import java.util.concurrent.TimeUnit
+
+class MainRecyclerAdapter(val activity: MainActivity) : RecyclerView.Adapter<MainRecyclerAdapter.BaseViewHolder>()
+        , ItemTouchHelperAdapter {
+    companion object {
+        private const val VIEW_TYPE_ITEM = 1
+        private const val VIEW_TYPE_FOOTER = 2
+    }
+
+    private var mActivity: MainActivity = activity
+    private val mainStorage by lazy { MMKV.mmkvWithID(MmkvManager.ID_MAIN, MMKV.MULTI_PROCESS_MODE) }
+    private val subStorage by lazy { MMKV.mmkvWithID(MmkvManager.ID_SUB, MMKV.MULTI_PROCESS_MODE) }
+    private val settingsStorage by lazy { MMKV.mmkvWithID(MmkvManager.ID_SETTING, MMKV.MULTI_PROCESS_MODE) }
+    private val share_method: Array<out String> by lazy {
+        mActivity.resources.getStringArray(R.array.share_method)
+    }
+    var isRunning = false
+
+    override fun getItemCount() = mActivity.mainViewModel.serversCache.size + 1
+
+    override fun onBindViewHolder(holder: BaseViewHolder, position: Int) {
+        if (holder is MainViewHolder) {
+            val guid = mActivity.mainViewModel.serversCache[position].guid
+            val config = mActivity.mainViewModel.serversCache[position].config
+//            //filter
+//            if (mActivity.mainViewModel.subscriptionId.isNotEmpty()
+//                && mActivity.mainViewModel.subscriptionId != config.subscriptionId
+//            ) {
+//                holder.itemMainBinding.cardView.visibility = View.GONE
+//            } else {
+//                holder.itemMainBinding.cardView.visibility = View.VISIBLE
+//            }
+
+            val outbound = config.getProxyOutbound()
+            val aff = MmkvManager.decodeServerAffiliationInfo(guid)
+
+            holder.itemMainBinding.tvName.text = config.remarks
+            holder.itemView.setBackgroundColor(Color.TRANSPARENT)
+            holder.itemMainBinding.tvTestResult.text = aff?.getTestDelayString() ?: ""
+            if ((aff?.testDelayMillis ?: 0L) < 0L) {
+                holder.itemMainBinding.tvTestResult.setTextColor(ContextCompat.getColor(mActivity, R.color.colorPingRed))
+            } else {
+                holder.itemMainBinding.tvTestResult.setTextColor(ContextCompat.getColor(mActivity, R.color.colorPing))
+            }
+            if (guid == mainStorage?.decodeString(MmkvManager.KEY_SELECTED_SERVER)) {
+                holder.itemMainBinding.layoutIndicator.setBackgroundResource(R.color.colorSelected)
+            } else {
+                holder.itemMainBinding.layoutIndicator.setBackgroundResource(R.color.colorUnselected)
+            }
+            holder.itemMainBinding.tvSubscription.text = ""
+            val json = subStorage?.decodeString(config.subscriptionId)
+            if (!json.isNullOrBlank()) {
+                val sub = Gson().fromJson(json, SubscriptionItem::class.java)
+                holder.itemMainBinding.tvSubscription.text = sub.remarks
+            }
+
+            var shareOptions = share_method.asList()
+            when (config.configType) {
+                EConfigType.CUSTOM -> {
+                    holder.itemMainBinding.tvType.text = mActivity.getString(R.string.server_customize_config)
+                    shareOptions = shareOptions.takeLast(1)
+                }
+                EConfigType.VLESS -> {
+                    holder.itemMainBinding.tvType.text = config.configType.name
+                }
+                else -> {
+                    holder.itemMainBinding.tvType.text = config.configType.name.lowercase()
+                }
+            }
+            holder.itemMainBinding.tvStatistics.text = "${outbound?.getServerAddress()} : ${outbound?.getServerPort()}"
+
+            holder.itemMainBinding.layoutShare.setOnClickListener {
+                AlertDialog.Builder(mActivity).setItems(shareOptions.toTypedArray()) { _, i ->
+                    try {
+                        when (i) {
+                            0 -> {
+                                if (config.configType == EConfigType.CUSTOM) {
+                                    shareFullContent(guid)
+                                } else {
+                                    val ivBinding = ItemQrcodeBinding.inflate(LayoutInflater.from(mActivity))
+                                    ivBinding.ivQcode.setImageBitmap(AngConfigManager.share2QRCode(guid))
+                                    AlertDialog.Builder(mActivity).setView(ivBinding.root).show()
+                                }
+                            }
+                            1 -> {
+                                if (AngConfigManager.share2Clipboard(mActivity, guid) == 0) {
+                                    mActivity.toast(R.string.toast_success)
+                                } else {
+                                    mActivity.toast(R.string.toast_failure)
+                                }
+                            }
+                            2 -> shareFullContent(guid)
+                            else -> mActivity.toast("else")
+                        }
+                    } catch (e: Exception) {
+                        e.printStackTrace()
+                    }
+                }.show()
+            }
+
+            holder.itemMainBinding.layoutEdit.setOnClickListener {
+                val intent = Intent().putExtra("guid", guid)
+                        .putExtra("isRunning", isRunning)
+                if (config.configType == EConfigType.CUSTOM) {
+                    mActivity.startActivity(intent.setClass(mActivity, ServerCustomConfigActivity::class.java))
+                } else {
+                    mActivity.startActivity(intent.setClass(mActivity, ServerActivity::class.java))
+                }
+            }
+            holder.itemMainBinding.layoutRemove.setOnClickListener {
+                if (guid != mainStorage?.decodeString(MmkvManager.KEY_SELECTED_SERVER)) {
+                    if (settingsStorage?.decodeBool(AppConfig.PREF_CONFIRM_REMOVE) == true) {
+                        AlertDialog.Builder(mActivity).setMessage(R.string.del_config_comfirm)
+                            .setPositiveButton(android.R.string.ok) { _, _ ->
+                                removeServer(guid, position)
+                            }
+                            .show()
+                    } else {
+                        removeServer(guid, position)
+                    }
+                }
+            }
+
+            holder.itemMainBinding.infoContainer.setOnClickListener {
+                val selected = mainStorage?.decodeString(MmkvManager.KEY_SELECTED_SERVER)
+                if (guid != selected) {
+                    mainStorage?.encode(MmkvManager.KEY_SELECTED_SERVER, guid)
+                    if (!TextUtils.isEmpty(selected)) {
+                        notifyItemChanged(mActivity.mainViewModel.getPosition(selected!!))
+                    }
+                    notifyItemChanged(mActivity.mainViewModel.getPosition(guid))
+                    if (isRunning) {
+                        mActivity.showCircle()
+                        Utils.stopVService(mActivity)
+                        Observable.timer(500, TimeUnit.MILLISECONDS)
+                                .observeOn(AndroidSchedulers.mainThread())
+                                .subscribe {
+                                    V2RayServiceManager.startV2Ray(mActivity)
+                                    mActivity.hideCircle()
+                                }
+                    }
+                }
+            }
+        }
+        if (holder is FooterViewHolder) {
+            //if (activity?.defaultDPreference?.getPrefBoolean(AppConfig.PREF_INAPP_BUY_IS_PREMIUM, false)) {
+            if (true) {
+                holder.itemFooterBinding.layoutEdit.visibility = View.INVISIBLE
+            } else {
+                holder.itemFooterBinding.layoutEdit.setOnClickListener {
+                    Utils.openUri(mActivity, "${Utils.decode(AppConfig.promotionUrl)}?t=${System.currentTimeMillis()}")
+                }
+            }
+        }
+    }
+
+    private fun shareFullContent(guid: String) {
+        if (AngConfigManager.shareFullContent2Clipboard(mActivity, guid) == 0) {
+            mActivity.toast(R.string.toast_success)
+        } else {
+            mActivity.toast(R.string.toast_failure)
+        }
+    }
+
+    private  fun removeServer(guid: String,position:Int) {
+        mActivity.mainViewModel.removeServer(guid)
+        notifyItemRemoved(position)
+        notifyItemRangeChanged(position, mActivity.mainViewModel.serversCache.size)
+    }
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): BaseViewHolder {
+        return when (viewType) {
+            VIEW_TYPE_ITEM ->
+                MainViewHolder(ItemRecyclerMainBinding.inflate(LayoutInflater.from(parent.context), parent, false))
+            else ->
+                FooterViewHolder(ItemRecyclerFooterBinding.inflate(LayoutInflater.from(parent.context), parent, false))
+        }
+    }
+
+    override fun getItemViewType(position: Int): Int {
+        return if (position == mActivity.mainViewModel.serversCache.size) {
+            VIEW_TYPE_FOOTER
+        } else {
+            VIEW_TYPE_ITEM
+        }
+    }
+
+    open class BaseViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
+        fun onItemSelected() {
+            itemView.setBackgroundColor(Color.LTGRAY)
+        }
+
+        fun onItemClear() {
+            itemView.setBackgroundColor(0)
+        }
+    }
+
+    class MainViewHolder(val itemMainBinding: ItemRecyclerMainBinding) :
+            BaseViewHolder(itemMainBinding.root), ItemTouchHelperViewHolder
+
+    class FooterViewHolder(val itemFooterBinding: ItemRecyclerFooterBinding) :
+            BaseViewHolder(itemFooterBinding.root), ItemTouchHelperViewHolder
+
+    override fun onItemDismiss(position: Int) {
+        val guid = mActivity.mainViewModel.serversCache.getOrNull(position)?.guid ?: return
+        if (guid != mainStorage?.decodeString(MmkvManager.KEY_SELECTED_SERVER)) {
+//            mActivity.alert(R.string.del_config_comfirm) {
+//                positiveButton(android.R.string.ok) {
+            mActivity.mainViewModel.removeServer(guid)
+            notifyItemRemoved(position)
+//                }
+//                show()
+//            }
+        }
+    }
+
+    override fun onItemMove(fromPosition: Int, toPosition: Int): Boolean {
+        mActivity.mainViewModel.swapServer(fromPosition, toPosition)
+        notifyItemMoved(fromPosition, toPosition)
+        // position is changed, since position is used by click callbacks, need to update range
+        if (toPosition > fromPosition)
+            notifyItemRangeChanged(fromPosition, toPosition - fromPosition + 1)
+        else
+            notifyItemRangeChanged(toPosition, fromPosition - toPosition + 1)
+        return true
+    }
+
+    override fun onItemMoveCompleted() {
+        // do nothing
+    }
+}

V2rayNG/app/src/main/kotlin/com/v2ray/ang/ui/PerAppProxyActivity.kt

@@ -0,0 +1,355 @@
+package com.v2ray.ang.ui
+
+import android.os.Bundle
+import android.text.TextUtils
+import android.util.Log
+import android.view.Menu
+import android.view.MenuItem
+import android.view.View
+import androidx.appcompat.widget.SearchView
+import androidx.lifecycle.lifecycleScope
+import androidx.preference.PreferenceManager
+import androidx.recyclerview.widget.DividerItemDecoration
+import androidx.recyclerview.widget.LinearLayoutManager
+import com.v2ray.ang.AppConfig
+import com.v2ray.ang.AppConfig.ANG_PACKAGE
+import com.v2ray.ang.R
+import com.v2ray.ang.databinding.ActivityBypassListBinding
+import com.v2ray.ang.dto.AppInfo
+import com.v2ray.ang.extension.toast
+import com.v2ray.ang.extension.v2RayApplication
+import com.v2ray.ang.util.AppManagerUtil
+import com.v2ray.ang.util.Utils
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.launch
+import rx.android.schedulers.AndroidSchedulers
+import rx.schedulers.Schedulers
+import java.text.Collator
+import java.util.*
+
+class PerAppProxyActivity : BaseActivity() {
+    private lateinit var binding: ActivityBypassListBinding
+
+    private var adapter: PerAppProxyAdapter? = null
+    private var appsAll: List<AppInfo>? = null
+    private val defaultSharedPreferences by lazy { PreferenceManager.getDefaultSharedPreferences(this) }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        binding = ActivityBypassListBinding.inflate(layoutInflater)
+        val view = binding.root
+        setContentView(view)
+
+        supportActionBar?.setDisplayHomeAsUpEnabled(true)
+
+        val dividerItemDecoration = DividerItemDecoration(this, LinearLayoutManager.VERTICAL)
+        binding.recyclerView.addItemDecoration(dividerItemDecoration)
+
+        val blacklist = defaultSharedPreferences.getStringSet(AppConfig.PREF_PER_APP_PROXY_SET, null)
+
+        AppManagerUtil.rxLoadNetworkAppList(this)
+                .subscribeOn(Schedulers.io())
+                .map {
+                    if (blacklist != null) {
+                        it.forEach { one ->
+                            if ((blacklist.contains(one.packageName))) {
+                                one.isSelected = 1
+                            } else {
+                                one.isSelected = 0
+                            }
+                        }
+                        val comparator = Comparator<AppInfo> { p1, p2 ->
+                            when {
+                                p1.isSelected > p2.isSelected -> -1
+                                p1.isSelected == p2.isSelected -> 0
+                                else -> 1
+                            }
+                        }
+                        it.sortedWith(comparator)
+                    } else {
+                        val comparator = object : Comparator<AppInfo> {
+                            val collator = Collator.getInstance()
+                            override fun compare(o1: AppInfo, o2: AppInfo) = collator.compare(o1.appName, o2.appName)
+                        }
+                        it.sortedWith(comparator)
+                    }
+                }
+//                .map {
+//                    val comparator = object : Comparator<AppInfo> {
+//                        val collator = Collator.getInstance()
+//                        override fun compare(o1: AppInfo, o2: AppInfo) = collator.compare(o1.appName, o2.appName)
+//                    }
+//                    it.sortedWith(comparator)
+//                }
+                .observeOn(AndroidSchedulers.mainThread())
+                .subscribe {
+                    appsAll = it
+                    adapter = PerAppProxyAdapter(this, it, blacklist)
+                    binding.recyclerView.adapter = adapter
+                    binding.pbWaiting.visibility = View.GONE
+                }
+        /***
+        recycler_view.addOnScrollListener(object : RecyclerView.OnScrollListener() {
+        var dst = 0
+        val threshold = resources.getDimensionPixelSize(R.dimen.bypass_list_header_height) * 2
+        override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
+        dst += dy
+        if (dst > threshold) {
+        header_view.hide()
+        dst = 0
+        } else if (dst < -20) {
+        header_view.show()
+        dst = 0
+        }
+        }
+
+        var hiding = false
+        fun View.hide() {
+        val target = -height.toFloat()
+        if (hiding || translationY == target) return
+        animate()
+        .translationY(target)
+        .setInterpolator(AccelerateInterpolator(2F))
+        .setListener(object : AnimatorListenerAdapter() {
+        override fun onAnimationEnd(animation: Animator?) {
+        hiding = false
+        }
+        })
+        hiding = true
+        }
+
+        var showing = false
+        fun View.show() {
+        val target = 0f
+        if (showing || translationY == target) return
+        animate()
+        .translationY(target)
+        .setInterpolator(DecelerateInterpolator(2F))
+        .setListener(object : AnimatorListenerAdapter() {
+        override fun onAnimationEnd(animation: Animator?) {
+        showing = false
+        }
+        })
+        showing = true
+        }
+        })
+         ***/
+
+        binding.switchPerAppProxy.setOnCheckedChangeListener { _, isChecked ->
+            defaultSharedPreferences.edit().putBoolean(AppConfig.PREF_PER_APP_PROXY, isChecked).apply()
+        }
+        binding.switchPerAppProxy.isChecked = defaultSharedPreferences.getBoolean(AppConfig.PREF_PER_APP_PROXY, false)
+
+        binding.switchBypassApps.setOnCheckedChangeListener { _, isChecked ->
+            defaultSharedPreferences.edit().putBoolean(AppConfig.PREF_BYPASS_APPS, isChecked).apply()
+        }
+        binding.switchBypassApps.isChecked = defaultSharedPreferences.getBoolean(AppConfig.PREF_BYPASS_APPS, false)
+
+        /***
+        et_search.setOnEditorActionListener { v, actionId, event ->
+        if (actionId == EditorInfo.IME_ACTION_SEARCH) {
+        //hide
+        var imm: InputMethodManager = v.context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
+        imm.toggleSoftInput(0, InputMethodManager.HIDE_NOT_ALWAYS)
+
+        val key = v.text.toString().toUpperCase()
+        val apps = ArrayList<AppInfo>()
+        if (TextUtils.isEmpty(key)) {
+        appsAll?.forEach {
+        apps.add(it)
+        }
+        } else {
+        appsAll?.forEach {
+        if (it.appName.toUpperCase().indexOf(key) >= 0) {
+        apps.add(it)
+        }
+        }
+        }
+        adapter = PerAppProxyAdapter(this, apps, adapter?.blacklist)
+        recycler_view.adapter = adapter
+        adapter?.notifyDataSetChanged()
+        true
+        } else {
+        false
+        }
+        }
+         ***/
+    }
+
+    override fun onPause() {
+        super.onPause()
+        adapter?.let {
+            defaultSharedPreferences.edit().putStringSet(AppConfig.PREF_PER_APP_PROXY_SET, it.blacklist).apply()
+        }
+    }
+
+    override fun onCreateOptionsMenu(menu: Menu): Boolean {
+        menuInflater.inflate(R.menu.menu_bypass_list, menu)
+
+        val searchItem = menu.findItem(R.id.search_view)
+        if (searchItem != null) {
+            val searchView = searchItem.actionView as SearchView
+            searchView.setOnQueryTextListener(object : SearchView.OnQueryTextListener {
+                override fun onQueryTextSubmit(query: String?): Boolean {
+                    return false
+                }
+
+                override fun onQueryTextChange(newText: String?): Boolean {
+                    filterProxyApp(newText!!)
+                    return false
+                }
+            })
+        }
+
+
+        return super.onCreateOptionsMenu(menu)
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem) = when (item.itemId) {
+        R.id.select_all -> adapter?.let {
+            val pkgNames = it.apps.map { it.packageName }
+            if (it.blacklist.containsAll(pkgNames)) {
+                it.apps.forEach {
+                    val packageName = it.packageName
+                    adapter?.blacklist!!.remove(packageName)
+                }
+            } else {
+                it.apps.forEach {
+                    val packageName = it.packageName
+                    adapter?.blacklist!!.add(packageName)
+                }
+            }
+            it.notifyDataSetChanged()
+            true
+        } ?: false
+        R.id.select_proxy_app -> {
+            selectProxyApp()
+            true
+        }
+        R.id.import_proxy_app -> {
+            importProxyApp()
+            true
+        }
+        R.id.export_proxy_app -> {
+            exportProxyApp()
+            true
+        }
+        else -> super.onOptionsItemSelected(item)
+    }
+
+    private fun selectProxyApp() {
+        toast(R.string.msg_downloading_content)
+        val url = AppConfig.androidpackagenamelistUrl
+        lifecycleScope.launch(Dispatchers.IO) {
+            val content = Utils.getUrlContext(url, 5000)
+            launch(Dispatchers.Main) {
+                Log.d(ANG_PACKAGE, content)
+                selectProxyApp(content, true)
+                toast(R.string.toast_success)
+            }
+        }
+    }
+
+    private fun importProxyApp() {
+        val content = Utils.getClipboard(applicationContext)
+        if (TextUtils.isEmpty(content)) {
+            return
+        }
+        selectProxyApp(content, false)
+        toast(R.string.toast_success)
+    }
+
+    private fun exportProxyApp() {
+        var lst = binding.switchBypassApps.isChecked.toString()
+
+        adapter?.blacklist?.forEach block@{
+            lst = lst + System.getProperty("line.separator") + it
+        }
+        Utils.setClipboard(applicationContext, lst)
+        toast(R.string.toast_success)
+    }
+
+    private fun selectProxyApp(content: String, force: Boolean): Boolean {
+        try {
+            val proxyApps = if (TextUtils.isEmpty(content)) {
+                Utils.readTextFromAssets(v2RayApplication, "proxy_packagename.txt")
+            } else {
+                content
+            }
+            if (TextUtils.isEmpty(proxyApps)) {
+                return false
+            }
+
+            adapter?.blacklist!!.clear()
+
+            if (binding.switchBypassApps.isChecked) {
+                adapter?.let {
+                    it.apps.forEach block@{
+                        val packageName = it.packageName
+                        Log.d(ANG_PACKAGE, packageName)
+                        if (!inProxyApps(proxyApps, packageName, force)) {
+                            adapter?.blacklist!!.add(packageName)
+                            println(packageName)
+                            return@block
+                        }
+                    }
+                    it.notifyDataSetChanged()
+                }
+            } else {
+                adapter?.let {
+                    it.apps.forEach block@{
+                        val packageName = it.packageName
+                        Log.d(ANG_PACKAGE, packageName)
+                        if (inProxyApps(proxyApps, packageName, force)) {
+                            adapter?.blacklist!!.add(packageName)
+                            println(packageName)
+                            return@block
+                        }
+                    }
+                    it.notifyDataSetChanged()
+                }
+            }
+        } catch (e: Exception) {
+            e.printStackTrace()
+            return false
+        }
+        return true
+    }
+
+    private fun inProxyApps(proxyApps: String, packageName: String, force: Boolean): Boolean {
+        if (force) {
+            if (packageName == "com.google.android.webview") {
+                return false
+            }
+            if (packageName.startsWith("com.google")) {
+                return true
+            }
+        }
+
+        return proxyApps.indexOf(packageName) >= 0
+    }
+
+    private fun filterProxyApp(content: String): Boolean {
+        val apps = ArrayList<AppInfo>()
+
+        val key = content.uppercase()
+        if (key.isNotEmpty()) {
+            appsAll?.forEach {
+                if (it.appName.uppercase().indexOf(key) >= 0
+                        || it.packageName.uppercase().indexOf(key) >= 0) {
+                    apps.add(it)
+                }
+            }
+        } else {
+            appsAll?.forEach {
+                apps.add(it)
+            }
+        }
+
+        adapter = PerAppProxyAdapter(this, apps, adapter?.blacklist)
+        binding.recyclerView.adapter = adapter
+        adapter?.notifyDataSetChanged()
+        return true
+    }
+}

V2rayNG/app/src/main/kotlin/com/v2ray/ang/ui/PerAppProxyAdapter.kt

@@ -0,0 +1,87 @@
+package com.v2ray.ang.ui
+
+import android.view.LayoutInflater
+import androidx.recyclerview.widget.RecyclerView
+import android.view.View
+import android.view.ViewGroup
+import com.v2ray.ang.R
+import com.v2ray.ang.databinding.ItemRecyclerBypassListBinding
+import com.v2ray.ang.dto.AppInfo
+import java.util.*
+
+class PerAppProxyAdapter(val activity: BaseActivity, val apps: List<AppInfo>, blacklist: MutableSet<String>?) :
+        RecyclerView.Adapter<PerAppProxyAdapter.BaseViewHolder>() {
+
+    companion object {
+        private const val VIEW_TYPE_HEADER = 0
+        private const val VIEW_TYPE_ITEM = 1
+    }
+
+    val blacklist = if (blacklist == null) HashSet() else HashSet(blacklist)
+
+    override fun onBindViewHolder(holder: BaseViewHolder, position: Int) {
+        if (holder is AppViewHolder) {
+            val appInfo = apps[position - 1]
+            holder.bind(appInfo)
+        }
+    }
+
+    override fun getItemCount() = apps.size + 1
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): BaseViewHolder {
+        val ctx = parent.context
+
+        return when (viewType) {
+            VIEW_TYPE_HEADER -> {
+                val view = View(ctx)
+                view.layoutParams = ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
+                        ctx.resources.getDimensionPixelSize(R.dimen.bypass_list_header_height) * 0)
+                BaseViewHolder(view)
+            }
+//            VIEW_TYPE_ITEM -> AppViewHolder(ctx.layoutInflater
+//                    .inflate(R.layout.item_recycler_bypass_list, parent, false))
+
+            else -> AppViewHolder(ItemRecyclerBypassListBinding.inflate(LayoutInflater.from(ctx), parent, false))
+
+        }
+    }
+
+    override fun getItemViewType(position: Int) = if (position == 0) VIEW_TYPE_HEADER else VIEW_TYPE_ITEM
+
+    open class BaseViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView)
+
+    inner class AppViewHolder(private val itemBypassBinding: ItemRecyclerBypassListBinding) : BaseViewHolder(itemBypassBinding.root),
+            View.OnClickListener {
+        private val inBlacklist: Boolean get() = blacklist.contains(appInfo.packageName)
+        private lateinit var appInfo: AppInfo
+
+        fun bind(appInfo: AppInfo) {
+            this.appInfo = appInfo
+
+            itemBypassBinding.icon.setImageDrawable(appInfo.appIcon)
+//            name.text = appInfo.appName
+
+            itemBypassBinding.checkBox.isChecked = inBlacklist
+            itemBypassBinding.packageName.text = appInfo.packageName
+            if (appInfo.isSystemApp) {
+                itemBypassBinding.name.text = String.format("** %1s", appInfo.appName)
+                //name.textColor = Color.RED
+            } else {
+                itemBypassBinding.name.text = appInfo.appName
+                //name.textColor = Color.DKGRAY
+            }
+
+            itemView.setOnClickListener(this)
+        }
+
+        override fun onClick(v: View?) {
+            if (inBlacklist) {
+                blacklist.remove(appInfo.packageName)
+                itemBypassBinding.checkBox.isChecked = false
+            } else {
+                blacklist.add(appInfo.packageName)
+                itemBypassBinding.checkBox.isChecked = true
+            }
+        }
+    }
+}

V2rayNG/app/src/main/kotlin/com/v2ray/ang/ui/RoutingSettingsActivity.kt

@@ -0,0 +1,38 @@
+package com.v2ray.ang.ui
+
+import android.os.Bundle
+import com.v2ray.ang.R
+import androidx.fragment.app.Fragment
+import com.google.android.material.tabs.TabLayoutMediator
+import com.v2ray.ang.AppConfig
+import com.v2ray.ang.databinding.ActivityRoutingSettingsBinding
+
+class RoutingSettingsActivity : BaseActivity() {
+    private lateinit var binding: ActivityRoutingSettingsBinding
+
+    private val titles: Array<out String> by lazy {
+        resources.getStringArray(R.array.routing_tag)
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        binding = ActivityRoutingSettingsBinding.inflate(layoutInflater)
+        val view = binding.root
+        setContentView(view)
+
+        title = getString(R.string.title_pref_routing_custom)
+        supportActionBar?.setDisplayHomeAsUpEnabled(true)
+
+        val fragments = ArrayList<Fragment>()
+        fragments.add(RoutingSettingsFragment().newInstance(AppConfig.PREF_V2RAY_ROUTING_AGENT))
+        fragments.add(RoutingSettingsFragment().newInstance(AppConfig.PREF_V2RAY_ROUTING_DIRECT))
+        fragments.add(RoutingSettingsFragment().newInstance(AppConfig.PREF_V2RAY_ROUTING_BLOCKED))
+
+        val adapter = FragmentAdapter(this, fragments)
+        binding.viewpager.adapter = adapter
+        //tablayout.setTabTextColors(Color.BLACK, Color.RED)
+        TabLayoutMediator(binding.tablayout, binding.viewpager) { tab, position ->
+            tab.text = titles[position]
+        }.attach()
+    }
+}

V2rayNG/app/src/main/kotlin/com/v2ray/ang/ui/RoutingSettingsFragment.kt

@@ -0,0 +1,158 @@
+package com.v2ray.ang.ui
+
+import android.Manifest
+import android.app.Activity.RESULT_OK
+import android.content.Intent
+import android.os.Bundle
+import android.text.TextUtils
+import android.view.*
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.fragment.app.Fragment
+import androidx.lifecycle.lifecycleScope
+import androidx.preference.PreferenceManager
+import com.tbruyelle.rxpermissions.RxPermissions
+import com.v2ray.ang.AppConfig
+import com.v2ray.ang.R
+import com.v2ray.ang.databinding.FragmentRoutingSettingsBinding
+import com.v2ray.ang.extension.toast
+import com.v2ray.ang.extension.v2RayApplication
+import com.v2ray.ang.util.Utils
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.launch
+
+class RoutingSettingsFragment : Fragment() {
+    private lateinit var binding: FragmentRoutingSettingsBinding
+    companion object {
+        private const val routing_arg = "routing_arg"
+    }
+
+    val defaultSharedPreferences by lazy { PreferenceManager.getDefaultSharedPreferences(requireContext()) }
+
+    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?,
+                              savedInstanceState: Bundle?): View? {
+        // Inflate the layout for this fragment
+        binding = FragmentRoutingSettingsBinding.inflate(layoutInflater)
+        return binding.root// inflater.inflate(R.layout.fragment_routing_settings, container, false)
+    }
+
+    fun newInstance(arg: String): Fragment {
+        val fragment = RoutingSettingsFragment()
+        val bundle = Bundle()
+        bundle.putString(routing_arg, arg)
+        fragment.arguments = bundle
+        return fragment
+    }
+
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        super.onViewCreated(view, savedInstanceState)
+
+        val content = defaultSharedPreferences.getString(requireArguments().getString(routing_arg), "")
+        binding.etRoutingContent.text = Utils.getEditable(content!!)
+
+        setHasOptionsMenu(true)
+    }
+
+    override fun onCreateOptionsMenu(menu: Menu, inflater: MenuInflater) {
+        inflater.inflate(R.menu.menu_routing, menu)
+        return super.onCreateOptionsMenu(menu, inflater)
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem) = when (item.itemId) {
+        R.id.save_routing -> {
+            saveRouting()
+            true
+        }
+        R.id.del_routing -> {
+            binding.etRoutingContent.text = null
+            true
+        }
+        R.id.scan_replace -> {
+            scanQRcode(true)
+            true
+        }
+        R.id.scan_append -> {
+            scanQRcode(false)
+            true
+        }
+        R.id.default_rules -> {
+            setDefaultRules()
+            true
+        }
+        else -> super.onOptionsItemSelected(item)
+    }
+
+    private fun saveRouting() {
+        val content = binding.etRoutingContent.text.toString()
+        defaultSharedPreferences.edit().putString(requireArguments().getString(routing_arg), content).apply()
+        activity?.toast(R.string.toast_success)
+    }
+
+    fun scanQRcode(forReplace: Boolean): Boolean {
+//        try {
+//            startActivityForResult(Intent("com.google.zxing.client.android.SCAN")
+//                    .addCategory(Intent.CATEGORY_DEFAULT)
+//                    .addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP), requestCode)
+//        } catch (e: Exception) {
+        RxPermissions(requireActivity())
+                .request(Manifest.permission.CAMERA)
+                .subscribe {
+                    if (it)
+                        if (forReplace)
+                            scanQRCodeForReplace.launch(Intent(activity, ScannerActivity::class.java))
+                        else
+                            scanQRCodeForAppend.launch(Intent(activity, ScannerActivity::class.java))
+                    else
+                        activity?.toast(R.string.toast_permission_denied)
+                }
+//        }
+        return true
+    }
+
+    private val scanQRCodeForReplace = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) {
+        if (it.resultCode == RESULT_OK) {
+            val content = it.data?.getStringExtra("SCAN_RESULT")
+            binding.etRoutingContent.text = Utils.getEditable(content!!)
+        }
+    }
+
+    private val scanQRCodeForAppend = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) {
+        if (it.resultCode == RESULT_OK) {
+            val content = it.data?.getStringExtra("SCAN_RESULT")
+            binding.etRoutingContent.text = Utils.getEditable("${binding.etRoutingContent.text},$content")
+        }
+    }
+
+    fun setDefaultRules(): Boolean {
+        var url = AppConfig.v2rayCustomRoutingListUrl
+        var tag = ""
+        when (requireArguments().getString(routing_arg)) {
+            AppConfig.PREF_V2RAY_ROUTING_AGENT -> {
+                tag = AppConfig.TAG_AGENT
+            }
+            AppConfig.PREF_V2RAY_ROUTING_DIRECT -> {
+                tag = AppConfig.TAG_DIRECT
+            }
+            AppConfig.PREF_V2RAY_ROUTING_BLOCKED -> {
+                tag = AppConfig.TAG_BLOCKED
+            }
+        }
+        url += tag
+
+        activity?.toast(R.string.msg_downloading_content)
+        lifecycleScope.launch(Dispatchers.IO) {
+            val content = Utils.getUrlContext(url, 5000)
+            launch(Dispatchers.Main) {
+                val routingList = if (TextUtils.isEmpty(content)) {
+                    Utils.readTextFromAssets(activity?.v2RayApplication!!, "custom_routing_$tag")
+                } else {
+                    content
+                }
+                binding.etRoutingContent.text = Utils.getEditable(routingList)
+                saveRouting()
+                //toast(R.string.toast_success)
+            }
+        }
+        return true
+    }
+}

V2rayNG/app/src/main/kotlin/com/v2ray/ang/ui/ScScannerActivity.kt

@@ -0,0 +1,45 @@
+package com.v2ray.ang.ui
+
+import android.Manifest
+import android.content.*
+import com.tbruyelle.rxpermissions.RxPermissions
+import com.v2ray.ang.R
+import com.v2ray.ang.util.AngConfigManager
+import android.os.Bundle
+import androidx.activity.result.contract.ActivityResultContracts
+import com.v2ray.ang.extension.toast
+
+class ScScannerActivity : BaseActivity() {
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_none)
+        importQRcode()
+    }
+
+    fun importQRcode(): Boolean {
+        RxPermissions(this)
+                .request(Manifest.permission.CAMERA)
+                .subscribe {
+                    if (it)
+                        scanQRCode.launch(Intent(this, ScannerActivity::class.java))
+                    else
+                        toast(R.string.toast_permission_denied)
+                }
+
+        return true
+    }
+
+    private val scanQRCode = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) {
+        if (it.resultCode == RESULT_OK) {
+            val count = AngConfigManager.importBatchConfig(it.data?.getStringExtra("SCAN_RESULT"), "", false)
+            if (count > 0) {
+                toast(R.string.toast_success)
+            } else {
+                toast(R.string.toast_failure)
+            }
+            startActivity(Intent(this, MainActivity::class.java))
+        }
+        finish()
+    }
+}

V2rayNG/app/src/main/kotlin/com/v2ray/ang/ui/ScSwitchActivity.kt

@@ -0,0 +1,22 @@
+package com.v2ray.ang.ui
+
+import com.v2ray.ang.R
+import com.v2ray.ang.util.Utils
+import android.os.Bundle
+import com.v2ray.ang.service.V2RayServiceManager
+
+class ScSwitchActivity : BaseActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        moveTaskToBack(true)
+
+        setContentView(R.layout.activity_none)
+
+        if (V2RayServiceManager.v2rayPoint.isRunning) {
+            Utils.stopVService(this)
+        } else {
+            Utils.startVServiceFromToggle(this)
+        }
+        finish()
+    }
+}

V2rayNG/app/src/main/kotlin/com/v2ray/ang/ui/ScannerActivity.kt

@@ -0,0 +1,116 @@
+package com.v2ray.ang.ui
+
+import android.Manifest
+import android.app.Activity
+import android.os.Bundle
+import com.google.zxing.Result
+import me.dm7.barcodescanner.zxing.ZXingScannerView
+import android.content.Intent
+import android.graphics.BitmapFactory
+import android.view.Menu
+import android.view.MenuItem
+import androidx.activity.result.contract.ActivityResultContracts
+import com.google.zxing.BarcodeFormat
+import com.tbruyelle.rxpermissions.RxPermissions
+import com.v2ray.ang.R
+import com.v2ray.ang.extension.toast
+import com.v2ray.ang.util.QRCodeDecoder
+
+class ScannerActivity : BaseActivity(), ZXingScannerView.ResultHandler {
+
+    private var mScannerView: ZXingScannerView? = null
+
+    public override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        mScannerView = ZXingScannerView(this)   // Programmatically initialize the scanner view
+
+        mScannerView?.setAutoFocus(true)
+        val formats = ArrayList<BarcodeFormat>()
+        formats.add(BarcodeFormat.QR_CODE)
+        mScannerView?.setFormats(formats)
+
+        setContentView(mScannerView)                // Set the scanner view as the content view
+
+        supportActionBar?.setDisplayHomeAsUpEnabled(true)
+    }
+
+    public override fun onResume() {
+        super.onResume()
+        mScannerView!!.setResultHandler(this) // Register ourselves as a handler for scan results.
+        mScannerView!!.startCamera()          // Start camera on resume
+    }
+
+    public override fun onPause() {
+        super.onPause()
+        mScannerView!!.stopCamera()           // Stop camera on pause
+    }
+
+    override fun handleResult(rawResult: Result) {
+        // Do something with the result here
+//        Log.v(FragmentActivity.TAG, rawResult.text) // Prints scan results
+//        Log.v(FragmentActivity.TAG, rawResult.barcodeFormat.toString()) // Prints the scan format (qrcode, pdf417 etc.)
+
+        finished(rawResult.text)
+
+        // If you would like to resume scanning, call this method below:
+//        mScannerView!!.resumeCameraPreview(this)
+    }
+
+    private fun finished(text: String) {
+        val intent = Intent()
+        intent.putExtra("SCAN_RESULT", text)
+        setResult(Activity.RESULT_OK, intent)
+        finish()
+    }
+
+    override fun onCreateOptionsMenu(menu: Menu): Boolean {
+        menuInflater.inflate(R.menu.menu_scanner, menu)
+        return true
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem) = when (item.itemId) {
+        R.id.select_photo -> {
+            RxPermissions(this)
+                    .request(Manifest.permission.READ_EXTERNAL_STORAGE)
+                    .subscribe {
+                        if (it) {
+                            try {
+                                showFileChooser()
+                            } catch (e: Exception) {
+                                e.printStackTrace()
+                            }
+                        } else
+                            toast(R.string.toast_permission_denied)
+                    }
+            true
+        }
+        else -> super.onOptionsItemSelected(item)
+    }
+
+    private fun showFileChooser() {
+        val intent = Intent(Intent.ACTION_GET_CONTENT)
+        intent.type = "image/*"
+        intent.addCategory(Intent.CATEGORY_OPENABLE)
+        //intent.putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true)
+
+        try {
+            chooseFile.launch(Intent.createChooser(intent, getString(R.string.title_file_chooser)))
+        } catch (ex: android.content.ActivityNotFoundException) {
+            toast(R.string.toast_require_file_manager)
+        }
+    }
+
+    private val chooseFile = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) {
+        val uri = it.data?.data
+        if (it.resultCode == RESULT_OK && uri != null) {
+            try {
+                val bitmap = BitmapFactory.decodeStream(contentResolver.openInputStream(uri))
+                val text = QRCodeDecoder.syncDecodeQRCode(bitmap)
+                finished(text!!)
+            } catch (e: Exception) {
+                e.printStackTrace()
+                toast(e.message.toString())
+            }
+        }
+    }
+}

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

@@ -0,0 +1,412 @@
+package com.v2ray.ang.ui
+
+import android.os.Bundle
+import android.text.TextUtils
+import android.view.Menu
+import android.view.MenuItem
+import android.view.View
+import android.widget.*
+import androidx.appcompat.app.AlertDialog
+import com.tencent.mmkv.MMKV
+import com.v2ray.ang.AppConfig
+import com.v2ray.ang.AppConfig.PREF_ALLOW_INSECURE
+import com.v2ray.ang.R
+import com.v2ray.ang.dto.EConfigType
+import com.v2ray.ang.dto.ServerConfig
+import com.v2ray.ang.dto.V2rayConfig
+import com.v2ray.ang.dto.V2rayConfig.Companion.DEFAULT_PORT
+import com.v2ray.ang.extension.toast
+import com.v2ray.ang.util.MmkvManager
+import com.v2ray.ang.util.MmkvManager.ID_MAIN
+import com.v2ray.ang.util.MmkvManager.KEY_SELECTED_SERVER
+import com.v2ray.ang.util.Utils
+
+class ServerActivity : BaseActivity() {
+
+    private val mainStorage by lazy { MMKV.mmkvWithID(ID_MAIN, MMKV.MULTI_PROCESS_MODE) }
+    private val settingsStorage by lazy { MMKV.mmkvWithID(MmkvManager.ID_SETTING, MMKV.MULTI_PROCESS_MODE) }
+    private val editGuid by lazy { intent.getStringExtra("guid").orEmpty() }
+    private val isRunning by lazy {
+        intent.getBooleanExtra("isRunning", false)
+                && editGuid.isNotEmpty()
+                && editGuid == mainStorage?.decodeString(KEY_SELECTED_SERVER)
+    }
+    private val createConfigType by lazy {
+        EConfigType.fromInt(intent.getIntExtra("createConfigType", EConfigType.VMESS.value)) ?: EConfigType.VMESS
+    }
+    private val subscriptionId by lazy {
+        intent.getStringExtra("subscriptionId")
+    }
+
+    private val securitys: Array<out String> by lazy {
+        resources.getStringArray(R.array.securitys)
+    }
+    private val shadowsocksSecuritys: Array<out String> by lazy {
+        resources.getStringArray(R.array.ss_securitys)
+    }
+    private val flows: Array<out String> by lazy {
+        resources.getStringArray(R.array.flows)
+    }
+    private val networks: Array<out String> by lazy {
+        resources.getStringArray(R.array.networks)
+    }
+    private val tcpTypes: Array<out String> by lazy {
+        resources.getStringArray(R.array.header_type_tcp)
+    }
+    private val kcpAndQuicTypes: Array<out String> by lazy {
+        resources.getStringArray(R.array.header_type_kcp_and_quic)
+    }
+    private val grpcModes: Array<out String> by lazy {
+        resources.getStringArray(R.array.mode_type_grpc)
+    }
+    private val streamSecuritys: Array<out String> by lazy {
+        resources.getStringArray(R.array.streamsecurityxs)
+    }
+    private val allowinsecures: Array<out String> by lazy {
+        resources.getStringArray(R.array.allowinsecures)
+    }
+    private  val  uTlsItems:  Array<out String> by lazy {
+        resources.getStringArray(R.array.streamsecurity_utls)
+    }
+    private val alpns: Array<out String> by lazy {
+        resources.getStringArray(R.array.streamsecurity_alpn)
+    }
+    // Kotlin synthetics was used, but since it is removed in 1.8. We switch to old manual approach.
+    // We don't use AndroidViewBinding because, it is better to share similar logics for different
+    // protocols. Use findViewById manually ensures the xml are de-coupled with the activity logic.
+    private val et_remarks: EditText by lazy { findViewById(R.id.et_remarks) }
+    private val et_address: EditText by lazy { findViewById(R.id.et_address) }
+    private val et_port: EditText by lazy { findViewById(R.id.et_port) }
+    private val et_id: EditText by lazy { findViewById(R.id.et_id) }
+    private val et_alterId: EditText? by lazy { findViewById(R.id.et_alterId) }
+    private val et_security: EditText? by lazy { findViewById(R.id.et_security) }
+    private val sp_flow: Spinner? by lazy { findViewById(R.id.sp_flow) }
+    private val sp_security: Spinner? by lazy { findViewById(R.id.sp_security) }
+    private val sp_stream_security: Spinner? by lazy { findViewById(R.id.sp_stream_security) }
+    private val sp_allow_insecure: Spinner? by lazy { findViewById(R.id.sp_allow_insecure) }
+    private val et_sni: EditText? by lazy { findViewById(R.id.et_sni) }
+    private val sp_stream_fingerprint: Spinner? by lazy { findViewById(R.id.sp_stream_fingerprint) } //uTLS
+    private val sp_network: Spinner? by lazy { findViewById(R.id.sp_network) }
+    private val sp_header_type: Spinner? by lazy { findViewById(R.id.sp_header_type) }
+    private val sp_header_type_title: TextView? by lazy { findViewById(R.id.sp_header_type_title) }
+    private val et_request_host: EditText? by lazy { findViewById(R.id.et_request_host) }
+    private val et_path: EditText? by lazy { findViewById(R.id.et_path) }
+    private val sp_stream_alpn: Spinner? by lazy { findViewById(R.id.sp_stream_alpn) } //uTLS
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        title = getString(R.string.title_server)
+
+        val config = MmkvManager.decodeServerConfig(editGuid)
+        when(config?.configType ?: createConfigType) {
+            EConfigType.VMESS -> setContentView(R.layout.activity_server_vmess)
+            EConfigType.CUSTOM -> return
+            EConfigType.SHADOWSOCKS -> setContentView(R.layout.activity_server_shadowsocks)
+            EConfigType.SOCKS -> setContentView(R.layout.activity_server_socks)
+            EConfigType.VLESS -> setContentView(R.layout.activity_server_vless)
+            EConfigType.TROJAN -> setContentView(R.layout.activity_server_trojan)
+        }
+        sp_network?.onItemSelectedListener = object : AdapterView.OnItemSelectedListener {
+            override fun onItemSelected(parent: AdapterView<*>?, view: View?, position: Int, id: Long) {
+                val types = transportTypes(networks[position])
+                sp_header_type?.isEnabled = types.size > 1
+                val adapter = ArrayAdapter(this@ServerActivity, android.R.layout.simple_spinner_item, types)
+                adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item)
+                sp_header_type?.adapter = adapter
+                sp_header_type_title?.text = if (networks[position] == "grpc")
+                    getString(R.string.server_lab_mode_type) else
+                    getString(R.string.server_lab_head_type)
+                config?.getProxyOutbound()?.getTransportSettingDetails()?.let { transportDetails ->
+                    sp_header_type?.setSelection(Utils.arrayFind(types, transportDetails[0]))
+                    et_request_host?.text = Utils.getEditable(transportDetails[1])
+                    et_path?.text = Utils.getEditable(transportDetails[2])
+                }
+            }
+            override fun onNothingSelected(parent: AdapterView<*>?) {
+                // do nothing
+            }
+        }
+        if (config != null) {
+            bindingServer(config)
+        } else {
+            clearServer()
+        }
+        supportActionBar?.setDisplayHomeAsUpEnabled(true)
+    }
+
+    /**
+     * bingding seleced server config
+     */
+    private fun bindingServer(config: ServerConfig): Boolean {
+        val outbound = config.getProxyOutbound() ?: return false
+        val streamSetting = config.outboundBean?.streamSettings ?: return false
+
+        et_remarks.text = Utils.getEditable(config.remarks)
+        et_address.text = Utils.getEditable(outbound.getServerAddress().orEmpty())
+        et_port.text = Utils.getEditable(outbound.getServerPort()?.toString() ?: DEFAULT_PORT.toString())
+        et_id.text = Utils.getEditable(outbound.getPassword().orEmpty())
+        et_alterId?.text = Utils.getEditable(outbound.settings?.vnext?.get(0)?.users?.get(0)?.alterId.toString())
+        if (config.configType == EConfigType.SOCKS) {
+            et_security?.text = Utils.getEditable(outbound.settings?.servers?.get(0)?.users?.get(0)?.user.orEmpty())
+        } else if (config.configType == EConfigType.VLESS) {
+            et_security?.text = Utils.getEditable(outbound.getSecurityEncryption().orEmpty())
+            val flow = Utils.arrayFind(flows, outbound.settings?.vnext?.get(0)?.users?.get(0)?.flow.orEmpty())
+            if (flow >= 0) {
+                sp_flow?.setSelection(flow)
+            }
+        } else if (config.configType == EConfigType.TROJAN) {
+            val flow = Utils.arrayFind(flows, outbound.settings?.servers?.get(0)?.flow.orEmpty())
+            if (flow >= 0) {
+                sp_flow?.setSelection(flow)
+            }
+        }
+        val securityEncryptions = if (config.configType == EConfigType.SHADOWSOCKS) shadowsocksSecuritys else securitys
+        val security = Utils.arrayFind(securityEncryptions, outbound.getSecurityEncryption().orEmpty())
+        if (security >= 0) {
+            sp_security?.setSelection(security)
+        }
+
+        val streamSecurity = Utils.arrayFind(streamSecuritys, streamSetting.security)
+        if (streamSecurity >= 0) {
+            sp_stream_security?.setSelection(streamSecurity)
+            (streamSetting.tlsSettings?: streamSetting.xtlsSettings)?.let { tlsSetting ->
+                val allowinsecure = Utils.arrayFind(allowinsecures, tlsSetting.allowInsecure.toString())
+                if (allowinsecure >= 0) {
+                    sp_allow_insecure?.setSelection(allowinsecure)
+                }
+                et_sni?.text = Utils.getEditable(tlsSetting.serverName)
+
+                tlsSetting.fingerprint?.let {
+                    val utlsIndex = Utils.arrayFind(uTlsItems, tlsSetting.fingerprint)
+                    sp_stream_fingerprint?.setSelection(utlsIndex)
+                }
+                tlsSetting.alpn?.let {
+                    val alpnIndex = Utils.arrayFind(alpns, Utils.removeWhiteSpace(tlsSetting.alpn.joinToString())!!)
+                    sp_stream_alpn?.setSelection(alpnIndex)
+                }
+
+            }
+        }
+        val network = Utils.arrayFind(networks, streamSetting.network)
+        if (network >= 0) {
+            sp_network?.setSelection(network)
+        }
+        return true
+    }
+
+    /**
+     * clear or init server config
+     */
+    private fun clearServer(): Boolean {
+        et_remarks.text = null
+        et_address.text = null
+        et_port.text = Utils.getEditable(DEFAULT_PORT.toString())
+        et_id.text = null
+        et_alterId?.text = Utils.getEditable("0")
+        sp_security?.setSelection(0)
+        sp_network?.setSelection(0)
+
+        sp_header_type?.setSelection(0)
+        et_request_host?.text = null
+        et_path?.text = null
+        sp_stream_security?.setSelection(0)
+        sp_allow_insecure?.setSelection(0)
+        et_sni?.text = null
+
+        //et_security.text = null
+        sp_flow?.setSelection(0)
+        return true
+    }
+
+    /**
+     * save server config
+     */
+    private fun saveServer(): Boolean {
+        if (TextUtils.isEmpty(et_remarks.text.toString())) {
+            toast(R.string.server_lab_remarks)
+            return false
+        }
+        if (TextUtils.isEmpty(et_address.text.toString())) {
+            toast(R.string.server_lab_address)
+            return false
+        }
+        val port = Utils.parseInt(et_port.text.toString())
+        if (port <= 0) {
+            toast(R.string.server_lab_port)
+            return false
+        }
+        val config = MmkvManager.decodeServerConfig(editGuid) ?: ServerConfig.create(createConfigType)
+        if (config.configType != EConfigType.SOCKS && TextUtils.isEmpty(et_id.text.toString())) {
+            toast(R.string.server_lab_id)
+            return false
+        }
+        sp_stream_security?.let {
+            if (config.configType == EConfigType.TROJAN && TextUtils.isEmpty(streamSecuritys[it.selectedItemPosition])) {
+                toast(R.string.server_lab_stream_security)
+                return false
+            }
+        }
+        et_alterId?.let {
+            val alterId = Utils.parseInt(it.text.toString())
+            if (alterId < 0) {
+                toast(R.string.server_lab_alterid)
+                return false
+            }
+        }
+
+        config.remarks = et_remarks.text.toString().trim()
+        config.outboundBean?.settings?.vnext?.get(0)?.let { vnext ->
+            saveVnext(vnext, port, config)
+        }
+        config.outboundBean?.settings?.servers?.get(0)?.let { server ->
+            saveServers(server, port, config)
+        }
+        config.outboundBean?.streamSettings?.let {
+            saveStreamSettings(it)
+        }
+        if(config.subscriptionId.isEmpty() && !subscriptionId.isNullOrEmpty()) {
+            config.subscriptionId = subscriptionId!!
+        }
+
+        MmkvManager.encodeServerConfig(editGuid, config)
+        toast(R.string.toast_success)
+        finish()
+        return true
+    }
+
+    private fun saveVnext(vnext: V2rayConfig.OutboundBean.OutSettingsBean.VnextBean, port: Int, config: ServerConfig) {
+        vnext.address = et_address.text.toString().trim()
+        vnext.port = port
+        vnext.users[0].id = et_id.text.toString().trim()
+        if (config.configType == EConfigType.VMESS) {
+            vnext.users[0].alterId = Utils.parseInt(et_alterId?.text.toString())
+            vnext.users[0].security = securitys[sp_security?.selectedItemPosition ?: 0]
+        } else if (config.configType == EConfigType.VLESS) {
+            vnext.users[0].encryption = et_security?.text.toString().trim()
+            vnext.users[0].flow = flows[sp_flow?.selectedItemPosition ?: 0]
+        }
+    }
+
+    private fun saveServers(server: V2rayConfig.OutboundBean.OutSettingsBean.ServersBean, port: Int, config: ServerConfig) {
+        server.address = et_address.text.toString().trim()
+        server.port = port
+        if (config.configType == EConfigType.SHADOWSOCKS) {
+            server.password = et_id.text.toString().trim()
+            server.method = shadowsocksSecuritys[sp_security?.selectedItemPosition ?: 0]
+        } else if (config.configType == EConfigType.SOCKS) {
+            if (TextUtils.isEmpty(et_security?.text) && TextUtils.isEmpty(et_id.text)) {
+                server.users = null
+            } else {
+                val socksUsersBean = V2rayConfig.OutboundBean.OutSettingsBean.ServersBean.SocksUsersBean()
+                socksUsersBean.user = et_security?.text.toString().trim()
+                socksUsersBean.pass = et_id.text.toString().trim()
+                server.users = listOf(socksUsersBean)
+            }
+        } else if (config.configType == EConfigType.TROJAN) {
+            server.password = et_id.text.toString().trim()
+            server.flow =
+                    if (streamSecuritys[sp_stream_security?.selectedItemPosition ?: 0] == V2rayConfig.XTLS) {
+                        flows[sp_flow?.selectedItemPosition ?: 0]
+                    } else {
+                        ""
+                    }
+        }
+    }
+
+    private fun saveStreamSettings(streamSetting: V2rayConfig.OutboundBean.StreamSettingsBean) {
+        val network = sp_network?.selectedItemPosition ?: return
+        val type = sp_header_type?.selectedItemPosition ?: return
+        val requestHost = et_request_host?.text?.toString()?.trim() ?: return
+        val path = et_path?.text?.toString()?.trim() ?: return
+        val sniField = et_sni?.text?.toString()?.trim() ?: return
+        val allowInsecureField = sp_allow_insecure?.selectedItemPosition ?: return
+        val streamSecurity = sp_stream_security?.selectedItemPosition ?: return
+        var utlsIndex = sp_stream_fingerprint?.selectedItemPosition ?: return
+        var alpnIndex = sp_stream_alpn?.selectedItemPosition ?: return
+
+        var sni = streamSetting.populateTransportSettings(
+                transport = networks[network],
+                headerType = transportTypes(networks[network])[type],
+                host = requestHost,
+                path = path,
+                seed = path,
+                quicSecurity = requestHost,
+                key = path,
+                mode = transportTypes(networks[network])[type],
+                serviceName = path
+        )
+        if (sniField.isNotBlank()) {
+            sni = sniField
+        }
+        val allowInsecure = if (allowinsecures[allowInsecureField].isBlank()) {
+            settingsStorage?.decodeBool(PREF_ALLOW_INSECURE) ?: false
+        } else {
+            allowinsecures[allowInsecureField].toBoolean()
+        }
+
+        streamSetting.populateTlsSettings(streamSecuritys[streamSecurity], allowInsecure, sni, uTlsItems[utlsIndex], alpns[alpnIndex])
+    }
+
+    private fun transportTypes(network: String?): Array<out String> {
+        return if (network == "tcp") {
+            tcpTypes
+        } else if (network == "kcp" || network == "quic") {
+            kcpAndQuicTypes
+        } else if (network == "grpc") {
+            grpcModes
+        } else {
+            arrayOf("---")
+        }
+    }
+
+    /**
+     * save server config
+     */
+    private fun deleteServer(): Boolean {
+        if (editGuid.isNotEmpty()) {
+            if (editGuid != mainStorage?.decodeString(MmkvManager.KEY_SELECTED_SERVER)) {
+                if (settingsStorage?.decodeBool(AppConfig.PREF_CONFIRM_REMOVE) == true) {
+                    AlertDialog.Builder(this).setMessage(R.string.del_config_comfirm)
+                        .setPositiveButton(android.R.string.ok) { _, _ ->
+                            MmkvManager.removeServer(editGuid)
+                            finish()
+                        }
+                        .show()
+                } else {
+                    MmkvManager.removeServer(editGuid)
+                    finish()
+                }
+            }
+        }
+        return true
+    }
+
+    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
+        }
+
+        return super.onCreateOptionsMenu(menu)
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem) = when (item.itemId) {
+        R.id.del_config -> {
+            deleteServer()
+            true
+        }
+        R.id.save_config -> {
+            saveServer()
+            true
+        }
+        else -> super.onOptionsItemSelected(item)
+    }
+}

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

@@ -0,0 +1,144 @@
+package com.v2ray.ang.ui
+
+import android.os.Bundle
+import android.text.TextUtils
+import android.view.Menu
+import android.view.MenuItem
+import android.widget.Toast
+import androidx.appcompat.app.AlertDialog
+import com.blacksquircle.ui.language.json.JsonLanguage
+import com.google.gson.*
+import com.tencent.mmkv.MMKV
+import com.v2ray.ang.R
+import com.v2ray.ang.databinding.ActivityServerCustomConfigBinding
+import com.v2ray.ang.dto.EConfigType
+import com.v2ray.ang.dto.ServerConfig
+import com.v2ray.ang.dto.V2rayConfig
+import com.v2ray.ang.extension.toast
+import com.v2ray.ang.util.MmkvManager
+import com.v2ray.ang.util.Utils
+import me.drakeet.support.toast.ToastCompat
+
+class ServerCustomConfigActivity : BaseActivity() {
+    private lateinit var binding: ActivityServerCustomConfigBinding
+
+    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 editGuid by lazy { intent.getStringExtra("guid").orEmpty() }
+    private val isRunning by lazy {
+        intent.getBooleanExtra("isRunning", false)
+                && editGuid.isNotEmpty()
+                && editGuid == mainStorage?.decodeString(MmkvManager.KEY_SELECTED_SERVER)
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        binding = ActivityServerCustomConfigBinding.inflate(layoutInflater)
+        val view = binding.root
+        setContentView(view)
+        title = getString(R.string.title_server)
+
+        binding.editor.language = JsonLanguage()
+        val config = MmkvManager.decodeServerConfig(editGuid)
+        if (config != null) {
+            bindingServer(config)
+        } else {
+            clearServer()
+        }
+        supportActionBar?.setDisplayHomeAsUpEnabled(true)
+    }
+
+    /**
+     * bingding seleced server config
+     */
+    private fun bindingServer(config: ServerConfig): Boolean {
+        binding.etRemarks.text = Utils.getEditable(config.remarks)
+        val raw = serverRawStorage?.decodeString(editGuid)
+        if (raw.isNullOrBlank()) {
+            binding.editor.setTextContent(Utils.getEditable(config.fullConfig?.toPrettyPrinting().orEmpty()))
+        } else {
+            binding.editor.setTextContent(Utils.getEditable(raw))
+        }
+        return true
+    }
+
+    /**
+     * clear or init server config
+     */
+    private fun clearServer(): Boolean {
+        binding.etRemarks.text = null
+        return true
+    }
+
+    /**
+     * save server config
+     */
+    private fun saveServer(): Boolean {
+        if (TextUtils.isEmpty(binding.etRemarks.text.toString())) {
+            toast(R.string.server_lab_remarks)
+            return false
+        }
+
+        val v2rayConfig = try {
+            Gson().fromJson(binding.editor.text.toString(), V2rayConfig::class.java)
+        } catch (e: Exception) {
+            e.printStackTrace()
+            ToastCompat.makeText(this, "${getString(R.string.toast_malformed_josn)} ${e.cause?.message}", Toast.LENGTH_LONG).show()
+            return false
+        }
+
+        val config = MmkvManager.decodeServerConfig(editGuid) ?: ServerConfig.create(EConfigType.CUSTOM)
+        config.remarks = binding.etRemarks.text.toString().trim()
+        config.fullConfig = v2rayConfig
+
+        MmkvManager.encodeServerConfig(editGuid, config)
+        serverRawStorage?.encode(editGuid, binding.editor.text.toString())
+        toast(R.string.toast_success)
+        finish()
+        return true
+    }
+
+    /**
+     * save server config
+     */
+    private fun deleteServer(): Boolean {
+        if (editGuid.isNotEmpty()) {
+            AlertDialog.Builder(this).setMessage(R.string.del_config_comfirm)
+                    .setPositiveButton(android.R.string.ok) { _, _ ->
+                        MmkvManager.removeServer(editGuid)
+                        finish()
+                    }
+                    .show()
+        }
+        return true
+    }
+
+    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
+        }
+
+        return super.onCreateOptionsMenu(menu)
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem) = when (item.itemId) {
+        R.id.del_config -> {
+            deleteServer()
+            true
+        }
+        R.id.save_config -> {
+            saveServer()
+            true
+        }
+        else -> super.onOptionsItemSelected(item)
+    }
+}

V2rayNG/app/src/main/kotlin/com/v2ray/ang/ui/SettingsActivity.kt

@@ -0,0 +1,182 @@
+package com.v2ray.ang.ui
+
+import android.content.Intent
+import android.os.Bundle
+import android.text.TextUtils
+import android.view.View
+import androidx.activity.viewModels
+import androidx.preference.*
+import com.v2ray.ang.AppConfig
+import com.v2ray.ang.R
+import com.v2ray.ang.util.Utils
+import com.v2ray.ang.viewmodel.SettingsViewModel
+
+class SettingsActivity : BaseActivity() {
+    private val settingsViewModel: SettingsViewModel by viewModels()
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_settings)
+
+        title = getString(R.string.title_settings)
+
+        supportActionBar?.setDisplayHomeAsUpEnabled(true)
+
+        settingsViewModel.startListenPreferenceChange()
+    }
+
+    class SettingsFragment : PreferenceFragmentCompat() {
+        private val perAppProxy by lazy { findPreference<CheckBoxPreference>(AppConfig.PREF_PER_APP_PROXY) }
+        private val localDns by lazy { findPreference<CheckBoxPreference>(AppConfig.PREF_LOCAL_DNS_ENABLED) }
+        private val fakeDns by lazy { findPreference<CheckBoxPreference>(AppConfig.PREF_FAKE_DNS_ENABLED) }
+        private val localDnsPort by lazy { findPreference<EditTextPreference>(AppConfig.PREF_LOCAL_DNS_PORT) }
+        private val vpnDns by lazy { findPreference<EditTextPreference>(AppConfig.PREF_VPN_DNS) }
+        //        val autoRestart by lazy { findPreference(PREF_AUTO_RESTART) as CheckBoxPreference }
+        private val remoteDns by lazy { findPreference<EditTextPreference>(AppConfig.PREF_REMOTE_DNS) }
+        private val domesticDns by lazy { findPreference<EditTextPreference>(AppConfig.PREF_DOMESTIC_DNS) }
+        private val socksPort by lazy { findPreference<EditTextPreference>(AppConfig.PREF_SOCKS_PORT) }
+        private val httpPort by lazy { findPreference<EditTextPreference>(AppConfig.PREF_HTTP_PORT) }
+        private val routingCustom by lazy { findPreference<Preference>(AppConfig.PREF_ROUTING_CUSTOM) }
+        //        val licenses: Preference by lazy { findPreference(PREF_LICENSES) }
+//        val feedback: Preference by lazy { findPreference(PREF_FEEDBACK) }
+//        val tgGroup: Preference by lazy { findPreference(PREF_TG_GROUP) }
+
+        private val mode by lazy { findPreference<ListPreference>(AppConfig.PREF_MODE) }
+
+        override fun onCreatePreferences(bundle: Bundle?, s: String?) {
+            addPreferencesFromResource(R.xml.pref_settings)
+
+            routingCustom?.setOnPreferenceClickListener {
+                startActivity(Intent(activity, RoutingSettingsActivity::class.java))
+                false
+            }
+
+//            licenses.onClick {
+//                val fragment = LicensesDialogFragment.Builder(act)
+//                        .setNotices(R.raw.licenses)
+//                        .setIncludeOwnLicense(false)
+//                        .build()
+//                fragment.show((act as AppCompatActivity).supportFragmentManager, null)
+//            }
+//
+//            feedback.onClick {
+//                Utils.openUri(activity, "https://github.com/2dust/v2rayNG/issues")
+//            }
+//            tgGroup.onClick {
+//                //                Utils.openUri(activity, "https://t.me/v2rayN")
+//                val intent = Intent(Intent.ACTION_VIEW, Uri.parse("tg:resolve?domain=v2rayN"))
+//                try {
+//                    startActivity(intent)
+//                } catch (e: Exception) {
+//                    e.printStackTrace()
+//                    toast(R.string.toast_tg_app_not_found)
+//                }
+//            }
+
+            perAppProxy?.setOnPreferenceClickListener {
+                startActivity(Intent(activity, PerAppProxyActivity::class.java))
+                perAppProxy?.isChecked = true
+                false
+            }
+
+            remoteDns?.setOnPreferenceChangeListener { _, any ->
+                // remoteDns.summary = any as String
+                val nval = any as String
+                remoteDns?.summary = if (nval == "") AppConfig.DNS_AGENT else nval
+                true
+            }
+            domesticDns?.setOnPreferenceChangeListener { _, any ->
+                // domesticDns.summary = any as String
+                val nval = any as String
+                domesticDns?.summary = if (nval == "") AppConfig.DNS_DIRECT else nval
+                true
+            }
+
+            localDns?.setOnPreferenceChangeListener{ _, any ->
+                updateLocalDns(any as Boolean)
+                true
+            }
+            localDnsPort?.setOnPreferenceChangeListener { _, any ->
+                val nval = any as String
+                localDnsPort?.summary = if (TextUtils.isEmpty(nval)) AppConfig.PORT_LOCAL_DNS else nval
+                true
+            }
+            vpnDns?.setOnPreferenceChangeListener { _, any ->
+                vpnDns?.summary = any as String
+                true
+            }
+            socksPort?.setOnPreferenceChangeListener { _, any ->
+                val nval = any as String
+                socksPort?.summary = if (TextUtils.isEmpty(nval)) AppConfig.PORT_SOCKS else nval
+                true
+            }
+            httpPort?.setOnPreferenceChangeListener { _, any ->
+                val nval = any as String
+                httpPort?.summary = if (TextUtils.isEmpty(nval)) AppConfig.PORT_HTTP else nval
+                true
+            }
+            mode?.setOnPreferenceChangeListener { _, newValue ->
+                updateMode(newValue.toString())
+                true
+            }
+            mode?.dialogLayoutResource = R.layout.preference_with_help_link
+            //loglevel.summary = "LogLevel"
+        }
+
+        override fun onStart() {
+            super.onStart()
+            val defaultSharedPreferences = PreferenceManager.getDefaultSharedPreferences(requireActivity())
+            updateMode(defaultSharedPreferences.getString(AppConfig.PREF_MODE, "VPN"))
+            var remoteDnsString = defaultSharedPreferences.getString(AppConfig.PREF_REMOTE_DNS, "")
+            domesticDns?.summary = defaultSharedPreferences.getString(AppConfig.PREF_DOMESTIC_DNS, "")
+
+            localDnsPort?.summary = defaultSharedPreferences.getString(AppConfig.PREF_LOCAL_DNS_PORT, AppConfig.PORT_LOCAL_DNS)
+            socksPort?.summary = defaultSharedPreferences.getString(AppConfig.PREF_SOCKS_PORT, AppConfig.PORT_SOCKS)
+            httpPort?.summary = defaultSharedPreferences.getString(AppConfig.PREF_HTTP_PORT, AppConfig.PORT_HTTP)
+
+            if (TextUtils.isEmpty(remoteDnsString)) {
+                remoteDnsString = AppConfig.DNS_AGENT
+            }
+            if (TextUtils.isEmpty(domesticDns?.summary)) {
+                domesticDns?.summary = AppConfig.DNS_DIRECT
+            }
+            remoteDns?.summary = remoteDnsString
+            vpnDns?.summary = defaultSharedPreferences.getString(AppConfig.PREF_VPN_DNS, remoteDnsString)
+
+            if (TextUtils.isEmpty(localDnsPort?.summary)) {
+                localDnsPort?.summary = AppConfig.PORT_LOCAL_DNS
+            }
+            if (TextUtils.isEmpty(socksPort?.summary)) {
+                socksPort?.summary = AppConfig.PORT_SOCKS
+            }
+            if (TextUtils.isEmpty(httpPort?.summary)) {
+                httpPort?.summary = AppConfig.PORT_HTTP
+            }
+        }
+
+        private fun updateMode(mode: String?) {
+            val defaultSharedPreferences = PreferenceManager.getDefaultSharedPreferences(requireActivity())
+            val vpn = mode == "VPN"
+            perAppProxy?.isEnabled = vpn
+            perAppProxy?.isChecked = PreferenceManager.getDefaultSharedPreferences(requireActivity())
+                    .getBoolean(AppConfig.PREF_PER_APP_PROXY, false)
+            localDns?.isEnabled = vpn
+            fakeDns?.isEnabled = vpn
+            localDnsPort?.isEnabled = vpn
+            vpnDns?.isEnabled = vpn
+            if (vpn) {
+                updateLocalDns(defaultSharedPreferences.getBoolean(AppConfig.PREF_LOCAL_DNS_ENABLED, false))
+            }
+        }
+
+        private fun updateLocalDns(enabled: Boolean) {
+            fakeDns?.isEnabled = enabled
+            localDnsPort?.isEnabled = enabled
+            vpnDns?.isEnabled = !enabled
+        }
+    }
+
+    fun onModeHelpClicked(view: View) {
+        Utils.openUri(this, AppConfig.v2rayNGWikiMode)
+    }
+}

V2rayNG/app/src/main/kotlin/com/v2ray/ang/ui/SubEditActivity.kt

@@ -0,0 +1,133 @@
+package com.v2ray.ang.ui
+
+import android.os.Bundle
+import android.text.TextUtils
+import android.view.Menu
+import android.view.MenuItem
+import androidx.appcompat.app.AlertDialog
+import com.google.gson.Gson
+import com.tencent.mmkv.MMKV
+import com.v2ray.ang.R
+import com.v2ray.ang.databinding.ActivitySubEditBinding
+import com.v2ray.ang.dto.SubscriptionItem
+import com.v2ray.ang.extension.toast
+import com.v2ray.ang.util.MmkvManager
+import com.v2ray.ang.util.Utils
+
+class SubEditActivity : BaseActivity() {
+    private lateinit var binding: ActivitySubEditBinding
+
+    var del_config: MenuItem? = null
+    var save_config: MenuItem? = null
+
+    private val subStorage by lazy { MMKV.mmkvWithID(MmkvManager.ID_SUB, MMKV.MULTI_PROCESS_MODE) }
+    private val editSubId by lazy { intent.getStringExtra("subId").orEmpty() }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        binding = ActivitySubEditBinding.inflate(layoutInflater)
+        val view = binding.root
+        setContentView(view)
+        title = getString(R.string.title_sub_setting)
+
+        val json = subStorage?.decodeString(editSubId)
+        if (!json.isNullOrBlank()) {
+            bindingServer(Gson().fromJson(json, SubscriptionItem::class.java))
+        } else {
+            clearServer()
+        }
+        supportActionBar?.setDisplayHomeAsUpEnabled(true)
+    }
+
+    /**
+     * bingding seleced server config
+     */
+    private fun bindingServer(subItem: SubscriptionItem): Boolean {
+        binding.etRemarks.text = Utils.getEditable(subItem.remarks)
+        binding.etUrl.text = Utils.getEditable(subItem.url)
+        binding.chkEnable.isChecked = subItem.enabled
+        return true
+    }
+
+    /**
+     * clear or init server config
+     */
+    private fun clearServer(): Boolean {
+        binding.etRemarks.text = null
+        binding.etUrl.text = null
+        binding.chkEnable.isChecked = true
+        return true
+    }
+
+    /**
+     * save server config
+     */
+    private fun saveServer(): Boolean {
+        val subItem: SubscriptionItem
+        val json = subStorage?.decodeString(editSubId)
+        var subId = editSubId
+        if (!json.isNullOrBlank()) {
+            subItem = Gson().fromJson(json, SubscriptionItem::class.java)
+        } else {
+            subId = Utils.getUuid()
+            subItem = SubscriptionItem()
+        }
+
+        subItem.remarks = binding.etRemarks.text.toString()
+        subItem.url = binding.etUrl.text.toString()
+        subItem.enabled = binding.chkEnable.isChecked
+
+        if (TextUtils.isEmpty(subItem.remarks)) {
+            toast(R.string.sub_setting_remarks)
+            return false
+        }
+//        if (TextUtils.isEmpty(subItem.url)) {
+//            toast(R.string.sub_setting_url)
+//            return false
+//        }
+
+        subStorage?.encode(subId, Gson().toJson(subItem))
+        toast(R.string.toast_success)
+        finish()
+        return true
+    }
+
+    /**
+     * save server config
+     */
+    private fun deleteServer(): Boolean {
+        if (editSubId.isNotEmpty()) {
+            AlertDialog.Builder(this).setMessage(R.string.del_config_comfirm)
+                    .setPositiveButton(android.R.string.ok) { _, _ ->
+                        MmkvManager.removeSubscription(editSubId)
+                        finish()
+                    }
+                    .show()
+        }
+        return true
+    }
+
+    override fun onCreateOptionsMenu(menu: Menu): Boolean {
+        menuInflater.inflate(R.menu.action_server, menu)
+        del_config = menu.findItem(R.id.del_config)
+        save_config = menu.findItem(R.id.save_config)
+
+        if (editSubId.isEmpty()) {
+            del_config?.isVisible = false
+        }
+
+        return super.onCreateOptionsMenu(menu)
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem) = when (item.itemId) {
+        R.id.del_config -> {
+            deleteServer()
+            true
+        }
+        R.id.save_config -> {
+            saveServer()
+            true
+        }
+        else -> super.onOptionsItemSelected(item)
+    }
+}

V2rayNG/app/src/main/kotlin/com/v2ray/ang/ui/SubSettingActivity.kt

@@ -0,0 +1,55 @@
+package com.v2ray.ang.ui
+
+import android.content.Intent
+import androidx.recyclerview.widget.LinearLayoutManager
+import android.view.Menu
+import android.view.MenuItem
+import com.v2ray.ang.R
+import android.os.Bundle
+import com.v2ray.ang.databinding.ActivitySubSettingBinding
+import com.v2ray.ang.dto.SubscriptionItem
+import com.v2ray.ang.util.MmkvManager
+
+class SubSettingActivity : BaseActivity() {
+    private lateinit var binding: ActivitySubSettingBinding
+
+    var subscriptions:List<Pair<String, SubscriptionItem>> = listOf()
+    private val adapter by lazy { SubSettingRecyclerAdapter(this) }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        binding = ActivitySubSettingBinding.inflate(layoutInflater)
+        val view = binding.root
+        setContentView(view)
+
+        title = getString(R.string.title_sub_setting)
+
+        binding.recyclerView.setHasFixedSize(true)
+        binding.recyclerView.layoutManager = LinearLayoutManager(this)
+        binding.recyclerView.adapter = adapter
+
+        supportActionBar?.setDisplayHomeAsUpEnabled(true)
+    }
+
+    override fun onResume() {
+        super.onResume()
+        subscriptions = MmkvManager.decodeSubscriptions()
+        adapter.notifyDataSetChanged()
+    }
+
+    override fun onCreateOptionsMenu(menu: Menu): Boolean {
+        menuInflater.inflate(R.menu.action_sub_setting, menu)
+        menu.findItem(R.id.del_config)?.isVisible = false
+        menu.findItem(R.id.save_config)?.isVisible = false
+
+        return super.onCreateOptionsMenu(menu)
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem) = when (item.itemId) {
+        R.id.add_config -> {
+            startActivity(Intent(this, SubEditActivity::class.java))
+            true
+        }
+        else -> super.onOptionsItemSelected(item)
+    }
+}

V2rayNG/app/src/main/kotlin/com/v2ray/ang/ui/SubSettingRecyclerAdapter.kt

@@ -0,0 +1,50 @@
+package com.v2ray.ang.ui
+
+import android.content.Intent
+import android.graphics.Color
+import android.view.LayoutInflater
+import androidx.recyclerview.widget.RecyclerView
+import android.view.ViewGroup
+import com.google.gson.Gson
+import com.tencent.mmkv.MMKV
+import com.v2ray.ang.R
+import com.v2ray.ang.databinding.ItemRecyclerSubSettingBinding
+import com.v2ray.ang.util.MmkvManager
+
+class SubSettingRecyclerAdapter(val activity: SubSettingActivity) : RecyclerView.Adapter<SubSettingRecyclerAdapter.MainViewHolder>() {
+
+    private var mActivity: SubSettingActivity = activity
+    private val subStorage by lazy { MMKV.mmkvWithID(MmkvManager.ID_SUB, MMKV.MULTI_PROCESS_MODE) }
+
+    override fun getItemCount() = mActivity.subscriptions.size
+
+    override fun onBindViewHolder(holder: MainViewHolder, position: Int) {
+        val subId = mActivity.subscriptions[position].first
+        val subItem = mActivity.subscriptions[position].second
+        holder.itemSubSettingBinding.tvName.text = subItem.remarks
+        holder.itemSubSettingBinding.tvUrl.text = subItem.url
+        if (subItem.enabled) {
+            holder.itemSubSettingBinding.chkEnable.setBackgroundResource(R.color.colorSelected)
+        } else {
+            holder.itemSubSettingBinding.chkEnable.setBackgroundResource(R.color.colorUnselected)
+        }
+        holder.itemView.setBackgroundColor(Color.TRANSPARENT)
+
+        holder.itemSubSettingBinding.layoutEdit.setOnClickListener {
+            mActivity.startActivity(Intent(mActivity, SubEditActivity::class.java)
+                    .putExtra("subId", subId)
+            )
+        }
+        holder.itemSubSettingBinding.infoContainer.setOnClickListener {
+            subItem.enabled = !subItem.enabled
+            subStorage?.encode(subId, Gson().toJson(subItem))
+            notifyItemChanged(position)
+        }
+    }
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): MainViewHolder {
+        return MainViewHolder(ItemRecyclerSubSettingBinding.inflate(LayoutInflater.from(parent.context), parent, false))
+    }
+
+    class MainViewHolder(val itemSubSettingBinding: ItemRecyclerSubSettingBinding) : RecyclerView.ViewHolder(itemSubSettingBinding.root)
+}

V2rayNG/app/src/main/kotlin/com/v2ray/ang/ui/TaskerActivity.kt

@@ -0,0 +1,117 @@
+package com.v2ray.ang.ui
+
+import android.app.Activity
+import android.os.Bundle
+import android.view.View
+import android.widget.ArrayAdapter
+import android.widget.ListView
+import java.util.ArrayList
+import com.v2ray.ang.R
+import android.content.Intent
+import android.text.TextUtils
+import android.view.Menu
+import android.view.MenuItem
+import com.google.zxing.WriterException
+import com.tencent.mmkv.MMKV
+import com.v2ray.ang.AppConfig
+import com.v2ray.ang.databinding.ActivityTaskerBinding
+import com.v2ray.ang.util.MmkvManager
+
+class TaskerActivity : BaseActivity() {
+    private lateinit var binding: ActivityTaskerBinding
+
+    private var listview: ListView? = null
+    private var lstData: ArrayList<String> = ArrayList()
+    private var lstGuid: ArrayList<String> = ArrayList()
+
+    private val serverStorage by lazy { MMKV.mmkvWithID(MmkvManager.ID_SERVER_CONFIG, MMKV.MULTI_PROCESS_MODE) }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        binding = ActivityTaskerBinding.inflate(layoutInflater)
+        val view = binding.root
+        setContentView(view)
+
+        //add def value
+        lstData.add("Default")
+        lstGuid.add(AppConfig.TASKER_DEFAULT_GUID)
+
+        serverStorage?.allKeys()?.forEach { key ->
+            MmkvManager.decodeServerConfig(key)?.let { config ->
+                lstData.add(config.remarks)
+                lstGuid.add(key)
+            }
+        }
+        val adapter = ArrayAdapter(this,
+                android.R.layout.simple_list_item_single_choice, lstData)
+        listview = findViewById<View>(R.id.listview) as ListView
+        listview!!.adapter = adapter
+
+        init()
+    }
+
+    private fun init() {
+        try {
+            val bundle = intent?.getBundleExtra(AppConfig.TASKER_EXTRA_BUNDLE)
+            val switch = bundle?.getBoolean(AppConfig.TASKER_EXTRA_BUNDLE_SWITCH, false)
+            val guid = bundle?.getString(AppConfig.TASKER_EXTRA_BUNDLE_GUID, "")
+
+            if (switch == null || TextUtils.isEmpty(guid)) {
+                return
+            } else {
+                binding.switchStartService.isChecked = switch
+                val pos = lstGuid.indexOf(guid.toString())
+                if (pos >= 0) {
+                    listview?.setItemChecked(pos, true)
+                }
+            }
+        } catch (e: WriterException) {
+            e.printStackTrace()
+
+        }
+    }
+
+    private fun confirmFinish() {
+        val position = listview?.checkedItemPosition
+        if (position == null || position < 0) {
+            return
+        }
+
+        val extraBundle = Bundle()
+        extraBundle.putBoolean(AppConfig.TASKER_EXTRA_BUNDLE_SWITCH, binding.switchStartService.isChecked)
+        extraBundle.putString(AppConfig.TASKER_EXTRA_BUNDLE_GUID, lstGuid[position])
+        val intent = Intent()
+
+        val remarks = lstData[position]
+        val blurb = if (binding.switchStartService.isChecked) {
+            "Start $remarks"
+        } else {
+            "Stop $remarks"
+        }
+
+        intent.putExtra(AppConfig.TASKER_EXTRA_BUNDLE, extraBundle)
+        intent.putExtra(AppConfig.TASKER_EXTRA_STRING_BLURB, blurb)
+        setResult(Activity.RESULT_OK, intent)
+        finish()
+    }
+
+    override fun onCreateOptionsMenu(menu: Menu): Boolean {
+        menuInflater.inflate(R.menu.action_server, menu)
+        val del_config = menu.findItem(R.id.del_config)
+        del_config?.isVisible = false
+        return super.onCreateOptionsMenu(menu)
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem) = when (item.itemId) {
+        R.id.del_config -> {
+            true
+        }
+        R.id.save_config -> {
+            confirmFinish()
+            true
+        }
+        else -> super.onOptionsItemSelected(item)
+    }
+
+}
+

V2rayNG/app/src/main/kotlin/com/v2ray/ang/ui/UrlSchemeActivity.kt

@@ -0,0 +1,51 @@
+package com.v2ray.ang.ui
+
+import android.content.Intent
+import android.net.Uri
+import android.os.Bundle
+import com.google.zxing.WriterException
+import com.v2ray.ang.R
+import com.v2ray.ang.databinding.ActivityLogcatBinding
+import com.v2ray.ang.extension.toast
+import com.v2ray.ang.util.AngConfigManager
+
+class UrlSchemeActivity : BaseActivity() {
+    private lateinit var binding: ActivityLogcatBinding
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        binding = ActivityLogcatBinding.inflate(layoutInflater)
+        val view = binding.root
+        setContentView(view)
+
+        var shareUrl: String = ""
+        try {
+            intent?.apply {
+                when (action) {
+                    Intent.ACTION_SEND -> {
+                        if ("text/plain" == type) {
+                            intent.getStringExtra(Intent.EXTRA_TEXT)?.let {
+                                shareUrl = it
+                            }
+                        }
+                    }
+                    Intent.ACTION_VIEW -> {
+                        val uri: Uri? = intent.data
+                        shareUrl = uri?.getQueryParameter("url")!!
+                    }
+                }
+            }
+            toast(shareUrl)
+            val count = AngConfigManager.importBatchConfig(shareUrl, "", false)
+            if (count > 0) {
+                toast(R.string.toast_success)
+            } else {
+                toast(R.string.toast_failure)
+            }
+            startActivity(Intent(this, MainActivity::class.java))
+            finish()
+        } catch (e: WriterException) {
+            e.printStackTrace()
+        }
+    }
+}

V2rayNG/app/src/main/kotlin/com/v2ray/ang/ui/UserAssetActivity.kt

@@ -0,0 +1,216 @@
+package com.v2ray.ang.ui
+
+import android.Manifest
+import android.annotation.SuppressLint
+import android.content.Intent
+import android.net.Uri
+import android.os.Bundle
+import android.provider.OpenableColumns
+import android.util.Log
+import android.view.*
+import android.view.View.GONE
+import android.view.View.VISIBLE
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.lifecycle.lifecycleScope
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+import com.tbruyelle.rxpermissions.RxPermissions
+import com.tencent.mmkv.MMKV
+import com.v2ray.ang.AppConfig
+import com.v2ray.ang.R
+import com.v2ray.ang.databinding.ActivitySubSettingBinding
+import com.v2ray.ang.databinding.ItemRecyclerUserAssetBinding
+import com.v2ray.ang.extension.toTrafficString
+import com.v2ray.ang.extension.toast
+import com.v2ray.ang.util.MmkvManager
+import com.v2ray.ang.util.Utils
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import java.io.File
+import java.io.FileOutputStream
+import java.net.HttpURLConnection
+import java.net.InetSocketAddress
+import java.net.Proxy
+import java.net.URL
+import java.text.DateFormat
+import java.util.*
+
+class UserAssetActivity : BaseActivity() {
+    private lateinit var binding: ActivitySubSettingBinding
+    private val settingsStorage by lazy { MMKV.mmkvWithID(MmkvManager.ID_SETTING, MMKV.MULTI_PROCESS_MODE) }
+
+    val extDir by lazy { File(Utils.userAssetPath(this)) }
+    val geofiles = arrayOf("geosite.dat", "geoip.dat")
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        binding = ActivitySubSettingBinding.inflate(layoutInflater)
+        val view = binding.root
+        setContentView(view)
+        title = getString(R.string.title_user_asset_setting)
+        supportActionBar?.setDisplayHomeAsUpEnabled(true)
+
+        binding.recyclerView.setHasFixedSize(true)
+        binding.recyclerView.layoutManager = LinearLayoutManager(this)
+        binding.recyclerView.adapter = UserAssetAdapter()
+    }
+
+    override fun onCreateOptionsMenu(menu: Menu): Boolean {
+        menuInflater.inflate(R.menu.menu_asset, menu)
+        return super.onCreateOptionsMenu(menu)
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem) = when (item.itemId) {
+        R.id.add_file -> {
+            showFileChooser()
+            true
+        }
+
+        R.id.download_file -> {
+            downloadGeoFiles()
+            true
+        }
+
+        else -> super.onOptionsItemSelected(item)
+    }
+
+    private fun showFileChooser() {
+        RxPermissions(this).request(Manifest.permission.READ_EXTERNAL_STORAGE).subscribe {
+            if (it) {
+                val intent = Intent(Intent.ACTION_GET_CONTENT)
+                intent.type = "*/*"
+                intent.addCategory(Intent.CATEGORY_OPENABLE)
+
+                try {
+                    chooseFile.launch(
+                        Intent.createChooser(
+                            intent,
+                            getString(R.string.title_file_chooser)
+                        )
+                    )
+                } catch (ex: android.content.ActivityNotFoundException) {
+                    toast(R.string.toast_require_file_manager)
+                }
+            }
+        }
+    }
+
+    private val chooseFile =
+        registerForActivityResult(ActivityResultContracts.StartActivityForResult()) {
+            val uri = it.data?.data
+            if (it.resultCode == RESULT_OK && uri != null) {
+                try {
+                    copyFile(uri)
+                } catch (e: Exception) {
+                    toast(R.string.toast_asset_copy_failed)
+                }
+            }
+        }
+
+    private fun copyFile(uri: Uri): String {
+        val targetFile = File(extDir, getCursorName(uri) ?: uri.toString())
+        contentResolver.openInputStream(uri).use { inputStream ->
+            targetFile.outputStream().use { fileOut ->
+                inputStream?.copyTo(fileOut)
+                toast(R.string.toast_success)
+                binding.recyclerView.adapter?.notifyDataSetChanged()
+            }
+        }
+        return targetFile.path
+    }
+
+    private fun getCursorName(uri: Uri): String? = try {
+        contentResolver.query(uri, null, null, null, null)?.let { cursor ->
+            cursor.run {
+                if (moveToFirst()) getString(getColumnIndexOrThrow(OpenableColumns.DISPLAY_NAME))
+                else null
+            }.also { cursor.close() }
+        }
+    } catch (e: Exception) {
+        e.printStackTrace()
+        null
+    }
+
+    private fun downloadGeoFiles() {
+        val httpPort = Utils.parseInt(settingsStorage?.decodeString(AppConfig.PREF_HTTP_PORT), AppConfig.PORT_HTTP.toInt())
+
+        toast(R.string.msg_downloading_content)
+        geofiles.forEach {
+            //toast(getString(R.string.msg_downloading_content) + it)
+            lifecycleScope.launch(Dispatchers.IO) {
+                val result = downloadGeo(it, 60000, httpPort)
+                launch(Dispatchers.Main) {
+                    if (result) {
+                        toast(getString(R.string.toast_success) + " " + it)
+                        binding.recyclerView.adapter?.notifyDataSetChanged()
+                    } else {
+                        toast(getString(R.string.toast_failure) + " " + it)
+                    }
+                }
+            }
+        }
+    }
+
+    private fun downloadGeo(name: String, timeout: Int, httpPort: Int): Boolean {
+        val url = AppConfig.geoUrl + name
+        val targetTemp = File(extDir, name + "_temp")
+        val target = File(extDir, name)
+        var conn: HttpURLConnection? = null
+        //Log.d(AppConfig.ANG_PACKAGE, url)
+
+        try {
+            conn = URL(url).openConnection(
+                Proxy(
+                    Proxy.Type.HTTP,
+                    InetSocketAddress("127.0.0.1", httpPort)
+                )
+            ) as HttpURLConnection
+            conn.connectTimeout = timeout
+            conn.readTimeout = timeout
+            val inputStream = conn.inputStream
+            val responseCode = conn.responseCode
+            if (responseCode == HttpURLConnection.HTTP_OK) {
+                FileOutputStream(targetTemp).use { output ->
+                    inputStream.copyTo(output)
+                }
+
+                targetTemp.renameTo(target)
+            }
+            return true
+        } catch (e: Exception) {
+            Log.e(AppConfig.ANG_PACKAGE, Log.getStackTraceString(e))
+            return false
+        } finally {
+            conn?.disconnect()
+        }
+    }
+
+    inner class UserAssetAdapter : RecyclerView.Adapter<UserAssetViewHolder>() {
+        override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): UserAssetViewHolder {
+            return UserAssetViewHolder(ItemRecyclerUserAssetBinding.inflate(LayoutInflater.from(parent.context), parent, false))
+        }
+
+        @SuppressLint("SetTextI18n")
+        override fun onBindViewHolder(holder: UserAssetViewHolder, position: Int) {
+            val file = extDir.listFiles()?.getOrNull(position) ?: return
+            holder.itemUserAssetBinding.assetName.text = file.name
+            val dateFormat = DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM)
+            holder.itemUserAssetBinding.assetProperties.text = "${file.length().toTrafficString()}  •  ${dateFormat.format(Date(file.lastModified()))}"
+            if (file.name in geofiles) {
+                holder.itemUserAssetBinding.layoutRemove.visibility = GONE
+            } else {
+                holder.itemUserAssetBinding.layoutRemove.visibility = VISIBLE
+            }
+            holder.itemUserAssetBinding.layoutRemove.setOnClickListener {
+                file.delete()
+                binding.recyclerView.adapter?.notifyItemRemoved(position)
+            }
+        }
+
+        override fun getItemCount(): Int {
+            return extDir.listFiles()?.size ?: 0
+        }
+    }
+
+    class UserAssetViewHolder(val itemUserAssetBinding: ItemRecyclerUserAssetBinding) : RecyclerView.ViewHolder(itemUserAssetBinding.root)
+}