Merge pull request #973 from yuhan6665/new-storage-fix

New storage fix

.github/workflows/build.yml

@@ -1,63 +0,0 @@
-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.22.2'
-
-    - 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 755 gradlew
-        ./gradlew assembleDebug
-
-    - name: Upload APK
-      uses: actions/upload-artifact@v4
-      with:
-        name: apk
-        path: ${{ github.workspace }}/V2rayNG/app/build/outputs/apk/debug/

.gitignore

@@ -1,5 +1,9 @@
+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
 *.dat
 *.jks
 V2rayNG/app/release/output.json
 .idea/
-.gradle/
+.gradle/

AndroidLibV2rayLite/.travis.yml

@@ -0,0 +1,26 @@
+sudo: required
+language: go
+go:
+  - "1.12"
+go_import_path: github.com/2dust/AndroidLibV2rayLite
+git:
+  depth: 5
+addons:
+  apt:
+    update: true
+before_script:
+- sudo ntpdate -u time.google.com
+- date
+- make all
+- make downloadGoMobile
+script:
+- make BuildMobile
+after_success:
+deploy:
+  provider: releases
+  api_key: ${GH_TOKEN}
+  file:
+    - libv2ray.aar
+  skip_cleanup: true
+  on:
+    tags: true

AndroidLibV2rayLite/CoreI/Status.go

@@ -0,0 +1,65 @@
+package CoreI
+
+import (
+	v2core "v2ray.com/core"
+)
+
+type Status struct {
+	IsRunning       bool
+	IsTRunning      bool
+	PackageName     string
+	PackageCodePath string
+
+	Vpoint v2core.Server
+}
+
+func CheckVersion() int {
+	return 22
+}
+
+func (v *Status) GetDataDir() string {
+	return v.PackageName
+}
+
+func (v *Status) GetApp(name string) string {
+	return v.PackageCodePath + name
+}
+
+func (v *Status) GetTun2socksArgs(localDNS bool, enableIPv6 bool) (ret []string) {
+	ret = []string{"--netif-ipaddr",
+		"26.26.26.2",
+		"--netif-netmask",
+		"255.255.255.252",
+		"--socks-server-addr",
+		"127.0.0.1:10808",
+		"--tunmtu",
+		"1500",
+		"--loglevel",
+		"notice",
+		"--enable-udprelay",
+		"--sock-path",
+		v.GetDataDir() + "sock_path",
+	}
+
+	if enableIPv6 {
+		ret = append(ret, "--netif-ip6addr", "da26:2626::2")
+	}
+
+	if localDNS {
+		ret = append(ret, "--dnsgw", "127.0.0.1:10807")
+	}
+
+	return
+}
+
+func (v *Status) GetVPNSetupArg(localDNS bool, enableIPv6 bool) (ret string) {
+	ret = "m,1500 a,26.26.26.1,30 r,0.0.0.0,0"
+
+	if enableIPv6 {
+		ret += " a,da26:2626::1,126 r,::,0"
+	}
+	if localDNS {
+		ret += " d,26.26.26.2"
+	}
+	return
+}

AndroidLibV2rayLite/Makefile

@@ -0,0 +1,31 @@
+pb:
+	  go get -u github.com/golang/protobuf/protoc-gen-go
+		@echo "pb Start"
+asset:
+	bash gen_assets.sh download
+	mkdir assets
+	cp -v data/*.dat assets/
+	# cd assets;curl https://raw.githubusercontent.com/2dust/AndroidLibV2rayLite/master/data/geosite.dat > geosite.dat		
+	# cd assets;curl https://raw.githubusercontent.com/2dust/AndroidLibV2rayLite/master/data/geoip.dat > geoip.dat
+
+fetchDep:
+	-go get  github.com/2dust/AndroidLibV2rayLite
+	go get github.com/2dust/AndroidLibV2rayLite
+
+ANDROID_HOME=$(HOME)/android-sdk-linux
+export ANDROID_HOME
+PATH:=$(PATH):$(GOPATH)/bin
+export PATH
+downloadGoMobile:
+	go get golang.org/x/mobile/cmd/...
+	sudo apt-get install -qq libstdc++6:i386 lib32z1 expect
+	cd ~ ;curl -L https://raw.githubusercontent.com/2dust/AndroidLibV2rayLite/master/ubuntu-cli-install-android-sdk.sh | sudo bash - > /dev/null
+	ls ~
+	ls ~/android-sdk-linux/
+	gomobile init ;gomobile bind -v  -tags json github.com/2dust/AndroidLibV2rayLite
+
+BuildMobile:
+	@echo Stub
+
+all: asset pb fetchDep
+	@echo DONE

AndroidLibV2rayLite/Process/Escort/escort.go

@@ -0,0 +1,79 @@
+package Escort
+
+import (
+	"os"
+	"os/exec"
+
+	"log"
+
+	"github.com/2dust/AndroidLibV2rayLite/CoreI"
+)
+
+func (v *Escorting) EscortRun(proc string, pt []string, additionalEnv string) {
+	log.Println(proc, pt)
+	count := 0
+	for count <= 42 {
+		cmd := exec.Command(proc, pt...)
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+
+		if len(additionalEnv) > 0 {
+			//additionalEnv := "FOO=bar"
+			newEnv := append(os.Environ(), additionalEnv)
+			cmd.Env = newEnv
+		}
+
+		if err := cmd.Start(); err != nil {
+			log.Println("EscortRun cmd.Start err", err)
+			goto CMDERROR
+		}
+
+		if v.escortProcess == nil {
+			log.Println("EscortRun v.escortProcess nil")
+			break
+		}
+
+		*v.escortProcess = append(*v.escortProcess, cmd.Process)
+		log.Println("EscortRun Waiting....")
+
+		if err := cmd.Wait(); err != nil {
+			log.Println("EscortRun cmd.Wait err:", err)
+		}
+
+	CMDERROR:
+		if v.Status.IsRunning {
+			log.Println("EscortRun Unexpected Exit, Restart now.")
+			count++
+		} else {
+			log.Println("EscortRun Exit")
+			break
+		}
+	}
+}
+
+func (v *Escorting) EscortingUp() {
+	if v.escortProcess != nil {
+		return
+	}
+	v.escortProcess = new([](*os.Process))
+}
+
+func (v *Escorting) EscortingDown() {
+	if v.escortProcess == nil {
+		return
+	}
+
+	log.Println("EscortingDown() Killing all escorted process ")
+	for _, pr := range *v.escortProcess {
+		pr.Kill()
+		if _, err := pr.Wait(); err != nil {
+			log.Println("EscortingDown pr.Wait err:", err)
+		}
+	}
+	v.escortProcess = nil
+}
+
+type Escorting struct {
+	escortProcess *[](*os.Process)
+	Status        *CoreI.Status
+}

AndroidLibV2rayLite/README.md

@@ -1,20 +1 @@
 # 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)

AndroidLibV2rayLite/VPN/vpnservice_support.go

@@ -0,0 +1,279 @@
+package VPN
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log"
+	"net"
+	"os"
+	"strings"
+	"sync"
+	"time"
+
+	"golang.org/x/sys/unix"
+	v2net "v2ray.com/core/common/net"
+	v2internet "v2ray.com/core/transport/internet"
+)
+
+type protectSet interface {
+	Protect(int) int
+}
+
+type resolved struct {
+	domain       string
+	IPs          []net.IP
+	Port         int
+	ipIdx        uint8
+	ipLock       sync.Mutex
+	lastSwitched time.Time
+}
+
+// NextIP switch to another resolved result.
+// there still be race-condition here if multiple err concurently occured
+// may cause idx keep switching,
+// but that's an outside error can hardly handled here
+func (r *resolved) NextIP() {
+	r.ipLock.Lock()
+	defer r.ipLock.Unlock()
+
+	if len(r.IPs) > 1 {
+
+		// throttle, don't switch too quickly
+		now := time.Now()
+		if now.Sub(r.lastSwitched) < time.Second*5 {
+			log.Println("switch too quickly")
+			return
+		}
+		r.lastSwitched = now
+		r.ipIdx++
+
+	} else {
+		return
+	}
+
+	if r.ipIdx >= uint8(len(r.IPs)) {
+		r.ipIdx = 0
+	}
+
+	cur := r.currentIP()
+	log.Printf("switched to next IP: %s", cur)
+}
+
+func (r *resolved) currentIP() net.IP {
+	if len(r.IPs) > 0 {
+		return r.IPs[r.ipIdx]
+	}
+
+	return nil
+}
+
+// NewPreotectedDialer ...
+func NewPreotectedDialer(p protectSet) *ProtectedDialer {
+	d := &ProtectedDialer{
+		// prefer native lookup on Android
+		resolver:   &net.Resolver{PreferGo: false},
+		protectSet: p,
+	}
+	return d
+}
+
+// ProtectedDialer ...
+type ProtectedDialer struct {
+	currentServer string
+	resolveChan   chan struct{}
+
+	vServer  *resolved
+	resolver *net.Resolver
+
+	protectSet
+}
+
+func (d *ProtectedDialer) IsVServerReady() bool {
+	return (d.vServer != nil)
+}
+
+func (d *ProtectedDialer) PrepareResolveChan() {
+	d.resolveChan = make(chan struct{})
+}
+
+func (d *ProtectedDialer) ResolveChan() <-chan struct{} {
+	return d.resolveChan
+}
+
+// simplicated version of golang: internetAddrList in src/net/ipsock.go
+func (d *ProtectedDialer) lookupAddr(addr string) (*resolved, error) {
+
+	var (
+		err        error
+		host, port string
+		portnum    int
+	)
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	if host, port, err = net.SplitHostPort(addr); err != nil {
+		log.Printf("PrepareDomain SplitHostPort Err: %v", err)
+		return nil, err
+	}
+
+	if portnum, err = d.resolver.LookupPort(ctx, "tcp", port); err != nil {
+		log.Printf("PrepareDomain LookupPort Err: %v", err)
+		return nil, err
+	}
+
+	addrs, err := d.resolver.LookupIPAddr(ctx, host)
+	if err != nil {
+		return nil, err
+	}
+	if len(addrs) == 0 {
+		return nil, fmt.Errorf("domain %s Failed to resolve", addr)
+	}
+
+	IPs := make([]net.IP, len(addrs))
+	for i, ia := range addrs {
+		IPs[i] = ia.IP
+	}
+
+	rs := &resolved{
+		domain: host,
+		IPs:    IPs,
+		Port:   portnum,
+	}
+
+	return rs, nil
+}
+
+// PrepareDomain caches direct v2ray server host
+func (d *ProtectedDialer) PrepareDomain(domainName string, closeCh <-chan struct{}) {
+	log.Printf("Preparing Domain: %s", domainName)
+	d.currentServer = domainName
+
+	defer close(d.resolveChan)
+	maxRetry := 10
+	for {
+		if maxRetry == 0 {
+			log.Println("PrepareDomain maxRetry reached. exiting.")
+			return
+		}
+
+		resolved, err := d.lookupAddr(domainName)
+		if err != nil {
+			maxRetry--
+			log.Printf("PrepareDomain err: %v\n", err)
+			select {
+			case <-closeCh:
+				log.Printf("PrepareDomain exit due to v2ray closed")
+				return
+			case <-time.After(time.Second * 2):
+			}
+			continue
+		}
+
+		d.vServer = resolved
+		log.Printf("Prepare Result:\n Domain: %s\n Port: %d\n IPs: %v\n",
+			resolved.domain, resolved.Port, resolved.IPs)
+		return
+	}
+}
+
+func (d *ProtectedDialer) getFd(network v2net.Network) (fd int, err error) {
+	switch network {
+	case v2net.Network_TCP:
+		fd, err = unix.Socket(unix.AF_INET6, unix.SOCK_STREAM, unix.IPPROTO_TCP)
+	case v2net.Network_UDP:
+		fd, err = unix.Socket(unix.AF_INET6, unix.SOCK_DGRAM, unix.IPPROTO_UDP)
+	default:
+		err = fmt.Errorf("unknow network")
+	}
+	return
+}
+
+// Dial exported as the protected dial method
+func (d *ProtectedDialer) Dial(ctx context.Context,
+	src v2net.Address, dest v2net.Destination, sockopt *v2internet.SocketConfig) (net.Conn, error) {
+
+	network := dest.Network.SystemString()
+	Address := dest.NetAddr()
+
+	// v2ray server address,
+	// try to connect fixed IP if multiple IP parsed from domain,
+	// and switch to next IP if error occurred
+	if strings.Compare(Address, d.currentServer) == 0 {
+		if d.vServer == nil {
+			log.Println("Dial pending prepare  ...", Address)
+			<-d.resolveChan
+
+			// user may close connection during PrepareDomain,
+			// fast return release resources.
+			if d.vServer == nil {
+				return nil, fmt.Errorf("fail to prepare domain %s", d.currentServer)
+			}
+		}
+
+		fd, err := d.getFd(dest.Network)
+		if err != nil {
+			return nil, err
+		}
+
+		curIP := d.vServer.currentIP()
+		conn, err := d.fdConn(ctx, curIP, d.vServer.Port, fd)
+		if err != nil {
+			d.vServer.NextIP()
+			return nil, err
+		}
+		log.Printf("Using Prepared: %s", curIP)
+		return conn, nil
+	}
+
+	// v2ray connecting to "domestic" servers, no caching results
+	log.Printf("Not Using Prepared: %s,%s", network, Address)
+	resolved, err := d.lookupAddr(Address)
+	if err != nil {
+		return nil, err
+	}
+
+	fd, err := d.getFd(dest.Network)
+	if err != nil {
+		return nil, err
+	}
+
+	// use the first resolved address.
+	// the result IP may vary, eg: IPv6 addrs comes first if client has ipv6 address
+	return d.fdConn(ctx, resolved.IPs[0], resolved.Port, fd)
+}
+
+func (d *ProtectedDialer) fdConn(ctx context.Context, ip net.IP, port int, fd int) (net.Conn, error) {
+
+	defer unix.Close(fd)
+
+	// call android VPN service to "protect" the fd connecting straight out
+	d.Protect(fd)
+
+	sa := &unix.SockaddrInet6{
+		Port: port,
+	}
+	copy(sa.Addr[:], ip)
+
+	if err := unix.Connect(fd, sa); err != nil {
+		log.Printf("fdConn unix.Connect err, Close Fd: %d Err: %v", fd, err)
+		return nil, err
+	}
+
+	file := os.NewFile(uintptr(fd), "Socket")
+	if file == nil {
+		// returned value will be nil if fd is not a valid file descriptor
+		return nil, errors.New("fdConn fd invalid")
+	}
+
+	defer file.Close()
+	//Closing conn does not affect file, and closing file does not affect conn.
+	conn, err := net.FileConn(file)
+	if err != nil {
+		log.Printf("fdConn FileConn Close Fd: %d Err: %v", fd, err)
+		return nil, err
+	}
+
+	return conn, nil
+}

AndroidLibV2rayLite/VPN/vpnservice_support_test.go

@@ -0,0 +1,151 @@
+package VPN
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"net"
+	"sync"
+	"testing"
+	"time"
+
+	v2net "v2ray.com/core/common/net"
+)
+
+type fakeSupportSet struct{}
+
+func (f fakeSupportSet) Protect(int) int {
+	return 0
+}
+
+func TestProtectedDialer_PrepareDomain(t *testing.T) {
+	type args struct {
+		domainName string
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		// TODO: Add test cases.
+		{"", args{"baidu.com:80"}},
+		// {"", args{"cloudflare.com:443"}},
+		// {"", args{"apple.com:443"}},
+		// {"", args{"110.110.110.110:443"}},
+		// {"", args{"[2002:1234::1]:443"}},
+	}
+	d := NewPreotectedDialer(fakeSupportSet{})
+	for _, tt := range tests {
+		ch := make(chan struct{})
+		t.Run(tt.name, func(t *testing.T) {
+			go d.PrepareDomain(tt.args.domainName, ch)
+
+			time.Sleep(time.Second)
+			go d.vServer.NextIP()
+			t.Log(d.vServer.currentIP())
+		})
+	}
+
+	time.Sleep(time.Second)
+}
+
+func TestProtectedDialer_Dial(t *testing.T) {
+
+	tests := []struct {
+		name    string
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+		{"baidu.com:80", false},
+		{"cloudflare.com:80", false},
+		{"172.16.192.11:80", true},
+		// {"172.16.192.10:80", true},
+		// {"[2fff:4322::1]:443", true},
+		// {"[fc00::1]:443", true},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ch := make(chan struct{})
+
+			d := NewPreotectedDialer(fakeSupportSet{})
+			d.currentServer = tt.name
+
+			go d.PrepareDomain(tt.name, ch)
+
+			var wg sync.WaitGroup
+
+			dial := func() {
+				defer wg.Done()
+				dest, _ := v2net.ParseDestination("tcp:" + tt.name)
+				ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+				defer cancel()
+
+				conn, err := d.Dial(ctx, nil, dest, nil)
+				if err != nil {
+					t.Log(err)
+					return
+				}
+				_host, _, _ := net.SplitHostPort(tt.name)
+				fmt.Fprintf(conn, fmt.Sprintf("GET / HTTP/1.1\r\nHost: %s\r\n\r\n", _host))
+				status, err := bufio.NewReader(conn).ReadString('\n')
+				t.Logf("%#v, %#v\n", status, err)
+				conn.Close()
+			}
+
+			for n := 0; n < 3; n++ {
+				wg.Add(1)
+				go dial()
+				// time.Sleep(time.Millisecond * 10)
+				// d.pendingMap[tt.name] = make(chan struct{})
+			}
+
+			wg.Wait()
+		})
+	}
+}
+
+func Test_resolved_NextIP(t *testing.T) {
+	type fields struct {
+		domain string
+		IPs    []net.IP
+		Port   int
+	}
+	tests := []struct {
+		name   string
+		fields fields
+	}{
+		// TODO: Add test cases.
+		{"test1",
+			fields{
+				domain: "www.baidu.com",
+				IPs: []net.IP{
+					net.ParseIP("1.2.3.4"),
+					net.ParseIP("4.3.2.1"),
+					net.ParseIP("1234::1"),
+					net.ParseIP("4321::1"),
+				},
+			}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			r := &resolved{
+				domain: tt.fields.domain,
+				IPs:    tt.fields.IPs,
+				Port:   tt.fields.Port,
+			}
+			t.Logf("%v", r.IPs)
+			t.Logf("%v", r.currentIP())
+			r.NextIP()
+			t.Logf("%v", r.currentIP())
+			r.NextIP()
+			t.Logf("%v", r.currentIP())
+			r.NextIP()
+			t.Logf("%v", r.currentIP())
+			time.Sleep(3 * time.Second)
+			r.NextIP()
+			t.Logf("%v", r.currentIP())
+			time.Sleep(5 * time.Second)
+			r.NextIP()
+			t.Logf("%v", r.currentIP())
+		})
+	}
+}

AndroidLibV2rayLite/compile-tun2socks.sh

@@ -0,0 +1,43 @@
+#!/bin/bash
+
+set -o errexit
+set -o pipefail
+set -o nounset
+
+# Set magic variables for current file & dir
+__dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+__file="${__dir}/$(basename "${BASH_SOURCE[0]}")"
+__base="$(basename ${__file} .sh)"
+
+if [[ ! -d $NDK_HOME ]]; then
+	echo "Android NDK: NDK_HOME not found. please set env \$NDK_HOME"
+	exit 1
+fi
+
+TMPDIR=$(mktemp -d)
+clear_tmp () {
+  rm -rf $TMPDIR
+}
+
+trap 'echo -e "Aborted, error $? in command: $BASH_COMMAND"; trap ERR; clear_tmp; exit 1' ERR INT
+install -m644 $__dir/tun2socks.mk $TMPDIR/
+
+pushd $TMPDIR
+git clone --depth=1 https://github.com/shadowsocks/badvpn.git
+git clone --depth=1 https://github.com/shadowsocks/libancillary.git
+$NDK_HOME/ndk-build \
+	NDK_PROJECT_PATH=. \
+	APP_BUILD_SCRIPT=./tun2socks.mk \
+	APP_ABI=all \
+	APP_PLATFORM=android-19 \
+	NDK_LIBS_OUT=$TMPDIR/libs \
+	NDK_OUT=$TMPDIR/tmp \
+	APP_SHORT_COMMANDS=false LOCAL_SHORT_COMMANDS=false -B -j4
+
+install -v -m755 libs/armeabi-v7a/tun2socks  $__dir/../V2rayNG/app/src/main/jniLibs/armeabi-v7a/libtun2socks.so
+install -v -m755 libs/arm64-v8a/tun2socks    $__dir/../V2rayNG/app/src/main/jniLibs/arm64-v8a/libtun2socks.so
+install -v -m755 libs/x86/tun2socks          $__dir/../V2rayNG/app/src/main/jniLibs/x86/libtun2socks.so
+install -v -m755 libs/x86_64/tun2socks       $__dir/../V2rayNG/app/src/main/jniLibs/x86_64/libtun2socks.so
+popd
+
+rm -rf $TMPDIR

AndroidLibV2rayLite/gen_assets.sh

@@ -0,0 +1,81 @@
+#!/bin/bash
+
+set -o errexit
+set -o pipefail
+set -o nounset
+
+# Set magic variables for current file & dir
+__dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+__file="${__dir}/$(basename "${BASH_SOURCE[0]}")"
+__base="$(basename ${__file} .sh)"
+
+
+DATADIR=${__dir}/data
+
+compile_dat () {
+    local TMPDIR=$(mktemp -d)
+
+    trap 'echo -e "Aborted, error $? in command: $BASH_COMMAND"; rm -rf $TMPDIR; trap ERR; exit 1' ERR
+
+    local GEOSITE=${GOPATH}/src/github.com/v2ray/domain-list-community
+    if [[ -d ${GEOSITE} ]]; then
+        cd ${GEOSITE} && git pull
+    else
+        mkdir -p ${GEOSITE}
+        cd ${GEOSITE} && git clone https://github.com/v2ray/domain-list-community.git .
+    fi
+    go run main.go
+
+    if [[ -e dlc.dat ]]; then
+        rm -f $DATADIR/geosite.dat
+        mv dlc.dat $DATADIR/geosite.dat
+        echo "----------> geosite.dat updated."
+    else
+        echo "----------> geosite.dat failed to update."
+    fi
+
+
+    if [[ ! -x $GOPATH/bin/geoip ]]; then
+        go get -v -u github.com/v2ray/geoip
+    fi
+
+    cd $TMPDIR
+    curl -L -O http://geolite.maxmind.com/download/geoip/database/GeoLite2-Country-CSV.zip
+    unzip -q GeoLite2-Country-CSV.zip
+    mkdir geoip && find . -name '*.csv' -exec mv -t ./geoip {} +
+    $GOPATH/bin/geoip \
+        --country=./geoip/GeoLite2-Country-Locations-en.csv \
+        --ipv4=./geoip/GeoLite2-Country-Blocks-IPv4.csv \
+        --ipv6=./geoip/GeoLite2-Country-Blocks-IPv6.csv
+
+    if [[ -e geoip.dat ]]; then
+        rm -f $DATADIR/geoip.dat
+        mv ./geoip.dat $DATADIR/geoip.dat
+        echo "----------> geoip.dat updated."
+    else
+        echo "----------> geoip.dat failed to update."
+    fi
+    trap ERR
+    return 0
+}
+
+
+download_dat () {
+    wget -qO - https://api.github.com/repos/v2ray/geoip/releases/latest \
+    | grep browser_download_url | cut -d '"' -f 4 \
+    | wget -i - -O $DATADIR/geoip.dat
+
+    wget -qO - https://api.github.com/repos/v2ray/domain-list-community/releases/latest \
+    | grep browser_download_url | cut -d '"' -f 4 \
+    | wget -i - -O $DATADIR/geosite.dat
+}
+
+ACTION="${1:-}"
+if [[ -z $ACTION ]]; then
+    ACTION=download
+fi
+
+case $ACTION in
+    "download") download_dat;;
+    "compile") compile_dat;;
+esac

AndroidLibV2rayLite/interact.go

@@ -0,0 +1,259 @@
+package libv2ray
+
+import (
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"strings"
+	"sync"
+
+	"github.com/2dust/AndroidLibV2rayLite/CoreI"
+	"github.com/2dust/AndroidLibV2rayLite/Process/Escort"
+	"github.com/2dust/AndroidLibV2rayLite/VPN"
+	mobasset "golang.org/x/mobile/asset"
+
+	v2core "v2ray.com/core"
+	v2filesystem "v2ray.com/core/common/platform/filesystem"
+	v2stats "v2ray.com/core/features/stats"
+	v2serial "v2ray.com/core/infra/conf/serial"
+	v2internet "v2ray.com/core/transport/internet"
+
+	v2applog "v2ray.com/core/app/log"
+	v2commlog "v2ray.com/core/common/log"
+)
+
+const (
+	v2Assert    = "v2ray.location.asset"
+	assetperfix = "/dev/libv2rayfs0/asset"
+)
+
+/*V2RayPoint V2Ray Point Server
+This is territory of Go, so no getter and setters!
+*/
+type V2RayPoint struct {
+	SupportSet   V2RayVPNServiceSupportsSet
+	statsManager v2stats.Manager
+
+	dialer    *VPN.ProtectedDialer
+	status    *CoreI.Status
+	escorter  *Escort.Escorting
+	v2rayOP   *sync.Mutex
+	closeChan chan struct{}
+
+	PackageName          string
+	PackageCodePath      string
+	DomainName           string
+	ConfigureFileContent string
+	EnableLocalDNS       bool
+	ForwardIpv6          bool
+	ProxyOnly            bool
+}
+
+/*V2RayVPNServiceSupportsSet To support Android VPN mode*/
+type V2RayVPNServiceSupportsSet interface {
+	Setup(Conf string) int
+	Prepare() int
+	Shutdown() int
+	Protect(int) int
+	OnEmitStatus(int, string) int
+}
+
+/*RunLoop Run V2Ray main loop
+ */
+func (v *V2RayPoint) RunLoop() (err error) {
+	v.v2rayOP.Lock()
+	defer v.v2rayOP.Unlock()
+	//Construct Context
+	v.status.PackageName = v.PackageName
+	v.status.PackageCodePath = v.PackageCodePath
+
+	if !v.status.IsRunning {
+		v.closeChan = make(chan struct{})
+		v.dialer.PrepareResolveChan()
+		go v.dialer.PrepareDomain(v.DomainName, v.closeChan)
+		go func() {
+			select {
+			// wait until resolved
+			case <-v.dialer.ResolveChan():
+				// shutdown VPNService if server name can not reolved
+				if !v.dialer.IsVServerReady() {
+					log.Println("vServer cannot resolved, shutdown")
+					v.StopLoop()
+				}
+
+			// stop waiting if manually closed
+			case <-v.closeChan:
+			}
+		}()
+
+		err = v.pointloop()
+	}
+	return
+}
+
+/*StopLoop Stop V2Ray main loop
+ */
+func (v *V2RayPoint) StopLoop() (err error) {
+	v.v2rayOP.Lock()
+	defer v.v2rayOP.Unlock()
+	if v.status.IsRunning {
+		v.shutdownInit()
+	}
+	return
+}
+
+//Delegate Funcation
+func (v *V2RayPoint) GetIsRunning() bool {
+	return v.status.IsRunning
+}
+
+func (v *V2RayPoint) GetIsTRunning() bool {
+	return v.status.IsTRunning
+}
+
+//Delegate Funcation
+func (v V2RayPoint) QueryStats(tag string, direct string) int64 {
+	if v.statsManager == nil {
+		return 0
+	}
+	counter := v.statsManager.GetCounter(fmt.Sprintf("outbound>>>%s>>>traffic>>>%s", tag, direct))
+	if counter == nil {
+		return 0
+	}
+	return counter.Set(0)
+}
+
+func (v *V2RayPoint) shutdownInit() {
+	close(v.closeChan)
+	v.statsManager = nil
+	v.status.Vpoint.Close()
+	v.status.Vpoint = nil
+	v.status.IsRunning = false
+
+	v.escorter.EscortingDown()
+
+	v.SupportSet.Shutdown()
+	v.SupportSet.OnEmitStatus(0, "Closed")
+}
+
+func (v *V2RayPoint) pointloop() error {
+	log.Println("loading v2ray config")
+	config, err := v2serial.LoadJSONConfig(strings.NewReader(v.ConfigureFileContent))
+	if err != nil {
+		log.Println(err)
+		return err
+	}
+
+	log.Println("new v2ray core")
+	inst, err := v2core.New(config)
+	if err != nil {
+		log.Println(err)
+		return err
+	}
+	v.status.Vpoint = inst
+	v.statsManager = inst.GetFeature(v2stats.ManagerType()).(v2stats.Manager)
+
+	log.Println("start v2ray core")
+	v.status.IsRunning = true
+	if err := v.status.Vpoint.Start(); err != nil {
+		v.status.IsRunning = false
+		log.Println(err)
+		return err
+	}
+
+	v.SupportSet.Prepare()
+	v.SupportSet.Setup(v.status.GetVPNSetupArg(v.EnableLocalDNS, v.ForwardIpv6))
+	v.SupportSet.OnEmitStatus(0, "Running")
+
+	v.status.IsTRunning = false
+	if !v.ProxyOnly {
+		if err := v.runTun2socks(); err != nil {
+			log.Println(err)
+			return err
+		}
+		v.status.IsTRunning = true
+
+		log.Printf("EnableLocalDNS: %v\nForwardIpv6: %v\nDomainName: %s",
+			v.EnableLocalDNS,
+			v.ForwardIpv6,
+			v.DomainName)
+	}
+
+	return nil
+}
+
+func initV2Env() {
+	if os.Getenv(v2Assert) != "" {
+		return
+	}
+	//Initialize asset API, Since Raymond Will not let notify the asset location inside Process,
+	//We need to set location outside V2Ray
+	os.Setenv(v2Assert, assetperfix)
+	//Now we handle read
+	v2filesystem.NewFileReader = func(path string) (io.ReadCloser, error) {
+		if strings.HasPrefix(path, assetperfix) {
+			p := path[len(assetperfix)+1:]
+			//is it overridden?
+			//by, ok := overridedAssets[p]
+			//if ok {
+			//	return os.Open(by)
+			//}
+			return mobasset.Open(p)
+		}
+		return os.Open(path)
+	}
+}
+
+//Delegate Funcation
+func TestConfig(ConfigureFileContent string) error {
+	initV2Env()
+	_, err := v2serial.LoadJSONConfig(strings.NewReader(ConfigureFileContent))
+	return err
+}
+
+/*NewV2RayPoint new V2RayPoint*/
+func NewV2RayPoint(s V2RayVPNServiceSupportsSet) *V2RayPoint {
+	initV2Env()
+
+	// inject our own log writer
+	v2applog.RegisterHandlerCreator(v2applog.LogType_Console,
+		func(lt v2applog.LogType,
+			options v2applog.HandlerCreatorOptions) (v2commlog.Handler, error) {
+			return v2commlog.NewLogger(createStdoutLogWriter()), nil
+		})
+
+	dialer := VPN.NewPreotectedDialer(s)
+	v2internet.UseAlternativeSystemDialer(dialer)
+	status := &CoreI.Status{}
+	return &V2RayPoint{
+		SupportSet: s,
+		v2rayOP:    new(sync.Mutex),
+		status:     status,
+		dialer:     dialer,
+		escorter:   &Escort.Escorting{Status: status},
+	}
+}
+
+func (v V2RayPoint) runTun2socks() error {
+	v.escorter.EscortingUp()
+	go v.escorter.EscortRun(
+		v.status.GetApp("libtun2socks.so"),
+		v.status.GetTun2socksArgs(v.EnableLocalDNS, v.ForwardIpv6), "")
+
+	return nil
+}
+
+/*CheckVersion int
+This func will return libv2ray binding version.
+*/
+func CheckVersion() int {
+	return CoreI.CheckVersion()
+}
+
+/*CheckVersionX string
+This func will return libv2ray binding version and V2Ray version used.
+*/
+func CheckVersionX() string {
+	return fmt.Sprintf("Libv2rayLite V%d, Core V%s", CheckVersion(), v2core.Version())
+}

AndroidLibV2rayLite/libv2init.go

@@ -0,0 +1,58 @@
+package libv2ray
+
+import (
+	// The following are necessary as they register handlers in their init functions.
+
+	// Required features. Can't remove unless there is replacements.
+	_ "v2ray.com/core/app/dispatcher"
+	_ "v2ray.com/core/app/proxyman/inbound"
+	_ "v2ray.com/core/app/proxyman/outbound"
+
+	// Other optional features.
+	_ "v2ray.com/core/app/dns"
+	_ "v2ray.com/core/app/log"
+	_ "v2ray.com/core/app/policy"
+	_ "v2ray.com/core/app/router"
+	_ "v2ray.com/core/app/stats"
+
+	// Inbound and outbound proxies.
+	_ "v2ray.com/core/proxy/blackhole"
+	_ "v2ray.com/core/proxy/dns"
+	_ "v2ray.com/core/proxy/dokodemo"
+	_ "v2ray.com/core/proxy/freedom"
+	_ "v2ray.com/core/proxy/http"
+	_ "v2ray.com/core/proxy/mtproto"
+	_ "v2ray.com/core/proxy/shadowsocks"
+	_ "v2ray.com/core/proxy/socks"
+	_ "v2ray.com/core/proxy/trojan"
+	_ "v2ray.com/core/proxy/vless/inbound"
+	_ "v2ray.com/core/proxy/vless/outbound"
+	_ "v2ray.com/core/proxy/vmess/inbound"
+	_ "v2ray.com/core/proxy/vmess/outbound"
+
+	// Transport
+	_ "v2ray.com/core/transport/internet/http"
+	_ "v2ray.com/core/transport/internet/kcp"
+	_ "v2ray.com/core/transport/internet/quic"
+	_ "v2ray.com/core/transport/internet/tcp"
+	_ "v2ray.com/core/transport/internet/tls"
+	_ "v2ray.com/core/transport/internet/udp"
+	_ "v2ray.com/core/transport/internet/websocket"
+
+	// Transport headers
+	_ "v2ray.com/core/transport/internet/headers/http"
+	_ "v2ray.com/core/transport/internet/headers/noop"
+	_ "v2ray.com/core/transport/internet/headers/srtp"
+	_ "v2ray.com/core/transport/internet/headers/tls"
+	_ "v2ray.com/core/transport/internet/headers/utp"
+	_ "v2ray.com/core/transport/internet/headers/wechat"
+	_ "v2ray.com/core/transport/internet/headers/wireguard"
+
+	// JSON config support. Choose only one from the two below.
+	// The following line loads JSON from v2ctl
+	// _ "v2ray.com/core/main/json"
+	// The following line loads JSON internally
+	_ "v2ray.com/core/main/jsonem"
+	// Load config from file or http(s)
+	// _ "v2ray.com/core/main/confloader/external"
+)

AndroidLibV2rayLite/libv2ray.go

@@ -0,0 +1,3 @@
+package libv2ray
+
+//go:generate make all

AndroidLibV2rayLite/readme.txt

@@ -0,0 +1 @@
+readme.txt

AndroidLibV2rayLite/tun2socks.mk

@@ -0,0 +1,128 @@
+# Copyright (C) 2009 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.
+#
+#
+LOCAL_PATH := $(call my-dir)
+ROOT_PATH := $(LOCAL_PATH)
+
+########################################################
+## libancillary
+########################################################
+
+include $(CLEAR_VARS)
+
+ANCILLARY_SOURCE := fd_recv.c fd_send.c
+
+LOCAL_MODULE := libancillary
+#LOCAL_CFLAGS += -I$(LOCAL_PATH)/libancillary
+LOCAL_C_INCLUDES := $(LOCAL_PATH)/libancillary
+LOCAL_SRC_FILES := $(addprefix libancillary/, $(ANCILLARY_SOURCE))
+
+include $(BUILD_STATIC_LIBRARY)
+
+########################################################
+## tun2socks
+########################################################
+
+include $(CLEAR_VARS)
+
+LOCAL_CFLAGS := -std=gnu99
+LOCAL_CFLAGS += -DBADVPN_THREADWORK_USE_PTHREAD -DBADVPN_LINUX -DBADVPN_BREACTOR_BADVPN -D_GNU_SOURCE
+LOCAL_CFLAGS += -DBADVPN_USE_SIGNALFD -DBADVPN_USE_EPOLL
+LOCAL_CFLAGS += -DBADVPN_LITTLE_ENDIAN -DBADVPN_THREAD_SAFE
+LOCAL_CFLAGS += -DNDEBUG -DANDROID
+LOCAL_CFLAGS += -I
+
+LOCAL_STATIC_LIBRARIES := libancillary
+
+LOCAL_C_INCLUDES := \
+	$(LOCAL_PATH)/badvpn/libancillary \
+        $(LOCAL_PATH)/badvpn/lwip/src/include/ipv4 \
+        $(LOCAL_PATH)/badvpn/lwip/src/include/ipv6 \
+        $(LOCAL_PATH)/badvpn/lwip/src/include \
+        $(LOCAL_PATH)/badvpn/lwip/custom \
+        $(LOCAL_PATH)/badvpn \
+	$(LOCAL_PATH)/libancillary
+
+TUN2SOCKS_SOURCES := \
+        base/BLog_syslog.c \
+        system/BReactor_badvpn.c \
+        system/BSignal.c \
+        system/BConnection_common.c \
+        system/BConnection_unix.c \
+        system/BTime.c \
+        system/BUnixSignal.c \
+        system/BNetwork.c \
+        flow/StreamRecvInterface.c \
+        flow/PacketRecvInterface.c \
+        flow/PacketPassInterface.c \
+        flow/StreamPassInterface.c \
+        flow/SinglePacketBuffer.c \
+        flow/BufferWriter.c \
+        flow/PacketBuffer.c \
+        flow/PacketStreamSender.c \
+        flow/PacketPassConnector.c \
+        flow/PacketProtoFlow.c \
+        flow/PacketPassFairQueue.c \
+        flow/PacketProtoEncoder.c \
+        flow/PacketProtoDecoder.c \
+        socksclient/BSocksClient.c \
+        tuntap/BTap.c \
+        lwip/src/core/udp.c \
+        lwip/src/core/memp.c \
+        lwip/src/core/init.c \
+        lwip/src/core/pbuf.c \
+        lwip/src/core/tcp.c \
+        lwip/src/core/tcp_out.c \
+        lwip/src/core/netif.c \
+        lwip/src/core/def.c \
+        lwip/src/core/ip.c \
+        lwip/src/core/mem.c \
+        lwip/src/core/tcp_in.c \
+        lwip/src/core/stats.c \
+        lwip/src/core/inet_chksum.c \
+        lwip/src/core/timeouts.c \
+        lwip/src/core/ipv4/icmp.c \
+        lwip/src/core/ipv4/igmp.c \
+        lwip/src/core/ipv4/ip4_addr.c \
+        lwip/src/core/ipv4/ip4_frag.c \
+        lwip/src/core/ipv4/ip4.c \
+        lwip/src/core/ipv4/autoip.c \
+        lwip/src/core/ipv6/ethip6.c \
+        lwip/src/core/ipv6/inet6.c \
+        lwip/src/core/ipv6/ip6_addr.c \
+        lwip/src/core/ipv6/mld6.c \
+        lwip/src/core/ipv6/dhcp6.c \
+        lwip/src/core/ipv6/icmp6.c \
+        lwip/src/core/ipv6/ip6.c \
+        lwip/src/core/ipv6/ip6_frag.c \
+        lwip/src/core/ipv6/nd6.c \
+        lwip/custom/sys.c \
+        tun2socks/tun2socks.c \
+        base/DebugObject.c \
+        base/BLog.c \
+        base/BPending.c \
+		system/BDatagram_unix.c \
+        flowextra/PacketPassInactivityMonitor.c \
+        tun2socks/SocksUdpGwClient.c \
+        udpgw_client/UdpGwClient.c
+
+LOCAL_MODULE := tun2socks
+
+LOCAL_LDLIBS := -ldl -llog
+
+LOCAL_SRC_FILES := $(addprefix badvpn/, $(TUN2SOCKS_SOURCES))
+
+include $(BUILD_SYSTEM)/build-executable.mk
+

AndroidLibV2rayLite/ubuntu-cli-install-android-sdk.sh

@@ -0,0 +1,79 @@
+#!/bin/bash
+
+# Thanks to https://gist.github.com/wenzhixin/43cf3ce909c24948c6e7
+# Execute this script in your home directory. Lines 17 and 21 will prompt you for a y/n
+
+# Install Oracle JDK 8
+apt-get update
+apt-get install -y openjdk-8-jdk
+apt-get install -y unzip make expect # NDK stuff
+
+# Get SDK tools (link from https://developer.android.com/studio/index.html#downloads)
+wget -q https://dl.google.com/android/repository/sdk-tools-linux-3859397.zip
+mkdir android-sdk-linux
+unzip sdk*.zip -d android-sdk-linux
+
+# Get NDK (https://developer.android.com/ndk/downloads/index.html)
+# wget -q https://dl.google.com/android/repository/android-ndk-r15c-linux-x86_64.zip
+# unzip android-ndk*.zip >> /dev/null
+
+ACCEPT_LICENSES_URL=https://gist.githubusercontent.com/xiaokangwang/1489fd223d26581bfec92adb3cb0088e/raw/328eb6925099df5aae3e76790f8232f0fc378f8b/accept-licenses
+
+ACCEPT_LICENSES_ITEM="android-sdk-license-bcbbd656|intel-android-sysimage-license-1ea702d1|android-sdk-license-2742d1c5"
+
+# Let it update itself and install some stuff
+cd android-sdk-linux/tools
+
+curl -L -o accept-licenses $ACCEPT_LICENSES_URL
+
+chmod +x accept-licenses
+
+./accept-licenses "./android update sdk --use-sdk-wrapper --all --no-ui" $ACCEPT_LICENSES_ITEM  >/dev/null
+
+# Download every build-tools version that has ever existed
+# This will save you time! Thank me later for this
+
+#./accept-licenses "./android update sdk --use-sdk-wrapper --all --no-ui --filter 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27" $ACCEPT_LICENSES_ITEM
+
+PACKAGE_PARSE_URL=https://gist.githubusercontent.com/xiaokangwang/06268fb23034ed94bc301880e862da09/raw/afd95cbbe2f8c1d9e7b0277b7c5ef39af756a6ee/parse.awk
+
+reduceout=https://gist.githubusercontent.com/xiaokangwang/4684bdb5c3415b943f52aa4803386480/raw/b46dab1cc60f02c0d87f88f01e27157034218faa/out.awk
+
+cd bin
+
+curl -L -o parse.awk $PACKAGE_PARSE_URL
+
+curl -L -o reduce.awk $reduceout
+
+sudo apt-get install gawk
+
+./sdkmanager --verbose --list |awk -f parse.awk > ~/package_to_install
+
+readarray -t filenames < $HOME/package_to_install
+
+cat $HOME/package_to_install
+
+yes|./sdkmanager --verbose "${filenames[@]}" |awk -f reduce.awk
+
+# If you need additional packages for your app, check available packages with:
+# ./android list sdk --all
+
+# install certain packages with:
+# ./android update sdk --no-ui --all --filter 1,2,3,<...>,N
+# where N is the number of the package in the list (see previous command)
+
+./sdkmanager "ndk-bundle"
+
+# Add the directory containing executables in PATH so that they can be found
+echo 'export ANDROID_HOME=$HOME/android-sdk-linux' >> ~/.bashrc
+echo 'export PATH=$PATH:$ANDROID_HOME/tools:$ANDROID_HOME/platform-tools' >> ~/.bashrc
+# echo 'export NDK_HOME=$HOME/android-ndk-r15c' >> ~/.bashrc
+# echo 'export ANDROID_NDK_HOME=$NDK_HOME' >> ~/.bashrc
+
+
+source ~/.bashrc
+
+# Make sure you can execute 32 bit executables if this is 64 bit machine, otherwise skip this
+dpkg --add-architecture i386
+apt-get update
+apt-get install -y libc6:i386 libstdc++6:i386 zlib1g:i386

AndroidLibV2rayLite/v2logger.go

@@ -0,0 +1,32 @@
+package libv2ray
+
+// This struct creates our own log writer without datatime stamp
+// As Android adds time stamps on each line
+
+import (
+	"log"
+	"os"
+
+	v2commlog "v2ray.com/core/common/log"
+)
+
+type consoleLogWriter struct {
+	logger *log.Logger
+}
+
+func (w *consoleLogWriter) Write(s string) error {
+	w.logger.Print(s)
+	return nil
+}
+
+func (w *consoleLogWriter) Close() error {
+	return nil
+}
+
+// This logger won't print data/time stamps
+func createStdoutLogWriter() v2commlog.WriterCreator {
+	return func() v2commlog.Writer {
+		return &consoleLogWriter{
+			logger: log.New(os.Stdout, "", 0)}
+	}
+}

CR.md

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

README.md

@@ -2,8 +2,8 @@
 
 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)
+[![API](https://img.shields.io/badge/API-17%2B-yellow.svg?style=flat)](https://developer.android.com/about/versions/jelly-bean#android-4.2)
+[![Kotlin Version](https://img.shields.io/badge/Kotlin-1.4.10-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)
@@ -13,24 +13,23 @@ A V2Ray client for Android, support [Xray core](https://github.com/XTLS/Xray-cor
 <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)
+v2rayNG release already embedded domain file `geoip.dat` and `geosite.dat`. However it is (probably) not the latest and not the most complete list.
+For power user, the embedded files can be easily replaced with the following steps:
+1. Launch v2rayNG (v1.4.9+)
+2. Find existing geoip.dat and geosite.dat in `Android/data/com.v2ray.ang/files/assets` (path may differ on some Android device)
+3. Replace them with the latest [domain list](https://github.com/v2fly/domain-list-community) and [ip list](https://github.com/v2fly/geoip)
+4. Enhanced version can be found in this [repo](https://github.com/Loyalsoldier/v2ray-rules-dat) (recommend to use `geosite:geolocation-!cn` for proxy dns and routing)
+5. It is also 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)
+#### See 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/)
+The aar can be compiled from the Golang project under AndroidLibV2rayLite folder. 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 can run on Android Emulators, with minimum Android 5.0

V2rayNG/.gitignore

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

V2rayNG/app/build.gradle

@@ -0,0 +1,121 @@
+apply plugin: 'com.android.application'
+apply plugin: 'kotlin-android'
+apply plugin: 'kotlin-android-extensions'
+
+android {
+    compileSdkVersion Integer.parseInt("$compileSdkVer")
+    buildToolsVersion buildToolsVer
+
+    compileOptions {
+        targetCompatibility = "8"
+        sourceCompatibility = "8"
+    }
+
+    defaultConfig {
+        applicationId "com.v2ray.ang"
+        minSdkVersion 17
+        targetSdkVersion Integer.parseInt("$targetSdkVer")
+        multiDexEnabled true
+        versionCode 212
+        versionName "1.0.2"
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+            zipAlignEnabled false
+            shrinkResources false
+            ndk.abiFilters 'x86', 'x86_64', 'armeabi-v7a', 'arm64-v8a'
+//            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+        debug {
+            minifyEnabled false
+            zipAlignEnabled false
+            shrinkResources false
+            ndk.abiFilters 'x86', 'x86_64', 'armeabi-v7a', 'arm64-v8a'
+        }
+    }
+
+    sourceSets {
+        main.java.srcDirs += 'src/main/kotlin'
+    }
+
+    kotlinOptions {
+        jvmTarget = JavaVersion.VERSION_1_8
+    }
+
+    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')
+    testImplementation 'junit:junit:4.13'
+
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion"
+    implementation "org.jetbrains.kotlin:kotlin-reflect:$kotlinVersion"
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.9"
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.9"
+
+    // Androidx ktx
+    implementation 'android.arch.lifecycle:extensions:1.1.1'
+    implementation 'android.arch.lifecycle:livedata:1.1.1'
+
+    // 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"
+    implementation "com.android.support:multidex:1.0.3"
+    implementation 'com.android.support.constraint:constraint-layout:2.0.1'
+
+    // DSL
+    implementation 'com.tencent:mmkv-static:1.0.19'
+    implementation 'com.google.code.gson:gson:2.8.6'
+    implementation 'io.reactivex:rxjava:1.3.4'
+    implementation 'io.reactivex:rxandroid:1.2.1'
+    implementation 'com.tbruyelle.rxpermissions:rxpermissions:0.9.4@aar'
+    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 'me.drakeet.support:toastcompat:1.1.0'
+
+    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

@@ -1,132 +0,0 @@
-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 = 561
-        versionName = "1.8.24"
-        multiDexEnabled = true
-        splits.abi {
-            reset()
-            include(
-                "arm64-v8a",
-                "armeabi-v7a",
-                "x86_64",
-                "x86"
-            )
-        }
-    }
-
-    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.12.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.7.1")
-    implementation("androidx.multidex:multidex:2.0.1")
-    implementation("androidx.viewpager2:viewpager2:1.1.0")
-
-    // Androidx ktx
-    implementation("androidx.activity:activity-ktx:1.9.0")
-    implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:2.8.0")
-    implementation("androidx.lifecycle:lifecycle-livedata-ktx:2.8.0")
-    implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.8.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.4")
-    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("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/libs/Readme.md

@@ -0,0 +1 @@
+https://github.com/2dust/v2rayNG/tree/master/AndroidLibV2rayLite

V2rayNG/app/proguard-rules.pro

@@ -0,0 +1,58 @@
+# 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 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

@@ -0,0 +1,13 @@
+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

@@ -1,4 +0,0 @@
-<?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,60 +1,53 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools"
-    tools:ignore="MissingLeanbackLauncher">
+    package="com.v2ray.ang">
 
     <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"/>
+            android:anyDensity="true"
+            android:smallScreens="true"
+            android:normalScreens="true"
+            android:largeScreens="true"
+            android:xlargeScreens="true"/>
 
     <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" />
+        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" />
-    <!-- <useapplications-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" /> -->
+    <!-- <uses-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/AppThemeDayNight"
-        android:usesCleartextTraffic="true"
-        tools:targetApi="m">
-
+        android:extractNativeLibs="true"
+        android:theme="@style/AppTheme">
         <activity
             android:name=".ui.MainActivity"
-            android:exported="true"
-            android:launchMode="singleTask"
-            android:theme="@style/AppThemeDayNight.NoActionBar">
+            android:theme="@style/AppTheme.NoActionBar"
+            android:launchMode="singleTask">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
                 <category android:name="android.intent.category.LAUNCHER" />
-<!--                <category android:name="android.intent.category.LEANBACK_LAUNCHER"/>-->
+            </intent-filter>
+            <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.service.quicksettings.action.QS_TILE_PREFERENCES" />
@@ -64,80 +57,35 @@
                 android:resource="@xml/shortcuts" />
         </activity>
         <activity
-            android:exported="false"
             android:name=".ui.ServerActivity"
             android:windowSoftInputMode="stateUnchanged" />
         <activity
-            android:exported="false"
             android:name=".ui.ServerCustomConfigActivity"
             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" />
         <activity
-            android:exported="false"
-            android:name=".ui.SettingsActivity" />
-        <activity
-            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: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.SubSettingActivity" />
 
+        <activity android:name=".ui.SubEditActivity" />
+        <activity android:name=".ui.ScScannerActivity" />
         <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>
-        <activity
-            android:exported="false"
-            android:name=".ui.AboutActivity" />
-
         <service
             android:name=".service.V2RayVpnService"
             android:enabled="true"
             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" />
@@ -145,29 +93,15 @@
             <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>
 
         <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>
 
-        <service android:name=".service.V2RayTestService"
-            android:exported="false"
-            android:process=":RunSoLibV2RayDaemon">
-        </service>
-
-        <receiver
-                android:exported="true"
-                android:name=".receiver.WidgetProvider"
+        <receiver android:name=".receiver.WidgetProvider"
                 android:process=":RunSoLibV2RayDaemon">
             <meta-data
                     android:name="android.appwidget.provider"
@@ -180,23 +114,17 @@
         </receiver>
 
         <service
-                android:exported="true"
                 android:name=".service.QSTileService"
-                android:icon="@drawable/ic_stat_name"
+                android:icon="@drawable/ic_v"
                 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">
@@ -205,37 +133,13 @@
             </intent-filter>
         </activity>
 
-        <receiver
-            android:exported="true"
-            android:name=".receiver.TaskerReceiver"
+        <receiver 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>
-
-        <provider
-            android:name="androidx.core.content.FileProvider"
-            android:authorities="${applicationId}.cache"
-            android:exported="false"
-            android:grantUriPermissions="true">
-            <meta-data
-                android:name="android.support.FILE_PROVIDER_PATHS"
-                android:resource="@xml/cache_paths"/>
-        </provider>
 
     </application>
 

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

@@ -0,0 +1,144 @@
+/*
+ * 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

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

V2rayNG/app/src/main/assets/custom_routing_direct

@@ -1,2 +0,0 @@
-geosite:cn,
-geosite:geolocation-cn

V2rayNG/app/src/main/assets/custom_routing_proxy

@@ -1 +0,0 @@
-geosite:geolocation-!cn

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

@@ -54,7 +54,7 @@
           "users": [
             {
               "id": "a3482e88-686a-4a58-8126-99c9df64b7bf",
-              "alterId": 0,
+              "alterId": 64,
               "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 androidx.recyclerview.widget.RecyclerView;
-import androidx.recyclerview.widget.ItemTouchHelper;
+import android.support.v7.widget.RecyclerView;
+import android.support.v7.widget.helper.ItemTouchHelper;
 
 /**
  * Interface to listen for a move or dismissal event from a {@link ItemTouchHelper.Callback}.

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

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

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

@@ -17,11 +17,9 @@
 package com.v2ray.ang.helper;
 
 import android.graphics.Canvas;
-import androidx.recyclerview.widget.GridLayoutManager;
-import androidx.recyclerview.widget.RecyclerView;
-import androidx.recyclerview.widget.ItemTouchHelper;
-
-import org.jetbrains.annotations.NotNull;
+import android.support.v7.widget.GridLayoutManager;
+import android.support.v7.widget.RecyclerView;
+import android.support.v7.widget.helper.ItemTouchHelper;
 
 /**
  * An implementation of {@link ItemTouchHelper.Callback} that enables basic drag & drop and
@@ -54,7 +52,7 @@ public class SimpleItemTouchHelperCallback extends ItemTouchHelper.Callback {
     }
 
     @Override
-    public int getMovementFlags(RecyclerView recyclerView, @NotNull RecyclerView.ViewHolder viewHolder) {
+    public int getMovementFlags(RecyclerView recyclerView, 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;
@@ -68,25 +66,24 @@ public class SimpleItemTouchHelperCallback extends ItemTouchHelper.Callback {
     }
 
     @Override
-    public boolean onMove(@NotNull RecyclerView recyclerView, RecyclerView.ViewHolder source, RecyclerView.ViewHolder target) {
+    public boolean onMove(RecyclerView recyclerView, RecyclerView.ViewHolder source, RecyclerView.ViewHolder target) {
         if (source.getItemViewType() != target.getItemViewType()) {
             return false;
         }
 
         // Notify the adapter of the move
-        mAdapter.onItemMove(source.getBindingAdapterPosition(), target.getBindingAdapterPosition());
+        mAdapter.onItemMove(source.getAdapterPosition(), target.getAdapterPosition());
         return true;
     }
 
     @Override
     public void onSwiped(RecyclerView.ViewHolder viewHolder, int i) {
         // Notify the adapter of the dismissal
-        mAdapter.onItemDismiss(viewHolder.getBindingAdapterPosition());
+        mAdapter.onItemDismiss(viewHolder.getAdapterPosition());
     }
 
     @Override
-    public void onChildDraw(@NotNull Canvas c, @NotNull RecyclerView recyclerView, @NotNull RecyclerView.ViewHolder viewHolder, float dX,
-                            float dY, int actionState, boolean isCurrentlyActive) {
+    public void onChildDraw(Canvas c, RecyclerView recyclerView, 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();
@@ -112,7 +109,7 @@ public class SimpleItemTouchHelperCallback extends ItemTouchHelper.Callback {
     }
 
     @Override
-    public void clearView(@NotNull RecyclerView recyclerView, @NotNull RecyclerView.ViewHolder viewHolder) {
+    public void clearView(RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder) {
         super.clearView(recyclerView, viewHolder);
 
         mAdapter.onItemMoveCompleted();

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

@@ -0,0 +1,121 @@
+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

@@ -0,0 +1,570 @@
+// 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

@@ -0,0 +1,32 @@
+// 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

@@ -0,0 +1,43 @@
+/* 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

@@ -0,0 +1,979 @@
+/* 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

@@ -0,0 +1,45 @@
+/* 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

@@ -0,0 +1,91 @@
+/* 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

@@ -0,0 +1,540 @@
+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

@@ -0,0 +1,63 @@
+/* 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

@@ -0,0 +1,116 @@
+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

@@ -0,0 +1,119 @@
+/* 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

@@ -0,0 +1,58 @@
+/* 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,44 +1,29 @@
 package com.v2ray.ang
 
-import android.content.Context
-import androidx.multidex.MultiDexApplication
-import androidx.work.Configuration
+import android.support.multidex.MultiDexApplication
+import android.support.v7.preference.PreferenceManager
 import com.tencent.mmkv.MMKV
-import com.v2ray.ang.util.Utils
 
-class AngApplication : MultiDexApplication(), Configuration.Provider {
+class AngApplication : MultiDexApplication() {
     companion object {
-        //const val PREF_LAST_VERSION = "pref_last_version"
-        lateinit var application: AngApplication
+        const val PREF_LAST_VERSION = "pref_last_version"
     }
 
-    override fun attachBaseContext(base: Context?) {
-        super.attachBaseContext(base)
-        application = this
-    }
-
-    //var firstRun = false
-     //   private set
+    var curIndex = -1 //Current proxy that is opened. (Used to implement restart feature)
+    var firstRun = false
+        private set
 
     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()
+        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)
         MMKV.initialize(this)
-
-        Utils.setNightMode(application)
-    }
-
-    override fun getWorkManagerConfiguration(): Configuration {
-        return Configuration.Builder()
-            .setDefaultProcessName("${BuildConfig.APPLICATION_ID}:bg")
-            .build()
     }
 }

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

@@ -5,73 +5,43 @@ package com.v2ray.ang
  * App Config Const
  */
 object AppConfig {
-    const val ANG_PACKAGE = BuildConfig.APPLICATION_ID
-    const val DIR_ASSETS = "assets"
-    const val DIR_BACKUPS = "backups"
+    const val ANG_PACKAGE = "com.v2ray.ang"
 
     // legacy
     const val ANG_CONFIG = "ang_config"
     const val PREF_INAPP_BUY_IS_PREMIUM = "pref_inapp_buy_is_premium"
+    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_ROUTE_ONLY_ENABLED = "pref_route_only_enabled"
-
-    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_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_LOCAL_DNS_PORT = "pref_local_dns_port"
-    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_FORWARD_IPV6 = "pref_forward_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_ROUTING_CUSTOM = "pref_routing_custom"
+    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_BYPASS_MAINLAND = "pref_bypass_mainland"
+    //        const val PREF_START_ON_BOOT = "pref_start_on_boot"
+    //        const val PREF_MUX_ENAimport libv2ray.Libv2rayBLED = "pref_mux_enabled"
+    //        const val PREF_SOCKS_PORT = "pref_socks_port"
+//        const val PREF_HTTP_PORT = "pref_http_port"
+    //        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_AUTO_RESTART = "pref_auto_restart"
 
-    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 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 PREF_SPEED_ENABLED = "pref_speed_enabled"
-    const val PREF_CONFIRM_REMOVE = "pref_confirm_remove"
-    const val PREF_START_SCAN_IMMEDIATE = "pref_start_scan_immediate"
-    const val PREF_LANGUAGE = "pref_language"
-    const val PREF_UI_MODE_NIGHT = "pref_ui_mode_night"
-
-    const val PREF_PREFER_IPV6 = "pref_prefer_ipv6"
-    const val PREF_PROXY_SHARING = "pref_proxy_sharing_enabled"
-    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_REMOTE_DNS = "pref_remote_dns"
-    const val PREF_DOMESTIC_DNS = "pref_domestic_dns"
-    const val PREF_DELAY_TEST_URL = "pref_delay_test_url"
-    const val PREF_LOGLEVEL = "pref_core_loglevel"
-    const val PREF_MODE = "pref_mode"
-
-    const val CACHE_SUBSCRIPTION_ID = "cache_subscription_id"
-    const val CACHE_KEYWORD_FILTER = "cache_keyword_filter"
-
-    //Preferences mapped to MMKV End
-
-    const val PROTOCOL_HTTP: String = "http://"
-    const val PROTOCOL_HTTPS: String = "https://"
-    const val PROTOCOL_FREEDOM: String = "freedom"
+    const val HTTP_PROTOCOL: String = "http://"
+    const val HTTPS_PROTOCOL: String = "https://"
 
     const val BROADCAST_ACTION_SERVICE = "com.v2ray.ang.action.service"
     const val BROADCAST_ACTION_ACTIVITY = "com.v2ray.ang.action.activity"
@@ -83,34 +53,18 @@ object AppConfig {
     const val TASKER_EXTRA_BUNDLE_GUID = "tasker_extra_bundle_guid"
     const val TASKER_DEFAULT_GUID = "Default"
 
-    const val TAG_PROXY = "proxy"
+    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 v2rayNGUrl = "https://github.com/2dust/v2rayNG"
-    const val v2rayNGIssues = "$v2rayNGUrl/issues"
-    const val v2rayNGWikiMode = "$v2rayNGUrl/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 TgChannelUrl = "https://t.me/github_2dust"
-    const val DelayTestUrl = "https://www.gstatic.com/generate_204"
+    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 v2rayNGWikiMode = "https://github.com/2dust/v2rayNG/wiki/Mode"
+    const val promotionUrl = "https://1.2345345.xyz/ads.html"
 
-    const val DNS_PROXY = "1.1.1.1"
+    const val DNS_AGENT = "1.1.1.1"
     const val DNS_DIRECT = "223.5.5.5"
-    const val DNS_VPN = "1.1.1.1"
-
-    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
@@ -122,9 +76,4 @@ 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
 }

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

@@ -17,16 +17,12 @@ 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 flow: String = "",
-                         var sni: String = "")
+                         var subid: String = "")
 
     data class SubItemBean(var id: String = "",
                            var remarks: String = "",
-                           var url: String = "",
-                           var enabled: Boolean = true)
+                           var url: String = "")
 }

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

@@ -1,8 +0,0 @@
-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

@@ -6,8 +6,7 @@ enum class EConfigType(val value: Int, val protocolScheme: String) {
     SHADOWSOCKS(3, "ss://"),
     SOCKS(4, "socks://"),
     VLESS(5, "vless://"),
-    TROJAN(6, "trojan://"),
-    WIREGUARD(7, "wireguard://");
+    TROJAN(6, "trojan://");
 
     companion object {
         fun fromInt(value: Int) = values().firstOrNull { it.value == value }

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

@@ -1,9 +0,0 @@
-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/ServerConfig.kt

@@ -1,6 +1,6 @@
 package com.v2ray.ang.dto
 
-import com.v2ray.ang.AppConfig.TAG_PROXY
+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
@@ -19,32 +19,23 @@ data class 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()))
+                            configType = configType,
+                            outboundBean = V2rayConfig.OutboundBean(
+                                    protocol = configType.name.toLowerCase(),
+                                    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())
-                            )))
+                            configType = configType,
+                            outboundBean = V2rayConfig.OutboundBean(
+                                    protocol = configType.name.toLowerCase(),
+                                    settings = V2rayConfig.OutboundBean.OutSettingsBean(
+                                            servers = listOf(V2rayConfig.OutboundBean.OutSettingsBean.ServersBean())),
+                                    streamSettings = V2rayConfig.OutboundBean.StreamSettingsBean()))
             }
         }
     }
@@ -58,7 +49,7 @@ data class ServerConfig(
 
     fun getAllOutboundTags(): MutableList<String> {
         if (configType != EConfigType.CUSTOM) {
-            return mutableListOf(TAG_PROXY, TAG_DIRECT, TAG_BLOCKED)
+            return mutableListOf(TAG_AGENT, TAG_DIRECT, TAG_BLOCKED)
         }
         fullConfig?.let { config ->
             return config.outbounds.map { it.tag }.toMutableList()
@@ -69,6 +60,10 @@ data class ServerConfig(
     fun getV2rayPointDomainAndPort(): String {
         val address = getProxyOutbound()?.getServerAddress().orEmpty()
         val port = getProxyOutbound()?.getServerPort()
-        return Utils.getIpv6Address(address) + ":" + port
+        return if (Utils.isIpv6Address(address)) {
+            String.format("[%s]:%s", address, port)
+        } else {
+            String.format("%s:%s", address, port)
+        }
     }
 }

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

@@ -1,4 +0,0 @@
-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

@@ -1,12 +1,8 @@
 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,
-)
-
+        var remarks: String = "",
+        var url: String = "",
+        var enabled: Boolean = true,
+        val addedTime: Long = System.currentTimeMillis()) {
+}

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

@@ -5,12 +5,10 @@ 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(
-        var remarks: String? = null,
         var stats: Any? = null,
         val log: LogBean,
         var policy: PolicyBean?,
@@ -21,25 +19,22 @@ data class V2rayConfig(
         val api: Any? = null,
         val transport: Any? = null,
         val reverse: Any? = null,
-        var fakedns: Any? = null,
-        val browserForwarder: Any? = null,
-        var observatory: Any? = null,
-        var burstObservatory: Any? = null) {
+        val fakedns: 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 DEFAULT_FLOW = "xtls-rprx-splice"
 
         const val TLS = "tls"
-        const val REALITY = "reality"
+        const val XTLS = "xtls"
         const val HTTP = "http"
     }
 
     data class LogBean(val access: String,
                        val error: String,
-                       var loglevel: String?,
-                       val dnsLog: Boolean? = null)
+                       var loglevel: String?)
 
     data class InboundBean(
             var tag: String,
@@ -59,40 +54,32 @@ data class V2rayConfig(
                                   val network: String? = null)
 
         data class SniffingBean(var enabled: Boolean,
-                                val destOverride: ArrayList<String>,
-                                val metadataOnly: Boolean? = null,
-                                var routeOnly: Boolean? = null)
+                                val destOverride: List<String>,
+                                val metadataOnly: Boolean? = null)
     }
 
-    data class OutboundBean(var tag: String = "proxy",
+    data class OutboundBean(val tag: String = "proxy",
                             var protocol: String,
                             var settings: OutSettingsBean? = null,
                             var streamSettings: StreamSettingsBean? = null,
                             val proxySettings: Any? = null,
                             val sendThrough: String? = null,
-                            var mux: MuxBean? = MuxBean(false)) {
+                            val mux: MuxBean? = MuxBean(false)) {
 
         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 address: String? = null,
                                    val port: Int? = null,
                 /*Freedom*/
-                                   var domainStrategy: String? = null,
+                                   val 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
-        ) {
+                                   val inboundTag: String? = null) {
 
             data class VnextBean(var address: String = "",
                                  var port: Int = DEFAULT_PORT,
@@ -106,10 +93,6 @@ data class V2rayConfig(
                                      var flow: String = "")
             }
 
-            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,
@@ -117,8 +100,7 @@ data class V2rayConfig(
                                    var port: Int = DEFAULT_PORT,
                                    var level: Int = DEFAULT_LEVEL,
                                    val email: String? = null,
-                                   var flow: String? = null,
-                                   val ivCheck: Boolean? = null,
+                                   val flow: String? = null,
                                    var users: List<SocksUsersBean>? = null) {
 
 
@@ -128,9 +110,6 @@ data class V2rayConfig(
             }
 
             data class Response(var type: String)
-
-            data class WireGuardBean(var publicKey: String = "",
-                                     var endpoint: String = "")
         }
 
         data class StreamSettingsBean(var network: String = DEFAULT_NETWORK,
@@ -138,32 +117,22 @@ data class V2rayConfig(
                                       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,
+                                      var xtlsSettings: TlsSettingsBean? = null,
+                                      val grpcSettings: Any? = null,
                                       val dsSettings: Any? = null,
-                                      var sockopt: SockoptBean? = null
+                                      val sockopt: Any? = null
         ) {
 
-            data class TcpSettingsBean(var header: HeaderBean = HeaderBean(),
-                                       val acceptProxyProtocol: Boolean? = null) {
+            data class TcpSettingsBean(var header: HeaderBean = HeaderBean()) {
                 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)
+                                           var headers: HeadersBean = HeadersBean()) {
+                        data class HeadersBean(var Host: List<String> = ArrayList())
                     }
                 }
             }
@@ -181,43 +150,18 @@ data class V2rayConfig(
             }
 
             data class WsSettingsBean(var path: String = "",
-                                      var headers: HeadersBean = HeadersBean(),
-                                      val maxEarlyData: Int? = null,
-                                      val useBrowserForwarding: Boolean? = null,
-                                      val acceptProxyProtocol: Boolean? = null) {
+                                      var headers: HeadersBean = HeadersBean()) {
                 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)
+                                       val disableSystemRoot: Boolean? = null)
 
             data class QuicSettingBean(var security: String = "none",
                                        var key: String = "",
@@ -225,16 +169,8 @@ data class V2rayConfig(
                 data class HeaderBean(var type: String = "none")
             }
 
-            data class GrpcSettingsBean(var serviceName: String = "",
-                                        var authority: String? = null,
-                                        var multiMode: Boolean? = null,
-                                        var idle_timeout: Int? = null,
-                                        var health_check_timeout: Int? = null
-                )
-
             fun populateTransportSettings(transport: String, headerType: String?, host: String?, path: String?, seed: String?,
-                                          quicSecurity: String?, key: String?, mode: String?, serviceName: String?,
-                                          authority: String?): String {
+                                          quicSecurity: String?, key: String?): String {
                 var sni = ""
                 network = transport
                 when (network) {
@@ -244,8 +180,8 @@ data class V2rayConfig(
                             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() }
+                                requestObj.headers.Host = (host ?: "").split(",").map { it.trim() }
+                                requestObj.path = (path ?: "").split(",").map { it.trim() }
                                 tcpSetting.header.request = requestObj
                                 sni = requestObj.headers.Host.getOrNull(0) ?: sni
                             }
@@ -272,17 +208,10 @@ data class V2rayConfig(
                         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() }
+                        h2Setting.host = (host ?: "").split(",").map { it.trim() }
                         sni = h2Setting.host.getOrNull(0) ?: sni
                         h2Setting.path = path ?: "/"
                         httpSettings = h2Setting
@@ -294,46 +223,25 @@ data class V2rayConfig(
                         quicsetting.header.type = headerType ?: "none"
                         quicSettings = quicsetting
                     }
-                    "grpc" -> {
-                        val grpcSetting = GrpcSettingsBean()
-                        grpcSetting.multiMode = mode == "multi"
-                        grpcSetting.serviceName = serviceName ?: ""
-                        grpcSetting.authority = authority ?: ""
-                        grpcSetting.idle_timeout = 60
-                        grpcSetting.health_check_timeout = 20
-                        sni = authority ?: ""
-                        grpcSettings = grpcSetting
-                    }
                 }
                 return sni
             }
 
-            fun populateTlsSettings(streamSecurity: String, allowInsecure: Boolean, sni: String, fingerprint: String?, alpns: String?,
-                                    publicKey: String?, shortId: String?, spiderX: String?) {
+            fun populateTlsSettings(streamSecurity: String, allowInsecure: Boolean, sni: 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
+                        serverName = sni
                 )
                 if (security == TLS) {
                     tlsSettings = tlsSetting
-                    realitySettings = null
-                } else if (security == REALITY) {
-                    tlsSettings = null
-                    realitySettings = tlsSetting
+                } else if (security == XTLS) {
+                    xtlsSettings = tlsSetting
                 }
             }
         }
 
-        data class MuxBean(var enabled: Boolean,
-                           var concurrency: Int = 8,
-                           var xudpConcurrency: Int = 8,
-                           var xudpProxyUDP443: String = "",)
+        data class MuxBean(var enabled: Boolean, var concurrency: Int = 8)
 
         fun getServerAddress(): String? {
             if (protocol.equals(EConfigType.VMESS.name, true)
@@ -343,8 +251,6 @@ data class V2rayConfig(
                     || 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
         }
@@ -357,8 +263,6 @@ data class V2rayConfig(
                     || 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
         }
@@ -372,8 +276,6 @@ data class V2rayConfig(
                 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
         }
@@ -389,9 +291,7 @@ data class V2rayConfig(
 
         fun getTransportSettingDetails(): List<String>? {
             if (protocol.equals(EConfigType.VMESS.name, true)
-                    || protocol.equals(EConfigType.VLESS.name, true)
-                    || protocol.equals(EConfigType.TROJAN.name, true)
-                    || protocol.equals(EConfigType.SHADOWSOCKS.name, true)) {
+                    || protocol.equals(EConfigType.VLESS.name, true)) {
                 val transport = streamSettings?.network ?: return null
                 return when (transport) {
                     "tcp" -> {
@@ -412,12 +312,6 @@ data class V2rayConfig(
                                 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("",
@@ -430,12 +324,6 @@ data class V2rayConfig(
                                 quicSetting.security,
                                 quicSetting.key)
                     }
-                    "grpc" -> {
-                        val grpcSetting = streamSettings?.grpcSettings ?: return null
-                        listOf(if (grpcSetting.multiMode == true) "multi" else "gun",
-                                grpcSetting.authority ?: "",
-                                grpcSetting.serviceName)
-                    }
                     else -> null
                 }
             }
@@ -443,26 +331,25 @@ data class V2rayConfig(
         }
     }
 
-    data class DnsBean(var servers: ArrayList<Any>? = null,
-                       var hosts: Map<String, Any>? = null,
+    data class DnsBean(var servers: List<Any>? = null,
+                       var hosts: Map<String, String>? = 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? = null,
-                               var domains: List<String>? = null,
-                               var expectIPs: List<String>? = null,
+                               var port: Int = 0,
+                               var domains: List<String>?,
+                               var expectIPs: List<String>?,
                                val clientIp: String? = null)
     }
 
     data class RoutingBean(var domainStrategy: String,
-                           var domainMatcher: String? = null,
+                           val domainMatcher: String? = null,
                            var rules: ArrayList<RulesBean>,
                            val balancers: List<Any>? = null) {
 
-        data class RulesBean(
+        data class RulesBean(var type: String = "",
                              var ip: ArrayList<String>? = null,
                              var domain: ArrayList<String>? = null,
                              var outboundTag: String = "",
@@ -491,15 +378,14 @@ data class V2rayConfig(
                 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.entries.forEach {
-                if (outbound.protocol.equals(it.name, true)) {
-                    return outbound
-                }
+            if (outbound.protocol.equals(EConfigType.VMESS.name, true) ||
+                    outbound.protocol.equals(EConfigType.VLESS.name, true) ||
+                    outbound.protocol.equals(EConfigType.SHADOWSOCKS.name, true) ||
+                    outbound.protocol.equals(EConfigType.SOCKS.name, true) ||
+                    outbound.protocol.equals(EConfigType.TROJAN.name, true)) {
+                return outbound
             }
         }
         return null

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

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

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

@@ -0,0 +1,244 @@
+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

@@ -6,64 +6,71 @@ import android.widget.Toast
 import com.v2ray.ang.AngApplication
 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
 
-fun Context.toast(message: Int) {
-    ToastCompat.makeText(this, message, Toast.LENGTH_SHORT).apply { show() }
-}
+inline fun Context.toast(message: Int): Toast = ToastCompat
+        .makeText(this, message, Toast.LENGTH_SHORT)
+        .apply {
+            show()
+        }
 
-fun Context.toast(message: CharSequence) {
-    ToastCompat.makeText(this, message, Toast.LENGTH_SHORT).apply { show() }
-}
+inline fun Context.toast(message: CharSequence): Toast = ToastCompat
+        .makeText(this, message, Toast.LENGTH_SHORT)
+        .apply {
+            show()
+        }
 
-fun JSONObject.putOpt(pair: Pair<String, Any?>) {
-    put(pair.first, pair.second)
-}
+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) }
 
-fun JSONObject.putOpt(pairs: Map<String, Any?>) {
-    pairs.forEach { put(it.key, it.value) }
-}
+const val threshold = 1000
+const val divisor = 1024F
 
-const val THRESHOLD = 1000L
-const val DIVISOR = 1024.0
-
-fun Long.toSpeedString(): String = this.toTrafficString() + "/s"
+fun Long.toSpeedString() = 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)
+    if (this == 0L)
+        return "\t\t\t0\t  B"
+
+    if (this < threshold)
+        return "${this.toFloat().toShortString()}\t  B"
+
+    val kib = this / divisor
+    if (kib < threshold)
+        return "${kib.toShortString()}\t KB"
+
+    val mib = kib / divisor
+    if (mib < threshold)
+        return "${mib.toShortString()}\t MB"
+
+    val gib = mib / divisor
+    if (gib < threshold)
+        return "${gib.toShortString()}\t GB"
+
+    val tib = gib / divisor
+    if (tib < threshold)
+        return "${tib.toShortString()}\t TB"
+
+    val pib = tib / divisor
+    if (pib < threshold)
+        return "${pib.toShortString()}\t PB"
+
+    return "∞"
+}
+
+private fun Float.toShortString(): String {
+    val s = "%.2f".format(this)
+    if (s.length <= 4)
+        return s
+    return s.substring(0, 4).removeSuffix(".")
 }
 
 val URLConnection.responseLength: Long
-    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(), "")
+    get() = if (Build.VERSION.SDK_INT >= 24) contentLengthLong else contentLength.toLong()

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

@@ -4,6 +4,7 @@ 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
@@ -33,7 +34,7 @@ class TaskerReceiver : BroadcastReceiver() {
             } else {
                 Utils.stopVService(context)
             }
-        } catch (e: Exception) {
+        } catch (e: WriterException) {
             e.printStackTrace()
         }
     }

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

@@ -6,10 +6,9 @@ import android.appwidget.AppWidgetProvider
 import android.content.ComponentName
 import android.content.Context
 import android.content.Intent
-import android.os.Build
 import android.widget.RemoteViews
-import com.v2ray.ang.AppConfig
 import com.v2ray.ang.R
+import com.v2ray.ang.AppConfig
 import com.v2ray.ang.service.V2RayServiceManager
 import com.v2ray.ang.util.Utils
 
@@ -22,27 +21,16 @@ class WidgetProvider : AppWidgetProvider() {
         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(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
-            })
+        val pendingIntent = PendingIntent.getBroadcast(context, R.id.layout_switch, intent, PendingIntent.FLAG_UPDATE_CURRENT)
         remoteViews.setOnClickPendingIntent(R.id.layout_switch, pendingIntent)
         if (isRunning) {
-            remoteViews.setInt(R.id.image_switch, "setImageResource", R.drawable.ic_stop_24dp)
-            remoteViews.setInt(R.id.layout_background, "setBackgroundResource", R.drawable.ic_rounded_corner_active)
+            remoteViews.setInt(R.id.layout_switch, "setBackgroundResource", R.drawable.ic_rounded_corner_theme)
         } else {
-            remoteViews.setInt(R.id.image_switch, "setImageResource", R.drawable.ic_play_24dp)
-            remoteViews.setInt(R.id.layout_background, "setBackgroundResource", R.drawable.ic_rounded_corner_inactive)
+            remoteViews.setInt(R.id.layout_switch, "setBackgroundResource", R.drawable.ic_rounded_corner_grey)
         }
 
         for (appWidgetId in appWidgetIds) {

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

@@ -22,11 +22,11 @@ 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_stat_name)
+            qsTile?.icon = Icon.createWithResource(applicationContext, R.drawable.ic_v_idle)
         } else if (state == Tile.STATE_ACTIVE) {
             qsTile?.state = Tile.STATE_ACTIVE
             qsTile?.label = V2RayServiceManager.currentConfig?.remarks
-            qsTile?.icon = Icon.createWithResource(applicationContext, R.drawable.ic_stat_name)
+            qsTile?.icon = Icon.createWithResource(applicationContext, R.drawable.ic_v)
         }
 
         qsTile?.updateTile()
@@ -36,12 +36,7 @@ class QSTileService : TileService() {
         super.onStartListening()
         setState(Tile.STATE_INACTIVE)
         mMsgReceive = ReceiveMessageHandler(this)
-        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))
-        }
-
+        registerReceiver(mMsgReceive, IntentFilter(AppConfig.BROADCAST_ACTION_ACTIVITY))
         MessageUtil.sendMsg2Service(this, AppConfig.MSG_REGISTER_CLIENT, "")
     }
 

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

@@ -5,9 +5,10 @@ import android.app.Service
 interface ServiceControl {
     fun getService(): Service
 
-    fun startService()
+    fun startService(parameters: String)
 
     fun stopService()
 
     fun vpnProtect(socket: Int): Boolean
+
 }

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

@@ -1,80 +0,0 @@
-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

@@ -1,13 +1,8 @@
 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 {
@@ -30,7 +25,7 @@ class V2RayProxyOnlyService : Service(), ServiceControl {
         return this
     }
 
-    override fun startService() {
+    override fun startService(parameters: String) {
         // do nothing
     }
 
@@ -45,12 +40,4 @@ class V2RayProxyOnlyService : Service(), ServiceControl {
     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

@@ -10,12 +10,11 @@ import android.content.Intent
 import android.content.IntentFilter
 import android.graphics.Color
 import android.os.Build
+import android.support.annotation.RequiresApi
+import android.support.v4.app.NotificationCompat
 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
@@ -27,9 +26,6 @@ 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
@@ -44,7 +40,7 @@ object V2RayServiceManager {
     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)
+    val v2rayPoint: V2RayPoint = Libv2ray.newV2RayPoint(V2RayCallback())
     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) }
@@ -52,8 +48,12 @@ object V2RayServiceManager {
     var serviceControl: SoftReference<ServiceControl>? = null
         set(value) {
             field = value
-            Seq.setContext(value?.get()?.getService()?.applicationContext)
-            Libv2ray.initV2Env(Utils.userAssetPath(value?.get()?.getService()), Utils.getDeviceIdForXUDPBaseKey())
+            val context = value?.get()?.getService()?.applicationContext
+            context?.let {
+                v2rayPoint.packageName = Utils.packagePath(context)
+                v2rayPoint.packageCodePath = context.applicationInfo.nativeLibraryDir + "/"
+                Seq.setContext(context)
+            }
         }
     var currentConfig: ServerConfig? = null
 
@@ -65,7 +65,7 @@ object V2RayServiceManager {
     fun startV2Ray(context: Context) {
         if (settingsStorage?.decodeBool(AppConfig.PREF_PROXY_SHARING) == true) {
             context.toast(R.string.toast_warning_pref_proxysharing_short)
-        } else {
+        }else{
             context.toast(R.string.toast_services_start)
         }
         val intent = if (settingsStorage?.decodeString(AppConfig.PREF_MODE) ?: "VPN" == "VPN") {
@@ -84,11 +84,12 @@ object V2RayServiceManager {
         override fun shutdown(): Long {
             val serviceControl = serviceControl?.get() ?: return -1
             // called by go
+            // shutdown the whole vpn service
             return try {
                 serviceControl.stopService()
                 0
             } catch (e: Exception) {
-                Log.d(ANG_PACKAGE, e.toString())
+                Log.d(serviceControl.getService().packageName, e.toString())
                 -1
             }
         }
@@ -97,9 +98,9 @@ object V2RayServiceManager {
             return 0
         }
 
-        override fun protect(l: Long): Boolean {
-            val serviceControl = serviceControl?.get() ?: return true
-            return serviceControl.vpnProtect(l.toInt())
+        override fun protect(l: Long): Long {
+            val serviceControl = serviceControl?.get() ?: return 0
+            return if (serviceControl.vpnProtect(l.toInt())) 0 else 1
         }
 
         override fun onEmitStatus(l: Long, s: String?): Long {
@@ -111,15 +112,16 @@ object V2RayServiceManager {
             val serviceControl = serviceControl?.get() ?: return -1
             //Logger.d(s)
             return try {
-                serviceControl.startService()
+                serviceControl.startService(s)
                 lastQueryTime = System.currentTimeMillis()
                 startSpeedNotification()
                 0
             } catch (e: Exception) {
-                Log.d(ANG_PACKAGE, e.toString())
+                Log.d(serviceControl.getService().packageName, e.toString())
                 -1
             }
         }
+
     }
 
     fun startV2rayPoint() {
@@ -136,23 +138,22 @@ object V2RayServiceManager {
                 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)
-                }
+                service.registerReceiver(mMsgReceive, mFilter)
             } catch (e: Exception) {
-                Log.d(ANG_PACKAGE, e.toString())
+                Log.d(service.packageName, e.toString())
             }
 
             v2rayPoint.configureFileContent = result.content
             v2rayPoint.domainName = config.getV2rayPointDomainAndPort()
             currentConfig = config
+            v2rayPoint.enableLocalDNS = settingsStorage?.decodeBool(AppConfig.PREF_LOCAL_DNS_ENABLED) ?: false
+            v2rayPoint.forwardIpv6 = settingsStorage?.decodeBool(AppConfig.PREF_FORWARD_IPV6) ?: false
+            v2rayPoint.proxyOnly = settingsStorage?.decodeString(AppConfig.PREF_MODE) ?: "VPN" != "VPN"
 
             try {
-                v2rayPoint.runLoop(settingsStorage?.decodeBool(AppConfig.PREF_PREFER_IPV6) ?: false)
+                v2rayPoint.runLoop()
             } catch (e: Exception) {
-                Log.d(ANG_PACKAGE, e.toString())
+                Log.d(service.packageName, e.toString())
             }
 
             if (v2rayPoint.isRunning) {
@@ -169,12 +170,10 @@ object V2RayServiceManager {
         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())
-                }
+            try {
+                v2rayPoint.stopLoop()
+            } catch (e: Exception) {
+                Log.d(service.packageName, e.toString())
             }
         }
 
@@ -184,7 +183,7 @@ object V2RayServiceManager {
         try {
             service.unregisterReceiver(mMsgReceive)
         } catch (e: Exception) {
-            Log.d(ANG_PACKAGE, e.toString())
+            Log.d(service.packageName, e.toString())
         }
     }
 
@@ -212,69 +211,35 @@ object V2RayServiceManager {
                 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")
+                    Log.d(AppConfig.ANG_PACKAGE, "SCREEN_OFF, stop querying stats")
                     stopSpeedNotification()
                 }
                 Intent.ACTION_SCREEN_ON -> {
-                    Log.d(ANG_PACKAGE, "SCREEN_ON, start querying stats")
+                    Log.d(AppConfig.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(Utils.getDelayTestUrl())
-                } 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
-            })
+                PendingIntent.FLAG_UPDATE_CURRENT)
 
         val stopV2RayIntent = Intent(AppConfig.BROADCAST_ACTION_SERVICE)
-        stopV2RayIntent.`package` = ANG_PACKAGE
+        stopV2RayIntent.`package` = AppConfig.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
-            })
+                PendingIntent.FLAG_UPDATE_CURRENT)
 
         val channelId =
                 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
@@ -286,14 +251,14 @@ object V2RayServiceManager {
                 }
 
         mBuilder = NotificationCompat.Builder(service, channelId)
-                .setSmallIcon(R.drawable.ic_stat_name)
+                .setSmallIcon(R.drawable.ic_v)
                 .setContentTitle(currentConfig?.remarks)
                 .setPriority(NotificationCompat.PRIORITY_MIN)
                 .setOngoing(true)
                 .setShowWhen(false)
                 .setOnlyAlertOnce(true)
                 .setContentIntent(contentPendingIntent)
-                .addAction(R.drawable.ic_delete_24dp,
+                .addAction(R.drawable.ic_close_grey_800_24dp,
                         service.getString(R.string.notification_action_stop_v2ray),
                         stopV2RayPendingIntent)
         //.build()
@@ -327,7 +292,7 @@ object V2RayServiceManager {
     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)
+                mBuilder?.setSmallIcon(R.drawable.ic_v)
             } else if (proxyTraffic > directTraffic) {
                 mBuilder?.setSmallIcon(R.drawable.ic_stat_proxy)
             } else {
@@ -347,7 +312,7 @@ object V2RayServiceManager {
         return mNotificationManager
     }
 
-    private fun startSpeedNotification() {
+    fun startSpeedNotification() {
         if (mSubscription == null &&
                 v2rayPoint.isRunning &&
                 settingsStorage?.decodeBool(AppConfig.PREF_SPEED_ENABLED) == true) {
@@ -371,7 +336,7 @@ object V2RayServiceManager {
                         }
                         val directUplink = v2rayPoint.queryStats(TAG_DIRECT, "uplink")
                         val directDownlink = v2rayPoint.queryStats(TAG_DIRECT, "downlink")
-                        val zeroSpeed = proxyTotal == 0L && directUplink == 0L && directDownlink == 0L
+                        val zeroSpeed = (proxyTotal == 0L && directUplink == 0L && directDownlink == 0L)
                         if (!zeroSpeed || !lastZeroSpeed) {
                             if (proxyTotal == 0L) {
                                 appendSpeedString(text, outboundTags?.firstOrNull(), 0.0, 0.0)
@@ -396,7 +361,7 @@ object V2RayServiceManager {
         text.append("•  ${up.toLong().toSpeedString()}↑  ${down.toLong().toSpeedString()}↓\n")
     }
 
-    private fun stopSpeedNotification() {
+    fun stopSpeedNotification() {
         if (mSubscription != null) {
             mSubscription?.unsubscribe() //stop queryStats
             mSubscription = null

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

@@ -1,45 +0,0 @@
-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,6 +1,6 @@
 package com.v2ray.ang.service
 
-import android.app.Service
+import android.app.*
 import android.content.Context
 import android.content.Intent
 import android.content.pm.PackageManager
@@ -8,14 +8,12 @@ import android.net.*
 import android.os.Build
 import android.os.ParcelFileDescriptor
 import android.os.StrictMode
+import android.support.annotation.RequiresApi
 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.dto.ERoutingMode
 import com.v2ray.ang.util.MmkvManager
-import com.v2ray.ang.util.MyContextWrapper
 import com.v2ray.ang.util.Utils
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.GlobalScope
@@ -24,32 +22,19 @@ import java.io.File
 import java.lang.ref.SoftReference
 
 class V2RayVpnService : VpnService(), ServiceControl {
-    companion object {
-        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"
-    }
-
     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
-     */
+    /**
+        * 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()
@@ -66,12 +51,10 @@ class V2RayVpnService : VpnService(), ServiceControl {
             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)
             }
@@ -90,17 +73,18 @@ class V2RayVpnService : VpnService(), ServiceControl {
         stopV2Ray()
     }
 
-//    override fun onLowMemory() {
-//        stopV2Ray()
-//        super.onLowMemory()
-//    }
+    override fun onLowMemory() {
+        stopV2Ray()
+        super.onLowMemory()
+    }
 
     override fun onDestroy() {
         super.onDestroy()
-        V2RayServiceManager.cancelNotification()
+        stopV2Ray()
     }
 
-    private fun setup() {
+    private fun setup(parameters: String) {
+
         val prepare = prepare(this)
         if (prepare != null) {
             return
@@ -109,46 +93,45 @@ class V2RayVpnService : VpnService(), ServiceControl {
         // 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(AppConfig.PREF_LOCAL_DNS_ENABLED, false)
+        val enableLocalDns = settingsStorage?.decodeBool(AppConfig.PREF_LOCAL_DNS_ENABLED) ?: false
+        val routingMode = settingsStorage?.decodeString(AppConfig.PREF_ROUTING_MODE) ?: "0"
 
-        val routingMode = settingsStorage?.decodeString(AppConfig.PREF_ROUTING_MODE)
-            ?: ERoutingMode.BYPASS_LAN_MAINLAND.value
-
-        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)
-        }
-
-        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 (settingsStorage?.decodeBool(AppConfig.PREF_LOCAL_DNS_ENABLED) == true) {
-            builder.addDnsServer(PRIVATE_VLAN4_ROUTER)
-        } else {
-            Utils.getVpnDnsServers()
-                    .forEach {
-                        if (Utils.isPureIpAddress(it)) {
-                            builder.addDnsServer(it)
+        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' -> {
+                            if (routingMode == "1" || routingMode == "3") {
+                                if (it[1] == "::") { //not very elegant, should move Vpn setting in Kotlin, simplify go code
+                                    builder.addRoute("2000::", 3)
+                                } else {
+                                    resources.getStringArray(R.array.bypass_private_ip_address).forEach { cidr ->
+                                        val addr = cidr.split('/')
+                                        builder.addRoute(addr[0], addr[1].toInt())
+                                    }
+                                }
+                            } else {
+                                builder.addRoute(it[1], Integer.parseInt(it[2]))
+                            }
                         }
+                        'd' -> builder.addDnsServer(it[1])
                     }
+                }
+
+        if(!enableLocalDns) {
+            Utils.getRemoteDnsServers()
+                .forEach {
+                    builder.addDnsServer(it)
+                }
         }
 
         builder.setSession(V2RayServiceManager.currentConfig?.remarks.orEmpty())
 
-        if (settingsStorage?.decodeBool(AppConfig.PREF_PER_APP_PROXY) == true) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP &&
+                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 {
@@ -185,69 +168,23 @@ class V2RayVpnService : VpnService(), ServiceControl {
         // Create a new interface using the builder and save the parameters.
         try {
             mInterface = builder.establish()!!
-            isRunning = true
-            runTun2socks()
         } catch (e: Exception) {
             // non-nullable lateinit var
             e.printStackTrace()
             stopV2Ray()
         }
-    }
 
-    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")
-
-        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())
-        }
+        sendFd()
     }
 
     private fun sendFd() {
         val fd = mInterface.fileDescriptor
-        val path = File(applicationContext.filesDir, "sock_path").absolutePath
-        Log.d(packageName, path)
+        val path = File(Utils.packagePath(applicationContext), "sock_path").absolutePath
 
         GlobalScope.launch(Dispatchers.IO) {
             var tries = 0
             while (true) try {
-                Thread.sleep(50L shl tries)
+                Thread.sleep(1000L shl tries)
                 Log.d(packageName, "sendFd tries: $tries")
                 LocalSocket().use { localSocket ->
                     localSocket.connect(LocalSocketAddress(path, LocalSocketAddress.Namespace.FILESYSTEM))
@@ -274,7 +211,6 @@ class V2RayVpnService : VpnService(), ServiceControl {
 //        val emptyInfo = VpnNetworkInfo()
 //        val info = loadVpnNetworkInfo(configName, emptyInfo)!! + (lastNetworkInfo ?: emptyInfo)
 //        saveVpnNetworkInfo(configName, info)
-        isRunning = false;
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
             try {
                 connectivity.unregisterNetworkCallback(defaultNetworkCallback)
@@ -283,13 +219,6 @@ class V2RayVpnService : VpnService(), ServiceControl {
             }
         }
 
-        try {
-            Log.d(packageName, "tun2socks destroy")
-            process.destroy()
-        } catch (e: Exception) {
-            Log.d(packageName, e.toString())
-        }
-
         V2RayServiceManager.stopV2rayPoint()
 
         if (isForced) {
@@ -305,6 +234,7 @@ class V2RayVpnService : VpnService(), ServiceControl {
             } catch (ignored: Exception) {
                 // ignored
             }
+
         }
     }
 
@@ -312,8 +242,8 @@ class V2RayVpnService : VpnService(), ServiceControl {
         return this
     }
 
-    override fun startService() {
-        setup()
+    override fun startService(parameters: String) {
+        setup(parameters)
     }
 
     override fun stopService() {
@@ -324,11 +254,4 @@ class V2RayVpnService : VpnService(), ServiceControl {
         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/AboutActivity.kt

@@ -1,177 +0,0 @@
-package com.v2ray.ang.ui
-
-import android.Manifest
-import android.content.Intent
-import android.os.Build
-import android.os.Bundle
-import androidx.activity.result.contract.ActivityResultContracts
-import androidx.core.content.FileProvider
-import com.tbruyelle.rxpermissions.RxPermissions
-import com.tencent.mmkv.MMKV
-import com.v2ray.ang.AppConfig
-import com.v2ray.ang.BuildConfig
-import com.v2ray.ang.R
-import com.v2ray.ang.databinding.ActivityAboutBinding
-import com.v2ray.ang.extension.toast
-import com.v2ray.ang.util.SpeedtestUtil
-import com.v2ray.ang.util.Utils
-import com.v2ray.ang.util.ZipUtil
-import java.io.File
-import java.text.SimpleDateFormat
-import java.util.Locale
-
-class AboutActivity : BaseActivity() {
-    private lateinit var binding: ActivityAboutBinding
-    private val extDir by lazy { File(Utils.backupPath(this)) }
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        binding = ActivityAboutBinding.inflate(layoutInflater)
-        val view = binding.root
-        setContentView(view)
-
-        title = getString(R.string.title_about)
-
-        binding.tvBackupSummary.text = this.getString(R.string.summary_configuration_backup, extDir)
-        binding.layoutBackup.setOnClickListener {
-            val ret = backupConfiguration(extDir.absolutePath)
-            if (ret.first) {
-                toast(R.string.toast_success)
-            } else {
-                toast(R.string.toast_failure)
-            }
-        }
-
-        binding.layoutShare.setOnClickListener {
-            val ret = backupConfiguration(cacheDir.absolutePath)
-            if (ret.first) {
-                startActivity(
-                    Intent.createChooser(
-                        Intent(Intent.ACTION_SEND).setType("application/zip")
-                            .setFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
-                            .putExtra(
-                                Intent.EXTRA_STREAM, FileProvider.getUriForFile(
-                                    this, BuildConfig.APPLICATION_ID + ".cache", File(ret.second)
-                                )
-                            ), getString(R.string.title_configuration_share)
-                    )
-                )
-            } else {
-                toast(R.string.toast_failure)
-            }
-        }
-
-        binding.layoutRestore.setOnClickListener {
-            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) {
-                        try {
-                            showFileChooser()
-                        } catch (e: Exception) {
-                            e.printStackTrace()
-                        }
-                    } else
-                        toast(R.string.toast_permission_denied)
-                }
-        }
-
-        binding.layoutSoureCcode.setOnClickListener {
-            Utils.openUri(this, AppConfig.v2rayNGUrl)
-        }
-
-        binding.layoutFeedback.setOnClickListener {
-            Utils.openUri(this, AppConfig.v2rayNGIssues)
-        }
-
-        binding.layoutTgChannel.setOnClickListener {
-            Utils.openUri(this, AppConfig.TgChannelUrl)
-        }
-
-        binding.layoutPrivacyPolicy.setOnClickListener {
-            Utils.openUri(this, AppConfig.v2rayNGPrivacyPolicy)
-        }
-
-        "v${BuildConfig.VERSION_NAME} (${SpeedtestUtil.getLibVersion()})".also {
-            binding.tvVersion.text = it
-        }
-    }
-
-    fun backupConfiguration(outputZipFilePos: String): Pair<Boolean, String> {
-        val dateFormated = SimpleDateFormat(
-            "yyyy-MM-dd-HH-mm-ss",
-            Locale.getDefault()
-        ).format(System.currentTimeMillis())
-        val folderName = "${getString(R.string.app_name)}_${dateFormated}"
-        val backupDir = this.cacheDir.absolutePath + "/$folderName"
-        val outputZipFilePath = "$outputZipFilePos/$folderName.zip"
-
-        val count = MMKV.backupAllToDirectory(backupDir)
-        if (count <= 0) {
-            return Pair(false, "")
-        }
-
-        if (ZipUtil.zipFromFolder(backupDir, outputZipFilePath)) {
-            return Pair(true, outputZipFilePath)
-        } else {
-            return Pair(false, "")
-        }
-    }
-
-    fun restoreConfiguration(zipFile: File): Boolean {
-        val backupDir = this.cacheDir.absolutePath + "/${System.currentTimeMillis()}"
-
-        if (!ZipUtil.unzipToFolder(zipFile, backupDir)) {
-            return false
-        }
-
-        val count = MMKV.restoreAllFromDirectory(backupDir)
-        return count > 0
-    }
-
-    private fun showFileChooser() {
-        val intent = Intent(Intent.ACTION_GET_CONTENT)
-        intent.type = "*/*"
-        intent.addCategory(Intent.CATEGORY_OPENABLE)
-
-        try {
-            chooseFile.launch(Intent.createChooser(intent, getString(R.string.title_file_chooser)))
-        } catch (ex: android.content.ActivityNotFoundException) {
-            toast(R.string.toast_require_file_manager)
-        }
-    }
-
-    private val chooseFile =
-        registerForActivityResult(ActivityResultContracts.StartActivityForResult()) {
-            val uri = it.data?.data
-            if (it.resultCode == RESULT_OK && uri != null) {
-                try {
-                    try {
-                        val targetFile =
-                            File(this.cacheDir.absolutePath, "${System.currentTimeMillis()}.zip")
-                        contentResolver.openInputStream(uri).use { input ->
-                            targetFile.outputStream().use { fileOut ->
-                                input?.copyTo(fileOut)
-                            }
-                        }
-                        if (restoreConfiguration(targetFile)) {
-                            toast(R.string.toast_success)
-                        } else {
-                            toast(R.string.toast_failure)
-                        }
-                    } catch (e: Exception) {
-                        e.printStackTrace()
-                    }
-
-                } catch (e: Exception) {
-                    e.printStackTrace()
-                    toast(e.message.toString())
-                }
-            }
-        }
-}

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

@@ -1,26 +1,9 @@
 package com.v2ray.ang.ui
 
-import android.content.Context
-import android.os.Build
-import android.os.Bundle
+import android.support.v7.app.AppCompatActivity
 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()
@@ -28,12 +11,4 @@ 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/FragmentAdapter.kt

@@ -1,17 +1,21 @@
 package com.v2ray.ang.ui
 
-import androidx.fragment.app.Fragment
-import androidx.fragment.app.FragmentActivity
-import androidx.viewpager2.adapter.FragmentStateAdapter
 
-class FragmentAdapter(fragmentActivity: FragmentActivity, private val mFragments: List<Fragment>) :
-        FragmentStateAdapter(fragmentActivity) {
+import android.support.v4.app.Fragment
+import android.support.v4.app.FragmentManager
+import android.support.v4.app.FragmentStatePagerAdapter
 
-    override fun createFragment(position: Int): Fragment {
+class FragmentAdapter(fm: FragmentManager, private val mFragments: List<Fragment>, private val mTitles: List<String>) : FragmentStatePagerAdapter(fm) {
+
+    override fun getItem(position: Int): Fragment {
         return mFragments[position]
     }
 
-    override fun getItemCount(): Int {
+    override fun getCount(): 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,45 +1,40 @@
 package com.v2ray.ang.ui
 
+import android.os.Bundle
 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 kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.launch
-
 import java.io.IOException
 import java.util.LinkedHashSet
 
 class LogcatActivity : BaseActivity() {
-    private lateinit var binding: ActivityLogcatBinding
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
-        binding = ActivityLogcatBinding.inflate(layoutInflater)
-        val view = binding.root
-        setContentView(view)
+        setContentView(R.layout.activity_logcat)
 
         title = getString(R.string.title_logcat)
 
+        supportActionBar?.setDisplayHomeAsUpEnabled(true)
         logcat(false)
     }
 
     private fun logcat(shouldFlushLog: Boolean) {
 
         try {
-            binding.pbWaiting.visibility = View.VISIBLE
+            pb_waiting.visibility = View.VISIBLE
 
-            lifecycleScope.launch(Dispatchers.Default) {
+            GlobalScope.launch(Dispatchers.Default) {
                 if (shouldFlushLog) {
                     val lst = LinkedHashSet<String>()
                     lst.add("logcat")
@@ -53,17 +48,17 @@ class LogcatActivity : BaseActivity() {
                 lst.add("-v")
                 lst.add("time")
                 lst.add("-s")
-                lst.add("GoLog,tun2socks,${ANG_PACKAGE},AndroidRuntime,System.err")
+                lst.add("GoLog,tun2socks,com.v2ray.ang")
                 val process = Runtime.getRuntime().exec(lst.toTypedArray())
 //                val bufferedReader = BufferedReader(
 //                        InputStreamReader(process.inputStream))
 //                val allText = bufferedReader.use(BufferedReader::readText)
                 val allText = process.inputStream.bufferedReader().use { it.readText() }
                 launch(Dispatchers.Main) {
-                    binding.tvLogcat.text = allText
-                    binding.tvLogcat.movementMethod = ScrollingMovementMethod()
-                    binding.pbWaiting.visibility = View.GONE
-                    Handler(Looper.getMainLooper()).post { binding.svLogcat.fullScroll(View.FOCUS_DOWN) }
+                    tv_logcat.text = allText
+                    tv_logcat.movementMethod = ScrollingMovementMethod()
+                    pb_waiting.visibility = View.GONE
+                    Handler(Looper.getMainLooper()).post { sv_logcat.fullScroll(View.FOCUS_DOWN) }
                 }
             }
         } catch (e: IOException) {
@@ -71,18 +66,18 @@ class LogcatActivity : BaseActivity() {
         }
     }
 
-    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, binding.tvLogcat.text.toString())
+            Utils.setClipboard(this, tv_logcat.text.toString())
             toast(R.string.toast_success)
             true
         }
-        R.id.clear_all -> {
+        R.id.delete -> {
             logcat(true)
             true
         }

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

@@ -1,36 +1,26 @@
 package com.v2ray.ang.ui
 
 import android.Manifest
-import android.content.ActivityNotFoundException
+import android.arch.lifecycle.ViewModelProviders
 import android.content.Intent
-import android.content.res.ColorStateList
 import android.net.Uri
 import android.net.VpnService
-import android.os.Build
 import android.os.Bundle
+import android.support.design.widget.NavigationView
+import android.support.v4.view.GravityCompat
+import android.support.v7.app.ActionBarDrawerToggle
+import android.support.v7.widget.LinearLayoutManager
+import android.support.v7.widget.helper.ItemTouchHelper
 import android.text.TextUtils
 import android.util.Log
 import android.view.KeyEvent
 import android.view.Menu
 import android.view.MenuItem
-import android.widget.Toast
-import androidx.activity.OnBackPressedCallback
-import androidx.activity.result.contract.ActivityResultContracts
-import androidx.activity.viewModels
-import androidx.appcompat.app.ActionBarDrawerToggle
-import androidx.appcompat.app.AlertDialog
-import androidx.core.content.ContextCompat
-import androidx.core.view.GravityCompat
-import androidx.lifecycle.lifecycleScope
-import androidx.recyclerview.widget.ItemTouchHelper
-import androidx.recyclerview.widget.LinearLayoutManager
-import com.google.android.material.navigation.NavigationView
 import com.tbruyelle.rxpermissions.RxPermissions
 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.databinding.ActivityMainBinding
 import com.v2ray.ang.dto.EConfigType
 import com.v2ray.ang.extension.toast
 import com.v2ray.ang.helper.SimpleItemTouchHelperCallback
@@ -38,183 +28,132 @@ 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 com.v2ray.ang.util.V2rayConfigUtil
 import com.v2ray.ang.viewmodel.MainViewModel
+import kotlinx.android.synthetic.main.activity_main.*
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.launch
-import me.drakeet.support.toast.ToastCompat
+import libv2ray.Libv2ray
 import rx.Observable
 import rx.android.schedulers.AndroidSchedulers
-import java.io.File
-import java.io.FileOutputStream
+import java.net.URL
 import java.util.concurrent.TimeUnit
 
 class MainActivity : BaseActivity(), NavigationView.OnNavigationItemSelectedListener {
-    private lateinit var binding: ActivityMainBinding
+    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
+    }
 
     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()
+    val mainViewModel: MainViewModel by lazy { ViewModelProviders.of(this).get(MainViewModel::class.java) }
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
-        binding = ActivityMainBinding.inflate(layoutInflater)
-        val view = binding.root
-        setContentView(view)
+        setContentView(R.layout.activity_main)
         title = getString(R.string.title_server)
-        setSupportActionBar(binding.toolbar)
+        setSupportActionBar(toolbar)
 
-        binding.fab.setOnClickListener {
+        fab.setOnClickListener {
             if (mainViewModel.isRunning.value == true) {
                 Utils.stopVService(this)
-            } else if ((settingsStorage?.decodeString(AppConfig.PREF_MODE) ?: "VPN") == "VPN") {
+            } else if (settingsStorage?.decodeString(AppConfig.PREF_MODE) ?: "VPN" == "VPN") {
                 val intent = VpnService.prepare(this)
                 if (intent == null) {
                     startV2Ray()
                 } else {
-                    requestVpnPermission.launch(intent)
+                    startActivityForResult(intent, REQUEST_CODE_VPN_PREPARE)
                 }
             } else {
                 startV2Ray()
             }
         }
-        binding.layoutTest.setOnClickListener {
+        layout_test.setOnClickListener {
             if (mainViewModel.isRunning.value == true) {
-                setTestState(getString(R.string.connection_test_testing))
+                tv_test_state.text = getString(R.string.connection_test_testing)
                 mainViewModel.testCurrentServerRealPing()
             } else {
 //                tv_test_state.text = getString(R.string.connection_test_fail)
             }
         }
 
-        binding.recyclerView.setHasFixedSize(true)
-        binding.recyclerView.layoutManager = LinearLayoutManager(this)
-        binding.recyclerView.adapter = adapter
+        recycler_view.setHasFixedSize(true)
+        recycler_view.layoutManager = LinearLayoutManager(this)
+        recycler_view.adapter = adapter
 
         val callback = SimpleItemTouchHelperCallback(adapter)
         mItemTouchHelper = ItemTouchHelper(callback)
-        mItemTouchHelper?.attachToRecyclerView(binding.recyclerView)
+        mItemTouchHelper?.attachToRecyclerView(recycler_view)
 
 
         val toggle = ActionBarDrawerToggle(
-                this, binding.drawerLayout, binding.toolbar, R.string.navigation_drawer_open, R.string.navigation_drawer_close)
-        binding.drawerLayout.addDrawerListener(toggle)
+                this, drawer_layout, toolbar, R.string.navigation_drawer_open, R.string.navigation_drawer_close)
+        drawer_layout.addDrawerListener(toggle)
         toggle.syncState()
-        binding.navView.setNavigationItemSelectedListener(this)
+        nav_view.setNavigationItemSelectedListener(this)
+        version.text = "v${BuildConfig.VERSION_NAME} (${Libv2ray.checkVersionX()})"
 
-
-        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)
-                }
-        }
-
-        onBackPressedDispatcher.addCallback(this, object : OnBackPressedCallback(true) {
-            override fun handleOnBackPressed() {
-                if (binding.drawerLayout.isDrawerOpen(GravityCompat.START)) {
-                    binding.drawerLayout.closeDrawer(GravityCompat.START)
-                } else {
-                    //super.onBackPressed()
-                    onBackPressedDispatcher.onBackPressed()
-                }
-            }
-        })
+        setupViewModelObserver()
+        migrateLegacy()
     }
 
-    private fun setupViewModel() {
-        mainViewModel.updateListAction.observe(this) { index ->
+    private fun setupViewModelObserver() {
+        mainViewModel.updateListAction.observe(this, {
+            val index = it ?: return@observe
             if (index >= 0) {
                 adapter.notifyItemChanged(index)
             } else {
                 adapter.notifyDataSetChanged()
             }
-        }
-        mainViewModel.updateTestResultAction.observe(this) { setTestState(it) }
-        mainViewModel.isRunning.observe(this) { isRunning ->
+        })
+        mainViewModel.updateTestResultAction.observe(this, { tv_test_state.text = it })
+        mainViewModel.isRunning.observe(this, {
+            val isRunning = it ?: return@observe
             adapter.isRunning = isRunning
             if (isRunning) {
-                binding.fab.setImageResource(R.drawable.ic_stop_24dp)
-                binding.fab.backgroundTintList = ColorStateList.valueOf(ContextCompat.getColor(this, R.color.color_fab_active))
-                setTestState(getString(R.string.connection_connected))
-                binding.layoutTest.isFocusable = true
+                fab.setImageResource(R.drawable.ic_v)
+                tv_test_state.text = getString(R.string.connection_connected)
+                layout_test.isFocusable = true
             } else {
-                binding.fab.setImageResource(R.drawable.ic_play_24dp)
-                binding.fab.backgroundTintList = ColorStateList.valueOf(ContextCompat.getColor(this, R.color.color_fab_inactive))
-                setTestState(getString(R.string.connection_not_connected))
-                binding.layoutTest.isFocusable = false
+                fab.setImageResource(R.drawable.ic_v_idle)
+                tv_test_state.text = getString(R.string.connection_not_connected)
+                layout_test.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() {
+        GlobalScope.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))
+                    }
+                }
             }
         }
     }
 
-//    private fun migrateLegacy() {
-//        lifecycleScope.launch(Dispatchers.IO) {
-//            val result = AngConfigManager.migrateLegacyConfig(this@MainActivity)
-//            if (result != null) {
-//                launch(Dispatchers.Main) {
-//                    if (result) {
-//                        toast(getString(R.string.migration_success))
-//                        mainViewModel.reloadServerList()
-//                    } else {
-//                        toast(getString(R.string.migration_fail))
-//                    }
-//                }
-//            }
-//        }
-//    }
-
     fun startV2Ray() {
         if (mainStorage?.decodeString(MmkvManager.KEY_SELECTED_SERVER).isNullOrEmpty()) {
             return
         }
+        showCircle()
+//        toast(R.string.toast_services_start)
         V2RayServiceManager.startV2Ray(this)
-    }
-
-    fun restartV2Ray() {
-        if (mainViewModel.isRunning.value == true) {
-            Utils.stopVService(this)
-        }
-        Observable.timer(500, TimeUnit.MILLISECONDS)
-                .observeOn(AndroidSchedulers.mainThread())
-                .subscribe {
-                    startV2Ray()
-                }
+        hideCircle()
     }
 
     public override fun onResume() {
@@ -226,14 +165,38 @@ class MainActivity : BaseActivity(), NavigationView.OnNavigationItemSelectedList
         super.onPause()
     }
 
-    override fun onCreateOptionsMenu(menu: Menu): Boolean {
+    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 -> {
+                val uri = data?.data
+                if (resultCode == RESULT_OK && uri != null) {
+                    readContentFromUri(uri)
+                }
+            }
+            REQUEST_SCAN_URL ->
+                if (resultCode == RESULT_OK) {
+                    importConfigCustomUrl(data?.getStringExtra("SCAN_RESULT"))
+                }
+        }
+    }
+
+    override fun onCreateOptionsMenu(menu: Menu?): Boolean {
         menuInflater.inflate(R.menu.menu_main, menu)
         return true
     }
 
     override fun onOptionsItemSelected(item: MenuItem) = when (item.itemId) {
         R.id.import_qrcode -> {
-            importQRcode(true)
+            importQRcode(REQUEST_SCAN)
             true
         }
         R.id.import_clipboard -> {
@@ -241,27 +204,18 @@ class MainActivity : BaseActivity(), NavigationView.OnNavigationItemSelectedList
             true
         }
         R.id.import_manually_vmess -> {
-            importManually(EConfigType.VMESS.value)
-            true
-        }
-        R.id.import_manually_vless -> {
-            importManually(EConfigType.VLESS.value)
+            startActivity(Intent().putExtra("createConfigType", EConfigType.VMESS.value).
+            setClass(this, ServerActivity::class.java))
             true
         }
         R.id.import_manually_ss -> {
-            importManually(EConfigType.SHADOWSOCKS.value)
+            startActivity(Intent().putExtra("createConfigType", EConfigType.SHADOWSOCKS.value).
+            setClass(this, ServerActivity::class.java))
             true
         }
         R.id.import_manually_socks -> {
-            importManually(EConfigType.SOCKS.value)
-            true
-        }
-        R.id.import_manually_trojan -> {
-            importManually(EConfigType.TROJAN.value)
-            true
-        }
-        R.id.import_manually_wireguard -> {
-            importManually(EConfigType.WIREGUARD.value)
+            startActivity(Intent().putExtra("createConfigType", EConfigType.SOCKS.value).
+            setClass(this, ServerActivity::class.java))
             true
         }
         R.id.import_config_custom_clipboard -> {
@@ -277,7 +231,7 @@ class MainActivity : BaseActivity(), NavigationView.OnNavigationItemSelectedList
             true
         }
         R.id.import_config_custom_url_scan -> {
-            importQRcode(false)
+            importQRcode(REQUEST_SCAN_URL)
             true
         }
 
@@ -305,77 +259,22 @@ class MainActivity : BaseActivity(), NavigationView.OnNavigationItemSelectedList
             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()
-                    }
-                    .setNegativeButton(android.R.string.no) {_, _ ->
-                        //do noting
-                    }
-                    .show()
-            true
-        }
-        R.id.del_duplicate_config-> {
-            AlertDialog.Builder(this).setMessage(R.string.del_config_comfirm)
-                .setPositiveButton(android.R.string.ok) { _, _ ->
-                    mainViewModel.removeDuplicateServer()
-                }
-                .setNegativeButton(android.R.string.no) {_, _ ->
-                    //do noting
-                }
-                .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()
-                }
-                .setNegativeButton(android.R.string.no) {_, _ ->
-                    //do noting
-                }
-                .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(forConfig: Boolean): Boolean {
+    fun importQRcode(requestCode: Int): Boolean {
 //        try {
 //            startActivityForResult(Intent("com.google.zxing.client.android.SCAN")
 //                    .addCategory(Intent.CATEGORY_DEFAULT)
@@ -385,10 +284,7 @@ class MainActivity : BaseActivity(), NavigationView.OnNavigationItemSelectedList
                 .request(Manifest.permission.CAMERA)
                 .subscribe {
                     if (it)
-                        if (forConfig)
-                            scanQRCodeForConfig.launch(Intent(this, ScannerActivity::class.java))
-                        else
-                            scanQRCodeForUrlToCustomConfig.launch(Intent(this, ScannerActivity::class.java))
+                        startActivityForResult(Intent(this, ScannerActivity::class.java), requestCode)
                     else
                         toast(R.string.toast_permission_denied)
                 }
@@ -396,18 +292,6 @@ 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
      */
@@ -424,19 +308,9 @@ class MainActivity : BaseActivity(), NavigationView.OnNavigationItemSelectedList
     }
 
     fun importBatchConfig(server: String?, subid: String = "") {
-        val subid2 = if(subid.isNullOrEmpty()){
-            mainViewModel.subscriptionId
-        }else{
-            subid
-        }
-        val append = subid.isNullOrEmpty()
-
-        var count = AngConfigManager.importBatchConfig(server, subid2, append)
+        var count = AngConfigManager.importBatchConfig(server, subid)
         if (count <= 0) {
-            count = AngConfigManager.importBatchConfig(Utils.decode(server!!), subid2, append)
-        }
-        if (count <= 0) {
-            count = AngConfigManager.appendCustomConfigServer(server, subid2)
+            count = AngConfigManager.importBatchConfig(Utils.decode(server!!), subid)
         }
         if (count > 0) {
             toast(R.string.toast_success)
@@ -499,9 +373,9 @@ class MainActivity : BaseActivity(), NavigationView.OnNavigationItemSelectedList
                 toast(R.string.toast_invalid_url)
                 return false
             }
-            lifecycleScope.launch(Dispatchers.IO) {
+            GlobalScope.launch(Dispatchers.IO) {
                 val configText = try {
-                    Utils.getUrlContentWithCustomUserAgent(url)
+                    URL(url).readText()
                 } catch (e: Exception) {
                     e.printStackTrace()
                     ""
@@ -531,38 +405,20 @@ class MainActivity : BaseActivity(), NavigationView.OnNavigationItemSelectedList
                 ) {
                     return@forEach
                 }
-                if (!it.second.enabled) {
-                    return@forEach
-                }
-                val url = Utils.idnToASCII(it.second.url)
+                val url = it.second.url
                 if (!Utils.isValidUrl(url)) {
                     return@forEach
                 }
-                Log.d(ANG_PACKAGE, url)
-                lifecycleScope.launch(Dispatchers.IO) {
-                    var configText = try {
-                        Utils.getUrlContentWithCustomUserAgent(url)
+                Log.d("Main", url)
+                GlobalScope.launch(Dispatchers.IO) {
+                    val configText = try {
+                        URL(url).readText()
                     } catch (e: Exception) {
                         e.printStackTrace()
                         ""
                     }
-                    if(configText.isEmpty()) {
-                        configText = try {
-                            val httpPort = Utils.parseInt(settingsStorage?.decodeString(AppConfig.PREF_HTTP_PORT), AppConfig.PORT_HTTP.toInt())
-                            Utils.getUrlContentWithCustomUserAgent(url, httpPort)
-                        } catch (e: Exception) {
-                            e.printStackTrace()
-                            ""
-                        }
-                    }
-                    if(configText.isEmpty()) {
-                        launch(Dispatchers.Main) {
-                            toast("\"" + it.second.remarks + "\" " + getString(R.string.toast_failure))
-                        }
-                        return@launch
-                    }
                     launch(Dispatchers.Main) {
-                        importBatchConfig(configText, it.first)
+                        importBatchConfig(Utils.decode(configText), it.first)
                     }
                 }
             }
@@ -582,30 +438,20 @@ class MainActivity : BaseActivity(), NavigationView.OnNavigationItemSelectedList
         intent.addCategory(Intent.CATEGORY_OPENABLE)
 
         try {
-            chooseFileForCustomConfig.launch(Intent.createChooser(intent, getString(R.string.title_file_chooser)))
-        } catch (ex: ActivityNotFoundException) {
+            startActivityForResult(
+                    Intent.createChooser(intent, getString(R.string.title_file_chooser)),
+                    REQUEST_FILE_CHOOSER)
+        } catch (ex: android.content.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(permission)
+                .request(Manifest.permission.READ_EXTERNAL_STORAGE)
                 .subscribe {
                     if (it) {
                         try {
@@ -629,21 +475,19 @@ class MainActivity : BaseActivity(), NavigationView.OnNavigationItemSelectedList
                 toast(R.string.toast_none_data)
                 return
             }
+            if (!V2rayConfigUtil.isValidConfig(server)) {
+                toast(R.string.toast_config_file_invalid)
+                return
+            }
             mainViewModel.appendCustomConfigServer(server)
-            mainViewModel.reloadServerList()
             toast(R.string.toast_success)
-            //adapter.notifyItemInserted(mainViewModel.serverList.lastIndex)
+            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?) {
 //        }
@@ -654,13 +498,38 @@ class MainActivity : BaseActivity(), NavigationView.OnNavigationItemSelectedList
 //    }
 
     override fun onKeyDown(keyCode: Int, event: KeyEvent): Boolean {
-        if (keyCode == KeyEvent.KEYCODE_BACK || keyCode == KeyEvent.KEYCODE_BUTTON_B) {
+        if (keyCode == KeyEvent.KEYCODE_BACK) {
             moveTaskToBack(false)
             return true
         }
         return super.onKeyDown(keyCode, event)
     }
 
+    fun showCircle() {
+        fabProgressCircle?.show()
+    }
+
+    fun hideCircle() {
+        try {
+            Observable.timer(300, TimeUnit.MILLISECONDS)
+                    .observeOn(AndroidSchedulers.mainThread())
+                    .subscribe {
+                        if (fabProgressCircle.isShown) {
+                            fabProgressCircle.hide()
+                        }
+                    }
+        } catch (e: Exception) {
+        }
+    }
+
+    override fun onBackPressed() {
+        if (drawer_layout.isDrawerOpen(GravityCompat.START)) {
+            drawer_layout.closeDrawer(GravityCompat.START)
+        } else {
+            super.onBackPressed()
+        }
+    }
+
     override fun onNavigationItemSelected(item: MenuItem): Boolean {
         // Handle navigation view item clicks here.
         when (item.itemId) {
@@ -672,20 +541,20 @@ class MainActivity : BaseActivity(), NavigationView.OnNavigationItemSelectedList
                 startActivity(Intent(this, SettingsActivity::class.java)
                         .putExtra("isRunning", mainViewModel.isRunning.value == true))
             }
-            R.id.user_asset_setting -> {
-                startActivity(Intent(this, UserAssetActivity::class.java))
+            R.id.feedback -> {
+                Utils.openUri(this, AppConfig.v2rayNGIssues)
             }
             R.id.promotion -> {
-                Utils.openUri(this, "${Utils.decode(AppConfig.PromotionUrl)}?t=${System.currentTimeMillis()}")
+                Utils.openUri(this, AppConfig.promotionUrl)
+            }
+            R.id.donate -> {
+//                startActivity<InappBuyActivity>()
             }
             R.id.logcat -> {
                 startActivity(Intent(this, LogcatActivity::class.java))
             }
-            R.id.about-> {
-                startActivity(Intent(this, AboutActivity::class.java))
-            }
         }
-        binding.drawerLayout.closeDrawer(GravityCompat.START)
+        drawer_layout.closeDrawer(GravityCompat.START)
         return true
     }
 }

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

@@ -2,21 +2,16 @@ package com.v2ray.ang.ui
 
 import android.content.Intent
 import android.graphics.Color
-import android.text.TextUtils
+import android.support.v4.content.ContextCompat
+import android.support.v7.app.AlertDialog
+import android.support.v7.widget.RecyclerView
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
-import androidx.appcompat.app.AlertDialog
-import androidx.core.content.ContextCompat
-import androidx.recyclerview.widget.RecyclerView
 import com.google.gson.Gson
 import com.tencent.mmkv.MMKV
-import com.v2ray.ang.AngApplication.Companion.application
 import com.v2ray.ang.AppConfig
 import com.v2ray.ang.R
-import com.v2ray.ang.databinding.ItemQrcodeBinding
-import com.v2ray.ang.databinding.ItemRecyclerFooterBinding
-import com.v2ray.ang.databinding.ItemRecyclerMainBinding
 import com.v2ray.ang.dto.EConfigType
 import com.v2ray.ang.dto.SubscriptionItem
 import com.v2ray.ang.extension.toast
@@ -26,6 +21,8 @@ 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 rx.Observable
 import rx.android.schedulers.AndroidSchedulers
 import java.util.concurrent.TimeUnit
@@ -40,67 +37,48 @@ class MainRecyclerAdapter(val activity: MainActivity) : RecyclerView.Adapter<Mai
     private var mActivity: MainActivity = activity
     private val mainStorage by lazy { MMKV.mmkvWithID(MmkvManager.ID_MAIN, MMKV.MULTI_PROCESS_MODE) }
     private val subStorage by lazy { MMKV.mmkvWithID(MmkvManager.ID_SUB, MMKV.MULTI_PROCESS_MODE) }
-    private val settingsStorage by lazy { MMKV.mmkvWithID(MmkvManager.ID_SETTING, MMKV.MULTI_PROCESS_MODE) }
     private val share_method: Array<out String> by lazy {
         mActivity.resources.getStringArray(R.array.share_method)
     }
     var isRunning = false
 
-    override fun getItemCount() = mActivity.mainViewModel.serversCache.size + 1
+    override fun getItemCount() = mActivity.mainViewModel.serverList.size + 1
 
     override fun onBindViewHolder(holder: BaseViewHolder, position: Int) {
         if (holder is MainViewHolder) {
-            val guid = mActivity.mainViewModel.serversCache[position].guid
-            val config = mActivity.mainViewModel.serversCache[position].config
-//            //filter
-//            if (mActivity.mainViewModel.subscriptionId.isNotEmpty()
-//                && mActivity.mainViewModel.subscriptionId != config.subscriptionId
-//            ) {
-//                holder.itemMainBinding.cardView.visibility = View.GONE
-//            } else {
-//                holder.itemMainBinding.cardView.visibility = View.VISIBLE
-//            }
-
+            val guid = mActivity.mainViewModel.serverList.getOrNull(position) ?: return
+            val config = MmkvManager.decodeServerConfig(guid) ?: return
             val outbound = config.getProxyOutbound()
             val aff = MmkvManager.decodeServerAffiliationInfo(guid)
 
-            holder.itemMainBinding.tvName.text = config.remarks
+            holder.name.text = config.remarks
+            holder.radio.isChecked = guid == mainStorage?.decodeString(MmkvManager.KEY_SELECTED_SERVER)
             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))
+            holder.test_result.text = aff?.getTestDelayString() ?: ""
+            if (aff?.testDelayMillis?:0L < 0L) {
+                holder.test_result.setTextColor(ContextCompat.getColor(mActivity, android.R.color.holo_red_dark))
             } else {
-                holder.itemMainBinding.tvTestResult.setTextColor(ContextCompat.getColor(mActivity, R.color.colorPing))
+                holder.test_result.setTextColor(ContextCompat.getColor(mActivity, R.color.colorPing))
             }
-            if (guid == mainStorage?.decodeString(MmkvManager.KEY_SELECTED_SERVER)) {
-                holder.itemMainBinding.layoutIndicator.setBackgroundResource(R.color.colorAccent)
-            } else {
-                holder.itemMainBinding.layoutIndicator.setBackgroundResource(0)
-            }
-            holder.itemMainBinding.tvSubscription.text = ""
+            holder.subscription.text = ""
             val json = subStorage?.decodeString(config.subscriptionId)
             if (!json.isNullOrBlank()) {
                 val sub = Gson().fromJson(json, SubscriptionItem::class.java)
-                holder.itemMainBinding.tvSubscription.text = sub.remarks
+                holder.subscription.text = sub.remarks
             }
 
             var shareOptions = share_method.asList()
-            when (config.configType) {
-                EConfigType.CUSTOM -> {
-                    holder.itemMainBinding.tvType.text = mActivity.getString(R.string.server_customize_config)
-                    shareOptions = shareOptions.takeLast(1)
-                }
-                EConfigType.VLESS -> {
-                    holder.itemMainBinding.tvType.text = config.configType.name
-                }
-                else -> {
-                    holder.itemMainBinding.tvType.text = config.configType.name.lowercase()
-                }
+            if (config.configType == EConfigType.CUSTOM) {
+                holder.type.text = mActivity.getString(R.string.server_customize_config)
+                shareOptions = shareOptions.takeLast(1)
+            } else if (config.configType == EConfigType.VLESS) {
+                holder.type.text = config.configType.name
+            } else {
+                holder.type.text = config.configType.name.toLowerCase()
             }
-            val strState = "${outbound?.getServerAddress()?.dropLast(3)}*** : ${outbound?.getServerPort()}"
-            holder.itemMainBinding.tvStatistics.text = strState
+            holder.statistics.text = "${outbound?.getServerAddress()} : ${outbound?.getServerPort()}"
 
-            holder.itemMainBinding.layoutShare.setOnClickListener {
+            holder.layout_share.setOnClickListener {
                 AlertDialog.Builder(mActivity).setItems(shareOptions.toTypedArray()) { _, i ->
                     try {
                         when (i) {
@@ -108,9 +86,9 @@ class MainRecyclerAdapter(val activity: MainActivity) : RecyclerView.Adapter<Mai
                                 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()
+                                    val iv = LayoutInflater.from(mActivity).inflate(R.layout.item_qrcode, null)
+                                    iv.iv_qcode.setImageBitmap(AngConfigManager.share2QRCode(guid))
+                                    AlertDialog.Builder(mActivity).setView(iv).show()
                                 }
                             }
                             1 -> {
@@ -129,7 +107,7 @@ class MainRecyclerAdapter(val activity: MainActivity) : RecyclerView.Adapter<Mai
                 }.show()
             }
 
-            holder.itemMainBinding.layoutEdit.setOnClickListener {
+            holder.layout_edit.setOnClickListener {
                 val intent = Intent().putExtra("guid", guid)
                         .putExtra("isRunning", isRunning)
                 if (config.configType == EConfigType.CUSTOM) {
@@ -138,39 +116,28 @@ class MainRecyclerAdapter(val activity: MainActivity) : RecyclerView.Adapter<Mai
                     mActivity.startActivity(intent.setClass(mActivity, ServerActivity::class.java))
                 }
             }
-            holder.itemMainBinding.layoutRemove.setOnClickListener {
+            holder.layout_remove.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)
-                            }
-                            .setNegativeButton(android.R.string.no) {_, _ ->
-                                //do noting
-                            }
-                            .show()
-                    } else {
-                        removeServer(guid, position)
-                    }
-                } else {
-                    application.toast(R.string.toast_action_not_allowed)
+                    mActivity.mainViewModel.removeServer(guid)
+                    notifyItemRemoved(position)
+                    notifyItemRangeChanged(position, mActivity.mainViewModel.serverList.size)
                 }
             }
 
-            holder.itemMainBinding.infoContainer.setOnClickListener {
+            holder.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))
+                    notifyItemChanged(mActivity.mainViewModel.serverList.indexOf(selected))
+                    notifyItemChanged(mActivity.mainViewModel.serverList.indexOf(guid))
                     if (isRunning) {
+                        mActivity.showCircle()
                         Utils.stopVService(mActivity)
                         Observable.timer(500, TimeUnit.MILLISECONDS)
                                 .observeOn(AndroidSchedulers.mainThread())
                                 .subscribe {
                                     V2RayServiceManager.startV2Ray(mActivity)
+                                    mActivity.hideCircle()
                                 }
                     }
                 }
@@ -179,10 +146,10 @@ class MainRecyclerAdapter(val activity: MainActivity) : RecyclerView.Adapter<Mai
         if (holder is FooterViewHolder) {
             //if (activity?.defaultDPreference?.getPrefBoolean(AppConfig.PREF_INAPP_BUY_IS_PREMIUM, false)) {
             if (true) {
-                holder.itemFooterBinding.layoutEdit.visibility = View.INVISIBLE
+                holder.layout_edit.visibility = View.INVISIBLE
             } else {
-                holder.itemFooterBinding.layoutEdit.setOnClickListener {
-                    Utils.openUri(mActivity, "${Utils.decode(AppConfig.PromotionUrl)}?t=${System.currentTimeMillis()}")
+                holder.layout_edit.setOnClickListener {
+                    Utils.openUri(mActivity, "${Utils.decode(AppConfig.promotionUrl)}?t=${System.currentTimeMillis()}")
                 }
             }
         }
@@ -196,47 +163,62 @@ class MainRecyclerAdapter(val activity: MainActivity) : RecyclerView.Adapter<Mai
         }
     }
 
-    private  fun removeServer(guid: String,position:Int) {
-        mActivity.mainViewModel.removeServer(guid)
-        notifyItemRemoved(position)
-        notifyItemRangeChanged(position, mActivity.mainViewModel.serversCache.size)
-    }
-
     override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): BaseViewHolder {
         return when (viewType) {
             VIEW_TYPE_ITEM ->
-                MainViewHolder(ItemRecyclerMainBinding.inflate(LayoutInflater.from(parent.context), parent, false))
+                MainViewHolder(LayoutInflater.from(parent.context)
+                        .inflate(R.layout.item_recycler_main, parent, false))
             else ->
-                FooterViewHolder(ItemRecyclerFooterBinding.inflate(LayoutInflater.from(parent.context), parent, false))
+                FooterViewHolder(LayoutInflater.from(parent.context)
+                        .inflate(R.layout.item_recycler_footer, parent, false))
         }
     }
 
     override fun getItemViewType(position: Int): Int {
-        return if (position == mActivity.mainViewModel.serversCache.size) {
+        return if (position == mActivity.mainViewModel.serverList.size) {
             VIEW_TYPE_FOOTER
         } else {
             VIEW_TYPE_ITEM
         }
     }
 
-    open class BaseViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
-        fun onItemSelected() {
+    open class BaseViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView)
+
+    class MainViewHolder(itemView: View) : BaseViewHolder(itemView), ItemTouchHelperViewHolder {
+        val subscription = itemView.tv_subscription!!
+        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() {
             itemView.setBackgroundColor(Color.LTGRAY)
         }
 
-        fun onItemClear() {
+        override fun onItemClear() {
             itemView.setBackgroundColor(0)
         }
     }
 
-    class MainViewHolder(val itemMainBinding: ItemRecyclerMainBinding) :
-            BaseViewHolder(itemMainBinding.root), ItemTouchHelperViewHolder
+    class FooterViewHolder(itemView: View) : BaseViewHolder(itemView), ItemTouchHelperViewHolder {
+        val layout_edit = itemView.layout_edit!!
 
-    class FooterViewHolder(val itemFooterBinding: ItemRecyclerFooterBinding) :
-            BaseViewHolder(itemFooterBinding.root)
+        override fun onItemSelected() {
+            itemView.setBackgroundColor(Color.LTGRAY)
+        }
+
+        override fun onItemClear() {
+            itemView.setBackgroundColor(0)
+        }
+    }
 
     override fun onItemDismiss(position: Int) {
-        val guid = mActivity.mainViewModel.serversCache.getOrNull(position)?.guid ?: return
+        val guid = mActivity.mainViewModel.serverList.getOrNull(position) ?: return
         if (guid != mainStorage?.decodeString(MmkvManager.KEY_SELECTED_SERVER)) {
 //            mActivity.alert(R.string.del_config_comfirm) {
 //                positiveButton(android.R.string.ok) {
@@ -251,11 +233,7 @@ class MainRecyclerAdapter(val activity: MainActivity) : RecyclerView.Adapter<Mai
     override fun onItemMove(fromPosition: Int, toPosition: Int): Boolean {
         mActivity.mainViewModel.swapServer(fromPosition, toPosition)
         notifyItemMoved(fromPosition, toPosition)
-        // position is changed, since position is used by click callbacks, need to update range
-        if (toPosition > fromPosition)
-            notifyItemRangeChanged(fromPosition, toPosition - fromPosition + 1)
-        else
-            notifyItemRangeChanged(toPosition, fromPosition - toPosition + 1)
+        //notifyItemRangeChanged(fromPosition, toPosition - fromPosition + 1)
         return true
     }
 

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

@@ -1,63 +1,69 @@
 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.preference.PreferenceManager
+import android.support.v7.widget.DividerItemDecoration
+import android.support.v7.widget.LinearLayoutManager
+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 androidx.appcompat.widget.SearchView
-import androidx.lifecycle.lifecycleScope
-import androidx.recyclerview.widget.DividerItemDecoration
-import androidx.recyclerview.widget.LinearLayoutManager
-import com.tencent.mmkv.MMKV
-import com.v2ray.ang.AppConfig
-import com.v2ray.ang.AppConfig.ANG_PACKAGE
+import android.view.animation.AccelerateInterpolator
+import android.view.animation.DecelerateInterpolator
 import com.v2ray.ang.R
-import com.v2ray.ang.databinding.ActivityBypassListBinding
-import com.v2ray.ang.dto.AppInfo
-import com.v2ray.ang.extension.toast
-import com.v2ray.ang.extension.v2RayApplication
 import com.v2ray.ang.util.AppManagerUtil
-import com.v2ray.ang.util.MmkvManager
-import com.v2ray.ang.util.Utils
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
+import kotlinx.android.synthetic.main.activity_bypass_list.*
 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.toast
+import com.v2ray.ang.extension.v2RayApplication
+import com.v2ray.ang.util.Utils
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.launch
+import java.net.URL
 
 class PerAppProxyActivity : BaseActivity() {
-    private lateinit var binding: ActivityBypassListBinding
 
     private var adapter: PerAppProxyAdapter? = null
     private var appsAll: List<AppInfo>? = null
-    private val settingsStorage by lazy { MMKV.mmkvWithID(MmkvManager.ID_SETTING, MMKV.MULTI_PROCESS_MODE) }
+    private val defaultSharedPreferences by lazy { PreferenceManager.getDefaultSharedPreferences(this) }
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
-        binding = ActivityBypassListBinding.inflate(layoutInflater)
-        val view = binding.root
-        setContentView(view)
+        setContentView(R.layout.activity_bypass_list)
+
+        supportActionBar?.setDisplayHomeAsUpEnabled(true)
 
         val dividerItemDecoration = DividerItemDecoration(this, LinearLayoutManager.VERTICAL)
-        binding.recyclerView.addItemDecoration(dividerItemDecoration)
+        recycler_view.addItemDecoration(dividerItemDecoration)
 
-        val blacklist = settingsStorage?.decodeStringSet(AppConfig.PREF_PER_APP_PROXY_SET)
+        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 = Comparator<AppInfo> { p1, p2 ->
-                            when {
+                        val comparator = object : Comparator<AppInfo> {
+                            override fun compare(p1: AppInfo, p2: AppInfo): Int = when {
                                 p1.isSelected > p2.isSelected -> -1
                                 p1.isSelected == p2.isSelected -> 0
                                 else -> 1
@@ -83,123 +89,103 @@ class PerAppProxyActivity : BaseActivity() {
                 .subscribe {
                     appsAll = it
                     adapter = PerAppProxyAdapter(this, it, blacklist)
-                    binding.recyclerView.adapter = adapter
-                    binding.pbWaiting.visibility = View.GONE
+                    recycler_view.adapter = adapter
+                    pb_waiting.visibility = View.GONE
                 }
-        /***
+
         recycler_view.addOnScrollListener(object : RecyclerView.OnScrollListener() {
-        var dst = 0
-        val threshold = resources.getDimensionPixelSize(R.dimen.bypass_list_header_height) * 2
-        override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
-        dst += dy
-        if (dst > threshold) {
-        header_view.hide()
-        dst = 0
-        } else if (dst < -20) {
-        header_view.show()
-        dst = 0
-        }
-        }
+            var 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 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
-        }
+            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
+            }
         })
-        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
+        switch_per_app_proxy.setOnCheckedChangeListener { _, isChecked ->
+            defaultSharedPreferences.edit().putBoolean(AppConfig.PREF_PER_APP_PROXY, isChecked).apply()
         }
-        })
-        showing = true
-        }
-        })
-         ***/
+        switch_per_app_proxy.isChecked = defaultSharedPreferences.getBoolean(AppConfig.PREF_PER_APP_PROXY, false)
 
-        binding.switchPerAppProxy.setOnCheckedChangeListener { _, isChecked ->
-            settingsStorage.encode(AppConfig.PREF_PER_APP_PROXY, isChecked)
+        switch_bypass_apps.setOnCheckedChangeListener { _, isChecked ->
+            defaultSharedPreferences.edit().putBoolean(AppConfig.PREF_BYPASS_APPS, isChecked).apply()
         }
-        binding.switchPerAppProxy.isChecked = settingsStorage.getBoolean(AppConfig.PREF_PER_APP_PROXY, false)
+        switch_bypass_apps.isChecked = defaultSharedPreferences.getBoolean(AppConfig.PREF_BYPASS_APPS, false)
 
-        binding.switchBypassApps.setOnCheckedChangeListener { _, isChecked ->
-            settingsStorage.encode(AppConfig.PREF_BYPASS_APPS, isChecked)
-        }
-        binding.switchBypassApps.isChecked = settingsStorage.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)
+                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
+            }
         }
-        } 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 {
-            settingsStorage.encode(AppConfig.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)
     }
 
@@ -216,20 +202,14 @@ 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)
@@ -238,41 +218,27 @@ class PerAppProxyActivity : BaseActivity() {
     private fun selectProxyApp() {
         toast(R.string.msg_downloading_content)
         val url = AppConfig.androidpackagenamelistUrl
-        lifecycleScope.launch(Dispatchers.IO) {
-            val content = Utils.getUrlContext(url, 5000)
+        GlobalScope.launch(Dispatchers.IO) {
+            val content = try {
+                URL(url).readText()
+            } catch (e: Exception) {
+                e.printStackTrace()
+                ""
+            }
             launch(Dispatchers.Main) {
-                Log.d(ANG_PACKAGE, content)
-                selectProxyApp(content, true)
+                Log.d("selectProxyApp", content)
+                selectProxyApp(content)
                 toast(R.string.toast_success)
             }
         }
     }
 
-    private fun importProxyApp() {
-        val content = Utils.getClipboard(applicationContext)
-        if (TextUtils.isEmpty(content)) {
-            return
-        }
-        selectProxyApp(content, false)
-        toast(R.string.toast_success)
-    }
-
-    private fun exportProxyApp() {
-        var lst = binding.switchBypassApps.isChecked.toString()
-
-        adapter?.blacklist?.forEach block@{
-            lst = lst + System.getProperty("line.separator") + it
-        }
-        Utils.setClipboard(applicationContext, lst)
-        toast(R.string.toast_success)
-    }
-
-    private fun selectProxyApp(content: String, force: Boolean): Boolean {
+    private fun selectProxyApp(content: String): Boolean {
         try {
-            val proxyApps = if (TextUtils.isEmpty(content)) {
-                Utils.readTextFromAssets(v2RayApplication, "proxy_packagename.txt")
-            } else {
-                content
+            var proxyApps = content
+            if (TextUtils.isEmpty(content)) {
+                val assets = Utils.readTextFromAssets(v2RayApplication, "proxy_packagename.txt")
+                proxyApps = assets.lines().toString()
             }
             if (TextUtils.isEmpty(proxyApps)) {
                 return false
@@ -280,12 +246,12 @@ class PerAppProxyActivity : BaseActivity() {
 
             adapter?.blacklist!!.clear()
 
-            if (binding.switchBypassApps.isChecked) {
+            if (switch_bypass_apps.isChecked) {
                 adapter?.let {
                     it.apps.forEach block@{
                         val packageName = it.packageName
-                        Log.d(ANG_PACKAGE, packageName)
-                        if (!inProxyApps(proxyApps, packageName, force)) {
+                        Log.d("selectProxyApp2", packageName)
+                        if (proxyApps.indexOf(packageName) < 0) {
                             adapter?.blacklist!!.add(packageName)
                             println(packageName)
                             return@block
@@ -297,8 +263,8 @@ class PerAppProxyActivity : BaseActivity() {
                 adapter?.let {
                     it.apps.forEach block@{
                         val packageName = it.packageName
-                        Log.d(ANG_PACKAGE, packageName)
-                        if (inProxyApps(proxyApps, packageName, force)) {
+                        Log.d("selectProxyApp3", packageName)
+                        if (proxyApps.indexOf(packageName) >= 0) {
                             adapter?.blacklist!!.add(packageName)
                             println(packageName)
                             return@block
@@ -313,40 +279,4 @@ 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,12 +1,13 @@
 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 java.util.*
 
 class PerAppProxyAdapter(val activity: BaseActivity, val apps: List<AppInfo>, blacklist: MutableSet<String>?) :
@@ -17,7 +18,8 @@ class PerAppProxyAdapter(val activity: BaseActivity, val apps: List<AppInfo>, bl
         private const val VIEW_TYPE_ITEM = 1
     }
 
-    val blacklist = if (blacklist == null) HashSet() else HashSet(blacklist)
+    private var mActivity: BaseActivity = activity
+    val blacklist = if (blacklist == null) HashSet<String>() else HashSet<String>(blacklist)
 
     override fun onBindViewHolder(holder: BaseViewHolder, position: Int) {
         if (holder is AppViewHolder) {
@@ -35,13 +37,14 @@ 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) * 0)
+                        ctx.resources.getDimensionPixelSize(R.dimen.bypass_list_header_height) * 3)
                 BaseViewHolder(view)
             }
 //            VIEW_TYPE_ITEM -> AppViewHolder(ctx.layoutInflater
 //                    .inflate(R.layout.item_recycler_bypass_list, parent, false))
 
-            else -> AppViewHolder(ItemRecyclerBypassListBinding.inflate(LayoutInflater.from(ctx), parent, false))
+            else -> AppViewHolder(LayoutInflater.from(ctx)
+                    .inflate(R.layout.item_recycler_bypass_list, parent, false))
 
         }
     }
@@ -50,25 +53,30 @@ class PerAppProxyAdapter(val activity: BaseActivity, val apps: List<AppInfo>, bl
 
     open class BaseViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView)
 
-    inner class AppViewHolder(private val itemBypassBinding: ItemRecyclerBypassListBinding) : BaseViewHolder(itemBypassBinding.root),
+    inner class AppViewHolder(itemView: View) : BaseViewHolder(itemView),
             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 package_name = itemView.package_name!!
+        val checkBox = itemView.check_box!!
+
         fun bind(appInfo: AppInfo) {
             this.appInfo = appInfo
 
-            itemBypassBinding.icon.setImageDrawable(appInfo.appIcon)
+            icon.setImageDrawable(appInfo.appIcon)
 //            name.text = appInfo.appName
 
-            itemBypassBinding.checkBox.isChecked = inBlacklist
-            itemBypassBinding.packageName.text = appInfo.packageName
+            checkBox.isChecked = inBlacklist
+            package_name.text = appInfo.packageName
             if (appInfo.isSystemApp) {
-                itemBypassBinding.name.text = String.format("** %1s", appInfo.appName)
-                //name.textColor = Color.RED
+                name.text = String.format("** %1s", appInfo.appName)
+                name.setTextColor(Color.RED)
             } else {
-                itemBypassBinding.name.text = appInfo.appName
-                //name.textColor = Color.DKGRAY
+                name.text = appInfo.appName
+                name.setTextColor(Color.DKGRAY)
             }
 
             itemView.setOnClickListener(this)
@@ -77,10 +85,10 @@ class PerAppProxyAdapter(val activity: BaseActivity, val apps: List<AppInfo>, bl
         override fun onClick(v: View?) {
             if (inBlacklist) {
                 blacklist.remove(appInfo.packageName)
-                itemBypassBinding.checkBox.isChecked = false
+                checkBox.isChecked = false
             } else {
                 blacklist.add(appInfo.packageName)
-                itemBypassBinding.checkBox.isChecked = true
+                checkBox.isChecked = true
             }
         }
     }

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

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

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

@@ -1,40 +1,37 @@
 package com.v2ray.ang.ui
 
 import android.Manifest
-import androidx.appcompat.app.AppCompatActivity.RESULT_OK
+import android.app.Activity.RESULT_OK
 import android.content.Intent
 import android.os.Bundle
-import android.text.TextUtils
+import android.support.v4.app.Fragment
+import android.support.v7.preference.PreferenceManager
 import android.view.*
-import androidx.activity.result.contract.ActivityResultContracts
-import androidx.fragment.app.Fragment
-import androidx.lifecycle.lifecycleScope
-import androidx.preference.PreferenceManager
-import com.tbruyelle.rxpermissions.RxPermissions
-import com.tencent.mmkv.MMKV
-import com.v2ray.ang.AppConfig
 import com.v2ray.ang.R
-import com.v2ray.ang.databinding.FragmentRoutingSettingsBinding
-import com.v2ray.ang.extension.toast
-import com.v2ray.ang.extension.v2RayApplication
-import com.v2ray.ang.util.MmkvManager
 import com.v2ray.ang.util.Utils
+import kotlinx.android.synthetic.main.fragment_routing_settings.*
+import android.view.MenuInflater
+import com.tbruyelle.rxpermissions.RxPermissions
+import com.v2ray.ang.AppConfig
+import com.v2ray.ang.extension.toast
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.launch
+import java.net.URL
 
 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
     }
 
-   private val settingsStorage by lazy { MMKV.mmkvWithID(MmkvManager.ID_SETTING, MMKV.MULTI_PROCESS_MODE) }
+    val defaultSharedPreferences by lazy { PreferenceManager.getDefaultSharedPreferences(context) }
 
     override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?,
                               savedInstanceState: Bundle?): View? {
         // Inflate the layout for this fragment
-        binding = FragmentRoutingSettingsBinding.inflate(layoutInflater)
-        return binding.root// inflater.inflate(R.layout.fragment_routing_settings, container, false)
+        return inflater.inflate(R.layout.fragment_routing_settings, container, false)
     }
 
     fun newInstance(arg: String): Fragment {
@@ -48,8 +45,8 @@ class RoutingSettingsFragment : Fragment() {
     override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
         super.onViewCreated(view, savedInstanceState)
 
-        val content = settingsStorage?.getString(requireArguments().getString(routing_arg), "")
-        binding.etRoutingContent.text = Utils.getEditable(content!!)
+        val content = defaultSharedPreferences.getString(arguments!!.getString(routing_arg), "")
+        et_routing_content.text = Utils.getEditable(content!!)
 
         setHasOptionsMenu(true)
     }
@@ -61,19 +58,21 @@ class RoutingSettingsFragment : Fragment() {
 
     override fun onOptionsItemSelected(item: MenuItem) = when (item.itemId) {
         R.id.save_routing -> {
-            saveRouting()
+            val content = et_routing_content.text.toString()
+            defaultSharedPreferences.edit().putString(arguments!!.getString(routing_arg), content).apply()
+            activity?.toast(R.string.toast_success)
             true
         }
         R.id.del_routing -> {
-            binding.etRoutingContent.text = null
+            et_routing_content.text = null
             true
         }
         R.id.scan_replace -> {
-            scanQRcode(true)
+            scanQRcode(REQUEST_SCAN_REPLACE)
             true
         }
         R.id.scan_append -> {
-            scanQRcode(false)
+            scanQRcode(REQUEST_SCAN_APPEND)
             true
         }
         R.id.default_rules -> {
@@ -83,26 +82,17 @@ class RoutingSettingsFragment : Fragment() {
         else -> super.onOptionsItemSelected(item)
     }
 
-    private fun saveRouting() {
-        val content = binding.etRoutingContent.text.toString()
-        settingsStorage?.encode(requireArguments().getString(routing_arg), content)
-        activity?.toast(R.string.toast_success)
-    }
-
-    fun scanQRcode(forReplace: Boolean): Boolean {
+    fun scanQRcode(requestCode: Int): Boolean {
 //        try {
 //            startActivityForResult(Intent("com.google.zxing.client.android.SCAN")
 //                    .addCategory(Intent.CATEGORY_DEFAULT)
 //                    .addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP), requestCode)
 //        } catch (e: Exception) {
-        RxPermissions(requireActivity())
+        RxPermissions(activity!!)
                 .request(Manifest.permission.CAMERA)
                 .subscribe {
                     if (it)
-                        if (forReplace)
-                            scanQRCodeForReplace.launch(Intent(activity, ScannerActivity::class.java))
-                        else
-                            scanQRCodeForAppend.launch(Intent(activity, ScannerActivity::class.java))
+                        startActivityForResult(Intent(activity, ScannerActivity::class.java), requestCode)
                     else
                         activity?.toast(R.string.toast_permission_denied)
                 }
@@ -110,50 +100,51 @@ 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
-        var tag = ""
-        when (requireArguments().getString(routing_arg)) {
+        when (arguments!!.getString(routing_arg)) {
             AppConfig.PREF_V2RAY_ROUTING_AGENT -> {
-                tag = AppConfig.TAG_PROXY
+                url += AppConfig.TAG_AGENT
             }
             AppConfig.PREF_V2RAY_ROUTING_DIRECT -> {
-                tag = AppConfig.TAG_DIRECT
+                url += AppConfig.TAG_DIRECT
             }
             AppConfig.PREF_V2RAY_ROUTING_BLOCKED -> {
-                tag = AppConfig.TAG_BLOCKED
+                url += AppConfig.TAG_BLOCKED
             }
         }
-        url += tag
 
         activity?.toast(R.string.msg_downloading_content)
-        lifecycleScope.launch(Dispatchers.IO) {
-            val content = Utils.getUrlContext(url, 5000)
+        GlobalScope.launch(Dispatchers.IO) {
+            val content = try {
+                URL(url).readText()
+            } catch (e: Exception) {
+                e.printStackTrace()
+                ""
+            }
             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)
+                et_routing_content.text = Utils.getEditable(content)
+                activity?.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,23 +6,25 @@ import com.tbruyelle.rxpermissions.RxPermissions
 import com.v2ray.ang.R
 import com.v2ray.ang.util.AngConfigManager
 import android.os.Bundle
-import androidx.activity.result.contract.ActivityResultContracts
 import com.v2ray.ang.extension.toast
 
 class ScScannerActivity : BaseActivity() {
+    companion object {
+        private const val REQUEST_SCAN = 1
+    }
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         setContentView(R.layout.activity_none)
-        importQRcode()
+        importQRcode(REQUEST_SCAN)
     }
 
-    fun importQRcode(): Boolean {
+    fun importQRcode(requestCode: Int): Boolean {
         RxPermissions(this)
                 .request(Manifest.permission.CAMERA)
                 .subscribe {
                     if (it)
-                        scanQRCode.launch(Intent(this, ScannerActivity::class.java))
+                        startActivityForResult(Intent(this, ScannerActivity::class.java), requestCode)
                     else
                         toast(R.string.toast_permission_denied)
                 }
@@ -30,16 +32,21 @@ class ScScannerActivity : BaseActivity() {
         return true
     }
 
-    private val scanQRCode = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) {
-        if (it.resultCode == RESULT_OK) {
-            val count = AngConfigManager.importBatchConfig(it.data?.getStringExtra("SCAN_RESULT"), "", false)
-            if (count > 0) {
-                toast(R.string.toast_success)
-            } else {
-                toast(R.string.toast_failure)
-            }
-            startActivity(Intent(this, MainActivity::class.java))
+    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(Intent(this, MainActivity::class.java))
+                }
         }
         finish()
     }
+
 }

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

@@ -1,91 +1,90 @@
 package com.v2ray.ang.ui
 
 import android.Manifest
-import androidx.appcompat.app.AppCompatActivity
+import android.app.Activity
 import android.os.Bundle
+import com.google.zxing.Result
+import me.dm7.barcodescanner.zxing.ZXingScannerView
 import android.content.Intent
 import android.graphics.BitmapFactory
-import android.os.Build
 import android.view.Menu
 import android.view.MenuItem
-import androidx.activity.result.contract.ActivityResultContracts
+import com.google.zxing.BarcodeFormat
 import com.tbruyelle.rxpermissions.RxPermissions
-import com.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 io.github.g00fy2.quickie.QRResult
-import io.github.g00fy2.quickie.ScanCustomCode
-import io.github.g00fy2.quickie.config.ScannerConfig
 
-class ScannerActivity : BaseActivity(){
+class ScannerActivity : BaseActivity(), ZXingScannerView.ResultHandler {
+    companion object {
+        private const val REQUEST_FILE_CHOOSER = 2
+    }
 
-    private val scanQrCode = registerForActivityResult(ScanCustomCode(), ::handleResult)
-    private val settingsStorage by lazy { MMKV.mmkvWithID(MmkvManager.ID_SETTING, MMKV.MULTI_PROCESS_MODE) }
+
+    private var mScannerView: ZXingScannerView? = null
 
     public override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
+        mScannerView = ZXingScannerView(this)   // Programmatically initialize the scanner view
 
-        if (settingsStorage?.decodeBool(AppConfig.PREF_START_SCAN_IMMEDIATE) == true) {
-            launchScan()
-        }
+        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
     }
 
-    private fun finished(text: String) {
+    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) {
         val intent = Intent()
         intent.putExtra("SCAN_RESULT", text)
-        setResult(AppCompatActivity.RESULT_OK, intent)
+        setResult(Activity.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(permission)
-                .subscribe {
-                    if (it) {
-                        try {
-                            showFileChooser()
-                        } catch (e: Exception) {
-                            e.printStackTrace()
-                        }
-                    } else
-                        toast(R.string.toast_permission_denied)
-                }
+                    .request(Manifest.permission.READ_EXTERNAL_STORAGE)
+                    .subscribe {
+                        if (it) {
+                            try {
+                                showFileChooser()
+                            } catch (e: Exception) {
+                                e.printStackTrace()
+                            }
+                        } else
+                            toast(R.string.toast_permission_denied)
+                    }
             true
         }
         else -> super.onOptionsItemSelected(item)
@@ -98,22 +97,30 @@ class ScannerActivity : BaseActivity(){
         //intent.putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true)
 
         try {
-            chooseFile.launch(Intent.createChooser(intent, getString(R.string.title_file_chooser)))
+            startActivityForResult(
+                    Intent.createChooser(intent, getString(R.string.title_file_chooser)),
+                    REQUEST_FILE_CHOOSER)
         } catch (ex: android.content.ActivityNotFoundException) {
             toast(R.string.toast_require_file_manager)
         }
     }
 
-    private val chooseFile = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) {
-        val uri = it.data?.data
-        if (it.resultCode == RESULT_OK && uri != null) {
-            try {
-                val bitmap = BitmapFactory.decodeStream(contentResolver.openInputStream(uri))
-                val text = QRCodeDecoder.syncDecodeQRCode(bitmap)
-                finished(text!!)
-            } catch (e: Exception) {
-                e.printStackTrace()
-                toast(e.message.toString())
+
+    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
+        super.onActivityResult(requestCode, resultCode, data)
+        when (requestCode) {
+            REQUEST_FILE_CHOOSER -> {
+                val uri = data?.data
+                if (resultCode == RESULT_OK && uri != null) {
+                    try {
+                        val bitmap = BitmapFactory.decodeStream(contentResolver.openInputStream(uri))
+                        val text = QRCodeDecoder.syncDecodeQRCode(bitmap)
+                        finished(text)
+                    } catch (e: Exception) {
+                        e.printStackTrace()
+                        toast(e.message.toString())
+                    }
+                }
             }
         }
     }

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

@@ -1,42 +1,40 @@
 package com.v2ray.ang.ui
 
 import android.os.Bundle
+import android.support.v7.app.AlertDialog
 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.AngApplication
-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.EConfigType
 import com.v2ray.ang.dto.ServerConfig
 import com.v2ray.ang.dto.V2rayConfig
+import com.v2ray.ang.dto.V2rayConfig.Companion.DEFAULT_NETWORK
 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.dto.V2rayConfig.Companion.XTLS
 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 com.v2ray.ang.util.Utils.getIpv6Address
+import kotlinx.android.synthetic.main.activity_server_socks.*
+import kotlinx.android.synthetic.main.activity_server_vmess.*
+import kotlinx.android.synthetic.main.activity_server_vmess.et_address
+import kotlinx.android.synthetic.main.activity_server_vmess.et_id
+import kotlinx.android.synthetic.main.activity_server_vmess.et_path
+import kotlinx.android.synthetic.main.activity_server_vmess.et_port
+import kotlinx.android.synthetic.main.activity_server_vmess.et_remarks
+import kotlinx.android.synthetic.main.activity_server_vmess.et_request_host
+import kotlinx.android.synthetic.main.activity_server_vmess.sp_allow_insecure
+import kotlinx.android.synthetic.main.activity_server_vmess.sp_header_type
+import kotlinx.android.synthetic.main.activity_server_vmess.sp_network
+import kotlinx.android.synthetic.main.activity_server_vmess.sp_stream_security
 
 class ServerActivity : BaseActivity() {
 
     private val mainStorage by lazy { MMKV.mmkvWithID(ID_MAIN, MMKV.MULTI_PROCESS_MODE) }
-    private val settingsStorage by lazy {
-        MMKV.mmkvWithID(
-            MmkvManager.ID_SETTING,
-            MMKV.MULTI_PROCESS_MODE
-        )
-    }
+    private val 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)
@@ -44,13 +42,8 @@ class ServerActivity : BaseActivity() {
                 && editGuid == mainStorage?.decodeString(KEY_SELECTED_SERVER)
     }
     private val createConfigType by lazy {
-        EConfigType.fromInt(intent.getIntExtra("createConfigType", EConfigType.VMESS.value))
-            ?: EConfigType.VMESS
+        EConfigType.fromInt(intent.getIntExtra("createConfigType", EConfigType.VMESS.value)) ?: EConfigType.VMESS
     }
-    private val subscriptionId by lazy {
-        intent.getStringExtra("subscriptionId")
-    }
-
     private val securitys: Array<out String> by lazy {
         resources.getStringArray(R.array.securitys)
     }
@@ -63,14 +56,8 @@ class ServerActivity : BaseActivity() {
     private val networks: Array<out String> by lazy {
         resources.getStringArray(R.array.networks)
     }
-    private val tcpTypes: Array<out String> by lazy {
-        resources.getStringArray(R.array.header_type_tcp)
-    }
-    private val kcpAndQuicTypes: Array<out String> by lazy {
-        resources.getStringArray(R.array.header_type_kcp_and_quic)
-    }
-    private val grpcModes: Array<out String> by lazy {
-        resources.getStringArray(R.array.mode_type_grpc)
+    private val headertypes: Array<out String> by lazy {
+        resources.getStringArray(R.array.headertypes)
     }
     private val streamSecuritys: Array<out String> by lazy {
         resources.getStringArray(R.array.streamsecurityxs)
@@ -78,252 +65,75 @@ class ServerActivity : BaseActivity() {
     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)
         title = getString(R.string.title_server)
 
         val config = MmkvManager.decodeServerConfig(editGuid)
-        when (config?.configType ?: createConfigType) {
+        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
-            }
+//            EConfigType.VLESS -> setContentView(R.layout.activity_server_vless)
+//            EConfigType.TROJAN -> setContentView(R.layout.activity_server_trojan)
         }
         if (config != null) {
             bindingServer(config)
         } else {
             clearServer()
         }
+        supportActionBar?.setDisplayHomeAsUpEnabled(true)
     }
 
     /**
-     * binding selected server config
+     * bingding seleced server config
      */
     private fun bindingServer(config: ServerConfig): Boolean {
         val outbound = config.getProxyOutbound() ?: return false
+        val streamSetting = config.outboundBean?.streamSettings ?: return false
 
         et_remarks.text = Utils.getEditable(config.remarks)
         et_address.text = Utils.getEditable(outbound.getServerAddress().orEmpty())
-        et_port.text =
-            Utils.getEditable(outbound.getServerPort()?.toString() ?: DEFAULT_PORT.toString())
+        et_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())
+        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())
+            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()
-            )
+            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())
+                //sp_flow.setSelection(flow)
             }
         }
-        val securityEncryptions =
-            if (config.configType == EConfigType.SHADOWSOCKS) shadowsocksSecuritys else securitys
-        val security =
-            Utils.arrayFind(securityEncryptions, outbound.getSecurityEncryption().orEmpty())
+        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 streamSetting = config.outboundBean?.streamSettings ?: return true
         val streamSecurity = Utils.arrayFind(streamSecuritys, streamSetting.security)
         if (streamSecurity >= 0) {
             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)
+            (streamSetting.tlsSettings?: streamSetting.xtlsSettings)?.let { tlsSetting ->
+                val allowinsecure = Utils.arrayFind(allowinsecures, tlsSetting.allowInsecure.toString())
+                if (allowinsecure >= 0) {
+                    sp_allow_insecure?.setSelection(allowinsecure)
                 }
-                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
+                et_request_host.text = Utils.getEditable(tlsSetting.serverName)
             }
         }
         val network = Utils.arrayFind(networks, streamSetting.network)
         if (network >= 0) {
             sp_network?.setSelection(network)
         }
+        outbound.getTransportSettingDetails()?.let { transportDetails ->
+            sp_header_type.setSelection(Utils.arrayFind(headertypes, transportDetails[0]))
+            et_request_host.text = Utils.getEditable(transportDetails[1])
+            et_path.text = Utils.getEditable(transportDetails[2])
+        }
         return true
     }
 
@@ -344,17 +154,9 @@ class ServerActivity : BaseActivity() {
         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)
+        //sp_flow?.setSelection(0)
         return true
     }
 
@@ -375,24 +177,13 @@ class ServerActivity : BaseActivity() {
             toast(R.string.server_lab_port)
             return false
         }
-        val config =
-            MmkvManager.decodeServerConfig(editGuid) ?: ServerConfig.create(createConfigType)
+        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)
-            }
+            toast(R.string.server_lab_id)
             return false
         }
-        sp_stream_security?.let {
-            if (config.configType == EConfigType.TROJAN && TextUtils.isEmpty(streamSecuritys[it.selectedItemPosition])) {
-                toast(R.string.server_lab_stream_security)
-                return false
-            }
-        }
         et_alterId?.let {
-            val alterId = Utils.parseInt(it.text.toString())
+            val alterId = Utils.parseInt(et_alterId.text.toString())
             if (alterId < 0) {
                 toast(R.string.server_lab_alterid)
                 return false
@@ -406,15 +197,8 @@ class ServerActivity : BaseActivity() {
         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!!
+            saveStreamSettings(it, config)
         }
 
         MmkvManager.encodeServerConfig(editGuid, config)
@@ -423,40 +207,36 @@ class ServerActivity : BaseActivity() {
         return true
     }
 
-    private fun saveVnext(
-        vnext: V2rayConfig.OutboundBean.OutSettingsBean.VnextBean,
-        port: Int,
-        config: ServerConfig
-    ) {
+    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]
+            vnext.users[0].alterId = Utils.parseInt(et_alterId.text.toString())
+            vnext.users[0].security = securitys[sp_security.selectedItemPosition]
         } else if (config.configType == EConfigType.VLESS) {
-            vnext.users[0].encryption = et_security?.text.toString().trim()
-            vnext.users[0].flow = flows[sp_flow?.selectedItemPosition ?: 0]
+            vnext.users[0].encryption = et_security.text.toString().trim()
+            if (streamSecuritys[sp_stream_security.selectedItemPosition] == XTLS) {
+//                vnext.users[0].flow = if (flows[sp_flow.selectedItemPosition].isBlank()) V2rayConfig.DEFAULT_FLOW
+//                else flows[sp_flow.selectedItemPosition]
+            } else {
+                vnext.users[0].flow = ""
+            }
         }
     }
 
-    private fun saveServers(
-        server: V2rayConfig.OutboundBean.OutSettingsBean.ServersBean,
-        port: Int,
-        config: ServerConfig
-    ) {
+    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]
+            server.method = shadowsocksSecuritys[sp_security.selectedItemPosition]
         } else if (config.configType == EConfigType.SOCKS) {
-            if (TextUtils.isEmpty(et_security?.text) && TextUtils.isEmpty(et_id.text)) {
+            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()
+                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)
             }
@@ -465,121 +245,50 @@ class ServerActivity : BaseActivity() {
         }
     }
 
-    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 {
-            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
-
+    private fun saveStreamSettings(streamSetting: V2rayConfig.OutboundBean.StreamSettingsBean, config: ServerConfig) {
+        val requestHost = et_request_host?.text.toString().trim()
+        val path = et_path?.text.toString().trim()
         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,
-                authority = requestHost,
+                if (sp_network != null) networks[sp_network.selectedItemPosition] else DEFAULT_NETWORK,
+                if (sp_header_type != null) headertypes[sp_header_type.selectedItemPosition] else "",
+                requestHost,
+                path,
+                path,
+                requestHost,
+                path
         )
-        if (sniField.isNotBlank()) {
-            sni = sniField
-        }
-        val allowInsecure = if (allowinsecures[allowInsecureField].isBlank()) {
-            settingsStorage?.decodeBool(PREF_ALLOW_INSECURE) ?: false
+        val allowInsecure = if (sp_allow_insecure == null || allowinsecures[sp_allow_insecure.selectedItemPosition].isBlank()) {
+            false//settingsStorage?.decodeBool(PREF_ALLOW_INSECURE) ?: false
         } else {
-            allowinsecures[allowInsecureField].toBoolean()
+            allowinsecures[sp_allow_insecure.selectedItemPosition].toBoolean()
         }
-
+        val defaultTls = if (config.configType == EConfigType.TROJAN) V2rayConfig.TLS else ""
         streamSetting.populateTlsSettings(
-            streamSecurity = streamSecuritys[streamSecurity],
-            allowInsecure = allowInsecure,
-            sni = sni,
-            fingerprint = uTlsItems[utlsIndex],
-            alpns = alpns[alpnIndex],
-            publicKey = publicKey,
-            shortId = shortId,
-            spiderX = spiderX
+                if (sp_stream_security != null) streamSecuritys[sp_stream_security.selectedItemPosition] else defaultTls,
+                allowInsecure,
+                sni
         )
     }
 
-    private fun transportTypes(network: String?): Array<out String> {
-        return when (network) {
-            "tcp" -> {
-                tcpTypes
-            }
-
-            "kcp", "quic" -> {
-                kcpAndQuicTypes
-            }
-
-            "grpc" -> {
-                grpcModes
-            }
-
-            else -> {
-                arrayOf("---")
-            }
-        }
-    }
-
     /**
      * save server config
      */
     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()
-                        }
-                        .setNegativeButton(android.R.string.no) { _, _ ->
-                            // do nothing
-                        }
-                        .show()
-                } else {
-                    MmkvManager.removeServer(editGuid)
-                    finish()
-                }
-            } else {
-                application.toast(R.string.toast_action_not_allowed)
-            }
+            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 {
+    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)
+        val delButton = menu?.findItem(R.id.del_config)
+        val saveButton = menu?.findItem(R.id.save_config)
 
         if (editGuid.isNotEmpty()) {
             if (isRunning) {
@@ -598,12 +307,10 @@ 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

@@ -1,30 +1,24 @@
 package com.v2ray.ang.ui
 
 import android.os.Bundle
+import android.support.v7.app.AlertDialog
 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.google.gson.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
+import kotlinx.android.synthetic.main.activity_server_custom_config.*
 
 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)
@@ -34,34 +28,24 @@ class ServerCustomConfigActivity : BaseActivity() {
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
-        binding = ActivityServerCustomConfigBinding.inflate(layoutInflater)
-        val view = binding.root
-        setContentView(view)
+        setContentView(R.layout.activity_server_custom_config)
         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()
         }
+        supportActionBar?.setDisplayHomeAsUpEnabled(true)
     }
 
     /**
      * bingding seleced server config
      */
     private fun bindingServer(config: ServerConfig): Boolean {
-        binding.etRemarks.text = Utils.getEditable(config.remarks)
-        val raw = serverRawStorage?.decodeString(editGuid)
-        if (raw.isNullOrBlank()) {
-            binding.editor.setTextContent(Utils.getEditable(config.fullConfig?.toPrettyPrinting().orEmpty()))
-        } else {
-            binding.editor.setTextContent(Utils.getEditable(raw))
-        }
+        et_remarks.text = Utils.getEditable(config.remarks)
+        tv_content.text = Utils.getEditable(config.fullConfig?.toPrettyPrinting().orEmpty())
         return true
     }
 
@@ -69,7 +53,7 @@ class ServerCustomConfigActivity : BaseActivity() {
      * clear or init server config
      */
     private fun clearServer(): Boolean {
-        binding.etRemarks.text = null
+        et_remarks.text = null
         return true
     }
 
@@ -77,25 +61,24 @@ class ServerCustomConfigActivity : BaseActivity() {
      * save server config
      */
     private fun saveServer(): Boolean {
-        if (TextUtils.isEmpty(binding.etRemarks.text.toString())) {
+        if (TextUtils.isEmpty(et_remarks.text.toString())) {
             toast(R.string.server_lab_remarks)
             return false
         }
 
         val v2rayConfig = try {
-            Gson().fromJson(binding.editor.text.toString(), V2rayConfig::class.java)
+            Gson().fromJson(tv_content.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()
+            toast(R.string.toast_malformed_josn)
             return false
         }
 
         val config = MmkvManager.decodeServerConfig(editGuid) ?: ServerConfig.create(EConfigType.CUSTOM)
-        config.remarks = v2rayConfig.remarks ?: binding.etRemarks.text.toString().trim()
+        config.remarks = et_remarks.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
@@ -111,18 +94,15 @@ class ServerCustomConfigActivity : BaseActivity() {
                         MmkvManager.removeServer(editGuid)
                         finish()
                     }
-                    .setNegativeButton(android.R.string.no) {_, _ ->
-                        // do nothing
-                    }
                     .show()
         }
         return true
     }
 
-    override fun onCreateOptionsMenu(menu: Menu): Boolean {
+    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)
+        val delButton = menu?.findItem(R.id.del_config)
+        val saveButton = menu?.findItem(R.id.save_config)
 
         if (editGuid.isNotEmpty()) {
             if (isRunning) {

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

@@ -1,30 +1,20 @@
 package com.v2ray.ang.ui
 
+import android.arch.lifecycle.ViewModelProviders
 import android.content.Intent
 import android.os.Bundle
-import android.text.TextUtils
+import android.support.v7.preference.*
 import android.view.View
-import androidx.activity.viewModels
-import androidx.preference.CheckBoxPreference
-import androidx.preference.EditTextPreference
-import androidx.preference.ListPreference
-import androidx.preference.Preference
-import androidx.preference.PreferenceFragmentCompat
-import androidx.work.ExistingPeriodicWorkPolicy
-import androidx.work.PeriodicWorkRequest
-import androidx.work.multiprocess.RemoteWorkManager
-import com.tencent.mmkv.MMKV
-import com.v2ray.ang.AngApplication
-import com.v2ray.ang.AppConfig
 import com.v2ray.ang.R
-import com.v2ray.ang.service.SubscriptionUpdater
-import com.v2ray.ang.util.MmkvManager
+import com.v2ray.ang.AppConfig
+import com.v2ray.ang.extension.toast
+import com.v2ray.ang.service.V2RayServiceManager
 import com.v2ray.ang.util.Utils
 import com.v2ray.ang.viewmodel.SettingsViewModel
-import java.util.concurrent.TimeUnit
 
 class SettingsActivity : BaseActivity() {
-    private val settingsViewModel: SettingsViewModel by viewModels()
+
+    private val settingsViewModel by lazy { ViewModelProviders.of(this).get(SettingsViewModel::class.java) }
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
@@ -32,333 +22,198 @@ class SettingsActivity : BaseActivity() {
 
         title = getString(R.string.title_settings)
 
+        supportActionBar?.setDisplayHomeAsUpEnabled(true)
+
         settingsViewModel.startListenPreferenceChange()
     }
 
     class SettingsFragment : PreferenceFragmentCompat() {
-        private val settingsStorage by lazy { MMKV.mmkvWithID(MmkvManager.ID_SETTING, MMKV.MULTI_PROCESS_MODE) }
+        private val perAppProxy by lazy { findPreference(AppConfig.PREF_PER_APP_PROXY) as CheckBoxPreference }
+        private val sppedEnabled by lazy { findPreference(AppConfig.PREF_SPEED_ENABLED) as CheckBoxPreference }
+        private val sniffingEnabled by lazy { findPreference(AppConfig.PREF_SNIFFING_ENABLED) as CheckBoxPreference }
+        private val proxySharing by lazy { findPreference(AppConfig.PREF_PROXY_SHARING) as CheckBoxPreference }
+        private val domainStrategy by lazy { findPreference(AppConfig.PREF_ROUTING_DOMAIN_STRATEGY) as ListPreference }
+        private val routingMode by lazy { findPreference(AppConfig.PREF_ROUTING_MODE) as ListPreference }
 
-        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 forwardIpv6 by lazy { findPreference(AppConfig.PREF_FORWARD_IPV6) as CheckBoxPreference }
+        private val enableLocalDns by lazy { findPreference(AppConfig.PREF_LOCAL_DNS_ENABLED) as CheckBoxPreference }
+        private val domesticDns by lazy { findPreference(AppConfig.PREF_DOMESTIC_DNS) as EditTextPreference }
+        private val remoteDns by lazy { findPreference(AppConfig.PREF_REMOTE_DNS) as EditTextPreference }
 
-        private val routingCustom by lazy { findPreference<Preference>(AppConfig.PREF_ROUTING_CUSTOM) }
+        //        val autoRestart by lazy { findPreference(PREF_AUTO_RESTART) as CheckBoxPreference }
 
-        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 socksPort by lazy { findPreference(PREF_SOCKS_PORT) as EditTextPreference }
+//        val httpPort by lazy { findPreference(PREF_HTTP_PORT) as EditTextPreference }
 
-        private val autoUpdateCheck by lazy { findPreference<CheckBoxPreference>(AppConfig.SUBSCRIPTION_AUTO_UPDATE) }
-        private val autoUpdateInterval by lazy { findPreference<EditTextPreference>(AppConfig.SUBSCRIPTION_AUTO_UPDATE_INTERVAL) }
+        private val routingCustom: Preference by lazy { findPreference(AppConfig.PREF_ROUTING_CUSTOM) }
+//        val donate: Preference by lazy { findPreference(PREF_DONATE) }
+        //        val licenses: Preference by lazy { findPreference(PREF_LICENSES) }
+//        val feedback: Preference by lazy { findPreference(PREF_FEEDBACK) }
+//        val tgGroup: Preference by lazy { findPreference(PREF_TG_GROUP) }
 
-        private val socksPort by lazy { findPreference<EditTextPreference>(AppConfig.PREF_SOCKS_PORT) }
-        private val httpPort by lazy { findPreference<EditTextPreference>(AppConfig.PREF_HTTP_PORT) }
-        private val remoteDns by lazy { findPreference<EditTextPreference>(AppConfig.PREF_REMOTE_DNS) }
-        private val domesticDns by lazy { findPreference<EditTextPreference>(AppConfig.PREF_DOMESTIC_DNS) }
-        private val delayTestUrl by lazy { findPreference<EditTextPreference>(AppConfig.PREF_DELAY_TEST_URL) }
-        private val mode by lazy { findPreference<ListPreference>(AppConfig.PREF_MODE) }
+        private val mode by lazy { findPreference(AppConfig.PREF_MODE) as ListPreference }
+
+        private fun restartProxy() {
+            Utils.stopVService(requireContext())
+            V2RayServiceManager.startV2Ray(requireContext())
+        }
+
+        private fun isRunning(): Boolean {
+            return false //TODO no point of adding logic now since Settings will be changed soon
+        }
 
         override fun onCreatePreferences(bundle: Bundle?, s: String?) {
             addPreferencesFromResource(R.xml.pref_settings)
 
-            perAppProxy?.setOnPreferenceClickListener {
+            perAppProxy.setOnPreferenceClickListener {
+                if (isRunning()) {
+                    Utils.stopVService(requireContext())
+                }
                 startActivity(Intent(activity, PerAppProxyActivity::class.java))
-                perAppProxy?.isChecked = true
-                false
-            }
-            localDns?.setOnPreferenceChangeListener { _, any ->
-                updateLocalDns(any as Boolean)
+                perAppProxy.isChecked = true
                 true
             }
-            localDnsPort?.setOnPreferenceChangeListener { _, any ->
-                val nval = any as String
-                localDnsPort?.summary =
-                    if (TextUtils.isEmpty(nval)) AppConfig.PORT_LOCAL_DNS else nval
+            sppedEnabled.setOnPreferenceClickListener {
+                if (isRunning())
+                    restartProxy()
                 true
             }
-            vpnDns?.setOnPreferenceChangeListener { _, any ->
-                vpnDns?.summary = any as String
+            sniffingEnabled.setOnPreferenceClickListener {
+                if (isRunning())
+                    restartProxy()
                 true
             }
 
-            routingCustom?.setOnPreferenceClickListener {
+            proxySharing.setOnPreferenceClickListener {
+                if (proxySharing.isChecked)
+                    activity?.toast(R.string.toast_warning_pref_proxysharing)
+                if (isRunning())
+                    restartProxy()
+                true
+            }
+
+            domainStrategy.setOnPreferenceChangeListener { _, _ ->
+                if (isRunning())
+                    restartProxy()
+                true
+            }
+            routingMode.setOnPreferenceChangeListener { _, _ ->
+                if (isRunning())
+                    restartProxy()
+                true
+            }
+
+            routingCustom.setOnPreferenceClickListener {
+                if (isRunning())
+                    Utils.stopVService(requireContext())
                 startActivity(Intent(activity, RoutingSettingsActivity::class.java))
                 false
             }
 
-            mux?.setOnPreferenceChangeListener { _, newValue ->
-                updateMux(newValue as Boolean)
-                true
-            }
-            muxConcurrency?.setOnPreferenceChangeListener { _, newValue ->
-                updateMuxConcurrency(newValue as String)
-                true
-            }
-            muxXudpConcurrency?.setOnPreferenceChangeListener { _, newValue ->
-                updateMuxXudpConcurrency(newValue as String)
+            forwardIpv6.setOnPreferenceClickListener {
+                if (isRunning())
+                    restartProxy()
                 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)
+            enableLocalDns.setOnPreferenceClickListener {
+                if (isRunning())
+                    restartProxy()
                 true
             }
 
-            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())
+            domesticDns.setOnPreferenceChangeListener { _, any ->
+                // domesticDns.summary = any as String
+                val nval = any as String
+                domesticDns.summary = if (nval == "") AppConfig.DNS_DIRECT else nval
+                if (isRunning())
+                    restartProxy()
                 true
             }
 
-            socksPort?.setOnPreferenceChangeListener { _, any ->
+            remoteDns.setOnPreferenceChangeListener { _, any ->
+                // remoteDns.summary = any as String
                 val nval = any as String
-                socksPort?.summary = if (TextUtils.isEmpty(nval)) AppConfig.PORT_SOCKS else nval
+                remoteDns.summary = if (nval == "") AppConfig.DNS_AGENT else nval
+                if (isRunning())
+                    restartProxy()
                 true
             }
-            httpPort?.setOnPreferenceChangeListener { _, any ->
-                val nval = any as String
-                httpPort?.summary = if (TextUtils.isEmpty(nval)) AppConfig.PORT_HTTP else nval
-                true
-            }
-            remoteDns?.setOnPreferenceChangeListener { _, any ->
-                val nval = any as String
-                remoteDns?.summary = if (nval == "") AppConfig.DNS_PROXY else nval
-                true
-            }
-            domesticDns?.setOnPreferenceChangeListener { _, any ->
-                val nval = any as String
-                domesticDns?.summary = if (nval == "") AppConfig.DNS_DIRECT else nval
-                true
-            }
-            delayTestUrl?.setOnPreferenceChangeListener { _, any ->
-                val nval = any as String
-                delayTestUrl?.summary = if (nval == "") AppConfig.DelayTestUrl else nval
-                true
-            }
-            mode?.setOnPreferenceChangeListener { _, newValue ->
-                updateMode(newValue.toString())
-                true
-            }
-            mode?.dialogLayoutResource = R.layout.preference_with_help_link
-            //loglevel.summary = "LogLevel"
 
+            mode.setOnPreferenceChangeListener { _, newValue ->
+                updatePerAppProxy(newValue.toString())
+                true
+            }
+            mode.dialogLayoutResource = R.layout.preference_with_help_link
+
+//            donate.onClick {
+//                startActivity<InappBuyActivity>()
+//            }
+
+//            licenses.onClick {
+//                val fragment = LicensesDialogFragment.Builder(act)
+//                        .setNotices(R.raw.licenses)
+//                        .setIncludeOwnLicense(false)
+//                        .build()
+//                fragment.show((act as AppCompatActivity).supportFragmentManager, null)
+//            }
+//
+//            feedback.onClick {
+//                Utils.openUri(activity, "https://github.com/2dust/v2rayNG/issues")
+//            }
+//            tgGroup.onClick {
+//                //                Utils.openUri(activity, "https://t.me/v2rayN")
+//                val intent = Intent(Intent.ACTION_VIEW, Uri.parse("tg:resolve?domain=v2rayN"))
+//                try {
+//                    startActivity(intent)
+//                } catch (e: Exception) {
+//                    e.printStackTrace()
+//                    toast(R.string.toast_tg_app_not_found)
+//                }
+//            }
+
+
+//            socksPort.setOnPreferenceChangeListener { preference, any ->
+//                socksPort.summary = any as String
+//                true
+//            }
+//            httpPort.setOnPreferenceChangeListener { preference, any ->
+//                httpPort.summary = any as String
+//                true
+//            }
         }
 
         override fun onStart() {
             super.onStart()
-            updateMode(settingsStorage.decodeString(AppConfig.PREF_MODE, "VPN"))
-            localDns?.isChecked = settingsStorage.getBoolean(AppConfig.PREF_LOCAL_DNS_ENABLED, false)
-            fakeDns?.isChecked = settingsStorage.getBoolean(AppConfig.PREF_FAKE_DNS_ENABLED, false)
-            localDnsPort?.summary = settingsStorage.decodeString(AppConfig.PREF_LOCAL_DNS_PORT, AppConfig.PORT_LOCAL_DNS)
-            vpnDns?.summary  = settingsStorage.decodeString(AppConfig.PREF_VPN_DNS, AppConfig.DNS_VPN)
+            val defaultSharedPreferences = PreferenceManager.getDefaultSharedPreferences(activity)
+            updatePerAppProxy(defaultSharedPreferences.getString(AppConfig.PREF_MODE, "VPN"))
+            remoteDns.summary = defaultSharedPreferences.getString(AppConfig.PREF_REMOTE_DNS, "")
+            domesticDns.summary = defaultSharedPreferences.getString(AppConfig.PREF_DOMESTIC_DNS, "")
 
-            updateMux(settingsStorage.getBoolean(AppConfig.PREF_MUX_ENABLED, false))
-            mux?.isChecked = settingsStorage.getBoolean(AppConfig.PREF_MUX_ENABLED, false)
-            muxConcurrency?.summary = settingsStorage.decodeString(AppConfig.PREF_MUX_CONCURRENCY, "8")
-            muxXudpConcurrency?.summary = settingsStorage.decodeString(AppConfig.PREF_MUX_XUDP_CONCURRENCY, "8")
-
-            updateFragment(settingsStorage.getBoolean(AppConfig.PREF_FRAGMENT_ENABLED, false))
-            fragment?.isChecked = settingsStorage.getBoolean(AppConfig.PREF_FRAGMENT_ENABLED, false)
-            fragmentPackets?.summary = settingsStorage.decodeString(AppConfig.PREF_FRAGMENT_PACKETS, "tlshello")
-            fragmentLength?.summary = settingsStorage.decodeString(AppConfig.PREF_FRAGMENT_LENGTH, "50-100")
-            fragmentInterval?.summary = settingsStorage.decodeString(AppConfig.PREF_FRAGMENT_INTERVAL, "10-20")
-
-            autoUpdateCheck?.isChecked = settingsStorage.getBoolean(AppConfig.SUBSCRIPTION_AUTO_UPDATE, false)
-            autoUpdateInterval?.summary = settingsStorage.decodeString(AppConfig.SUBSCRIPTION_AUTO_UPDATE_INTERVAL,AppConfig.SUBSCRIPTION_DEFAULT_UPDATE_INTERVAL)
-            autoUpdateInterval?.isEnabled = settingsStorage.getBoolean(AppConfig.SUBSCRIPTION_AUTO_UPDATE, false)
-
-            socksPort?.summary = settingsStorage.decodeString(AppConfig.PREF_SOCKS_PORT, AppConfig.PORT_SOCKS)
-            httpPort?.summary = settingsStorage.decodeString(AppConfig.PREF_HTTP_PORT, AppConfig.PORT_HTTP)
-            remoteDns?.summary = settingsStorage.decodeString(AppConfig.PREF_REMOTE_DNS, AppConfig.DNS_PROXY)
-            domesticDns?.summary = settingsStorage.decodeString(AppConfig.PREF_DOMESTIC_DNS, AppConfig.DNS_DIRECT)
-            delayTestUrl?.summary = settingsStorage.decodeString(AppConfig.PREF_DELAY_TEST_URL, AppConfig.DelayTestUrl)
-
-            initSharedPreference()
-        }
-
-        private fun initSharedPreference() {
-            listOf(
-                localDnsPort,
-                vpnDns,
-                muxConcurrency,
-                muxXudpConcurrency,
-                fragmentLength,
-                fragmentInterval,
-                autoUpdateInterval,
-                socksPort,
-                httpPort,
-                remoteDns,
-                domesticDns,
-                delayTestUrl
-            ).forEach { key ->
-                key?.text = key?.summary.toString()
+            if (remoteDns.summary == "") {
+                remoteDns.summary = AppConfig.DNS_AGENT
             }
 
-            listOf(
-                AppConfig.PREF_SNIFFING_ENABLED,
-            ).forEach { key ->
-                findPreference<CheckBoxPreference>(key)?.isChecked =
-                    settingsStorage.decodeBool(key, true)
+            if ( domesticDns.summary == "") {
+                domesticDns.summary = AppConfig.DNS_DIRECT
             }
 
-            listOf(
-                AppConfig.PREF_ROUTE_ONLY_ENABLED,
-                AppConfig.PREF_BYPASS_APPS,
-                AppConfig.PREF_SPEED_ENABLED,
-                AppConfig.PREF_CONFIRM_REMOVE,
-                AppConfig.PREF_START_SCAN_IMMEDIATE,
-                AppConfig.PREF_PREFER_IPV6,
-                AppConfig.PREF_PROXY_SHARING,
-                AppConfig.PREF_ALLOW_INSECURE
-            ).forEach { key ->
-                findPreference<CheckBoxPreference>(key)?.isChecked =
-                    settingsStorage.decodeBool(key, false)
-            }
-
-            listOf(
-                AppConfig.PREF_ROUTING_DOMAIN_STRATEGY,
-                AppConfig.PREF_ROUTING_MODE,
-                AppConfig.PREF_MUX_XUDP_QUIC,
-                AppConfig.PREF_FRAGMENT_PACKETS,
-                AppConfig.PREF_LANGUAGE,
-                AppConfig.PREF_UI_MODE_NIGHT,
-                AppConfig.PREF_LOGLEVEL,
-                AppConfig.PREF_MODE
-            ).forEach { key ->
-                if (settingsStorage.decodeString(key) != null) {
-                    findPreference<ListPreference>(key)?.value = settingsStorage.decodeString(key)
-                }
-            }
+//            socksPort.summary = defaultSharedPreferences.getString(PREF_SOCKS_PORT, "10808")
+//            lanconnPort.summary = defaultSharedPreferences.getString(PREF_HTTP_PORT, "")
         }
 
-        private fun updateMode(mode: String?) {
-            val vpn = mode == "VPN"
-            perAppProxy?.isEnabled = vpn
-            perAppProxy?.isChecked = settingsStorage.getBoolean(AppConfig.PREF_PER_APP_PROXY, false)
-            localDns?.isEnabled = vpn
-            fakeDns?.isEnabled = vpn
-            localDnsPort?.isEnabled = vpn
-            vpnDns?.isEnabled = vpn
-            if (vpn) {
-                updateLocalDns(
-                    settingsStorage.getBoolean(
-                        AppConfig.PREF_LOCAL_DNS_ENABLED,
-                        false
-                    )
-                )
-            }
-        }
-
-        private fun updateLocalDns(enabled: Boolean) {
-            fakeDns?.isEnabled = enabled
-            localDnsPort?.isEnabled = enabled
-            vpnDns?.isEnabled = !enabled
-        }
-
-        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) {
-            muxConcurrency?.isEnabled = enabled
-            muxXudpConcurrency?.isEnabled = enabled
-            muxXudpQuic?.isEnabled = enabled
-            if (enabled) {
-                updateMuxConcurrency(settingsStorage.decodeString(AppConfig.PREF_MUX_CONCURRENCY, "8"))
-                updateMuxXudpConcurrency(settingsStorage.decodeString(AppConfig.PREF_MUX_XUDP_CONCURRENCY, "8"))
-            }
-        }
-
-        private fun updateMuxConcurrency(value: String?) {
-            if (value == null) {
+        private fun updatePerAppProxy(mode: String?) {
+            if (mode == "VPN") {
+                perAppProxy.isEnabled = true
+                perAppProxy.isChecked = PreferenceManager.getDefaultSharedPreferences(activity)
+                        .getBoolean(AppConfig.PREF_PER_APP_PROXY, false)
             } else {
-                val concurrency = value.toIntOrNull() ?: 8
-                muxConcurrency?.summary = concurrency.toString()
+                perAppProxy.isEnabled = false
+                perAppProxy.isChecked = false
             }
         }
-
-        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) {
-            fragmentPackets?.isEnabled = enabled
-            fragmentLength?.isEnabled = enabled
-            fragmentInterval?.isEnabled = enabled
-            if (enabled) {
-                updateFragmentPackets(settingsStorage.decodeString(AppConfig.PREF_FRAGMENT_PACKETS, "tlshello"))
-                updateFragmentLength(settingsStorage.decodeString(AppConfig.PREF_FRAGMENT_LENGTH, "50-100"))
-                updateFragmentInterval(settingsStorage.decodeString(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) {

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

@@ -1,29 +1,20 @@
 package com.v2ray.ang.ui
 
 import android.os.Bundle
+import android.support.v7.app.AlertDialog
 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.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 java.util.concurrent.TimeUnit
+import kotlinx.android.synthetic.main.activity_sub_edit.*
 
 class SubEditActivity : BaseActivity() {
-    private lateinit var binding: ActivitySubEditBinding
 
     var del_config: MenuItem? = null
     var save_config: MenuItem? = null
@@ -33,9 +24,7 @@ class SubEditActivity : BaseActivity() {
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
-        binding = ActivitySubEditBinding.inflate(layoutInflater)
-        val view = binding.root
-        setContentView(view)
+        setContentView(R.layout.activity_sub_edit)
         title = getString(R.string.title_sub_setting)
 
         val json = subStorage?.decodeString(editSubId)
@@ -44,16 +33,16 @@ class SubEditActivity : BaseActivity() {
         } else {
             clearServer()
         }
+        supportActionBar?.setDisplayHomeAsUpEnabled(true)
     }
 
     /**
      * bingding seleced server config
      */
     private fun bindingServer(subItem: SubscriptionItem): Boolean {
-        binding.etRemarks.text = Utils.getEditable(subItem.remarks)
-        binding.etUrl.text = Utils.getEditable(subItem.url)
-        binding.chkEnable.isChecked = subItem.enabled
-        binding.autoUpdateCheck.isChecked = subItem.autoUpdate
+        et_remarks.text = Utils.getEditable(subItem.remarks)
+        et_url.text = Utils.getEditable(subItem.url)
+
         return true
     }
 
@@ -61,9 +50,9 @@ class SubEditActivity : BaseActivity() {
      * clear or init server config
      */
     private fun clearServer(): Boolean {
-        binding.etRemarks.text = null
-        binding.etUrl.text = null
-        binding.chkEnable.isChecked = true
+        et_remarks.text = null
+        et_url.text = null
+
         return true
     }
 
@@ -81,19 +70,17 @@ class SubEditActivity : BaseActivity() {
             subItem = SubscriptionItem()
         }
 
-        subItem.remarks = binding.etRemarks.text.toString()
-        subItem.url = binding.etUrl.text.toString()
-        subItem.enabled = binding.chkEnable.isChecked
-        subItem.autoUpdate = binding.autoUpdateCheck.isChecked
+        subItem.remarks = et_remarks.text.toString()
+        subItem.url = et_url.text.toString()
 
         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
+        }
 
         subStorage?.encode(subId, Gson().toJson(subItem))
         toast(R.string.toast_success)
@@ -111,18 +98,15 @@ class SubEditActivity : BaseActivity() {
                         MmkvManager.removeSubscription(editSubId)
                         finish()
                     }
-                    .setNegativeButton(android.R.string.no) {_, _ ->
-                        // do nothing
-                    }
                     .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 (editSubId.isEmpty()) {
             del_config?.isVisible = false
@@ -142,5 +126,4 @@ class SubEditActivity : BaseActivity() {
         }
         else -> super.onOptionsItemSelected(item)
     }
-
 }

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

@@ -1,32 +1,31 @@
 package com.v2ray.ang.ui
 
 import android.content.Intent
-import androidx.recyclerview.widget.LinearLayoutManager
 import android.view.Menu
 import android.view.MenuItem
 import com.v2ray.ang.R
+import kotlinx.android.synthetic.main.activity_sub_setting.*
 import android.os.Bundle
-import com.v2ray.ang.databinding.ActivitySubSettingBinding
+import android.support.v7.widget.LinearLayoutManager
 import com.v2ray.ang.dto.SubscriptionItem
 import com.v2ray.ang.util.MmkvManager
 
 class SubSettingActivity : BaseActivity() {
-    private lateinit var binding: ActivitySubSettingBinding
 
     var subscriptions:List<Pair<String, SubscriptionItem>> = listOf()
     private val adapter by lazy { SubSettingRecyclerAdapter(this) }
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
-        binding = ActivitySubSettingBinding.inflate(layoutInflater)
-        val view = binding.root
-        setContentView(view)
+        setContentView(R.layout.activity_sub_setting)
 
         title = getString(R.string.title_sub_setting)
 
-        binding.recyclerView.setHasFixedSize(true)
-        binding.recyclerView.layoutManager = LinearLayoutManager(this)
-        binding.recyclerView.adapter = adapter
+        recycler_view.setHasFixedSize(true)
+        recycler_view.layoutManager = LinearLayoutManager(this)
+        recycler_view.adapter = adapter
+
+        supportActionBar?.setDisplayHomeAsUpEnabled(true)
     }
 
     override fun onResume() {
@@ -35,10 +34,10 @@ class SubSettingActivity : BaseActivity() {
         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)
     }

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

@@ -2,102 +2,46 @@ package com.v2ray.ang.ui
 
 import android.content.Intent
 import android.graphics.Color
-import android.text.TextUtils
+import android.support.v7.widget.RecyclerView
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
-import androidx.appcompat.app.AlertDialog
-import androidx.recyclerview.widget.RecyclerView
-import com.google.gson.Gson
-import com.tencent.mmkv.MMKV
 import com.v2ray.ang.R
-import com.v2ray.ang.databinding.ItemQrcodeBinding
-import com.v2ray.ang.databinding.ItemRecyclerSubSettingBinding
-import com.v2ray.ang.extension.toast
-import com.v2ray.ang.util.MmkvManager
-import com.v2ray.ang.util.QRCodeDecoder
-import com.v2ray.ang.util.Utils
+import kotlinx.android.synthetic.main.item_recycler_sub_setting.view.*
 
-class SubSettingRecyclerAdapter(val activity: SubSettingActivity) :
-    RecyclerView.Adapter<SubSettingRecyclerAdapter.MainViewHolder>() {
+class SubSettingRecyclerAdapter(val activity: SubSettingActivity) : RecyclerView.Adapter<SubSettingRecyclerAdapter.BaseViewHolder>() {
 
     private var mActivity: SubSettingActivity = activity
-    private val subStorage by lazy { MMKV.mmkvWithID(MmkvManager.ID_SUB, MMKV.MULTI_PROCESS_MODE) }
-
-    private val share_method: Array<out String> by lazy {
-        mActivity.resources.getStringArray(R.array.share_sub_method)
-    }
 
     override fun getItemCount() = mActivity.subscriptions.size
 
-    override fun onBindViewHolder(holder: MainViewHolder, position: Int) {
-        val subId = mActivity.subscriptions[position].first
-        val subItem = mActivity.subscriptions[position].second
-        holder.itemSubSettingBinding.tvName.text = subItem.remarks
-        holder.itemSubSettingBinding.tvUrl.text = subItem.url
-        if (subItem.enabled) {
-            holder.itemSubSettingBinding.chkEnable.setBackgroundResource(R.color.colorAccent)
-        } else {
-            holder.itemSubSettingBinding.chkEnable.setBackgroundResource(0)
-        }
-        holder.itemView.setBackgroundColor(Color.TRANSPARENT)
+    override fun onBindViewHolder(holder: BaseViewHolder, position: Int) {
+        if (holder is MainViewHolder) {
+            val subId = mActivity.subscriptions[position].first
+            val subItem = mActivity.subscriptions[position].second
+            holder.name.text = subItem.remarks
+            holder.url.text = subItem.url
+            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()
+            holder.layout_edit.setOnClickListener {
+                mActivity.startActivity(Intent(mActivity, SubEditActivity::class.java)
+                        .putExtra("subId", subId)
+                )
             }
         }
     }
 
-    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): MainViewHolder {
-        return MainViewHolder(
-            ItemRecyclerSubSettingBinding.inflate(
-                LayoutInflater.from(parent.context),
-                parent,
-                false
-            )
-        )
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): BaseViewHolder {
+        return MainViewHolder(LayoutInflater.from(parent.context)
+                .inflate(R.layout.item_recycler_sub_setting, parent, false))
+    }
+
+    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!!
     }
 
-    class MainViewHolder(val itemSubSettingBinding: ItemRecyclerSubSettingBinding) :
-        RecyclerView.ViewHolder(itemSubSettingBinding.root)
 }

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

@@ -1,6 +1,6 @@
 package com.v2ray.ang.ui
 
-import androidx.appcompat.app.AppCompatActivity
+import android.app.Activity
 import android.os.Bundle
 import android.view.View
 import android.widget.ArrayAdapter
@@ -11,14 +11,13 @@ import android.content.Intent
 import android.text.TextUtils
 import android.view.Menu
 import android.view.MenuItem
+import com.google.zxing.WriterException
 import com.tencent.mmkv.MMKV
 import com.v2ray.ang.AppConfig
-import com.v2ray.ang.databinding.ActivityTaskerBinding
 import com.v2ray.ang.util.MmkvManager
+import kotlinx.android.synthetic.main.activity_tasker.*
 
 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()
@@ -27,9 +26,7 @@ class TaskerActivity : BaseActivity() {
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
-        binding = ActivityTaskerBinding.inflate(layoutInflater)
-        val view = binding.root
-        setContentView(view)
+        setContentView(R.layout.activity_tasker)
 
         //add def value
         lstData.add("Default")
@@ -58,13 +55,13 @@ class TaskerActivity : BaseActivity() {
             if (switch == null || TextUtils.isEmpty(guid)) {
                 return
             } else {
-                binding.switchStartService.isChecked = switch
+                switch_start_service.isChecked = switch
                 val pos = lstGuid.indexOf(guid.toString())
                 if (pos >= 0) {
                     listview?.setItemChecked(pos, true)
                 }
             }
-        } catch (e: Exception) {
+        } catch (e: WriterException) {
             e.printStackTrace()
 
         }
@@ -77,12 +74,12 @@ class TaskerActivity : BaseActivity() {
         }
 
         val extraBundle = Bundle()
-        extraBundle.putBoolean(AppConfig.TASKER_EXTRA_BUNDLE_SWITCH, binding.switchStartService.isChecked)
+        extraBundle.putBoolean(AppConfig.TASKER_EXTRA_BUNDLE_SWITCH, switch_start_service.isChecked)
         extraBundle.putString(AppConfig.TASKER_EXTRA_BUNDLE_GUID, lstGuid[position])
         val intent = Intent()
 
         val remarks = lstData[position]
-        val blurb = if (binding.switchStartService.isChecked) {
+        val blurb = if (switch_start_service.isChecked) {
             "Start $remarks"
         } else {
             "Stop $remarks"
@@ -90,13 +87,13 @@ class TaskerActivity : BaseActivity() {
 
         intent.putExtra(AppConfig.TASKER_EXTRA_BUNDLE, extraBundle)
         intent.putExtra(AppConfig.TASKER_EXTRA_STRING_BLURB, blurb)
-        setResult(AppCompatActivity.RESULT_OK, intent)
+        setResult(Activity.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)
     }
@@ -113,4 +110,3 @@ class TaskerActivity : BaseActivity() {
     }
 
 }
-