Update 1.8.18

Update dependency

.github/ISSUE_TEMPLATE/bug_cn.md

@@ -0,0 +1,34 @@
+---
+name: v2rayNG程序问题
+about: 创建一个报告来帮助我们改进
+---
+
+在提出问题前请先自行排除服务器端问题，同时也请通过搜索确认是否有人提出过相同问题。
+
+
+### 预期行为
+描述你认为应该发生什么
+
+### 实际行为
+描述实际发生了什么
+
+### 复现方法
+1.
+2.
+3.
+
+### 日志信息
+<details>
+
+通过`adb logcat -s com.v2ray.ang GoLog V2rayConfigUtilGoLog Main`获取日志。请自行删减日志中可能出现的敏感信息。
+
+如果问题可重现，建议先执行`adb logcat -c`清空系统日志再执行上述命令，再操作重现问题。
+```
+在这里粘贴日志
+```
+</details>
+
+### 环境信息
+
+### 额外信息（可选）
+

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name: V2Ray程序问题
+    url: https://github.com/v2fly/v2ray-core/
+    about: 如果您有V2Ray而非v2rayNG的问题，请至这个链接讨论。

.github/workflows/build.yml

@@ -0,0 +1,64 @@
+name: Build APK
+
+on:
+  push:
+  workflow_dispatch:
+    inputs:
+      XRAY_CORE_VERSION:
+        description: 'Xray core version or commit hash'
+        required: false
+
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+      
+    - name: Setup Java
+      uses: actions/setup-java@v4
+      with:
+        distribution: 'temurin'
+        java-version: '17'
+
+    - name: Setup Golang
+      uses: actions/setup-go@v5
+      with:
+        go-version: '1.21.4'
+
+    - name: Install gomobile
+      run: |
+        go install golang.org/x/mobile/cmd/gomobile@latest
+        echo "$(go env GOPATH)/bin" >> $GITHUB_PATH
+
+
+    - name: Setup Android environment
+      uses: android-actions/setup-android@v3
+  
+
+    - name: Build dependencies
+      run: |
+        mkdir ${{ github.workspace }}/build
+        cd ${{ github.workspace }}/build
+        git clone --depth=1 -b main https://github.com/2dust/AndroidLibXrayLite.git
+        cd AndroidLibXrayLite
+        go get github.com/xtls/xray-core@${{ github.event.inputs.XRAY_CORE_VERSION }} || true
+        gomobile init
+        go mod tidy -v
+        gomobile bind -v -androidapi 19 -ldflags='-s -w' ./
+        cp *.aar ${{ github.workspace }}/V2rayNG/app/libs/
+
+    - name: Build APK
+      run: |
+        cd ${{ github.workspace }}/V2rayNG
+        chmod 777 *
+        sed -i 's/org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8/org.gradle.jvmargs=-Xmx2048m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8/' ${{ github.workspace }}/V2rayNG/gradle.properties
+        ./gradlew assembleDebug
+
+    - name: Upload APK
+      uses: actions/upload-artifact@v4
+      with:
+        name: apk
+        path: ${{ github.workspace }}/V2rayNG/app/build/outputs/apk/debug/

.gitignore

@@ -1,12 +1,5 @@
-V2rayNG/app/src/main/res/layout/activity_inapp_buy.xml
-V2rayNG/app/src/main/assets/geoip.dat
-V2rayNG/app/src/main/assets/geosite.dat
-V2rayNG/app/src/main/java/com/v2ray/ang/InappBuyActivity.java
-V2rayNG/gradle/wrapper/gradle-wrapper.properties
-V2rayNG/gradle/wrapper/gradle-wrapper.properties
-*.aar
 *.dat
 *.jks
-V2rayNG/gradle/wrapper/gradle-wrapper.properties
-V2rayNG/gradle/wrapper/gradle-wrapper.properties
-V2rayNG/app/release/output.json
+V2rayNG/app/release/output.json
+.idea/
+.gradle/

AndroidLibV2rayLite/README.md

@@ -0,0 +1,20 @@
+# AndroidLibV2rayLite
+
+### Preparation
+- latest Ubuntu environment
+- At lease 30G free space
+- Get Repo [AndroidLibV2rayLite](https://github.com/2dust/AndroidLibV2rayLite) or [AndroidLibXrayLite](https://github.com/2dust/AndroidLibXrayLite)
+### Prepare Go
+- Go to https://golang.org/doc/install and install latest go
+- Make sure `go version` works as expected
+### Prepare gomobile
+- Go to https://pkg.go.dev/golang.org/x/mobile/cmd/gomobile and install gomobile
+- export PATH=$PATH:~/go/bin
+- Make sure `gomobile init` works as expected
+### Prepare NDK
+- Go to https://developer.android.com/ndk/downloads and install latest NDK
+- export PATH=$PATH:<wherever you ndk is located>
+- Make sure `ndk-build -v` works as expected
+### Make
+- sudo apt install make
+- Read and understand [build script](https://github.com/2dust/AndroidLibV2rayLite/blob/master/Makefile)

CR.md

@@ -1,29 +1,40 @@
-v2rayNG 隐私条款
+**v2rayNG 隐私权政策**
 
-最后更新 2017-11-22
+本政策自2023年11月17日起施行
 
-v2rayNG 尊重并保护所有用户的个人隐私权，为此我们向大众公开这份隐私条款。**您使用 v2rayNG 即代表您以阅读并同意了这份条款，如果您不同意这份条款请立即停止使用并卸载 v2rayNG。**
+2dust 将 v2rayNG 应用程序构建为开源应用程序。 本服务由 2dust 免费提供，并且旨在按原样使用。
 
-1. 信息收集
+v2rayNG 尊重并保护所有用户的个人隐私权，为此我们向大众公开这份隐私权政策。**您使用 v2rayNG 即代表您以阅读并同意了这份条款，如果您不同意这份条款请立即停止使用并卸载 v2rayNG。**
 
-	v2rayNG 软件自身不会发送任何信息到开发者，但是您下载软件的应用市场（如 Google Play）可能会收集关于应用运行状态的相关信息并提供给 v2rayNG 开发者。有关这些信息，请阅读您使用的应用市场所提供的隐私条款。
+**信息收集**
 
-	v2rayNG 软件中可能包含需要通过 IAP 支付解锁的功能，您的支付信息将由相关的 IAP 渠道进行处理，而我们对支付信息没有访问权。
+v2rayNG 软件自身不会发送任何信息到开发者，但是您下载软件的应用市场（如 Google Play）可能会收集关于应用运行状态的相关信息并提供给 v2rayNG 开发者。有关这些信息，请阅读您使用的应用市场所提供的隐私权政策。
 
-	当您向 v2rayNG 开发者反馈软件运行中的错误时，开发者可能会要求您提供软件以及系统的日志以帮助确认问题的原因。因日志中可能包括敏感信息，此类信息只能由您自己操作发送。**我们不对任何传输服务的安全性和隐私性做任何明示或暗示的担保，请您在传送相关信息时选择可以您自身可以接受的方式。**
+v2rayNG 软件中可能包含需要通过 IAP 支付解锁的功能，您的支付信息将由相关的 IAP 渠道进行处理，而我们对支付信息没有访问权。
 
-2. 信息共享
+当您向 v2rayNG 开发者反馈软件运行中的错误时，开发者可能会要求您提供软件以及系统的日志以帮助确认问题的原因。因日志中可能包括敏感信息，此类信息只能由您自己操作发送。**我们不对任何传输服务的安全性和隐私性做任何明示或暗示的担保，请您在传送相关信息时选择可以您自身可以接受的方式。**
 
-	我们不会向任何第三方出售收集到的用户数据。我们可能向外部开发者提供信息以协助软件的开发，但是在提供信息之前我们会传达相关保密义务并确定其可以遵守。
+**信息共享**
 
-3. 信息存留
+我们不会向任何第三方出售收集到的用户数据。我们可能向外部开发者提供信息以协助软件的开发，但是在提供信息之前我们会传达相关保密义务并确定其可以遵守。
 
-	除非有相关法律规定，我们会在 30 天内清除不需要继续使用的用户数据，或将统计数据整合为无法识别单个用户的综合报告。
+**信息存留**
 
-4. 信息泄露
+除非有相关法律规定，我们会在 30 天内清除不需要继续使用的用户数据，或将统计数据整合为无法识别单个用户的综合报告。
 
-	我们会使用合理的技术和安全手段尽力保护用户的数据，但是无法保证数据的绝对安全。如果我们确认数据发生了泄露，我们会在 7 天内通过可用的渠道通知用户。**您同意不向我们追责任何因不可抗力而造成的损失。**
+**信息泄露**
 
-5. 条款修改
+我们会使用合理的技术和安全手段尽力保护用户的数据，但是无法保证数据的绝对安全。如果我们确认数据发生了泄露，我们会在 7 天内通过可用的渠道通知用户。**您同意不向我们追责任何因不可抗力而造成的损失。**
+
+**儿童隐私**
+
+这些服务不针对 13 岁以下的任何人。我不会故意收集 13 岁以下儿童的个人身份信息。 如果我发现 13 岁以下的儿童向我提供了个人信息，我会立即从我们的服务器中删除该信息。 如果您是父母或监护人，并且您知道您的孩子向我们提供了个人信息，请与我联系，以便我能够采取必要的行动。
+
+**条款修改**
+
+我们保留修改这份隐私权政策的权利，但是会确保在更新条款前至少 30 天通过我们的可用渠道和应用内提示来通知用户。**在新条款生效后继续使用软件即表示您同意修改后的隐私权政策。**
+
+**联系我们**
+
+如果您对我的隐私政策有任何疑问或建议，请随时通过 CaptainIronng@protonmail.com 与我联系。
 
-	我们保留修改这份隐私条款的权利，但是会确保在更新条款前至少 30 天通过我们的可用渠道和应用内提示来通知用户。**在新条款生效后继续使用软件即表示您同意修改后的隐私条款。**

README.md

@@ -1,6 +1,36 @@
 # v2rayNG
 
+A V2Ray client for Android, support [Xray core](https://github.com/XTLS/Xray-core) and [v2fly core](https://github.com/v2fly/v2ray-core)
+
+[![API](https://img.shields.io/badge/API-21%2B-yellow.svg?style=flat)](https://developer.android.com/about/versions/lollipop)
+[![Kotlin Version](https://img.shields.io/badge/Kotlin-1.6.21-blue.svg)](https://kotlinlang.org)
+[![GitHub commit activity](https://img.shields.io/github/commit-activity/m/2dust/v2rayNG)](https://github.com/2dust/v2rayNG/commits/master)
+[![CodeFactor](https://www.codefactor.io/repository/github/2dust/v2rayng/badge)](https://www.codefactor.io/repository/github/2dust/v2rayng)
+[![GitHub Releases](https://img.shields.io/github/downloads/2dust/v2rayNG/latest/total?logo=github)](https://github.com/2dust/v2rayNG/releases)
+[![Chat on Telegram](https://img.shields.io/badge/Chat%20on-Telegram-brightgreen.svg)](https://t.me/v2rayn)
+
 <a href="https://play.google.com/store/apps/details?id=com.v2ray.ang">
 <img alt="Get it on Google Play" src="https://play.google.com/intl/en_us/badges/images/generic/en_badge_web_generic.png" width="165" height="64" />
 </a>
 
+### Telegram Channel
+[github_2dust](https://t.me/github_2dust)
+
+### Usage
+
+#### Geoip and Geosite
+- geoip.dat and geosite.dat files are in `Android/data/com.v2ray.ang/files/assets` (path may differ on some Android device)
+- download feature will get enhanced version in this [repo](https://github.com/Loyalsoldier/v2ray-rules-dat) (Note it need a working proxy)
+- latest official [domain list](https://github.com/v2fly/domain-list-community) and [ip list](https://github.com/v2fly/geoip) can be imported manually
+- possible to use third party dat file in the same folder, like [h2y](https://guide.v2fly.org/routing/sitedata.html#%E5%A4%96%E7%BD%AE%E7%9A%84%E5%9F%9F%E5%90%8D%E6%96%87%E4%BB%B6)
+
+### More in our [wiki](https://github.com/2dust/v2rayNG/wiki)
+
+### Development guide
+
+Android project under V2rayNG folder can be compiled directly in Android Studio, or using Gradle wrapper. But the v2ray core inside the aar is (probably) outdated.  
+The aar can be compiled from the Golang project [AndroidLibV2rayLite](https://github.com/2dust/AndroidLibV2rayLite) or [AndroidLibXrayLite](https://github.com/2dust/AndroidLibXrayLite).
+For a quick start, read guide for [Go Mobile](https://github.com/golang/go/wiki/Mobile) and [Makefiles for Go Developers](https://tutorialedge.net/golang/makefiles-for-go-developers/)
+
+v2rayNG can run on Android Emulators. For WSA, VPN permission need to be granted via
+`appops set [package name] ACTIVATE_VPN allow`

V2rayNG/.gitignore

@@ -7,3 +7,4 @@
 /captures
 *.apk
 signing.properties
+*.aar

V2rayNG/app/build.gradle

@@ -1,129 +0,0 @@
-apply plugin: 'com.android.application'
-apply plugin: 'kotlin-android'
-apply plugin: 'kotlin-android-extensions'
-
-android {
-    compileSdkVersion 27
-    buildToolsVersion '27.0.3'
-
-    compileOptions {
-        targetCompatibility = "8"
-        sourceCompatibility = "8"
-    }
-
-    defaultConfig {
-        applicationId "com.v2ray.ang"
-        minSdkVersion 17
-        targetSdkVersion Integer.parseInt("$targetSdkVer")
-        multiDexEnabled true
-        versionCode 206
-        versionName "0.6.21"
-    }
-
-    signingConfigs {
-        release {
-            storeFile file("../key.jks")
-            keyAlias 'ang'
-            keyPassword '123456'
-            storePassword '123456'
-        }
-        debug {
-            storeFile file("../key.jks")
-            keyAlias 'ang'
-            keyPassword '123456'
-            storePassword '123456'
-        }
-    }
-
-    buildTypes {
-        release {
-            minifyEnabled false
-            zipAlignEnabled false
-            shrinkResources false
-            signingConfig signingConfigs.release
-//            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
-        }
-        debug {
-            minifyEnabled false
-            zipAlignEnabled false
-            shrinkResources false
-            signingConfig signingConfigs.release
-        }
-    }
-
-    sourceSets {
-        main.java.srcDirs += 'src/main/kotlin'
-    }
-
-    splits {
-        abi {
-            enable true
-            reset()
-            include 'x86', 'x86_64', 'armeabi-v7a', 'arm64-v8a' //select ABIs to build APKs for
-            universalApk true //generate an additional APK that contains all the ABIs
-        }
-    }
-
-    // map for the version code
-    project.ext.versionCodes = ['armeabi-v7a': 1, 'arm64-v8a': 2, 'x86': 3, 'x86_64': 4]
-
-    android.applicationVariants.all { variant ->
-        // assign different version code for each output
-        variant.outputs.each { output ->
-            output.versionCodeOverride =
-                    project.ext.versionCodes.get(output.getFilter(com.android.build.OutputFile.ABI), 0) *
-                            1000000 + android.defaultConfig.versionCode
-        }
-    }
-}
-
-dependencies {
-    implementation fileTree(include: ['*.jar'], dir: 'libs')
-    implementation 'com.android.support.constraint:constraint-layout:1.1.3'
-    testImplementation 'junit:junit:4.12'
-    implementation project(':dpreference')
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion"
-    implementation "org.jetbrains.kotlin:kotlin-reflect:$kotlinVersion"
-    // Android support library
-    implementation "com.android.support:support-v4:$supportLibVersion"
-    implementation "com.android.support:appcompat-v7:$supportLibVersion"
-    implementation "com.android.support:design:$supportLibVersion"
-    implementation "com.android.support:cardview-v7:$supportLibVersion"
-    implementation "com.android.support:preference-v7:$supportLibVersion"
-    implementation "com.android.support:recyclerview-v7:$supportLibVersion"
-    // DSL
-    implementation "org.jetbrains.anko:anko-sdk15:$ankoVersion"
-    implementation "org.jetbrains.anko:anko-support-v4:$ankoVersion"
-    implementation "org.jetbrains.anko:anko-appcompat-v7:$ankoVersion"
-    implementation "org.jetbrains.anko:anko-design:$ankoVersion"
-    implementation 'com.google.code.gson:gson:2.8.2'
-    implementation 'io.reactivex:rxjava:1.3.4'
-    implementation 'io.reactivex:rxandroid:1.2.1'
-    implementation 'com.tbruyelle.rxpermissions:rxpermissions:0.9.4@aar'
-    implementation 'com.dinuscxj:recycleritemdecoration:1.0.0'
-    implementation 'io.reactivex:rxkotlin:0.60.0'
-    implementation 'me.dm7.barcodescanner:core:1.9.8'
-    implementation 'me.dm7.barcodescanner:zxing:1.9.8'
-    implementation 'com.github.jorgecastilloprz:fabprogresscircle:1.01@aar'
-    implementation 'com.beust:klaxon:3.0.1'
-    implementation 'com.android.support:multidex:1.0.3'
-
-    implementation(name: 'libv2ray', ext: 'aar')
-    //implementation(name: 'tun2socks', ext: 'aar')
-}
-
-buildscript {
-    repositories {
-        google()
-        jcenter()
-        maven { url 'https://maven.google.com' }
-    }
-    dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-android-extensions:$kotlinVersion"
-    }
-}
-repositories {
-    flatDir {
-        dirs 'libs'
-    }
-}

V2rayNG/app/build.gradle.kts

@@ -0,0 +1,124 @@
+plugins {
+    id("com.android.application")
+    id("org.jetbrains.kotlin.android")
+}
+
+android {
+    namespace = "com.v2ray.ang"
+    compileSdk = 34
+
+    defaultConfig {
+        applicationId = "com.v2ray.ang"
+        minSdk = 21
+        targetSdk = 34
+        versionCode = 550
+        versionName = "1.8.18"
+        multiDexEnabled = true
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_1_8
+        targetCompatibility = JavaVersion.VERSION_1_8
+    }
+    buildTypes {
+        release {
+            isMinifyEnabled = false
+
+        }
+        debug {
+            isMinifyEnabled = false
+
+        }
+    }
+
+    sourceSets {
+        getByName("main") {
+            jniLibs.srcDirs("libs")
+        }
+    }
+
+    kotlinOptions {
+        jvmTarget = JavaVersion.VERSION_1_8.toString()
+    }
+
+    splits {
+        abi {
+            isEnable = true
+            isUniversalApk = true
+        }
+    }
+
+    applicationVariants.all {
+        val variant = this
+        val versionCodes =
+            mapOf("armeabi-v7a" to 1, "arm64-v8a" to 2, "x86" to 3, "x86_64" to 4)
+
+        variant.outputs
+            .map { it as com.android.build.gradle.internal.api.ApkVariantOutputImpl }
+            .forEach { output ->
+                val abi = if (output.getFilter("ABI") != null)
+                    output.getFilter("ABI")
+                else
+                    "all"
+
+                output.outputFileName = "v2rayNG_${variant.versionName}_${abi}.apk"
+                if(versionCodes.containsKey(abi))
+                {
+                    output.versionCodeOverride = (1000000 * versionCodes[abi]!!).plus(variant.versionCode)
+                }
+                else
+                {
+                    return@forEach
+                }
+            }
+    }
+
+    buildFeatures {
+        viewBinding = true
+        buildConfig = true
+    }
+}
+
+dependencies {
+    implementation(fileTree(mapOf("dir" to "libs", "include" to listOf("*.aar","*.jar"))))
+    testImplementation("junit:junit:4.13.2")
+
+    // Androidx
+    implementation("androidx.constraintlayout:constraintlayout:2.1.4")
+    implementation("androidx.legacy:legacy-support-v4:1.0.0")
+    implementation("androidx.appcompat:appcompat:1.6.1")
+    implementation("com.google.android.material:material:1.11.0")
+    implementation("androidx.cardview:cardview:1.0.0")
+    implementation("androidx.preference:preference-ktx:1.2.1")
+    implementation("androidx.recyclerview:recyclerview:1.3.2")
+    implementation("androidx.fragment:fragment-ktx:1.6.2")
+    implementation("androidx.multidex:multidex:2.0.1")
+    implementation("androidx.viewpager2:viewpager2:1.1.0-beta02")
+
+    // Androidx ktx
+    implementation("androidx.activity:activity-ktx:1.8.2")
+    implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:2.7.0")
+    implementation("androidx.lifecycle:lifecycle-livedata-ktx:2.7.0")
+    implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.7.0")
+
+    //kotlin
+    implementation("org.jetbrains.kotlin:kotlin-reflect:1.9.23")
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.8.0")
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.8.0")
+
+    implementation("com.tencent:mmkv-static:1.3.3")
+    implementation("com.google.code.gson:gson:2.10.1")
+    implementation("io.reactivex:rxjava:1.3.8")
+    implementation("io.reactivex:rxandroid:1.2.1")
+    implementation("com.tbruyelle.rxpermissions:rxpermissions:0.9.4@aar")
+    implementation("com.github.jorgecastilloprz:fabprogresscircle:1.01@aar")
+    implementation("me.drakeet.support:toastcompat:1.1.0")
+    implementation("com.blacksquircle.ui:editorkit:2.9.0")
+    implementation("com.blacksquircle.ui:language-base:2.9.0")
+    implementation("com.blacksquircle.ui:language-json:2.9.0")
+    implementation("io.github.g00fy2.quickie:quickie-bundled:1.9.0")
+    implementation("com.google.zxing:core:3.5.3")
+
+    implementation("androidx.work:work-runtime-ktx:2.8.1")
+    implementation("androidx.work:work-multiprocess:2.8.1")
+}

V2rayNG/app/proguard-rules.pro

@@ -1,61 +0,0 @@
-# Add project specific ProGuard rules here.
-# By default, the flags in this file are appended to flags specified
-# in G:\android-sdk/tools/proguard/proguard-android.txt
-# You can edit the include path and order by changing the proguardFiles
-# directive in build.gradle.
-#
-# For more details, see
-#   http://developer.android.com/guide/developing/tools/proguard.html
-
-# Add any project specific keep options here:
-
-# If your project uses WebView with JS, uncomment the following
-# and specify the fully qualified class name to the JavaScript interface
-# class:
-#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
-#   public *;
-#}
-
-# Gson uses generic type information stored in a class file when working with fields. Proguard
-# removes such information by default, so configure it to keep all of it.
--keepattributes Signature
-
-# For using GSON @Expose annotation
--keepattributes *Annotation*
-
-# Gson specific classes
--keep class sun.misc.Unsafe { *; }
-
--dontwarn org.apache.commons.**
--keep class org.apache.commons.** { *;}
-
-# Disable debug info output
--assumenosideeffects class android.util.Log {
-    public static boolean isLoggable(java.lang.String,int);
-    public static int v(...);
-    public static int i(...);
-    public static int w(...);
-    public static int d(...);
-    public static int e(...);
-}
--assumenosideeffects class kotlin.jvm.internal.Intrinsics {
-    static void checkParameterIsNotNull(java.lang.Object, java.lang.String);
-    static void checkExpressionValueIsNotNull(java.lang.Object, java.lang.String);
-    static void throwUninitializedPropertyAccessException(java.lang.String);
-}
-
--dontwarn org.jetbrains.anko.internals.**
--keep class org.jetbrains.anko.internals.** { *;}
-
--dontwarn rx.internal.util.unsafe.**
--keep class rx.internal.util.unsafe.** { *;}
-
--dontwarn app.dinus.**
--keep class app.dinus.** { *;}
-
--keepclassmembers class ** {
-    @com.hwangjr.rxbus.annotation.Subscribe public *;
-    @com.hwangjr.rxbus.annotation.Produce public *;
-}
-
--keep class libv2ray.** { *;}

V2rayNG/app/src/androidTest/java/com/v2ray/ang/ApplicationTest.java

@@ -1,13 +0,0 @@
-package com.v2ray.ang;
-
-import android.app.Application;
-import android.test.ApplicationTestCase;
-
-/**
- * <a href="http://d.android.com/tools/testing/testing_android.html">Testing Fundamentals</a>
- */
-public class ApplicationTest extends ApplicationTestCase<Application> {
-    public ApplicationTest() {
-        super(Application.class);
-    }
-}

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

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <item name="app_name" type="string">v2rayNG (DEV)</item>
+</resources>

V2rayNG/app/src/main/AndroidManifest.xml

@@ -1,72 +1,132 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="com.v2ray.ang">
+    xmlns:tools="http://schemas.android.com/tools"
+    tools:ignore="MissingLeanbackLauncher">
 
-    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
-    <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE"/>
+    <supports-screens
+        android:anyDensity="true"
+        android:smallScreens="true"
+        android:normalScreens="true"
+        android:largeScreens="true"
+        android:xlargeScreens="true"/>
+
+    <uses-sdk android:minSdkVersion="21" tools:overrideLibrary="com.blacksquircle.ui.editorkit"/>
+
+    <uses-feature android:name="android.hardware.camera" android:required="false"/>
+    <uses-feature android:name="android.hardware.camera.autofocus" android:required="false"/>
+    <uses-feature android:name="android.software.leanback" android:required="false" />
+    <uses-feature android:name="android.hardware.touchscreen" android:required="false" />
+
+    <!-- https://developer.android.com/about/versions/11/privacy/package-visibility -->
+    <uses-permission android:name="android.permission.QUERY_ALL_PACKAGES"
+            tools:ignore="QueryAllPackagesPermission" />
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
     <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
-    <!-- <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" /> -->
+    <!-- <useapplications-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" /> -->
     <uses-permission android:name="android.permission.CAMERA" />
-    <uses-permission android:name="com.android.vending.BILLING" />
-
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <uses-permission
+        android:name="android.permission.FOREGROUND_SERVICE_SPECIAL_USE"
+        android:minSdkVersion="34" />
     <!-- <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" /> -->
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS"/>
+    <uses-permission android:name="android.permission.READ_MEDIA_IMAGES" />
+
+
     <application
         android:name=".AngApplication"
         android:allowBackup="true"
         android:icon="@mipmap/ic_launcher"
+        android:banner="@mipmap/ic_banner"
         android:label="@string/app_name"
         android:supportsRtl="true"
-        android:theme="@style/AppTheme">
+        android:theme="@style/AppThemeDayNight"
+        android:usesCleartextTraffic="true"
+        tools:targetApi="m">
+
         <activity
             android:name=".ui.MainActivity"
-            android:theme="@style/AppTheme.NoActionBar"
-            android:launchMode="singleTask">
+            android:exported="true"
+            android:launchMode="singleTask"
+            android:theme="@style/AppThemeDayNight.NoActionBar">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
-
                 <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-            <intent-filter>
-                <action android:name="android.intent.action.SEND" />
-
-                <category android:name="android.intent.category.DEFAULT" />
-
-                <data android:mimeType="text/plain" />
+<!--                <category android:name="android.intent.category.LEANBACK_LAUNCHER"/>-->
             </intent-filter>
             <intent-filter>
                 <action android:name="android.service.quicksettings.action.QS_TILE_PREFERENCES" />
             </intent-filter>
-
             <meta-data
                 android:name="android.app.shortcuts"
                 android:resource="@xml/shortcuts" />
         </activity>
         <activity
+            android:exported="false"
             android:name=".ui.ServerActivity"
             android:windowSoftInputMode="stateUnchanged" />
         <activity
-            android:name=".ui.Server2Activity"
+            android:exported="false"
+            android:name=".ui.ServerCustomConfigActivity"
             android:windowSoftInputMode="stateUnchanged" />
         <activity
-            android:name=".ui.Server3Activity"
-            android:windowSoftInputMode="stateUnchanged" />
+            android:exported="false"
+            android:name=".ui.SettingsActivity" />
         <activity
-            android:name=".ui.Server4Activity"
-            android:windowSoftInputMode="stateUnchanged" />
-        <activity android:name=".ui.SettingsActivity" />
-        <activity android:name=".ui.PerAppProxyActivity" />
-        <activity android:name=".ui.ScannerActivity" />
-        <activity android:name=".InappBuyActivity" />
-        <activity android:name=".ui.LogcatActivity" />
+            android:exported="false"
+            android:name=".ui.PerAppProxyActivity" />
         <activity
+            android:exported="false"
+            android:name=".ui.ScannerActivity" />
+        <activity
+            android:exported="false"
+            android:name=".ui.LogcatActivity" />
+        <activity
+            android:exported="false"
             android:name=".ui.RoutingSettingsActivity"
             android:windowSoftInputMode="stateUnchanged" />
-        <activity android:name=".ui.SubSettingActivity" />
+        <activity
+            android:exported="false"
+            android:name=".ui.SubSettingActivity" />
+        <activity
+            android:exported="false"
+            android:name=".ui.UserAssetActivity" />
+        <activity
+            android:exported="false"
+            android:name=".ui.UserAssetUrlActivity" />
 
-        <activity android:name=".ui.SubEditActivity" />
-        <activity android:name=".ui.ScScannerActivity" />
-        <activity android:name=".ui.ScSwitchActivity" />
+        <activity
+            android:exported="false"
+            android:name=".ui.SubEditActivity" />
+        <activity
+            android:exported="false"
+            android:name=".ui.ScScannerActivity" />
+        <activity
+            android:exported="false"
+            android:name=".ui.ScSwitchActivity"
+            android:excludeFromRecents="true"
+            android:process=":RunSoLibV2RayDaemon"
+            android:theme="@style/AppTheme.NoActionBar.Translucent" />
+
+        <activity
+            android:exported="true"
+            android:name=".ui.UrlSchemeActivity">
+            <intent-filter>
+                <action android:name="android.intent.action.SEND" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <data android:mimeType="text/plain" />
+            </intent-filter>
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW"/>
+                <category android:name="android.intent.category.BROWSABLE"/>
+                <category android:name="android.intent.category.DEFAULT"/>
+                <data android:scheme="v2rayng"/>
+                <data android:host="install-config"/>
+                <data android:host="install-sub"/>
+            </intent-filter>
+        </activity>
 
         <service
             android:name=".service.V2RayVpnService"
@@ -74,6 +134,7 @@
             android:exported="false"
             android:label="@string/app_name"
             android:permission="android.permission.BIND_VPN_SERVICE"
+            android:foregroundServiceType="specialUse"
             android:process=":RunSoLibV2RayDaemon">
             <intent-filter>
                 <action android:name="android.net.VpnService" />
@@ -81,30 +142,58 @@
             <meta-data
                 android:name="android.net.VpnService.SUPPORTS_ALWAYS_ON"
                 android:value="true" />
+            <property
+                android:name="android.app.PROPERTY_SPECIAL_USE_FGS_SUBTYPE"
+                android:value="vpn" />
         </service>
 
-        <!--<receiver android:name=".receiver.WidgetProvider">-->
-        <!--<meta-data-->
-        <!--android:name="android.appwidget.provider"-->
-        <!--android:resource="@xml/app_widget_provider" />-->
+        <service android:name=".service.V2RayProxyOnlyService"
+                android:exported="false"
+                android:label="@string/app_name"
+                android:foregroundServiceType="specialUse"
+                android:process=":RunSoLibV2RayDaemon">
+            <property
+                android:name="android.app.PROPERTY_SPECIAL_USE_FGS_SUBTYPE"
+                android:value="proxy" />
+        </service>
 
-        <!--<intent-filter>-->
-        <!--<action android:name="android.appwidget.action.APPWIDGET_UPDATE" />-->
-        <!--<action android:name="com.v2ray.ang.action.widget.click" />-->
-        <!--</intent-filter>-->
-        <!--</receiver>-->
+        <service android:name=".service.V2RayTestService"
+            android:exported="false"
+            android:process=":RunSoLibV2RayDaemon">
+        </service>
+
+        <receiver
+                android:exported="true"
+                android:name=".receiver.WidgetProvider"
+                android:process=":RunSoLibV2RayDaemon">
+            <meta-data
+                    android:name="android.appwidget.provider"
+                    android:resource="@xml/app_widget_provider" />
+            <intent-filter>
+                <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
+                <action android:name="com.v2ray.ang.action.widget.click" />
+                <action android:name="com.v2ray.ang.action.activity" />
+            </intent-filter>
+        </receiver>
 
         <service
-            android:name=".service.QSTileService"
-            android:icon="@drawable/ic_v"
-            android:label="@string/app_tile_name"
-            android:permission="android.permission.BIND_QUICK_SETTINGS_TILE">
+                android:exported="true"
+                android:name=".service.QSTileService"
+                android:icon="@drawable/ic_stat_name"
+                android:label="@string/app_tile_name"
+                android:foregroundServiceType="specialUse"
+                android:permission="android.permission.BIND_QUICK_SETTINGS_TILE"
+                android:process=":RunSoLibV2RayDaemon">
             <intent-filter>
                 <action android:name="android.service.quicksettings.action.QS_TILE" />
             </intent-filter>
+            <property
+                android:name="android.app.PROPERTY_SPECIAL_USE_FGS_SUBTYPE"
+                android:value="tile" />
         </service>
         <!-- =====================Tasker===================== -->
         <activity
+            android:exported="true"
             android:name=".ui.TaskerActivity"
             android:icon="@mipmap/ic_launcher"
             android:label="@string/app_name">
@@ -113,13 +202,28 @@
             </intent-filter>
         </activity>
 
-        <receiver android:name=".receiver.TaskerReceiver">
+        <receiver
+            android:exported="true"
+            android:name=".receiver.TaskerReceiver"
+                android:process=":RunSoLibV2RayDaemon">
             <intent-filter>
                 <action android:name="com.twofortyfouram.locale.intent.action.FIRE_SETTING" />
             </intent-filter>
         </receiver>
         <!-- =====================Tasker===================== -->
+        <provider
+            android:name="androidx.startup.InitializationProvider"
+            android:authorities="${applicationId}.androidx-startup"
+            android:exported="false"
+            tools:node="merge">
+
+            <meta-data
+                android:name="androidx.work.WorkManagerInitializer"
+                android:value="androidx.startup"
+                tools:node="remove" />
+
+        </provider>
 
     </application>
 
-</manifest>
+</manifest>

V2rayNG/app/src/main/aidl/com/android/vending/billing/IInAppBillingService.aidl

@@ -1,144 +0,0 @@
-/*
- * Copyright (C) 2012 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.android.vending.billing;
-
-import android.os.Bundle;
-
-/**
- * InAppBillingService is the service that provides in-app billing version 3 and beyond.
- * This service provides the following features:
- * 1. Provides a new API to get details of in-app items published for the app including
- *    price, type, title and description.
- * 2. The purchase flow is synchronous and purchase information is available immediately
- *    after it completes.
- * 3. Purchase information of in-app purchases is maintained within the Google Play system
- *    till the purchase is consumed.
- * 4. An API to consume a purchase of an inapp item. All purchases of one-time
- *    in-app items are consumable and thereafter can be purchased again.
- * 5. An API to get current purchases of the user immediately. This will not contain any
- *    consumed purchases.
- *
- * All calls will give a response code with the following possible values
- * RESULT_OK = 0 - success
- * RESULT_USER_CANCELED = 1 - user pressed back or canceled a dialog
- * RESULT_BILLING_UNAVAILABLE = 3 - this billing API version is not supported for the type requested
- * RESULT_ITEM_UNAVAILABLE = 4 - requested SKU is not available for purchase
- * RESULT_DEVELOPER_ERROR = 5 - invalid arguments provided to the API
- * RESULT_ERROR = 6 - Fatal error during the API action
- * RESULT_ITEM_ALREADY_OWNED = 7 - Failure to purchase since item is already owned
- * RESULT_ITEM_NOT_OWNED = 8 - Failure to consume since item is not owned
- */
-interface IInAppBillingService {
-    /**
-     * Checks support for the requested billing API version, package and in-app type.
-     * Minimum API version supported by this interface is 3.
-     * @param apiVersion the billing version which the app is using
-     * @param packageName the package name of the calling app
-     * @param type type of the in-app item being purchased "inapp" for one-time purchases
-     *        and "subs" for subscription.
-     * @return RESULT_OK(0) on success, corresponding result code on failures
-     */
-    int isBillingSupported(int apiVersion, String packageName, String type);
-
-    /**
-     * Provides details of a list of SKUs
-     * Given a list of SKUs of a valid type in the skusBundle, this returns a bundle
-     * with a list JSON strings containing the productId, price, title and description.
-     * This API can be called with a maximum of 20 SKUs.
-     * @param apiVersion billing API version that the Third-party is using
-     * @param packageName the package name of the calling app
-     * @param skusBundle bundle containing a StringArrayList of SKUs with key "ITEM_ID_LIST"
-     * @return Bundle containing the following key-value pairs
-     *         "RESPONSE_CODE" with int value, RESULT_OK(0) if success, other response codes on
-     *              failure as listed above.
-     *         "DETAILS_LIST" with a StringArrayList containing purchase information
-     *              in JSON format similar to:
-     *              '{ "productId" : "exampleSku", "type" : "inapp", "price" : "$5.00",
-     *                 "title : "Example Title", "description" : "This is an example description" }'
-     */
-    Bundle getSkuDetails(int apiVersion, String packageName, String type, in Bundle skusBundle);
-
-    /**
-     * Returns a pending intent to launch the purchase flow for an in-app item by providing a SKU,
-     * the type, a unique purchase token and an optional developer payload.
-     * @param apiVersion billing API version that the app is using
-     * @param packageName package name of the calling app
-     * @param sku the SKU of the in-app item as published in the developer console
-     * @param type the type of the in-app item ("inapp" for one-time purchases
-     *        and "subs" for subscription).
-     * @param developerPayload optional argument to be sent back with the purchase information
-     * @return Bundle containing the following key-value pairs
-     *         "RESPONSE_CODE" with int value, RESULT_OK(0) if success, other response codes on
-     *              failure as listed above.
-     *         "BUY_INTENT" - PendingIntent to start the purchase flow
-     *
-     * The Pending intent should be launched with startIntentSenderForResult. When purchase flow
-     * has completed, the onActivityResult() will give a resultCode of OK or CANCELED.
-     * If the purchase is successful, the result data will contain the following key-value pairs
-     *         "RESPONSE_CODE" with int value, RESULT_OK(0) if success, other response codes on
-     *              failure as listed above.
-     *         "INAPP_PURCHASE_DATA" - String in JSON format similar to
-     *              '{"orderId":"12999763169054705758.1371079406387615",
-     *                "packageName":"com.example.app",
-     *                "productId":"exampleSku",
-     *                "purchaseTime":1345678900000,
-     *                "purchaseToken" : "122333444455555",
-     *                "developerPayload":"example developer payload" }'
-     *         "INAPP_DATA_SIGNATURE" - String containing the signature of the purchase data that
-     *                                  was signed with the private key of the developer
-     *                                  TODO: change this to app-specific keys.
-     */
-    Bundle getBuyIntent(int apiVersion, String packageName, String sku, String type,
-        String developerPayload);
-
-    /**
-     * Returns the current SKUs owned by the user of the type and package name specified along with
-     * purchase information and a signature of the data to be validated.
-     * This will return all SKUs that have been purchased in V3 and managed items purchased using
-     * V1 and V2 that have not been consumed.
-     * @param apiVersion billing API version that the app is using
-     * @param packageName package name of the calling app
-     * @param type the type of the in-app items being requested
-     *        ("inapp" for one-time purchases and "subs" for subscription).
-     * @param continuationToken to be set as null for the first call, if the number of owned
-     *        skus are too many, a continuationToken is returned in the response bundle.
-     *        This method can be called again with the continuation token to get the next set of
-     *        owned skus.
-     * @return Bundle containing the following key-value pairs
-     *         "RESPONSE_CODE" with int value, RESULT_OK(0) if success, other response codes on
-     *              failure as listed above.
-     *         "INAPP_PURCHASE_ITEM_LIST" - StringArrayList containing the list of SKUs
-     *         "INAPP_PURCHASE_DATA_LIST" - StringArrayList containing the purchase information
-     *         "INAPP_DATA_SIGNATURE_LIST"- StringArrayList containing the signatures
-     *                                      of the purchase information
-     *         "INAPP_CONTINUATION_TOKEN" - String containing a continuation token for the
-     *                                      next set of in-app purchases. Only set if the
-     *                                      user has more owned skus than the current list.
-     */
-    Bundle getPurchases(int apiVersion, String packageName, String type, String continuationToken);
-
-    /**
-     * Consume the last purchase of the given SKU. This will result in this item being removed
-     * from all subsequent responses to getPurchases() and allow re-purchase of this item.
-     * @param apiVersion billing API version that the app is using
-     * @param packageName package name of the calling app
-     * @param purchaseToken token in the purchase information JSON that identifies the purchase
-     *        to be consumed
-     * @return 0 if consumption succeeded. Appropriate error values for failures.
-     */
-    int consumePurchase(int apiVersion, String packageName, String purchaseToken);
-}

V2rayNG/app/src/main/assets/custom_routing_block

@@ -0,0 +1 @@
+geosite:category-ads-all,

V2rayNG/app/src/main/assets/custom_routing_direct

@@ -0,0 +1,132 @@
+domain:12306.com,
+domain:51ym.me,
+domain:52pojie.cn,
+domain:8686c.com,
+domain:abercrombie.com,
+domain:adobesc.com,
+domain:air-matters.com,
+domain:air-matters.io,
+domain:airtable.com,
+domain:akadns.net,
+domain:apache.org,
+domain:api.crisp.chat,
+domain:api.termius.com,
+domain:appshike.com,
+domain:appstore.com,
+domain:aweme.snssdk.com,
+domain:bababian.com,
+domain:battle.net,
+domain:beatsbydre.com,
+domain:bet365.com,
+domain:bilibili.cn,
+domain:ccgslb.com,
+domain:ccgslb.net,
+domain:chunbo.com,
+domain:chunboimg.com,
+domain:clashroyaleapp.com,
+domain:cloudsigma.com,
+domain:cloudxns.net,
+domain:cmfu.com,
+domain:culturedcode.com,
+domain:dct-cloud.com,
+domain:didialift.com,
+domain:douyutv.com,
+domain:duokan.com,
+domain:dytt8.net,
+domain:easou.com,
+domain:ecitic.net,
+domain:eclipse.org,
+domain:eudic.net,
+domain:ewqcxz.com,
+domain:fir.im,
+domain:frdic.com,
+domain:fresh-ideas.cc,
+domain:godic.net,
+domain:goodread.com,
+domain:haibian.com,
+domain:hdslb.net,
+domain:hollisterco.com,
+domain:hongxiu.com,
+domain:hxcdn.net,
+domain:images.unsplash.com,
+domain:img4me.com,
+domain:ipify.org,
+domain:ixdzs.com,
+domain:jd.hk,
+domain:jianshuapi.com,
+domain:jomodns.com,
+domain:jsboxbbs.com,
+domain:knewone.com,
+domain:kuaidi100.com,
+domain:lemicp.com,
+domain:letvcloud.com,
+domain:lizhi.io,
+domain:localizecdn.com,
+domain:lucifr.com,
+domain:luoo.net,
+domain:mai.tn,
+domain:maven.org,
+domain:miwifi.com,
+domain:moji.com,
+domain:moke.com,
+domain:mtalk.google.com,
+domain:mxhichina.com,
+domain:myqcloud.com,
+domain:myunlu.com,
+domain:netease.com,
+domain:nfoservers.com,
+domain:nssurge.com,
+domain:nuomi.com,
+domain:ourdvs.com,
+domain:overcast.fm,
+domain:paypal.com,
+domain:paypalobjects.com,
+domain:pgyer.com,
+domain:qdaily.com,
+domain:qdmm.com,
+domain:qin.io,
+domain:qingmang.me,
+domain:qingmang.mobi,
+domain:qqurl.com,
+domain:rarbg.to,
+domain:rrmj.tv,
+domain:ruguoapp.com,
+domain:sm.ms,
+domain:snwx.com,
+domain:soku.com,
+domain:startssl.com,
+domain:store.steampowered.com,
+domain:symcd.com,
+domain:teamviewer.com,
+domain:tmzvps.com,
+domain:trello.com,
+domain:trellocdn.com,
+domain:ttmeiju.com,
+domain:udache.com,
+domain:uxengine.net,
+domain:weather.bjango.com,
+domain:weather.com,
+domain:webqxs.com,
+domain:weico.cc,
+domain:wenku8.net,
+domain:werewolf.53site.com,
+domain:windowsupdate.com,
+domain:wkcdn.com,
+domain:workflowy.com,
+domain:xdrig.com,
+domain:xiaojukeji.com,
+domain:xiaomi.net,
+domain:xiaomicp.com,
+domain:ximalaya.com,
+domain:xitek.com,
+domain:xmcdn.com,
+domain:xslb.net,
+domain:xteko.com,
+domain:yach.me,
+domain:yixia.com,
+domain:yunjiasu-cdn.net,
+domain:zealer.com,
+domain:zgslb.net,
+domain:zimuzu.tv,
+domain:zmz002.com,
+domain:samsungdm.com,

V2rayNG/app/src/main/assets/custom_routing_proxy

@@ -0,0 +1,33 @@
+geosite:google,
+geosite:github,
+geosite:netflix,
+geosite:steam,
+geosite:telegram,
+geosite:tumblr,
+geosite:speedtest,
+geosite:bbc,
+domain:gvt1.com,
+domain:textnow.com,
+domain:twitch.tv,
+domain:wikileaks.org,
+domain:naver.com,
+91.108.4.0/22,
+91.108.8.0/22,
+91.108.12.0/22,
+91.108.20.0/22,
+91.108.36.0/23,
+91.108.38.0/23,
+91.108.56.0/22,
+149.154.160.0/20,
+149.154.164.0/22,
+149.154.172.0/22,
+74.125.0.0/16,
+173.194.0.0/16,
+172.217.0.0/16,
+216.58.200.0/24,
+216.58.220.0/24,
+91.108.56.116,
+91.108.56.0/24,
+109.239.140.0/24,
+149.154.167.0/24,
+149.154.175.0/24,

V2rayNG/app/src/main/assets/proxy_packagename.txt

@@ -1,196 +1,241 @@
-com.android.chrome
-com.google.android.googlequicksearchbox
-com.google.android.apps.photos
-com.google.android.youtube
-com.google.android.gm
-com.google.android.apps.plus
-com.android.vending
-com.google.android.inputmethod.latin
-com.google.android.apps.paidtasks
-com.google.android.keep
-com.google.android.gms.setup
-com. google.android. apps.magazines
-com.google.android.videos
-com. google.android.gms
-com.google.android.apps.books
-com.google.android.music
-com.google.android.play.games
-com.google.android.gsf
-com.google.android.gsf.login
-com.app.pornhub
-com.spotify.music
-org.thunderdog.challegram
-com.tumblr
-com.twitter.android
-com.xda.labs
-com.kapp.youtube.final
-com.google.android.ims
-com.wire
-mark.via.gp
-com.downloader.video.tumblr
-com.sololearn
-com.cygames.shadowverse
-com.felixfilip.scpae
 amanita_design.samorost3.gp
-com.devolver.reigns2
-com.utopia.pxview
-ch.protonmail.android
-com.perol.asdpl.pixivez
-com.pinterest
-com.paypal.android.p2pmobile
-com.arthurivanets.owly
-com.rubenmayayo.reddit
-com.rayark.cytus2
-com.rayark.pluto
-com.rayark.implosion
-com.fireproofstudios.theroom4
-com.netflix.mediaclient
-com.instagram.android
-com.google.android.apps.hangoutsdialer
-com.google.android.talk
-com.google.android.apps.plus
-com.google.android.apps.pdfviewer
-com.google.android.apps.magazines
-com.google.android.apps.nbu.files
-com.evernote
-net.tsapps.appsales
-com.google.android.apps.translate
-com.google.ar.lens
-com.google.android.apps.adm
-com.google.android.apps.googleassistant
-tw.com.gamer.android.activecenter
-org.telegram.plus
-com.brave.browser
-com.breel.wallpapers18
-com.teslacoilsw.launcher
-com.lastpass.lpandroid
-org.kustom.widget
-com.fooview.android.fooview
-com.google.android.apps.docs
-com.google.android.apps.maps
-com.facebook.services
-com.facebook.system
-com.facebook.katana
-com.nianticlabs.ingress.prime.qa
-com.vanced.android.youtube
-com.nianticproject.ingress
-com.quoord.tapatalkpro.activity
-org.mozilla.firefox
-com.reddit.frontpage
-com.google.android.apps.fitness
+android
 au.com.shiftyjelly.pocketcasts
-com.google.android.gms
-com.android.providers.telephony
-com.resilio.sync
-com.google.android.apps.googlevoice
-com.discord
-com.cradle.iitc_mobile
+bbc.mobile.news.ww
 be.mygod.vpnhotspot
+ch.protonmail.android
+co.wanqu.android
 com.alphainventor.filemanager
+com.amazon.kindle
+com.amazon.mshop.android.shopping
+com.android.chrome
 com.android.providers.downloads
+com.android.providers.downloads.ui
+com.android.providers.telephony
+com.android.settings
+com.android.vending
+com.android6park.m6park
 com.apkpure.aegon
+com.apkupdater
+com.app.pornhub
+com.arthurivanets.owly
+com.asahi.tida.tablet
+com.authy.authy
+com.avmovie
 com.ballistiq.artstation
+com.binance.dev
 com.bitly.app
+com.brave.browser
+com.brave.browser_beta
+com.breel.wallpapers18
+com.bvanced.android.youtube
+com.chrome.beta
 com.chrome.canary
 com.chrome.dev
+com.cl.newt66y
+com.cradle.iitc_mobile
+com.cygames.shadowverse
 com.devhd.feedly
+com.devolver.reigns2
+com.discord
+com.downloader.video.tumblr
+com.driverbrowser
 com.dropbox.android
+com.duolingo
+com.duckduckgo.mobile.android
+com.dv.adm
 com.estrongs.android.pop
 com.estrongs.android.pop.pro
+com.evernote
+com.facebook.katana
+com.facebook.lite
+com.facebook.mlite
+com.facebook.orca
+com.facebook.services
+com.facebook.system
 com.fastaccess.github
+com.felixfilip.scpae
+com.fireproofstudios.theroom4
 com.firstrowria.pushnotificationtester
+com.flyersoft.moonreaderp
+com.fooview.android.fooview
 com.fvd.eversync
+com.gameloft.android.anmp.glofta8hm
+com.gameloft.android.anmp.glofta9hm
 com.gianlu.aria2app
 com.github.yeriomin.yalpstore
+com.google.android.apps.adm
+com.google.android.apps.books
+com.google.android.apps.docs
 com.google.android.apps.docs.editors.sheets
+com.google.android.apps.fitness
+com.google.android.apps.googleassistant
+com.google.android.apps.googlevoice
+com.google.android.apps.hangoutsdialer
+com.google.android.apps.inbox
+com.google.android.apps.magazines
+com.google.android.apps.maps
+com.google.android.apps.nbu.files
+com.google.android.apps.paidtasks
+com.google.android.apps.pdfviewer
+com.google.android.apps.photos
+com.google.android.apps.plus
+com.google.android.apps.translate
+com.google.android.gm
+com.google.android.gms
+com.google.android.gms.setup
+com.google.android.googlequicksearchbox
+com.google.android.gsf
+com.google.android.gsf.login
+com.google.android.ims
+com.google.android.inputmethod.latin
 com.google.android.instantapps.supervisor
+com.google.android.keep
+com.google.android.music
 com.google.android.ogyoutube
 com.google.android.partnersetup
+com.google.android.play.games
+com.google.android.street
 com.google.android.syncadapters.calendar
 com.google.android.syncadapters.contacts
+com.google.android.talk
 com.google.android.tts
+com.google.android.videos
+com.google.android.youtube
+com.google.ar.lens
 com.hochan.coldsoup
 com.ifttt.ifttt
 com.imgur.mobile
 com.innologica.inoreader
+com.instagram.android
 com.instapaper.android
 com.jarvanh.vpntether
+com.kapp.youtube.final
+com.klinker.android.twitter_l
+com.lastpass.lpandroid
+com.linecorp.linelite
+com.lingodeer
 com.mediapods.tumbpods
 com.mgoogle.android.gms
+com.microsoft.emmx
 com.microsoft.office.powerpoint
+com.microsoft.skydrive
 com.mixplorer
 com.msd.consumerchinese
 com.msd.professionalchinese
 com.mss2011c.sharehelper
+com.netflix.mediaclient
 com.newin.nplayer.pro
+com.nianticlabs.ingress.prime.qa
+com.nianticproject.ingress
+com.ninefolders.hd3
+com.ninegag.android.app
+com.nintendo.zara
+com.nytimes.cn
 com.oasisfeng.island
+com.ocnt.liveapp.hw
 com.orekie.search
+com.patreon.android
+com.paypal.android.p2pmobile
+com.perol.asdpl.pixivez
+com.pinterest
+com.popularapp.periodcalendar
 com.popularapp.videodownloaderforinstagram
 com.pushbullet.android
+com.quoord.tapatalkpro.activity
+com.quora.android
+com.rayark.cytus2
+com.rayark.implosion
+com.rayark.pluto
+com.reddit.frontpage
+com.resilio.sync
 com.rhmsoft.edit
+com.rubenmayayo.reddit
+com.sec.android.app.sbrowser
+com.sec.android.app.sbrowser.beta
+com.shanga.walli
+com.simplehabit.simplehabitapp
 com.slack
+com.snaptube.premium
+com.sololearn
+com.sonelli.juicessh
+com.spotify.music
 com.tencent.huatuo
 com.termux
+com.teslacoilsw.launcher
+com.theinitium.news
+com.thomsonreuters.reuters
 com.thunkable.android.hritvik00.freenom
 com.topjohnwu.magisk
+com.tripadvisor.tripadvisor
+com.tumblr
+com.twitter.android
 com.u91porn
 com.u9porn
+com.ubisoft.dance.justdance2015companion
+com.utopia.pxview
+com.valvesoftware.android.steam.communimunity
+com.valvesoftware.android.steam.community
+com.vanced.android.youtube
 com.vimeo.android.videoapp
+com.vivaldi.browser
+com.vivaldi.browser.snapshot
+com.vkontakte.android
+com.whatsapp
+com.wire
 com.wuxiangai.refactor
+com.xda.labs
+com.xvideos.app
 com.yandex.browser
+com.yandex.browser.beta
+com.yandex.browser.alpha
 com.z28j.feel
+con.medium.reader
+de.apkgrabber
 de.robv.android.xposed.installer
 dk.tacit.android.foldersync.full
 es.rafalense.telegram.themes
 es.rafalense.themes
 flipboard.app
+fm.moon.app
+fr.gouv.etalab.mastodon
 github.tornaco.xposedmoduletest
+idm.internet.download.manager
+idm.internet.download.manager.plus
+io.github.javiewer
+io.github.skyhacker2.magnetsearch
 io.va.exposed
+it.mvilla.android.fenix2
+jp.bokete.app.android
+jp.naver.line.android
 jp.pxv.android
+luo.speedometergpspro
+mark.via.gp
 me.tshine.easymark
 net.teeha.android.url_shortener
+net.tsapps.appsales
 onion.fire
 org.fdroid.fdroid
+org.freedownloadmanager.fdm
+org.kustom.widget
 org.mozilla.fennec_aurora
+org.mozilla.fenix
+org.mozilla.fenix.nightly
+org.mozilla.firefox
+org.mozilla.firefox_beta
+org.mozilla.focus
 org.schabi.newpipe
 org.telegram.messenger
+org.telegram.multi
+org.telegram.plus
+org.thunderdog.challegram
 org.torproject.android
+org.torproject.torbrowser_alpha
+org.wikipedia
 org.xbmc.kodi
 pl.zdunex25.updater
-videodownloader.downloadvideo.downloader
-com.quora.android
-com.lingodeer
-org.wikipedia
-com.ninegag.android.app
-com.duolingo
-com.patreon.android
-com.valvesoftware.android.steam.communimunity
-co.wanqu.android
-jp.bokete.app.android
-com.vkontakte.android
-com.amazon.mshop.android.shopping
-com.ubisoft.dance.justdance2015companion
-com.gameloft.android.anmp.glofta8hm
-com.gameloft.android.anmp.glofta9hm
-com.binance.dev
-com.asahi.tida.tablet
-com.theinitium.news
-com.driverbrowser
-com.thomsonreuters.reuters
-com.nytimes.cn
-com.android.providers.downloads.ui
-com.avmovie
-bbc.mobile.news.ww
-org.mozilla.focus
-io.github.javiewer
-com.sonelli.juicessh
-con.medium.reader
-com.microsoft.skydrive
-com.valvesoftware.android.steam.community
-com.nintendo.zara
-org.torproject.torbrowser_alpha
 tv.twitch.android.app
-com.shanga.walli
-com.whatsapp
-com.wire
-com.simplehabit.simplehabitapp
+tw.com.gamer.android.activecenter
+videodownloader.downloadvideo.downloader
+uk.co.bbc.learningenglish
+com.ted.android

V2rayNG/app/src/main/assets/v2ray_config.json

@@ -13,8 +13,8 @@
         }
       },
       "system": {
-        "statsInboundUplink": true,
-        "statsInboundDownlink": true
+        "statsOutboundUplink": true,
+        "statsOutboundDownlink": true
       }
   },
   "inbounds": [{
@@ -54,7 +54,7 @@
           "users": [
             {
               "id": "a3482e88-686a-4a58-8126-99c9df64b7bf",
-              "alterId": 64,
+              "alterId": 0,
               "security": "auto",
               "level": 8
             }

V2rayNG/app/src/main/java/com/v2ray/ang/helper/ItemTouchHelperAdapter.java

@@ -16,8 +16,8 @@
 
 package com.v2ray.ang.helper;
 
-import android.support.v7.widget.RecyclerView;
-import android.support.v7.widget.helper.ItemTouchHelper;
+import androidx.recyclerview.widget.RecyclerView;
+import androidx.recyclerview.widget.ItemTouchHelper;
 
 /**
  * Interface to listen for a move or dismissal event from a {@link ItemTouchHelper.Callback}.
@@ -43,6 +43,8 @@ public interface ItemTouchHelperAdapter {
     boolean onItemMove(int fromPosition, int toPosition);
 
 
+    void onItemMoveCompleted();
+
     /**
      * Called when an item has been dismissed by a swipe.<br/>
      * <br/>

V2rayNG/app/src/main/java/com/v2ray/ang/helper/ItemTouchHelperViewHolder.java

@@ -16,7 +16,7 @@
 
 package com.v2ray.ang.helper;
 
-import android.support.v7.widget.helper.ItemTouchHelper;
+import androidx.recyclerview.widget.ItemTouchHelper;
 
 /**
  * Interface to notify an item ViewHolder of relevant callbacks from {@link

V2rayNG/app/src/main/java/com/v2ray/ang/helper/OnStartDragListener.java

@@ -16,7 +16,7 @@
 
 package com.v2ray.ang.helper;
 
-import android.support.v7.widget.RecyclerView;
+import androidx.recyclerview.widget.RecyclerView;
 
 /**
  * Listener for manual initiation of a drag.

V2rayNG/app/src/main/java/com/v2ray/ang/helper/SimpleItemTouchHelperCallback.java

@@ -17,9 +17,11 @@
 package com.v2ray.ang.helper;
 
 import android.graphics.Canvas;
-import android.support.v7.widget.GridLayoutManager;
-import android.support.v7.widget.RecyclerView;
-import android.support.v7.widget.helper.ItemTouchHelper;
+import androidx.recyclerview.widget.GridLayoutManager;
+import androidx.recyclerview.widget.RecyclerView;
+import androidx.recyclerview.widget.ItemTouchHelper;
+
+import org.jetbrains.annotations.NotNull;
 
 /**
  * An implementation of {@link ItemTouchHelper.Callback} that enables basic drag & drop and
@@ -52,7 +54,7 @@ public class SimpleItemTouchHelperCallback extends ItemTouchHelper.Callback {
     }
 
     @Override
-    public int getMovementFlags(RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder) {
+    public int getMovementFlags(RecyclerView recyclerView, @NotNull RecyclerView.ViewHolder viewHolder) {
         // Set movement flags based on the layout manager
         if (recyclerView.getLayoutManager() instanceof GridLayoutManager) {
             final int dragFlags = ItemTouchHelper.UP | ItemTouchHelper.DOWN | ItemTouchHelper.LEFT | ItemTouchHelper.RIGHT;
@@ -66,24 +68,25 @@ public class SimpleItemTouchHelperCallback extends ItemTouchHelper.Callback {
     }
 
     @Override
-    public boolean onMove(RecyclerView recyclerView, RecyclerView.ViewHolder source, RecyclerView.ViewHolder target) {
+    public boolean onMove(@NotNull RecyclerView recyclerView, RecyclerView.ViewHolder source, RecyclerView.ViewHolder target) {
         if (source.getItemViewType() != target.getItemViewType()) {
             return false;
         }
 
         // Notify the adapter of the move
-        mAdapter.onItemMove(source.getAdapterPosition(), target.getAdapterPosition());
+        mAdapter.onItemMove(source.getBindingAdapterPosition(), target.getBindingAdapterPosition());
         return true;
     }
 
     @Override
     public void onSwiped(RecyclerView.ViewHolder viewHolder, int i) {
         // Notify the adapter of the dismissal
-        mAdapter.onItemDismiss(viewHolder.getAdapterPosition());
+        mAdapter.onItemDismiss(viewHolder.getBindingAdapterPosition());
     }
 
     @Override
-    public void onChildDraw(Canvas c, RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder, float dX, float dY, int actionState, boolean isCurrentlyActive) {
+    public void onChildDraw(@NotNull Canvas c, @NotNull RecyclerView recyclerView, @NotNull RecyclerView.ViewHolder viewHolder, float dX,
+                            float dY, int actionState, boolean isCurrentlyActive) {
         if (actionState == ItemTouchHelper.ACTION_STATE_SWIPE) {
             // Fade out the view as it is swiped out of the parent's bounds
             final float alpha = ALPHA_FULL - Math.abs(dX) / (float) viewHolder.itemView.getWidth();
@@ -109,9 +112,11 @@ public class SimpleItemTouchHelperCallback extends ItemTouchHelper.Callback {
     }
 
     @Override
-    public void clearView(RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder) {
+    public void clearView(@NotNull RecyclerView recyclerView, @NotNull RecyclerView.ViewHolder viewHolder) {
         super.clearView(recyclerView, viewHolder);
 
+        mAdapter.onItemMoveCompleted();
+
         viewHolder.itemView.setAlpha(ALPHA_FULL);
 
         if (viewHolder instanceof ItemTouchHelperViewHolder) {

V2rayNG/app/src/main/java/com/v2ray/ang/util/AssetsUtil.java

@@ -1,121 +0,0 @@
-package com.v2ray.ang.util;
-
-import static android.content.Context.MODE_PRIVATE;
-
-import android.content.Context;
-import android.content.res.AssetManager;
-
-import java.io.BufferedReader;
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.OutputStream;
-
-public class AssetsUtil {
-    public static boolean copyAssetFolder(AssetManager assetManager,
-                                          String fromAssetPath, String toPath) {
-        try {
-            String[] files = assetManager.list(fromAssetPath);
-            new File(toPath).mkdirs();
-            boolean res = true;
-            for (String file : files)
-                if (file.contains("."))
-                    res &= copyAsset(assetManager,
-                            fromAssetPath + "/" + file,
-                            toPath + "/" + file);
-                else
-                    res &= copyAssetFolder(assetManager,
-                            fromAssetPath + "/" + file,
-                            toPath + "/" + file);
-            return res;
-        } catch (Exception e) {
-            e.printStackTrace();
-            return false;
-        }
-    }
-
-    public static boolean copyAsset(AssetManager assetManager,
-                                    String fromAssetPath, String toPath) {
-        InputStream in = null;
-        OutputStream out = null;
-        try {
-            in = assetManager.open(fromAssetPath);
-            new File(toPath).createNewFile();
-            out = new FileOutputStream(toPath);
-            copyFile(in, out);
-            in.close();
-            return true;
-        } catch (Exception e) {
-            e.printStackTrace();
-            return false;
-        } finally {
-            try {
-                if (out != null) {
-                    out.close();
-                }
-                if (in != null) {
-                    in.close();
-                }
-            } catch (IOException e) {
-                e.printStackTrace();
-            }
-        }
-    }
-
-    public static String readTextFromAssets(AssetManager assetManager, String fileName) {
-        try {
-            InputStreamReader inputReader = new InputStreamReader(assetManager.open(fileName));
-            BufferedReader bufReader = new BufferedReader(inputReader);
-            String line;
-            String Result = "";
-            while ((line = bufReader.readLine()) != null)
-                Result += line;
-            return Result;
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-
-        return null;
-    }
-
-    public static String getAssetPath(Context context, String assetPath) {
-        InputStream in = null;
-        OutputStream out = null;
-        try {
-            context.deleteFile(assetPath);
-
-            in = context.getAssets().open(assetPath);
-            out = context.openFileOutput(assetPath, MODE_PRIVATE);
-            copyFile(in, out);
-            in.close();
-
-            String path = context.getFilesDir().toString();
-            return path + "/" + assetPath;
-
-        } catch (Exception e) {
-            e.printStackTrace();
-            return "";
-        } finally {
-            try {
-                if (out != null) {
-                    out.close();
-                }
-                if (in != null) {
-                    in.close();
-                }
-            } catch (IOException e) {
-                e.printStackTrace();
-            }
-        }
-    }
-
-    private static void copyFile(InputStream in, OutputStream out) throws IOException {
-        byte[] buffer = new byte[1024];
-        int read;
-        while ((read = in.read(buffer)) != -1) {
-            out.write(buffer, 0, read);
-        }
-    }
-}

V2rayNG/app/src/main/java/com/v2ray/ang/util/Base64.java

@@ -1,570 +0,0 @@
-// Portions copyright 2002, Google, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package com.v2ray.ang.util;
-
-// This code was converted from code at http://iharder.sourceforge.net/base64/
-// Lots of extraneous features were removed.
-/* The original code said:
- * <p>
- * I am placing this code in the Public Domain. Do with it as you will.
- * This software comes with no guarantees or warranties but with
- * plenty of well-wishing instead!
- * Please visit
- * <a href="http://iharder.net/xmlizable">http://iharder.net/xmlizable</a>
- * periodically to check for updates or to contribute improvements.
- * </p>
- *
- * @author Robert Harder
- * @author rharder@usa.net
- * @version 1.3
- */
-
-/**
- * Base64 converter class. This code is not a complete MIME encoder;
- * it simply converts binary data to base64 data and back.
- *
- * <p>Note {@link CharBase64} is a GWT-compatible implementation of this
- * class.
- */
-public class Base64 {
-    /** Specify encoding (value is {@code true}). */
-    public final static boolean ENCODE = true;
-
-    /** Specify decoding (value is {@code false}). */
-    public final static boolean DECODE = false;
-
-    /** The equals sign (=) as a byte. */
-    private final static byte EQUALS_SIGN = (byte) '=';
-
-    /** The new line character (\n) as a byte. */
-    private final static byte NEW_LINE = (byte) '\n';
-
-    /**
-     * The 64 valid Base64 values.
-     */
-    private final static byte[] ALPHABET =
-        {(byte) 'A', (byte) 'B', (byte) 'C', (byte) 'D', (byte) 'E', (byte) 'F',
-        (byte) 'G', (byte) 'H', (byte) 'I', (byte) 'J', (byte) 'K',
-        (byte) 'L', (byte) 'M', (byte) 'N', (byte) 'O', (byte) 'P',
-        (byte) 'Q', (byte) 'R', (byte) 'S', (byte) 'T', (byte) 'U',
-        (byte) 'V', (byte) 'W', (byte) 'X', (byte) 'Y', (byte) 'Z',
-        (byte) 'a', (byte) 'b', (byte) 'c', (byte) 'd', (byte) 'e',
-        (byte) 'f', (byte) 'g', (byte) 'h', (byte) 'i', (byte) 'j',
-        (byte) 'k', (byte) 'l', (byte) 'm', (byte) 'n', (byte) 'o',
-        (byte) 'p', (byte) 'q', (byte) 'r', (byte) 's', (byte) 't',
-        (byte) 'u', (byte) 'v', (byte) 'w', (byte) 'x', (byte) 'y',
-        (byte) 'z', (byte) '0', (byte) '1', (byte) '2', (byte) '3',
-        (byte) '4', (byte) '5', (byte) '6', (byte) '7', (byte) '8',
-        (byte) '9', (byte) '+', (byte) '/'};
-
-    /**
-     * The 64 valid web safe Base64 values.
-     */
-    private final static byte[] WEBSAFE_ALPHABET =
-        {(byte) 'A', (byte) 'B', (byte) 'C', (byte) 'D', (byte) 'E', (byte) 'F',
-        (byte) 'G', (byte) 'H', (byte) 'I', (byte) 'J', (byte) 'K',
-        (byte) 'L', (byte) 'M', (byte) 'N', (byte) 'O', (byte) 'P',
-        (byte) 'Q', (byte) 'R', (byte) 'S', (byte) 'T', (byte) 'U',
-        (byte) 'V', (byte) 'W', (byte) 'X', (byte) 'Y', (byte) 'Z',
-        (byte) 'a', (byte) 'b', (byte) 'c', (byte) 'd', (byte) 'e',
-        (byte) 'f', (byte) 'g', (byte) 'h', (byte) 'i', (byte) 'j',
-        (byte) 'k', (byte) 'l', (byte) 'm', (byte) 'n', (byte) 'o',
-        (byte) 'p', (byte) 'q', (byte) 'r', (byte) 's', (byte) 't',
-        (byte) 'u', (byte) 'v', (byte) 'w', (byte) 'x', (byte) 'y',
-        (byte) 'z', (byte) '0', (byte) '1', (byte) '2', (byte) '3',
-        (byte) '4', (byte) '5', (byte) '6', (byte) '7', (byte) '8',
-        (byte) '9', (byte) '-', (byte) '_'};
-
-    /**
-     * Translates a Base64 value to either its 6-bit reconstruction value
-     * or a negative number indicating some other meaning.
-     **/
-    private final static byte[] DECODABET = {-9, -9, -9, -9, -9, -9, -9, -9, -9, // Decimal  0 -  8
-        -5, -5, // Whitespace: Tab and Linefeed
-        -9, -9, // Decimal 11 - 12
-        -5, // Whitespace: Carriage Return
-        -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, // Decimal 14 - 26
-        -9, -9, -9, -9, -9, // Decimal 27 - 31
-        -5, // Whitespace: Space
-        -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, // Decimal 33 - 42
-        62, // Plus sign at decimal 43
-        -9, -9, -9, // Decimal 44 - 46
-        63, // Slash at decimal 47
-        52, 53, 54, 55, 56, 57, 58, 59, 60, 61, // Numbers zero through nine
-        -9, -9, -9, // Decimal 58 - 60
-        -1, // Equals sign at decimal 61
-        -9, -9, -9, // Decimal 62 - 64
-        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, // Letters 'A' through 'N'
-        14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, // Letters 'O' through 'Z'
-        -9, -9, -9, -9, -9, -9, // Decimal 91 - 96
-        26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, // Letters 'a' through 'm'
-        39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, // Letters 'n' through 'z'
-        -9, -9, -9, -9, -9 // Decimal 123 - 127
-        /*  ,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 128 - 139
-        -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 140 - 152
-        -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 153 - 165
-        -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 166 - 178
-        -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 179 - 191
-        -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 192 - 204
-        -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 205 - 217
-        -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 218 - 230
-        -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 231 - 243
-        -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9         // Decimal 244 - 255 */
-    };
-
-    /** The web safe decodabet */
-    private final static byte[] WEBSAFE_DECODABET =
-        {-9, -9, -9, -9, -9, -9, -9, -9, -9, // Decimal  0 -  8
-        -5, -5, // Whitespace: Tab and Linefeed
-        -9, -9, // Decimal 11 - 12
-        -5, // Whitespace: Carriage Return
-        -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, // Decimal 14 - 26
-        -9, -9, -9, -9, -9, // Decimal 27 - 31
-        -5, // Whitespace: Space
-        -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, // Decimal 33 - 44
-        62, // Dash '-' sign at decimal 45
-        -9, -9, // Decimal 46-47
-        52, 53, 54, 55, 56, 57, 58, 59, 60, 61, // Numbers zero through nine
-        -9, -9, -9, // Decimal 58 - 60
-        -1, // Equals sign at decimal 61
-        -9, -9, -9, // Decimal 62 - 64
-        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, // Letters 'A' through 'N'
-        14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, // Letters 'O' through 'Z'
-        -9, -9, -9, -9, // Decimal 91-94
-        63, // Underscore '_' at decimal 95
-        -9, // Decimal 96
-        26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, // Letters 'a' through 'm'
-        39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, // Letters 'n' through 'z'
-        -9, -9, -9, -9, -9 // Decimal 123 - 127
-        /*  ,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 128 - 139
-        -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 140 - 152
-        -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 153 - 165
-        -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 166 - 178
-        -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 179 - 191
-        -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 192 - 204
-        -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 205 - 217
-        -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 218 - 230
-        -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 231 - 243
-        -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9         // Decimal 244 - 255 */
-        };
-
-    // Indicates white space in encoding
-    private final static byte WHITE_SPACE_ENC = -5;
-    // Indicates equals sign in encoding
-    private final static byte EQUALS_SIGN_ENC = -1;
-
-    /** Defeats instantiation. */
-    private Base64() {
-    }
-
-    /* ********  E N C O D I N G   M E T H O D S  ******** */
-
-    /**
-     * Encodes up to three bytes of the array <var>source</var>
-     * and writes the resulting four Base64 bytes to <var>destination</var>.
-     * The source and destination arrays can be manipulated
-     * anywhere along their length by specifying
-     * <var>srcOffset</var> and <var>destOffset</var>.
-     * This method does not check to make sure your arrays
-     * are large enough to accommodate <var>srcOffset</var> + 3 for
-     * the <var>source</var> array or <var>destOffset</var> + 4 for
-     * the <var>destination</var> array.
-     * The actual number of significant bytes in your array is
-     * given by <var>numSigBytes</var>.
-     *
-     * @param source the array to convert
-     * @param srcOffset the index where conversion begins
-     * @param numSigBytes the number of significant bytes in your array
-     * @param destination the array to hold the conversion
-     * @param destOffset the index where output will be put
-     * @param alphabet is the encoding alphabet
-     * @return the <var>destination</var> array
-     * @since 1.3
-     */
-    private static byte[] encode3to4(byte[] source, int srcOffset,
-            int numSigBytes, byte[] destination, int destOffset, byte[] alphabet) {
-        //           1         2         3
-        // 01234567890123456789012345678901 Bit position
-        // --------000000001111111122222222 Array position from threeBytes
-        // --------|    ||    ||    ||    | Six bit groups to index alphabet
-        //          >>18  >>12  >> 6  >> 0  Right shift necessary
-        //                0x3f  0x3f  0x3f  Additional AND
-
-        // Create buffer with zero-padding if there are only one or two
-        // significant bytes passed in the array.
-        // We have to shift left 24 in order to flush out the 1's that appear
-        // when Java treats a value as negative that is cast from a byte to an int.
-        int inBuff =
-                (numSigBytes > 0 ? ((source[srcOffset] << 24) >>> 8) : 0)
-                | (numSigBytes > 1 ? ((source[srcOffset + 1] << 24) >>> 16) : 0)
-                | (numSigBytes > 2 ? ((source[srcOffset + 2] << 24) >>> 24) : 0);
-
-        switch (numSigBytes) {
-            case 3:
-                destination[destOffset] = alphabet[(inBuff >>> 18)];
-                destination[destOffset + 1] = alphabet[(inBuff >>> 12) & 0x3f];
-                destination[destOffset + 2] = alphabet[(inBuff >>> 6) & 0x3f];
-                destination[destOffset + 3] = alphabet[(inBuff) & 0x3f];
-                return destination;
-            case 2:
-                destination[destOffset] = alphabet[(inBuff >>> 18)];
-                destination[destOffset + 1] = alphabet[(inBuff >>> 12) & 0x3f];
-                destination[destOffset + 2] = alphabet[(inBuff >>> 6) & 0x3f];
-                destination[destOffset + 3] = EQUALS_SIGN;
-                return destination;
-            case 1:
-                destination[destOffset] = alphabet[(inBuff >>> 18)];
-                destination[destOffset + 1] = alphabet[(inBuff >>> 12) & 0x3f];
-                destination[destOffset + 2] = EQUALS_SIGN;
-                destination[destOffset + 3] = EQUALS_SIGN;
-                return destination;
-            default:
-                return destination;
-        } // end switch
-    } // end encode3to4
-
-    /**
-     * Encodes a byte array into Base64 notation.
-     * Equivalent to calling
-     * {@code encodeBytes(source, 0, source.length)}
-     *
-     * @param source The data to convert
-     * @since 1.4
-     */
-    public static String encode(byte[] source) {
-        return encode(source, 0, source.length, ALPHABET, true);
-    }
-
-    /**
-     * Encodes a byte array into web safe Base64 notation.
-     *
-     * @param source The data to convert
-     * @param doPadding is {@code true} to pad result with '=' chars
-     *        if it does not fall on 3 byte boundaries
-     */
-    public static String encodeWebSafe(byte[] source, boolean doPadding) {
-        return encode(source, 0, source.length, WEBSAFE_ALPHABET, doPadding);
-    }
-
-    /**
-     * Encodes a byte array into Base64 notation.
-     *
-     * @param source the data to convert
-     * @param off offset in array where conversion should begin
-     * @param len length of data to convert
-     * @param alphabet the encoding alphabet
-     * @param doPadding is {@code true} to pad result with '=' chars
-     * if it does not fall on 3 byte boundaries
-     * @since 1.4
-     */
-    public static String encode(byte[] source, int off, int len, byte[] alphabet,
-                                boolean doPadding) {
-        byte[] outBuff = encode(source, off, len, alphabet, Integer.MAX_VALUE);
-        int outLen = outBuff.length;
-
-        // If doPadding is false, set length to truncate '='
-        // padding characters
-        while (doPadding == false && outLen > 0) {
-            if (outBuff[outLen - 1] != '=') {
-                break;
-            }
-            outLen -= 1;
-        }
-
-        return new String(outBuff, 0, outLen);
-    }
-
-    /**
-     * Encodes a byte array into Base64 notation.
-     *
-     * @param source the data to convert
-     * @param off offset in array where conversion should begin
-     * @param len length of data to convert
-     * @param alphabet is the encoding alphabet
-     * @param maxLineLength maximum length of one line.
-     * @return the BASE64-encoded byte array
-     */
-    public static byte[] encode(byte[] source, int off, int len, byte[] alphabet,
-            int maxLineLength) {
-        int lenDiv3 = (len + 2) / 3; // ceil(len / 3)
-        int len43 = lenDiv3 * 4;
-        byte[] outBuff = new byte[len43 // Main 4:3
-                                  + (len43 / maxLineLength)]; // New lines
-
-        int d = 0;
-        int e = 0;
-        int len2 = len - 2;
-        int lineLength = 0;
-        for (; d < len2; d += 3, e += 4) {
-
-            // The following block of code is the same as
-            // encode3to4( source, d + off, 3, outBuff, e, alphabet );
-            // but inlined for faster encoding (~20% improvement)
-            int inBuff =
-                    ((source[d + off] << 24) >>> 8)
-                    | ((source[d + 1 + off] << 24) >>> 16)
-                    | ((source[d + 2 + off] << 24) >>> 24);
-            outBuff[e] = alphabet[(inBuff >>> 18)];
-            outBuff[e + 1] = alphabet[(inBuff >>> 12) & 0x3f];
-            outBuff[e + 2] = alphabet[(inBuff >>> 6) & 0x3f];
-            outBuff[e + 3] = alphabet[(inBuff) & 0x3f];
-
-            lineLength += 4;
-            if (lineLength == maxLineLength) {
-                outBuff[e + 4] = NEW_LINE;
-                e++;
-                lineLength = 0;
-            } // end if: end of line
-        } // end for: each piece of array
-
-        if (d < len) {
-            encode3to4(source, d + off, len - d, outBuff, e, alphabet);
-
-            lineLength += 4;
-            if (lineLength == maxLineLength) {
-                // Add a last newline
-                outBuff[e + 4] = NEW_LINE;
-                e++;
-            }
-            e += 4;
-        }
-
-        assert (e == outBuff.length);
-        return outBuff;
-    }
-
-
-    /* ********  D E C O D I N G   M E T H O D S  ******** */
-
-
-    /**
-     * Decodes four bytes from array <var>source</var>
-     * and writes the resulting bytes (up to three of them)
-     * to <var>destination</var>.
-     * The source and destination arrays can be manipulated
-     * anywhere along their length by specifying
-     * <var>srcOffset</var> and <var>destOffset</var>.
-     * This method does not check to make sure your arrays
-     * are large enough to accommodate <var>srcOffset</var> + 4 for
-     * the <var>source</var> array or <var>destOffset</var> + 3 for
-     * the <var>destination</var> array.
-     * This method returns the actual number of bytes that
-     * were converted from the Base64 encoding.
-     *
-     *
-     * @param source the array to convert
-     * @param srcOffset the index where conversion begins
-     * @param destination the array to hold the conversion
-     * @param destOffset the index where output will be put
-     * @param decodabet the decodabet for decoding Base64 content
-     * @return the number of decoded bytes converted
-     * @since 1.3
-     */
-    private static int decode4to3(byte[] source, int srcOffset,
-            byte[] destination, int destOffset, byte[] decodabet) {
-        // Example: Dk==
-        if (source[srcOffset + 2] == EQUALS_SIGN) {
-            int outBuff =
-                    ((decodabet[source[srcOffset]] << 24) >>> 6)
-                    | ((decodabet[source[srcOffset + 1]] << 24) >>> 12);
-
-            destination[destOffset] = (byte) (outBuff >>> 16);
-            return 1;
-        } else if (source[srcOffset + 3] == EQUALS_SIGN) {
-            // Example: DkL=
-            int outBuff =
-                    ((decodabet[source[srcOffset]] << 24) >>> 6)
-                    | ((decodabet[source[srcOffset + 1]] << 24) >>> 12)
-                    | ((decodabet[source[srcOffset + 2]] << 24) >>> 18);
-
-            destination[destOffset] = (byte) (outBuff >>> 16);
-            destination[destOffset + 1] = (byte) (outBuff >>> 8);
-            return 2;
-        } else {
-            // Example: DkLE
-            int outBuff =
-                    ((decodabet[source[srcOffset]] << 24) >>> 6)
-                    | ((decodabet[source[srcOffset + 1]] << 24) >>> 12)
-                    | ((decodabet[source[srcOffset + 2]] << 24) >>> 18)
-                    | ((decodabet[source[srcOffset + 3]] << 24) >>> 24);
-
-            destination[destOffset] = (byte) (outBuff >> 16);
-            destination[destOffset + 1] = (byte) (outBuff >> 8);
-            destination[destOffset + 2] = (byte) (outBuff);
-            return 3;
-        }
-    } // end decodeToBytes
-
-
-    /**
-     * Decodes data from Base64 notation.
-     *
-     * @param s the string to decode (decoded in default encoding)
-     * @return the decoded data
-     * @since 1.4
-     */
-    public static byte[] decode(String s) throws Base64DecoderException {
-        byte[] bytes = s.getBytes();
-        return decode(bytes, 0, bytes.length);
-    }
-
-    /**
-     * Decodes data from web safe Base64 notation.
-     * Web safe encoding uses '-' instead of '+', '_' instead of '/'
-     *
-     * @param s the string to decode (decoded in default encoding)
-     * @return the decoded data
-     */
-    public static byte[] decodeWebSafe(String s) throws Base64DecoderException {
-        byte[] bytes = s.getBytes();
-        return decodeWebSafe(bytes, 0, bytes.length);
-    }
-
-    /**
-     * Decodes Base64 content in byte array format and returns
-     * the decoded byte array.
-     *
-     * @param source The Base64 encoded data
-     * @return decoded data
-     * @since 1.3
-     * @throws Base64DecoderException
-     */
-    public static byte[] decode(byte[] source) throws Base64DecoderException {
-        return decode(source, 0, source.length);
-    }
-
-    /**
-     * Decodes web safe Base64 content in byte array format and returns
-     * the decoded data.
-     * Web safe encoding uses '-' instead of '+', '_' instead of '/'
-     *
-     * @param source the string to decode (decoded in default encoding)
-     * @return the decoded data
-     */
-    public static byte[] decodeWebSafe(byte[] source)
-            throws Base64DecoderException {
-        return decodeWebSafe(source, 0, source.length);
-    }
-
-    /**
-     * Decodes Base64 content in byte array format and returns
-     * the decoded byte array.
-     *
-     * @param source the Base64 encoded data
-     * @param off    the offset of where to begin decoding
-     * @param len    the length of characters to decode
-     * @return decoded data
-     * @since 1.3
-     * @throws Base64DecoderException
-     */
-    public static byte[] decode(byte[] source, int off, int len)
-            throws Base64DecoderException {
-        return decode(source, off, len, DECODABET);
-    }
-
-    /**
-     * Decodes web safe Base64 content in byte array format and returns
-     * the decoded byte array.
-     * Web safe encoding uses '-' instead of '+', '_' instead of '/'
-     *
-     * @param source the Base64 encoded data
-     * @param off    the offset of where to begin decoding
-     * @param len    the length of characters to decode
-     * @return decoded data
-     */
-    public static byte[] decodeWebSafe(byte[] source, int off, int len)
-            throws Base64DecoderException {
-        return decode(source, off, len, WEBSAFE_DECODABET);
-    }
-
-    /**
-     * Decodes Base64 content using the supplied decodabet and returns
-     * the decoded byte array.
-     *
-     * @param source the Base64 encoded data
-     * @param off the offset of where to begin decoding
-     * @param len the length of characters to decode
-     * @param decodabet the decodabet for decoding Base64 content
-     * @return decoded data
-     */
-    public static byte[] decode(byte[] source, int off, int len, byte[] decodabet)
-            throws Base64DecoderException {
-        int len34 = len * 3 / 4;
-        byte[] outBuff = new byte[2 + len34]; // Upper limit on size of output
-        int outBuffPosn = 0;
-
-        byte[] b4 = new byte[4];
-        int b4Posn = 0;
-        int i = 0;
-        byte sbiCrop = 0;
-        byte sbiDecode = 0;
-        for (i = 0; i < len; i++) {
-            sbiCrop = (byte) (source[i + off] & 0x7f); // Only the low seven bits
-            sbiDecode = decodabet[sbiCrop];
-
-            if (sbiDecode >= WHITE_SPACE_ENC) { // White space Equals sign or better
-                if (sbiDecode >= EQUALS_SIGN_ENC) {
-                    // An equals sign (for padding) must not occur at position 0 or 1
-                    // and must be the last byte[s] in the encoded value
-                    if (sbiCrop == EQUALS_SIGN) {
-                        int bytesLeft = len - i;
-                        byte lastByte = (byte) (source[len - 1 + off] & 0x7f);
-                        if (b4Posn == 0 || b4Posn == 1) {
-                            throw new Base64DecoderException(
-                                    "invalid padding byte '=' at byte offset " + i);
-                        } else if ((b4Posn == 3 && bytesLeft > 2)
-                                || (b4Posn == 4 && bytesLeft > 1)) {
-                            throw new Base64DecoderException(
-                                    "padding byte '=' falsely signals end of encoded value "
-                                            + "at offset " + i);
-                        } else if (lastByte != EQUALS_SIGN && lastByte != NEW_LINE) {
-                            throw new Base64DecoderException(
-                                    "encoded value has invalid trailing byte");
-                        }
-                        break;
-                    }
-
-                    b4[b4Posn++] = sbiCrop;
-                    if (b4Posn == 4) {
-                        outBuffPosn += decode4to3(b4, 0, outBuff, outBuffPosn, decodabet);
-                        b4Posn = 0;
-                    }
-                }
-            } else {
-                throw new Base64DecoderException("Bad Base64 input character at " + i
-                        + ": " + source[i + off] + "(decimal)");
-            }
-        }
-
-        // Because web safe encoding allows non padding base64 encodes, we
-        // need to pad the rest of the b4 buffer with equal signs when
-        // b4Posn != 0.  There can be at most 2 equal signs at the end of
-        // four characters, so the b4 buffer must have two or three
-        // characters.  This also catches the case where the input is
-        // padded with EQUALS_SIGN
-        if (b4Posn != 0) {
-            if (b4Posn == 1) {
-                throw new Base64DecoderException("single trailing character at offset "
-                        + (len - 1));
-            }
-            b4[b4Posn++] = EQUALS_SIGN;
-            outBuffPosn += decode4to3(b4, 0, outBuff, outBuffPosn, decodabet);
-        }
-
-        byte[] out = new byte[outBuffPosn];
-        System.arraycopy(outBuff, 0, out, 0, outBuffPosn);
-        return out;
-    }
-}

V2rayNG/app/src/main/java/com/v2ray/ang/util/Base64DecoderException.java

@@ -1,32 +0,0 @@
-// Copyright 2002, Google, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package com.v2ray.ang.util;
-
-/**
- * Exception thrown when encountering an invalid Base64 input character.
- *
- * @author nelson
- */
-public class Base64DecoderException extends Exception {
-    public Base64DecoderException() {
-        super();
-    }
-
-    public Base64DecoderException(String s) {
-        super(s);
-    }
-
-    private static final long serialVersionUID = 1L;
-}

V2rayNG/app/src/main/java/com/v2ray/ang/util/IabException.java

@@ -1,43 +0,0 @@
-/* Copyright (c) 2012 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.v2ray.ang.util;
-
-/**
- * Exception thrown when something went wrong with in-app billing.
- * An IabException has an associated IabResult (an error).
- * To get the IAB result that caused this exception to be thrown,
- * call {@link #getResult()}.
- */
-public class IabException extends Exception {
-    IabResult mResult;
-
-    public IabException(IabResult r) {
-        this(r, null);
-    }
-    public IabException(int response, String message) {
-        this(new IabResult(response, message));
-    }
-    public IabException(IabResult r, Exception cause) {
-        super(r.getMessage(), cause);
-        mResult = r;
-    }
-    public IabException(int response, String message, Exception cause) {
-        this(new IabResult(response, message), cause);
-    }
-
-    /** Returns the IAB result (error) that this exception signals. */
-    public IabResult getResult() { return mResult; }
-}

V2rayNG/app/src/main/java/com/v2ray/ang/util/IabHelper.java

@@ -1,979 +0,0 @@
-/* Copyright (c) 2012 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.v2ray.ang.util;
-
-import android.app.Activity;
-import android.app.PendingIntent;
-import android.content.ComponentName;
-import android.content.Context;
-import android.content.Intent;
-import android.content.IntentSender.SendIntentException;
-import android.content.ServiceConnection;
-import android.os.Bundle;
-import android.os.Handler;
-import android.os.IBinder;
-import android.os.RemoteException;
-import android.text.TextUtils;
-import android.util.Log;
-
-import com.android.vending.billing.IInAppBillingService;
-
-import org.json.JSONException;
-
-import java.util.ArrayList;
-import java.util.List;
-
-
-/**
- * Provides convenience methods for in-app billing. You can create one instance of this
- * class for your application and use it to process in-app billing operations.
- * It provides synchronous (blocking) and asynchronous (non-blocking) methods for
- * many common in-app billing operations, as well as automatic signature
- * verification.
- * <p>
- * After instantiating, you must perform setup in order to start using the object.
- * To perform setup, call the {@link #startSetup} method and provide a listener;
- * that listener will be notified when setup is complete, after which (and not before)
- * you may call other methods.
- * <p>
- * After setup is complete, you will typically want to request an inventory of owned
- * items and subscriptions. See {@link #queryInventory}, {@link #queryInventoryAsync}
- * and related methods.
- * <p>
- * When you are done with this object, don't forget to call {@link #dispose}
- * to ensure proper cleanup. This object holds a binding to the in-app billing
- * service, which will leak unless you dispose of it correctly. If you created
- * the object on an Activity's onCreate method, then the recommended
- * place to dispose of it is the Activity's onDestroy method.
- * <p>
- * A note about threading: When using this object from a background thread, you may
- * call the blocking versions of methods; when using from a UI thread, call
- * only the asynchronous versions and handle the results via callbacks.
- * Also, notice that you can only call one asynchronous operation at a time;
- * attempting to start a second asynchronous operation while the first one
- * has not yet completed will result in an exception being thrown.
- *
- * @author Bruno Oliveira (Google)
- */
-public class IabHelper {
-    // Is debug logging enabled?
-    boolean mDebugLog = false;
-    String mDebugTag = "IabHelper";
-
-    // Is setup done?
-    boolean mSetupDone = false;
-
-    // Has this object been disposed of? (If so, we should ignore callbacks, etc)
-    boolean mDisposed = false;
-
-    // Are subscriptions supported?
-    boolean mSubscriptionsSupported = false;
-
-    // Is an asynchronous operation in progress?
-    // (only one at a time can be in progress)
-    boolean mAsyncInProgress = false;
-
-    // (for logging/debugging)
-    // if mAsyncInProgress == true, what asynchronous operation is in progress?
-    String mAsyncOperation = "";
-
-    // Context we were passed during initialization
-    Context mContext;
-
-    // Connection to the service
-    IInAppBillingService mService;
-    ServiceConnection mServiceConn;
-
-    // The request code used to launch purchase flow
-    int mRequestCode;
-
-    // The item type of the current purchase flow
-    String mPurchasingItemType;
-
-    // Public key for verifying signature, in base64 encoding
-    String mSignatureBase64 = null;
-
-    // Billing response codes
-    public static final int BILLING_RESPONSE_RESULT_OK = 0;
-    public static final int BILLING_RESPONSE_RESULT_USER_CANCELED = 1;
-    public static final int BILLING_RESPONSE_RESULT_BILLING_UNAVAILABLE = 3;
-    public static final int BILLING_RESPONSE_RESULT_ITEM_UNAVAILABLE = 4;
-    public static final int BILLING_RESPONSE_RESULT_DEVELOPER_ERROR = 5;
-    public static final int BILLING_RESPONSE_RESULT_ERROR = 6;
-    public static final int BILLING_RESPONSE_RESULT_ITEM_ALREADY_OWNED = 7;
-    public static final int BILLING_RESPONSE_RESULT_ITEM_NOT_OWNED = 8;
-
-    // IAB Helper error codes
-    public static final int IABHELPER_ERROR_BASE = -1000;
-    public static final int IABHELPER_REMOTE_EXCEPTION = -1001;
-    public static final int IABHELPER_BAD_RESPONSE = -1002;
-    public static final int IABHELPER_VERIFICATION_FAILED = -1003;
-    public static final int IABHELPER_SEND_INTENT_FAILED = -1004;
-    public static final int IABHELPER_USER_CANCELLED = -1005;
-    public static final int IABHELPER_UNKNOWN_PURCHASE_RESPONSE = -1006;
-    public static final int IABHELPER_MISSING_TOKEN = -1007;
-    public static final int IABHELPER_UNKNOWN_ERROR = -1008;
-    public static final int IABHELPER_SUBSCRIPTIONS_NOT_AVAILABLE = -1009;
-    public static final int IABHELPER_INVALID_CONSUMPTION = -1010;
-
-    // Keys for the responses from InAppBillingService
-    public static final String RESPONSE_CODE = "RESPONSE_CODE";
-    public static final String RESPONSE_GET_SKU_DETAILS_LIST = "DETAILS_LIST";
-    public static final String RESPONSE_BUY_INTENT = "BUY_INTENT";
-    public static final String RESPONSE_INAPP_PURCHASE_DATA = "INAPP_PURCHASE_DATA";
-    public static final String RESPONSE_INAPP_SIGNATURE = "INAPP_DATA_SIGNATURE";
-    public static final String RESPONSE_INAPP_ITEM_LIST = "INAPP_PURCHASE_ITEM_LIST";
-    public static final String RESPONSE_INAPP_PURCHASE_DATA_LIST = "INAPP_PURCHASE_DATA_LIST";
-    public static final String RESPONSE_INAPP_SIGNATURE_LIST = "INAPP_DATA_SIGNATURE_LIST";
-    public static final String INAPP_CONTINUATION_TOKEN = "INAPP_CONTINUATION_TOKEN";
-
-    // Item types
-    public static final String ITEM_TYPE_INAPP = "inapp";
-    public static final String ITEM_TYPE_SUBS = "subs";
-
-    // some fields on the getSkuDetails response bundle
-    public static final String GET_SKU_DETAILS_ITEM_LIST = "ITEM_ID_LIST";
-    public static final String GET_SKU_DETAILS_ITEM_TYPE_LIST = "ITEM_TYPE_LIST";
-
-    /**
-     * Creates an instance. After creation, it will not yet be ready to use. You must perform
-     * setup by calling {@link #startSetup} and wait for setup to complete. This constructor does not
-     * block and is safe to call from a UI thread.
-     *
-     * @param ctx             Your application or Activity context. Needed to bind to the in-app billing service.
-     * @param base64PublicKey Your application's public key, encoded in base64.
-     *                        This is used for verification of purchase signatures. You can find your app's base64-encoded
-     *                        public key in your application's page on Google Play Developer Console. Note that this
-     *                        is NOT your "developer public key".
-     */
-    public IabHelper(Context ctx, String base64PublicKey) {
-        mContext = ctx.getApplicationContext();
-        mSignatureBase64 = base64PublicKey;
-        logDebug("IAB helper created.");
-    }
-
-    /**
-     * Enables or disable debug logging through LogCat.
-     */
-    public void enableDebugLogging(boolean enable, String tag) {
-        checkNotDisposed();
-        mDebugLog = enable;
-        mDebugTag = tag;
-    }
-
-    public void enableDebugLogging(boolean enable) {
-        checkNotDisposed();
-        mDebugLog = enable;
-    }
-
-    /**
-     * Callback for setup process. This listener's {@link #onIabSetupFinished} method is called
-     * when the setup process is complete.
-     */
-    public interface OnIabSetupFinishedListener {
-        /**
-         * Called to notify that setup is complete.
-         *
-         * @param result The result of the setup process.
-         */
-        void onIabSetupFinished(IabResult result);
-    }
-
-    /**
-     * Starts the setup process. This will start up the setup process asynchronously.
-     * You will be notified through the listener when the setup process is complete.
-     * This method is safe to call from a UI thread.
-     *
-     * @param listener The listener to notify when the setup process is complete.
-     */
-    public void startSetup(final OnIabSetupFinishedListener listener) {
-        // If already set up, can't do it again.
-        checkNotDisposed();
-        if (mSetupDone) throw new IllegalStateException("IAB helper is already set up.");
-
-        // Connection to IAB service
-        logDebug("Starting in-app billing setup.");
-        mServiceConn = new ServiceConnection() {
-            @Override
-            public void onServiceDisconnected(ComponentName name) {
-                logDebug("Billing service disconnected.");
-                mService = null;
-            }
-
-            @Override
-            public void onServiceConnected(ComponentName name, IBinder service) {
-                if (mDisposed) return;
-                logDebug("Billing service connected.");
-                mService = IInAppBillingService.Stub.asInterface(service);
-                String packageName = mContext.getPackageName();
-                try {
-                    logDebug("Checking for in-app billing 3 support.");
-
-                    // check for in-app billing v3 support
-                    int response = mService.isBillingSupported(3, packageName, ITEM_TYPE_INAPP);
-                    if (response != BILLING_RESPONSE_RESULT_OK) {
-                        if (listener != null) listener.onIabSetupFinished(new IabResult(response,
-                                "Error checking for billing v3 support."));
-
-                        // if in-app purchases aren't supported, neither are subscriptions.
-                        mSubscriptionsSupported = false;
-                        return;
-                    }
-                    logDebug("In-app billing version 3 supported for " + packageName);
-
-                    // check for v3 subscriptions support
-                    response = mService.isBillingSupported(3, packageName, ITEM_TYPE_SUBS);
-                    if (response == BILLING_RESPONSE_RESULT_OK) {
-                        logDebug("Subscriptions AVAILABLE.");
-                        mSubscriptionsSupported = true;
-                    } else {
-                        logDebug("Subscriptions NOT AVAILABLE. Response: " + response);
-                    }
-
-                    mSetupDone = true;
-                } catch (RemoteException e) {
-                    if (listener != null) {
-                        listener.onIabSetupFinished(new IabResult(IABHELPER_REMOTE_EXCEPTION,
-                                "RemoteException while setting up in-app billing."));
-                    }
-                    e.printStackTrace();
-                    return;
-                }
-
-                if (listener != null) {
-                    listener.onIabSetupFinished(new IabResult(BILLING_RESPONSE_RESULT_OK, "Setup successful."));
-                }
-            }
-        };
-
-//        Intent serviceIntent = new Intent("ir.cafebazaar.pardakht.InAppBillingService.BIND");
-//        serviceIntent.setPackage("com.farsitel.bazaar");
-        Intent serviceIntent = new Intent("com.android.vending.billing.InAppBillingService.BIND");
-        serviceIntent.setPackage("com.android.vending");
-        if (!mContext.getPackageManager().queryIntentServices(serviceIntent, 0).isEmpty()) {
-            // service available to handle that Intent
-            mContext.bindService(serviceIntent, mServiceConn, Context.BIND_AUTO_CREATE);
-        } else {
-            // no service available to handle that Intent
-            if (listener != null) {
-                listener.onIabSetupFinished(
-                        new IabResult(BILLING_RESPONSE_RESULT_BILLING_UNAVAILABLE,
-                                "Billing service unavailable on device."));
-            }
-        }
-    }
-
-    /**
-     * Dispose of object, releasing resources. It's very important to call this
-     * method when you are done with this object. It will release any resources
-     * used by it such as service connections. Naturally, once the object is
-     * disposed of, it can't be used again.
-     */
-    public void dispose() {
-        logDebug("Disposing.");
-        mSetupDone = false;
-        if (mServiceConn != null) {
-            logDebug("Unbinding from service.");
-            if (mContext != null) mContext.unbindService(mServiceConn);
-        }
-        mDisposed = true;
-        mContext = null;
-        mServiceConn = null;
-        mService = null;
-        mPurchaseListener = null;
-    }
-
-    private void checkNotDisposed() {
-        if (mDisposed)
-            throw new IllegalStateException("IabHelper was disposed of, so it cannot be used.");
-    }
-
-    /**
-     * Returns whether subscriptions are supported.
-     */
-    public boolean subscriptionsSupported() {
-        checkNotDisposed();
-        return mSubscriptionsSupported;
-    }
-
-
-    /**
-     * Callback that notifies when a purchase is finished.
-     */
-    public interface OnIabPurchaseFinishedListener {
-        /**
-         * Called to notify that an in-app purchase finished. If the purchase was successful,
-         * then the sku parameter specifies which item was purchased. If the purchase failed,
-         * the sku and extraData parameters may or may not be null, depending on how far the purchase
-         * process went.
-         *
-         * @param result The result of the purchase.
-         * @param info   The purchase information (null if purchase failed)
-         */
-        void onIabPurchaseFinished(IabResult result, Purchase info);
-    }
-
-    // The listener registered on launchPurchaseFlow, which we have to call back when
-    // the purchase finishes
-    OnIabPurchaseFinishedListener mPurchaseListener;
-
-    public void launchPurchaseFlow(Activity act, String sku, int requestCode, OnIabPurchaseFinishedListener listener) {
-        launchPurchaseFlow(act, sku, requestCode, listener, "");
-    }
-
-    public void launchPurchaseFlow(Activity act, String sku, int requestCode,
-                                   OnIabPurchaseFinishedListener listener, String extraData) {
-        launchPurchaseFlow(act, sku, ITEM_TYPE_INAPP, requestCode, listener, extraData);
-    }
-
-    public void launchSubscriptionPurchaseFlow(Activity act, String sku, int requestCode,
-                                               OnIabPurchaseFinishedListener listener) {
-        launchSubscriptionPurchaseFlow(act, sku, requestCode, listener, "");
-    }
-
-    public void launchSubscriptionPurchaseFlow(Activity act, String sku, int requestCode,
-                                               OnIabPurchaseFinishedListener listener, String extraData) {
-        launchPurchaseFlow(act, sku, ITEM_TYPE_SUBS, requestCode, listener, extraData);
-    }
-
-    /**
-     * Initiate the UI flow for an in-app purchase. Call this method to initiate an in-app purchase,
-     * which will involve bringing up the Google Play screen. The calling activity will be paused while
-     * the user interacts with Google Play, and the result will be delivered via the activity's
-     * {@link android.app.Activity#onActivityResult} method, at which point you must call
-     * this object's {@link #handleActivityResult} method to continue the purchase flow. This method
-     * MUST be called from the UI thread of the Activity.
-     *
-     * @param act         The calling activity.
-     * @param sku         The sku of the item to purchase.
-     * @param itemType    indicates if it's a product or a subscription (ITEM_TYPE_INAPP or ITEM_TYPE_SUBS)
-     * @param requestCode A request code (to differentiate from other responses --
-     *                    as in {@link android.app.Activity#startActivityForResult}).
-     * @param listener    The listener to notify when the purchase process finishes
-     * @param extraData   Extra data (developer payload), which will be returned with the purchase data
-     *                    when the purchase completes. This extra data will be permanently bound to that purchase
-     *                    and will always be returned when the purchase is queried.
-     */
-    public void launchPurchaseFlow(Activity act, String sku, String itemType, int requestCode,
-                                   OnIabPurchaseFinishedListener listener, String extraData) {
-        checkNotDisposed();
-        checkSetupDone("launchPurchaseFlow");
-        flagStartAsync("launchPurchaseFlow");
-        IabResult result;
-
-        if (itemType.equals(ITEM_TYPE_SUBS) && !mSubscriptionsSupported) {
-            IabResult r = new IabResult(IABHELPER_SUBSCRIPTIONS_NOT_AVAILABLE,
-                    "Subscriptions are not available.");
-            flagEndAsync();
-            if (listener != null) listener.onIabPurchaseFinished(r, null);
-            return;
-        }
-
-        try {
-            logDebug("Constructing buy intent for " + sku + ", item type: " + itemType);
-            Bundle buyIntentBundle = mService.getBuyIntent(3, mContext.getPackageName(), sku, itemType, extraData);
-            int response = getResponseCodeFromBundle(buyIntentBundle);
-            if (response != BILLING_RESPONSE_RESULT_OK) {
-                logError("Unable to buy item, Error response: " + getResponseDesc(response));
-                flagEndAsync();
-                result = new IabResult(response, "Unable to buy item");
-                if (listener != null) listener.onIabPurchaseFinished(result, null);
-                return;
-            }
-
-            PendingIntent pendingIntent = buyIntentBundle.getParcelable(RESPONSE_BUY_INTENT);
-            logDebug("Launching buy intent for " + sku + ". Request code: " + requestCode);
-            mRequestCode = requestCode;
-            mPurchaseListener = listener;
-            mPurchasingItemType = itemType;
-            act.startIntentSenderForResult(pendingIntent.getIntentSender(),
-                    requestCode, new Intent(),
-                    Integer.valueOf(0), Integer.valueOf(0),
-                    Integer.valueOf(0));
-        } catch (SendIntentException e) {
-            logError("SendIntentException while launching purchase flow for sku " + sku);
-            e.printStackTrace();
-            flagEndAsync();
-
-            result = new IabResult(IABHELPER_SEND_INTENT_FAILED, "Failed to send intent.");
-            if (listener != null) listener.onIabPurchaseFinished(result, null);
-        } catch (RemoteException e) {
-            logError("RemoteException while launching purchase flow for sku " + sku);
-            e.printStackTrace();
-            flagEndAsync();
-
-            result = new IabResult(IABHELPER_REMOTE_EXCEPTION, "Remote exception while starting purchase flow");
-            if (listener != null) listener.onIabPurchaseFinished(result, null);
-        }
-    }
-
-    /**
-     * Handles an activity result that's part of the purchase flow in in-app billing. If you
-     * are calling {@link #launchPurchaseFlow}, then you must call this method from your
-     * Activity's {@link android.app.Activity@onActivityResult} method. This method
-     * MUST be called from the UI thread of the Activity.
-     *
-     * @param requestCode The requestCode as you received it.
-     * @param resultCode  The resultCode as you received it.
-     * @param data        The data (Intent) as you received it.
-     * @return Returns true if the result was related to a purchase flow and was handled;
-     * false if the result was not related to a purchase, in which case you should
-     * handle it normally.
-     */
-    public boolean handleActivityResult(int requestCode, int resultCode, Intent data) {
-        IabResult result;
-        if (requestCode != mRequestCode) return false;
-
-        checkNotDisposed();
-        checkSetupDone("handleActivityResult");
-
-        // end of async purchase operation that started on launchPurchaseFlow
-        flagEndAsync();
-
-        if (data == null) {
-            logError("Null data in IAB activity result.");
-            result = new IabResult(IABHELPER_BAD_RESPONSE, "Null data in IAB result");
-            if (mPurchaseListener != null) mPurchaseListener.onIabPurchaseFinished(result, null);
-            return true;
-        }
-
-        int responseCode = getResponseCodeFromIntent(data);
-        String purchaseData = data.getStringExtra(RESPONSE_INAPP_PURCHASE_DATA);
-        String dataSignature = data.getStringExtra(RESPONSE_INAPP_SIGNATURE);
-
-        if (resultCode == Activity.RESULT_OK && responseCode == BILLING_RESPONSE_RESULT_OK) {
-            logDebug("Successful resultcode from purchase activity.");
-            logDebug("Purchase data: " + purchaseData);
-            logDebug("Data signature: " + dataSignature);
-            logDebug("Extras: " + data.getExtras());
-            logDebug("Expected item type: " + mPurchasingItemType);
-
-            if (purchaseData == null || dataSignature == null) {
-                logError("BUG: either purchaseData or dataSignature is null.");
-                logDebug("Extras: " + data.getExtras().toString());
-                result = new IabResult(IABHELPER_UNKNOWN_ERROR, "IAB returned null purchaseData or dataSignature");
-                if (mPurchaseListener != null)
-                    mPurchaseListener.onIabPurchaseFinished(result, null);
-                return true;
-            }
-
-            Purchase purchase = null;
-            try {
-                purchase = new Purchase(mPurchasingItemType, purchaseData, dataSignature);
-                String sku = purchase.getSku();
-
-                // Verify signature
-                if (!Security.verifyPurchase(mSignatureBase64, purchaseData, dataSignature)) {
-                    logError("Purchase signature verification FAILED for sku " + sku);
-                    result = new IabResult(IABHELPER_VERIFICATION_FAILED, "Signature verification failed for sku " + sku);
-                    if (mPurchaseListener != null)
-                        mPurchaseListener.onIabPurchaseFinished(result, purchase);
-                    return true;
-                }
-                logDebug("Purchase signature successfully verified.");
-            } catch (JSONException e) {
-                logError("Failed to parse purchase data.");
-                e.printStackTrace();
-                result = new IabResult(IABHELPER_BAD_RESPONSE, "Failed to parse purchase data.");
-                if (mPurchaseListener != null)
-                    mPurchaseListener.onIabPurchaseFinished(result, null);
-                return true;
-            }
-
-            if (mPurchaseListener != null) {
-                mPurchaseListener.onIabPurchaseFinished(new IabResult(BILLING_RESPONSE_RESULT_OK, "Success"), purchase);
-            }
-        } else if (resultCode == Activity.RESULT_OK) {
-            // result code was OK, but in-app billing response was not OK.
-            logDebug("Result code was OK but in-app billing response was not OK: " + getResponseDesc(responseCode));
-            if (mPurchaseListener != null) {
-                result = new IabResult(responseCode, "Problem purchashing item.");
-                mPurchaseListener.onIabPurchaseFinished(result, null);
-            }
-        } else if (resultCode == Activity.RESULT_CANCELED) {
-            logDebug("Purchase canceled - Response: " + getResponseDesc(responseCode));
-            result = new IabResult(IABHELPER_USER_CANCELLED, "User canceled.");
-            if (mPurchaseListener != null) mPurchaseListener.onIabPurchaseFinished(result, null);
-        } else {
-            logError("Purchase failed. Result code: " + Integer.toString(resultCode)
-                    + ". Response: " + getResponseDesc(responseCode));
-            result = new IabResult(IABHELPER_UNKNOWN_PURCHASE_RESPONSE, "Unknown purchase response.");
-            if (mPurchaseListener != null) mPurchaseListener.onIabPurchaseFinished(result, null);
-        }
-        return true;
-    }
-
-    public Inventory queryInventory(boolean querySkuDetails, List<String> moreSkus) throws IabException {
-        return queryInventory(querySkuDetails, moreSkus, null);
-    }
-
-    /**
-     * Queries the inventory. This will query all owned items from the server, as well as
-     * information on additional skus, if specified. This method may block or take long to execute.
-     * Do not call from a UI thread. For that, use the non-blocking version {@link #refreshInventoryAsync}.
-     *
-     * @param querySkuDetails if true, SKU details (price, description, etc) will be queried as well
-     *                        as purchase information.
-     * @param moreItemSkus    additional PRODUCT skus to query information on, regardless of ownership.
-     *                        Ignored if null or if querySkuDetails is false.
-     * @param moreSubsSkus    additional SUBSCRIPTIONS skus to query information on, regardless of ownership.
-     *                        Ignored if null or if querySkuDetails is false.
-     * @throws IabException if a problem occurs while refreshing the inventory.
-     */
-    public Inventory queryInventory(boolean querySkuDetails, List<String> moreItemSkus,
-                                    List<String> moreSubsSkus) throws IabException {
-        checkNotDisposed();
-        checkSetupDone("queryInventory");
-        try {
-            Inventory inv = new Inventory();
-            int r = queryPurchases(inv, ITEM_TYPE_INAPP);
-            if (r != BILLING_RESPONSE_RESULT_OK) {
-                throw new IabException(r, "Error refreshing inventory (querying owned items).");
-            }
-
-            if (querySkuDetails) {
-                r = querySkuDetails(ITEM_TYPE_INAPP, inv, moreItemSkus);
-                if (r != BILLING_RESPONSE_RESULT_OK) {
-                    throw new IabException(r, "Error refreshing inventory (querying prices of items).");
-                }
-            }
-
-            // if subscriptions are supported, then also query for subscriptions
-            if (mSubscriptionsSupported) {
-                r = queryPurchases(inv, ITEM_TYPE_SUBS);
-                if (r != BILLING_RESPONSE_RESULT_OK) {
-                    throw new IabException(r, "Error refreshing inventory (querying owned subscriptions).");
-                }
-
-                if (querySkuDetails) {
-                    r = querySkuDetails(ITEM_TYPE_SUBS, inv, moreItemSkus);
-                    if (r != BILLING_RESPONSE_RESULT_OK) {
-                        throw new IabException(r, "Error refreshing inventory (querying prices of subscriptions).");
-                    }
-                }
-            }
-
-            return inv;
-        } catch (RemoteException e) {
-            throw new IabException(IABHELPER_REMOTE_EXCEPTION, "Remote exception while refreshing inventory.", e);
-        } catch (JSONException e) {
-            throw new IabException(IABHELPER_BAD_RESPONSE, "Error parsing JSON response while refreshing inventory.", e);
-        }
-    }
-
-    /**
-     * Listener that notifies when an inventory query operation completes.
-     */
-    public interface QueryInventoryFinishedListener {
-        /**
-         * Called to notify that an inventory query operation completed.
-         *
-         * @param result The result of the operation.
-         * @param inv    The inventory.
-         */
-        void onQueryInventoryFinished(IabResult result, Inventory inv);
-    }
-
-
-    /**
-     * Asynchronous wrapper for inventory query. This will perform an inventory
-     * query as described in {@link #queryInventory}, but will do so asynchronously
-     * and call back the specified listener upon completion. This method is safe to
-     * call from a UI thread.
-     *
-     * @param querySkuDetails as in {@link #queryInventory}
-     * @param moreSkus        as in {@link #queryInventory}
-     * @param listener        The listener to notify when the refresh operation completes.
-     */
-    public void queryInventoryAsync(final boolean querySkuDetails,
-                                    final List<String> moreSkus,
-                                    final QueryInventoryFinishedListener listener) {
-        final Handler handler = new Handler();
-        checkNotDisposed();
-        checkSetupDone("queryInventory");
-        flagStartAsync("refresh inventory");
-        (new Thread(new Runnable() {
-            public void run() {
-                IabResult result = new IabResult(BILLING_RESPONSE_RESULT_OK, "Inventory refresh successful.");
-                Inventory inv = null;
-                try {
-                    inv = queryInventory(querySkuDetails, moreSkus);
-                } catch (IabException ex) {
-                    result = ex.getResult();
-                }
-
-                flagEndAsync();
-
-                final IabResult result_f = result;
-                final Inventory inv_f = inv;
-                if (!mDisposed && listener != null) {
-                    handler.post(new Runnable() {
-                        public void run() {
-                            listener.onQueryInventoryFinished(result_f, inv_f);
-                        }
-                    });
-                }
-            }
-        })).start();
-    }
-
-    public void queryInventoryAsync(QueryInventoryFinishedListener listener) {
-        queryInventoryAsync(true, null, listener);
-    }
-
-    public void queryInventoryAsync(boolean querySkuDetails, QueryInventoryFinishedListener listener) {
-        queryInventoryAsync(querySkuDetails, null, listener);
-    }
-
-
-    /**
-     * Consumes a given in-app product. Consuming can only be done on an item
-     * that's owned, and as a result of consumption, the user will no longer own it.
-     * This method may block or take long to return. Do not call from the UI thread.
-     * For that, see {@link #consumeAsync}.
-     *
-     * @param itemInfo The PurchaseInfo that represents the item to consume.
-     * @throws IabException if there is a problem during consumption.
-     */
-    void consume(Purchase itemInfo) throws IabException {
-        checkNotDisposed();
-        checkSetupDone("consume");
-
-        if (!itemInfo.mItemType.equals(ITEM_TYPE_INAPP)) {
-            throw new IabException(IABHELPER_INVALID_CONSUMPTION,
-                    "Items of type '" + itemInfo.mItemType + "' can't be consumed.");
-        }
-
-        try {
-            String token = itemInfo.getToken();
-            String sku = itemInfo.getSku();
-            if (token == null || token.equals("")) {
-                logError("Can't consume " + sku + ". No token.");
-                throw new IabException(IABHELPER_MISSING_TOKEN, "PurchaseInfo is missing token for sku: "
-                        + sku + " " + itemInfo);
-            }
-
-            logDebug("Consuming sku: " + sku + ", token: " + token);
-            int response = mService.consumePurchase(3, mContext.getPackageName(), token);
-            if (response == BILLING_RESPONSE_RESULT_OK) {
-                logDebug("Successfully consumed sku: " + sku);
-            } else {
-                logDebug("Error consuming consuming sku " + sku + ". " + getResponseDesc(response));
-                throw new IabException(response, "Error consuming sku " + sku);
-            }
-        } catch (RemoteException e) {
-            throw new IabException(IABHELPER_REMOTE_EXCEPTION, "Remote exception while consuming. PurchaseInfo: " + itemInfo, e);
-        }
-    }
-
-    /**
-     * Callback that notifies when a consumption operation finishes.
-     */
-    public interface OnConsumeFinishedListener {
-        /**
-         * Called to notify that a consumption has finished.
-         *
-         * @param purchase The purchase that was (or was to be) consumed.
-         * @param result   The result of the consumption operation.
-         */
-        void onConsumeFinished(Purchase purchase, IabResult result);
-    }
-
-    /**
-     * Callback that notifies when a multi-item consumption operation finishes.
-     */
-    public interface OnConsumeMultiFinishedListener {
-        /**
-         * Called to notify that a consumption of multiple items has finished.
-         *
-         * @param purchases The purchases that were (or were to be) consumed.
-         * @param results   The results of each consumption operation, corresponding to each
-         *                  sku.
-         */
-        void onConsumeMultiFinished(List<Purchase> purchases, List<IabResult> results);
-    }
-
-    /**
-     * Asynchronous wrapper to item consumption. Works like {@link #consume}, but
-     * performs the consumption in the background and notifies completion through
-     * the provided listener. This method is safe to call from a UI thread.
-     *
-     * @param purchase The purchase to be consumed.
-     * @param listener The listener to notify when the consumption operation finishes.
-     */
-    public void consumeAsync(Purchase purchase, OnConsumeFinishedListener listener) {
-        checkNotDisposed();
-        checkSetupDone("consume");
-        List<Purchase> purchases = new ArrayList<Purchase>();
-        purchases.add(purchase);
-        consumeAsyncInternal(purchases, listener, null);
-    }
-
-    /**
-     * Same as {@link consumeAsync}, but for multiple items at once.
-     *
-     * @param purchases The list of PurchaseInfo objects representing the purchases to consume.
-     * @param listener  The listener to notify when the consumption operation finishes.
-     */
-    public void consumeAsync(List<Purchase> purchases, OnConsumeMultiFinishedListener listener) {
-        checkNotDisposed();
-        checkSetupDone("consume");
-        consumeAsyncInternal(purchases, null, listener);
-    }
-
-    /**
-     * Returns a human-readable description for the given response code.
-     *
-     * @param code The response code
-     * @return A human-readable string explaining the result code.
-     * It also includes the result code numerically.
-     */
-    public static String getResponseDesc(int code) {
-        String[] iab_msgs = ("0:OK/1:User Canceled/2:Unknown/" +
-                "3:Billing Unavailable/4:Item unavailable/" +
-                "5:Developer Error/6:Error/7:Item Already Owned/" +
-                "8:Item not owned").split("/");
-        String[] iabhelper_msgs = ("0:OK/-1001:Remote exception during initialization/" +
-                "-1002:Bad response received/" +
-                "-1003:Purchase signature verification failed/" +
-                "-1004:Send intent failed/" +
-                "-1005:User cancelled/" +
-                "-1006:Unknown purchase response/" +
-                "-1007:Missing token/" +
-                "-1008:Unknown error/" +
-                "-1009:Subscriptions not available/" +
-                "-1010:Invalid consumption attempt").split("/");
-
-        if (code <= IABHELPER_ERROR_BASE) {
-            int index = IABHELPER_ERROR_BASE - code;
-            if (index >= 0 && index < iabhelper_msgs.length) return iabhelper_msgs[index];
-            else return String.valueOf(code) + ":Unknown IAB Helper Error";
-        } else if (code < 0 || code >= iab_msgs.length)
-            return String.valueOf(code) + ":Unknown";
-        else
-            return iab_msgs[code];
-    }
-
-
-    // Checks that setup was done; if not, throws an exception.
-    void checkSetupDone(String operation) {
-        if (!mSetupDone) {
-            logError("Illegal state for operation (" + operation + "): IAB helper is not set up.");
-            throw new IllegalStateException("IAB helper is not set up. Can't perform operation: " + operation);
-        }
-    }
-
-    // Workaround to bug where sometimes response codes come as Long instead of Integer
-    int getResponseCodeFromBundle(Bundle b) {
-        Object o = b.get(RESPONSE_CODE);
-        if (o == null) {
-            logDebug("Bundle with null response code, assuming OK (known issue)");
-            return BILLING_RESPONSE_RESULT_OK;
-        } else if (o instanceof Integer) return ((Integer) o).intValue();
-        else if (o instanceof Long) return (int) ((Long) o).longValue();
-        else {
-            logError("Unexpected type for bundle response code.");
-            logError(o.getClass().getName());
-            throw new RuntimeException("Unexpected type for bundle response code: " + o.getClass().getName());
-        }
-    }
-
-    // Workaround to bug where sometimes response codes come as Long instead of Integer
-    int getResponseCodeFromIntent(Intent i) {
-        Object o = i.getExtras().get(RESPONSE_CODE);
-        if (o == null) {
-            logError("Intent with no response code, assuming OK (known issue)");
-            return BILLING_RESPONSE_RESULT_OK;
-        } else if (o instanceof Integer) return ((Integer) o).intValue();
-        else if (o instanceof Long) return (int) ((Long) o).longValue();
-        else {
-            logError("Unexpected type for intent response code.");
-            logError(o.getClass().getName());
-            throw new RuntimeException("Unexpected type for intent response code: " + o.getClass().getName());
-        }
-    }
-
-    void flagStartAsync(String operation) {
-        if (mAsyncInProgress) throw new IllegalStateException("Can't start async operation (" +
-                operation + ") because another async operation(" + mAsyncOperation + ") is in progress.");
-        mAsyncOperation = operation;
-        mAsyncInProgress = true;
-        logDebug("Starting async operation: " + operation);
-    }
-
-    void flagEndAsync() {
-        logDebug("Ending async operation: " + mAsyncOperation);
-        mAsyncOperation = "";
-        mAsyncInProgress = false;
-    }
-
-
-    int queryPurchases(Inventory inv, String itemType) throws JSONException, RemoteException {
-        // Query purchases
-        logDebug("Querying owned items, item type: " + itemType);
-        logDebug("Package name: " + mContext.getPackageName());
-        boolean verificationFailed = false;
-        String continueToken = null;
-
-        do {
-            logDebug("Calling getPurchases with continuation token: " + continueToken);
-            Bundle ownedItems = mService.getPurchases(3, mContext.getPackageName(),
-                    itemType, continueToken);
-
-            int response = getResponseCodeFromBundle(ownedItems);
-            logDebug("Owned items response: " + String.valueOf(response));
-            if (response != BILLING_RESPONSE_RESULT_OK) {
-                logDebug("getPurchases() failed: " + getResponseDesc(response));
-                return response;
-            }
-            if (!ownedItems.containsKey(RESPONSE_INAPP_ITEM_LIST)
-                    || !ownedItems.containsKey(RESPONSE_INAPP_PURCHASE_DATA_LIST)
-                    || !ownedItems.containsKey(RESPONSE_INAPP_SIGNATURE_LIST)) {
-                logError("Bundle returned from getPurchases() doesn't contain required fields.");
-                return IABHELPER_BAD_RESPONSE;
-            }
-
-            ArrayList<String> ownedSkus = ownedItems.getStringArrayList(
-                    RESPONSE_INAPP_ITEM_LIST);
-            ArrayList<String> purchaseDataList = ownedItems.getStringArrayList(
-                    RESPONSE_INAPP_PURCHASE_DATA_LIST);
-            ArrayList<String> signatureList = ownedItems.getStringArrayList(
-                    RESPONSE_INAPP_SIGNATURE_LIST);
-
-            for (int i = 0; i < purchaseDataList.size(); ++i) {
-                String purchaseData = purchaseDataList.get(i);
-                String signature = signatureList.get(i);
-                String sku = ownedSkus.get(i);
-                if (Security.verifyPurchase(mSignatureBase64, purchaseData, signature)) {
-                    logDebug("Sku is owned: " + sku);
-                    Purchase purchase = new Purchase(itemType, purchaseData, signature);
-
-                    if (TextUtils.isEmpty(purchase.getToken())) {
-                        logWarn("BUG: empty/null token!");
-                        logDebug("Purchase data: " + purchaseData);
-                    }
-
-                    // Record ownership and token
-                    inv.addPurchase(purchase);
-                } else {
-                    logWarn("Purchase signature verification **FAILED**. Not adding item.");
-                    logDebug("   Purchase data: " + purchaseData);
-                    logDebug("   Signature: " + signature);
-                    verificationFailed = true;
-                }
-            }
-
-            continueToken = ownedItems.getString(INAPP_CONTINUATION_TOKEN);
-            logDebug("Continuation token: " + continueToken);
-        } while (!TextUtils.isEmpty(continueToken));
-
-        return verificationFailed ? IABHELPER_VERIFICATION_FAILED : BILLING_RESPONSE_RESULT_OK;
-    }
-
-    int querySkuDetails(String itemType, Inventory inv, List<String> moreSkus)
-            throws RemoteException, JSONException {
-        logDebug("Querying SKU details.");
-        ArrayList<String> skuList = new ArrayList<String>();
-        skuList.addAll(inv.getAllOwnedSkus(itemType));
-        if (moreSkus != null) {
-            for (String sku : moreSkus) {
-                if (!skuList.contains(sku)) {
-                    skuList.add(sku);
-                }
-            }
-        }
-
-        if (skuList.size() == 0) {
-            logDebug("queryPrices: nothing to do because there are no SKUs.");
-            return BILLING_RESPONSE_RESULT_OK;
-        }
-
-        Bundle querySkus = new Bundle();
-        querySkus.putStringArrayList(GET_SKU_DETAILS_ITEM_LIST, skuList);
-        Bundle skuDetails = mService.getSkuDetails(3, mContext.getPackageName(),
-                itemType, querySkus);
-
-        if (!skuDetails.containsKey(RESPONSE_GET_SKU_DETAILS_LIST)) {
-            int response = getResponseCodeFromBundle(skuDetails);
-            if (response != BILLING_RESPONSE_RESULT_OK) {
-                logDebug("getSkuDetails() failed: " + getResponseDesc(response));
-                return response;
-            } else {
-                logError("getSkuDetails() returned a bundle with neither an error nor a detail list.");
-                return IABHELPER_BAD_RESPONSE;
-            }
-        }
-
-        ArrayList<String> responseList = skuDetails.getStringArrayList(
-                RESPONSE_GET_SKU_DETAILS_LIST);
-
-        for (String thisResponse : responseList) {
-            SkuDetails d = new SkuDetails(itemType, thisResponse);
-            logDebug("Got sku details: " + d);
-            inv.addSkuDetails(d);
-        }
-        return BILLING_RESPONSE_RESULT_OK;
-    }
-
-
-    void consumeAsyncInternal(final List<Purchase> purchases,
-                              final OnConsumeFinishedListener singleListener,
-                              final OnConsumeMultiFinishedListener multiListener) {
-        final Handler handler = new Handler();
-        flagStartAsync("consume");
-        (new Thread(new Runnable() {
-            public void run() {
-                final List<IabResult> results = new ArrayList<IabResult>();
-                for (Purchase purchase : purchases) {
-                    try {
-                        consume(purchase);
-                        results.add(new IabResult(BILLING_RESPONSE_RESULT_OK, "Successful consume of sku " + purchase.getSku()));
-                    } catch (IabException ex) {
-                        results.add(ex.getResult());
-                    }
-                }
-
-                flagEndAsync();
-                if (!mDisposed && singleListener != null) {
-                    handler.post(new Runnable() {
-                        public void run() {
-                            singleListener.onConsumeFinished(purchases.get(0), results.get(0));
-                        }
-                    });
-                }
-                if (!mDisposed && multiListener != null) {
-                    handler.post(new Runnable() {
-                        public void run() {
-                            multiListener.onConsumeMultiFinished(purchases, results);
-                        }
-                    });
-                }
-            }
-        })).start();
-    }
-
-    void logDebug(String msg) {
-        if (mDebugLog) Log.d(mDebugTag, msg);
-    }
-
-    void logError(String msg) {
-        Log.e(mDebugTag, "In-app billing error: " + msg);
-    }
-
-    void logWarn(String msg) {
-        Log.w(mDebugTag, "In-app billing warning: " + msg);
-    }
-}

V2rayNG/app/src/main/java/com/v2ray/ang/util/IabResult.java

@@ -1,45 +0,0 @@
-/* Copyright (c) 2012 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.v2ray.ang.util;
-
-/**
- * Represents the result of an in-app billing operation.
- * A result is composed of a response code (an integer) and possibly a
- * message (String). You can get those by calling
- * {@link #getResponse} and {@link #getMessage()}, respectively. You
- * can also inquire whether a result is a success or a failure by
- * calling {@link #isSuccess()} and {@link #isFailure()}.
- */
-public class IabResult {
-    int mResponse;
-    String mMessage;
-
-    public IabResult(int response, String message) {
-        mResponse = response;
-        if (message == null || message.trim().length() == 0) {
-            mMessage = IabHelper.getResponseDesc(response);
-        }
-        else {
-            mMessage = message + " (response: " + IabHelper.getResponseDesc(response) + ")";
-        }
-    }
-    public int getResponse() { return mResponse; }
-    public String getMessage() { return mMessage; }
-    public boolean isSuccess() { return mResponse == IabHelper.BILLING_RESPONSE_RESULT_OK; }
-    public boolean isFailure() { return !isSuccess(); }
-    public String toString() { return "IabResult: " + getMessage(); }
-}
-

V2rayNG/app/src/main/java/com/v2ray/ang/util/Inventory.java

@@ -1,91 +0,0 @@
-/* Copyright (c) 2012 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.v2ray.ang.util;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-/**
- * Represents a block of information about in-app items.
- * An Inventory is returned by such methods as {@link IabHelper#queryInventory}.
- */
-public class Inventory {
-    Map<String,SkuDetails> mSkuMap = new HashMap<String,SkuDetails>();
-    Map<String,Purchase> mPurchaseMap = new HashMap<String,Purchase>();
-
-    Inventory() { }
-
-    /** Returns the listing details for an in-app product. */
-    public SkuDetails getSkuDetails(String sku) {
-        return mSkuMap.get(sku);
-    }
-
-    /** Returns purchase information for a given product, or null if there is no purchase. */
-    public Purchase getPurchase(String sku) {
-        return mPurchaseMap.get(sku);
-    }
-
-    /** Returns whether or not there exists a purchase of the given product. */
-    public boolean hasPurchase(String sku) {
-        return mPurchaseMap.containsKey(sku);
-    }
-
-    /** Return whether or not details about the given product are available. */
-    public boolean hasDetails(String sku) {
-        return mSkuMap.containsKey(sku);
-    }
-
-    /**
-     * Erase a purchase (locally) from the inventory, given its product ID. This just
-     * modifies the Inventory object locally and has no effect on the server! This is
-     * useful when you have an existing Inventory object which you know to be up to date,
-     * and you have just consumed an item successfully, which means that erasing its
-     * purchase data from the Inventory you already have is quicker than querying for
-     * a new Inventory.
-     */
-    public void erasePurchase(String sku) {
-        if (mPurchaseMap.containsKey(sku)) mPurchaseMap.remove(sku);
-    }
-
-    /** Returns a list of all owned product IDs. */
-    List<String> getAllOwnedSkus() {
-        return new ArrayList<String>(mPurchaseMap.keySet());
-    }
-
-    /** Returns a list of all owned product IDs of a given type */
-    List<String> getAllOwnedSkus(String itemType) {
-        List<String> result = new ArrayList<String>();
-        for (Purchase p : mPurchaseMap.values()) {
-            if (p.getItemType().equals(itemType)) result.add(p.getSku());
-        }
-        return result;
-    }
-
-    /** Returns a list of all purchases. */
-    List<Purchase> getAllPurchases() {
-        return new ArrayList<Purchase>(mPurchaseMap.values());
-    }
-
-    void addSkuDetails(SkuDetails d) {
-        mSkuMap.put(d.getSku(), d);
-    }
-
-    void addPurchase(Purchase p) {
-        mPurchaseMap.put(p.getSku(), p);
-    }
-}

V2rayNG/app/src/main/java/com/v2ray/ang/util/LogRecorder.java

@@ -1,540 +0,0 @@
-package com.v2ray.ang.util;
-
-import android.content.Context;
-import android.os.Environment;
-import android.os.Handler;
-import android.os.Message;
-import android.text.TextUtils;
-
-import java.io.BufferedReader;
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.InputStreamReader;
-import java.text.SimpleDateFormat;
-import java.util.ArrayList;
-import java.util.Date;
-import java.util.List;
-
-/**
- * Reference to http://blog.csdn.net/way_ping_li/article/details/8487866
- * and improved some features...
- */
-public class LogRecorder {
-
-    public static final int LOG_LEVEL_NO_SET = 0;
-
-    public static final int LOG_BUFFER_MAIN = 1;
-    public static final int LOG_BUFFER_SYSTEM = 1 << 1;
-    public static final int LOG_BUFFER_RADIO = 1 << 2;
-    public static final int LOG_BUFFER_EVENTS = 1 << 3;
-    public static final int LOG_BUFFER_KERNEL = 1 << 4; // not be supported by now
-
-    public static final int LOG_BUFFER_DEFAULT = LOG_BUFFER_MAIN | LOG_BUFFER_SYSTEM;
-
-    public static final int INVALID_PID = -1;
-
-    public String mFileSuffix;
-    public String mFolderPath;
-    public int mFileSizeLimitation;
-    public int mLevel;
-    public List<String> mFilterTags = new ArrayList<>();
-    public int mPID = INVALID_PID;
-
-    public boolean mUseLogcatFileOut = false;
-
-    private LogDumper mLogDumper = null;
-
-    public static final int EVENT_RESTART_LOG = 1001;
-
-    private RestartHandler mHandler;
-
-    private static class RestartHandler extends Handler {
-        final LogRecorder logRecorder;
-        public RestartHandler(LogRecorder logRecorder) {
-            this.logRecorder = logRecorder;
-        }
-
-        @Override
-        public void handleMessage(Message msg) {
-            if (msg.what == EVENT_RESTART_LOG) {
-                logRecorder.stop();
-                logRecorder.start();
-            }
-        }
-    }
-
-    public LogRecorder() {
-        mHandler = new RestartHandler(this);
-    }
-
-    public void start() {
-        // make sure the out folder exist
-        // TODO support multi-phase path
-        File file = new File(mFolderPath);
-        if (!file.exists()) {
-            file.mkdirs();
-        }
-
-        String cmdStr = collectLogcatCommand();
-
-        if (mLogDumper != null) {
-            mLogDumper.stopDumping();
-            mLogDumper = null;
-        }
-
-        mLogDumper = new LogDumper(mFolderPath, mFileSuffix, mFileSizeLimitation, cmdStr, mHandler);
-        mLogDumper.start();
-    }
-
-    public void stop() {
-        // TODO maybe should clean the log buffer first?
-        if (mLogDumper != null) {
-            mLogDumper.stopDumping();
-            mLogDumper = null;
-        }
-    }
-
-    private String collectLogcatCommand() {
-        StringBuilder stringBuilder = new StringBuilder();
-        final String SPACE = " ";
-        stringBuilder.append("logcat");
-
-        // TODO select ring buffer, -b
-
-        // TODO set out format
-        stringBuilder.append(SPACE);
-        stringBuilder.append("-v time");
-
-        // append tag filters
-        String levelStr = getLevelStr();
-
-        if (!mFilterTags.isEmpty()) {
-            stringBuilder.append(SPACE);
-            stringBuilder.append("-s");
-            for (int i = 0; i < mFilterTags.size(); i++) {
-                String tag = mFilterTags.get(i) + ":" + levelStr;
-                stringBuilder.append(SPACE);
-                stringBuilder.append(tag);
-            }
-        } else {
-            if (!TextUtils.isEmpty(levelStr)) {
-                stringBuilder.append(SPACE);
-                stringBuilder.append("*:" + levelStr);
-            }
-        }
-
-        // logcat -f , but the rotated count default is 4?
-        // can`t be sure to use that feature
-        if (mPID != INVALID_PID) {
-            mUseLogcatFileOut = false;
-            String pidStr = adjustPIDStr();
-            if (!TextUtils.isEmpty(pidStr)) {
-                stringBuilder.append(SPACE);
-                stringBuilder.append("|");
-                stringBuilder.append(SPACE);
-                stringBuilder.append("grep (" + pidStr + ")");
-            }
-        }
-
-        return stringBuilder.toString();
-    }
-
-    private String getLevelStr() {
-        switch (mLevel) {
-            case 2:
-                return "V";
-            case 3:
-                return "D";
-            case 4:
-                return "I";
-            case 5:
-                return "W";
-            case 6:
-                return "E";
-            case 7:
-                return "F";
-        }
-
-        return "V";
-    }
-
-    /**
-     * Android`s user app pid is bigger than 1000.
-     *
-     * @return
-     */
-    private String adjustPIDStr() {
-        if (mPID == INVALID_PID) {
-            return null;
-        }
-
-        String pidStr = String.valueOf(mPID);
-        int length = pidStr.length();
-        if (length < 4) {
-            pidStr = " 0" + pidStr;
-        }
-
-        if (length == 4) {
-            pidStr = " " + pidStr;
-        }
-
-        return pidStr;
-    }
-
-
-    private class LogDumper extends Thread {
-        final String logPath;
-        final String logFileSuffix;
-        final int logFileLimitation;
-        final String logCmd;
-
-        final RestartHandler restartHandler;
-
-        private Process logcatProc;
-        private BufferedReader mReader = null;
-        private FileOutputStream out = null;
-
-        private boolean mRunning = true;
-        final private Object mRunningLock = new Object();
-
-        private long currentFileSize;
-
-        public LogDumper(String folderPath, String suffix,
-                         int fileSizeLimitation, String command,
-                         RestartHandler handler) {
-            logPath = folderPath;
-            logFileSuffix = suffix;
-            logFileLimitation = fileSizeLimitation;
-            logCmd = command;
-            restartHandler = handler;
-
-            String date = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss")
-                    .format(new Date(System.currentTimeMillis()));
-            String fileName = (TextUtils.isEmpty(logFileSuffix)) ? date : (logFileSuffix + "-"+ date);
-            try {
-                out = new FileOutputStream(new File(logPath, fileName + ".log"));
-            } catch (FileNotFoundException e) {
-                e.printStackTrace();
-            }
-        }
-
-        public void stopDumping() {
-            synchronized (mRunningLock) {
-                mRunning = false;
-            }
-        }
-
-        @Override
-        public void run() {
-            try {
-                logcatProc = Runtime.getRuntime().exec(logCmd);
-                mReader = new BufferedReader(new InputStreamReader(
-                        logcatProc.getInputStream()), 1024);
-                String line = null;
-                while (mRunning && (line = mReader.readLine()) != null) {
-                    if (!mRunning) {
-                        break;
-                    }
-                    if (line.length() == 0) {
-                        continue;
-                    }
-                    if (out != null && !line.isEmpty()) {
-                        byte[] data = (line + "\n").getBytes();
-                        out.write(data);
-                        if (logFileLimitation != 0) {
-	                        currentFileSize += data.length;
-	                        if (currentFileSize > logFileLimitation*1024) {
-	                            restartHandler.sendEmptyMessage(EVENT_RESTART_LOG);
-	                            break;
-	                        }
-                        }
-                    }
-                }
-
-            } catch (IOException e) {
-                e.printStackTrace();
-            } finally {
-                if (logcatProc != null) {
-                    logcatProc.destroy();
-                    logcatProc = null;
-                }
-                if (mReader != null) {
-                    try {
-                        mReader.close();
-                        mReader = null;
-                    } catch (IOException e) {
-                        e.printStackTrace();
-                    }
-                }
-                if (out != null) {
-                    try {
-                        out.close();
-                    } catch (IOException e) {
-                        e.printStackTrace();
-                    }
-                    out = null;
-                }
-            }
-        }
-    }
-
-    public static class Builder {
-
-        /**
-         * context object
-         */
-        private Context mContext;
-
-        /**
-         * the folder name that we save log files to,
-         * just folder name, not the whole path,
-         * if set this, will save log files to /sdcard/$mLogFolderName folder,
-         * use /sdcard/$ApplicationName as default.
-         */
-        private String mLogFolderName;
-
-        /**
-         * the whole folder path that we save log files to,
-         * this setting`s priority is bigger than folder name.
-         */
-        private String mLogFolderPath;
-
-        /**
-         * the log file suffix,
-         * if this is sot, it will be appended to log file name automatically
-         */
-        private String mLogFileNameSuffix = "";
-
-        /**
-         * single log file size limitation,
-         * in k-bytes, ex. set to 16, is 16KB limitation.
-         */
-        private int mLogFileSizeLimitation = 0;
-
-        /**
-         * log level, see android.util.Log, 2 - 7,
-         * if not be set, will use verbose as default
-         */
-        private int mLogLevel = LogRecorder.LOG_LEVEL_NO_SET;
-
-        /**
-         * can set several filter tags
-         * logcat -s ActivityManager:V SystemUI:V
-         */
-        private List<String> mLogFilterTags = new ArrayList<>();
-
-        /**
-         * filter through pid, by setting this with your APP PID,
-         * the log recorder will just record the APP`s own log,
-         * use one call: android.os.Process.myPid().
-         */
-        private int mPID = LogRecorder.INVALID_PID;
-
-        /**
-         * which log buffer to catch...
-         * <p/>
-         * Request alternate ring buffer, 'main', 'system', 'radio'
-         * or 'events'. Multiple -b parameters are allowed and the
-         * results are interleaved.
-         * <p/>
-         * The default is -b main -b system.
-         */
-        private int mLogBuffersSelected = LogRecorder.LOG_BUFFER_DEFAULT;
-
-        /**
-         * log output format, don`t support config yet, use $time format as default.
-         * <p/>
-         * Log messages contain a number of metadata fields, in addition to the tag and priority.
-         * You can modify the output format for messages so that they display a specific metadata
-         * field. To do so, you use the -v option and specify one of the supported output formats
-         * listed below.
-         * <p/>
-         * brief      — Display priority/tag and PID of the process issuing the message.
-         * process    — Display PID only.
-         * tag        — Display the priority/tag only.
-         * thread     - Display the priority, tag, and the PID(process ID) and TID(thread ID)
-         * of the thread issuing the message.
-         * raw        — Display the raw log message, with no other metadata fields.
-         * time       — Display the date, invocation time, priority/tag, and PID of
-         * the process issuing the message.
-         * threadtime — Display the date, invocation time, priority, tag, and the PID(process ID)
-         * and TID(thread ID) of the thread issuing the message.
-         * long       — Display all metadata fields and separate messages with blank lines.
-         */
-        private int mLogOutFormat;
-
-        /**
-         * set log out folder name
-         *
-         * @param logFolderName folder name
-         * @return The same Builder.
-         */
-        public Builder setLogFolderName(String logFolderName) {
-            this.mLogFolderName = logFolderName;
-            return this;
-        }
-
-        /**
-         * set log out folder path
-         *
-         * @param logFolderPath out folder absolute path
-         * @return the same Builder
-         */
-        public Builder setLogFolderPath(String logFolderPath) {
-            this.mLogFolderPath = logFolderPath;
-            return this;
-        }
-
-        /**
-         * set log file name suffix
-         *
-         * @param logFileNameSuffix auto appened suffix
-         * @return the same Builder
-         */
-        public Builder setLogFileNameSuffix(String logFileNameSuffix) {
-            this.mLogFileNameSuffix = logFileNameSuffix;
-            return this;
-        }
-
-        /**
-         * set the file size limitation
-         *
-         * @param fileSizeLimitation file size limitation in KB
-         * @return the same Builder
-         */
-        public Builder setLogFileSizeLimitation(int fileSizeLimitation) {
-            this.mLogFileSizeLimitation = fileSizeLimitation;
-            return this;
-        }
-
-        /**
-         * set the log level
-         *
-         * @param logLevel log level, 2-7
-         * @return the same Builder
-         */
-        public Builder setLogLevel(int logLevel) {
-            this.mLogLevel = logLevel;
-            return this;
-        }
-
-        /**
-         * add log filterspec tag name, can add multiple ones,
-         * they use the same log level set by setLogLevel()
-         *
-         * @param tag tag name
-         * @return the same Builder
-         */
-        public Builder addLogFilterTag(String tag) {
-            mLogFilterTags.add(tag);
-            return this;
-        }
-
-        /**
-         * which process`s log
-         *
-         * @param mPID process id
-         * @return the same Builder
-         */
-        public Builder setPID(int mPID) {
-            this.mPID = mPID;
-            return this;
-        }
-
-        /**
-         * -b radio, -b main, -b system, -b events
-         * -b main -b system as default
-         *
-         * @param logBuffersSelected one of
-         *                           LOG_BUFFER_MAIN = 1 << 0;
-         *                           LOG_BUFFER_SYSTEM = 1 << 1;
-         *                           LOG_BUFFER_RADIO = 1 << 2;
-         *                           LOG_BUFFER_EVENTS = 1 << 3;
-         *                           LOG_BUFFER_KERNEL = 1 << 4;
-         * @return the same Builder
-         */
-        public Builder setLogBufferSelected(int logBuffersSelected) {
-            this.mLogBuffersSelected = logBuffersSelected;
-            return this;
-        }
-
-        /**
-         * sets log out format, -v parameter
-         *
-         * @param logOutFormat out format, like -v time
-         * @return the same Builder
-         */
-        public Builder setLogOutFormat(int logOutFormat) {
-            this.mLogOutFormat = mLogOutFormat;
-            return this;
-        }
-
-        public Builder(Context context) {
-            mContext = context;
-        }
-
-        /**
-         * call this only if mLogFolderName and mLogFolderPath not
-         * be set both.
-         *
-         * @return
-         */
-        private void applyAppNameAsOutfolderName() {
-            try {
-                String appName = mContext.getPackageName();
-                String versionName = mContext.getPackageManager().getPackageInfo(
-                        appName, 0).versionName;
-                int versionCode = mContext.getPackageManager()
-                        .getPackageInfo(appName, 0).versionCode;
-                mLogFolderName = appName + "-" + versionName + "-" + versionCode;
-                mLogFolderPath = applyOutfolderPath();
-            } catch (Exception e) {
-            }
-        }
-
-        private String applyOutfolderPath() {
-            String outPath = "";
-            if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
-                outPath = Environment.getExternalStorageDirectory()
-                        .getAbsolutePath() + File.separator + mLogFolderName;
-            }
-
-            return outPath;
-        }
-
-        /**
-         * Combine all of the options that have been set and return
-         * a new {@link LogRecorder} object.
-         */
-        public LogRecorder build() {
-            LogRecorder logRecorder = new LogRecorder();
-
-            // no folder name & folder path be set
-            if (TextUtils.isEmpty(mLogFolderName)
-                    && TextUtils.isEmpty(mLogFolderPath)) {
-                applyAppNameAsOutfolderName();
-            }
-
-            // make sure out path be set
-            if (TextUtils.isEmpty(mLogFolderPath)) {
-                mLogFolderPath = applyOutfolderPath();
-            }
-
-            logRecorder.mFolderPath = mLogFolderPath;
-            logRecorder.mFileSuffix = mLogFileNameSuffix;
-            logRecorder.mFileSizeLimitation = mLogFileSizeLimitation;
-            logRecorder.mLevel = mLogLevel;
-            if (!mLogFilterTags.isEmpty()) {
-                for (int i = 0; i < mLogFilterTags.size(); i++) {
-                    logRecorder.mFilterTags.add(mLogFilterTags.get(i));
-                }
-            }
-            logRecorder.mPID = mPID;
-
-            return logRecorder;
-        }
-    }
-
-}

V2rayNG/app/src/main/java/com/v2ray/ang/util/Purchase.java

@@ -1,63 +0,0 @@
-/* Copyright (c) 2012 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.v2ray.ang.util;
-
-import org.json.JSONException;
-import org.json.JSONObject;
-
-/**
- * Represents an in-app billing purchase.
- */
-public class Purchase {
-    String mItemType;  // ITEM_TYPE_INAPP or ITEM_TYPE_SUBS
-    String mOrderId;
-    String mPackageName;
-    String mSku;
-    long mPurchaseTime;
-    int mPurchaseState;
-    String mDeveloperPayload;
-    String mToken;
-    String mOriginalJson;
-    String mSignature;
-
-    public Purchase(String itemType, String jsonPurchaseInfo, String signature) throws JSONException {
-        mItemType = itemType;
-        mOriginalJson = jsonPurchaseInfo;
-        JSONObject o = new JSONObject(mOriginalJson);
-        mOrderId = o.optString("orderId");
-        mPackageName = o.optString("packageName");
-        mSku = o.optString("productId");
-        mPurchaseTime = o.optLong("purchaseTime");
-        mPurchaseState = o.optInt("purchaseState");
-        mDeveloperPayload = o.optString("developerPayload");
-        mToken = o.optString("token", o.optString("purchaseToken"));
-        mSignature = signature;
-    }
-
-    public String getItemType() { return mItemType; }
-    public String getOrderId() { return mOrderId; }
-    public String getPackageName() { return mPackageName; }
-    public String getSku() { return mSku; }
-    public long getPurchaseTime() { return mPurchaseTime; }
-    public int getPurchaseState() { return mPurchaseState; }
-    public String getDeveloperPayload() { return mDeveloperPayload; }
-    public String getToken() { return mToken; }
-    public String getOriginalJson() { return mOriginalJson; }
-    public String getSignature() { return mSignature; }
-
-    @Override
-    public String toString() { return "PurchaseInfo(type:" + mItemType + "):" + mOriginalJson; }
-}

V2rayNG/app/src/main/java/com/v2ray/ang/util/QRCodeDecoder.java

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

V2rayNG/app/src/main/java/com/v2ray/ang/util/Security.java

@@ -1,119 +0,0 @@
-/* Copyright (c) 2012 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.v2ray.ang.util;
-
-import android.text.TextUtils;
-import android.util.Log;
-
-import java.security.InvalidKeyException;
-import java.security.KeyFactory;
-import java.security.NoSuchAlgorithmException;
-import java.security.PublicKey;
-import java.security.Signature;
-import java.security.SignatureException;
-import java.security.spec.InvalidKeySpecException;
-import java.security.spec.X509EncodedKeySpec;
-
-/**
- * Security-related methods. For a secure implementation, all of this code
- * should be implemented on a server that communicates with the
- * application on the device. For the sake of simplicity and clarity of this
- * example, this code is included here and is executed on the device. If you
- * must verify the purchases on the phone, you should obfuscate this code to
- * make it harder for an attacker to replace the code with stubs that treat all
- * purchases as verified.
- */
-public class Security {
-    private static final String TAG = "IABUtil/Security";
-
-    private static final String KEY_FACTORY_ALGORITHM = "RSA";
-    private static final String SIGNATURE_ALGORITHM = "SHA1withRSA";
-
-    /**
-     * Verifies that the data was signed with the given signature, and returns
-     * the verified purchase. The data is in JSON format and signed
-     * with a private key. The data also contains the {@link PurchaseState}
-     * and product ID of the purchase.
-     * @param base64PublicKey the base64-encoded public key to use for verifying.
-     * @param signedData the signed JSON string (signed, not encrypted)
-     * @param signature the signature for the data, signed with the private key
-     */
-    public static boolean verifyPurchase(String base64PublicKey, String signedData, String signature) {
-        if (TextUtils.isEmpty(signedData) || TextUtils.isEmpty(base64PublicKey) ||
-                TextUtils.isEmpty(signature)) {
-            Log.e(TAG, "Purchase verification failed: missing data.");
-            return false;
-        }
-
-        PublicKey key = Security.generatePublicKey(base64PublicKey);
-        return Security.verify(key, signedData, signature);
-    }
-
-    /**
-     * Generates a PublicKey instance from a string containing the
-     * Base64-encoded public key.
-     *
-     * @param encodedPublicKey Base64-encoded public key
-     * @throws IllegalArgumentException if encodedPublicKey is invalid
-     */
-    public static PublicKey generatePublicKey(String encodedPublicKey) {
-        try {
-            byte[] decodedKey = Base64.decode(encodedPublicKey);
-            KeyFactory keyFactory = KeyFactory.getInstance(KEY_FACTORY_ALGORITHM);
-            return keyFactory.generatePublic(new X509EncodedKeySpec(decodedKey));
-        } catch (NoSuchAlgorithmException e) {
-            throw new RuntimeException(e);
-        } catch (InvalidKeySpecException e) {
-            Log.e(TAG, "Invalid key specification.");
-            throw new IllegalArgumentException(e);
-        } catch (Base64DecoderException e) {
-            Log.e(TAG, "Base64 decoding failed.");
-            throw new IllegalArgumentException(e);
-        }
-    }
-
-    /**
-     * Verifies that the signature from the server matches the computed
-     * signature on the data.  Returns true if the data is correctly signed.
-     *
-     * @param publicKey public key associated with the developer account
-     * @param signedData signed data from server
-     * @param signature server signature
-     * @return true if the data and signature match
-     */
-    public static boolean verify(PublicKey publicKey, String signedData, String signature) {
-        Signature sig;
-        try {
-            sig = Signature.getInstance(SIGNATURE_ALGORITHM);
-            sig.initVerify(publicKey);
-            sig.update(signedData.getBytes());
-            if (!sig.verify(Base64.decode(signature))) {
-                Log.e(TAG, "Signature verification failed.");
-                return false;
-            }
-            return true;
-        } catch (NoSuchAlgorithmException e) {
-            Log.e(TAG, "NoSuchAlgorithmException.");
-        } catch (InvalidKeyException e) {
-            Log.e(TAG, "Invalid key specification.");
-        } catch (SignatureException e) {
-            Log.e(TAG, "Signature exception.");
-        } catch (Base64DecoderException e) {
-            Log.e(TAG, "Base64 decoding failed.");
-        }
-        return false;
-    }
-}

V2rayNG/app/src/main/java/com/v2ray/ang/util/SkuDetails.java

@@ -1,58 +0,0 @@
-/* Copyright (c) 2012 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.v2ray.ang.util;
-
-import org.json.JSONException;
-import org.json.JSONObject;
-
-/**
- * Represents an in-app product's listing details.
- */
-public class SkuDetails {
-    String mItemType;
-    String mSku;
-    String mType;
-    String mPrice;
-    String mTitle;
-    String mDescription;
-    String mJson;
-
-    public SkuDetails(String jsonSkuDetails) throws JSONException {
-        this(IabHelper.ITEM_TYPE_INAPP, jsonSkuDetails);
-    }
-
-    public SkuDetails(String itemType, String jsonSkuDetails) throws JSONException {
-        mItemType = itemType;
-        mJson = jsonSkuDetails;
-        JSONObject o = new JSONObject(mJson);
-        mSku = o.optString("productId");
-        mType = o.optString("type");
-        mPrice = o.optString("price");
-        mTitle = o.optString("title");
-        mDescription = o.optString("description");
-    }
-
-    public String getSku() { return mSku; }
-    public String getType() { return mType; }
-    public String getPrice() { return mPrice; }
-    public String getTitle() { return mTitle; }
-    public String getDescription() { return mDescription; }
-
-    @Override
-    public String toString() {
-        return "SkuDetails:" + mJson;
-    }
-}

V2rayNG/app/src/main/kotlin/com/v2ray/ang/AngApplication.kt

@@ -1,31 +1,42 @@
 package com.v2ray.ang
 
-import android.app.Application
-//import com.squareup.leakcanary.LeakCanary
-import com.v2ray.ang.util.AngConfigManager
-import me.dozen.dpreference.DPreference
-import org.jetbrains.anko.defaultSharedPreferences
+import android.content.Context
+import androidx.multidex.MultiDexApplication
+import androidx.preference.PreferenceManager
+import androidx.work.Configuration
+import com.tencent.mmkv.MMKV
 
-class AngApplication : Application() {
+class AngApplication : MultiDexApplication(), Configuration.Provider {
     companion object {
         const val PREF_LAST_VERSION = "pref_last_version"
+        lateinit var application: AngApplication
+    }
+
+    override fun attachBaseContext(base: Context?) {
+        super.attachBaseContext(base)
+        application = this
     }
 
     var firstRun = false
         private set
 
-    val defaultDPreference by lazy { DPreference(this, packageName + "_preferences") }
-
     override fun onCreate() {
         super.onCreate()
 
 //        LeakCanary.install(this)
 
+        val defaultSharedPreferences = PreferenceManager.getDefaultSharedPreferences(this)
         firstRun = defaultSharedPreferences.getInt(PREF_LAST_VERSION, 0) != BuildConfig.VERSION_CODE
         if (firstRun)
             defaultSharedPreferences.edit().putInt(PREF_LAST_VERSION, BuildConfig.VERSION_CODE).apply()
 
         //Logger.init().logLevel(if (BuildConfig.DEBUG) LogLevel.FULL else LogLevel.NONE)
-        AngConfigManager.inject(this)
+        MMKV.initialize(this)
+    }
+
+    override fun getWorkManagerConfiguration(): Configuration {
+        return Configuration.Builder()
+            .setDefaultProcessName("${BuildConfig.APPLICATION_ID}:bg")
+            .build()
     }
 }

V2rayNG/app/src/main/kotlin/com/v2ray/ang/AppConfig.kt

@@ -5,16 +5,54 @@ package com.v2ray.ang
  * App Config Const
  */
 object AppConfig {
-    const val ANG_PACKAGE = "com.v2ray.ang"
+    const val ANG_PACKAGE = BuildConfig.APPLICATION_ID
+    const val DIR_ASSETS = "assets"
+
+    // legacy
     const val ANG_CONFIG = "ang_config"
-    const val PREF_CURR_CONFIG = "pref_v2ray_config"
-    const val PREF_CURR_CONFIG_GUID = "pref_v2ray_config_guid"
-    const val PREF_CURR_CONFIG_NAME = "pref_v2ray_config_name"
-    const val PREF_CURR_CONFIG_DOMAIN = "pref_v2ray_config_domain"
     const val PREF_INAPP_BUY_IS_PREMIUM = "pref_inapp_buy_is_premium"
-    const val VMESS_PROTOCOL: String = "vmess://"
-    const val SS_PROTOCOL: String = "ss://"
-    const val SOCKS_PROTOCOL: String = "socks://"
+    const val PREF_ROUTING_CUSTOM = "pref_routing_custom"
+
+    // Preferences mapped to MMKV
+    const val PREF_MODE = "pref_mode"
+    const val PREF_SPEED_ENABLED = "pref_speed_enabled"
+    const val PREF_SNIFFING_ENABLED = "pref_sniffing_enabled"
+    const val PREF_PROXY_SHARING = "pref_proxy_sharing_enabled"
+    const val PREF_LOCAL_DNS_ENABLED = "pref_local_dns_enabled"
+    const val PREF_FAKE_DNS_ENABLED = "pref_fake_dns_enabled"
+    const val PREF_VPN_DNS = "pref_vpn_dns"
+    const val PREF_REMOTE_DNS = "pref_remote_dns"
+    const val PREF_DOMESTIC_DNS = "pref_domestic_dns"
+    const val PREF_LOCAL_DNS_PORT = "pref_local_dns_port"
+    const val PREF_ALLOW_INSECURE = "pref_allow_insecure"
+    const val PREF_SOCKS_PORT = "pref_socks_port"
+    const val PREF_HTTP_PORT = "pref_http_port"
+    const val PREF_LOGLEVEL = "pref_core_loglevel"
+    const val PREF_LANGUAGE = "pref_language"
+    const val PREF_PREFER_IPV6 = "pref_prefer_ipv6"
+    const val PREF_ROUTING_DOMAIN_STRATEGY = "pref_routing_domain_strategy"
+    const val PREF_ROUTING_MODE = "pref_routing_mode"
+    const val PREF_V2RAY_ROUTING_AGENT = "pref_v2ray_routing_agent"
+    const val PREF_V2RAY_ROUTING_DIRECT = "pref_v2ray_routing_direct"
+    const val PREF_V2RAY_ROUTING_BLOCKED = "pref_v2ray_routing_blocked"
+    const val PREF_PER_APP_PROXY = "pref_per_app_proxy"
+    const val PREF_PER_APP_PROXY_SET = "pref_per_app_proxy_set"
+    const val PREF_BYPASS_APPS = "pref_bypass_apps"
+    const val PREF_CONFIRM_REMOVE = "pref_confirm_remove"
+    const val PREF_START_SCAN_IMMEDIATE = "pref_start_scan_immediate"
+    const val PREF_MUX_ENABLED = "pref_mux_enabled"
+    const val PREF_MUX_CONCURRENCY = "pref_mux_concurency"
+    const val PREF_MUX_XUDP_CONCURRENCY = "pref_mux_xudp_concurency"
+    const val PREF_MUX_XUDP_QUIC = "pref_mux_xudp_quic"
+    const val PREF_FRAGMENT_ENABLED = "pref_fragment_enabled"
+    const val PREF_FRAGMENT_PACKETS = "pref_fragment_packets"
+    const val PREF_FRAGMENT_LENGTH = "pref_fragment_length"
+    const val PREF_FRAGMENT_INTERVAL = "pref_fragment_interval"
+
+    const val PROTOCOL_HTTP: String = "http://"
+    const val PROTOCOL_HTTPS: String = "https://"
+    const val PROTOCOL_FREEDOM: String = "freedom"
+
     const val BROADCAST_ACTION_SERVICE = "com.v2ray.ang.action.service"
     const val BROADCAST_ACTION_ACTIVITY = "com.v2ray.ang.action.activity"
     const val BROADCAST_ACTION_WIDGET_CLICK = "com.v2ray.ang.action.widget.click"
@@ -25,21 +63,31 @@ object AppConfig {
     const val TASKER_EXTRA_BUNDLE_GUID = "tasker_extra_bundle_guid"
     const val TASKER_DEFAULT_GUID = "Default"
 
-    const val PREF_V2RAY_ROUTING_AGENT = "pref_v2ray_routing_agent"
-    const val PREF_V2RAY_ROUTING_DIRECT = "pref_v2ray_routing_direct"
-    const val PREF_V2RAY_ROUTING_BLOCKED = "pref_v2ray_routing_blocked"
     const val TAG_AGENT = "proxy"
     const val TAG_DIRECT = "direct"
     const val TAG_BLOCKED = "block"
+    const val TAG_FRAGMENT = "fragment"
 
-    const val androidpackagenamelistUrl = "https://raw.githubusercontent.com/2dust/androidpackagenamelist/master/proxy.txt"
-    const val v2rayCustomRoutingListUrl = "https://raw.githubusercontent.com/2dust/v2rayCustomRoutingList/master/"
+    const val androidpackagenamelistUrl =
+        "https://raw.githubusercontent.com/2dust/androidpackagenamelist/master/proxy.txt"
+    const val v2rayCustomRoutingListUrl =
+        "https://raw.githubusercontent.com/2dust/v2rayCustomRoutingList/master/"
     const val v2rayNGIssues = "https://github.com/2dust/v2rayNG/issues"
-    const val promotionUrl = "https://1.2345345.xyz/ads.html"
+    const val v2rayNGWikiMode = "https://github.com/2dust/v2rayNG/wiki/Mode"
+    const val v2rayNGPrivacyPolicy = "https://raw.githubusercontent.com/2dust/v2rayNG/master/CR.md"
+    const val promotionUrl = "aHR0cHM6Ly85LjIzNDQ1Ni54eXovYWJjLmh0bWw="
+    const val geoUrl = "https://github.com/Loyalsoldier/v2ray-rules-dat/releases/latest/download/"
 
     const val DNS_AGENT = "1.1.1.1"
     const val DNS_DIRECT = "223.5.5.5"
 
+    const val PORT_LOCAL_DNS = "10853"
+    const val PORT_SOCKS = "10808"
+    const val PORT_HTTP = "10809"
+    const val WIREGUARD_LOCAL_ADDRESS_V4 = "172.16.0.2/32"
+    const val WIREGUARD_LOCAL_ADDRESS_V6 = "2606:4700:110:8f81:d551:a0:532e:a2b3/128"
+    const val WIREGUARD_LOCAL_MTU = "1420"
+
     const val MSG_REGISTER_CLIENT = 1
     const val MSG_STATE_RUNNING = 11
     const val MSG_STATE_NOT_RUNNING = 12
@@ -50,12 +98,18 @@ object AppConfig {
     const val MSG_STATE_STOP = 4
     const val MSG_STATE_STOP_SUCCESS = 41
     const val MSG_STATE_RESTART = 5
+    const val MSG_MEASURE_DELAY = 6
+    const val MSG_MEASURE_DELAY_SUCCESS = 61
+    const val MSG_MEASURE_CONFIG = 7
+    const val MSG_MEASURE_CONFIG_SUCCESS = 71
+    const val MSG_MEASURE_CONFIG_CANCEL = 72
 
-    object EConfigType {
-        val Vmess = 1
-        val Custom = 2
-        val Shadowsocks = 3
-        val Socks = 4
-    }
+    // subscription settings
+    const val SUBSCRIPTION_AUTO_UPDATE = "pref_auto_update_subscription"
+    const val SUBSCRIPTION_AUTO_UPDATE_INTERVAL = "pref_auto_update_interval"
+    const val SUBSCRIPTION_DEFAULT_UPDATE_INTERVAL = "1440" // 24 hours
+    const val SUBSCRIPTION_UPDATE_TASK_NAME = "subscription_updater"
 
-}
+    const val CACHE_SUBSCRIPTION_ID = "cache_subscription_id"
+    const val CACHE_KEYWORD_FILTER = "cache_keyword_filter"
+}

V2rayNG/app/src/main/kotlin/com/v2ray/ang/dto/AngConfig.kt

@@ -17,12 +17,16 @@ data class AngConfig(
                          var requestHost: String = "",
                          var path: String = "",
                          var streamSecurity: String = "",
+                         var allowInsecure: String = "",
                          var configType: Int = 1,
                          var configVersion: Int = 1,
                          var testResult: String = "",
-                         var subid: String = "")
+                         var subid: String = "",
+                         var flow: String = "",
+                         var sni: String = "")
 
     data class SubItemBean(var id: String = "",
                            var remarks: String = "",
-                           var url: String = "")
+                           var url: String = "",
+                           var enabled: Boolean = true)
 }

V2rayNG/app/src/main/kotlin/com/v2ray/ang/dto/AssetUrlItem.kt

@@ -0,0 +1,8 @@
+package com.v2ray.ang.dto
+
+data class AssetUrlItem(
+    var remarks: String = "",
+    var url: String = "",
+    val addedTime: Long = System.currentTimeMillis(),
+    var lastUpdated: Long = -1
+)

V2rayNG/app/src/main/kotlin/com/v2ray/ang/dto/EConfigType.kt

@@ -0,0 +1,15 @@
+package com.v2ray.ang.dto
+
+enum class EConfigType(val value: Int, val protocolScheme: String) {
+    VMESS(1, "vmess://"),
+    CUSTOM(2, ""),
+    SHADOWSOCKS(3, "ss://"),
+    SOCKS(4, "socks://"),
+    VLESS(5, "vless://"),
+    TROJAN(6, "trojan://"),
+    WIREGUARD(7, "wireguard://");
+
+    companion object {
+        fun fromInt(value: Int) = values().firstOrNull { it.value == value }
+    }
+}

V2rayNG/app/src/main/kotlin/com/v2ray/ang/dto/ERoutingMode.kt

@@ -0,0 +1,9 @@
+package com.v2ray.ang.dto
+
+enum class ERoutingMode(val value: String  ) {
+    GLOBAL_PROXY("0"),
+    BYPASS_LAN("1"),
+    BYPASS_MAINLAND("2"),
+    BYPASS_LAN_MAINLAND("3"),
+    GLOBAL_DIRECT("4");
+}

V2rayNG/app/src/main/kotlin/com/v2ray/ang/dto/ServerAffiliationInfo.kt

@@ -0,0 +1,10 @@
+package com.v2ray.ang.dto
+
+data class ServerAffiliationInfo(var testDelayMillis: Long = 0L) {
+    fun getTestDelayString(): String {
+        if (testDelayMillis == 0L) {
+            return ""
+        }
+        return testDelayMillis.toString() + "ms"
+    }
+}

V2rayNG/app/src/main/kotlin/com/v2ray/ang/dto/ServerConfig.kt

@@ -0,0 +1,74 @@
+package com.v2ray.ang.dto
+
+import com.v2ray.ang.AppConfig.TAG_AGENT
+import com.v2ray.ang.AppConfig.TAG_BLOCKED
+import com.v2ray.ang.AppConfig.TAG_DIRECT
+import com.v2ray.ang.util.Utils
+
+data class ServerConfig(
+        val configVersion: Int = 3,
+        val configType: EConfigType,
+        var subscriptionId: String = "",
+        val addedTime: Long = System.currentTimeMillis(),
+        var remarks: String = "",
+        val outboundBean: V2rayConfig.OutboundBean? = null,
+        var fullConfig: V2rayConfig? = null
+) {
+    companion object {
+        fun create(configType: EConfigType): ServerConfig {
+            when(configType) {
+                EConfigType.VMESS, EConfigType.VLESS ->
+                    return ServerConfig(
+                        configType = configType,
+                        outboundBean = V2rayConfig.OutboundBean(
+                            protocol = configType.name.lowercase(),
+                            settings = V2rayConfig.OutboundBean.OutSettingsBean(
+                                vnext = listOf(V2rayConfig.OutboundBean.OutSettingsBean.VnextBean(
+                                    users = listOf(V2rayConfig.OutboundBean.OutSettingsBean.VnextBean.UsersBean())))),
+                            streamSettings = V2rayConfig.OutboundBean.StreamSettingsBean()))
+                EConfigType.CUSTOM ->
+                    return ServerConfig(configType = configType)
+                EConfigType.SHADOWSOCKS, EConfigType.SOCKS, EConfigType.TROJAN ->
+                    return ServerConfig(
+                        configType = configType,
+                        outboundBean = V2rayConfig.OutboundBean(
+                            protocol = configType.name.lowercase(),
+                            settings = V2rayConfig.OutboundBean.OutSettingsBean(
+                                servers = listOf(V2rayConfig.OutboundBean.OutSettingsBean.ServersBean())),
+                            streamSettings = V2rayConfig.OutboundBean.StreamSettingsBean()))
+                EConfigType.WIREGUARD ->
+                    return ServerConfig(
+                        configType = configType,
+                        outboundBean =  V2rayConfig.OutboundBean(
+                            protocol = configType.name.lowercase(),
+                            settings = V2rayConfig.OutboundBean.OutSettingsBean(
+                                secretKey = "",
+                                peers = listOf(V2rayConfig.OutboundBean.OutSettingsBean.WireGuardBean())
+                            )))
+            }
+        }
+    }
+
+    fun getProxyOutbound(): V2rayConfig.OutboundBean? {
+        if (configType != EConfigType.CUSTOM) {
+            return outboundBean
+        }
+        return fullConfig?.getProxyOutbound()
+    }
+
+    fun getAllOutboundTags(): MutableList<String> {
+        if (configType != EConfigType.CUSTOM) {
+            return mutableListOf(TAG_AGENT, TAG_DIRECT, TAG_BLOCKED)
+        }
+        fullConfig?.let { config ->
+            return config.outbounds.map { it.tag }.toMutableList()
+        }
+        return mutableListOf()
+    }
+
+    fun getV2rayPointDomainAndPort(): String {
+        val address = getProxyOutbound()?.getServerAddress().orEmpty()
+        val port = getProxyOutbound()?.getServerPort()
+        return Utils.getIpv6Address(address) + ":" + port
+    }
+}

V2rayNG/app/src/main/kotlin/com/v2ray/ang/dto/ServersCache.kt

@@ -0,0 +1,4 @@
+package com.v2ray.ang.dto
+
+data class ServersCache(val guid: String,
+                        val config: ServerConfig)

V2rayNG/app/src/main/kotlin/com/v2ray/ang/dto/SubscriptionItem.kt

@@ -0,0 +1,12 @@
+package com.v2ray.ang.dto
+
+data class SubscriptionItem(
+    var remarks: String = "",
+    var url: String = "",
+    var enabled: Boolean = true,
+    val addedTime: Long = System.currentTimeMillis(),
+    var lastUpdated: Long = -1,
+    var autoUpdate: Boolean = false,
+    val updateInterval: Int? = null,
+)
+

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

@@ -1,142 +1,507 @@
 package com.v2ray.ang.dto
 
+import android.text.TextUtils
+import com.google.gson.GsonBuilder
+import com.google.gson.JsonPrimitive
+import com.google.gson.JsonSerializationContext
+import com.google.gson.JsonSerializer
+import com.google.gson.annotations.SerializedName
+import com.google.gson.reflect.TypeToken
+import java.lang.reflect.Type
+
 data class V2rayConfig(
-        val stats: Any?=null,
+        var remarks: String? = null,
+        var stats: Any? = null,
         val log: LogBean,
-        val policy: PolicyBean,
+        var policy: PolicyBean?,
         val inbounds: ArrayList<InboundBean>,
         var outbounds: ArrayList<OutboundBean>,
         var dns: DnsBean,
-        val routing: RoutingBean) {
+        val routing: RoutingBean,
+        val api: Any? = null,
+        val transport: Any? = null,
+        val reverse: Any? = null,
+        var fakedns: Any? = null,
+        val browserForwarder: Any? = null) {
+    companion object {
+        const val DEFAULT_PORT = 443
+        const val DEFAULT_SECURITY = "auto"
+        const val DEFAULT_LEVEL = 8
+        const val DEFAULT_NETWORK = "tcp"
+
+        const val TLS = "tls"
+        const val REALITY = "reality"
+        const val HTTP = "http"
+    }
 
     data class LogBean(val access: String,
                        val error: String,
-                       val loglevel: String)
+                       var loglevel: String?,
+                       val dnsLog: Boolean? = null)
 
     data class InboundBean(
             var tag: String,
             var port: Int,
             var protocol: String,
-            var listen: String?=null,
-            val settings: InSettingsBean,
-            val sniffing: SniffingBean?) {
+            var listen: String? = null,
+            val settings: Any? = null,
+            val sniffing: SniffingBean?,
+            val streamSettings: Any? = null,
+            val allocate: Any? = null) {
 
         data class InSettingsBean(val auth: String? = null,
                                   val udp: Boolean? = null,
-                                  val userLevel: Int? =null,
+                                  val userLevel: Int? = null,
                                   val address: String? = null,
                                   val port: Int? = null,
                                   val network: String? = null)
 
         data class SniffingBean(var enabled: Boolean,
-                                val destOverride: List<String>)
+                                val destOverride: ArrayList<String>,
+                                val metadataOnly: Boolean? = null)
     }
 
-    data class OutboundBean(val tag: String,
+    data class OutboundBean(var tag: String = "proxy",
                             var protocol: String,
-                            var settings: OutSettingsBean?,
-                            var streamSettings: StreamSettingsBean?,
-                            var mux: MuxBean?) {
+                            var settings: OutSettingsBean? = null,
+                            var streamSettings: StreamSettingsBean? = null,
+                            val proxySettings: Any? = null,
+                            val sendThrough: String? = null,
+                            var mux: MuxBean? = MuxBean(false)) {
 
-        data class OutSettingsBean(var vnext: List<VnextBean>?,
-                                   var servers: List<ServersBean>?,
-                                   var response: Response) {
-
-            data class VnextBean(var address: String,
-                                 var port: Int,
-                                 var users: List<UsersBean>) {
-
-                data class UsersBean(var id: String,
-                                     var alterId: Int,
-                                     var security: String,
-                                     var level: Int)
-            }
-
-            data class ServersBean(var address: String,
-                                   var method: String,
-                                   var ota: Boolean,
-                                   var password: String,
-                                   var port: Int,
-                                   var level: Int)
-
-            data class Response(var type: String)
-        }
-
-        data class StreamSettingsBean(var network: String,
-                                      var security: String,
-                                      var tcpSettings: TcpsettingsBean?,
-                                      var kcpsettings: KcpsettingsBean?,
-                                      var wssettings: WssettingsBean?,
-                                      var httpsettings: HttpsettingsBean?,
-                                      var tlssettings: TlssettingsBean?,
-                                      var quicsettings: QuicsettingBean?
+        data class OutSettingsBean(var vnext: List<VnextBean>? = null,
+                                   var fragment: FragmentBean? = null,
+                                   var servers: List<ServersBean>? = null,
+                /*Blackhole*/
+                                   var response: Response? = null,
+                /*DNS*/
+                                   val network: String? = null,
+                                   var address: Any? = null,
+                                   val port: Int? = null,
+                /*Freedom*/
+                                   var domainStrategy: String? = null,
+                                   val redirect: String? = null,
+                                   val userLevel: Int? = null,
+                /*Loopback*/
+                                   val inboundTag: String? = null,
+                /*Wireguard*/
+                                   var secretKey: String? = null,
+                                   val peers: List<WireGuardBean>? = null,
+                                   var reserved: List<Int>? = null,
+                                   var mtu :Int? = null
         ) {
 
-            data class TcpsettingsBean(var connectionReuse: Boolean = true,
-                                       var header: HeaderBean = HeaderBean()) {
-                data class HeaderBean(var type: String = "none",
-                                      var request: Any? = null,
-                                      var response: Any? = null)
+            data class VnextBean(var address: String = "",
+                                 var port: Int = DEFAULT_PORT,
+                                 var users: List<UsersBean>) {
+
+                data class UsersBean(var id: String = "",
+                                     var alterId: Int? = null,
+                                     var security: String = DEFAULT_SECURITY,
+                                     var level: Int = DEFAULT_LEVEL,
+                                     var encryption: String = "",
+                                     var flow: String = "")
             }
 
-            data class KcpsettingsBean(var mtu: Int = 1350,
-                                       var tti: Int = 20,
+            data class FragmentBean(var packets: String? = null,
+                                 var length: String? = null,
+                                 var interval: String? = null)
+
+            data class ServersBean(var address: String = "",
+                                   var method: String = "chacha20-poly1305",
+                                   var ota: Boolean = false,
+                                   var password: String = "",
+                                   var port: Int = DEFAULT_PORT,
+                                   var level: Int = DEFAULT_LEVEL,
+                                   val email: String? = null,
+                                   var flow: String? = null,
+                                   val ivCheck: Boolean? = null,
+                                   var users: List<SocksUsersBean>? = null) {
+
+
+                data class SocksUsersBean(var user: String = "",
+                                          var pass: String = "",
+                                          var level: Int = DEFAULT_LEVEL)
+            }
+
+            data class Response(var type: String)
+
+            data class WireGuardBean(var publicKey: String = "",
+                                     var endpoint: String = "")
+        }
+
+        data class StreamSettingsBean(var network: String = DEFAULT_NETWORK,
+                                      var security: String = "",
+                                      var tcpSettings: TcpSettingsBean? = null,
+                                      var kcpSettings: KcpSettingsBean? = null,
+                                      var wsSettings: WsSettingsBean? = null,
+                                      var httpupgradeSettings: HttpupgradeSettingsBean? = null,
+                                      var httpSettings: HttpSettingsBean? = null,
+                                      var tlsSettings: TlsSettingsBean? = null,
+                                      var quicSettings: QuicSettingBean? = null,
+                                      var realitySettings: TlsSettingsBean? = null,
+                                      var grpcSettings: GrpcSettingsBean? = null,
+                                      val dsSettings: Any? = null,
+                                      var sockopt: SockoptBean? = null
+        ) {
+
+            data class TcpSettingsBean(var header: HeaderBean = HeaderBean(),
+                                       val acceptProxyProtocol: Boolean? = null) {
+                data class HeaderBean(var type: String = "none",
+                                      var request: RequestBean? = null,
+                                      var response: Any? = null) {
+                    data class RequestBean(var path: List<String> = ArrayList(),
+                                           var headers: HeadersBean = HeadersBean(),
+                                           val version: String? = null,
+                                           val method: String? = null) {
+                        data class HeadersBean(var Host: List<String> = ArrayList(),
+                                               @SerializedName("User-Agent")
+                                               val userAgent: List<String>? = null,
+                                               @SerializedName("Accept-Encoding")
+                                               val acceptEncoding: List<String>? = null,
+                                               val Connection: List<String>? = null,
+                                               val Pragma: String? = null)
+                    }
+                }
+            }
+
+            data class KcpSettingsBean(var mtu: Int = 1350,
+                                       var tti: Int = 50,
                                        var uplinkCapacity: Int = 12,
                                        var downlinkCapacity: Int = 100,
                                        var congestion: Boolean = false,
                                        var readBufferSize: Int = 1,
                                        var writeBufferSize: Int = 1,
+                                       var header: HeaderBean = HeaderBean(),
+                                       var seed: String? = null) {
+                data class HeaderBean(var type: String = "none")
+            }
+
+            data class WsSettingsBean(var path: String = "",
+                                      var headers: HeadersBean = HeadersBean(),
+                                      val maxEarlyData: Int? = null,
+                                      val useBrowserForwarding: Boolean? = null,
+                                      val acceptProxyProtocol: Boolean? = null) {
+                data class HeadersBean(var Host: String = "")
+            }
+
+            data class HttpupgradeSettingsBean(var path: String = "",
+                                               var host: String = "",
+                                               val acceptProxyProtocol: Boolean? = null)
+
+            data class HttpSettingsBean(var host: List<String> = ArrayList(),
+                                        var path: String = "")
+
+            data class SockoptBean(var TcpNoDelay: Boolean? = null,
+                                   var tcpKeepAliveIdle: Int? = null,
+                                   var tcpFastOpen: Boolean? = null,
+                                   var tproxy: String? = null,
+                                   var mark: Int? = null,
+                                   var dialerProxy: String? = null)
+
+            data class TlsSettingsBean(var allowInsecure: Boolean = false,
+                                       var serverName: String = "",
+                                       val alpn: List<String>? = null,
+                                       val minVersion: String? = null,
+                                       val maxVersion: String? = null,
+                                       val preferServerCipherSuites: Boolean? = null,
+                                       val cipherSuites: String? = null,
+                                       val fingerprint: String? = null,
+                                       val certificates: List<Any>? = null,
+                                       val disableSystemRoot: Boolean? = null,
+                                       val enableSessionResumption: Boolean? = null,
+                    // REALITY settings
+                                       val show: Boolean = false,
+                                       var publicKey: String? = null,
+                                       var shortId: String? = null,
+                                       var spiderX: String? = null)
+
+            data class QuicSettingBean(var security: String = "none",
+                                       var key: String = "",
                                        var header: HeaderBean = HeaderBean()) {
                 data class HeaderBean(var type: String = "none")
             }
 
-            data class WssettingsBean(var connectionReuse: Boolean = true,
-                                      var path: String = "",
-                                      var headers: HeadersBean = HeadersBean()) {
-                data class HeadersBean(var Host: String = "")
+            data class GrpcSettingsBean(var serviceName: String = "",
+                                        var multiMode: Boolean? = null)
+
+            fun populateTransportSettings(transport: String, headerType: String?, host: String?, path: String?, seed: String?,
+                                          quicSecurity: String?, key: String?, mode: String?, serviceName: String?): String {
+                var sni = ""
+                network = transport
+                when (network) {
+                    "tcp" -> {
+                        val tcpSetting = TcpSettingsBean()
+                        if (headerType == HTTP) {
+                            tcpSetting.header.type = HTTP
+                            if (!TextUtils.isEmpty(host) || !TextUtils.isEmpty(path)) {
+                                val requestObj = TcpSettingsBean.HeaderBean.RequestBean()
+                                requestObj.headers.Host = (host ?: "").split(",").map { it.trim() }.filter { it.isNotEmpty() }
+                                requestObj.path = (path ?: "").split(",").map { it.trim() }.filter { it.isNotEmpty() }
+                                tcpSetting.header.request = requestObj
+                                sni = requestObj.headers.Host.getOrNull(0) ?: sni
+                            }
+                        } else {
+                            tcpSetting.header.type = "none"
+                            sni = host ?: ""
+                        }
+                        tcpSettings = tcpSetting
+                    }
+                    "kcp" -> {
+                        val kcpsetting = KcpSettingsBean()
+                        kcpsetting.header.type = headerType ?: "none"
+                        if (seed.isNullOrEmpty()) {
+                            kcpsetting.seed = null
+                        } else {
+                            kcpsetting.seed = seed
+                        }
+                        kcpSettings = kcpsetting
+                    }
+                    "ws" -> {
+                        val wssetting = WsSettingsBean()
+                        wssetting.headers.Host = host ?: ""
+                        sni = wssetting.headers.Host
+                        wssetting.path = path ?: "/"
+                        wsSettings = wssetting
+                    }
+                    "httpupgrade" -> {
+                        val httpupgradeSetting = HttpupgradeSettingsBean()
+                        httpupgradeSetting.host = host ?: ""
+                        sni = httpupgradeSetting.host
+                        httpupgradeSetting.path = path ?: "/"
+                        httpupgradeSettings = httpupgradeSetting
+                    }
+                    "h2", "http" -> {
+                        network = "h2"
+                        val h2Setting = HttpSettingsBean()
+                        h2Setting.host = (host ?: "").split(",").map { it.trim() }.filter { it.isNotEmpty() }
+                        sni = h2Setting.host.getOrNull(0) ?: sni
+                        h2Setting.path = path ?: "/"
+                        httpSettings = h2Setting
+                    }
+                    "quic" -> {
+                        val quicsetting = QuicSettingBean()
+                        quicsetting.security = quicSecurity ?: "none"
+                        quicsetting.key = key ?: ""
+                        quicsetting.header.type = headerType ?: "none"
+                        quicSettings = quicsetting
+                    }
+                    "grpc" -> {
+                        val grpcSetting = GrpcSettingsBean()
+                        grpcSetting.multiMode = mode == "multi"
+                        grpcSetting.serviceName = serviceName ?: ""
+                        sni = host ?: ""
+                        grpcSettings = grpcSetting
+                    }
+                }
+                return sni
             }
 
-            data class HttpsettingsBean(var host: List<String> = ArrayList<String>(), var path: String = "")
-
-            data class TlssettingsBean(var allowInsecure: Boolean = true,
-                                       var serverName: String = "")
-
-            data class QuicsettingBean(var security: String = "none",
-                                        var key: String = "",
-                                        var header: HeaderBean = HeaderBean()) {
-                data class HeaderBean(var type: String = "none")
+            fun populateTlsSettings(streamSecurity: String, allowInsecure: Boolean, sni: String, fingerprint: String?, alpns: String?,
+                                    publicKey: String?, shortId: String?, spiderX: String?) {
+                security = streamSecurity
+                val tlsSetting = TlsSettingsBean(
+                        allowInsecure = allowInsecure,
+                        serverName = sni,
+                        fingerprint = fingerprint,
+                        alpn = if (alpns.isNullOrEmpty()) null else alpns.split(",").map { it.trim() }.filter { it.isNotEmpty() },
+                        publicKey = publicKey,
+                        shortId = shortId,
+                        spiderX = spiderX
+                )
+                if (security == TLS) {
+                    tlsSettings = tlsSetting
+                    realitySettings = null
+                } else if (security == REALITY) {
+                    tlsSettings = null
+                    realitySettings = tlsSetting
+                }
             }
         }
 
-        data class MuxBean(var enabled: Boolean)
+        data class MuxBean(var enabled: Boolean,
+                           var concurrency: Int = 8,
+                           var xudpConcurrency: Int = 8,
+                           var xudpProxyUDP443: String = "",)
+
+        fun getServerAddress(): String? {
+            if (protocol.equals(EConfigType.VMESS.name, true)
+                    || protocol.equals(EConfigType.VLESS.name, true)) {
+                return settings?.vnext?.get(0)?.address
+            } else if (protocol.equals(EConfigType.SHADOWSOCKS.name, true)
+                    || protocol.equals(EConfigType.SOCKS.name, true)
+                    || protocol.equals(EConfigType.TROJAN.name, true)) {
+                return settings?.servers?.get(0)?.address
+            } else if (protocol.equals(EConfigType.WIREGUARD.name, true)) {
+                return settings?.peers?.get(0)?.endpoint?.substringBeforeLast(":")
+            }
+            return null
+        }
+
+        fun getServerPort(): Int? {
+            if (protocol.equals(EConfigType.VMESS.name, true)
+                    || protocol.equals(EConfigType.VLESS.name, true)) {
+                return settings?.vnext?.get(0)?.port
+            } else if (protocol.equals(EConfigType.SHADOWSOCKS.name, true)
+                    || protocol.equals(EConfigType.SOCKS.name, true)
+                    || protocol.equals(EConfigType.TROJAN.name, true)) {
+                return settings?.servers?.get(0)?.port
+            } else if (protocol.equals(EConfigType.WIREGUARD.name, true)) {
+                return settings?.peers?.get(0)?.endpoint?.substringAfterLast(":")?.toInt()
+            }
+            return null
+        }
+
+        fun getPassword(): String? {
+            if (protocol.equals(EConfigType.VMESS.name, true)
+                    || protocol.equals(EConfigType.VLESS.name, true)) {
+                return settings?.vnext?.get(0)?.users?.get(0)?.id
+            } else if (protocol.equals(EConfigType.SHADOWSOCKS.name, true)
+                    || protocol.equals(EConfigType.TROJAN.name, true)) {
+                return settings?.servers?.get(0)?.password
+            } else if (protocol.equals(EConfigType.SOCKS.name, true)) {
+                return settings?.servers?.get(0)?.users?.get(0)?.pass
+            } else if (protocol.equals(EConfigType.WIREGUARD.name, true)) {
+                return settings?.secretKey
+            }
+            return null
+        }
+
+        fun getSecurityEncryption(): String? {
+            return when {
+                protocol.equals(EConfigType.VMESS.name, true) -> settings?.vnext?.get(0)?.users?.get(0)?.security
+                protocol.equals(EConfigType.VLESS.name, true) -> settings?.vnext?.get(0)?.users?.get(0)?.encryption
+                protocol.equals(EConfigType.SHADOWSOCKS.name, true) -> settings?.servers?.get(0)?.method
+                else -> null
+            }
+        }
+
+        fun getTransportSettingDetails(): List<String>? {
+            if (protocol.equals(EConfigType.VMESS.name, true)
+                    || protocol.equals(EConfigType.VLESS.name, true)
+                    || protocol.equals(EConfigType.TROJAN.name, true)) {
+                val transport = streamSettings?.network ?: return null
+                return when (transport) {
+                    "tcp" -> {
+                        val tcpSetting = streamSettings?.tcpSettings ?: return null
+                        listOf(tcpSetting.header.type,
+                                tcpSetting.header.request?.headers?.Host?.joinToString().orEmpty(),
+                                tcpSetting.header.request?.path?.joinToString().orEmpty())
+                    }
+                    "kcp" -> {
+                        val kcpSetting = streamSettings?.kcpSettings ?: return null
+                        listOf(kcpSetting.header.type,
+                                "",
+                                kcpSetting.seed.orEmpty())
+                    }
+                    "ws" -> {
+                        val wsSetting = streamSettings?.wsSettings ?: return null
+                        listOf("",
+                                wsSetting.headers.Host,
+                                wsSetting.path)
+                    }
+                    "httpupgrade" -> {
+                        val httpupgradeSetting = streamSettings?.httpupgradeSettings ?: return null
+                        listOf("",
+                            httpupgradeSetting.host,
+                            httpupgradeSetting.path)
+                    }
+                    "h2" -> {
+                        val h2Setting = streamSettings?.httpSettings ?: return null
+                        listOf("",
+                                h2Setting.host.joinToString(),
+                                h2Setting.path)
+                    }
+                    "quic" -> {
+                        val quicSetting = streamSettings?.quicSettings ?: return null
+                        listOf(quicSetting.header.type,
+                                quicSetting.security,
+                                quicSetting.key)
+                    }
+                    "grpc" -> {
+                        val grpcSetting = streamSettings?.grpcSettings ?: return null
+                        listOf(if (grpcSetting.multiMode == true) "multi" else "gun",
+                                "",
+                                grpcSetting.serviceName)
+                    }
+                    else -> null
+                }
+            }
+            return null
+        }
     }
 
-    //data class DnsBean(var servers: List<String>)
-    data class DnsBean(var servers: List<Any>?=null,
-                       var hosts: Map<String, String>?=null
+    data class DnsBean(var servers: ArrayList<Any>? = null,
+                       var hosts: Map<String, Any>? = null,
+                       val clientIp: String? = null,
+                       val disableCache: Boolean? = null,
+                       val queryStrategy: String? = null,
+                       val tag: String? = null
     ) {
         data class ServersBean(var address: String = "",
-                               var port: Int = 0,
-                               var domains: List<String>?)
+                               var port: Int? = null,
+                               var domains: List<String>? = null,
+                               var expectIPs: List<String>? = null,
+                               val clientIp: String? = null)
     }
 
     data class RoutingBean(var domainStrategy: String,
-                           var rules: ArrayList<RulesBean>) {
+                           var domainMatcher: String? = null,
+                           var rules: ArrayList<RulesBean>,
+                           val balancers: List<Any>? = null) {
 
         data class RulesBean(var type: String = "",
                              var ip: ArrayList<String>? = null,
                              var domain: ArrayList<String>? = null,
                              var outboundTag: String = "",
+                             var balancerTag: String? = null,
                              var port: String? = null,
-                             var inboundTag: ArrayList<String>? = null)
+                             val sourcePort: String? = null,
+                             val network: String? = null,
+                             val source: List<String>? = null,
+                             val user: List<String>? = null,
+                             var inboundTag: List<String>? = null,
+                             val protocol: List<String>? = null,
+                             val attrs: String? = null,
+                             val domainMatcher: String? = null
+        )
     }
 
     data class PolicyBean(var levels: Map<String, LevelBean>,
-                            var system: Any?=null) {
+                          var system: Any? = null) {
         data class LevelBean(
-                  var handshake: Int? = null,
-                  var connIdle: Int? = null,
-                  var uplinkOnly: Int? = null,
-                  var downlinkOnly: Int? = null)
+                var handshake: Int? = null,
+                var connIdle: Int? = null,
+                var uplinkOnly: Int? = null,
+                var downlinkOnly: Int? = null,
+                val statsUserUplink: Boolean? = null,
+                val statsUserDownlink: Boolean? = null,
+                var bufferSize: Int? = null)
     }
-}
+
+    data class FakednsBean(var ipPool: String = "198.18.0.0/15",
+                           var poolSize: Int = 10000) // roughly 10 times smaller than total ip pool
+
+    fun getProxyOutbound(): OutboundBean? {
+        outbounds?.forEach { outbound ->
+            EConfigType.values().forEach {
+                if (outbound.protocol.equals(it.name, true)) {
+                    return outbound
+                }
+            }
+        }
+        return null
+    }
+
+    fun toPrettyPrinting(): String {
+        return GsonBuilder()
+                .setPrettyPrinting()
+                .disableHtmlEscaping()
+                .registerTypeAdapter( // custom serialiser is needed here since JSON by default parse number as Double, core will fail to start
+                        object : TypeToken<Double>() {}.type,
+                        JsonSerializer { src: Double?, _: Type?, _: JsonSerializationContext? -> JsonPrimitive(src?.toInt()) }
+                )
+                .create()
+                .toJson(this)
+    }
+}

V2rayNG/app/src/main/kotlin/com/v2ray/ang/dto/VmessQRCode.kt

@@ -5,9 +5,13 @@ data class VmessQRCode(var v: String = "",
                        var add: String = "",
                        var port: String = "",
                        var id: String = "",
-                       var aid: String = "",
+                       var aid: String = "0",
+                       var scy: String = "",
                        var net: String = "",
                        var type: String = "",
                        var host: String = "",
                        var path: String = "",
-                       var tls: String = "")
+                       var tls: String = "",
+                       var sni: String = "",
+                       var alpn: String = "",
+                       var fp: String = "")

V2rayNG/app/src/main/kotlin/com/v2ray/ang/extension/_Dialog.kt

@@ -1,244 +0,0 @@
-package com.v2ray.ang.extension
-
-import android.app.Fragment
-import android.app.ProgressDialog
-import android.content.Context
-import android.content.DialogInterface
-import android.database.Cursor
-import android.graphics.drawable.Drawable
-import android.support.v7.app.AlertDialog
-import android.view.KeyEvent
-import android.view.View
-import android.widget.ListAdapter
-
-
-fun Context.alertView(
-        title: String? = null,
-        view: View,
-        init: (KAlertDialogBuilder.() -> Unit)? = null
-) = KAlertDialogBuilder(this).apply {
-    if (title != null) title(title)
-    if (title != null) customView(view)
-    if (init != null) init()
-}
-
-fun Fragment.alert(
-        message: String,
-        title: String? = null,
-        init: (KAlertDialogBuilder.() -> Unit)? = null
-) = activity.alert(message, title, init)
-
-fun Context.alert(
-        message: String,
-        title: String? = null,
-        init: (KAlertDialogBuilder.() -> Unit)? = null
-) = KAlertDialogBuilder(this).apply {
-    if (title != null) title(title)
-    message(message)
-    if (init != null) init()
-}
-
-fun Fragment.alert(
-        message: Int,
-        title: Int? = null,
-        init: (KAlertDialogBuilder.() -> Unit)? = null
-) = activity.alert(message, title, init)
-
-fun Context.alert(
-        message: Int,
-        title: Int? = null,
-        init: (KAlertDialogBuilder.() -> Unit)? = null
-) = KAlertDialogBuilder(this).apply {
-    if (title != null) title(title)
-    message(message)
-    if (init != null) init()
-}
-
-
-fun Fragment.alert(init: KAlertDialogBuilder.() -> Unit): KAlertDialogBuilder = activity.alert(init)
-
-fun Context.alert(init: KAlertDialogBuilder.() -> Unit) = KAlertDialogBuilder(this).apply { init() }
-
-fun Fragment.progressDialog(
-        message: Int? = null,
-        title: Int? = null,
-        init: (ProgressDialog.() -> Unit)? = null
-) = activity.progressDialog(message, title, init)
-
-fun Context.progressDialog(
-        message: Int? = null,
-        title: Int? = null,
-        init: (ProgressDialog.() -> Unit)? = null
-) = progressDialog(false, message?.let { getString(it) }, title?.let { getString(it) }, init)
-
-fun Fragment.indeterminateProgressDialog(
-        message: Int? = null,
-        title: Int? = null,
-        init: (ProgressDialog.() -> Unit)? = null
-) = activity.progressDialog(message, title, init)
-
-fun Context.indeterminateProgressDialog(
-        message: Int? = null,
-        title: Int? = null,
-        init: (ProgressDialog.() -> Unit)? = null
-) = progressDialog(true, message?.let { getString(it) }, title?.let { getString(it) }, init)
-
-fun Fragment.progressDialog(
-        message: String? = null,
-        title: String? = null,
-        init: (ProgressDialog.() -> Unit)? = null
-) = activity.progressDialog(message, title, init)
-
-fun Context.progressDialog(
-        message: String? = null,
-        title: String? = null,
-        init: (ProgressDialog.() -> Unit)? = null
-) = progressDialog(false, message, title, init)
-
-fun Fragment.indeterminateProgressDialog(
-        message: String? = null,
-        title: String? = null,
-        init: (ProgressDialog.() -> Unit)? = null
-) = activity.indeterminateProgressDialog(message, title, init)
-
-fun Context.indeterminateProgressDialog(
-        message: String? = null,
-        title: String? = null,
-        init: (ProgressDialog.() -> Unit)? = null
-) = progressDialog(true, message, title, init)
-
-private fun Context.progressDialog(
-        indeterminate: Boolean,
-        message: String? = null,
-        title: String? = null,
-        init: (ProgressDialog.() -> Unit)? = null
-) = ProgressDialog(this).apply {
-    isIndeterminate = indeterminate
-    if (!indeterminate) setProgressStyle(ProgressDialog.STYLE_HORIZONTAL)
-    if (message != null) setMessage(message)
-    if (title != null) setTitle(title)
-    if (init != null) init()
-    show()
-}
-
-fun Fragment.selector(
-        title: CharSequence? = null,
-        items: List<CharSequence>,
-        onClick: (Int) -> Unit
-): Unit = activity.selector(title, items, onClick)
-
-fun Context.selector(
-        title: CharSequence? = null,
-        items: List<CharSequence>,
-        onClick: (Int) -> Unit
-) {
-    with(KAlertDialogBuilder(this)) {
-        if (title != null) title(title)
-        items(items, onClick)
-        show()
-    }
-}
-
-class KAlertDialogBuilder(val ctx: Context) {
-
-    val builder: AlertDialog.Builder = AlertDialog.Builder(ctx)
-    protected var dialog: AlertDialog? = null
-
-    fun dismiss() {
-        dialog?.dismiss()
-    }
-
-    fun show(): KAlertDialogBuilder {
-        dialog = builder.create()
-        dialog!!.show()
-        return this
-    }
-
-    fun title(title: CharSequence) {
-        builder.setTitle(title)
-    }
-
-    fun title(resource: Int) {
-        builder.setTitle(resource)
-    }
-
-    fun message(title: CharSequence) {
-        builder.setMessage(title)
-    }
-
-    fun message(resource: Int) {
-        builder.setMessage(resource)
-    }
-
-    fun icon(icon: Int) {
-        builder.setIcon(icon)
-    }
-
-    fun icon(icon: Drawable) {
-        builder.setIcon(icon)
-    }
-
-    fun customTitle(title: View) {
-        builder.setCustomTitle(title)
-    }
-
-    fun customView(view: View) {
-        builder.setView(view)
-    }
-
-    fun cancellable(value: Boolean = true) {
-        builder.setCancelable(value)
-    }
-
-    fun onCancel(f: () -> Unit) {
-        builder.setOnCancelListener { f() }
-    }
-
-    fun onKey(f: (keyCode: Int, e: KeyEvent) -> Boolean) {
-        builder.setOnKeyListener({ dialog, keyCode, event -> f(keyCode, event) })
-    }
-
-    fun neutralButton(textResource: Int = android.R.string.ok, f: DialogInterface.() -> Unit = { dismiss() }) {
-        neutralButton(ctx.getString(textResource), f)
-    }
-
-    fun neutralButton(title: String, f: DialogInterface.() -> Unit = { dismiss() }) {
-        builder.setNeutralButton(title, { dialog, which -> dialog.f() })
-    }
-
-    fun positiveButton(textResource: Int = android.R.string.ok, f: DialogInterface.() -> Unit) {
-        positiveButton(ctx.getString(textResource), f)
-    }
-
-    fun positiveButton(title: String, f: DialogInterface.() -> Unit) {
-        builder.setPositiveButton(title, { dialog, which -> dialog.f() })
-    }
-
-    fun negativeButton(textResource: Int = android.R.string.cancel, f: DialogInterface.() -> Unit = { dismiss() }) {
-        negativeButton(ctx.getString(textResource), f)
-    }
-
-    fun negativeButton(title: String, f: DialogInterface.() -> Unit = { dismiss() }) {
-        builder.setNegativeButton(title, { dialog, which -> dialog.f() })
-    }
-
-    fun items(itemsId: Int, f: (which: Int) -> Unit) {
-        items(ctx.resources!!.getTextArray(itemsId), f)
-    }
-
-    fun items(items: List<CharSequence>, f: (which: Int) -> Unit) {
-        items(items.toTypedArray(), f)
-    }
-
-    fun items(items: Array<CharSequence>, f: (which: Int) -> Unit) {
-        builder.setItems(items, { dialog, which -> f(which) })
-    }
-
-    fun adapter(adapter: ListAdapter, f: (which: Int) -> Unit) {
-        builder.setAdapter(adapter, { dialog, which -> f(which) })
-    }
-
-    fun adapter(cursor: Cursor, labelColumn: String, f: (which: Int) -> Unit) {
-        builder.setCursor(cursor, { dialog, which -> f(which) }, labelColumn)
-    }
-}

V2rayNG/app/src/main/kotlin/com/v2ray/ang/extension/_Ext.kt

@@ -2,63 +2,68 @@ package com.v2ray.ang.extension
 
 import android.content.Context
 import android.os.Build
+import android.widget.Toast
 import com.v2ray.ang.AngApplication
-import me.dozen.dpreference.DPreference
+import me.drakeet.support.toast.ToastCompat
 import org.json.JSONObject
+import java.net.URI
 import java.net.URLConnection
 
-/**
- * Some extensions
- */
-
 val Context.v2RayApplication: AngApplication
     get() = applicationContext as AngApplication
 
-val Context.defaultDPreference: DPreference
-    get() = v2RayApplication.defaultDPreference
-
-
-fun JSONObject.putOpt(pair: Pair<String, Any>) = putOpt(pair.first, pair.second)!!
-fun JSONObject.putOpt(pairs: Map<String, Any>) = pairs.forEach { putOpt(it.key to it.value) }
-
-const val threshold = 1000
-const val divisor = 1024F
-
-fun Long.toSpeedString() = toTrafficString() + "/s"
-
-fun Long.toTrafficString(): String {
-    if (this < threshold)
-        return "$this B"
-
-    val kib = this / divisor
-    if (kib < threshold)
-        return "${kib.toShortString()} KB"
-
-    val mib = kib / divisor
-    if (mib < threshold)
-        return "${mib.toShortString()} MB"
-
-    val gib = mib / divisor
-    if (gib < threshold)
-        return "${gib.toShortString()} GB"
-
-    val tib = gib / divisor
-    if (tib < threshold)
-        return "${tib.toShortString()} TB"
-
-    val pib = tib / divisor
-    if (pib < threshold)
-        return "${pib.toShortString()} PB"
-
-    return "∞"
+fun Context.toast(message: Int) {
+    ToastCompat.makeText(this, message, Toast.LENGTH_SHORT).apply { show() }
 }
 
-private fun Float.toShortString(): String {
-    val s = toString()
-    if (s.length <= 4)
-        return s
-    return s.substring(0, 4).removeSuffix(".")
+fun Context.toast(message: CharSequence) {
+    ToastCompat.makeText(this, message, Toast.LENGTH_SHORT).apply { show() }
+}
+
+fun JSONObject.putOpt(pair: Pair<String, Any?>) {
+    put(pair.first, pair.second)
+}
+
+fun JSONObject.putOpt(pairs: Map<String, Any?>) {
+    pairs.forEach { put(it.key, it.value) }
+}
+
+const val THRESHOLD = 1000L
+const val DIVISOR = 1024.0
+
+fun Long.toSpeedString(): String = this.toTrafficString() + "/s"
+
+fun Long.toTrafficString(): String {
+    if (this < THRESHOLD) {
+        return "$this B"
+    }
+    val kb = this / DIVISOR
+    if (kb < THRESHOLD) {
+        return "${String.format("%.1f KB", kb)}"
+    }
+    val mb = kb / DIVISOR
+    if (mb < THRESHOLD) {
+        return "${String.format("%.1f MB", mb)}"
+    }
+    val gb = mb / DIVISOR
+    if (gb < THRESHOLD) {
+        return "${String.format("%.1f GB", gb)}"
+    }
+    val tb = gb / DIVISOR
+    if (tb < THRESHOLD) {
+        return "${String.format("%.1f TB", tb)}"
+    }
+    return String.format("%.1f PB", tb / DIVISOR)
 }
 
 val URLConnection.responseLength: Long
-    get() = if (Build.VERSION.SDK_INT >= 24) contentLengthLong else contentLength.toLong()
+    get() = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+        contentLengthLong
+    } else {
+        contentLength.toLong()
+    }
+
+val URI.idnHost: String
+    get() = host?.replace("[", "")?.replace("]", "") ?: ""
+
+fun String.removeWhiteSpace(): String = replace("\\s+".toRegex(), "")

V2rayNG/app/src/main/kotlin/com/v2ray/ang/extension/_Preference.kt

@@ -1,10 +0,0 @@
-package com.v2ray.ang.extension
-
-import android.preference.Preference
-
-fun Preference.onClick(listener: () -> Unit) {
-    setOnPreferenceClickListener {
-        listener()
-        true
-    }
-}

V2rayNG/app/src/main/kotlin/com/v2ray/ang/receiver/TaskerReceiver.kt

@@ -4,12 +4,16 @@ import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
 import android.text.TextUtils
-import com.google.zxing.WriterException
+import com.tencent.mmkv.MMKV
 import com.v2ray.ang.AppConfig
+import com.v2ray.ang.service.V2RayServiceManager
+import com.v2ray.ang.util.MmkvManager
 
 import com.v2ray.ang.util.Utils
 
 class TaskerReceiver : BroadcastReceiver() {
+    private val mainStorage by lazy { MMKV.mmkvWithID(MmkvManager.ID_MAIN, MMKV.MULTI_PROCESS_MODE) }
+
     override fun onReceive(context: Context, intent: Intent?) {
 
         try {
@@ -21,14 +25,15 @@ class TaskerReceiver : BroadcastReceiver() {
                 return
             } else if (switch) {
                 if (guid == AppConfig.TASKER_DEFAULT_GUID) {
-                    Utils.startVService(context)
+                    Utils.startVServiceFromToggle(context)
                 } else {
-                    Utils.startVService(context, guid)
+                    mainStorage?.encode(MmkvManager.KEY_SELECTED_SERVER, guid)
+                    V2RayServiceManager.startV2Ray(context)
                 }
             } else {
                 Utils.stopVService(context)
             }
-        } catch (e: WriterException) {
+        } catch (e: Exception) {
             e.printStackTrace()
         }
     }

V2rayNG/app/src/main/kotlin/com/v2ray/ang/receiver/WidgetProvider.kt

@@ -3,14 +3,15 @@ package com.v2ray.ang.receiver
 import android.app.PendingIntent
 import android.appwidget.AppWidgetManager
 import android.appwidget.AppWidgetProvider
+import android.content.ComponentName
 import android.content.Context
 import android.content.Intent
-import android.os.Bundle
+import android.os.Build
 import android.widget.RemoteViews
 import com.v2ray.ang.R
 import com.v2ray.ang.AppConfig
+import com.v2ray.ang.service.V2RayServiceManager
 import com.v2ray.ang.util.Utils
-import org.jetbrains.anko.toast
 
 class WidgetProvider : AppWidgetProvider() {
     /**
@@ -18,11 +19,43 @@ class WidgetProvider : AppWidgetProvider() {
      */
     override fun onUpdate(context: Context, appWidgetManager: AppWidgetManager, appWidgetIds: IntArray) {
         super.onUpdate(context, appWidgetManager, appWidgetIds)
+        updateWidgetBackground(context, appWidgetManager, appWidgetIds, V2RayServiceManager.v2rayPoint.isRunning)
+    }
 
+
+    private fun updateWidgetBackground(context: Context, appWidgetManager: AppWidgetManager, appWidgetIds: IntArray, isRunning: Boolean) {
         val remoteViews = RemoteViews(context.packageName, R.layout.widget_switch)
-        val intent = Intent(AppConfig.BROADCAST_ACTION_WIDGET_CLICK)
-        val pendingIntent = PendingIntent.getBroadcast(context, R.id.layout_switch, intent, PendingIntent.FLAG_UPDATE_CURRENT)
+        val intent = Intent(context, WidgetProvider::class.java)
+        intent.action = AppConfig.BROADCAST_ACTION_WIDGET_CLICK
+        val pendingIntent = PendingIntent.getBroadcast(
+            context,
+            R.id.layout_switch,
+            intent,
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
+            } else {
+                PendingIntent.FLAG_UPDATE_CURRENT
+            })
         remoteViews.setOnClickPendingIntent(R.id.layout_switch, pendingIntent)
+        if (isRunning) {
+            if (!Utils.getDarkModeStatus(context)) {
+                remoteViews.setInt(R.id.image_switch, "setImageResource", R.drawable.ic_stat_name)
+            }
+            remoteViews.setInt(
+                R.id.layout_switch,
+                "setBackgroundResource",
+                R.drawable.ic_rounded_corner_active
+            )
+        } else {
+            if (!Utils.getDarkModeStatus(context)) {
+                remoteViews.setInt(R.id.image_switch, "setImageResource", R.drawable.ic_stat_name_black)
+            }
+            remoteViews.setInt(
+                R.id.layout_switch,
+                "setBackgroundResource",
+                R.drawable.ic_rounded_corner_grey
+            )
+        }
 
         for (appWidgetId in appWidgetIds) {
             appWidgetManager.updateAppWidget(appWidgetId, remoteViews)
@@ -30,21 +63,29 @@ class WidgetProvider : AppWidgetProvider() {
     }
 
     /**
-     * 接收窗口小部件点击时发送的广播
+     * 接收窗口小部件发送的广播
      */
     override fun onReceive(context: Context, intent: Intent) {
         super.onReceive(context, intent)
         if (AppConfig.BROADCAST_ACTION_WIDGET_CLICK == intent.action) {
-
-            val isRunning = Utils.isServiceRun(context, "com.v2ray.ang.service.V2RayVpnService")
-            if (isRunning) {
-//                context.toast(R.string.toast_services_stop)
+            if (V2RayServiceManager.v2rayPoint.isRunning) {
                 Utils.stopVService(context)
             } else {
-//                context.toast(R.string.toast_services_start)
-                Utils.startVService(context)
+                Utils.startVServiceFromToggle(context)
+            }
+        } else if (AppConfig.BROADCAST_ACTION_ACTIVITY == intent.action) {
+            AppWidgetManager.getInstance(context)?.let { manager ->
+                when (intent.getIntExtra("key", 0)) {
+                    AppConfig.MSG_STATE_RUNNING, AppConfig.MSG_STATE_START_SUCCESS -> {
+                        updateWidgetBackground(context, manager, manager.getAppWidgetIds(ComponentName(context, WidgetProvider::class.java)),
+                                true)
+                    }
+                    AppConfig.MSG_STATE_NOT_RUNNING, AppConfig.MSG_STATE_START_FAILURE, AppConfig.MSG_STATE_STOP_SUCCESS -> {
+                        updateWidgetBackground(context, manager, manager.getAppWidgetIds(ComponentName(context, WidgetProvider::class.java)),
+                                false)
+                    }
+                }
             }
         }
     }
-
 }

V2rayNG/app/src/main/kotlin/com/v2ray/ang/service/QSTileService.kt

@@ -6,19 +6,15 @@ import android.content.Context
 import android.content.Intent
 import android.content.IntentFilter
 import android.graphics.drawable.Icon
-import android.net.VpnService
 import android.os.Build
 import android.service.quicksettings.Tile
 import android.service.quicksettings.TileService
 import com.v2ray.ang.AppConfig
 import com.v2ray.ang.R
-import com.v2ray.ang.extension.defaultDPreference
 import com.v2ray.ang.util.MessageUtil
 import com.v2ray.ang.util.Utils
-import org.jetbrains.anko.toast
 import java.lang.ref.SoftReference
 
-
 @TargetApi(Build.VERSION_CODES.N)
 class QSTileService : TileService() {
 
@@ -26,14 +22,13 @@ class QSTileService : TileService() {
         if (state == Tile.STATE_INACTIVE) {
             qsTile?.state = Tile.STATE_INACTIVE
             qsTile?.label = getString(R.string.app_name)
-            qsTile?.icon = Icon.createWithResource(applicationContext, R.drawable.ic_v_idle)
+            qsTile?.icon = Icon.createWithResource(applicationContext, R.drawable.ic_stat_name)
         } else if (state == Tile.STATE_ACTIVE) {
             qsTile?.state = Tile.STATE_ACTIVE
-            qsTile?.label = defaultDPreference.getPrefString(AppConfig.PREF_CURR_CONFIG_NAME, "NG")
-            qsTile?.icon = Icon.createWithResource(applicationContext, R.drawable.ic_v)
+            qsTile?.label = V2RayServiceManager.currentConfig?.remarks
+            qsTile?.icon = Icon.createWithResource(applicationContext, R.drawable.ic_stat_name)
         }
 
-
         qsTile?.updateTile()
     }
 
@@ -41,7 +36,12 @@ class QSTileService : TileService() {
         super.onStartListening()
         setState(Tile.STATE_INACTIVE)
         mMsgReceive = ReceiveMessageHandler(this)
-        registerReceiver(mMsgReceive, IntentFilter(AppConfig.BROADCAST_ACTION_ACTIVITY))
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            registerReceiver(mMsgReceive, IntentFilter(AppConfig.BROADCAST_ACTION_ACTIVITY), Context.RECEIVER_EXPORTED)
+        } else {
+            registerReceiver(mMsgReceive, IntentFilter(AppConfig.BROADCAST_ACTION_ACTIVITY))
+        }
+
         MessageUtil.sendMsg2Service(this, AppConfig.MSG_REGISTER_CLIENT, "")
     }
 
@@ -56,11 +56,7 @@ class QSTileService : TileService() {
         super.onClick()
         when (qsTile.state) {
             Tile.STATE_INACTIVE -> {
-                val intent = VpnService.prepare(this)
-                if (intent == null)
-                    if (!Utils.startVService(this)) {
-                        toast(R.string.app_tile_first_use)
-                    }
+                Utils.startVServiceFromToggle(this)
             }
             Tile.STATE_ACTIVE -> {
                 Utils.stopVService(this)
@@ -93,4 +89,4 @@ class QSTileService : TileService() {
             }
         }
     }
-}
+}

V2rayNG/app/src/main/kotlin/com/v2ray/ang/service/ServiceControl.kt

@@ -0,0 +1,13 @@
+package com.v2ray.ang.service
+
+import android.app.Service
+
+interface ServiceControl {
+    fun getService(): Service
+
+    fun startService()
+
+    fun stopService()
+
+    fun vpnProtect(socket: Int): Boolean
+}

V2rayNG/app/src/main/kotlin/com/v2ray/ang/service/SubscriptionUpdater.kt

@@ -0,0 +1,80 @@
+package com.v2ray.ang.service
+
+import android.annotation.SuppressLint
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.content.Context
+import android.os.Build
+import android.util.Log
+import androidx.core.app.NotificationCompat
+import androidx.core.app.NotificationManagerCompat
+import androidx.work.CoroutineWorker
+import androidx.work.WorkerParameters
+import com.v2ray.ang.AppConfig
+import com.v2ray.ang.R
+import com.v2ray.ang.util.AngConfigManager
+import com.v2ray.ang.util.MmkvManager
+import com.v2ray.ang.util.Utils
+
+object SubscriptionUpdater {
+
+    const val notificationChannel = "subscription_update_channel"
+
+    class UpdateTask(context: Context, params: WorkerParameters) :
+        CoroutineWorker(context, params) {
+
+        private val notificationManager = NotificationManagerCompat.from(applicationContext)
+        private val notification =
+            NotificationCompat.Builder(applicationContext, notificationChannel)
+                .setWhen(0)
+                .setTicker("Update")
+                .setContentTitle(context.getString(R.string.title_pref_auto_update_subscription))
+                .setSmallIcon(R.drawable.ic_stat_name)
+                .setCategory(NotificationCompat.CATEGORY_SERVICE)
+                .setPriority(NotificationCompat.PRIORITY_DEFAULT)
+
+        @SuppressLint("MissingPermission")
+        override suspend fun doWork(): Result {
+            Log.d(AppConfig.ANG_PACKAGE, "subscription automatic update starting")
+
+            val subs = MmkvManager.decodeSubscriptions().filter { it.second.autoUpdate }
+
+            for (i in subs) {
+                val subscription = i.second
+
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                    notification.setChannelId(notificationChannel)
+                    val channel =
+                        NotificationChannel(
+                            notificationChannel,
+                            "Subscription Update Service",
+                            NotificationManager.IMPORTANCE_MIN
+                        )
+                    notificationManager.createNotificationChannel(channel)
+                }
+                notificationManager.notify(3, notification.build())
+                Log.d(
+                    AppConfig.ANG_PACKAGE,
+                    "subscription automatic update: ---${subscription.remarks}"
+                )
+                val configs = Utils.getUrlContentWithCustomUserAgent(subscription.url)
+                importBatchConfig(configs, i.first)
+                notification.setContentText("Updating ${subscription.remarks}")
+            }
+            notificationManager.cancel(3)
+            return Result.success()
+        }
+    }
+
+    fun importBatchConfig(server: String?, subid: String = "") {
+        val append = subid.isEmpty()
+
+        val count = AngConfigManager.importBatchConfig(server, subid, append)
+        if (count <= 0) {
+            AngConfigManager.importBatchConfig(Utils.decode(server!!), subid, append)
+        }
+        if (count <= 0) {
+            AngConfigManager.appendCustomConfigServer(server, subid)
+        }
+    }
+}

V2rayNG/app/src/main/kotlin/com/v2ray/ang/service/V2RayProxyOnlyService.kt

@@ -0,0 +1,56 @@
+package com.v2ray.ang.service
+
+import android.app.Service
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import android.os.IBinder
+import androidx.annotation.RequiresApi
+import com.v2ray.ang.util.MyContextWrapper
+import com.v2ray.ang.util.Utils
+import java.lang.ref.SoftReference
+
+class V2RayProxyOnlyService : Service(), ServiceControl {
+    override fun onCreate() {
+        super.onCreate()
+        V2RayServiceManager.serviceControl = SoftReference(this)
+    }
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        V2RayServiceManager.startV2rayPoint()
+        return START_STICKY
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        V2RayServiceManager.stopV2rayPoint()
+    }
+
+    override fun getService(): Service {
+        return this
+    }
+
+    override fun startService() {
+        // do nothing
+    }
+
+    override fun stopService() {
+        stopSelf()
+    }
+
+    override fun vpnProtect(socket: Int): Boolean {
+        return true
+    }
+
+    override fun onBind(intent: Intent?): IBinder? {
+        return null
+    }
+
+    @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/service/V2RayServiceManager.kt

@@ -0,0 +1,403 @@
+package com.v2ray.ang.service
+
+import android.app.*
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.graphics.Color
+import android.os.Build
+import android.util.Log
+import androidx.annotation.RequiresApi
+import androidx.core.app.NotificationCompat
+import com.tencent.mmkv.MMKV
+import com.v2ray.ang.AppConfig
+import com.v2ray.ang.AppConfig.ANG_PACKAGE
+import com.v2ray.ang.AppConfig.TAG_DIRECT
+import com.v2ray.ang.R
+import com.v2ray.ang.dto.ServerConfig
+import com.v2ray.ang.extension.toSpeedString
+import com.v2ray.ang.extension.toast
+import com.v2ray.ang.ui.MainActivity
+import com.v2ray.ang.util.MessageUtil
+import com.v2ray.ang.util.MmkvManager
+import com.v2ray.ang.util.Utils
+import com.v2ray.ang.util.V2rayConfigUtil
+import go.Seq
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.launch
+import libv2ray.Libv2ray
+import libv2ray.V2RayPoint
+import libv2ray.V2RayVPNServiceSupportsSet
+import rx.Observable
+import rx.Subscription
+import java.lang.ref.SoftReference
+import kotlin.math.min
+
+object V2RayServiceManager {
+    private const val NOTIFICATION_ID = 1
+    private const val NOTIFICATION_PENDING_INTENT_CONTENT = 0
+    private const val NOTIFICATION_PENDING_INTENT_STOP_V2RAY = 1
+    private const val NOTIFICATION_ICON_THRESHOLD = 3000
+
+    val v2rayPoint: V2RayPoint = Libv2ray.newV2RayPoint(V2RayCallback(), Build.VERSION.SDK_INT >= Build.VERSION_CODES.N_MR1)
+    private val mMsgReceive = ReceiveMessageHandler()
+    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) }
+
+    var serviceControl: SoftReference<ServiceControl>? = null
+        set(value) {
+            field = value
+            Seq.setContext(value?.get()?.getService()?.applicationContext)
+            Libv2ray.initV2Env(Utils.userAssetPath(value?.get()?.getService()), Utils.getDeviceIdForXUDPBaseKey())
+        }
+    var currentConfig: ServerConfig? = null
+
+    private var lastQueryTime = 0L
+    private var mBuilder: NotificationCompat.Builder? = null
+    private var mSubscription: Subscription? = null
+    private var mNotificationManager: NotificationManager? = null
+
+    fun startV2Ray(context: Context) {
+        if (settingsStorage?.decodeBool(AppConfig.PREF_PROXY_SHARING) == true) {
+            context.toast(R.string.toast_warning_pref_proxysharing_short)
+        } else {
+            context.toast(R.string.toast_services_start)
+        }
+        val intent = if (settingsStorage?.decodeString(AppConfig.PREF_MODE) ?: "VPN" == "VPN") {
+            Intent(context.applicationContext, V2RayVpnService::class.java)
+        } else {
+            Intent(context.applicationContext, V2RayProxyOnlyService::class.java)
+        }
+        if (Build.VERSION.SDK_INT > Build.VERSION_CODES.N_MR1) {
+            context.startForegroundService(intent)
+        } else {
+            context.startService(intent)
+        }
+    }
+
+    private class V2RayCallback : V2RayVPNServiceSupportsSet {
+        override fun shutdown(): Long {
+            val serviceControl = serviceControl?.get() ?: return -1
+            // called by go
+            return try {
+                serviceControl.stopService()
+                0
+            } catch (e: Exception) {
+                Log.d(ANG_PACKAGE, e.toString())
+                -1
+            }
+        }
+
+        override fun prepare(): Long {
+            return 0
+        }
+
+        override fun protect(l: Long): Boolean {
+            val serviceControl = serviceControl?.get() ?: return true
+            return serviceControl.vpnProtect(l.toInt())
+        }
+
+        override fun onEmitStatus(l: Long, s: String?): Long {
+            //Logger.d(s)
+            return 0
+        }
+
+        override fun setup(s: String): Long {
+            val serviceControl = serviceControl?.get() ?: return -1
+            //Logger.d(s)
+            return try {
+                serviceControl.startService()
+                lastQueryTime = System.currentTimeMillis()
+                startSpeedNotification()
+                0
+            } catch (e: Exception) {
+                Log.d(ANG_PACKAGE, e.toString())
+                -1
+            }
+        }
+    }
+
+    fun startV2rayPoint() {
+        val service = serviceControl?.get()?.getService() ?: return
+        val guid = mainStorage?.decodeString(MmkvManager.KEY_SELECTED_SERVER) ?: return
+        val config = MmkvManager.decodeServerConfig(guid) ?: return
+        if (!v2rayPoint.isRunning) {
+            val result = V2rayConfigUtil.getV2rayConfig(service, guid)
+            if (!result.status)
+                return
+
+            try {
+                val mFilter = IntentFilter(AppConfig.BROADCAST_ACTION_SERVICE)
+                mFilter.addAction(Intent.ACTION_SCREEN_ON)
+                mFilter.addAction(Intent.ACTION_SCREEN_OFF)
+                mFilter.addAction(Intent.ACTION_USER_PRESENT)
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                    service.registerReceiver(mMsgReceive, mFilter, Context.RECEIVER_EXPORTED)
+                } else {
+                    service.registerReceiver(mMsgReceive, mFilter)
+                }
+            } catch (e: Exception) {
+                Log.d(ANG_PACKAGE, e.toString())
+            }
+
+            v2rayPoint.configureFileContent = result.content
+            v2rayPoint.domainName = config.getV2rayPointDomainAndPort()
+            currentConfig = config
+
+            try {
+                v2rayPoint.runLoop(settingsStorage?.decodeBool(AppConfig.PREF_PREFER_IPV6) ?: false)
+            } catch (e: Exception) {
+                Log.d(ANG_PACKAGE, e.toString())
+            }
+
+            if (v2rayPoint.isRunning) {
+                MessageUtil.sendMsg2UI(service, AppConfig.MSG_STATE_START_SUCCESS, "")
+                showNotification()
+            } else {
+                MessageUtil.sendMsg2UI(service, AppConfig.MSG_STATE_START_FAILURE, "")
+                cancelNotification()
+            }
+        }
+    }
+
+    fun stopV2rayPoint() {
+        val service = serviceControl?.get()?.getService() ?: return
+
+        if (v2rayPoint.isRunning) {
+            GlobalScope.launch(Dispatchers.Default) {
+                try {
+                    v2rayPoint.stopLoop()
+                } catch (e: Exception) {
+                    Log.d(ANG_PACKAGE, e.toString())
+                }
+            }
+        }
+
+        MessageUtil.sendMsg2UI(service, AppConfig.MSG_STATE_STOP_SUCCESS, "")
+        cancelNotification()
+
+        try {
+            service.unregisterReceiver(mMsgReceive)
+        } catch (e: Exception) {
+            Log.d(ANG_PACKAGE, e.toString())
+        }
+    }
+
+    private class ReceiveMessageHandler : BroadcastReceiver() {
+        override fun onReceive(ctx: Context?, intent: Intent?) {
+            val serviceControl = serviceControl?.get() ?: return
+            when (intent?.getIntExtra("key", 0)) {
+                AppConfig.MSG_REGISTER_CLIENT -> {
+                    //Logger.e("ReceiveMessageHandler", intent?.getIntExtra("key", 0).toString())
+                    if (v2rayPoint.isRunning) {
+                        MessageUtil.sendMsg2UI(serviceControl.getService(), AppConfig.MSG_STATE_RUNNING, "")
+                    } else {
+                        MessageUtil.sendMsg2UI(serviceControl.getService(), AppConfig.MSG_STATE_NOT_RUNNING, "")
+                    }
+                }
+                AppConfig.MSG_UNREGISTER_CLIENT -> {
+                    // nothing to do
+                }
+                AppConfig.MSG_STATE_START -> {
+                    // nothing to do
+                }
+                AppConfig.MSG_STATE_STOP -> {
+                    serviceControl.stopService()
+                }
+                AppConfig.MSG_STATE_RESTART -> {
+                    startV2rayPoint()
+                }
+                AppConfig.MSG_MEASURE_DELAY -> {
+                    measureV2rayDelay()
+                }
+            }
+
+            when (intent?.action) {
+                Intent.ACTION_SCREEN_OFF -> {
+                    Log.d(ANG_PACKAGE, "SCREEN_OFF, stop querying stats")
+                    stopSpeedNotification()
+                }
+                Intent.ACTION_SCREEN_ON -> {
+                    Log.d(ANG_PACKAGE, "SCREEN_ON, start querying stats")
+                    startSpeedNotification()
+                }
+            }
+        }
+    }
+
+    private fun measureV2rayDelay() {
+        GlobalScope.launch(Dispatchers.IO) {
+            val service = serviceControl?.get()?.getService() ?: return@launch
+            var time = -1L
+            var errstr = ""
+            if (v2rayPoint.isRunning) {
+                try {
+                    time = v2rayPoint.measureDelay()
+                } catch (e: Exception) {
+                    Log.d(ANG_PACKAGE, "measureV2rayDelay: $e")
+                    errstr = e.message?.substringAfter("\":") ?: "empty message"
+                }
+            }
+            val result = if (time == -1L) {
+                service.getString(R.string.connection_test_error, errstr)
+            } else {
+                service.getString(R.string.connection_test_available, time)
+            }
+
+            MessageUtil.sendMsg2UI(service, AppConfig.MSG_MEASURE_DELAY_SUCCESS, result)
+        }
+    }
+
+    private fun showNotification() {
+        val service = serviceControl?.get()?.getService() ?: return
+        val startMainIntent = Intent(service, MainActivity::class.java)
+        val contentPendingIntent = PendingIntent.getActivity(service,
+                NOTIFICATION_PENDING_INTENT_CONTENT, startMainIntent,
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
+            } else {
+                PendingIntent.FLAG_UPDATE_CURRENT
+            })
+
+        val stopV2RayIntent = Intent(AppConfig.BROADCAST_ACTION_SERVICE)
+        stopV2RayIntent.`package` = ANG_PACKAGE
+        stopV2RayIntent.putExtra("key", AppConfig.MSG_STATE_STOP)
+
+        val stopV2RayPendingIntent = PendingIntent.getBroadcast(service,
+                NOTIFICATION_PENDING_INTENT_STOP_V2RAY, stopV2RayIntent,
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
+            } else {
+                PendingIntent.FLAG_UPDATE_CURRENT
+            })
+
+        val channelId =
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                    createNotificationChannel()
+                } else {
+                    // If earlier version channel ID is not used
+                    // https://developer.android.com/reference/android/support/v4/app/NotificationCompat.Builder.html#NotificationCompat.Builder(android.content.Context)
+                    ""
+                }
+
+        mBuilder = NotificationCompat.Builder(service, channelId)
+                .setSmallIcon(R.drawable.ic_stat_name)
+                .setContentTitle(currentConfig?.remarks)
+                .setPriority(NotificationCompat.PRIORITY_MIN)
+                .setOngoing(true)
+                .setShowWhen(false)
+                .setOnlyAlertOnce(true)
+                .setContentIntent(contentPendingIntent)
+                .addAction(R.drawable.ic_close_grey_800_24dp,
+                        service.getString(R.string.notification_action_stop_v2ray),
+                        stopV2RayPendingIntent)
+        //.build()
+
+        //mBuilder?.setDefaults(NotificationCompat.FLAG_ONLY_ALERT_ONCE)  //取消震动,铃声其他都不好使
+
+        service.startForeground(NOTIFICATION_ID, mBuilder?.build())
+    }
+
+    @RequiresApi(Build.VERSION_CODES.O)
+    private fun createNotificationChannel(): String {
+        val channelId = "RAY_NG_M_CH_ID"
+        val channelName = "V2rayNG Background Service"
+        val chan = NotificationChannel(channelId,
+                channelName, NotificationManager.IMPORTANCE_HIGH)
+        chan.lightColor = Color.DKGRAY
+        chan.importance = NotificationManager.IMPORTANCE_NONE
+        chan.lockscreenVisibility = Notification.VISIBILITY_PRIVATE
+        getNotificationManager()?.createNotificationChannel(chan)
+        return channelId
+    }
+
+    fun cancelNotification() {
+        val service = serviceControl?.get()?.getService() ?: return
+        service.stopForeground(true)
+        mBuilder = null
+        mSubscription?.unsubscribe()
+        mSubscription = null
+    }
+
+    private fun updateNotification(contentText: String?, proxyTraffic: Long, directTraffic: Long) {
+        if (mBuilder != null) {
+            if (proxyTraffic < NOTIFICATION_ICON_THRESHOLD && directTraffic < NOTIFICATION_ICON_THRESHOLD) {
+                mBuilder?.setSmallIcon(R.drawable.ic_stat_name)
+            } else if (proxyTraffic > directTraffic) {
+                mBuilder?.setSmallIcon(R.drawable.ic_stat_proxy)
+            } else {
+                mBuilder?.setSmallIcon(R.drawable.ic_stat_direct)
+            }
+            mBuilder?.setStyle(NotificationCompat.BigTextStyle().bigText(contentText))
+            mBuilder?.setContentText(contentText) // Emui4.1 need content text even if style is set as BigTextStyle
+            getNotificationManager()?.notify(NOTIFICATION_ID, mBuilder?.build())
+        }
+    }
+
+    private fun getNotificationManager(): NotificationManager? {
+        if (mNotificationManager == null) {
+            val service = serviceControl?.get()?.getService() ?: return null
+            mNotificationManager = service.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        }
+        return mNotificationManager
+    }
+
+    private fun startSpeedNotification() {
+        if (mSubscription == null &&
+                v2rayPoint.isRunning &&
+                settingsStorage?.decodeBool(AppConfig.PREF_SPEED_ENABLED) == true) {
+            var lastZeroSpeed = false
+            val outboundTags = currentConfig?.getAllOutboundTags()
+            outboundTags?.remove(TAG_DIRECT)
+
+            mSubscription = Observable.interval(3, java.util.concurrent.TimeUnit.SECONDS)
+                    .subscribe {
+                        val queryTime = System.currentTimeMillis()
+                        val sinceLastQueryInSeconds = (queryTime - lastQueryTime) / 1000.0
+                        var proxyTotal = 0L
+                        val text = StringBuilder()
+                        outboundTags?.forEach {
+                            val up = v2rayPoint.queryStats(it, "uplink")
+                            val down = v2rayPoint.queryStats(it, "downlink")
+                            if (up + down > 0) {
+                                appendSpeedString(text, it, up / sinceLastQueryInSeconds, down / sinceLastQueryInSeconds)
+                                proxyTotal += up + down
+                            }
+                        }
+                        val directUplink = v2rayPoint.queryStats(TAG_DIRECT, "uplink")
+                        val directDownlink = v2rayPoint.queryStats(TAG_DIRECT, "downlink")
+                        val zeroSpeed = proxyTotal == 0L && directUplink == 0L && directDownlink == 0L
+                        if (!zeroSpeed || !lastZeroSpeed) {
+                            if (proxyTotal == 0L) {
+                                appendSpeedString(text, outboundTags?.firstOrNull(), 0.0, 0.0)
+                            }
+                            appendSpeedString(text, TAG_DIRECT, directUplink / sinceLastQueryInSeconds,
+                                    directDownlink / sinceLastQueryInSeconds)
+                            updateNotification(text.toString(), proxyTotal, directDownlink + directUplink)
+                        }
+                        lastZeroSpeed = zeroSpeed
+                        lastQueryTime = queryTime
+                    }
+        }
+    }
+
+    private fun appendSpeedString(text: StringBuilder, name: String?, up: Double, down: Double) {
+        var n = name ?: "no tag"
+        n = n.substring(0, min(n.length, 6))
+        text.append(n)
+        for (i in n.length..6 step 2) {
+            text.append("\t")
+        }
+        text.append("•  ${up.toLong().toSpeedString()}↑  ${down.toLong().toSpeedString()}↓\n")
+    }
+
+    private fun stopSpeedNotification() {
+        if (mSubscription != null) {
+            mSubscription?.unsubscribe() //stop queryStats
+            mSubscription = null
+            updateNotification(currentConfig?.remarks, 0, 0)
+        }
+    }
+}

V2rayNG/app/src/main/kotlin/com/v2ray/ang/service/V2RayTestService.kt

@@ -0,0 +1,45 @@
+package com.v2ray.ang.service
+
+import android.app.Service
+import android.content.Intent
+import android.os.IBinder
+import com.v2ray.ang.AppConfig.MSG_MEASURE_CONFIG
+import com.v2ray.ang.AppConfig.MSG_MEASURE_CONFIG_CANCEL
+import com.v2ray.ang.AppConfig.MSG_MEASURE_CONFIG_SUCCESS
+import com.v2ray.ang.util.MessageUtil
+import com.v2ray.ang.util.SpeedtestUtil
+import com.v2ray.ang.util.Utils
+import go.Seq
+import kotlinx.coroutines.*
+import libv2ray.Libv2ray
+import java.util.concurrent.Executors
+
+class V2RayTestService : Service() {
+    private val realTestScope by lazy { CoroutineScope(Executors.newFixedThreadPool(10).asCoroutineDispatcher()) }
+
+    override fun onCreate() {
+        super.onCreate()
+        Seq.setContext(this)
+        Libv2ray.initV2Env(Utils.userAssetPath(this), Utils.getDeviceIdForXUDPBaseKey())
+    }
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        when (intent?.getIntExtra("key", 0)) {
+            MSG_MEASURE_CONFIG -> {
+                val contentPair = intent.getSerializableExtra("content") as Pair<String, String>
+                realTestScope.launch {
+                    val result = SpeedtestUtil.realPing(contentPair.second)
+                    MessageUtil.sendMsg2UI(this@V2RayTestService, MSG_MEASURE_CONFIG_SUCCESS, Pair(contentPair.first, result))
+                }
+            }
+            MSG_MEASURE_CONFIG_CANCEL -> {
+                realTestScope.coroutineContext[Job]?.cancelChildren()
+            }
+        }
+        return super.onStartCommand(intent, flags, startId)
+    }
+
+    override fun onBind(intent: Intent?): IBinder? {
+        return null
+    }
+}

V2rayNG/app/src/main/kotlin/com/v2ray/ang/service/V2RayVpnService.kt

@@ -1,124 +1,107 @@
 package com.v2ray.ang.service
 
-import android.app.Notification
-import android.app.NotificationChannel
-import android.app.NotificationManager
-import android.app.PendingIntent
-import android.content.BroadcastReceiver
+import android.app.Service
 import android.content.Context
 import android.content.Intent
-import android.content.IntentFilter
 import android.content.pm.PackageManager
-import android.graphics.Color
 import android.net.*
-import android.net.VpnService
-import android.os.*
-import android.support.annotation.RequiresApi
-import android.support.v4.app.NotificationCompat
+import android.os.Build
+import android.os.ParcelFileDescriptor
+import android.os.StrictMode
+import android.util.Log
+import androidx.annotation.RequiresApi
+import com.tencent.mmkv.MMKV
 import com.v2ray.ang.AppConfig
 import com.v2ray.ang.R
-import com.v2ray.ang.extension.defaultDPreference
-import com.v2ray.ang.extension.toSpeedString
-import com.v2ray.ang.ui.MainActivity
-import com.v2ray.ang.ui.PerAppProxyActivity
-import com.v2ray.ang.ui.SettingsActivity
-import com.v2ray.ang.util.MessageUtil
+import com.v2ray.ang.dto.ERoutingMode
+import com.v2ray.ang.util.MmkvManager
+import com.v2ray.ang.util.MyContextWrapper
 import com.v2ray.ang.util.Utils
-import libv2ray.Libv2ray
-import libv2ray.V2RayVPNServiceSupportsSet
-import rx.Observable
-import rx.Subscription
-import java.net.InetAddress
-import java.io.IOException
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.launch
 import java.io.File
-import java.io.FileDescriptor
-import java.io.FileInputStream
 import java.lang.ref.SoftReference
-import android.os.Build
-import android.annotation.TargetApi
-import android.util.Log
-import org.jetbrains.anko.doAsync
 
-class V2RayVpnService : VpnService() {
+class V2RayVpnService : VpnService(), ServiceControl {
     companion object {
-        const val NOTIFICATION_ID = 1
-        const val NOTIFICATION_PENDING_INTENT_CONTENT = 0
-        const val NOTIFICATION_PENDING_INTENT_STOP_V2RAY = 1
+        private const val VPN_MTU = 1500
+        private const val PRIVATE_VLAN4_CLIENT = "26.26.26.1"
+        private const val PRIVATE_VLAN4_ROUTER = "26.26.26.2"
+        private const val PRIVATE_VLAN6_CLIENT = "da26:2626::1"
+        private const val PRIVATE_VLAN6_ROUTER = "da26:2626::2"
+        private const val TUN2SOCKS = "libtun2socks.so"
+    }
 
-        fun startV2Ray(context: Context) {
-            val intent = Intent(context.applicationContext, V2RayVpnService::class.java)
-            if (Build.VERSION.SDK_INT > Build.VERSION_CODES.N_MR1) {
-                context.startForegroundService(intent)
-            } else {
-                context.startService(intent)
+    private val settingsStorage by lazy { MMKV.mmkvWithID(MmkvManager.ID_SETTING, MMKV.MULTI_PROCESS_MODE) }
+
+    private lateinit var mInterface: ParcelFileDescriptor
+    private var isRunning = false
+
+    //val fd: Int get() = mInterface.fd
+    private lateinit var process: Process
+
+    /**destroy
+     * Unfortunately registerDefaultNetworkCallback is going to return our VPN interface: https://android.googlesource.com/platform/frameworks/base/+/dda156ab0c5d66ad82bdcf76cda07cbc0a9c8a2e
+     *
+     * This makes doing a requestNetwork with REQUEST necessary so that we don't get ALL possible networks that
+     * satisfies default network capabilities but only THE default network. Unfortunately we need to have
+     * android.permission.CHANGE_NETWORK_STATE to be able to call requestNetwork.
+     *
+     * Source: https://android.googlesource.com/platform/frameworks/base/+/2df4c7d/services/core/java/com/android/server/ConnectivityService.java#887
+     */
+    @delegate:RequiresApi(Build.VERSION_CODES.P)
+    private val defaultNetworkRequest by lazy {
+        NetworkRequest.Builder()
+                .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
+                .addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED)
+                .build()
+    }
+
+    private val connectivity by lazy { getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager }
+
+    @delegate:RequiresApi(Build.VERSION_CODES.P)
+    private val defaultNetworkCallback by lazy {
+        object : ConnectivityManager.NetworkCallback() {
+            override fun onAvailable(network: Network) {
+                setUnderlyingNetworks(arrayOf(network))
+            }
+
+            override fun onCapabilitiesChanged(network: Network, networkCapabilities: NetworkCapabilities) {
+                // it's a good idea to refresh capabilities
+                setUnderlyingNetworks(arrayOf(network))
+            }
+
+            override fun onLost(network: Network) {
+                setUnderlyingNetworks(null)
             }
         }
     }
 
-    private val v2rayPoint = Libv2ray.newV2RayPoint()
-    private val v2rayCallback = V2RayCallback()
-    private lateinit var configContent: String
-    private lateinit var mInterface: ParcelFileDescriptor
-    val fd: Int get() = mInterface.fd
-    private var mBuilder: NotificationCompat.Builder? = null
-    private var mSubscription: Subscription? = null
-    private var mNotificationManager: NotificationManager? = null
-
-
-
-    /**
-        * Unfortunately registerDefaultNetworkCallback is going to return our VPN interface: https://android.googlesource.com/platform/frameworks/base/+/dda156ab0c5d66ad82bdcf76cda07cbc0a9c8a2e
-        *
-        * This makes doing a requestNetwork with REQUEST necessary so that we don't get ALL possible networks that
-        * satisfies default network capabilities but only THE default network. Unfortunately we need to have
-        * android.permission.CHANGE_NETWORK_STATE to be able to call requestNetwork.
-        *
-        * Source: https://android.googlesource.com/platform/frameworks/base/+/2df4c7d/services/core/java/com/android/server/ConnectivityService.java#887
-        */
-    @TargetApi(28)
-    private val defaultNetworkRequest = NetworkRequest.Builder()
-            .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
-            .addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED)
-            .build()
-
-
-    private val connectivity by lazy { getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager }
-    @TargetApi(28)
-    private val defaultNetworkCallback = object : ConnectivityManager.NetworkCallback() {
-        override fun onAvailable(network: Network) {
-            setUnderlyingNetworks(arrayOf(network))
-        }
-        override fun onCapabilitiesChanged(network: Network, networkCapabilities: NetworkCapabilities?) {
-            // it's a good idea to refresh capabilities
-            setUnderlyingNetworks(arrayOf(network))
-        }
-        override fun onLost(network: Network) {
-            setUnderlyingNetworks(null)
-        }
-    }
-    private var listeningForDefaultNetwork = false
-
     override fun onCreate() {
         super.onCreate()
 
         val policy = StrictMode.ThreadPolicy.Builder().permitAll().build()
         StrictMode.setThreadPolicy(policy)
-        v2rayPoint.packageName = Utils.packagePath(applicationContext)
+        V2RayServiceManager.serviceControl = SoftReference(this)
     }
 
     override fun onRevoke() {
         stopV2Ray()
     }
 
+//    override fun onLowMemory() {
+//        stopV2Ray()
+//        super.onLowMemory()
+//    }
+
     override fun onDestroy() {
         super.onDestroy()
-
-        cancelNotification()
+        V2RayServiceManager.cancelNotification()
     }
 
-    fun setup(parameters: String) {
-
-        val prepare = VpnService.prepare(this)
+    private fun setup() {
+        val prepare = prepare(this)
         if (prepare != null) {
             return
         }
@@ -126,33 +109,47 @@ class V2RayVpnService : VpnService() {
         // If the old interface has exactly the same parameters, use it!
         // Configure a builder while parsing the parameters.
         val builder = Builder()
-        val enableLocalDns = defaultDPreference.getPrefBoolean(SettingsActivity.PREF_LOCAL_DNS_ENABLED, false)
+        //val enableLocalDns = defaultDPreference.getPrefBoolean(AppConfig.PREF_LOCAL_DNS_ENABLED, false)
 
-        parameters.split(" ")
-                .map { it.split(",") }
-                .forEach {
-                    when (it[0][0]) {
-                        'm' -> builder.setMtu(java.lang.Short.parseShort(it[1]).toInt())
-                        's' -> builder.addSearchDomain(it[1])
-                        'a' -> builder.addAddress(it[1], Integer.parseInt(it[2]))
-                        'r' -> builder.addRoute(it[1], Integer.parseInt(it[2]))
-                        'd' -> builder.addDnsServer(it[1])
-                    }
-                }
+        val routingMode = settingsStorage?.decodeString(AppConfig.PREF_ROUTING_MODE) ?: ERoutingMode.GLOBAL_PROXY.value
 
-        if(!enableLocalDns) {
-            Utils.getRemoteDnsServers(defaultDPreference)
-                .forEach {
-                    builder.addDnsServer(it)
-                }
+        builder.setMtu(VPN_MTU)
+        builder.addAddress(PRIVATE_VLAN4_CLIENT, 30)
+        //builder.addDnsServer(PRIVATE_VLAN4_ROUTER)
+        if (routingMode == ERoutingMode.BYPASS_LAN.value || routingMode == ERoutingMode.BYPASS_LAN_MAINLAND.value) {
+            resources.getStringArray(R.array.bypass_private_ip_address).forEach {
+                val addr = it.split('/')
+                builder.addRoute(addr[0], addr[1].toInt())
+            }
+        } else {
+            builder.addRoute("0.0.0.0", 0)
         }
 
-        builder.setSession(defaultDPreference.getPrefString(AppConfig.PREF_CURR_CONFIG_NAME, ""))
+        if (settingsStorage?.decodeBool(AppConfig.PREF_PREFER_IPV6) == true) {
+            builder.addAddress(PRIVATE_VLAN6_CLIENT, 126)
+            if (routingMode == ERoutingMode.BYPASS_LAN.value || routingMode == ERoutingMode.BYPASS_LAN_MAINLAND.value) {
+                builder.addRoute("2000::", 3) //currently only 1/8 of total ipV6 is in use
+            } else {
+                builder.addRoute("::", 0)
+            }
+        }
 
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP &&
-                defaultDPreference.getPrefBoolean(SettingsActivity.PREF_PER_APP_PROXY, false)) {
-            val apps = defaultDPreference.getPrefStringSet(PerAppProxyActivity.PREF_PER_APP_PROXY_SET, null)
-            val bypassApps = defaultDPreference.getPrefBoolean(PerAppProxyActivity.PREF_BYPASS_APPS, false)
+        if (settingsStorage?.decodeBool(AppConfig.PREF_LOCAL_DNS_ENABLED) == true) {
+            builder.addDnsServer(PRIVATE_VLAN4_ROUTER)
+        } else {
+            Utils.getVpnDnsServers()
+                    .forEach {
+                        if (Utils.isPureIpAddress(it)) {
+                            builder.addDnsServer(it)
+                        }
+                    }
+        }
+
+        builder.setSession(V2RayServiceManager.currentConfig?.remarks.orEmpty())
+
+        if (settingsStorage?.decodeBool(AppConfig.PREF_PER_APP_PROXY) == true) {
+            val apps = settingsStorage?.decodeStringSet(AppConfig.PREF_PER_APP_PROXY_SET)
+            val bypassApps = settingsStorage?.decodeBool(AppConfig.PREF_BYPASS_APPS) ?: false
             apps?.forEach {
                 try {
                     if (bypassApps)
@@ -169,44 +166,88 @@ class V2RayVpnService : VpnService() {
         try {
             mInterface.close()
         } catch (ignored: Exception) {
+            // ignored
         }
 
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+            try {
+                connectivity.requestNetwork(defaultNetworkRequest, defaultNetworkCallback)
+            } catch (e: Exception) {
+                e.printStackTrace()
+            }
+        }
 
-        if (Build.VERSION.SDK_INT >= 28) {
-            connectivity.requestNetwork(defaultNetworkRequest, defaultNetworkCallback)
-            listeningForDefaultNetwork = true
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            builder.setMetered(false)
         }
 
         // Create a new interface using the builder and save the parameters.
-        mInterface = builder.establish()
-        sendFd()
-
-        if (defaultDPreference.getPrefBoolean(SettingsActivity.PREF_SPEED_ENABLED, false)) {
-            mSubscription = Observable.interval(3, java.util.concurrent.TimeUnit.SECONDS)
-                    .subscribe {
-                        val uplink = v2rayPoint.queryStats("socks", "uplink")
-                        val downlink = v2rayPoint.queryStats("socks", "downlink")
-                        updateNotification("${(uplink / 3).toSpeedString()} ↑  ${(downlink / 3).toSpeedString()} ↓")
-                    }
-        }
-    }
-
-    fun shutdown() {
         try {
-            mInterface.close()
-        } catch (ignored: Exception) {
+            mInterface = builder.establish()!!
+            isRunning = true
+            runTun2socks()
+        } catch (e: Exception) {
+            // non-nullable lateinit var
+            e.printStackTrace()
+            stopV2Ray()
         }
     }
 
-    fun sendFd() {
-        val fd = mInterface.fileDescriptor
-        val path = File(Utils.packagePath(applicationContext), "sock_path").absolutePath
+    private fun runTun2socks() {
+        val socksPort = Utils.parseInt(settingsStorage?.decodeString(AppConfig.PREF_SOCKS_PORT), AppConfig.PORT_SOCKS.toInt())
+        val cmd = arrayListOf(File(applicationContext.applicationInfo.nativeLibraryDir, TUN2SOCKS).absolutePath,
+                "--netif-ipaddr", PRIVATE_VLAN4_ROUTER,
+                "--netif-netmask", "255.255.255.252",
+                "--socks-server-addr", "127.0.0.1:${socksPort}",
+                "--tunmtu", VPN_MTU.toString(),
+                "--sock-path", "sock_path",//File(applicationContext.filesDir, "sock_path").absolutePath,
+                "--enable-udprelay",
+                "--loglevel", "notice")
 
-        doAsync {
+        if (settingsStorage?.decodeBool(AppConfig.PREF_PREFER_IPV6) == true) {
+            cmd.add("--netif-ip6addr")
+            cmd.add(PRIVATE_VLAN6_ROUTER)
+        }
+        if (settingsStorage?.decodeBool(AppConfig.PREF_LOCAL_DNS_ENABLED) == true) {
+            val localDnsPort = Utils.parseInt(settingsStorage?.decodeString(AppConfig.PREF_LOCAL_DNS_PORT), AppConfig.PORT_LOCAL_DNS.toInt())
+            cmd.add("--dnsgw")
+            cmd.add("127.0.0.1:${localDnsPort}")
+        }
+        Log.d(packageName, cmd.toString())
+
+        try {
+            val proBuilder = ProcessBuilder(cmd)
+            proBuilder.redirectErrorStream(true)
+            process = proBuilder
+                    .directory(applicationContext.filesDir)
+                    .start()
+            Thread(Runnable {
+                Log.d(packageName,"$TUN2SOCKS check")
+                process.waitFor()
+                Log.d(packageName,"$TUN2SOCKS exited")
+                if (isRunning) {
+                    Log.d(packageName,"$TUN2SOCKS restart")
+                    runTun2socks()
+                }
+            }).start()
+            Log.d(packageName, process.toString())
+
+            sendFd()
+        } catch (e: Exception) {
+            Log.d(packageName, e.toString())
+        }
+    }
+
+    private fun sendFd() {
+        val fd = mInterface.fileDescriptor
+        val path = File(applicationContext.filesDir, "sock_path").absolutePath
+        Log.d(packageName, path)
+
+        GlobalScope.launch(Dispatchers.IO) {
             var tries = 0
             while (true) try {
                 Thread.sleep(50L shl tries)
-                Log.d(packageName, "sendFd tries: " + tries.toString())
+                Log.d(packageName, "sendFd tries: $tries")
                 LocalSocket().use { localSocket ->
                     localSocket.connect(LocalSocketAddress(path, LocalSocketAddress.Namespace.FILESYSTEM))
                     localSocket.setFileDescriptorsForSend(arrayOf(fd))
@@ -222,232 +263,71 @@ class V2RayVpnService : VpnService() {
     }
 
     override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
-        startV2ray()
+        V2RayServiceManager.startV2rayPoint()
         return START_STICKY
         //return super.onStartCommand(intent, flags, startId)
     }
 
-    private fun startV2ray() {
-        if (!v2rayPoint.isRunning) {
-
-            try {
-                registerReceiver(mMsgReceive, IntentFilter(AppConfig.BROADCAST_ACTION_SERVICE))
-            } catch (e: Exception) {
-            }
-
-            configContent = defaultDPreference.getPrefString(AppConfig.PREF_CURR_CONFIG, "")
-            v2rayPoint.supportSet = v2rayCallback
-            v2rayPoint.configureFileContent = configContent
-            v2rayPoint.enableLocalDNS = defaultDPreference.getPrefBoolean(SettingsActivity.PREF_LOCAL_DNS_ENABLED, false)
-            v2rayPoint.forwardIpv6 = defaultDPreference.getPrefBoolean(SettingsActivity.PREF_FORWARD_IPV6, false)
-            v2rayPoint.domainName = defaultDPreference.getPrefString(AppConfig.PREF_CURR_CONFIG_DOMAIN, "")
-
-            try {
-                v2rayPoint.runLoop()
-            } catch (e: Exception) {
-                Log.d(packageName, e.toString())
-            }
-
-            if (v2rayPoint.isRunning) {
-                MessageUtil.sendMsg2UI(this, AppConfig.MSG_STATE_START_SUCCESS, "")
-                showNotification()
-            } else {
-                MessageUtil.sendMsg2UI(this, AppConfig.MSG_STATE_START_FAILURE, "")
-                cancelNotification()
-            }
-        }
-        //        showNotification()
-    }
-
     private fun stopV2Ray(isForced: Boolean = true) {
 //        val configName = defaultDPreference.getPrefString(PREF_CURR_CONFIG_GUID, "")
 //        val emptyInfo = VpnNetworkInfo()
 //        val info = loadVpnNetworkInfo(configName, emptyInfo)!! + (lastNetworkInfo ?: emptyInfo)
 //        saveVpnNetworkInfo(configName, info)
-        if (Build.VERSION.SDK_INT >= 28) {
-            if (listeningForDefaultNetwork) {
-                connectivity.unregisterNetworkCallback(defaultNetworkCallback)
-                listeningForDefaultNetwork = false
-            }
-        }
-        if (v2rayPoint.isRunning) {
+        isRunning = false;
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
             try {
-                v2rayPoint.stopLoop()
-            } catch (e: Exception) {
-                Log.d(packageName, e.toString())
+                connectivity.unregisterNetworkCallback(defaultNetworkCallback)
+            } catch (ignored: Exception) {
+                // ignored
             }
         }
 
-        MessageUtil.sendMsg2UI(this, AppConfig.MSG_STATE_STOP_SUCCESS, "")
-        cancelNotification()
+        try {
+            Log.d(packageName, "tun2socks destroy")
+            process.destroy()
+        } catch (e: Exception) {
+            Log.d(packageName, e.toString())
+        }
+
+        V2RayServiceManager.stopV2rayPoint()
 
         if (isForced) {
-            try {
-                unregisterReceiver(mMsgReceive)
-            } catch (e: Exception) {
-            }
+            //stopSelf has to be called ahead of mInterface.close(). otherwise v2ray core cannot be stooped
+            //It's strage but true.
+            //This can be verified by putting stopself() behind and call stopLoop and startLoop
+            //in a row for several times. You will find that later created v2ray core report port in use
+            //which means the first v2ray core somehow failed to stop and release the port.
+            stopSelf()
+
             try {
                 mInterface.close()
             } catch (ignored: Exception) {
-            }
-
-            stopSelf()
-        }
-    }
-
-    private fun showNotification() {
-        val startMainIntent = Intent(applicationContext, MainActivity::class.java)
-        val contentPendingIntent = PendingIntent.getActivity(applicationContext,
-                NOTIFICATION_PENDING_INTENT_CONTENT, startMainIntent,
-                PendingIntent.FLAG_UPDATE_CURRENT)
-
-        val stopV2RayIntent = Intent(AppConfig.BROADCAST_ACTION_SERVICE)
-        stopV2RayIntent.`package` = AppConfig.ANG_PACKAGE
-        stopV2RayIntent.putExtra("key", AppConfig.MSG_STATE_STOP)
-
-        val stopV2RayPendingIntent = PendingIntent.getBroadcast(applicationContext,
-                NOTIFICATION_PENDING_INTENT_STOP_V2RAY, stopV2RayIntent,
-                PendingIntent.FLAG_UPDATE_CURRENT)
-
-        val channelId =
-                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-                    createNotificationChannel()
-                } else {
-                    // If earlier version channel ID is not used
-                    // https://developer.android.com/reference/android/support/v4/app/NotificationCompat.Builder.html#NotificationCompat.Builder(android.content.Context)
-                    ""
-                }
-
-        mBuilder = NotificationCompat.Builder(applicationContext, channelId)
-                .setSmallIcon(R.drawable.ic_v)
-                .setContentTitle(defaultDPreference.getPrefString(AppConfig.PREF_CURR_CONFIG_NAME, ""))
-                .setContentText(getString(R.string.notification_action_more))
-                .setPriority(NotificationCompat.PRIORITY_MIN)
-                .setOngoing(true)
-                .setShowWhen(false)
-                .setOnlyAlertOnce(true)
-                .setContentIntent(contentPendingIntent)
-                .addAction(R.drawable.ic_close_grey_800_24dp,
-                        getString(R.string.notification_action_stop_v2ray),
-                        stopV2RayPendingIntent)
-        //.build()
-
-        //mBuilder?.setDefaults(NotificationCompat.FLAG_ONLY_ALERT_ONCE)  //取消震动,铃声其他都不好使
-
-        startForeground(NOTIFICATION_ID, mBuilder?.build())
-    }
-
-    @RequiresApi(Build.VERSION_CODES.O)
-    private fun createNotificationChannel(): String {
-        val channelId = "RAY_NG_M_CH_ID"
-        val channelName = "V2rayNG Background Service"
-        val chan = NotificationChannel(channelId,
-                channelName, NotificationManager.IMPORTANCE_HIGH)
-        chan.lightColor = Color.DKGRAY
-        chan.importance = NotificationManager.IMPORTANCE_NONE
-        chan.lockscreenVisibility = Notification.VISIBILITY_PRIVATE
-        getNotificationManager().createNotificationChannel(chan)
-        return channelId
-    }
-
-    private fun cancelNotification() {
-        stopForeground(true)
-        mBuilder = null
-        mSubscription?.unsubscribe()
-        mSubscription = null
-    }
-
-    private fun updateNotification(contentText: String) {
-        if (mBuilder != null) {
-            mBuilder?.setContentText(contentText)
-            getNotificationManager().notify(NOTIFICATION_ID, mBuilder?.build())
-        }
-    }
-
-    private fun getNotificationManager(): NotificationManager {
-        if (mNotificationManager == null) {
-            mNotificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-        }
-        return mNotificationManager!!
-    }
-
-    private inner class V2RayCallback : V2RayVPNServiceSupportsSet {
-        override fun shutdown(): Long {
-            try {
-                this@V2RayVpnService.shutdown()
-                return 0
-            } catch (e: Exception) {
-                Log.d(packageName, e.toString())
-                return -1
+                // ignored
             }
         }
-
-        override fun prepare(): Long {
-            return 0
-        }
-
-        override fun protect(l: Long) = (if (this@V2RayVpnService.protect(l.toInt())) 0 else 1).toLong()
-
-        override fun onEmitStatus(l: Long, s: String?): Long {
-            //Logger.d(s)
-            return 0
-        }
-
-        override fun setup(s: String): Long {
-            //Logger.d(s)
-            try {
-                this@V2RayVpnService.setup(s)
-                return 0
-            } catch (e: Exception) {
-                Log.d(packageName, e.toString())
-                return -1
-            }
-        }
-
-        override fun sendFd(): Long {
-            try {
-                this@V2RayVpnService.sendFd()
-            } catch (e: Exception) {
-                Log.d(packageName, e.toString())
-                return -1
-            }
-            return 0
-        }
     }
 
-    private var mMsgReceive = ReceiveMessageHandler(this@V2RayVpnService)
+    override fun getService(): Service {
+        return this
+    }
 
-    private class ReceiveMessageHandler(vpnService: V2RayVpnService) : BroadcastReceiver() {
-        internal var mReference: SoftReference<V2RayVpnService> = SoftReference(vpnService)
+    override fun startService() {
+        setup()
+    }
 
-        override fun onReceive(ctx: Context?, intent: Intent?) {
-            val vpnService = mReference.get()
-            when (intent?.getIntExtra("key", 0)) {
-                AppConfig.MSG_REGISTER_CLIENT -> {
-                    //Logger.e("ReceiveMessageHandler", intent?.getIntExtra("key", 0).toString())
+    override fun stopService() {
+        stopV2Ray(true)
+    }
 
-                    val isRunning = vpnService?.v2rayPoint!!.isRunning
-                            && VpnService.prepare(vpnService) == null
-                    if (isRunning) {
-                        MessageUtil.sendMsg2UI(vpnService, AppConfig.MSG_STATE_RUNNING, "")
-                    } else {
-                        MessageUtil.sendMsg2UI(vpnService, AppConfig.MSG_STATE_NOT_RUNNING, "")
-                    }
-                }
-                AppConfig.MSG_UNREGISTER_CLIENT -> {
-//                    vpnService?.mMsgSend = null
-                }
-                AppConfig.MSG_STATE_START -> {
-                    //nothing to do
-                }
-                AppConfig.MSG_STATE_STOP -> {
-                    vpnService?.stopV2Ray()
-                }
-                AppConfig.MSG_STATE_RESTART -> {
-                    vpnService?.startV2ray()
-                }
-            }
+    override fun vpnProtect(socket: Int): Boolean {
+        return protect(socket)
+    }
+
+    @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/BaseActivity.kt

@@ -1,9 +1,26 @@
 package com.v2ray.ang.ui
 
-import android.support.v7.app.AppCompatActivity
+import android.content.Context
+import android.os.Build
+import android.os.Bundle
 import android.view.MenuItem
+import androidx.annotation.RequiresApi
+import androidx.appcompat.app.AppCompatActivity
+import androidx.core.view.WindowCompat
+import com.v2ray.ang.util.MyContextWrapper
+import com.v2ray.ang.util.Utils
 
 abstract class BaseActivity : AppCompatActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        supportActionBar?.setDisplayHomeAsUpEnabled(true)
+        if (!Utils.getDarkModeStatus(this)) {
+            WindowCompat.getInsetsController(window, window.decorView).apply {
+                isAppearanceLightStatusBars = true
+            }
+        }
+    }
+
     override fun onOptionsItemSelected(item: MenuItem) = when (item.itemId) {
         android.R.id.home -> {
             onBackPressed()
@@ -11,4 +28,12 @@ abstract class BaseActivity : AppCompatActivity() {
         }
         else -> super.onOptionsItemSelected(item)
     }
-}
+
+    @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/BaseDrawerActivity.kt

@@ -1,206 +0,0 @@
-package com.v2ray.ang.ui
-
-import android.app.ActivityOptions
-import android.app.FragmentManager
-import android.content.Intent
-import android.content.res.Configuration
-import android.os.Bundle
-import android.support.design.widget.NavigationView
-import android.support.v4.view.GravityCompat
-import android.support.v4.widget.DrawerLayout
-import android.support.v7.app.ActionBarDrawerToggle
-import android.support.v7.widget.Toolbar
-import android.util.Log
-import android.view.MenuItem
-import android.view.View
-import com.v2ray.ang.InappBuyActivity
-
-import com.v2ray.ang.R
-import org.jetbrains.anko.startActivity
-
-
-abstract class BaseDrawerActivity : BaseActivity() {
-    companion object {
-
-        private val TAG = "BaseDrawerActivity"
-    }
-
-    private var mToolbar: Toolbar? = null
-
-    private var mDrawerToggle: ActionBarDrawerToggle? = null
-
-    private var mDrawerLayout: DrawerLayout? = null
-
-    private var mToolbarInitialized: Boolean = false
-
-    private var mItemToOpenWhenDrawerCloses = -1
-
-    private val backStackChangedListener = FragmentManager.OnBackStackChangedListener { updateDrawerToggle() }
-
-    private val drawerListener = object : DrawerLayout.DrawerListener {
-        override fun onDrawerSlide(drawerView: View, slideOffset: Float) {
-            mDrawerToggle!!.onDrawerSlide(drawerView, slideOffset)
-        }
-
-        override fun onDrawerOpened(drawerView: View) {
-            mDrawerToggle!!.onDrawerOpened(drawerView)
-            //supportActionBar!!.setTitle(R.string.app_name)
-        }
-
-        override fun onDrawerClosed(drawerView: View) {
-            mDrawerToggle!!.onDrawerClosed(drawerView)
-
-            if (mItemToOpenWhenDrawerCloses >= 0) {
-                val extras = ActivityOptions.makeCustomAnimation(
-                        this@BaseDrawerActivity, R.anim.fade_in, R.anim.fade_out).toBundle()
-                var activityClass: Class<*>? = null
-                when (mItemToOpenWhenDrawerCloses) {
-                    R.id.server_profile -> activityClass = MainActivity::class.java
-                    R.id.sub_setting -> activityClass = SubSettingActivity::class.java
-                    R.id.settings -> activityClass = SettingsActivity::class.java
-                    R.id.logcat -> {
-                        startActivity<LogcatActivity>()
-                        return
-                    }
-                    R.id.donate -> {
-                        startActivity<InappBuyActivity>()
-                        return
-                    }
-                }
-                if (activityClass != null) {
-                    startActivity(Intent(this@BaseDrawerActivity, activityClass), extras)
-                    finish()
-                }
-            }
-        }
-
-        override fun onDrawerStateChanged(newState: Int) {
-            mDrawerToggle!!.onDrawerStateChanged(newState)
-        }
-    }
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        Log.d(TAG, "Activity onCreate")
-    }
-
-    override fun onStart() {
-        super.onStart()
-        if (!mToolbarInitialized) {
-            throw IllegalStateException("You must run super.initializeToolbar at " + "the end of your onCreate method")
-        }
-    }
-
-    public override fun onResume() {
-        super.onResume()
-        // Whenever the fragment back stack changes, we may need to update the
-        // action bar toggle: only top level screens show the hamburger-like icon, inner
-        // screens - either Activities or fragments - show the "Up" icon instead.
-        fragmentManager.addOnBackStackChangedListener(backStackChangedListener)
-    }
-
-    public override fun onPause() {
-        super.onPause()
-        fragmentManager.removeOnBackStackChangedListener(backStackChangedListener)
-    }
-
-    override fun onPostCreate(savedInstanceState: Bundle?) {
-        super.onPostCreate(savedInstanceState)
-        mDrawerToggle!!.syncState()
-    }
-
-    override fun onConfigurationChanged(newConfig: Configuration) {
-        super.onConfigurationChanged(newConfig)
-        mDrawerToggle!!.onConfigurationChanged(newConfig)
-    }
-
-    override fun onOptionsItemSelected(item: MenuItem): Boolean {
-        if (mDrawerToggle != null && mDrawerToggle!!.onOptionsItemSelected(item)) {
-            return true
-        }
-        // If not handled by drawerToggle, home needs to be handled by returning to previous
-        if (item.itemId == android.R.id.home) {
-            onBackPressed()
-            return true
-        }
-        return super.onOptionsItemSelected(item)
-    }
-
-    override fun onBackPressed() {
-        // If the drawer is open, back will close it
-        if (mDrawerLayout != null && mDrawerLayout!!.isDrawerOpen(GravityCompat.START)) {
-            mDrawerLayout!!.closeDrawers()
-            return
-        }
-        // Otherwise, it may return to the previous fragment stack
-        val fragmentManager = fragmentManager
-        if (fragmentManager.backStackEntryCount > 0) {
-            fragmentManager.popBackStack()
-        } else {
-            // Lastly, it will rely on the system behavior for back
-            super.onBackPressed()
-        }
-    }
-
-    private fun updateDrawerToggle() {
-        if (mDrawerToggle == null) {
-            return
-        }
-        val isRoot = fragmentManager.backStackEntryCount == 0
-        mDrawerToggle!!.isDrawerIndicatorEnabled = isRoot
-
-        supportActionBar!!.setDisplayShowHomeEnabled(!isRoot)
-        supportActionBar!!.setDisplayHomeAsUpEnabled(!isRoot)
-        supportActionBar!!.setHomeButtonEnabled(!isRoot)
-
-        if (isRoot) {
-            mDrawerToggle!!.syncState()
-        }
-    }
-
-    protected fun initializeToolbar() {
-        mToolbar = findViewById<View>(R.id.toolbar) as Toolbar
-        if (mToolbar == null) {
-            throw IllegalStateException("Layout is required to include a Toolbar with id " + "'toolbar'")
-        }
-
-        //        mToolbar.inflateMenu(R.menu.main);
-
-        mDrawerLayout = findViewById<View>(R.id.drawer_layout) as DrawerLayout
-        if (mDrawerLayout != null) {
-            val navigationView = findViewById<View>(R.id.nav_view) as NavigationView
-                    ?: throw IllegalStateException("Layout requires a NavigationView " + "with id 'nav_view'")
-
-            // Create an ActionBarDrawerToggle that will handle opening/closing of the drawer:
-            mDrawerToggle = ActionBarDrawerToggle(this, mDrawerLayout,
-                    mToolbar, R.string.navigation_drawer_open, R.string.navigation_drawer_close)
-
-            mDrawerLayout!!.addDrawerListener(drawerListener)
-
-            populateDrawerItems(navigationView)
-            setSupportActionBar(mToolbar)
-            updateDrawerToggle()
-        } else {
-            setSupportActionBar(mToolbar)
-        }
-
-        mToolbarInitialized = true
-    }
-
-    private fun populateDrawerItems(navigationView: NavigationView) {
-        navigationView.setNavigationItemSelectedListener { menuItem ->
-            menuItem.isChecked = true
-            mItemToOpenWhenDrawerCloses = menuItem.itemId
-            mDrawerLayout!!.closeDrawers()
-            true
-        }
-
-        if (MainActivity::class.java.isAssignableFrom(javaClass)) {
-            navigationView.setCheckedItem(R.id.server_profile)
-        } else if (SubSettingActivity::class.java.isAssignableFrom(javaClass)) {
-            navigationView.setCheckedItem(R.id.sub_setting)
-        } else if (SettingsActivity::class.java.isAssignableFrom(javaClass)) {
-            navigationView.setCheckedItem(R.id.settings)
-        }
-    }
-}

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

@@ -1,21 +1,17 @@
 package com.v2ray.ang.ui
 
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.FragmentActivity
+import androidx.viewpager2.adapter.FragmentStateAdapter
 
-import android.support.v4.app.Fragment
-import android.support.v4.app.FragmentManager
-import android.support.v4.app.FragmentStatePagerAdapter
+class FragmentAdapter(fragmentActivity: FragmentActivity, private val mFragments: List<Fragment>) :
+        FragmentStateAdapter(fragmentActivity) {
 
-class FragmentAdapter(fm: FragmentManager, private val mFragments: List<Fragment>, private val mTitles: List<String>) : FragmentStatePagerAdapter(fm) {
-
-    override fun getItem(position: Int): Fragment {
+    override fun createFragment(position: Int): Fragment {
         return mFragments[position]
     }
 
-    override fun getCount(): Int {
+    override fun getItemCount(): Int {
         return mFragments.size
     }
-
-    override fun getPageTitle(position: Int): CharSequence? {
-        return mTitles[position]
-    }
-}
+}

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

@@ -1,72 +1,91 @@
 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.android.synthetic.main.activity_logcat.*
-import org.jetbrains.anko.doAsync
-import org.jetbrains.anko.toast
-import org.jetbrains.anko.uiThread
+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)
-        setContentView(R.layout.activity_logcat)
+        binding = ActivityLogcatBinding.inflate(layoutInflater)
+        val view = binding.root
+        setContentView(view)
 
         title = getString(R.string.title_logcat)
 
-        supportActionBar?.setDisplayHomeAsUpEnabled(true)
-        logcat()
+        logcat(false)
     }
 
-    private fun logcat() {
+    private fun logcat(shouldFlushLog: Boolean) {
 
         try {
-            pb_waiting.visibility = View.VISIBLE
+            binding.pbWaiting.visibility = View.VISIBLE
 
-            doAsync {
+            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,com.v2ray.ang")
+                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() }
-                uiThread {
-                    tv_logcat.text = allText
-                    tv_logcat.movementMethod = ScrollingMovementMethod()
-                    pb_waiting.visibility = View.GONE
+                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 {
+    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, tv_logcat.text.toString())
+            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

@@ -4,184 +4,229 @@ import android.Manifest
 import android.content.*
 import android.net.Uri
 import android.net.VpnService
-import android.support.v7.widget.LinearLayoutManager
+import androidx.recyclerview.widget.LinearLayoutManager
 import android.view.Menu
 import android.view.MenuItem
 import com.tbruyelle.rxpermissions.RxPermissions
 import com.v2ray.ang.R
-import com.v2ray.ang.util.AngConfigManager
-import com.v2ray.ang.util.Utils
-import kotlinx.android.synthetic.main.activity_main.*
 import android.os.Bundle
 import android.text.TextUtils
 import android.view.KeyEvent
 import com.v2ray.ang.AppConfig
-import com.v2ray.ang.util.MessageUtil
-import com.v2ray.ang.util.V2rayConfigUtil
-import org.jetbrains.anko.*
-import java.lang.ref.SoftReference
-import java.net.URL
-import android.content.IntentFilter
-import android.support.design.widget.NavigationView
-import android.support.v4.view.GravityCompat
-import android.support.v7.app.ActionBarDrawerToggle
-import android.support.v7.widget.helper.ItemTouchHelper
+import android.content.res.ColorStateList
+import android.os.Build
+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 com.v2ray.ang.InappBuyActivity
+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.util.AngConfigManager.configs
+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 {
-    companion object {
-        private const val REQUEST_CODE_VPN_PREPARE = 0
-        private const val REQUEST_SCAN = 1
-        private const val REQUEST_FILE_CHOOSER = 2
-        private const val REQUEST_SCAN_URL = 3
-    }
-
-    var isRunning = false
-        set(value) {
-            field = value
-            adapter.changeable = !value
-            if (value) {
-                fab.imageResource = R.drawable.ic_v
-                tv_test_state.text = getString(R.string.connection_connected)
-            } else {
-                fab.imageResource = R.drawable.ic_v_idle
-                tv_test_state.text = getString(R.string.connection_not_connected)
-            }
-            hideCircle()
-        }
+    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)
-        setContentView(R.layout.activity_main)
+        binding = ActivityMainBinding.inflate(layoutInflater)
+        val view = binding.root
+        setContentView(view)
         title = getString(R.string.title_server)
-        setSupportActionBar(toolbar)
+        setSupportActionBar(binding.toolbar)
 
-        fab.setOnClickListener {
-            if (isRunning) {
+        binding.fab.setOnClickListener {
+            if (mainViewModel.isRunning.value == true) {
                 Utils.stopVService(this)
-            } else {
+            } else if (settingsStorage?.decodeString(AppConfig.PREF_MODE) ?: "VPN" == "VPN") {
                 val intent = VpnService.prepare(this)
                 if (intent == null) {
                     startV2Ray()
                 } else {
-                    startActivityForResult(intent, REQUEST_CODE_VPN_PREPARE)
+                    requestVpnPermission.launch(intent)
                 }
+            } else {
+                startV2Ray()
             }
         }
-        layout_test.setOnClickListener {
-            if (isRunning) {
-                val socksPort = 10808//Utils.parseInt(defaultDPreference.getPrefString(SettingsActivity.PREF_SOCKS_PORT, "10808"))
-
-                tv_test_state.text = getString(R.string.connection_test_testing)
-                doAsync {
-                    val result = Utils.testConnection(this@MainActivity, socksPort)
-                    uiThread {
-                        tv_test_state.text = Utils.getEditable(result)
-                    }
-                }
+        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)
             }
         }
 
-        recycler_view.setHasFixedSize(true)
-        recycler_view.layoutManager = LinearLayoutManager(this)
-        recycler_view.adapter = adapter
+        binding.recyclerView.setHasFixedSize(true)
+        binding.recyclerView.layoutManager = LinearLayoutManager(this)
+        binding.recyclerView.adapter = adapter
 
         val callback = SimpleItemTouchHelperCallback(adapter)
         mItemTouchHelper = ItemTouchHelper(callback)
-        mItemTouchHelper?.attachToRecyclerView(recycler_view)
+        mItemTouchHelper?.attachToRecyclerView(binding.recyclerView)
 
 
         val toggle = ActionBarDrawerToggle(
-                this, drawer_layout, toolbar, R.string.navigation_drawer_open, R.string.navigation_drawer_close)
-        drawer_layout.addDrawerListener(toggle)
+                this, binding.drawerLayout, binding.toolbar, R.string.navigation_drawer_open, R.string.navigation_drawer_close)
+        binding.drawerLayout.addDrawerListener(toggle)
         toggle.syncState()
-        nav_view.setNavigationItemSelectedListener(this)
+        binding.navView.setNavigationItemSelectedListener(this)
+        "v${BuildConfig.VERSION_NAME} (${SpeedtestUtil.getLibVersion()})".also { binding.version.text = it }
+
+        setupViewModel()
+        copyAssets()
+        migrateLegacy()
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            RxPermissions(this)
+                .request(Manifest.permission.POST_NOTIFICATIONS)
+                .subscribe {
+                    if (!it)
+                        toast(R.string.toast_permission_denied)
+                }
+        }
+    }
+
+    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) {
+                if (!Utils.getDarkModeStatus(this)) {
+                    binding.fab.setImageResource(R.drawable.ic_stat_name)
+                }
+                binding.fab.backgroundTintList = ColorStateList.valueOf(ContextCompat.getColor(this, R.color.color_fab_orange))
+                setTestState(getString(R.string.connection_connected))
+                binding.layoutTest.isFocusable = true
+            } else {
+                if (!Utils.getDarkModeStatus(this)) {
+                    binding.fab.setImageResource(R.drawable.ic_stat_name)
+                }
+                binding.fab.backgroundTintList = ColorStateList.valueOf(ContextCompat.getColor(this, R.color.color_fab_grey))
+                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 (AngConfigManager.configs.index < 0) {
+        if (mainStorage?.decodeString(MmkvManager.KEY_SELECTED_SERVER).isNullOrEmpty()) {
             return
         }
         showCircle()
 //        toast(R.string.toast_services_start)
-        if (!Utils.startVService(this)) {
-            hideCircle()
-        }
+        V2RayServiceManager.startV2Ray(this)
+        hideCircle()
     }
 
-    override fun onStart() {
-        super.onStart()
-        isRunning = false
-
-//        val intent = Intent(this.applicationContext, V2RayVpnService::class.java)
-//        intent.`package` = AppConfig.ANG_PACKAGE
-//        bindService(intent, mConnection, BIND_AUTO_CREATE)
-
-        mMsgReceive = ReceiveMessageHandler(this@MainActivity)
-        registerReceiver(mMsgReceive, IntentFilter(AppConfig.BROADCAST_ACTION_ACTIVITY))
-        MessageUtil.sendMsg2Service(this, AppConfig.MSG_REGISTER_CLIENT, "")
-    }
-
-    override fun onStop() {
-        super.onStop()
-        if (mMsgReceive != null) {
-            unregisterReceiver(mMsgReceive)
-            mMsgReceive = null
+    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()
-        adapter.updateConfigList()
+        mainViewModel.reloadServerList()
     }
 
     public override fun onPause() {
         super.onPause()
     }
 
-    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
-        super.onActivityResult(requestCode, resultCode, data)
-        when (requestCode) {
-            REQUEST_CODE_VPN_PREPARE ->
-                if (resultCode == RESULT_OK) {
-                    startV2Ray()
-                }
-            REQUEST_SCAN ->
-                if (resultCode == RESULT_OK) {
-                    importBatchConfig(data?.getStringExtra("SCAN_RESULT"))
-                }
-            REQUEST_FILE_CHOOSER -> {
-                if (resultCode == RESULT_OK) {
-                    val uri = data!!.data
-                    readContentFromUri(uri)
-                }
-            }
-            REQUEST_SCAN_URL ->
-                if (resultCode == RESULT_OK) {
-                    importConfigCustomUrl(data?.getStringExtra("SCAN_RESULT"))
-                }
-        }
-    }
-
-    override fun onCreateOptionsMenu(menu: Menu?): Boolean {
+    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(REQUEST_SCAN)
+            importQRcode(true)
             true
         }
         R.id.import_clipboard -> {
@@ -189,18 +234,27 @@ class MainActivity : BaseActivity(), NavigationView.OnNavigationItemSelectedList
             true
         }
         R.id.import_manually_vmess -> {
-            startActivity<ServerActivity>("position" to -1, "isRunning" to isRunning)
-            adapter.updateConfigList()
+            importManually(EConfigType.VMESS.value)
+            true
+        }
+        R.id.import_manually_vless -> {
+            importManually(EConfigType.VLESS.value)
             true
         }
         R.id.import_manually_ss -> {
-            startActivity<Server3Activity>("position" to -1, "isRunning" to isRunning)
-            adapter.updateConfigList()
+            importManually(EConfigType.SHADOWSOCKS.value)
             true
         }
         R.id.import_manually_socks -> {
-            startActivity<Server4Activity>("position" to -1, "isRunning" to isRunning)
-            adapter.updateConfigList()
+            importManually(EConfigType.SOCKS.value)
+            true
+        }
+        R.id.import_manually_trojan -> {
+            importManually(EConfigType.TROJAN.value)
+            true
+        }
+        R.id.import_manually_wireguard -> {
+            importManually(EConfigType.WIREGUARD.value)
             true
         }
         R.id.import_config_custom_clipboard -> {
@@ -216,7 +270,7 @@ class MainActivity : BaseActivity(), NavigationView.OnNavigationItemSelectedList
             true
         }
         R.id.import_config_custom_url_scan -> {
-            importQRcode(REQUEST_SCAN_URL)
+            importQRcode(false)
             true
         }
 
@@ -231,7 +285,7 @@ class MainActivity : BaseActivity(), NavigationView.OnNavigationItemSelectedList
         }
 
         R.id.export_all -> {
-            if (AngConfigManager.shareAll2Clipboard() == 0) {
+            if (AngConfigManager.shareNonCustomConfigsToClipboard(this, mainViewModel.serverList) == 0) {
                 toast(R.string.toast_success)
             } else {
                 toast(R.string.toast_failure)
@@ -240,39 +294,72 @@ class MainActivity : BaseActivity(), NavigationView.OnNavigationItemSelectedList
         }
 
         R.id.ping_all -> {
-            for (k in 0 until configs.vmess.count()) {
-                configs.vmess[k].testResult = ""
-                adapter.updateConfigList()
-            }
-            for (k in 0 until configs.vmess.count()) {
-                if (configs.vmess[k].configType != AppConfig.EConfigType.Custom) {
-                    doAsync {
-                        configs.vmess[k].testResult = Utils.tcping(configs.vmess[k].address, configs.vmess[k].port)
-                        uiThread {
-                            adapter.updateSelectedItem(k)
-                        }
-                    }
-                }
-            }
+            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_duplicate_config-> {
+            AlertDialog.Builder(this).setMessage(R.string.del_config_comfirm)
+                .setPositiveButton(android.R.string.ok) { _, _ ->
+                    mainViewModel.removeDuplicateServer()
+                }
+                .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
         }
 
-//        R.id.settings -> {
-//            startActivity<SettingsActivity>("isRunning" to isRunning)
-//            true
-//        }
-//        R.id.logcat -> {
-//            startActivity<LogcatActivity>()
-//            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(requestCode: Int): Boolean {
+    fun importQRcode(forConfig: Boolean): Boolean {
 //        try {
 //            startActivityForResult(Intent("com.google.zxing.client.android.SCAN")
 //                    .addCategory(Intent.CATEGORY_DEFAULT)
@@ -282,7 +369,10 @@ class MainActivity : BaseActivity(), NavigationView.OnNavigationItemSelectedList
                 .request(Manifest.permission.CAMERA)
                 .subscribe {
                     if (it)
-                        startActivityForResult<ScannerActivity>(requestCode)
+                        if (forConfig)
+                            scanQRCodeForConfig.launch(Intent(this, ScannerActivity::class.java))
+                        else
+                            scanQRCodeForUrlToCustomConfig.launch(Intent(this, ScannerActivity::class.java))
                     else
                         toast(R.string.toast_permission_denied)
                 }
@@ -290,6 +380,18 @@ class MainActivity : BaseActivity(), NavigationView.OnNavigationItemSelectedList
         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
      */
@@ -306,10 +408,23 @@ class MainActivity : BaseActivity(), NavigationView.OnNavigationItemSelectedList
     }
 
     fun importBatchConfig(server: String?, subid: String = "") {
-        val count = AngConfigManager.importBatchConfig(server, subid)
+        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) {
+            count = AngConfigManager.appendCustomConfigServer(server, subid2)
+        }
         if (count > 0) {
             toast(R.string.toast_success)
-            adapter.updateConfigList()
+            mainViewModel.reloadServerList()
         } else {
             toast(R.string.toast_failure)
         }
@@ -368,9 +483,14 @@ class MainActivity : BaseActivity(), NavigationView.OnNavigationItemSelectedList
                 toast(R.string.toast_invalid_url)
                 return false
             }
-            doAsync {
-                val configText = URL(url).readText()
-                uiThread {
+            lifecycleScope.launch(Dispatchers.IO) {
+                val configText = try {
+                    Utils.getUrlContentWithCustomUserAgent(url)
+                } catch (e: Exception) {
+                    e.printStackTrace()
+                    ""
+                }
+                launch(Dispatchers.Main) {
                     importCustomizeConfig(configText)
                 }
             }
@@ -388,24 +508,33 @@ class MainActivity : BaseActivity(), NavigationView.OnNavigationItemSelectedList
             : Boolean {
         try {
             toast(R.string.title_sub_update)
-            val subItem = AngConfigManager.configs.subItem
-            for (k in 0 until subItem.count()) {
-                if (TextUtils.isEmpty(subItem[k].id)
-                        || TextUtils.isEmpty(subItem[k].remarks)
-                        || TextUtils.isEmpty(subItem[k].url)
+            MmkvManager.decodeSubscriptions().forEach {
+                if (TextUtils.isEmpty(it.first)
+                        || TextUtils.isEmpty(it.second.remarks)
+                        || TextUtils.isEmpty(it.second.url)
                 ) {
-                    continue
+                    return@forEach
                 }
-                val id = subItem[k].id
-                val url = subItem[k].url
+                if (!it.second.enabled) {
+                    return@forEach
+                }
+                val url = Utils.idnToASCII(it.second.url)
                 if (!Utils.isValidUrl(url)) {
-                    continue
+                    return@forEach
                 }
-                Log.d("Main", url)
-                doAsync {
-                    val configText = URL(url).readText()
-                    uiThread {
-                        importBatchConfig(Utils.decode(configText), id)
+                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)
                     }
                 }
             }
@@ -425,26 +554,36 @@ class MainActivity : BaseActivity(), NavigationView.OnNavigationItemSelectedList
         intent.addCategory(Intent.CATEGORY_OPENABLE)
 
         try {
-            startActivityForResult(
-                    Intent.createChooser(intent, getString(R.string.title_file_chooser)),
-                    REQUEST_FILE_CHOOSER)
-        } catch (ex: android.content.ActivityNotFoundException) {
+            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) {
+        val permission = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            Manifest.permission.READ_MEDIA_IMAGES
+        } else {
+            Manifest.permission.READ_EXTERNAL_STORAGE
+        }
         RxPermissions(this)
-                .request(Manifest.permission.READ_EXTERNAL_STORAGE)
+                .request(permission)
                 .subscribe {
                     if (it) {
                         try {
-                            val inputStream = contentResolver.openInputStream(uri)
-                            val configText = inputStream.bufferedReader().readText()
-                            importCustomizeConfig(configText)
+                            contentResolver.openInputStream(uri).use { input ->
+                                importCustomizeConfig(input?.bufferedReader()?.readText())
+                            }
                         } catch (e: Exception) {
                             e.printStackTrace()
                         }
@@ -457,22 +596,26 @@ class MainActivity : BaseActivity(), NavigationView.OnNavigationItemSelectedList
      * import customize config
      */
     fun importCustomizeConfig(server: String?) {
-        if (server == null) {
-            return
-        }
-        if (!V2rayConfigUtil.isValidConfig(server)) {
-            toast(R.string.toast_config_file_invalid)
-            return
-        }
-        val resId = AngConfigManager.importCustomizeConfig(server)
-        if (resId > 0) {
-            toast(resId)
-        } else {
+        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.updateConfigList()
+            //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?) {
 //        }
@@ -482,45 +625,17 @@ class MainActivity : BaseActivity(), NavigationView.OnNavigationItemSelectedList
 //        }
 //    }
 
-    private
-    var mMsgReceive: BroadcastReceiver? = null
-
-    private class ReceiveMessageHandler(activity: MainActivity) : BroadcastReceiver() {
-        internal var mReference: SoftReference<MainActivity> = SoftReference(activity)
-        override fun onReceive(ctx: Context?, intent: Intent?) {
-            val activity = mReference.get()
-            when (intent?.getIntExtra("key", 0)) {
-                AppConfig.MSG_STATE_RUNNING -> {
-                    activity?.isRunning = true
-                }
-                AppConfig.MSG_STATE_NOT_RUNNING -> {
-                    activity?.isRunning = false
-                }
-                AppConfig.MSG_STATE_START_SUCCESS -> {
-                    activity?.toast(R.string.toast_services_success)
-                    activity?.isRunning = true
-                }
-                AppConfig.MSG_STATE_START_FAILURE -> {
-                    activity?.toast(R.string.toast_services_failure)
-                    activity?.isRunning = false
-                }
-                AppConfig.MSG_STATE_STOP_SUCCESS -> {
-                    activity?.isRunning = false
-                }
-            }
-        }
-    }
-
     override fun onKeyDown(keyCode: Int, event: KeyEvent): Boolean {
-        if (keyCode == KeyEvent.KEYCODE_BACK) {
+        if (keyCode == KeyEvent.KEYCODE_BACK || keyCode == KeyEvent.KEYCODE_BUTTON_B) {
             moveTaskToBack(false)
             return true
         }
         return super.onKeyDown(keyCode, event)
     }
 
+
     fun showCircle() {
-        fabProgressCircle?.show()
+        binding.fabProgressCircle.show()
     }
 
     fun hideCircle() {
@@ -528,19 +643,26 @@ class MainActivity : BaseActivity(), NavigationView.OnNavigationItemSelectedList
             Observable.timer(300, TimeUnit.MILLISECONDS)
                     .observeOn(AndroidSchedulers.mainThread())
                     .subscribe {
-                        if (fabProgressCircle.isShown) {
-                            fabProgressCircle.hide()
+                        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())
         }
     }
 
+    @Deprecated("Deprecated in Java")
     override fun onBackPressed() {
-        if (drawer_layout.isDrawerOpen(GravityCompat.START)) {
-            drawer_layout.closeDrawer(GravityCompat.START)
+        if (binding.drawerLayout.isDrawerOpen(GravityCompat.START)) {
+            binding.drawerLayout.closeDrawer(GravityCompat.START)
         } else {
-            super.onBackPressed()
+            //super.onBackPressed()
+            onBackPressedDispatcher.onBackPressed()
         }
     }
 
@@ -549,25 +671,29 @@ class MainActivity : BaseActivity(), NavigationView.OnNavigationItemSelectedList
         when (item.itemId) {
             //R.id.server_profile -> activityClass = MainActivity::class.java
             R.id.sub_setting -> {
-                startActivity<SubSettingActivity>()
+                startActivity(Intent(this, SubSettingActivity::class.java))
             }
             R.id.settings -> {
-                startActivity<SettingsActivity>("isRunning" to isRunning)
+                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, AppConfig.promotionUrl)
-            }
-            R.id.donate -> {
-                startActivity<InappBuyActivity>()
+                Utils.openUri(this, "${Utils.decode(AppConfig.promotionUrl)}?t=${System.currentTimeMillis()}")
             }
             R.id.logcat -> {
-                startActivity<LogcatActivity>()
+                startActivity(Intent(this, LogcatActivity::class.java))
+            }
+            R.id.privacy_policy-> {
+                Utils.openUri(this, AppConfig.v2rayNGPrivacyPolicy)
             }
         }
-        drawer_layout.closeDrawer(GravityCompat.START)
+        binding.drawerLayout.closeDrawer(GravityCompat.START)
         return true
     }
-}
+}

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

@@ -1,24 +1,33 @@
 package com.v2ray.ang.ui
 
+import android.content.Intent
 import android.graphics.Color
-import android.support.v7.widget.RecyclerView
 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.dto.AngConfig
+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 kotlinx.android.synthetic.main.item_qrcode.view.*
-import kotlinx.android.synthetic.main.item_recycler_main.view.*
-import org.jetbrains.anko.*
 import rx.Observable
 import rx.android.schedulers.AndroidSchedulers
 import java.util.concurrent.TimeUnit
-import com.v2ray.ang.extension.defaultDPreference
 
 class MainRecyclerAdapter(val activity: MainActivity) : RecyclerView.Adapter<MainRecyclerAdapter.BaseViewHolder>()
         , ItemTouchHelperAdapter {
@@ -28,241 +37,225 @@ class MainRecyclerAdapter(val activity: MainActivity) : RecyclerView.Adapter<Mai
     }
 
     private var mActivity: MainActivity = activity
-    private lateinit var configs: AngConfig
+    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
 
-    var changeable: Boolean = true
-        set(value) {
-            if (field == value)
-                return
-            field = value
-            notifyDataSetChanged()
-        }
-
-    init {
-        updateConfigList()
-    }
-
-    override fun getItemCount() = configs.vmess.count() + 1
+    override fun getItemCount() = mActivity.mainViewModel.serversCache.size + 1
 
     override fun onBindViewHolder(holder: BaseViewHolder, position: Int) {
         if (holder is MainViewHolder) {
-            val configType = configs.vmess[position].configType
-            val remarks = configs.vmess[position].remarks
-            val subid = configs.vmess[position].subid
-            val address = configs.vmess[position].address
-            val port = configs.vmess[position].port
-            val test_result = configs.vmess[position].testResult
+            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
+//            }
 
-            holder.name.text = remarks
-            holder.radio.isChecked = (position == configs.index)
-            holder.itemView.backgroundColor = Color.TRANSPARENT
-            holder.test_result.text = test_result
+            val outbound = config.getProxyOutbound()
+            val aff = MmkvManager.decodeServerAffiliationInfo(guid)
 
-            if (TextUtils.isEmpty(subid)) {
-                holder.subid.text = ""
+            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.subid.text = "S"
+                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
             }
 
-            if (configType == AppConfig.EConfigType.Vmess) {
-                holder.type.text = "vmess"
-                holder.statistics.text = "$address : $port"
-                holder.layout_share.visibility = View.VISIBLE
-            } else if (configType == AppConfig.EConfigType.Custom) {
-                holder.type.text = mActivity.getString(R.string.server_customize_config)
-                holder.statistics.text = ""//mActivity.getString(R.string.server_customize_config)
-                holder.layout_share.visibility = View.INVISIBLE
-            } else if (configType == AppConfig.EConfigType.Shadowsocks) {
-                holder.type.text = "shadowsocks"
-                holder.statistics.text = "$address : $port"
-                holder.layout_share.visibility = View.VISIBLE
-            } else if (configType == AppConfig.EConfigType.Socks) {
-                holder.type.text = "socks"
-                holder.statistics.text = "$address : $port"
-                holder.layout_share.visibility = View.VISIBLE
+            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()
+                }
             }
+            val strState = "${outbound?.getServerAddress()?.dropLast(3)}*** : ${outbound?.getServerPort()}"
+            holder.itemMainBinding.tvStatistics.text = strState
 
-            holder.layout_share.setOnClickListener {
-                mActivity.selector(null, share_method.asList()) { dialogInterface, i ->
+            holder.itemMainBinding.layoutShare.setOnClickListener {
+                AlertDialog.Builder(mActivity).setItems(shareOptions.toTypedArray()) { _, i ->
                     try {
                         when (i) {
                             0 -> {
-                                val iv = mActivity.layoutInflater.inflate(R.layout.item_qrcode, null)
-                                iv.iv_qcode.setImageBitmap(AngConfigManager.share2QRCode(position))
-
-                                mActivity.alert {
-                                    customView {
-                                        linearLayout {
-                                            addView(iv)
-                                        }
-                                    }
-                                }.show()
+                                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(position) == 0) {
+                                if (AngConfigManager.share2Clipboard(mActivity, guid) == 0) {
                                     mActivity.toast(R.string.toast_success)
                                 } else {
                                     mActivity.toast(R.string.toast_failure)
                                 }
                             }
-                            2 -> {
-                                if (AngConfigManager.shareFullContent2Clipboard(position) == 0) {
-                                    mActivity.toast(R.string.toast_success)
-                                } else {
-                                    mActivity.toast(R.string.toast_failure)
-                                }
-                            }
-                            else ->
-                                mActivity.toast("else")
+                            2 -> shareFullContent(guid)
+                            else -> mActivity.toast("else")
                         }
                     } catch (e: Exception) {
                         e.printStackTrace()
                     }
-                }
+                }.show()
             }
 
-            holder.layout_edit.setOnClickListener {
-                if (configType == AppConfig.EConfigType.Vmess) {
-                    mActivity.startActivity<ServerActivity>("position" to position, "isRunning" to !changeable)
-                } else if (configType == AppConfig.EConfigType.Custom) {
-                    mActivity.startActivity<Server2Activity>("position" to position, "isRunning" to !changeable)
-                } else if (configType == AppConfig.EConfigType.Shadowsocks) {
-                    mActivity.startActivity<Server3Activity>("position" to position, "isRunning" to !changeable)
-                } else if (configType == AppConfig.EConfigType.Socks) {
-                    mActivity.startActivity<Server4Activity>("position" to position, "isRunning" to !changeable)
+            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.layout_remove.setOnClickListener {
-                if (configs.index != position) {
-                    if (AngConfigManager.removeServer(position) == 0) {
-                        notifyItemRemoved(position)
-                        updateSelectedItem(position)
+            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.infoContainer.setOnClickListener {
-                if (changeable) {
-                    AngConfigManager.setActiveServer(position)
-                } else {
-                    mActivity.showCircle()
-                    Utils.stopVService(mActivity)
-                    AngConfigManager.setActiveServer(position)
-                    Observable.timer(500, TimeUnit.MILLISECONDS)
-                            .observeOn(AndroidSchedulers.mainThread())
-                            .subscribe {
-                                mActivity.showCircle()
-                                if (!Utils.startVService(mActivity)) {
+            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()
                                 }
-                            }
-
+                    }
                 }
-                notifyDataSetChanged()
             }
         }
         if (holder is FooterViewHolder) {
             //if (activity?.defaultDPreference?.getPrefBoolean(AppConfig.PREF_INAPP_BUY_IS_PREMIUM, false)) {
             if (true) {
-                holder.layout_edit.visibility = View.INVISIBLE
+                holder.itemFooterBinding.layoutEdit.visibility = View.INVISIBLE
             } else {
-                holder.layout_edit.setOnClickListener {
-                    Utils.openUri(mActivity, AppConfig.promotionUrl)
+                holder.itemFooterBinding.layoutEdit.setOnClickListener {
+                    Utils.openUri(mActivity, "${Utils.decode(AppConfig.promotionUrl)}?t=${System.currentTimeMillis()}")
                 }
             }
         }
     }
 
-    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): BaseViewHolder {
-        when (viewType) {
-            VIEW_TYPE_ITEM ->
-                return MainViewHolder(parent.context.layoutInflater
-                        .inflate(R.layout.item_recycler_main, parent, false))
-            else ->
-                return FooterViewHolder(parent.context.layoutInflater
-                        .inflate(R.layout.item_recycler_footer, parent, false))
+    private fun shareFullContent(guid: String) {
+        if (AngConfigManager.shareFullContent2Clipboard(mActivity, guid) == 0) {
+            mActivity.toast(R.string.toast_success)
+        } else {
+            mActivity.toast(R.string.toast_failure)
         }
     }
 
-    fun updateConfigList() {
-        configs = AngConfigManager.configs
-        notifyDataSetChanged()
+    private  fun removeServer(guid: String,position:Int) {
+        mActivity.mainViewModel.removeServer(guid)
+        notifyItemRemoved(position)
+        notifyItemRangeChanged(position, mActivity.mainViewModel.serversCache.size)
     }
 
-//    fun updateSelectedItem() {
-//        updateSelectedItem(configs.index)
-//    }
-
-    fun updateSelectedItem(pos: Int) {
-        //notifyItemChanged(pos)
-        notifyItemRangeChanged(pos, itemCount - pos)
+    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 {
-        if (position == configs.vmess.count()) {
-            return VIEW_TYPE_FOOTER
+        return if (position == mActivity.mainViewModel.serversCache.size) {
+            VIEW_TYPE_FOOTER
         } else {
-            return VIEW_TYPE_ITEM
+            VIEW_TYPE_ITEM
         }
     }
 
-    open class BaseViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView)
-
-    class MainViewHolder(itemView: View) : BaseViewHolder(itemView), ItemTouchHelperViewHolder {
-        val subid = itemView.tv_subid
-        val radio = itemView.btn_radio!!
-        val name = itemView.tv_name!!
-        val test_result = itemView.tv_test_result!!
-        val type = itemView.tv_type!!
-        val statistics = itemView.tv_statistics!!
-        val infoContainer = itemView.info_container!!
-        val layout_edit = itemView.layout_edit!!
-        val layout_share = itemView.layout_share
-        val layout_remove = itemView.layout_remove!!
-
-        override fun onItemSelected() {
+    open class BaseViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
+        fun onItemSelected() {
             itemView.setBackgroundColor(Color.LTGRAY)
         }
 
-        override fun onItemClear() {
+        fun onItemClear() {
             itemView.setBackgroundColor(0)
         }
     }
 
-    class FooterViewHolder(itemView: View) : BaseViewHolder(itemView), ItemTouchHelperViewHolder {
-        val layout_edit = itemView.layout_edit!!
+    class MainViewHolder(val itemMainBinding: ItemRecyclerMainBinding) :
+            BaseViewHolder(itemMainBinding.root), ItemTouchHelperViewHolder
 
-        override fun onItemSelected() {
-            itemView.setBackgroundColor(Color.LTGRAY)
-        }
-
-        override fun onItemClear() {
-            itemView.setBackgroundColor(0)
-        }
-    }
+    class FooterViewHolder(val itemFooterBinding: ItemRecyclerFooterBinding) :
+            BaseViewHolder(itemFooterBinding.root)
 
     override fun onItemDismiss(position: Int) {
-        if (configs.index != position) {
+        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) {
-            if (AngConfigManager.removeServer(position) == 0) {
-                notifyItemRemoved(position)
-            }
+            mActivity.mainViewModel.removeServer(guid)
+            notifyItemRemoved(position)
 //                }
 //                show()
 //            }
         }
-        updateSelectedItem(position)
     }
 
     override fun onItemMove(fromPosition: Int, toPosition: Int): Boolean {
-        AngConfigManager.swapServer(fromPosition, toPosition)
+        mActivity.mainViewModel.swapServer(fromPosition, toPosition)
         notifyItemMoved(fromPosition, toPosition)
-        //notifyDataSetChanged()
-        updateSelectedItem(if (fromPosition < toPosition) fromPosition else 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

@@ -1,71 +1,63 @@
 package com.v2ray.ang.ui
 
-import android.animation.Animator
-import android.animation.AnimatorListenerAdapter
-import android.content.Context
 import android.os.Bundle
-import android.support.v7.widget.RecyclerView
 import android.text.TextUtils
 import android.util.Log
 import android.view.Menu
 import android.view.MenuItem
 import android.view.View
-import android.view.animation.AccelerateInterpolator
-import android.view.animation.DecelerateInterpolator
-import com.dinuscxj.itemdecoration.LinearDividerItemDecoration
+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.extension.defaultDPreference
+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 kotlinx.android.synthetic.main.activity_bypass_list.*
+import com.v2ray.ang.util.Utils
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
 import rx.android.schedulers.AndroidSchedulers
 import rx.schedulers.Schedulers
 import java.text.Collator
 import java.util.*
-import android.view.inputmethod.EditorInfo
-import android.view.inputmethod.InputMethodManager
-import com.v2ray.ang.AppConfig
-import com.v2ray.ang.dto.AppInfo
-import com.v2ray.ang.extension.v2RayApplication
-import com.v2ray.ang.util.Utils
-import org.jetbrains.anko.doAsync
-import org.jetbrains.anko.toast
-import org.jetbrains.anko.uiThread
-import java.net.URL
 
 class PerAppProxyActivity : BaseActivity() {
-    companion object {
-        const val PREF_PER_APP_PROXY_SET = "pref_per_app_proxy_set"
-        const val PREF_BYPASS_APPS = "pref_bypass_apps"
-    }
+    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)
-        setContentView(R.layout.activity_bypass_list)
+        binding = ActivityBypassListBinding.inflate(layoutInflater)
+        val view = binding.root
+        setContentView(view)
 
-        supportActionBar?.setDisplayHomeAsUpEnabled(true)
+        val dividerItemDecoration = DividerItemDecoration(this, LinearLayoutManager.VERTICAL)
+        binding.recyclerView.addItemDecoration(dividerItemDecoration)
 
-        val dividerItemDecoration = LinearDividerItemDecoration(
-                this, LinearDividerItemDecoration.LINEAR_DIVIDER_VERTICAL)
-        recycler_view.addItemDecoration(dividerItemDecoration)
-
-        val blacklist = defaultDPreference.getPrefStringSet(PREF_PER_APP_PROXY_SET, null)
+        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))) {
+                            if (blacklist.contains(one.packageName)) {
                                 one.isSelected = 1
                             } else {
                                 one.isSelected = 0
                             }
                         }
-                        val comparator = object : Comparator<AppInfo> {
-                            override fun compare(p1: AppInfo, p2: AppInfo): Int = when {
+                        val comparator = Comparator<AppInfo> { p1, p2 ->
+                            when {
                                 p1.isSelected > p2.isSelected -> -1
                                 p1.isSelected == p2.isSelected -> 0
                                 else -> 1
@@ -91,103 +83,123 @@ class PerAppProxyActivity : BaseActivity() {
                 .subscribe {
                     appsAll = it
                     adapter = PerAppProxyAdapter(this, it, blacklist)
-                    recycler_view.adapter = adapter
-                    pb_waiting.visibility = View.GONE
+                    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) * 3
-            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 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
-            }
+        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
+        }
         })
-
-        switch_per_app_proxy.setOnCheckedChangeListener { buttonView, isChecked ->
-            defaultDPreference.setPrefBoolean(SettingsActivity.PREF_PER_APP_PROXY, isChecked)
+        hiding = true
         }
-        switch_per_app_proxy.isChecked = defaultDPreference.getPrefBoolean(SettingsActivity.PREF_PER_APP_PROXY, false)
 
-        switch_bypass_apps.setOnCheckedChangeListener { buttonView, isChecked ->
-            defaultDPreference.setPrefBoolean(PREF_BYPASS_APPS, isChecked)
+        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
         }
-        switch_bypass_apps.isChecked = defaultDPreference.getPrefBoolean(PREF_BYPASS_APPS, 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)
+        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
-            }
+        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 {
-            defaultDPreference.setPrefStringSet(PREF_PER_APP_PROXY_SET, it.blacklist)
+            defaultSharedPreferences.edit().putStringSet(AppConfig.PREF_PER_APP_PROXY_SET, it.blacklist).apply()
         }
     }
 
-    override fun onCreateOptionsMenu(menu: Menu?): Boolean {
+    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)
     }
 
@@ -204,14 +216,20 @@ class PerAppProxyActivity : BaseActivity() {
                     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)
@@ -220,22 +238,41 @@ class PerAppProxyActivity : BaseActivity() {
     private fun selectProxyApp() {
         toast(R.string.msg_downloading_content)
         val url = AppConfig.androidpackagenamelistUrl
-        doAsync {
-            val content = URL(url).readText()
-            uiThread {
-                Log.d("selectProxyApp", content)
-                selectProxyApp(content)
+        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 selectProxyApp(content: String): Boolean {
+    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 {
-            var proxyApps = content
-            if (TextUtils.isEmpty(content)) {
-                val assets = Utils.readTextFromAssets(v2RayApplication, "proxy_packagename.txt")
-                proxyApps = assets.lines().toString()
+            val proxyApps = if (TextUtils.isEmpty(content)) {
+                Utils.readTextFromAssets(v2RayApplication, "proxy_packagename.txt")
+            } else {
+                content
             }
             if (TextUtils.isEmpty(proxyApps)) {
                 return false
@@ -243,12 +280,12 @@ class PerAppProxyActivity : BaseActivity() {
 
             adapter?.blacklist!!.clear()
 
-            if (switch_bypass_apps.isChecked) {
+            if (binding.switchBypassApps.isChecked) {
                 adapter?.let {
                     it.apps.forEach block@{
                         val packageName = it.packageName
-                        Log.d("selectProxyApp2", packageName)
-                        if (proxyApps.indexOf(packageName) < 0) {
+                        Log.d(ANG_PACKAGE, packageName)
+                        if (!inProxyApps(proxyApps, packageName, force)) {
                             adapter?.blacklist!!.add(packageName)
                             println(packageName)
                             return@block
@@ -260,8 +297,8 @@ class PerAppProxyActivity : BaseActivity() {
                 adapter?.let {
                     it.apps.forEach block@{
                         val packageName = it.packageName
-                        Log.d("selectProxyApp3", packageName)
-                        if (proxyApps.indexOf(packageName) >= 0) {
+                        Log.d(ANG_PACKAGE, packageName)
+                        if (inProxyApps(proxyApps, packageName, force)) {
                             adapter?.blacklist!!.add(packageName)
                             println(packageName)
                             return@block
@@ -276,4 +313,40 @@ class PerAppProxyActivity : BaseActivity() {
         }
         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

@@ -1,15 +1,12 @@
 package com.v2ray.ang.ui
 
-import android.graphics.Color
-import android.support.v7.widget.RecyclerView
+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 kotlinx.android.synthetic.main.item_recycler_bypass_list.view.*
-import org.jetbrains.anko.image
-import org.jetbrains.anko.layoutInflater
-import org.jetbrains.anko.textColor
 import java.util.*
 
 class PerAppProxyAdapter(val activity: BaseActivity, val apps: List<AppInfo>, blacklist: MutableSet<String>?) :
@@ -20,8 +17,7 @@ class PerAppProxyAdapter(val activity: BaseActivity, val apps: List<AppInfo>, bl
         private const val VIEW_TYPE_ITEM = 1
     }
 
-    private var mActivity: BaseActivity = activity
-    val blacklist = if (blacklist == null) HashSet<String>() else HashSet<String>(blacklist)
+    val blacklist = if (blacklist == null) HashSet() else HashSet(blacklist)
 
     override fun onBindViewHolder(holder: BaseViewHolder, position: Int) {
         if (holder is AppViewHolder) {
@@ -39,14 +35,13 @@ class PerAppProxyAdapter(val activity: BaseActivity, val apps: List<AppInfo>, bl
             VIEW_TYPE_HEADER -> {
                 val view = View(ctx)
                 view.layoutParams = ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
-                        ctx.resources.getDimensionPixelSize(R.dimen.bypass_list_header_height) * 3)
+                        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(ctx.layoutInflater
-                    .inflate(R.layout.item_recycler_bypass_list, parent, false))
+            else -> AppViewHolder(ItemRecyclerBypassListBinding.inflate(LayoutInflater.from(ctx), parent, false))
 
         }
     }
@@ -55,32 +50,25 @@ class PerAppProxyAdapter(val activity: BaseActivity, val apps: List<AppInfo>, bl
 
     open class BaseViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView)
 
-    inner class AppViewHolder(itemView: View) : BaseViewHolder(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
 
-        val icon = itemView.icon!!
-        val name = itemView.name!!
-        val checkBox = itemView.check_box!!
-
         fun bind(appInfo: AppInfo) {
             this.appInfo = appInfo
 
-            icon.image = appInfo.appIcon
+            itemBypassBinding.icon.setImageDrawable(appInfo.appIcon)
 //            name.text = appInfo.appName
 
-            checkBox.isChecked = inBlacklist
-
-//            name.textColor = mActivity.resources.getColor(if (appInfo.isSystemApp)
-//                R.color.color_highlight_material else R.color.abc_secondary_text_material_light)
-
+            itemBypassBinding.checkBox.isChecked = inBlacklist
+            itemBypassBinding.packageName.text = appInfo.packageName
             if (appInfo.isSystemApp) {
-                name.text = String.format("** %1s", appInfo.appName)
-                name.textColor = Color.RED
+                itemBypassBinding.name.text = String.format("** %1s", appInfo.appName)
+                //name.textColor = Color.RED
             } else {
-                name.text = appInfo.appName
-                name.textColor = Color.DKGRAY
+                itemBypassBinding.name.text = appInfo.appName
+                //name.textColor = Color.DKGRAY
             }
 
             itemView.setOnClickListener(this)
@@ -89,11 +77,11 @@ class PerAppProxyAdapter(val activity: BaseActivity, val apps: List<AppInfo>, bl
         override fun onClick(v: View?) {
             if (inBlacklist) {
                 blacklist.remove(appInfo.packageName)
-                checkBox.isChecked = false
+                itemBypassBinding.checkBox.isChecked = false
             } else {
                 blacklist.add(appInfo.packageName)
-                checkBox.isChecked = true
+                itemBypassBinding.checkBox.isChecked = true
             }
         }
     }
-}
+}

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

@@ -1,33 +1,37 @@
 package com.v2ray.ang.ui
 
-import android.graphics.Color
 import android.os.Bundle
 import com.v2ray.ang.R
-import android.support.v4.app.Fragment
+import androidx.fragment.app.Fragment
+import com.google.android.material.tabs.TabLayoutMediator
 import com.v2ray.ang.AppConfig
-import kotlinx.android.synthetic.main.activity_routing_settings.*
-
+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)
-        setContentView(R.layout.activity_routing_settings)
+        binding = ActivityRoutingSettingsBinding.inflate(layoutInflater)
+        val view = binding.root
+        setContentView(view)
 
-        title = getString(R.string.routing_settings_title)
-        supportActionBar?.setDisplayHomeAsUpEnabled(true)
+        title = getString(R.string.title_pref_routing_custom)
 
         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(supportFragmentManager, fragments, titles.toList())
-        viewpager?.adapter = adapter
-        tablayout.setTabTextColors(Color.BLACK, Color.RED)
-        tablayout.setupWithViewPager(viewpager)
+        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

@@ -1,41 +1,38 @@
 package com.v2ray.ang.ui
 
-
 import android.Manifest
-import android.app.Activity.RESULT_OK
+import androidx.appcompat.app.AppCompatActivity.RESULT_OK
 import android.content.Intent
 import android.os.Bundle
-import android.support.v4.app.Fragment
 import android.text.TextUtils
-import android.util.Log
 import android.view.*
-import com.v2ray.ang.R
-import com.v2ray.ang.extension.defaultDPreference
-import com.v2ray.ang.util.Utils
-import kotlinx.android.synthetic.main.fragment_routing_settings.*
-import org.jetbrains.anko.toast
-import android.view.MenuInflater
+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 org.jetbrains.anko.doAsync
-import org.jetbrains.anko.startActivityForResult
-import org.jetbrains.anko.support.v4.startActivityForResult
-import org.jetbrains.anko.support.v4.toast
-import org.jetbrains.anko.uiThread
-import java.net.URL
-
+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.launch
 
 class RoutingSettingsFragment : Fragment() {
+    private lateinit var binding: FragmentRoutingSettingsBinding
     companion object {
         private const val routing_arg = "routing_arg"
-        private const val REQUEST_SCAN_REPLACE = 11
-        private const val REQUEST_SCAN_APPEND = 12
     }
 
+    val defaultSharedPreferences by lazy { PreferenceManager.getDefaultSharedPreferences(requireContext()) }
+
     override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?,
                               savedInstanceState: Bundle?): View? {
         // Inflate the layout for this fragment
-        return inflater.inflate(R.layout.fragment_routing_settings, container, false)
+        binding = FragmentRoutingSettingsBinding.inflate(layoutInflater)
+        return binding.root// inflater.inflate(R.layout.fragment_routing_settings, container, false)
     }
 
     fun newInstance(arg: String): Fragment {
@@ -46,11 +43,11 @@ class RoutingSettingsFragment : Fragment() {
         return fragment
     }
 
-    override fun onActivityCreated(savedInstanceState: Bundle?) {
-        super.onActivityCreated(savedInstanceState)
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        super.onViewCreated(view, savedInstanceState)
 
-        val content = activity?.defaultDPreference?.getPrefString(arguments!!.getString(routing_arg), "")
-        et_routing_content.text = Utils.getEditable(content!!)
+        val content = defaultSharedPreferences.getString(requireArguments().getString(routing_arg), "")
+        binding.etRoutingContent.text = Utils.getEditable(content!!)
 
         setHasOptionsMenu(true)
     }
@@ -62,21 +59,19 @@ class RoutingSettingsFragment : Fragment() {
 
     override fun onOptionsItemSelected(item: MenuItem) = when (item.itemId) {
         R.id.save_routing -> {
-            val content = et_routing_content.text.toString()
-            activity?.defaultDPreference?.setPrefString(arguments!!.getString(routing_arg), content)
-            activity?.toast(R.string.toast_success)
+            saveRouting()
             true
         }
         R.id.del_routing -> {
-            et_routing_content.text = null
+            binding.etRoutingContent.text = null
             true
         }
         R.id.scan_replace -> {
-            scanQRcode(REQUEST_SCAN_REPLACE)
+            scanQRcode(true)
             true
         }
         R.id.scan_append -> {
-            scanQRcode(REQUEST_SCAN_APPEND)
+            scanQRcode(false)
             true
         }
         R.id.default_rules -> {
@@ -86,17 +81,26 @@ class RoutingSettingsFragment : Fragment() {
         else -> super.onOptionsItemSelected(item)
     }
 
-    fun scanQRcode(requestCode: Int): Boolean {
+    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(activity!!)
+        RxPermissions(requireActivity())
                 .request(Manifest.permission.CAMERA)
                 .subscribe {
                     if (it)
-                        startActivityForResult<ScannerActivity>(requestCode)
+                        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)
                 }
@@ -104,46 +108,50 @@ class RoutingSettingsFragment : Fragment() {
         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
-        when (arguments!!.getString(routing_arg)) {
+        var tag = ""
+        when (requireArguments().getString(routing_arg)) {
             AppConfig.PREF_V2RAY_ROUTING_AGENT -> {
-                url += AppConfig.TAG_AGENT
+                tag = AppConfig.TAG_AGENT
             }
             AppConfig.PREF_V2RAY_ROUTING_DIRECT -> {
-                url += AppConfig.TAG_DIRECT
+                tag = AppConfig.TAG_DIRECT
             }
             AppConfig.PREF_V2RAY_ROUTING_BLOCKED -> {
-                url += AppConfig.TAG_BLOCKED
+                tag = AppConfig.TAG_BLOCKED
             }
         }
+        url += tag
 
-        toast(R.string.msg_downloading_content)
-        doAsync {
-            val content = URL(url).readText()
-            uiThread {
-                et_routing_content.text = Utils.getEditable(content!!)
-                toast(R.string.toast_success)
+        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
     }
-
-    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
-        super.onActivityResult(requestCode, resultCode, data)
-        when (requestCode) {
-            REQUEST_SCAN_REPLACE ->
-                if (resultCode == RESULT_OK) {
-                    val content = data?.getStringExtra("SCAN_RESULT")
-                    et_routing_content.text = Utils.getEditable(content!!)
-                }
-            REQUEST_SCAN_APPEND ->
-                if (resultCode == RESULT_OK) {
-                    val content = data?.getStringExtra("SCAN_RESULT")
-                    et_routing_content.text = Utils.getEditable("${et_routing_content.text},$content")
-                }
-        }
-    }
-
-
 }

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

@@ -6,25 +6,23 @@ import com.tbruyelle.rxpermissions.RxPermissions
 import com.v2ray.ang.R
 import com.v2ray.ang.util.AngConfigManager
 import android.os.Bundle
-import org.jetbrains.anko.*
+import androidx.activity.result.contract.ActivityResultContracts
+import com.v2ray.ang.extension.toast
 
 class ScScannerActivity : BaseActivity() {
-    companion object {
-        private const val REQUEST_SCAN = 1
-    }
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         setContentView(R.layout.activity_none)
-        importQRcode(REQUEST_SCAN)
+        importQRcode()
     }
 
-    fun importQRcode(requestCode: Int): Boolean {
+    fun importQRcode(): Boolean {
         RxPermissions(this)
                 .request(Manifest.permission.CAMERA)
                 .subscribe {
                     if (it)
-                        startActivityForResult<ScannerActivity>(requestCode)
+                        scanQRCode.launch(Intent(this, ScannerActivity::class.java))
                     else
                         toast(R.string.toast_permission_denied)
                 }
@@ -32,21 +30,16 @@ class ScScannerActivity : BaseActivity() {
         return true
     }
 
-    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
-        super.onActivityResult(requestCode, resultCode, data)
-        when (requestCode) {
-            REQUEST_SCAN ->
-                if (resultCode == RESULT_OK) {
-                    val count = AngConfigManager.importBatchConfig(data?.getStringExtra("SCAN_RESULT"), "")
-                    if (count > 0) {
-                        toast(R.string.toast_success)
-                    } else {
-                        toast(R.string.toast_failure)
-                    }
-                    startActivity<MainActivity>()
-                }
+    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

@@ -1,104 +1,22 @@
 package com.v2ray.ang.ui
 
-import android.content.*
-import android.net.VpnService
 import com.v2ray.ang.R
 import com.v2ray.ang.util.Utils
 import android.os.Bundle
-import com.v2ray.ang.AppConfig
-import com.v2ray.ang.util.MessageUtil
-import java.lang.ref.SoftReference
-import android.content.IntentFilter
-import kotlinx.android.synthetic.main.activity_main.*
-import rx.Observable
-import rx.android.schedulers.AndroidSchedulers
-import java.util.concurrent.TimeUnit
+import com.v2ray.ang.service.V2RayServiceManager
 
 class ScSwitchActivity : BaseActivity() {
-    companion object {
-        private const val REQUEST_CODE_VPN_PREPARE = 0
-    }
-
-    var isRunning = false
-        set(value) {
-            field = value
-            if (value) {
-                Utils.stopVService(this)
-            } else {
-                val intent = VpnService.prepare(this)
-                if (intent == null) {
-                    Utils.startVService(this)
-                } else {
-                    startActivityForResult(intent, REQUEST_CODE_VPN_PREPARE)
-                }
-            }
-            finishActivity()
-        }
-
-    fun finishActivity() {
-        try {
-            Observable.timer(5000, TimeUnit.MILLISECONDS)
-                    .observeOn(AndroidSchedulers.mainThread())
-                    .subscribe {
-                        finish()
-                    }
-        } catch (e: Exception) {
-        }
-    }
-
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         moveTaskToBack(true)
 
         setContentView(R.layout.activity_none)
 
-        val isRunning = Utils.isServiceRun(this, "com.v2ray.ang.service.V2RayVpnService")
-        if (isRunning) {
-            //Utils.stopVService(this)
-            mMsgReceive = ReceiveMessageHandler(this@ScSwitchActivity)
-            registerReceiver(mMsgReceive, IntentFilter(AppConfig.BROADCAST_ACTION_ACTIVITY))
-            MessageUtil.sendMsg2Service(this, AppConfig.MSG_REGISTER_CLIENT, "")
-
+        if (V2RayServiceManager.v2rayPoint.isRunning) {
+            Utils.stopVService(this)
         } else {
-            Utils.startVService(this)
-            finishActivity()
+            Utils.startVServiceFromToggle(this)
         }
+        finish()
     }
-
-    override fun onStop() {
-        super.onStop()
-        if (mMsgReceive != null) {
-            unregisterReceiver(mMsgReceive)
-            mMsgReceive = null
-        }
-    }
-
-    private var mMsgReceive: BroadcastReceiver? = null
-
-    private class ReceiveMessageHandler(activity: ScSwitchActivity) : BroadcastReceiver() {
-        internal var mReference: SoftReference<ScSwitchActivity> = SoftReference(activity)
-        override fun onReceive(ctx: Context?, intent: Intent?) {
-            val activity = mReference.get()
-            when (intent?.getIntExtra("key", 0)) {
-                AppConfig.MSG_STATE_RUNNING -> {
-                    activity?.isRunning = true
-                }
-                AppConfig.MSG_STATE_NOT_RUNNING -> {
-                    activity?.isRunning = false
-                }
-//                AppConfig.MSG_STATE_START_SUCCESS -> {
-//                    activity?.toast(R.string.toast_services_success)
-//                    activity?.isRunning = true
-//                }
-//                AppConfig.MSG_STATE_START_FAILURE -> {
-//                    activity?.toast(R.string.toast_services_failure)
-//                    activity?.isRunning = false
-//                }
-//                AppConfig.MSG_STATE_STOP_SUCCESS -> {
-//                    activity?.isRunning = false
-//                }
-            }
-        }
-    }
-
-}
+}

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

@@ -1,100 +1,91 @@
 package com.v2ray.ang.ui
 
 import android.Manifest
-import android.app.Activity
+import androidx.appcompat.app.AppCompatActivity
 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.icu.util.TimeUnit
+import android.os.Build
 import android.view.Menu
 import android.view.MenuItem
-import com.google.zxing.BarcodeFormat
+import androidx.activity.result.contract.ActivityResultContracts
 import com.tbruyelle.rxpermissions.RxPermissions
+import com.tencent.mmkv.MMKV
+import com.v2ray.ang.AppConfig
 import com.v2ray.ang.R
+import com.v2ray.ang.extension.toast
+import com.v2ray.ang.util.MmkvManager
 import com.v2ray.ang.util.QRCodeDecoder
-import org.jetbrains.anko.toast
-import rx.Observable
-import android.os.SystemClock
-import kotlinx.android.synthetic.main.activity_main.*
-import rx.Observer
-import rx.android.schedulers.AndroidSchedulers
-import javax.xml.datatype.DatatypeConstants.SECONDS
+import io.github.g00fy2.quickie.QRResult
+import io.github.g00fy2.quickie.ScanCustomCode
+import io.github.g00fy2.quickie.config.ScannerConfig
 
+class ScannerActivity : BaseActivity(){
 
+    private val scanQrCode = registerForActivityResult(ScanCustomCode(), ::handleResult)
+    private val settingsStorage by lazy { MMKV.mmkvWithID(MmkvManager.ID_SETTING, MMKV.MULTI_PROCESS_MODE) }
 
+    public override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
 
-class ScannerActivity : BaseActivity(), ZXingScannerView.ResultHandler {
-    companion object {
-        private const val REQUEST_FILE_CHOOSER = 2
+        if (settingsStorage?.decodeBool(AppConfig.PREF_START_SCAN_IMMEDIATE) == true) {
+            launchScan()
+        }
     }
 
-
-    private var mScannerView: ZXingScannerView? = null
-
-    public override fun onCreate(state: Bundle?) {
-        super.onCreate(state)
-        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)
+    private fun launchScan(){
+        scanQrCode.launch(
+            ScannerConfig.build {
+                setHapticSuccessFeedback(true) // enable (default) or disable haptic feedback when a barcode was detected
+                setShowTorchToggle(true) // show or hide (default) torch/flashlight toggle button
+                setShowCloseButton(true) // show or hide (default) close button
+            }
+        )
     }
 
-    public override fun onResume() {
-        super.onResume()
-        mScannerView!!.setResultHandler(this) // Register ourselves as a handler for scan results.
-        mScannerView!!.startCamera()          // Start camera on resume
+    private fun handleResult(result: QRResult) {
+        if (result is QRResult.QRSuccess ) {
+            finished(result.content.rawValue!!)
+        } else {
+            finish()
+        }
     }
 
-    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)
-    }
-
-    fun finished(text: String) {
+    private fun finished(text: String) {
         val intent = Intent()
         intent.putExtra("SCAN_RESULT", text)
-        setResult(Activity.RESULT_OK, intent)
+        setResult(AppCompatActivity.RESULT_OK, intent)
         finish()
     }
 
-    override fun onCreateOptionsMenu(menu: Menu?): Boolean {
+    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.scan_code -> {
+            launchScan()
+            true
+        }
         R.id.select_photo -> {
+            val permission = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                Manifest.permission.READ_MEDIA_IMAGES
+            } else {
+                Manifest.permission.READ_EXTERNAL_STORAGE
+            }
             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)
-                    }
+                .request(permission)
+                .subscribe {
+                    if (it) {
+                        try {
+                            showFileChooser()
+                        } catch (e: Exception) {
+                            e.printStackTrace()
+                        }
+                    } else
+                        toast(R.string.toast_permission_denied)
+                }
             true
         }
         else -> super.onOptionsItemSelected(item)
@@ -107,30 +98,23 @@ class ScannerActivity : BaseActivity(), ZXingScannerView.ResultHandler {
         //intent.putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true)
 
         try {
-            startActivityForResult(
-                    Intent.createChooser(intent, getString(R.string.title_file_chooser)),
-                    REQUEST_FILE_CHOOSER)
+            chooseFile.launch(Intent.createChooser(intent, getString(R.string.title_file_chooser)))
         } catch (ex: android.content.ActivityNotFoundException) {
             toast(R.string.toast_require_file_manager)
         }
     }
 
-
-    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
-        super.onActivityResult(requestCode, resultCode, data)
-        when (requestCode) {
-            REQUEST_FILE_CHOOSER ->
-                if (resultCode == RESULT_OK) {
-                    try {
-                        val uri = data!!.data
-                        val bitmap = BitmapFactory.decodeStream(contentResolver.openInputStream(uri))
-                        val text = QRCodeDecoder.syncDecodeQRCode(bitmap)
-                        finished(text)
-                    } catch (e: Exception) {
-                        e.printStackTrace()
-                        toast(e.message.toString())
-                    }
-                }
+    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/Server2Activity.kt

@@ -1,139 +0,0 @@
-package com.v2ray.ang.ui
-
-import android.os.Bundle
-import android.text.TextUtils
-import android.view.Menu
-import android.view.MenuItem
-import com.v2ray.ang.AppConfig
-import com.v2ray.ang.R
-import com.v2ray.ang.extension.defaultDPreference
-import com.v2ray.ang.dto.AngConfig
-import com.v2ray.ang.util.AngConfigManager
-import com.v2ray.ang.util.Utils
-import kotlinx.android.synthetic.main.activity_server2.*
-import org.jetbrains.anko.*
-
-
-class Server2Activity : BaseActivity() {
-    companion object {
-        private const val REQUEST_SCAN = 1
-    }
-
-    var del_config: MenuItem? = null
-    var save_config: MenuItem? = null
-
-    private lateinit var configs: AngConfig
-    private var edit_index: Int = -1 //当前编辑的服务器
-    private var edit_guid: String = ""
-    private var isRunning: Boolean = false
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        setContentView(R.layout.activity_server2)
-
-        configs = AngConfigManager.configs
-        edit_index = intent.getIntExtra("position", -1)
-        isRunning = intent.getBooleanExtra("isRunning", false)
-        title = getString(R.string.title_server)
-
-        if (edit_index >= 0) {
-            edit_guid = configs.vmess[edit_index].guid
-            bindingServer(configs.vmess[edit_index])
-        } else {
-            clearServer()
-        }
-        supportActionBar?.setDisplayHomeAsUpEnabled(true)
-    }
-
-    /**
-     * bingding seleced server config
-     */
-    fun bindingServer(vmess: AngConfig.VmessBean): Boolean {
-        et_remarks.text = Utils.getEditable(vmess.remarks)
-        tv_content.text = defaultDPreference.getPrefString(AppConfig.ANG_CONFIG + edit_guid, "")
-        return true
-    }
-
-    /**
-     * clear or init server config
-     */
-    fun clearServer(): Boolean {
-        et_remarks.text = null
-        return true
-    }
-
-    /**
-     * save server config
-     */
-    fun saveServer(): Boolean {
-        val vmess = configs.vmess[edit_index]
-
-        vmess.remarks = et_remarks.text.toString()
-
-        if (TextUtils.isEmpty(vmess.remarks)) {
-            toast(R.string.server_lab_remarks)
-            return false
-        }
-
-        if (AngConfigManager.addCustomServer(vmess, edit_index) == 0) {
-            toast(R.string.toast_success)
-            finish()
-            return true
-        } else {
-            toast(R.string.toast_failure)
-            return false
-        }
-    }
-
-    /**
-     * save server config
-     */
-    fun deleteServer(): Boolean {
-        if (edit_index >= 0) {
-            alert(R.string.del_config_comfirm) {
-                positiveButton(android.R.string.ok) {
-                    if (AngConfigManager.removeServer(edit_index) == 0) {
-                        toast(R.string.toast_success)
-                        finish()
-                    } else {
-                        toast(R.string.toast_failure)
-                    }
-                }
-                show()
-            }
-        } else {
-        }
-        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 (edit_index >= 0) {
-            if (isRunning) {
-                if (edit_index == configs.index) {
-                    del_config?.isVisible = false
-                    save_config?.isVisible = false
-                }
-            }
-        } else {
-            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/Server3Activity.kt

@@ -1,175 +0,0 @@
-package com.v2ray.ang.ui
-
-import android.os.Bundle
-import android.text.TextUtils
-import android.view.Menu
-import android.view.MenuItem
-import com.v2ray.ang.R
-import com.v2ray.ang.dto.AngConfig
-import com.v2ray.ang.util.AngConfigManager
-import com.v2ray.ang.util.Utils
-import kotlinx.android.synthetic.main.activity_server3.*
-import org.jetbrains.anko.*
-
-
-class Server3Activity : BaseActivity() {
-    companion object {
-        private const val REQUEST_SCAN = 1
-    }
-
-    var del_config: MenuItem? = null
-    var save_config: MenuItem? = null
-
-    private lateinit var configs: AngConfig
-    private var edit_index: Int = -1 //当前编辑的服务器
-    private var edit_guid: String = ""
-    private var isRunning: Boolean = false
-    private val securitys: Array<out String> by lazy {
-        resources.getStringArray(R.array.ss_securitys)
-    }
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        setContentView(R.layout.activity_server3)
-
-        configs = AngConfigManager.configs
-        edit_index = intent.getIntExtra("position", -1)
-        isRunning = intent.getBooleanExtra("isRunning", false)
-        title = getString(R.string.title_server)
-
-        if (edit_index >= 0) {
-            edit_guid = configs.vmess[edit_index].guid
-            bindingServer(configs.vmess[edit_index])
-        } else {
-            clearServer()
-        }
-        supportActionBar?.setDisplayHomeAsUpEnabled(true)
-    }
-
-    /**
-     * bingding seleced server config
-     */
-    fun bindingServer(vmess: AngConfig.VmessBean): Boolean {
-        et_remarks.text = Utils.getEditable(vmess.remarks)
-
-        et_address.text = Utils.getEditable(vmess.address)
-        et_port.text = Utils.getEditable(vmess.port.toString())
-        et_id.text = Utils.getEditable(vmess.id)
-        val security = Utils.arrayFind(securitys, vmess.security)
-        if (security >= 0) {
-            sp_security.setSelection(security)
-        }
-
-        return true
-    }
-
-    /**
-     * clear or init server config
-     */
-    fun clearServer(): Boolean {
-        et_remarks.text = null
-        et_address.text = null
-        et_port.text = Utils.getEditable("10086")
-        et_id.text = null
-        sp_security.setSelection(0)
-
-        return true
-    }
-
-    /**
-     * save server config
-     */
-    fun saveServer(): Boolean {
-        val vmess: AngConfig.VmessBean
-        if (edit_index >= 0) {
-            vmess = configs.vmess[edit_index]
-        } else {
-            vmess = AngConfig.VmessBean()
-        }
-
-        vmess.guid = edit_guid
-        vmess.remarks = et_remarks.text.toString()
-        vmess.address = et_address.text.toString()
-        vmess.port = Utils.parseInt(et_port.text.toString())
-        vmess.id = et_id.text.toString()
-        vmess.security = securitys[sp_security.selectedItemPosition]
-
-        if (TextUtils.isEmpty(vmess.remarks)) {
-            toast(R.string.server_lab_remarks)
-            return false
-        }
-        if (TextUtils.isEmpty(vmess.address)) {
-            toast(R.string.server_lab_address3)
-            return false
-        }
-        if (TextUtils.isEmpty(vmess.port.toString()) || vmess.port <= 0) {
-            toast(R.string.server_lab_port3)
-            return false
-        }
-        if (TextUtils.isEmpty(vmess.id)) {
-            toast(R.string.server_lab_id3)
-            return false
-        }
-
-        if (AngConfigManager.addShadowsocksServer(vmess, edit_index) == 0) {
-            toast(R.string.toast_success)
-            finish()
-            return true
-        } else {
-            toast(R.string.toast_failure)
-            return false
-        }
-    }
-
-    /**
-     * save server config
-     */
-    fun deleteServer(): Boolean {
-        if (edit_index >= 0) {
-            alert(R.string.del_config_comfirm) {
-                positiveButton(android.R.string.ok) {
-                    if (AngConfigManager.removeServer(edit_index) == 0) {
-                        toast(R.string.toast_success)
-                        finish()
-                    } else {
-                        toast(R.string.toast_failure)
-                    }
-                }
-                show()
-            }
-        } else {
-        }
-        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 (edit_index >= 0) {
-            if (isRunning) {
-                if (edit_index == configs.index) {
-                    del_config?.isVisible = false
-                    save_config?.isVisible = false
-                }
-            }
-        } else {
-            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/Server4Activity.kt

@@ -1,159 +0,0 @@
-package com.v2ray.ang.ui
-
-import android.os.Bundle
-import android.text.TextUtils
-import android.view.Menu
-import android.view.MenuItem
-import com.v2ray.ang.R
-import com.v2ray.ang.dto.AngConfig
-import com.v2ray.ang.util.AngConfigManager
-import com.v2ray.ang.util.Utils
-import kotlinx.android.synthetic.main.activity_server4.*
-import org.jetbrains.anko.*
-
-
-class Server4Activity : BaseActivity() {
-    companion object {
-        private const val REQUEST_SCAN = 1
-    }
-
-    var del_config: MenuItem? = null
-    var save_config: MenuItem? = null
-
-    private lateinit var configs: AngConfig
-    private var edit_index: Int = -1 //当前编辑的服务器
-    private var edit_guid: String = ""
-    private var isRunning: Boolean = false
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        setContentView(R.layout.activity_server4)
-
-        configs = AngConfigManager.configs
-        edit_index = intent.getIntExtra("position", -1)
-        isRunning = intent.getBooleanExtra("isRunning", false)
-        title = getString(R.string.title_server)
-
-        if (edit_index >= 0) {
-            edit_guid = configs.vmess[edit_index].guid
-            bindingServer(configs.vmess[edit_index])
-        } else {
-            clearServer()
-        }
-        supportActionBar?.setDisplayHomeAsUpEnabled(true)
-    }
-
-    /**
-     * bingding seleced server config
-     */
-    fun bindingServer(vmess: AngConfig.VmessBean): Boolean {
-        et_remarks.text = Utils.getEditable(vmess.remarks)
-
-        et_address.text = Utils.getEditable(vmess.address)
-        et_port.text = Utils.getEditable(vmess.port.toString())
-
-        return true
-    }
-
-    /**
-     * clear or init server config
-     */
-    fun clearServer(): Boolean {
-        et_remarks.text = null
-        et_address.text = null
-        et_port.text = Utils.getEditable("10086")
-
-        return true
-    }
-
-    /**
-     * save server config
-     */
-    fun saveServer(): Boolean {
-        val vmess: AngConfig.VmessBean
-        if (edit_index >= 0) {
-            vmess = configs.vmess[edit_index]
-        } else {
-            vmess = AngConfig.VmessBean()
-        }
-
-        vmess.guid = edit_guid
-        vmess.remarks = et_remarks.text.toString()
-        vmess.address = et_address.text.toString()
-        vmess.port = Utils.parseInt(et_port.text.toString())
-
-        if (TextUtils.isEmpty(vmess.remarks)) {
-            toast(R.string.server_lab_remarks)
-            return false
-        }
-        if (TextUtils.isEmpty(vmess.address)) {
-            toast(R.string.server_lab_address3)
-            return false
-        }
-        if (TextUtils.isEmpty(vmess.port.toString()) || vmess.port <= 0) {
-            toast(R.string.server_lab_port3)
-            return false
-        }
-
-        if (AngConfigManager.addSocksServer(vmess, edit_index) == 0) {
-            toast(R.string.toast_success)
-            finish()
-            return true
-        } else {
-            toast(R.string.toast_failure)
-            return false
-        }
-    }
-
-    /**
-     * save server config
-     */
-    fun deleteServer(): Boolean {
-        if (edit_index >= 0) {
-            alert(R.string.del_config_comfirm) {
-                positiveButton(android.R.string.ok) {
-                    if (AngConfigManager.removeServer(edit_index) == 0) {
-                        toast(R.string.toast_success)
-                        finish()
-                    } else {
-                        toast(R.string.toast_failure)
-                    }
-                }
-                show()
-            }
-        } else {
-        }
-        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 (edit_index >= 0) {
-            if (isRunning) {
-                if (edit_index == configs.index) {
-                    del_config?.isVisible = false
-                    save_config?.isVisible = false
-                }
-            }
-        } else {
-            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/ServerActivity.kt

@@ -4,87 +4,324 @@ 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.AppConfig.WIREGUARD_LOCAL_ADDRESS_V4
+import com.v2ray.ang.AppConfig.WIREGUARD_LOCAL_ADDRESS_V6
+import com.v2ray.ang.AppConfig.WIREGUARD_LOCAL_MTU
 import com.v2ray.ang.R
-import com.v2ray.ang.dto.AngConfig
-import com.v2ray.ang.util.AngConfigManager
+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.dto.V2rayConfig.Companion.TLS
+import com.v2ray.ang.extension.removeWhiteSpace
+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
-import kotlinx.android.synthetic.main.activity_server.*
-import org.jetbrains.anko.*
-
+import com.v2ray.ang.util.Utils.getIpv6Address
 
 class ServerActivity : BaseActivity() {
-    companion object {
-        private const val REQUEST_SCAN = 1
+
+    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")
     }
 
-    var del_config: MenuItem? = null
-    var save_config: MenuItem? = null
-
-    private lateinit var configs: AngConfig
-    private var edit_index: Int = -1 //当前编辑的服务器
-    private var edit_guid: String = ""
-    private var isRunning: Boolean = false
     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 headertypes: Array<out String> by lazy {
-        resources.getStringArray(R.array.headertypes)
+    private val tcpTypes: Array<out String> by lazy {
+        resources.getStringArray(R.array.header_type_tcp)
     }
-    private val streamsecuritys: Array<out String> by lazy {
-        resources.getStringArray(R.array.streamsecuritys)
+    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 container_allow_insecure: LinearLayout? by lazy { findViewById(R.id.l5) }
+    private val et_sni: EditText? by lazy { findViewById(R.id.et_sni) }
+    private val container_sni: LinearLayout? by lazy { findViewById(R.id.l2) }
+    private val sp_stream_fingerprint: Spinner? by lazy { findViewById(R.id.sp_stream_fingerprint) } //uTLS
+    private val container_fingerprint: LinearLayout? by lazy { findViewById(R.id.l3) }
+    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
+    private val container_alpn: LinearLayout? by lazy { findViewById(R.id.l4) }
+    private val et_public_key: EditText? by lazy { findViewById(R.id.et_public_key) }
+    private val container_public_key: LinearLayout? by lazy { findViewById(R.id.l6) }
+    private val et_short_id: EditText? by lazy { findViewById(R.id.et_short_id) }
+    private val container_short_id: LinearLayout? by lazy { findViewById(R.id.l7) }
+    private val et_spider_x: EditText? by lazy { findViewById(R.id.et_spider_x) }
+    private val container_spider_x: LinearLayout? by lazy { findViewById(R.id.l8) }
+    private val et_reserved1: EditText? by lazy { findViewById(R.id.et_reserved1) }
+    private val et_reserved2: EditText? by lazy { findViewById(R.id.et_reserved2) }
+    private val et_reserved3: EditText? by lazy { findViewById(R.id.et_reserved3) }
+    private val et_local_address: EditText? by lazy { findViewById(R.id.et_local_address) }
+    private val et_local_mtu: EditText? by lazy { findViewById(R.id.et_local_mtu) }
+
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
-        setContentView(R.layout.activity_server)
-
-        configs = AngConfigManager.configs
-        edit_index = intent.getIntExtra("position", -1)
-        isRunning = intent.getBooleanExtra("isRunning", false)
         title = getString(R.string.title_server)
 
-        if (edit_index >= 0) {
-            edit_guid = configs.vmess[edit_index].guid
-            bindingServer(configs.vmess[edit_index])
+        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)
+            EConfigType.WIREGUARD -> setContentView(R.layout.activity_server_wireguard)
+        }
+        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
+            }
+        }
+        sp_stream_security?.onItemSelectedListener = object : AdapterView.OnItemSelectedListener {
+            override fun onItemSelected(
+                parent: AdapterView<*>?,
+                view: View?,
+                position: Int,
+                id: Long
+            ) {
+                if (streamSecuritys[position].isBlank()) {
+                    container_sni?.visibility = View.GONE
+                    container_fingerprint?.visibility = View.GONE
+                    container_alpn?.visibility = View.GONE
+                    container_allow_insecure?.visibility = View.GONE
+                    container_public_key?.visibility = View.GONE
+                    container_short_id?.visibility = View.GONE
+                    container_spider_x?.visibility = View.GONE
+                } else {
+                    container_sni?.visibility = View.VISIBLE
+                    container_fingerprint?.visibility = View.VISIBLE
+                    container_alpn?.visibility = View.VISIBLE
+                    if (streamSecuritys[position] == TLS) {
+                        container_allow_insecure?.visibility = View.VISIBLE
+                        container_public_key?.visibility = View.GONE
+                        container_short_id?.visibility = View.GONE
+                        container_spider_x?.visibility = View.GONE
+                    } else {
+                        container_allow_insecure?.visibility = View.GONE
+                        container_alpn?.visibility = View.GONE
+                        container_public_key?.visibility = View.VISIBLE
+                        container_short_id?.visibility = View.VISIBLE
+                        container_spider_x?.visibility = View.VISIBLE
+                    }
+                }
+            }
+
+            override fun onNothingSelected(p0: AdapterView<*>?) {
+                // do nothing
+            }
+        }
+        if (config != null) {
+            bindingServer(config)
         } else {
             clearServer()
         }
-        supportActionBar?.setDisplayHomeAsUpEnabled(true)
     }
 
     /**
      * bingding seleced server config
      */
-    fun bindingServer(vmess: AngConfig.VmessBean): Boolean {
-        et_remarks.text = Utils.getEditable(vmess.remarks)
+    private fun bindingServer(config: ServerConfig): Boolean {
+        val outbound = config.getProxyOutbound() ?: return false
 
-        et_address.text = Utils.getEditable(vmess.address)
-        et_port.text = Utils.getEditable(vmess.port.toString())
-        et_id.text = Utils.getEditable(vmess.id)
-        et_alterId.text = Utils.getEditable(vmess.alterId.toString())
-
-        val security = Utils.arrayFind(securitys, vmess.security)
+        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.WIREGUARD) {
+            et_public_key?.text =
+                Utils.getEditable(outbound.settings?.peers?.get(0)?.publicKey.orEmpty())
+            if (outbound.settings?.reserved == null) {
+                et_reserved1?.text = Utils.getEditable("0")
+                et_reserved2?.text = Utils.getEditable("0")
+                et_reserved3?.text = Utils.getEditable("0")
+            } else {
+                et_reserved1?.text =
+                    Utils.getEditable(outbound.settings?.reserved?.get(0).toString())
+                et_reserved2?.text =
+                    Utils.getEditable(outbound.settings?.reserved?.get(1).toString())
+                et_reserved3?.text =
+                    Utils.getEditable(outbound.settings?.reserved?.get(2).toString())
+            }
+            if (outbound.settings?.address == null) {
+                et_local_address?.text =
+                    Utils.getEditable("${WIREGUARD_LOCAL_ADDRESS_V4},${WIREGUARD_LOCAL_ADDRESS_V6}")
+            } else {
+                val list = outbound.settings?.address as List<*>
+                et_local_address?.text = Utils.getEditable(list.joinToString())
+            }
+            if (outbound.settings?.mtu == null) {
+                et_local_mtu?.text = Utils.getEditable(WIREGUARD_LOCAL_MTU)
+            } else {
+                et_local_mtu?.text = Utils.getEditable(outbound.settings?.mtu.toString())
+            }
+        }
+        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 network = Utils.arrayFind(networks, vmess.network)
-        if (network >= 0) {
-            sp_network.setSelection(network)
+            sp_security?.setSelection(security)
         }
 
-        val headerType = Utils.arrayFind(headertypes, vmess.headerType)
-        if (headerType >= 0) {
-            sp_header_type.setSelection(headerType)
-        }
-        et_request_host.text = Utils.getEditable(vmess.requestHost)
-        et_path.text = Utils.getEditable(vmess.path)
-
-        val streamSecurity = Utils.arrayFind(streamsecuritys, vmess.streamSecurity)
+        val streamSetting = config.outboundBean?.streamSettings ?: return true
+        val streamSecurity = Utils.arrayFind(streamSecuritys, streamSetting.security)
         if (streamSecurity >= 0) {
-            sp_stream_security.setSelection(streamSecurity)
+            sp_stream_security?.setSelection(streamSecurity)
+            (streamSetting.tlsSettings ?: streamSetting.realitySettings)?.let { tlsSetting ->
+                container_sni?.visibility = View.VISIBLE
+                container_fingerprint?.visibility = View.VISIBLE
+                container_alpn?.visibility = View.VISIBLE
+                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)
+                }
+                if (streamSetting.tlsSettings != null) {
+                    container_allow_insecure?.visibility = View.VISIBLE
+                    val allowinsecure =
+                        Utils.arrayFind(allowinsecures, tlsSetting.allowInsecure.toString())
+                    if (allowinsecure >= 0) {
+                        sp_allow_insecure?.setSelection(allowinsecure)
+                    }
+                    container_public_key?.visibility = View.GONE
+                    container_short_id?.visibility = View.GONE
+                    container_spider_x?.visibility = View.GONE
+                } else { // reality settings
+                    container_public_key?.visibility = View.VISIBLE
+                    et_public_key?.text = Utils.getEditable(tlsSetting.publicKey.orEmpty())
+                    container_short_id?.visibility = View.VISIBLE
+                    et_short_id?.text = Utils.getEditable(tlsSetting.shortId.orEmpty())
+                    container_spider_x?.visibility = View.VISIBLE
+                    et_spider_x?.text = Utils.getEditable(tlsSetting.spiderX.orEmpty())
+                    container_allow_insecure?.visibility = View.GONE
+                }
+            }
+            if (streamSetting.tlsSettings == null && streamSetting.realitySettings == null) {
+                container_sni?.visibility = View.GONE
+                container_fingerprint?.visibility = View.GONE
+                container_alpn?.visibility = View.GONE
+                container_allow_insecure?.visibility = View.GONE
+                container_public_key?.visibility = View.GONE
+                container_short_id?.visibility = View.GONE
+                container_spider_x?.visibility = View.GONE
+            }
+        }
+        val network = Utils.arrayFind(networks, streamSetting.network)
+        if (network >= 0) {
+            sp_network?.setSelection(network)
         }
         return true
     }
@@ -92,113 +329,258 @@ class ServerActivity : BaseActivity() {
     /**
      * clear or init server config
      */
-    fun clearServer(): Boolean {
+    private fun clearServer(): Boolean {
         et_remarks.text = null
         et_address.text = null
-        et_port.text = Utils.getEditable("10086")
+        et_port.text = Utils.getEditable(DEFAULT_PORT.toString())
         et_id.text = null
-        et_alterId.text = Utils.getEditable("64")
-        sp_security.setSelection(0)
-        sp_network.setSelection(0)
+        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_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)
+        et_public_key?.text = null
+        et_reserved1?.text = Utils.getEditable("0")
+        et_reserved2?.text = Utils.getEditable("0")
+        et_reserved3?.text = Utils.getEditable("0")
+        et_local_address?.text =
+            Utils.getEditable("${WIREGUARD_LOCAL_ADDRESS_V4},${WIREGUARD_LOCAL_ADDRESS_V6}")
+        et_local_mtu?.text = Utils.getEditable(WIREGUARD_LOCAL_MTU)
         return true
     }
 
     /**
      * save server config
      */
-    fun saveServer(): Boolean {
-        val vmess: AngConfig.VmessBean
-        if (edit_index >= 0) {
-            vmess = configs.vmess[edit_index]
-        } else {
-            vmess = AngConfig.VmessBean()
-        }
-
-        vmess.guid = edit_guid
-        vmess.remarks = et_remarks.text.toString()
-        vmess.address = et_address.text.toString()
-        vmess.port = Utils.parseInt(et_port.text.toString())
-        vmess.id = et_id.text.toString()
-        vmess.alterId = Utils.parseInt(et_alterId.text.toString())
-        vmess.security = securitys[sp_security.selectedItemPosition]
-        vmess.network = networks[sp_network.selectedItemPosition]
-
-        vmess.headerType = headertypes[sp_header_type.selectedItemPosition]
-        vmess.requestHost = et_request_host.text.toString()
-        vmess.path = et_path.text.toString()
-        vmess.streamSecurity = streamsecuritys[sp_stream_security.selectedItemPosition]
-
-        if (TextUtils.isEmpty(vmess.remarks)) {
+    private fun saveServer(): Boolean {
+        if (TextUtils.isEmpty(et_remarks.text.toString())) {
             toast(R.string.server_lab_remarks)
             return false
         }
-        if (TextUtils.isEmpty(vmess.address)) {
+        if (TextUtils.isEmpty(et_address.text.toString())) {
             toast(R.string.server_lab_address)
             return false
         }
-        if (TextUtils.isEmpty(vmess.port.toString()) || vmess.port <= 0) {
+        val port = Utils.parseInt(et_port.text.toString())
+        if (port <= 0) {
             toast(R.string.server_lab_port)
             return false
         }
-        if (TextUtils.isEmpty(vmess.id)) {
-            toast(R.string.server_lab_id)
+        val config =
+            MmkvManager.decodeServerConfig(editGuid) ?: ServerConfig.create(createConfigType)
+        if (config.configType != EConfigType.SOCKS && TextUtils.isEmpty(et_id.text.toString())) {
+            if (config.configType == EConfigType.TROJAN || config.configType == EConfigType.SHADOWSOCKS) {
+                toast(R.string.server_lab_id3)
+            } else {
+                toast(R.string.server_lab_id)
+            }
             return false
         }
-        if (TextUtils.isEmpty(vmess.alterId.toString()) || vmess.alterId < 0) {
-            toast(R.string.server_lab_alterid)
-            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
+            }
         }
 
-        if (AngConfigManager.addServer(vmess, edit_index) == 0) {
-            toast(R.string.toast_success)
-            finish()
-            return true
+        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)
+        }
+        val wireguard = config.outboundBean?.settings
+        wireguard?.peers?.get(0)?.let { _ ->
+            savePeer(wireguard, port)
+        }
+        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()
+        }
+    }
+
+    private fun savePeer(wireguard: V2rayConfig.OutboundBean.OutSettingsBean, port: Int) {
+        wireguard.secretKey = et_id.text.toString().trim()
+        wireguard.peers?.get(0)?.publicKey = et_public_key?.text.toString().trim()
+        wireguard.peers?.get(0)?.endpoint =
+            getIpv6Address(et_address.text.toString().trim()) + ":" + port
+        val reserved1 = Utils.parseInt(et_reserved1?.text.toString())
+        val reserved2 = Utils.parseInt(et_reserved2?.text.toString())
+        val reserved3 = Utils.parseInt(et_reserved3?.text.toString())
+        if (reserved1 > 0 || reserved2 > 0 || reserved3 > 0) {
+            wireguard.reserved = listOf(reserved1, reserved2, reserved3)
         } else {
-            toast(R.string.toast_failure)
-            return false
+            wireguard.reserved = null
+        }
+        wireguard.address = et_local_address?.text.toString().removeWhiteSpace().split(",")
+        wireguard.mtu = Utils.parseInt(et_local_mtu?.text.toString())
+    }
+
+    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
+        val utlsIndex = sp_stream_fingerprint?.selectedItemPosition ?: return
+        val alpnIndex = sp_stream_alpn?.selectedItemPosition ?: return
+        val publicKey = et_public_key?.text?.toString()?.trim() ?: return
+        val shortId = et_short_id?.text?.toString()?.trim() ?: return
+        val spiderX = et_spider_x?.text?.toString()?.trim() ?: 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(
+            streamSecurity = streamSecuritys[streamSecurity],
+            allowInsecure = allowInsecure,
+            sni = sni,
+            fingerprint = uTlsItems[utlsIndex],
+            alpns = alpns[alpnIndex],
+            publicKey = publicKey,
+            shortId = shortId,
+            spiderX = spiderX
+        )
+    }
+
+    private fun transportTypes(network: String?): Array<out String> {
+        return when (network) {
+            "tcp" -> {
+                tcpTypes
+            }
+
+            "kcp", "quic" -> {
+                kcpAndQuicTypes
+            }
+
+            "grpc" -> {
+                grpcModes
+            }
+
+            else -> {
+                arrayOf("---")
+            }
         }
     }
 
     /**
      * save server config
      */
-    fun deleteServer(): Boolean {
-        if (edit_index >= 0) {
-            alert(R.string.del_config_comfirm) {
-                positiveButton(android.R.string.ok) {
-                    if (AngConfigManager.removeServer(edit_index) == 0) {
-                        toast(R.string.toast_success)
-                        finish()
-                    } else {
-                        toast(R.string.toast_failure)
-                    }
+    private fun deleteServer(): Boolean {
+        if (editGuid.isNotEmpty()) {
+            if (editGuid != mainStorage?.decodeString(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()
                 }
-                show()
             }
-        } else {
         }
         return true
     }
 
-    override fun onCreateOptionsMenu(menu: Menu?): Boolean {
+    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)
+        val delButton = menu.findItem(R.id.del_config)
+        val saveButton = menu.findItem(R.id.save_config)
 
-        if (edit_index >= 0) {
+        if (editGuid.isNotEmpty()) {
             if (isRunning) {
-                if (edit_index == configs.index) {
-                    del_config?.isVisible = false
-                    save_config?.isVisible = false
-                }
+                delButton?.isVisible = false
+                saveButton?.isVisible = false
             }
         } else {
-            del_config?.isVisible = false
+            delButton?.isVisible = false
         }
 
         return super.onCreateOptionsMenu(menu)
@@ -209,10 +591,12 @@ class ServerActivity : BaseActivity() {
             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,147 @@
+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.editorkit.utils.EditorTheme
+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)
+
+        if (!Utils.getDarkModeStatus(this)) {
+            binding.editor.colorScheme = EditorTheme.INTELLIJ_LIGHT
+        }
+        binding.editor.language = JsonLanguage()
+        val config = MmkvManager.decodeServerConfig(editGuid)
+        if (config != null) {
+            bindingServer(config)
+        } else {
+            clearServer()
+        }
+    }
+
+    /**
+     * 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 = v2rayConfig.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

@@ -1,52 +1,24 @@
 package com.v2ray.ang.ui
 
 import android.content.Intent
-import android.content.SharedPreferences
-import android.net.Uri
 import android.os.Bundle
-import android.preference.CheckBoxPreference
-import android.preference.EditTextPreference
-import android.preference.Preference
-import android.preference.PreferenceFragment
-import com.v2ray.ang.BuildConfig
-import com.v2ray.ang.InappBuyActivity
-import com.v2ray.ang.R
+import android.text.TextUtils
+import android.view.View
+import androidx.activity.viewModels
+import androidx.preference.*
+import androidx.work.ExistingPeriodicWorkPolicy
+import androidx.work.PeriodicWorkRequest
+import androidx.work.multiprocess.RemoteWorkManager
+import com.v2ray.ang.AngApplication
 import com.v2ray.ang.AppConfig
-import com.v2ray.ang.extension.defaultDPreference
-import com.v2ray.ang.extension.onClick
+import com.v2ray.ang.R
+import com.v2ray.ang.service.SubscriptionUpdater
 import com.v2ray.ang.util.Utils
-import org.jetbrains.anko.act
-import org.jetbrains.anko.defaultSharedPreferences
-import org.jetbrains.anko.startActivity
-import org.jetbrains.anko.toast
-import libv2ray.Libv2ray
+import com.v2ray.ang.viewmodel.SettingsViewModel
+import java.util.concurrent.TimeUnit
 
 class SettingsActivity : BaseActivity() {
-    companion object {
-        //        const val PREF_BYPASS_MAINLAND = "pref_bypass_mainland"
-        //        const val PREF_START_ON_BOOT = "pref_start_on_boot"
-        const val PREF_PER_APP_PROXY = "pref_per_app_proxy"
-//        const val PREF_MUX_ENAimport libv2ray.Libv2rayBLED = "pref_mux_enabled"
-        const val PREF_SPEED_ENABLED = "pref_speed_enabled"
-        const val PREF_SNIFFING_ENABLED = "pref_sniffing_enabled"
-        const val PREF_LOCAL_DNS_ENABLED = "pref_local_dns_enabled"
-        const val PREF_REMOTE_DNS = "pref_remote_dns"
-        const val PREF_DOMESTIC_DNS = "pref_domestic_dns"
-
-//        const val PREF_SOCKS_PORT = "pref_socks_port"
-//        const val PREF_LANCONN_PORT = "pref_lanconn_port"
-
-        const val PREF_ROUTING_DOMAIN_STRATEGY = "pref_routing_domain_strategy"
-        const val PREF_ROUTING_MODE = "pref_routing_mode"
-        const val PREF_ROUTING_CUSTOM = "pref_routing_custom"
-//        const val PREF_DONATE = "pref_donate"
-        //        const val PREF_LICENSES = "pref_licenses"
-//        const val PREF_FEEDBACK = "pref_feedback"
-//        const val PREF_TG_GROUP = "pref_tg_group"
-        const val PREF_VERSION = "pref_version"
-        //        const val PREF_AUTO_RESTART = "pref_auto_restart"
-        const val PREF_FORWARD_IPV6 = "pref_forward_ipv6"
-    }
+    private val settingsViewModel: SettingsViewModel by viewModels()
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
@@ -54,39 +26,68 @@ class SettingsActivity : BaseActivity() {
 
         title = getString(R.string.title_settings)
 
-        supportActionBar?.setDisplayHomeAsUpEnabled(true)
+        settingsViewModel.startListenPreferenceChange()
     }
 
-    class SettingsFragment : PreferenceFragment(), SharedPreferences.OnSharedPreferenceChangeListener {
-        val perAppProxy by lazy { findPreference(PREF_PER_APP_PROXY) as CheckBoxPreference }
+    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) }
+        
+        private val mux by lazy { findPreference<CheckBoxPreference>(AppConfig.PREF_MUX_ENABLED) }
+        private val muxConcurrency by lazy { findPreference<EditTextPreference>(AppConfig.PREF_MUX_CONCURRENCY) }
+        private val muxXudpConcurrency by lazy { findPreference<EditTextPreference>(AppConfig.PREF_MUX_XUDP_CONCURRENCY) }
+        private val muxXudpQuic by lazy { findPreference<ListPreference>(AppConfig.PREF_MUX_XUDP_QUIC) }
+
+        private val fragment by lazy { findPreference<CheckBoxPreference>(AppConfig.PREF_FRAGMENT_ENABLED) }
+        private val fragmentPackets by lazy { findPreference<ListPreference>(AppConfig.PREF_FRAGMENT_PACKETS) }
+        private val fragmentLength by lazy { findPreference<EditTextPreference>(AppConfig.PREF_FRAGMENT_LENGTH) }
+        private val fragmentInterval by lazy { findPreference<EditTextPreference>(AppConfig.PREF_FRAGMENT_INTERVAL) }
+
         //        val autoRestart by lazy { findPreference(PREF_AUTO_RESTART) as CheckBoxPreference }
-        val remoteDns by lazy { findPreference(PREF_REMOTE_DNS) as EditTextPreference }
-        val domesticDns by lazy { findPreference(PREF_DOMESTIC_DNS) as EditTextPreference }
-
-        val enableLocalDns by lazy { findPreference(PREF_LOCAL_DNS_ENABLED) as CheckBoxPreference }
-        val forwardIpv6 by lazy { findPreference(PREF_FORWARD_IPV6) as CheckBoxPreference }
-
-//        val socksPort by lazy { findPreference(PREF_SOCKS_PORT) as EditTextPreference }
-//        val lanconnPort by lazy { findPreference(PREF_LANCONN_PORT) as EditTextPreference }
-
-        val routingCustom: Preference by lazy { findPreference(PREF_ROUTING_CUSTOM) }
-//        val donate: Preference by lazy { findPreference(PREF_DONATE) }
+        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) }
+        private val autoUpdateCheck by lazy { findPreference<CheckBoxPreference>(AppConfig.SUBSCRIPTION_AUTO_UPDATE) }
+        private val autoUpdateInterval by lazy { findPreference<EditTextPreference>(AppConfig.SUBSCRIPTION_AUTO_UPDATE_INTERVAL) }
         //        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) }
-        val version: Preference by lazy { findPreference(PREF_VERSION) }
 
-        override fun onCreate(savedInstanceState: Bundle?) {
-            super.onCreate(savedInstanceState)
+        private val mode by lazy { findPreference<ListPreference>(AppConfig.PREF_MODE) }
+
+        override fun onCreatePreferences(bundle: Bundle?, s: String?) {
             addPreferencesFromResource(R.xml.pref_settings)
 
-            routingCustom.onClick {
-                startActivity<RoutingSettingsActivity>()
+            routingCustom?.setOnPreferenceClickListener {
+                startActivity(Intent(activity, RoutingSettingsActivity::class.java))
+                false
             }
 
-//            donate.onClick {
-//                startActivity<InappBuyActivity>()
-//            }
+            autoUpdateCheck?.setOnPreferenceChangeListener { _, newValue ->
+                val value = newValue as Boolean
+                autoUpdateCheck?.isChecked = value
+                autoUpdateInterval?.isEnabled = value
+                autoUpdateInterval?.text?.toLong()?.let {
+                    if (newValue) configureUpdateTask(it) else cancelUpdateTask()
+                }
+                true
+            }
+
+            autoUpdateInterval?.setOnPreferenceChangeListener { _, any ->
+                var nval = any as String
+
+                // It must be greater than 15 minutes because WorkManager couldn't run tasks under 15 minutes intervals
+                nval =
+                    if (TextUtils.isEmpty(nval) || nval.toLong() < 15) AppConfig.SUBSCRIPTION_DEFAULT_UPDATE_INTERVAL else nval
+                autoUpdateInterval?.summary = nval
+                configureUpdateTask(nval.toLong())
+                true
+            }
 
 //            licenses.onClick {
 //                val fragment = LicensesDialogFragment.Builder(act)
@@ -110,71 +111,231 @@ class SettingsActivity : BaseActivity() {
 //                }
 //            }
 
-            perAppProxy.setOnPreferenceClickListener {
-                startActivity<PerAppProxyActivity>()
-                perAppProxy.isChecked = true
+            perAppProxy?.setOnPreferenceClickListener {
+                startActivity(Intent(activity, PerAppProxyActivity::class.java))
+                perAppProxy?.isChecked = true
                 false
             }
 
-            remoteDns.setOnPreferenceChangeListener { preference, any ->
+            remoteDns?.setOnPreferenceChangeListener { _, any ->
                 // remoteDns.summary = any as String
                 val nval = any as String
-                remoteDns.summary = if (nval == "") AppConfig.DNS_AGENT else nval
+                remoteDns?.summary = if (nval == "") AppConfig.DNS_AGENT else nval
                 true
             }
-            domesticDns.setOnPreferenceChangeListener { preference, any ->
+            domesticDns?.setOnPreferenceChangeListener { _, any ->
                 // domesticDns.summary = any as String
                 val nval = any as String
-                domesticDns.summary = if (nval == "") AppConfig.DNS_DIRECT else nval
+                domesticDns?.summary = if (nval == "") AppConfig.DNS_DIRECT else nval
                 true
             }
-//            socksPort.setOnPreferenceChangeListener { preference, any ->
-//                socksPort.summary = any as String
-//                true
-//            }
-//            lanconnPort.setOnPreferenceChangeListener { preference, any ->
-//                lanconnPort.summary = any as String
-//                true
-//            }
 
-            version.summary = "${BuildConfig.VERSION_NAME} (${Libv2ray.checkVersionX()})"
+            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"
+            mux?.setOnPreferenceChangeListener { _, newValue ->
+                updateMux(newValue as Boolean)
+                true
+            }
+            muxConcurrency?.setOnPreferenceChangeListener { _, newValue ->
+                updateMuxConcurrency(newValue as String)
+                true
+            }
+            muxXudpConcurrency?.setOnPreferenceChangeListener { _, newValue ->
+                updateMuxXudpConcurrency(newValue as String)
+                true
+            }
+
+            fragment?.setOnPreferenceChangeListener { _, newValue ->
+                updateFragment(newValue as Boolean)
+                true
+            }
+            fragmentPackets?.setOnPreferenceChangeListener { _, newValue ->
+                updateFragmentPackets(newValue as String)
+                true
+            }
+            fragmentLength?.setOnPreferenceChangeListener { _, newValue ->
+                updateFragmentLength(newValue as String)
+                true
+            }
+            fragmentInterval?.setOnPreferenceChangeListener { _, newValue ->
+                updateFragmentInterval(newValue as String)
+                true
+            }
         }
 
         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, "")
 
-            perAppProxy.isChecked = defaultSharedPreferences.getBoolean(PREF_PER_APP_PROXY, false)
-            remoteDns.summary = defaultSharedPreferences.getString(PREF_REMOTE_DNS, "")
-            domesticDns.summary = defaultSharedPreferences.getString(PREF_DOMESTIC_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)
+            updateMux(defaultSharedPreferences.getBoolean(AppConfig.PREF_MUX_ENABLED, false))
+            muxConcurrency?.summary = defaultSharedPreferences.getString(AppConfig.PREF_MUX_CONCURRENCY, "8")
+            muxXudpConcurrency?.summary = defaultSharedPreferences.getString(AppConfig.PREF_MUX_XUDP_CONCURRENCY, "8")
+            updateFragment(defaultSharedPreferences.getBoolean(AppConfig.PREF_FRAGMENT_ENABLED, false))
+            fragmentPackets?.summary = defaultSharedPreferences.getString(AppConfig.PREF_FRAGMENT_PACKETS, "tlshello")
+            fragmentLength?.summary = defaultSharedPreferences.getString(AppConfig.PREF_FRAGMENT_LENGTH, "50-100")
+            fragmentInterval?.summary = defaultSharedPreferences.getString(AppConfig.PREF_FRAGMENT_INTERVAL, "10-20")
+            autoUpdateInterval?.summary = defaultSharedPreferences.getString(AppConfig.SUBSCRIPTION_AUTO_UPDATE_INTERVAL,AppConfig.SUBSCRIPTION_DEFAULT_UPDATE_INTERVAL)
+            autoUpdateInterval?.isEnabled = defaultSharedPreferences.getBoolean(AppConfig.SUBSCRIPTION_AUTO_UPDATE, false)
 
-            if (remoteDns.summary == "") {
-                remoteDns.summary = AppConfig.DNS_AGENT
+            if (TextUtils.isEmpty(remoteDnsString)) {
+                remoteDnsString = AppConfig.DNS_AGENT
             }
-
-            if ( domesticDns.summary == "") {
-                domesticDns.summary = AppConfig.DNS_DIRECT
+            if (TextUtils.isEmpty(domesticDns?.summary)) {
+                domesticDns?.summary = AppConfig.DNS_DIRECT
             }
+            remoteDns?.summary = remoteDnsString
+            vpnDns?.summary =
+                defaultSharedPreferences.getString(AppConfig.PREF_VPN_DNS, remoteDnsString)
 
-//            socksPort.summary = defaultSharedPreferences.getString(PREF_SOCKS_PORT, "10808")
-//            lanconnPort.summary = defaultSharedPreferences.getString(PREF_LANCONN_PORT, "")
-
-            defaultSharedPreferences.registerOnSharedPreferenceChangeListener(this)
+            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
+            }
         }
 
-        override fun onStop() {
-            super.onStop()
-            defaultSharedPreferences.unregisterOnSharedPreferenceChangeListener(this)
+        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
+                    )
+                )
+            }
         }
 
-        override fun onSharedPreferenceChanged(sharedPreferences: SharedPreferences, key: String?) {
-            when (key) {
-//                PREF_AUTO_RESTART ->
-//                    act.defaultDPreference.setPrefBoolean(key, sharedPreferences.getBoolean(key, false))
+        private fun updateLocalDns(enabled: Boolean) {
+            fakeDns?.isEnabled = enabled
+            localDnsPort?.isEnabled = enabled
+            vpnDns?.isEnabled = !enabled
+        }
 
-                PREF_PER_APP_PROXY ->
-                    act.defaultDPreference.setPrefBoolean(key, sharedPreferences.getBoolean(key, false))
+        private fun configureUpdateTask(interval: Long) {
+            val rw = RemoteWorkManager.getInstance(AngApplication.application)
+            rw.cancelUniqueWork(AppConfig.SUBSCRIPTION_UPDATE_TASK_NAME)
+            rw.enqueueUniquePeriodicWork(
+                AppConfig.SUBSCRIPTION_UPDATE_TASK_NAME,
+                ExistingPeriodicWorkPolicy.UPDATE,
+                PeriodicWorkRequest.Builder(
+                    SubscriptionUpdater.UpdateTask::class.java,
+                    interval,
+                    TimeUnit.MINUTES
+                )
+                    .apply {
+                        setInitialDelay(interval, TimeUnit.MINUTES)
+                    }
+                    .build()
+            )
+        }
+
+        private fun cancelUpdateTask() {
+            val rw = RemoteWorkManager.getInstance(AngApplication.application)
+            rw.cancelUniqueWork(AppConfig.SUBSCRIPTION_UPDATE_TASK_NAME)
+        }
+            
+        private fun updateMux(enabled: Boolean) {
+            val defaultSharedPreferences = PreferenceManager.getDefaultSharedPreferences(requireActivity())
+            muxConcurrency?.isEnabled = enabled
+            muxXudpConcurrency?.isEnabled = enabled
+            muxXudpQuic?.isEnabled = enabled
+            if (enabled) {
+                updateMuxConcurrency(defaultSharedPreferences.getString(AppConfig.PREF_MUX_CONCURRENCY, "8"))
+                updateMuxXudpConcurrency(defaultSharedPreferences.getString(AppConfig.PREF_MUX_XUDP_CONCURRENCY, "8"))
             }
         }
+
+        private fun updateMuxConcurrency(value: String?) {
+            if (value == null) {
+            } else {
+                val concurrency = value.toIntOrNull() ?: 8
+                muxConcurrency?.summary = concurrency.toString()
+            }
+        }
+
+        private fun updateMuxXudpConcurrency(value: String?) {
+            if (value == null) {
+                muxXudpQuic?.isEnabled = true
+            } else {
+                val concurrency = value.toIntOrNull() ?: 8
+                muxXudpConcurrency?.summary = concurrency.toString()
+                muxXudpQuic?.isEnabled = concurrency >= 0
+            }
+        }
+
+        private fun updateFragment(enabled: Boolean) {
+            val defaultSharedPreferences = PreferenceManager.getDefaultSharedPreferences(requireActivity())
+            fragmentPackets?.isEnabled = enabled
+            fragmentLength?.isEnabled = enabled
+            fragmentInterval?.isEnabled = enabled
+            if (enabled) {
+                updateFragmentPackets(defaultSharedPreferences.getString(AppConfig.PREF_FRAGMENT_PACKETS, "tlshello"))
+                updateFragmentLength(defaultSharedPreferences.getString(AppConfig.PREF_FRAGMENT_LENGTH, "50-100"))
+                updateFragmentInterval(defaultSharedPreferences.getString(AppConfig.PREF_FRAGMENT_INTERVAL, "10-20"))
+            }
+        }
+        private fun updateFragmentPackets(value: String?) {
+            fragmentPackets?.summary = value.toString()
+        }
+        private fun updateFragmentLength(value: String?) {
+            fragmentLength?.summary = value.toString()
+        }
+        private fun updateFragmentInterval(value: String?) {
+            fragmentInterval?.summary = value.toString()
+        }
     }
 
-}
+    fun onModeHelpClicked(view: View) {
+        Utils.openUri(this, AppConfig.v2rayNGWikiMode)
+    }
+}

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

@@ -4,120 +4,124 @@ import android.os.Bundle
 import android.text.TextUtils
 import android.view.Menu
 import android.view.MenuItem
+import androidx.appcompat.app.AlertDialog
+import androidx.work.Constraints
+import androidx.work.ExistingPeriodicWorkPolicy
+import androidx.work.NetworkType
+import androidx.work.PeriodicWorkRequest
+import androidx.work.multiprocess.RemoteWorkManager
+import com.google.gson.Gson
+import com.tencent.mmkv.MMKV
+import com.v2ray.ang.AngApplication
 import com.v2ray.ang.R
-import com.v2ray.ang.dto.AngConfig
-import com.v2ray.ang.util.AngConfigManager
+import com.v2ray.ang.databinding.ActivitySubEditBinding
+import com.v2ray.ang.dto.SubscriptionItem
+import com.v2ray.ang.extension.toast
+import com.v2ray.ang.service.SubscriptionUpdater
+import com.v2ray.ang.util.MmkvManager
 import com.v2ray.ang.util.Utils
-import kotlinx.android.synthetic.main.activity_sub_edit.*
-import org.jetbrains.anko.*
-
+import java.util.concurrent.TimeUnit
 
 class SubEditActivity : BaseActivity() {
+    private lateinit var binding: ActivitySubEditBinding
 
     var del_config: MenuItem? = null
     var save_config: MenuItem? = null
 
-    private lateinit var configs: AngConfig
-    private var edit_index: Int = -1 //当前编辑的
+    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)
-        setContentView(R.layout.activity_sub_edit)
-
-        configs = AngConfigManager.configs
-        edit_index = intent.getIntExtra("position", -1)
-
+        binding = ActivitySubEditBinding.inflate(layoutInflater)
+        val view = binding.root
+        setContentView(view)
         title = getString(R.string.title_sub_setting)
 
-        if (edit_index >= 0) {
-            bindingServer(configs.subItem[edit_index])
+        val json = subStorage?.decodeString(editSubId)
+        if (!json.isNullOrBlank()) {
+            bindingServer(Gson().fromJson(json, SubscriptionItem::class.java))
         } else {
             clearServer()
         }
-        supportActionBar?.setDisplayHomeAsUpEnabled(true)
     }
 
     /**
      * bingding seleced server config
      */
-    fun bindingServer(subItem: AngConfig.SubItemBean): Boolean {
-        et_remarks.text = Utils.getEditable(subItem.remarks)
-        et_url.text = Utils.getEditable(subItem.url)
-
+    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
+        binding.autoUpdateCheck.isChecked = subItem.autoUpdate
         return true
     }
 
     /**
      * clear or init server config
      */
-    fun clearServer(): Boolean {
-        et_remarks.text = null
-        et_url.text = null
-
+    private fun clearServer(): Boolean {
+        binding.etRemarks.text = null
+        binding.etUrl.text = null
+        binding.chkEnable.isChecked = true
         return true
     }
 
     /**
      * save server config
      */
-    fun saveServer(): Boolean {
-        val subItem: AngConfig.SubItemBean
-        if (edit_index >= 0) {
-            subItem = configs.subItem[edit_index]
+    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 {
-            subItem = AngConfig.SubItemBean()
+            subId = Utils.getUuid()
+            subItem = SubscriptionItem()
         }
 
-        subItem.remarks = et_remarks.text.toString()
-        subItem.url = et_url.text.toString()
+        subItem.remarks = binding.etRemarks.text.toString()
+        subItem.url = binding.etUrl.text.toString()
+        subItem.enabled = binding.chkEnable.isChecked
+        subItem.autoUpdate = binding.autoUpdateCheck.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
-        }
+//        if (TextUtils.isEmpty(subItem.url)) {
+//            toast(R.string.sub_setting_url)
+//            return false
+//        }
 
-        if (AngConfigManager.addSubItem(subItem, edit_index) == 0) {
-            toast(R.string.toast_success)
-            finish()
-            return true
-        } else {
-            toast(R.string.toast_failure)
-            return false
-        }
+        subStorage?.encode(subId, Gson().toJson(subItem))
+        toast(R.string.toast_success)
+        finish()
+        return true
     }
 
     /**
      * save server config
      */
-    fun deleteServer(): Boolean {
-        if (edit_index >= 0) {
-            alert(R.string.del_config_comfirm) {
-                positiveButton(android.R.string.ok) {
-                    if (AngConfigManager.removeSubItem(edit_index) == 0) {
-                        toast(R.string.toast_success)
+    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()
-                    } else {
-                        toast(R.string.toast_failure)
                     }
-                }
-                show()
-            }
-        } else {
+                    .show()
         }
         return true
     }
 
-    override fun onCreateOptionsMenu(menu: Menu?): Boolean {
+    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)
+        del_config = menu.findItem(R.id.del_config)
+        save_config = menu.findItem(R.id.save_config)
 
-        if (edit_index >= 0) {
-        } else {
+        if (editSubId.isEmpty()) {
             del_config?.isVisible = false
         }
 
@@ -135,4 +139,5 @@ class SubEditActivity : BaseActivity() {
         }
         else -> super.onOptionsItemSelected(item)
     }
-}
+
+}

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

@@ -1,51 +1,53 @@
 package com.v2ray.ang.ui
 
-import android.support.v7.widget.LinearLayoutManager
+import android.content.Intent
+import androidx.recyclerview.widget.LinearLayoutManager
 import android.view.Menu
 import android.view.MenuItem
 import com.v2ray.ang.R
-import kotlinx.android.synthetic.main.activity_sub_setting.*
 import android.os.Bundle
-import org.jetbrains.anko.startActivity
+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)
-        setContentView(R.layout.activity_sub_setting)
+        binding = ActivitySubSettingBinding.inflate(layoutInflater)
+        val view = binding.root
+        setContentView(view)
 
         title = getString(R.string.title_sub_setting)
 
-        recycler_view.setHasFixedSize(true)
-        recycler_view.layoutManager = LinearLayoutManager(this)
-        recycler_view.adapter = adapter
-
-        supportActionBar?.setDisplayHomeAsUpEnabled(true)
+        binding.recyclerView.setHasFixedSize(true)
+        binding.recyclerView.layoutManager = LinearLayoutManager(this)
+        binding.recyclerView.adapter = adapter
     }
 
     override fun onResume() {
         super.onResume()
-        adapter.updateConfigList()
+        subscriptions = MmkvManager.decodeSubscriptions()
+        adapter.notifyDataSetChanged()
     }
 
-    override fun onCreateOptionsMenu(menu: Menu?): Boolean {
+    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
+        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<SubEditActivity>("position" to -1)
-            adapter.updateConfigList()
+            startActivity(Intent(this, SubEditActivity::class.java))
             true
         }
         else -> super.onOptionsItemSelected(item)
     }
-
-
-}
+}

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

@@ -1,62 +1,105 @@
 package com.v2ray.ang.ui
 
+import android.content.Intent
 import android.graphics.Color
-import android.support.v7.widget.RecyclerView
+import android.text.TextUtils
+import android.view.LayoutInflater
 import android.view.View
+import androidx.recyclerview.widget.RecyclerView
 import android.view.ViewGroup
+import androidx.appcompat.app.AlertDialog
+import com.google.gson.Gson
+import com.tencent.mmkv.MMKV
 import com.v2ray.ang.R
-import com.v2ray.ang.dto.AngConfig
+import com.v2ray.ang.databinding.ItemQrcodeBinding
+import com.v2ray.ang.databinding.ItemRecyclerSubSettingBinding
+import com.v2ray.ang.dto.EConfigType
+import com.v2ray.ang.extension.toast
 import com.v2ray.ang.util.AngConfigManager
-import kotlinx.android.synthetic.main.item_recycler_sub_setting.view.*
-import org.jetbrains.anko.*
+import com.v2ray.ang.util.MmkvManager
+import com.v2ray.ang.util.QRCodeDecoder
+import com.v2ray.ang.util.Utils
 
-class SubSettingRecyclerAdapter(val activity: SubSettingActivity) : RecyclerView.Adapter<SubSettingRecyclerAdapter.BaseViewHolder>() {
+class SubSettingRecyclerAdapter(val activity: SubSettingActivity) :
+    RecyclerView.Adapter<SubSettingRecyclerAdapter.MainViewHolder>() {
 
     private var mActivity: SubSettingActivity = activity
-    private lateinit var configs: AngConfig
+    private val subStorage by lazy { MMKV.mmkvWithID(MmkvManager.ID_SUB, MMKV.MULTI_PROCESS_MODE) }
 
-    init {
-        updateConfigList()
+    private val share_method: Array<out String> by lazy {
+        mActivity.resources.getStringArray(R.array.share_sub_method)
     }
 
-    override fun getItemCount() = configs.subItem.count()
+    override fun getItemCount() = mActivity.subscriptions.size
 
-    override fun onBindViewHolder(holder: BaseViewHolder, position: Int) {
-        if (holder is MainViewHolder) {
-            val remarks = configs.subItem[position].remarks
-            val url = configs.subItem[position].url
-
-            holder.name.text = remarks
-            holder.url.text = url
-            holder.itemView.backgroundColor = Color.TRANSPARENT
-
-            holder.layout_edit.setOnClickListener {
-                mActivity.startActivity<SubEditActivity>("position" to position)
-            }
+    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)
+        }
+
+        if (TextUtils.isEmpty(subItem.url)) {
+            holder.itemSubSettingBinding.layoutShare.visibility = View.INVISIBLE
+        } else {
+            holder.itemSubSettingBinding.layoutShare.setOnClickListener {
+                AlertDialog.Builder(mActivity)
+                    .setItems(share_method.asList().toTypedArray()) { _, i ->
+                        try {
+                            when (i) {
+                                0 -> {
+                                    val ivBinding =
+                                        ItemQrcodeBinding.inflate(LayoutInflater.from(mActivity))
+                                    ivBinding.ivQcode.setImageBitmap(
+                                        QRCodeDecoder.createQRCode(
+                                            subItem.url
+
+                                        )
+                                    )
+                                    AlertDialog.Builder(mActivity).setView(ivBinding.root).show()
+                                }
+
+                                1 -> {
+                                    Utils.setClipboard(mActivity, subItem.url)
+                                }
+
+                                else -> mActivity.toast("else")
+                            }
+                        } catch (e: Exception) {
+                            e.printStackTrace()
+                        }
+                    }.show()
+            }
         }
     }
 
-    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): BaseViewHolder {
-        return MainViewHolder(parent.context.layoutInflater
-                .inflate(R.layout.item_recycler_sub_setting, parent, false))
-    }
-
-    fun updateConfigList() {
-        configs = AngConfigManager.configs
-        notifyDataSetChanged()
-    }
-
-//    fun updateSelectedItem() {
-//        notifyItemChanged(configs.index)
-//    }
-
-    open class BaseViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView)
-
-    class MainViewHolder(itemView: View) : BaseViewHolder(itemView) {
-        val name = itemView.tv_name!!
-        val url = itemView.tv_url!!
-        val layout_edit = itemView.layout_edit!!
+    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

@@ -1,38 +1,45 @@
 package com.v2ray.ang.ui
 
-import android.app.Activity
+import androidx.appcompat.app.AppCompatActivity
 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 com.v2ray.ang.util.AngConfigManager
 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 kotlinx.android.synthetic.main.activity_tasker.*
-
+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)
-        setContentView(R.layout.activity_tasker)
+        binding = ActivityTaskerBinding.inflate(layoutInflater)
+        val view = binding.root
+        setContentView(view)
 
         //add def value
         lstData.add("Default")
         lstGuid.add(AppConfig.TASKER_DEFAULT_GUID)
 
-        AngConfigManager.configs.vmess.forEach {
-            lstData.add(it.remarks)
-            lstGuid.add(it.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)
@@ -51,13 +58,13 @@ class TaskerActivity : BaseActivity() {
             if (switch == null || TextUtils.isEmpty(guid)) {
                 return
             } else {
-                switch_start_service.isChecked = switch
+                binding.switchStartService.isChecked = switch
                 val pos = lstGuid.indexOf(guid.toString())
                 if (pos >= 0) {
                     listview?.setItemChecked(pos, true)
                 }
             }
-        } catch (e: WriterException) {
+        } catch (e: Exception) {
             e.printStackTrace()
 
         }
@@ -70,28 +77,26 @@ class TaskerActivity : BaseActivity() {
         }
 
         val extraBundle = Bundle()
-        extraBundle.putBoolean(AppConfig.TASKER_EXTRA_BUNDLE_SWITCH, switch_start_service.isChecked)
+        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]
-        var blurb = ""
-
-        if (switch_start_service.isChecked) {
-            blurb = "Start $remarks"
+        val blurb = if (binding.switchStartService.isChecked) {
+            "Start $remarks"
         } else {
-            blurb = "Stop $remarks"
+            "Stop $remarks"
         }
 
         intent.putExtra(AppConfig.TASKER_EXTRA_BUNDLE, extraBundle)
         intent.putExtra(AppConfig.TASKER_EXTRA_STRING_BLURB, blurb)
-        setResult(Activity.RESULT_OK, intent)
+        setResult(AppCompatActivity.RESULT_OK, intent)
         finish()
     }
 
-    override fun onCreateOptionsMenu(menu: Menu?): Boolean {
+    override fun onCreateOptionsMenu(menu: Menu): Boolean {
         menuInflater.inflate(R.menu.action_server, menu)
-        val del_config = menu?.findItem(R.id.del_config)
+        val del_config = menu.findItem(R.id.del_config)
         del_config?.isVisible = false
         return super.onCreateOptionsMenu(menu)
     }

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

@@ -0,0 +1,86 @@
+package com.v2ray.ang.ui
+
+import android.content.Intent
+import android.net.Uri
+import android.os.Bundle
+import com.v2ray.ang.AppConfig
+import com.v2ray.ang.R
+import com.v2ray.ang.databinding.ActivityLogcatBinding
+import com.v2ray.ang.extension.toast
+import com.v2ray.ang.util.AngConfigManager
+import java.net.URLDecoder
+
+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)
+
+        try {
+            intent.apply {
+                if (action == Intent.ACTION_SEND) {
+                    if ("text/plain" == type) {
+                        intent.getStringExtra(Intent.EXTRA_TEXT)?.let {
+                            val uri = Uri.parse(it)
+                            if (uri.scheme?.startsWith(AppConfig.PROTOCOL_HTTPS) == true || uri.scheme?.startsWith(
+                                    AppConfig.PROTOCOL_HTTP
+                                ) == true
+                            ) {
+                                val name = uri.getQueryParameter("name") ?: "Subscription"
+                                importSubscription(it, name)
+                            } else {
+                                importConfig(it)
+                            }
+                        }
+                    }
+                } else if (action == Intent.ACTION_VIEW) {
+                    when (data?.host) {
+                        "install-config" -> {
+                            val uri: Uri? = intent.data
+                            val shareUrl: String = uri?.getQueryParameter("url")!!
+                            toast(shareUrl)
+                            importConfig(shareUrl)
+                        }
+
+                        "install-sub" -> {
+                            val uri: Uri? = intent.data
+                            val url = uri?.getQueryParameter("url")!!
+                            val name = uri.getQueryParameter("name") ?: "Subscription"
+                            importSubscription(url, name)
+                        }
+
+                        else -> {
+                            toast(R.string.toast_failure)
+                        }
+                    }
+                }
+
+            }
+
+
+            startActivity(Intent(this, MainActivity::class.java))
+            finish()
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+    }
+
+    private fun importSubscription(url: String, name: String) {
+        val decodedUrl = URLDecoder.decode(url, "UTF-8")
+
+        val check = AngConfigManager.importSubscription(name, decodedUrl)
+        if (check) toast(R.string.import_subscription_success) else toast(R.string.import_subscription_failure)
+    }
+
+    private fun importConfig(shareUrl: String) {
+        val count = AngConfigManager.importBatchConfig(shareUrl, "", false)
+        if (count > 0) {
+            toast(R.string.toast_success)
+        } else {
+            toast(R.string.toast_failure)
+        }
+    }
+}

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

@@ -0,0 +1,295 @@
+package com.v2ray.ang.ui
+
+import android.Manifest
+import android.annotation.SuppressLint
+import android.content.Intent
+import android.net.Uri
+import android.os.Build
+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.google.gson.Gson
+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.dto.AssetUrlItem
+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) }
+    private val assetStorage by lazy { MMKV.mmkvWithID(MmkvManager.ID_ASSET, MMKV.MULTI_PROCESS_MODE) }
+
+    val extDir by lazy { File(Utils.userAssetPath(this)) }
+    val builtInGeoFiles = 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)
+
+        binding.recyclerView.setHasFixedSize(true)
+        binding.recyclerView.layoutManager = LinearLayoutManager(this)
+        binding.recyclerView.adapter = UserAssetAdapter()
+    }
+
+    override fun onResume() {
+        super.onResume()
+        binding.recyclerView.adapter?.notifyDataSetChanged()
+    }
+
+    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.add_url -> {
+            val intent = Intent(this, UserAssetUrlActivity::class.java)
+            startActivity(intent)
+            true
+        }
+        R.id.download_file -> {
+            downloadGeoFiles()
+            true
+        }
+
+        else -> super.onOptionsItemSelected(item)
+    }
+
+    private fun showFileChooser() {
+        val permission = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            Manifest.permission.READ_MEDIA_IMAGES
+        } else {
+            Manifest.permission.READ_EXTERNAL_STORAGE
+        }
+        RxPermissions(this)
+            .request(permission)
+            .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)
+                }
+            } else
+                toast(R.string.toast_permission_denied)
+        }
+    }
+
+    private val chooseFile =
+        registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { it ->
+            val uri = it.data?.data
+            if (it.resultCode == RESULT_OK && uri != null) {
+                val assetId = Utils.getUuid()
+                try {
+                    val assetItem = AssetUrlItem(
+                        getCursorName(uri) ?: uri.toString(),
+                        "file"
+                    )
+
+                    // check remarks unique
+                    val assetList = MmkvManager.decodeAssetUrls()
+                    if (assetList.any { it.second.remarks == assetItem.remarks && it.first != assetId }) {
+                        toast(R.string.msg_remark_is_duplicate)
+                        return@registerForActivityResult
+                    }
+                    assetStorage?.encode(assetId, Gson().toJson(assetItem))
+                    copyFile(uri)
+                } catch (e: Exception) {
+                    toast(R.string.toast_asset_copy_failed)
+                    MmkvManager.removeAssetUrl(assetId)
+                }
+            }
+        }
+
+    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)
+        var assets = MmkvManager.decodeAssetUrls()
+        assets = addBuiltInGeoItems(assets)
+
+        assets.forEach {
+            //toast(getString(R.string.msg_downloading_content) + it)
+            lifecycleScope.launch(Dispatchers.IO) {
+                val result = downloadGeo(it.second, 60000, httpPort)
+                launch(Dispatchers.Main) {
+                    if (result) {
+                        toast(getString(R.string.toast_success) + " " + it.second.remarks)
+                        binding.recyclerView.adapter?.notifyDataSetChanged()
+                    } else {
+                        toast(getString(R.string.toast_failure) + " " + it.second.remarks)
+                    }
+                }
+            }
+        }
+    }
+
+    private fun downloadGeo(item: AssetUrlItem, timeout: Int, httpPort: Int): Boolean {
+        val targetTemp = File(extDir, item.remarks + "_temp")
+        val target = File(extDir, item.remarks)
+        var conn: HttpURLConnection? = null
+        //Log.d(AppConfig.ANG_PACKAGE, url)
+
+        try {
+            conn = URL(item.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()
+        }
+    }
+    private fun addBuiltInGeoItems(assets: List<Pair<String, AssetUrlItem>>): List<Pair<String, AssetUrlItem>> {
+        val list = mutableListOf<Pair<String, AssetUrlItem>>()
+        builtInGeoFiles.forEach {
+            list.add(Utils.getUuid() to AssetUrlItem(
+                it,
+                AppConfig.geoUrl + it
+            )
+            )
+        }
+
+        return list + assets
+    }
+
+    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) {
+            var assets = MmkvManager.decodeAssetUrls();
+            assets = addBuiltInGeoItems(assets);
+            val item = assets.getOrNull(position) ?: return
+//            file with name == item.second.remarks
+            val file = extDir.listFiles()?.find { it.name == item.second.remarks }
+
+            holder.itemUserAssetBinding.assetName.text = item.second.remarks
+
+            if (file != null) {
+                val dateFormat = DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM)
+                holder.itemUserAssetBinding.assetProperties.text =
+                    "${file.length().toTrafficString()}  •  ${dateFormat.format(Date(file.lastModified()))}"
+            } else {
+                holder.itemUserAssetBinding.assetProperties.text = getString(R.string.msg_file_not_found)
+            }
+
+            if (item.second.remarks in builtInGeoFiles) {
+                holder.itemUserAssetBinding.layoutEdit.visibility = GONE
+                holder.itemUserAssetBinding.layoutRemove.visibility = GONE
+            } else {
+                holder.itemUserAssetBinding.layoutEdit.visibility = item.second.url.let { if (it == "file") GONE else VISIBLE }
+                holder.itemUserAssetBinding.layoutRemove.visibility = VISIBLE
+            }
+
+            holder.itemUserAssetBinding.layoutEdit.setOnClickListener {
+                val intent = Intent(this@UserAssetActivity, UserAssetUrlActivity::class.java)
+                intent.putExtra("assetId", item.first)
+                startActivity(intent)
+            }
+            holder.itemUserAssetBinding.layoutRemove.setOnClickListener {
+                file?.delete()
+                MmkvManager.removeAssetUrl(item.first)
+                binding.recyclerView.adapter?.notifyItemRemoved(position)
+            }
+        }
+
+        override fun getItemCount(): Int {
+            var assets = MmkvManager.decodeAssetUrls();
+            assets = addBuiltInGeoItems(assets);
+            return assets.size
+        }
+    }
+
+    class UserAssetViewHolder(val itemUserAssetBinding: ItemRecyclerUserAssetBinding) :
+        RecyclerView.ViewHolder(itemUserAssetBinding.root)
+}

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

@@ -0,0 +1,145 @@
+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.ActivityUserAssetUrlBinding
+import com.v2ray.ang.dto.AssetUrlItem
+import com.v2ray.ang.extension.toast
+import com.v2ray.ang.util.MmkvManager
+import com.v2ray.ang.util.Utils
+import java.io.File
+
+class UserAssetUrlActivity : BaseActivity() {
+    private lateinit var binding: ActivityUserAssetUrlBinding
+
+    var del_config: MenuItem? = null
+    var save_config: MenuItem? = null
+
+    val extDir by lazy { File(Utils.userAssetPath(this)) }
+    private val assetStorage by lazy { MMKV.mmkvWithID(MmkvManager.ID_ASSET, MMKV.MULTI_PROCESS_MODE) }
+    private val editAssetId by lazy { intent.getStringExtra("assetId").orEmpty() }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        binding = ActivityUserAssetUrlBinding.inflate(layoutInflater)
+        val view = binding.root
+        setContentView(view)
+        title = getString(R.string.title_user_asset_add_url)
+
+        val json = assetStorage?.decodeString(editAssetId)
+        if (!json.isNullOrBlank()) {
+            bindingAsset(Gson().fromJson(json, AssetUrlItem::class.java))
+        } else {
+            clearAsset()
+        }
+    }
+
+    /**
+     * bingding seleced asset config
+     */
+    private fun bindingAsset(assetItem: AssetUrlItem): Boolean {
+        binding.etRemarks.text = Utils.getEditable(assetItem.remarks)
+        binding.etUrl.text = Utils.getEditable(assetItem.url)
+        return true
+    }
+
+    /**
+     * clear or init asset config
+     */
+    private fun clearAsset(): Boolean {
+        binding.etRemarks.text = null
+        binding.etUrl.text = null
+        return true
+    }
+
+    /**
+     * save asset config
+     */
+    private fun saveServer(): Boolean {
+        val assetItem: AssetUrlItem
+        val json = assetStorage?.decodeString(editAssetId)
+        var assetId = editAssetId
+        if (!json.isNullOrBlank()) {
+            assetItem = Gson().fromJson(json, AssetUrlItem::class.java)
+
+            // remove file associated with the asset
+            val file = extDir.resolve(assetItem.remarks)
+            if (file.exists()) {
+                file.delete()
+            }
+        } else {
+            assetId = Utils.getUuid()
+            assetItem = AssetUrlItem()
+        }
+
+        assetItem.remarks = binding.etRemarks.text.toString()
+        assetItem.url = binding.etUrl.text.toString()
+
+        // check remarks unique
+        val assetList = MmkvManager.decodeAssetUrls()
+        if (assetList.any { it.second.remarks == assetItem.remarks && it.first != assetId }) {
+            toast(R.string.msg_remark_is_duplicate)
+            return false
+        }
+
+
+        if (TextUtils.isEmpty(assetItem.remarks)) {
+            toast(R.string.sub_setting_remarks)
+            return false
+        }
+        if (TextUtils.isEmpty(assetItem.url)) {
+            toast(R.string.title_url)
+            return false
+        }
+
+        assetStorage?.encode(assetId, Gson().toJson(assetItem))
+        toast(R.string.toast_success)
+        finish()
+        return true
+    }
+
+    /**
+     * save server config
+     */
+    private fun deleteServer(): Boolean {
+        if (editAssetId.isNotEmpty()) {
+            AlertDialog.Builder(this).setMessage(R.string.del_config_comfirm)
+                .setPositiveButton(android.R.string.ok) { _, _ ->
+                    MmkvManager.removeAssetUrl(editAssetId)
+                    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 (editAssetId.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/util/AppManagerUtil.kt

@@ -16,13 +16,13 @@ object AppManagerUtil {
         val apps = ArrayList<AppInfo>()
 
         for (pkg in packages) {
-            if (!pkg.hasInternetPermission) continue
+            if (!pkg.hasInternetPermission && pkg.packageName != "android") continue
 
             val applicationInfo = pkg.applicationInfo
 
             val appName = applicationInfo.loadLabel(packageManager).toString()
             val appIcon = applicationInfo.loadIcon(packageManager)
-            val isSystemApp = (applicationInfo.flags and ApplicationInfo.FLAG_SYSTEM) > 0
+            val isSystemApp = applicationInfo.flags and ApplicationInfo.FLAG_SYSTEM > 0
 
             val appInfo = AppInfo(appName, pkg.packageName, appIcon, isSystemApp, 0)
             apps.add(appInfo)
@@ -31,7 +31,7 @@ object AppManagerUtil {
         return apps
     }
 
-    fun rxLoadNetworkAppList(ctx: Context): Observable<ArrayList<AppInfo>> = Observable.create {
+    fun rxLoadNetworkAppList(ctx: Context): Observable<ArrayList<AppInfo>> = Observable.unsafeCreate {
         it.onNext(loadNetworkAppList(ctx))
     }
 
@@ -40,4 +40,4 @@ object AppManagerUtil {
             val permissions = requestedPermissions
             return permissions?.any { it == Manifest.permission.INTERNET } ?: false
         }
-}
+}

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

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

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

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

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

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

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

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

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

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

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

@@ -4,49 +4,34 @@ import android.content.ClipboardManager
 import android.content.Context
 import android.text.Editable
 import android.util.Base64
-import com.google.zxing.WriterException
-import android.graphics.Bitmap
-import com.google.zxing.BarcodeFormat
-import com.google.zxing.qrcode.QRCodeWriter
-import com.google.zxing.EncodeHintType
 import java.util.*
-import kotlin.collections.HashMap
-import android.app.ActivityManager
 import android.content.ClipData
 import android.content.Intent
-import android.content.res.AssetManager
+import android.content.pm.PackageManager
+import android.content.res.Configuration.UI_MODE_NIGHT_MASK
+import android.content.res.Configuration.UI_MODE_NIGHT_NO
 import android.net.Uri
-import android.os.SystemClock
-import android.text.TextUtils
-import android.text.method.ScrollingMovementMethod
+import android.os.Build
+import android.os.LocaleList
+import android.provider.Settings
 import android.util.Log
 import android.util.Patterns
-import android.view.View
 import android.webkit.URLUtil
-import com.v2ray.ang.AngApplication
+import com.tencent.mmkv.MMKV
 import com.v2ray.ang.AppConfig
+import com.v2ray.ang.AppConfig.ANG_PACKAGE
+import com.v2ray.ang.BuildConfig
 import com.v2ray.ang.R
-import com.v2ray.ang.extension.responseLength
-import com.v2ray.ang.service.V2RayVpnService
-import com.v2ray.ang.ui.SettingsActivity
-import kotlinx.android.synthetic.main.activity_logcat.*
-import me.dozen.dpreference.DPreference
-import org.jetbrains.anko.toast
-import org.jetbrains.anko.uiThread
-import java.io.BufferedReader
-import java.io.File
-import java.io.IOException
-import java.io.InputStreamReader
+import com.v2ray.ang.extension.toast
 import java.net.*
-import java.util.regex.Matcher
-import java.util.regex.Pattern
-import java.math.BigInteger
-import java.util.concurrent.TimeUnit
-import libv2ray.Libv2ray
-
+import com.v2ray.ang.service.V2RayServiceManager
+import java.io.IOException
 
 object Utils {
 
+    private val mainStorage by lazy { MMKV.mmkvWithID(MmkvManager.ID_MAIN, MMKV.MULTI_PROCESS_MODE) }
+    private val settingsStorage by lazy { MMKV.mmkvWithID(MmkvManager.ID_SETTING, MMKV.MULTI_PROCESS_MODE) }
+
     /**
      * convert string to editalbe for kotlin
      *
@@ -73,11 +58,16 @@ object Utils {
      * parseInt
      */
     fun parseInt(str: String): Int {
-        try {
-            return Integer.parseInt(str)
+        return parseInt(str, 0)
+    }
+
+    fun parseInt(str: String?, default: Int): Int {
+        str ?: return default
+        return try {
+            Integer.parseInt(str)
         } catch (e: Exception) {
             e.printStackTrace()
-            return 0
+            default
         }
     }
 
@@ -85,12 +75,12 @@ object Utils {
      * get text from clipboard
      */
     fun getClipboard(context: Context): String {
-        try {
+        return try {
             val cmb = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
-            return cmb.primaryClip?.getItemAt(0)?.text.toString()
+            cmb.primaryClip?.getItemAt(0)?.text.toString()
         } catch (e: Exception) {
             e.printStackTrace()
-            return ""
+            ""
         }
     }
 
@@ -101,7 +91,7 @@ object Utils {
         try {
             val cmb = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
             val clipData = ClipData.newPlainText(null, content)
-            cmb.primaryClip = clipData
+            cmb.setPrimaryClip(clipData)
         } catch (e: Exception) {
             e.printStackTrace()
         }
@@ -111,98 +101,72 @@ object Utils {
      * base64 decode
      */
     fun decode(text: String): String {
+        tryDecodeBase64(text)?.let { return it }
+        if (text.endsWith('=')) {
+            // try again for some loosely formatted base64
+            tryDecodeBase64(text.trimEnd('='))?.let { return it }
+        }
+        return ""
+    }
+
+    fun tryDecodeBase64(text: String): String? {
         try {
             return Base64.decode(text, Base64.NO_WRAP).toString(charset("UTF-8"))
         } catch (e: Exception) {
-            e.printStackTrace()
-            return ""
+            Log.i(ANG_PACKAGE, "Parse base64 standard failed $e")
         }
+        try {
+            return Base64.decode(text, Base64.NO_WRAP.or(Base64.URL_SAFE)).toString(charset("UTF-8"))
+        } catch (e: Exception) {
+            Log.i(ANG_PACKAGE, "Parse base64 url safe failed $e")
+        }
+        return null
     }
 
     /**
      * base64 encode
      */
     fun encode(text: String): String {
-        try {
-            return Base64.encodeToString(text.toByteArray(charset("UTF-8")), Base64.NO_WRAP)
+        return try {
+            Base64.encodeToString(text.toByteArray(charset("UTF-8")), Base64.NO_WRAP)
         } catch (e: Exception) {
             e.printStackTrace()
-            return ""
+            ""
         }
     }
 
     /**
      * get remote dns servers from preference
      */
-    fun getRemoteDnsServers(defaultDPreference: DPreference): ArrayList<String> {
-        val remoteDns = defaultDPreference.getPrefString(SettingsActivity.PREF_REMOTE_DNS, AppConfig.DNS_AGENT)
-        val ret = ArrayList<String>()
-        if (!TextUtils.isEmpty(remoteDns)) {
-            remoteDns
-                    .split(",")
-                    .forEach {
-                        if (Utils.isPureIpAddress(it)) {
-                            ret.add(it)
-                        }
-                    }
-        }
-        if (ret.size == 0) {
-            ret.add(AppConfig.DNS_AGENT)
+    fun getRemoteDnsServers(): List<String> {
+        val remoteDns = settingsStorage?.decodeString(AppConfig.PREF_REMOTE_DNS) ?: AppConfig.DNS_AGENT
+        val ret = remoteDns.split(",").filter { isPureIpAddress(it) || isCoreDNSAddress(it) }
+        if (ret.isEmpty()) {
+            return listOf(AppConfig.DNS_AGENT)
         }
         return ret
     }
 
+    fun getVpnDnsServers(): List<String> {
+        val vpnDns = settingsStorage?.decodeString(AppConfig.PREF_VPN_DNS)
+                ?: settingsStorage?.decodeString(AppConfig.PREF_REMOTE_DNS)
+                ?: AppConfig.DNS_AGENT
+        return vpnDns.split(",").filter { isPureIpAddress(it) }
+        // allow empty, in that case dns will use system default
+    }
+
     /**
      * get remote dns servers from preference
      */
-    fun getDomesticDnsServers(defaultDPreference: DPreference): ArrayList<String> {
-        val domesticDns = defaultDPreference.getPrefString(SettingsActivity.PREF_DOMESTIC_DNS, AppConfig.DNS_DIRECT)
-        val ret = ArrayList<String>()
-        if (!TextUtils.isEmpty(domesticDns)) {
-            domesticDns
-                    .split(",")
-                    .forEach {
-                        if (Utils.isPureIpAddress(it)) {
-                            ret.add(it)
-                        }
-                    }
-        }
-        if (ret.size == 0) {
-            ret.add(AppConfig.DNS_DIRECT)
+    fun getDomesticDnsServers(): List<String> {
+        val domesticDns = settingsStorage?.decodeString(AppConfig.PREF_DOMESTIC_DNS) ?: AppConfig.DNS_DIRECT
+        val ret = domesticDns.split(",").filter { isPureIpAddress(it) || isCoreDNSAddress(it) }
+        if (ret.isEmpty()) {
+            return listOf(AppConfig.DNS_DIRECT)
         }
         return ret
     }
 
-    /**
-     * create qrcode using zxing
-     */
-    fun createQRCode(text: String, size: Int = 800): Bitmap? {
-        try {
-            val hints = HashMap<EncodeHintType, String>()
-            hints.put(EncodeHintType.CHARACTER_SET, "utf-8")
-            val bitMatrix = QRCodeWriter().encode(text,
-                    BarcodeFormat.QR_CODE, size, size, hints)
-            val pixels = IntArray(size * size)
-            for (y in 0..size - 1) {
-                for (x in 0..size - 1) {
-                    if (bitMatrix.get(x, y)) {
-                        pixels[y * size + x] = 0xff000000.toInt()
-                    } else {
-                        pixels[y * size + x] = 0xffffffff.toInt()
-                    }
-
-                }
-            }
-            val bitmap = Bitmap.createBitmap(size, size,
-                    Bitmap.Config.ARGB_8888)
-            bitmap.setPixels(pixels, 0, size, 0, 0, size, size)
-            return bitmap
-        } catch (e: WriterException) {
-            e.printStackTrace()
-            return null
-        }
-    }
-
     /**
      * is ip address
      */
@@ -215,7 +179,7 @@ object Utils {
             //CIDR
             if (addr.indexOf("/") > 0) {
                 val arr = addr.split("/")
-                if (arr.count() == 2 && Integer.parseInt(arr[1]) > 0) {
+                if (arr.count() == 2 && Integer.parseInt(arr[1]) > -1) {
                     addr = arr[0]
                 }
             }
@@ -229,9 +193,9 @@ object Utils {
             }
 
             // addr = addr.toLowerCase()
-            var octets = addr.split('.').toTypedArray()
+            val octets = addr.split('.').toTypedArray()
             if (octets.size == 4) {
-                if(octets[3].indexOf(":") > 0) {
+                if (octets[3].indexOf(":") > 0) {
                     addr = addr.substring(0, addr.indexOf(":"))
                 }
                 return isIpv4Address(addr)
@@ -246,7 +210,7 @@ object Utils {
     }
 
     fun isPureIpAddress(value: String): Boolean {
-        return (isIpv4Address(value) || isIpv6Address(value))
+        return isIpv4Address(value) || isIpv6Address(value)
     }
 
     fun isIpv4Address(value: String): Boolean {
@@ -264,86 +228,32 @@ object Utils {
         return regV6.matches(addr)
     }
 
+    private fun isCoreDNSAddress(s: String): Boolean {
+        return s.startsWith("https") || s.startsWith("tcp") || s.startsWith("quic")
+    }
+
     /**
      * is valid url
      */
     fun isValidUrl(value: String?): Boolean {
         try {
-            if (Patterns.WEB_URL.matcher(value).matches() || URLUtil.isValidUrl(value)) {
+            if (value != null && Patterns.WEB_URL.matcher(value).matches() || URLUtil.isValidUrl(value)) {
                 return true
             }
-        } catch (e: WriterException) {
+        } catch (e: Exception) {
             e.printStackTrace()
             return false
         }
         return false
     }
 
-
-    /**
-     * 判断服务是否后台运行
-
-     * @param context
-     * *            Context
-     * *
-     * @param className
-     * *            判断的服务名字
-     * *
-     * @return true 在运行 false 不在运行
-     */
-    fun isServiceRun(context: Context, className: String): Boolean {
-        var isRun = false
-        val activityManager = context
-                .getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
-        val serviceList = activityManager
-                .getRunningServices(999)
-        val size = serviceList.size
-        for (i in 0..size - 1) {
-            if (serviceList[i].service.className == className) {
-                isRun = true
-                break
-            }
-        }
-        return isRun
-    }
-
-    /**
-     * startVService
-     */
-    fun startVService(context: Context): Boolean {
-        context.toast(R.string.toast_services_start)
-        if (AngConfigManager.genStoreV2rayConfig(-1)) {
-            val configContent = AngConfigManager.currGeneratedV2rayConfig()
-            val configType = AngConfigManager.currConfigType()
-            if (configType == AppConfig.EConfigType.Custom) {
-                try {
-                    Libv2ray.testConfig(configContent)
-                } catch (e: Exception) {
-                    context.toast(e.toString())
-                    return false
-                }
-            }
-            V2RayVpnService.startV2Ray(context)
-            return true
-        } else {
+    fun startVServiceFromToggle(context: Context): Boolean {
+        if (mainStorage?.decodeString(MmkvManager.KEY_SELECTED_SERVER).isNullOrEmpty()) {
+            context.toast(R.string.app_tile_first_use)
             return false
         }
-    }
-
-    /**
-     * startVService
-     */
-    fun startVService(context: Context, guid: String): Boolean {
-        val index = AngConfigManager.getIndexViaGuid(guid)
-        return startVService(context, index)
-    }
-
-    /**
-     * startVService
-     */
-    fun startVService(context: Context, index: Int): Boolean {
-        AngConfigManager.setActiveServer(index)
-        return startVService(context)
+        V2RayServiceManager.startV2Ray(context)
+        return true
     }
 
     /**
@@ -363,147 +273,142 @@ object Utils {
      * uuid
      */
     fun getUuid(): String {
-        try {
-            return UUID.randomUUID().toString().replace("-", "")
+        return try {
+            UUID.randomUUID().toString().replace("-", "")
         } catch (e: Exception) {
             e.printStackTrace()
-            return ""
+            ""
         }
     }
 
     fun urlDecode(url: String): String {
-        try {
-            return URLDecoder.decode(url, "UTF-8")
+        return try {
+            URLDecoder.decode(url, "UTF-8")
         } catch (e: Exception) {
             e.printStackTrace()
-            return url
+            url
         }
     }
 
     fun urlEncode(url: String): String {
-        try {
-            return URLEncoder.encode(url, "UTF-8")
+        return try {
+            URLEncoder.encode(url, "UTF-8")
         } catch (e: Exception) {
             e.printStackTrace()
-            return url
+            url
         }
     }
 
-    fun testConnection(context: Context, port: Int): String {
-        var result: String
-        var conn: HttpURLConnection? = null
-
-        try {
-            val url = URL("https",
-                    "www.google.com",
-                    "/generate_204")
-
-            conn = url.openConnection(
-                Proxy(Proxy.Type.HTTP,
-                InetSocketAddress("127.0.0.1", port + 1))) as HttpURLConnection
-            conn.connectTimeout = 30000
-            conn.readTimeout = 30000
-            conn.setRequestProperty("Connection", "close")
-            conn.instanceFollowRedirects = false
-            conn.useCaches = false
-
-            val start = SystemClock.elapsedRealtime()
-            val code = conn.responseCode
-            val elapsed = SystemClock.elapsedRealtime() - start
-
-            if (code == 204 || code == 200 && conn.responseLength == 0L) {
-                result = context.getString(R.string.connection_test_available, elapsed)
-            } else {
-                throw IOException(context.getString(R.string.connection_test_error_status_code, code))
-            }
-        } catch (e: IOException) {
-            // network exception
-            Log.d(AppConfig.ANG_PACKAGE,"testConnection IOException: "+Log.getStackTraceString(e))
-            result = context.getString(R.string.connection_test_error, e.message)
-        } catch (e: Exception) {
-            // library exception, eg sumsung
-            Log.d(AppConfig.ANG_PACKAGE,"testConnection Exception: "+Log.getStackTraceString(e))
-            result = context.getString(R.string.connection_test_error, e.message)
-        } finally {
-            conn?.disconnect()
-        }
-
-        return result
-    }
-
-    /**
-     * package path
-     */
-    fun packagePath(context: Context): String {
-        var path = context.filesDir.toString()
-        path = path.replace("files", "")
-        //path += "tun2socks"
-
-        return path
-    }
-
 
     /**
      * readTextFromAssets
      */
-    fun readTextFromAssets(app: AngApplication, fileName: String): String {
-        val content = app.assets.open(fileName).bufferedReader().use {
+    fun readTextFromAssets(context: Context, fileName: String): String {
+        val content = context.assets.open(fileName).bufferedReader().use {
             it.readText()
         }
         return content
     }
 
-    /**
-     * ping
-     */
-    fun ping(url: String): String {
-        try {
-            val command = "/system/bin/ping -c 3 $url"
-            val process = Runtime.getRuntime().exec(command)
-            val allText = process.inputStream.bufferedReader().use { it.readText() }
-            if (!TextUtils.isEmpty(allText)) {
-                val tempInfo = allText.substring(allText.indexOf("min/avg/max/mdev") + 19)
-                val temps = tempInfo.split("/".toRegex()).dropLastWhile({ it.isEmpty() }).toTypedArray()
-                if (temps.count() > 0 && temps[0].length < 10) {
-                    return temps[0].toFloat().toInt().toString() + "ms"
-                }
-            }
-        } catch (e: Exception) {
-            e.printStackTrace()
-        }
-        return "-1ms"
+    fun userAssetPath(context: Context?): String {
+        if (context == null)
+            return ""
+        val extDir = context.getExternalFilesDir(AppConfig.DIR_ASSETS)
+                ?: return context.getDir(AppConfig.DIR_ASSETS, 0).absolutePath
+        return extDir.absolutePath
     }
 
-    /**
-     * tcping
-     */
-    fun tcping(url: String, port: Int): String {
-        var time = -1L
-        for (k in 0 until 2) {
-            val one = socketConnectTime(url, port)
-            if (one != -1L  )
-                if(time == -1L || one < time) {
-                time = one
-            }
-        }
-        return time.toString() + "ms"
+    fun getDeviceIdForXUDPBaseKey(): String {
+        val androidId = Settings.Secure.ANDROID_ID.toByteArray(charset("UTF-8"))
+        return Base64.encodeToString(androidId.copyOf(32), Base64.NO_PADDING.or(Base64.URL_SAFE))
     }
 
-    fun socketConnectTime(url: String, port: Int): Long {
+    fun getUrlContext(url: String, timeout: Int): String {
+        var result: String
+        var conn: HttpURLConnection? = null
+
         try {
-            val start = System.currentTimeMillis()
-            val socket = Socket(url, port)
-            val time = System.currentTimeMillis() - start
-            socket.close()
-            return time
-        } catch (e: UnknownHostException) {
-            e.printStackTrace()
-        } catch (e: IOException) {
-            e.printStackTrace()
+            conn = URL(url).openConnection() as HttpURLConnection
+            conn.connectTimeout = timeout
+            conn.readTimeout = timeout
+            conn.setRequestProperty("Connection", "close")
+            conn.instanceFollowRedirects = false
+            conn.useCaches = false
+            //val code = conn.responseCode
+            result = conn.inputStream.bufferedReader().readText()
         } catch (e: Exception) {
-            e.printStackTrace()
+            result = ""
+        } finally {
+            conn?.disconnect()
         }
-        return -1
+        return result
     }
+
+    @Throws(IOException::class)
+    fun getUrlContentWithCustomUserAgent(urlStr: String?): String {
+        val url = URL(urlStr)
+        val conn = url.openConnection()
+        conn.setRequestProperty("Connection", "close")
+        conn.setRequestProperty("User-agent", "v2rayNG/${BuildConfig.VERSION_NAME}")
+        url.userInfo?.let {
+            conn.setRequestProperty("Authorization",
+                "Basic ${encode(urlDecode(it))}")
+        }
+        conn.useCaches = false
+        return conn.inputStream.use {
+            it.bufferedReader().readText()
+        }
+    }
+
+    fun getDarkModeStatus(context: Context): Boolean {
+        val mode = context.resources.configuration.uiMode and UI_MODE_NIGHT_MASK
+        return mode != UI_MODE_NIGHT_NO
+    }
+
+    fun getIpv6Address(address: String): String {
+        return if (isIpv6Address(address) && !address.contains('[') && !address.contains(']')) {
+            String.format("[%s]", address)
+        } else {
+            address
+        }
+    }
+
+    fun getLocale(context: Context): Locale =
+        when (settingsStorage?.decodeString(AppConfig.PREF_LANGUAGE) ?: "auto") {
+            "auto" ->  getSysLocale()
+            "en" -> Locale("en")
+            "zh-rCN" -> Locale("zh", "CN")
+            "zh-rTW" -> Locale("zh", "TW")
+            "vi" -> Locale("vi")
+            "ru" -> Locale("ru")
+            "fa" -> Locale("fa")
+            else -> getSysLocale()
+        }
+
+    private fun getSysLocale(): Locale = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+        LocaleList.getDefault()[0]
+    } else {
+        Locale.getDefault()
+    }
+
+    fun fixIllegalUrl(str: String): String {
+        return str
+            .replace(" ","%20")
+            .replace("|","%7C")
+    }
+
+    fun removeWhiteSpace(str: String?): String? {
+        return str?.replace(" ", "")
+    }
+
+    fun idnToASCII(str: String): String {
+        val url = URL(str)
+        return URL(url.protocol, IDN.toASCII(url.host, IDN.ALLOW_UNASSIGNED), url.port, url.file)
+            .toExternalForm()
+    }
+
+    fun isTv(context: Context): Boolean =
+        context.packageManager.hasSystemFeature(PackageManager.FEATURE_LEANBACK)
+
 }