Optimize startTun performance

Optimize the display of different text scale

Optimize windows setup experience

.github/workflows/build.yaml

@@ -16,20 +16,20 @@ jobs:
           - platform: android
             os: ubuntu-latest
           - platform: windows
-            os: Windows-2022
+            os: windows-latest
             arch: amd64
           - platform: linux
-            os: ubuntu-22.04
+            os: ubuntu-latest
             arch: amd64
           - platform: macos
-            os: macos-15-intel
+            os: macos-13
             arch: amd64
           - platform: macos
             os: macos-latest
             arch: arm64
-          #          - platform: windows
-          #            os: windows-11-arm
-          #            arch: arm64
+          - platform: windows
+            os: windows-11-arm
+            arch: arm64
           - platform: linux
             os: ubuntu-24.04-arm
             arch: arm64
@@ -52,7 +52,6 @@ jobs:
         if: startsWith(matrix.platform,'android')
         run: |
           echo "${{ secrets.KEYSTORE }}" | base64 --decode > android/app/keystore.jks
-          echo "${{ secrets.SERVICE_JSON }}" | base64 --decode > android/app/google-services.json
           echo "keyAlias=${{ secrets.KEY_ALIAS }}" >> android/local.properties
           echo "storePassword=${{ secrets.STORE_PASSWORD }}" >> android/local.properties
           echo "keyPassword=${{ secrets.KEY_PASSWORD }}" >> android/local.properties
@@ -65,24 +64,13 @@ jobs:
             core/go.sum
 
       - name: Setup Flutter
-        if: ${{ !(startsWith(matrix.os, 'windows-11-arm') || startsWith(matrix.os, 'ubuntu-24.04-arm')) }}
         uses: subosito/flutter-action@v2
         with:
-          channel: stable
-          flutter-version: 3.35.7
-          cache: true
-      - name: Setup Flutter With Other
-        if: startsWith(matrix.os, 'windows-11-arm') || startsWith(matrix.os, 'ubuntu-24.04-arm')
-        uses: subosito/flutter-action@v2
-        with:
-          channel: master
-          flutter-version: 3.35.7
+          channel: ${{ (startsWith(matrix.os, 'windows-11-arm') || startsWith(matrix.os, 'ubuntu-24.04-arm')) && 'master' || 'stable' }}
           cache: true
 
       - name: Get Flutter Dependency
-        run: |
-          flutter --version
-          flutter pub get
+        run: flutter pub get
 
       - name: Setup
         run: dart setup.dart ${{ matrix.platform }} ${{ matrix.arch && format('--arch {0}', matrix.arch) }} ${{ env.IS_STABLE == 'true' && '--env stable' || '' }}
@@ -107,26 +95,34 @@ jobs:
       - name: Generate
         if: ${{ env.IS_STABLE == 'true' }}
         run: |
-          last_ver=$(grep -m1 '^## ' CHANGELOG.md 2>/dev/null | sed 's/^## //')
-          
-          tags=($(git tag --merged HEAD --sort=-creatordate))
-          
-          temp="NEW_CHANGELOG.md" > "$temp"
-          
-          for i in "${!tags[@]}"; do
-              curr="${tags[i]}"
-              [[ "$curr" == "$last_ver" ]] && break
-          
-              prev="${tags[i+1]}"
-              range="${prev:+$prev..}$curr"
-          
-              echo -e "## $curr\n" >> "$temp"
-              git log --no-merges --pretty=format:"%B" "$range" | \
-              awk '!/Update changelog/ && NF {print "- " $0 "\n"}' >> "$temp"
+          tags=($(git tag --merged $(git rev-parse HEAD) --sort=-creatordate))
+          preTag=$(grep -oP '^## \K.*' CHANGELOG.md | head -n 1)
+          currentTag=""
+          for ((i = 0; i <= ${#tags[@]}; i++)); do
+            if (( i < ${#tags[@]} )); then
+              tag=${tags[$i]}
+            else
+              tag=""
+            fi
+            if [ -n "$currentTag" ]; then
+              if [ "$(echo -e "$currentTag\n$preTag" | sort -V | head -n 1)" == "$currentTag" ]; then
+                break
+              fi
+            fi
+            if [ -n "$currentTag" ]; then
+              echo "## $currentTag" >> NEW_CHANGELOG.md
+              echo "" >> NEW_CHANGELOG.md
+              if [ -n "$tag" ]; then
+                git log --pretty=format:"%B" "$tag..$currentTag" | awk 'NF {print "- " $0} !NF {print ""}' >> NEW_CHANGELOG.md
+              else
+                git log --pretty=format:"%B" "$currentTag" | awk 'NF {print "- " $0} !NF {print ""}' >> NEW_CHANGELOG.md
+              fi
+              echo "" >> NEW_CHANGELOG.md
+            fi
+            currentTag=$tag
           done
-          [ -f CHANGELOG.md ] && cat CHANGELOG.md >> "$temp"
-          
-          mv "$temp" CHANGELOG.md
+          cat CHANGELOG.md >> NEW_CHANGELOG.md
+          cat NEW_CHANGELOG.md > CHANGELOG.md
 
       - name: Commit
         if: ${{ env.IS_STABLE == 'true' }}
@@ -176,24 +172,31 @@ jobs:
 
       - name: Generate release.md
         run: |
-          tags=($(git tag --merged HEAD --sort=-creatordate))
-          preTag=$(curl -s "https://api.github.com/repos/chen08209/FlClash/releases/latest" | \
-          sed -nE 's/.*"tag_name": "([^"]+)".*/\1/p')
-          
-          [ -z "$preTag" ] && preTag=""
-          
-          out="release.md" > "$out"
-          
-          for i in "${!tags[@]}"; do
-            curr="${tags[i]}"
-            [[ "$curr" == "$preTag" ]] && break
-          
-            prev="${tags[i+1]}"
-            range="${prev:+$prev..}$curr"
-          
-            git log --no-merges --pretty=format:"%B" "$range" | \
-            awk '!/Update changelog/ && NF {print "- " $0 "\n"}' >> "$out"
+          tags=($(git tag --merged $(git rev-parse HEAD) --sort=-creatordate))
+          preTag=$(curl --silent "https://api.github.com/repos/chen08209/FlClash/releases/latest" | grep -Po '"tag_name": "\K.*?(?=")' || echo "")
+          currentTag=""
+          for ((i = 0; i <= ${#tags[@]}; i++)); do
+            if (( i < ${#tags[@]} )); then
+              tag=${tags[$i]}
+            else
+              tag=""
+            fi
+            if [ -n "$currentTag" ]; then
+              if [ "$(echo -e "$currentTag\n$preTag" | sort -V | head -n 1)" == "$currentTag" ]; then
+                break
+              fi
+            fi
+            if [ -n "$currentTag" ]; then
+              if [ -n "$tag" ]; then
+                git log --pretty=format:"%B" "$tag..$currentTag" | awk 'NF {print "- " $0} !NF {print ""}' >> release.md
+              else
+                git log --pretty=format:"%B" "$currentTag" | awk 'NF {print "- " $0} !NF {print ""}' >> release.md
+              fi
+              echo "" >> release.md
+            fi
+            currentTag=$tag
           done
+
       - name: Push to telegram
         env:
           TELEGRAM_BOT_TOKEN: ${{ secrets.TELEGRAM_BOT_TOKEN }}

.gitignore

@@ -45,19 +45,11 @@ app.*.map.json
 /android/app/debug
 /android/app/profile
 /android/app/release
-/android/**/.cxx
-/android/**/build
-/android/common/**/.**/
-/android/common/local.*
-/android/core/**/includes/
-/android/core/**/cmake-build-*/
-/android/core/**/jniLibs/
 
 
-#FlClash
+
+#libclash
 /libclash/
-/android/app/src/main/jniLibs/
-/services/helper/target
-/macos/**/Package.resolved
-devtools_options.yaml
 
+#jniLibs
+/android/app/src/main/jniLibs/

.gitmodules

@@ -6,9 +6,5 @@
 	path = plugins/flutter_distributor
 	url = git@github.com:chen08209/flutter_distributor.git
 	branch = FlClash
-[submodule "plugins/tray_manager"]
-	path = plugins/tray_manager
-	url = git@github.com:chen08209/tray_manager.git
-	branch = main
 
 

CHANGELOG.md

@@ -0,0 +1,838 @@
+## v0.8.82
+
+- Optimize android vpn performance
+
+- Add custom primary color and color scheme
+
+- Add linux nad windows arm release
+
+- Optimize requests and logs page
+
+- Fix map input page delete issues
+
+- Update changelog
+
+## v0.8.81
+
+- Add rule override
+
+- Update core
+
+- Optimize more details
+
+- Update changelog
+
+## v0.8.80
+
+- Optimize dashboard performance
+
+- Fix some issues
+
+- Fix unselected proxy group delay issues
+
+- Fix asn url issues
+
+- Update changelog
+
+## v0.8.79
+
+- Fix tab delay view issues
+
+- Fix tray action issues
+
+- Fix get profile redirect client ua issues
+
+- Fix proxy card delay view issues
+
+- Add Russian, Japanese adaptation
+
+- Fix some issues
+
+- Update changelog
+
+## v0.8.78
+
+- Fix list form input view issues
+
+- Fix traffic view issues
+
+- Update changelog
+
+## v0.8.77
+
+- Optimize performance
+
+- Update core
+
+- Optimize core stability
+
+- Fix linux tun authority check error
+
+- Fix some issues
+
+- Fix scroll physics error
+
+- Update changelog
+
+## v0.8.75
+
+- Add windows storage corruption detection
+
+- Fix core crash caused by windows resource manager restart
+
+- Optimize logs, requests, access to pages
+
+- Fix macos bypass domain issues
+
+- Update changelog
+
+## v0.8.74
+
+- Fix some issues
+
+- Update changelog
+
+## v0.8.73
+
+- Update popup menu
+
+- Add file editor
+
+- Fix android service issues
+
+- Optimize desktop background performance
+
+- Optimize android main process performance
+
+- Optimize delay test
+
+- Optimize vpn protect
+
+- Update changelog
+
+## v0.8.72
+
+- Update core
+
+- Fix some issues
+
+- Update changelog
+
+## v0.8.71
+
+- Remake dashboard
+
+- Optimize theme
+
+- Optimize more details
+
+- Update flutter version
+
+- Update changelog
+
+## v0.8.70
+
+- Support better window position memory
+
+- Add windows arm64 and linux arm64 build script
+
+- Optimize some details
+
+## v0.8.69
+
+- Remake desktop
+
+- Optimize change proxy
+
+- Optimize network check
+
+- Fix fallback issues
+
+- Optimize lots of details
+
+- Update change.yaml
+
+- Fix android tile issues
+
+- Fix windows tray issues
+
+- Support setting bypassDomain
+
+- Update flutter version
+
+- Fix android service issues
+
+- Fix macos dock exit button issues
+
+- Add route address setting
+
+- Optimize provider view
+
+- Update changelog
+
+- Update CHANGELOG.md
+
+## v0.8.67
+
+- Add android shortcuts
+
+- Fix init params issues
+
+- Fix dynamic color issues
+
+- Optimize navigator animate
+
+- Optimize window init
+
+- Optimize fab
+
+- Optimize save
+
+## v0.8.66
+
+- Fix the collapse issues
+
+- Add fontFamily options
+
+## v0.8.65
+
+- Update core version
+
+- Update flutter version
+
+- Optimize ip check
+
+- Optimize url-test
+
+## v0.8.64
+
+- Update release message
+
+- Init auto gen changelog
+
+- Fix windows tray issues
+
+- Fix urltest issues
+
+- Add auto changelog
+
+- Fix windows admin auto launch issues
+
+- Add android vpn options
+
+- Support proxies icon configuration
+
+- Optimize android immersion display
+
+- Fix some issues
+
+- Optimize ip detection
+
+- Support android vpn ipv6 inbound switch
+
+- Support log export
+
+- Optimize more details
+
+- Fix android system dns issues
+
+- Optimize dns default option
+
+- Fix some issues
+
+- Update readme
+
+## v0.8.60
+
+- Fix build error2
+
+- Fix build error
+
+- Support desktop hotkey
+
+- Support android ipv6 inbound
+
+- Support android system dns
+
+- fix some bugs
+
+## v0.8.59
+
+- Fix delete profile error
+
+## v0.8.58
+
+- Fix submit error 2
+
+- Fix submit error
+
+- Optimize DNS strategy
+
+- Fix the problem that the tray is not displayed in some cases
+
+- Optimize tray
+
+- Update core
+
+- Fix some error
+
+## v0.8.57
+
+- Fix tun update issues
+
+- Add DNS override
+- Fixed some bugs
+- Optimize more detail
+
+- Add Hosts override
+
+## v0.8.56
+
+- fix android tip error
+- fix windows auto launch error
+
+## v0.8.55
+
+- Fix windows tray issues
+
+- Optimize windows logic
+
+- Optimize app logic
+
+- Support windows administrator auto launch
+
+- Support android close vpn
+
+## v0.8.53
+
+- Change flutter version
+
+- Support profiles sort
+
+- Support windows country flags display
+
+- Optimize proxies page and profiles page columns
+
+## v0.8.52
+
+- Update flutter version
+
+- Update version
+
+- Update timeout time
+
+- Update access control page
+
+- Fix bug
+
+## v0.8.51
+
+- Optimize provider page
+
+- Optimize delay test
+
+- Support local backup and recovery
+
+- Fix android tile service issues
+
+## v0.8.49
+
+- Fix linux core build error
+
+- Add proxy-only traffic statistics
+
+- Update core
+
+- Optimize more details
+
+- Merge pull request #140 from txyyh/main
+
+- 添加自建 F-Droid 仓库相关 workflow
+- Rename readme fingerprint
+
+- Rename workflow deploy repo name
+
+- Add download guide to README
+
+- Add push release files to fdroid-repo
+
+## v0.8.48
+
+- Optimize proxies page
+
+- Fix ua issues
+
+- Optimize more details
+
+## v0.8.47
+
+- Fix windows build error
+
+## v0.8.46
+
+- Update app icon
+
+- Fix desktop backup error
+
+- Optimize request ua
+
+- Change android icon
+
+- Optimize dashboard
+
+## v0.8.44
+
+- Remove request validate certificate
+
+- Sync core
+
+## v0.8.43
+
+- Fix windows error
+
+## v0.8.42
+
+- Fix setup.dart error
+
+- Fix android system proxy not effective
+
+- Add macos arm64
+
+## v0.8.41
+
+- Optimize proxies page
+
+- Support mouse drag scroll
+
+- Adjust desktop ui
+
+- Revert "Fix android vpn issues"
+
+- This reverts commit 891977408e6938e2acd74e9b9adb959c48c79988.
+
+## v0.8.40
+
+- Fix android vpn issues
+
+- Fix android vpn issues
+
+- Rollback partial modification
+
+## v0.8.39
+
+- Fix the problem that ui can't be synchronized when android vpn is occupied by an external
+
+- Override default socksPort,port
+
+## v0.8.38
+
+- Fix fab issues
+
+## v0.8.37
+
+- Update version
+
+- Fix the problem that vpn cannot be started in some cases
+
+- Fix the problem that geodata url does not take effect
+
+## v0.8.36
+
+- Update ua
+
+- Fix change outbound mode without check ip issues
+
+- Separate android ui and vpn
+
+- Fix url validate issues 2
+
+- Add android hidden from the recent task
+
+- Add geoip file
+
+- Support modify geoData URL
+
+## v0.8.35
+
+- Fix url validate issues
+
+- Fix check ip performance problem
+
+- Optimize resources page
+
+## v0.8.34
+
+- Add ua selector
+
+- Support modify test url
+
+- Optimize android proxy
+
+- Fix the error that async proxy provider could not selected the proxy
+
+## v0.8.33
+
+- Fix android proxy error
+
+- Fix submit error
+
+- Add windows tun
+
+- Optimize android proxy
+
+- Optimize change profile
+
+- Update application ua
+
+- Optimize delay test
+
+## v0.8.32
+
+- Fix android repeated request notification issues
+
+## v0.8.31
+
+- Fix memory overflow issues
+
+## v0.8.30
+
+- Optimize proxies expansion panel 2
+
+- Fix android scan qrcode error
+
+## v0.8.29
+
+- Optimize proxies expansion panel
+
+- Fix text error
+
+## v0.8.28
+
+- Optimize proxy
+
+- Optimize delayed sorting performance
+
+- Add expansion panel proxies page
+
+- Support to adjust the proxy card size
+
+- Support to adjust proxies columns number
+
+- Fix autoRun show issues
+
+- Fix Android 10 issues
+
+- Optimize ip show
+
+## v0.8.26
+
+- Add intranet IP display
+
+- Add connections page
+
+- Add search in connections, requests
+
+- Add keyword search in connections, requests, logs
+
+- Add basic viewing editing capabilities
+
+- Optimize update profile
+
+## v0.8.25
+
+- Update version
+
+- Fix the problem of excessive memory usage in traffic usage.
+
+- Add lightBlue theme color
+
+- Fix start unable to update profile issues
+
+- Fix flashback caused by process
+
+## v0.8.23
+
+- Add build version
+
+- Optimize quick start
+
+- Update system default option
+
+## v0.8.22
+
+- Update build.yml
+
+- Fix android vpn close issues
+
+- Add requests page
+
+- Fix checkUpdate dark mode style error
+
+- Fix quickStart error open app
+
+- Add memory proxies tab index
+
+- Support hidden group
+
+- Optimize logs
+
+- Fix externalController hot load error
+
+## v0.8.21
+
+- Add tcp concurrent switch
+
+- Add system proxy switch
+
+- Add geodata loader switch
+
+- Add external controller switch
+
+- Add auto gc on trim memory
+
+- Fix android notification error
+
+## v0.8.20
+
+- Fix ipv6 error
+
+- Fix android udp direct error
+
+- Add ipv6 switch
+
+- Add access all selected button
+
+- Remove android low version splash
+
+## v0.8.19
+
+- Update version
+
+- Add allowBypass
+
+- Fix Android only pick .text file issues
+
+## v0.8.18
+
+- Fix search issues
+
+## v0.8.17
+
+- Fix LoadBalance, Relay load error
+
+- Fix build.yml4
+
+- Fix build.yml3
+
+- Fix build.yml2
+
+- Fix build.yml
+
+- Add search function at access control
+
+- Fix the issues with the profile add button to cover the edit button
+
+- Adapt LoadBalance and Relay
+
+- Add arm
+
+- Fix android notification icon error
+
+## v0.8.16
+
+- Add one-click update all profiles
+- Add expire show
+
+## v0.8.15
+
+- Temp remove tun mode
+
+- Remove macos in workflow
+
+- Change go version
+
+## v0.8.14
+
+- Update Version
+
+- Fix tun unable to open
+
+## v0.8.13
+
+- Optimize delay test2
+
+- Optimize delay test
+
+- Add check ip
+
+- add check ip request
+
+## v0.8.12
+
+- Fix the problem that the download of remote resources failed after GeodataMode was turned on, which caused the
+  application to flash back.
+
+- Fix edit profile error
+
+- Fix quickStart change proxy error
+
+- Fix core version
+
+## v0.8.10
+
+- Fix core version
+
+## v0.8.9
+
+- Update file_picker
+
+- Add resources page
+
+- Optimize more detail
+
+- Add access selected sorted
+
+- Fix notification duplicate creation issue
+
+- Fix AccessControl click issue
+
+## v0.8.7
+
+- Fix Workflow
+
+- Fix Linux unable to open
+
+- Update README.md 3
+
+- Create LICENSE
+- Update README.md 2
+
+- Update README.md
+
+- Optimize workFlow
+
+## v0.8.6
+
+- optimize checkUpdate
+
+## v0.8.5
+
+- Fix submit error
+
+## v0.8.4
+
+- add WebDAV
+
+- add Auto check updates
+
+- Optimize more details
+
+- optimize delayTest
+
+## v0.8.2
+
+- upgrade flutter version
+
+## v0.8.1
+
+- Update kernel
+- Add import profile via QR code image
+
+## v0.8.0
+
+- Add compatibility mode and adapt clash scheme.
+
+## v0.7.14
+
+- update Version
+
+- Reconstruction application proxy logic
+
+## v0.7.13
+
+- Fix Tab destroy error
+
+## v0.7.12
+
+- Optimize repeat healthcheck
+
+## v0.7.11
+
+- Optimize Direct mode ui
+
+## v0.7.10
+
+- Optimize Healthcheck
+
+- Remove proxies position animation, improve performance
+- Add Telegram Link
+
+- Update healthcheck policy
+
+- New Check URLTest
+
+- Fix the problem of invalid auto-selection
+
+## v0.7.8
+
+- New Async UpdateConfig
+
+- add changeProfileDebounce
+
+- Update Workflow
+
+- Fix ChangeProfile block
+
+- Fix Release Message Error
+
+## v0.7.7
+
+- Update Selector 2
+
+## v0.7.6
+
+- Update Version
+
+- Fix Proxies Select Error
+
+## v0.7.5
+
+- Fix the problem that the proxy group is empty in global mode.
+
+- Fix the problem that the proxy group is empty in global mode.
+
+## v0.7.4
+
+- Add ProxyProvider2
+
+## v0.7.3
+
+- Add ProxyProvider
+
+- Update Version
+
+- Update ProxyGroup Sort
+
+- Fix Android quickStart VpnService some problems
+
+## v0.7.1
+
+- Update version
+
+- Set Android notification low importance
+
+- Fix the issue that VpnService can't be closed correctly in special cases
+
+- Fix the problem that TileService is not destroyed correctly in some cases
+
+- Adjust tab animation defaults
+
+- Add Telegram in README_zh_CN.md
+
+- Add Telegram
+
+## v0.7.0
+
+- update mobile_scanner
+
+- Initial commit

README.md

@@ -41,8 +41,8 @@ on Mobile:
 ⚠️ Make sure to install the following dependencies before using them
 
    ```bash
-    sudo apt-get install libayatana-appindicator3-dev
-    sudo apt-get install libkeybinder-3.0-dev
+    sudo apt-get install appindicator3-0.1 libappindicator3-dev
+    sudo apt-get install keybinder-3.0
    ```
 
 ### Android
@@ -54,7 +54,7 @@ Support the following actions
     
     com.follow.clash.action.STOP
     
-    com.follow.clash.action.TOGGLE
+    com.follow.clash.action.CHANGE
    ```
 
 ## Download

README_zh_CN.md

@@ -41,8 +41,8 @@ on Mobile:
 ⚠️ 使用前请确保安装以下依赖
 
    ```bash
-    sudo apt-get install libayatana-appindicator3-dev
-    sudo apt-get install libkeybinder-3.0-dev
+    sudo apt-get install appindicator3-0.1 libappindicator3-dev
+    sudo apt-get install keybinder-3.0
    ```
 
 ### Android
@@ -54,7 +54,7 @@ on Mobile:
     
     com.follow.clash.action.STOP
     
-    com.follow.clash.action.TOGGLE
+    com.follow.clash.action.CHANGE
    ```
 
 ## Download

analysis_options.yaml

@@ -1,10 +1 @@
 include: package:flutter_lints/flutter.yaml
-analyzer:
-  exclude:
-    - lib/l10n/intl/**
-  errors:
-    invalid_annotation_target: ignore
-
-linter:
-  rules:
-    prefer_single_quotes: true

android/app/build.gradle

@@ -0,0 +1,97 @@
+plugins {
+    id "com.android.application"
+    id "kotlin-android"
+    id "dev.flutter.flutter-gradle-plugin"
+}
+
+def localProperties = new Properties()
+def localPropertiesFile = rootProject.file('local.properties')
+if (localPropertiesFile.exists()) {
+    localPropertiesFile.withReader('UTF-8') { reader ->
+        localProperties.load(reader)
+    }
+}
+
+
+def flutterVersionCode = localProperties.getProperty('flutter.versionCode')
+if (flutterVersionCode == null) {
+    flutterVersionCode = '1'
+}
+
+def flutterVersionName = localProperties.getProperty('flutter.versionName')
+if (flutterVersionName == null) {
+    flutterVersionName = '1.0'
+}
+
+def defStoreFile = file("keystore.jks")
+def defStorePassword = localProperties.getProperty('storePassword')
+def defKeyAlias = localProperties.getProperty('keyAlias')
+def defKeyPassword = localProperties.getProperty('keyPassword')
+def isRelease = defStoreFile.exists() && defStorePassword != null && defKeyAlias != null && defKeyPassword != null
+
+android {
+    namespace "com.follow.clash"
+    compileSdk 35
+    ndkVersion = "28.0.13004108"
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = '17'
+    }
+
+    sourceSets {
+        main.java.srcDirs += 'src/main/kotlin'
+    }
+    
+    signingConfigs {
+        if (isRelease) {
+            release {
+                storeFile defStoreFile
+                storePassword defStorePassword
+                keyAlias defKeyAlias
+                keyPassword defKeyPassword
+            }
+        }
+    }
+
+
+    defaultConfig {
+        applicationId "com.follow.clash"
+        minSdkVersion 21
+        targetSdkVersion 35
+        versionCode flutterVersionCode.toInteger()
+        versionName flutterVersionName
+    }
+
+    buildTypes {
+        debug {
+            minifyEnabled false
+            applicationIdSuffix '.debug'
+        }
+        release {
+            if (isRelease) {
+                signingConfig signingConfigs.release
+            } else {
+                signingConfig signingConfigs.debug
+            }
+            proguardFiles getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro"
+        }
+    }
+}
+
+flutter {
+    source '../..'
+}
+
+dependencies {
+    implementation project(":core")
+    implementation 'androidx.core:core-splashscreen:1.0.1'
+    implementation 'com.google.code.gson:gson:2.10.1'
+    implementation("com.android.tools.smali:smali-dexlib2:3.0.9") {
+        exclude group: "com.google.guava", module: "guava"
+    }
+}

android/app/build.gradle.kts

@@ -1,108 +0,0 @@
-import org.jetbrains.kotlin.gradle.dsl.JvmTarget
-import java.util.Properties
-
-plugins {
-    id("com.android.application")
-    id("kotlin-android")
-    id("dev.flutter.flutter-gradle-plugin")
-    id("com.google.gms.google-services")
-    id("com.google.firebase.crashlytics")
-}
-
-val localPropertiesFile = rootProject.file("local.properties")
-val localProperties = Properties().apply {
-    if (localPropertiesFile.exists()) {
-        localPropertiesFile.inputStream().use { load(it) }
-    }
-}
-
-val mStoreFile: File = file("keystore.jks")
-val mStorePassword: String? = localProperties.getProperty("storePassword")
-val mKeyAlias: String? = localProperties.getProperty("keyAlias")
-val mKeyPassword: String? = localProperties.getProperty("keyPassword")
-val isRelease =
-    mStoreFile.exists() && mStorePassword != null && mKeyAlias != null && mKeyPassword != null
-
-
-android {
-    namespace = "com.follow.clash"
-    compileSdk = libs.versions.compileSdk.get().toInt()
-    ndkVersion = libs.versions.ndkVersion.get()
-
-
-
-    compileOptions {
-        sourceCompatibility = JavaVersion.VERSION_17
-        targetCompatibility = JavaVersion.VERSION_17
-    }
-
-    defaultConfig {
-        applicationId = "com.follow.clash"
-        minSdk = flutter.minSdkVersion
-        targetSdk = libs.versions.targetSdk.get().toInt()
-        versionCode = flutter.versionCode
-        versionName = flutter.versionName
-    }
-
-    signingConfigs {
-        if (isRelease) {
-            create("release") {
-                storeFile = mStoreFile
-                storePassword = mStorePassword
-                keyAlias = mKeyAlias
-                keyPassword = mKeyPassword
-            }
-        }
-    }
-
-    packaging {
-        jniLibs {
-            useLegacyPackaging = true
-        }
-    }
-
-    buildTypes {
-        debug {
-            isMinifyEnabled = false
-            applicationIdSuffix = ".debug"
-        }
-
-        release {
-            isMinifyEnabled = true
-            isShrinkResources = true
-            signingConfig = if (isRelease) {
-                signingConfigs.getByName("release")
-            } else {
-                signingConfigs.getByName("debug")
-            }
-
-            proguardFiles(
-                getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro"
-            )
-        }
-    }
-}
-
-kotlin {
-    compilerOptions {
-        jvmTarget.set(JvmTarget.JVM_17)
-    }
-}
-
-flutter {
-    source = "../.."
-}
-
-
-dependencies {
-    implementation(project(":service"))
-    implementation(project(":common"))
-    implementation(libs.core.splashscreen)
-    implementation(libs.gson)
-    implementation(libs.smali.dexlib2) {
-        exclude(group = "com.google.guava", module = "guava")
-    }
-    implementation(platform(libs.firebase.bom))
-    implementation(libs.firebase.crashlytics.ndk)
-    implementation(libs.firebase.analytics)
-}

android/app/google-services.json

@@ -1,46 +0,0 @@
-{
-  "project_info": {
-    "project_number": "000000000000",
-    "project_id": "dev"
-  },
-  "client": [
-    {
-      "client_info": {
-        "mobilesdk_app_id": "1:000000000000:android:0000000000000000",
-        "android_client_info": {
-          "package_name": "com.follow.clash"
-        }
-      },
-      "oauth_client": [],
-      "api_key": [
-        {
-          "current_key": "0"
-        }
-      ],
-      "services": {
-        "appinvite_service": {
-          "other_platform_oauth_client": []
-        }
-      }
-    },
-    {
-      "client_info": {
-        "mobilesdk_app_id": "1:000000000000:android:0000000000000000",
-        "android_client_info": {
-          "package_name": "com.follow.clash.debug"
-        }
-      },
-      "oauth_client": [],
-      "api_key": [
-        {
-          "current_key": "0"
-        }
-      ],
-      "services": {
-        "appinvite_service": {
-          "other_platform_oauth_client": []
-        }
-      }
-    }
-  ]
-}

android/app/proguard-rules.pro

@@ -1,4 +1,2 @@
 
--keep class com.follow.clash.models.**{ *; }
-
--keep class com.follow.clash.service.models.**{ *; }
+-keep class com.follow.clash.models.**{ *; }

android/app/src/debug/AndroidManifest.xml

@@ -9,8 +9,9 @@
         android:label="FlClash Debug"
         tools:replace="android:label">
         <service
-            android:name=".TileService"
+            android:name=".services.FlClashTileService"
             android:label="FlClash Debug"
-            tools:replace="android:label" />
+            tools:replace="android:label"
+            tools:targetApi="24" />
     </application>
 </manifest>

android/app/src/main/AndroidManifest.xml

@@ -1,4 +1,3 @@
-<?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools">
 
@@ -8,42 +7,42 @@
     <uses-feature
         android:name="android.hardware.camera"
         android:required="false" />
-    <uses-feature
-        android:name="android.software.leanback"
-        android:required="false" />
 
     <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
     <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
     <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
+
     <uses-permission
         android:name="android.permission.QUERY_ALL_PACKAGES"
         tools:ignore="QueryAllPackagesPermission" />
-    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_SPECIAL_USE" />
-    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
 
     <application
-        android:name=".Application"
-        android:banner="@mipmap/ic_banner"
+        android:name=".FlClashApplication"
         android:hardwareAccelerated="true"
         android:icon="@mipmap/ic_launcher"
         android:label="FlClash">
         <activity
-            android:name=".MainActivity"
+            android:name="com.follow.clash.MainActivity"
             android:configChanges="orientation|keyboardHidden|keyboard|screenSize|smallestScreenSize|locale|layoutDirection|fontScale|screenLayout|density|uiMode"
             android:exported="true"
             android:hardwareAccelerated="true"
             android:launchMode="singleTop"
             android:theme="@style/LaunchTheme"
             android:windowSoftInputMode="adjustResize">
+            <!-- Specifies an Android theme to apply to this Activity as soon as
+                 the Android process has started. This theme is visible to the user
+                 while the Flutter UI initializes. After that, this theme continues
+                 to determine the Window background behind the Flutter UI. -->
             <meta-data
                 android:name="io.flutter.embedding.android.NormalTheme"
                 android:resource="@style/NormalTheme" />
 
             <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>
@@ -64,9 +63,12 @@
             </intent-filter>
         </activity>
 
+        <meta-data
+            android:name="io.flutter.embedding.android.EnableImpeller"
+            android:value="false" />
+
         <activity
             android:name=".TempActivity"
-            android:excludeFromRecents="true"
             android:exported="true"
             android:theme="@style/TransparentTheme">
             <intent-filter>
@@ -79,16 +81,17 @@
             </intent-filter>
             <intent-filter>
                 <category android:name="android.intent.category.DEFAULT" />
-                <action android:name="${applicationId}.action.TOGGLE" />
+                <action android:name="${applicationId}.action.CHANGE" />
             </intent-filter>
         </activity>
 
         <service
-            android:name=".TileService"
+            android:name=".services.FlClashTileService"
             android:exported="true"
-            android:icon="@drawable/ic"
+            android:icon="@drawable/ic_stat_name"
             android:label="FlClash"
-            android:permission="android.permission.BIND_QUICK_SETTINGS_TILE">
+            android:permission="android.permission.BIND_QUICK_SETTINGS_TILE"
+            tools:targetApi="n">
             <intent-filter>
                 <action android:name="android.service.quicksettings.action.QS_TILE" />
             </intent-filter>
@@ -97,16 +100,49 @@
                 android:value="true" />
         </service>
 
-        <receiver
-            android:name=".BroadcastReceiver"
-            android:enabled="true"
+        <provider
+            android:name=".FilesProvider"
+            android:authorities="${applicationId}.files"
             android:exported="true"
-            android:permission="${applicationId}.permission.RECEIVE_BROADCASTS">
+            android:grantUriPermissions="true"
+            android:permission="android.permission.MANAGE_DOCUMENTS"
+            android:process=":background">
             <intent-filter>
-                <action android:name="${applicationId}.intent.action.SERVICE_CREATED" />
-                <action android:name="${applicationId}.intent.action.SERVICE_DESTROYED" />
+                <action android:name="android.content.action.DOCUMENTS_PROVIDER" />
             </intent-filter>
-        </receiver>
+        </provider>
+
+        <provider
+            android:name="androidx.core.content.FileProvider"
+            android:authorities="${applicationId}.fileProvider"
+            android:exported="false"
+            android:grantUriPermissions="true">
+            <meta-data
+                android:name="android.support.FILE_PROVIDER_PATHS"
+                android:resource="@xml/file_paths" />
+        </provider>
+
+        <service
+            android:name=".services.FlClashVpnService"
+            android:exported="false"
+            android:foregroundServiceType="dataSync"
+            android:permission="android.permission.BIND_VPN_SERVICE">
+            <intent-filter>
+                <action android:name="android.net.VpnService" />
+            </intent-filter>
+            <property
+                android:name="android.app.PROPERTY_SPECIAL_USE_FGS_SUBTYPE"
+                android:value="vpn" />
+        </service>
+
+        <service
+            android:name=".services.FlClashService"
+            android:exported="false"
+            android:foregroundServiceType="dataSync">
+            <property
+                android:name="android.app.PROPERTY_SPECIAL_USE_FGS_SUBTYPE"
+                android:value="service" />
+        </service>
 
         <meta-data
             android:name="flutterEmbedding"

android/app/src/main/kotlin/com/follow/clash/Application.kt

@@ -1,13 +0,0 @@
-package com.follow.clash
-
-import android.app.Application
-import android.content.Context
-import com.follow.clash.common.GlobalState
-
-class Application : Application() {
-
-    override fun attachBaseContext(base: Context?) {
-        super.attachBaseContext(base)
-        GlobalState.init(this)
-    }
-}

android/app/src/main/kotlin/com/follow/clash/BroadcastReceiver.kt

@@ -1,29 +0,0 @@
-package com.follow.clash
-
-import android.content.BroadcastReceiver
-import android.content.Context
-import android.content.Intent
-import com.follow.clash.common.BroadcastAction
-import com.follow.clash.common.GlobalState
-import com.follow.clash.common.action
-import kotlinx.coroutines.launch
-
-class BroadcastReceiver : BroadcastReceiver() {
-    override fun onReceive(context: Context?, intent: Intent?) {
-        when (intent?.action) {
-            BroadcastAction.SERVICE_CREATED.action -> {
-                GlobalState.log("Receiver service created")
-                GlobalState.launch {
-                    State.handleStartServiceAction()
-                }
-            }
-
-            BroadcastAction.SERVICE_DESTROYED.action -> {
-                GlobalState.log("Receiver service destroyed")
-                GlobalState.launch {
-                    State.handleStopServiceAction()
-                }
-            }
-        }
-    }
-}

android/app/src/main/kotlin/com/follow/clash/Ext.kt

@@ -1,121 +0,0 @@
-package com.follow.clash
-
-import android.content.pm.PackageManager
-import android.graphics.Bitmap
-import android.graphics.drawable.Drawable
-import android.os.Build
-import android.os.Handler
-import android.os.Looper
-import androidx.core.graphics.drawable.toBitmap
-import com.follow.clash.common.GlobalState
-import io.flutter.embedding.engine.FlutterEngine
-import io.flutter.embedding.engine.plugins.FlutterPlugin
-import io.flutter.plugin.common.MethodChannel
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.suspendCancellableCoroutine
-import kotlinx.coroutines.withContext
-import java.io.File
-import java.io.FileOutputStream
-import java.util.concurrent.TimeUnit
-import kotlin.coroutines.resume
-
-private const val ICON_TTL_DAYS = 1L
-
-suspend fun PackageManager.getPackageIconPath(packageName: String): String =
-    withContext(Dispatchers.IO) {
-        val cacheDir = GlobalState.application.cacheDir
-        val iconDir = File(cacheDir, "icons").apply { mkdirs() }
-        return@withContext try {
-            val pkgInfo = getPackageInfo(packageName, 0)
-            val lastUpdateTime = pkgInfo.lastUpdateTime
-            val iconFile = File(iconDir, "${packageName}_${lastUpdateTime}.webp")
-            if (iconFile.exists() && !isExpired(iconFile)) {
-                return@withContext iconFile.absolutePath
-            }
-            iconDir.listFiles { f -> f.name.startsWith("${packageName}_") }?.forEach(File::delete)
-
-            val icon = getApplicationIcon(packageName)
-            saveDrawableToFile(icon, iconFile)
-            iconFile.absolutePath
-        } catch (_: Exception) {
-            val defaultIconFile = File(iconDir, "default_icon.webp")
-            if (!defaultIconFile.exists()) {
-                saveDrawableToFile(defaultActivityIcon, defaultIconFile)
-            }
-            defaultIconFile.absolutePath
-        }
-    }
-
-private suspend fun saveDrawableToFile(drawable: Drawable, file: File) {
-    val bitmap = withContext(Dispatchers.Default) {
-        drawable.toBitmap(width = 128, height = 128)
-    }
-    try {
-        val format = when {
-            Build.VERSION.SDK_INT >= Build.VERSION_CODES.R -> {
-                Bitmap.CompressFormat.WEBP_LOSSY
-            }
-
-            else -> {
-                Bitmap.CompressFormat.WEBP
-            }
-        }
-        FileOutputStream(file).use { fos ->
-            bitmap.compress(format, 90, fos)
-        }
-    } finally {
-        if (!bitmap.isRecycled) bitmap.recycle()
-    }
-}
-
-private fun isExpired(file: File): Boolean {
-    val now = System.currentTimeMillis()
-    val age = now - file.lastModified()
-    return age > TimeUnit.DAYS.toMillis(ICON_TTL_DAYS)
-}
-
-suspend fun <T> MethodChannel.awaitResult(
-    method: String, arguments: Any? = null
-): T? = withContext(Dispatchers.Main) {
-    suspendCancellableCoroutine { continuation ->
-        invokeMethod(method, arguments, object : MethodChannel.Result {
-            override fun success(result: Any?) {
-                @Suppress("UNCHECKED_CAST") continuation.resume(result as T?)
-            }
-
-            override fun error(code: String, message: String?, details: Any?) {
-                continuation.resume(null)
-            }
-
-            override fun notImplemented() {
-                continuation.resume(null)
-            }
-        })
-    }
-}
-
-inline fun <reified T : FlutterPlugin> FlutterEngine.plugin(): T? {
-    return plugins.get(T::class.java) as T?
-}
-
-fun <T> MethodChannel.invokeMethodOnMainThread(
-    method: String, arguments: Any? = null, callback: ((Result<T>) -> Unit)? = null
-) {
-    Handler(Looper.getMainLooper()).post {
-        invokeMethod(method, arguments, object : MethodChannel.Result {
-            override fun success(result: Any?) {
-                @Suppress("UNCHECKED_CAST") callback?.invoke(Result.success(result as T))
-            }
-
-            override fun error(errorCode: String, errorMessage: String?, errorDetails: Any?) {
-                val exception = Exception("MethodChannel error: $errorCode - $errorMessage")
-                callback?.invoke(Result.failure(exception))
-            }
-
-            override fun notImplemented() {
-                val exception = NotImplementedError("Method not implemented: $method")
-                callback?.invoke(Result.failure(exception))
-            }
-        })
-    }
-}

android/app/src/main/kotlin/com/follow/clash/FilesProvider.kt

@@ -1,33 +1,35 @@
-package com.follow.clash.service
+package com.follow.clash
 
 import android.database.Cursor
 import android.database.MatrixCursor
 import android.os.CancellationSignal
 import android.os.ParcelFileDescriptor
-import android.provider.DocumentsContract
+import android.provider.DocumentsContract.Document
+import android.provider.DocumentsContract.Root
 import android.provider.DocumentsProvider
 import java.io.File
 import java.io.FileNotFoundException
 
+
 class FilesProvider : DocumentsProvider() {
 
     companion object {
         private const val DEFAULT_ROOT_ID = "0"
 
         private val DEFAULT_DOCUMENT_COLUMNS = arrayOf(
-            DocumentsContract.Document.COLUMN_DOCUMENT_ID,
-            DocumentsContract.Document.COLUMN_DISPLAY_NAME,
-            DocumentsContract.Document.COLUMN_MIME_TYPE,
-            DocumentsContract.Document.COLUMN_FLAGS,
-            DocumentsContract.Document.COLUMN_SIZE,
+            Document.COLUMN_DOCUMENT_ID,
+            Document.COLUMN_DISPLAY_NAME,
+            Document.COLUMN_MIME_TYPE,
+            Document.COLUMN_FLAGS,
+            Document.COLUMN_SIZE,
         )
         private val DEFAULT_ROOT_COLUMNS = arrayOf(
-            DocumentsContract.Root.COLUMN_ROOT_ID,
-            DocumentsContract.Root.COLUMN_FLAGS,
-            DocumentsContract.Root.COLUMN_ICON,
-            DocumentsContract.Root.COLUMN_TITLE,
-            DocumentsContract.Root.COLUMN_SUMMARY,
-            DocumentsContract.Root.COLUMN_DOCUMENT_ID
+            Root.COLUMN_ROOT_ID,
+            Root.COLUMN_FLAGS,
+            Root.COLUMN_ICON,
+            Root.COLUMN_TITLE,
+            Root.COLUMN_SUMMARY,
+            Root.COLUMN_DOCUMENT_ID
         )
     }
 
@@ -38,12 +40,12 @@ class FilesProvider : DocumentsProvider() {
     override fun queryRoots(projection: Array<String>?): Cursor {
         return MatrixCursor(projection ?: DEFAULT_ROOT_COLUMNS).apply {
             newRow().apply {
-                add(DocumentsContract.Root.COLUMN_ROOT_ID, DEFAULT_ROOT_ID)
-                add(DocumentsContract.Root.COLUMN_FLAGS, DocumentsContract.Root.FLAG_LOCAL_ONLY)
-                add(DocumentsContract.Root.COLUMN_ICON, R.drawable.ic_service)
-                add(DocumentsContract.Root.COLUMN_TITLE, "FlClash")
-                add(DocumentsContract.Root.COLUMN_SUMMARY, "Data")
-                add(DocumentsContract.Root.COLUMN_DOCUMENT_ID, "/")
+                add(Root.COLUMN_ROOT_ID, DEFAULT_ROOT_ID)
+                add(Root.COLUMN_FLAGS, Root.FLAG_LOCAL_ONLY)
+                add(Root.COLUMN_ICON, R.mipmap.ic_launcher)
+                add(Root.COLUMN_TITLE, context!!.getString(R.string.fl_clash))
+                add(Root.COLUMN_SUMMARY, "Data")
+                add(Root.COLUMN_DOCUMENT_ID, "/")
             }
         }
     }
@@ -85,20 +87,20 @@ class FilesProvider : DocumentsProvider() {
 
     private fun includeFile(result: MatrixCursor, file: File) {
         result.newRow().apply {
-            add(DocumentsContract.Document.COLUMN_DOCUMENT_ID, file.absolutePath)
-            add(DocumentsContract.Document.COLUMN_DISPLAY_NAME, file.name)
-            add(DocumentsContract.Document.COLUMN_SIZE, file.length())
+            add(Document.COLUMN_DOCUMENT_ID, file.absolutePath)
+            add(Document.COLUMN_DISPLAY_NAME, file.name)
+            add(Document.COLUMN_SIZE, file.length())
             add(
-                DocumentsContract.Document.COLUMN_FLAGS,
-                DocumentsContract.Document.FLAG_SUPPORTS_WRITE or DocumentsContract.Document.FLAG_SUPPORTS_DELETE
+                Document.COLUMN_FLAGS,
+                Document.FLAG_SUPPORTS_WRITE or Document.FLAG_SUPPORTS_DELETE
             )
-            add(DocumentsContract.Document.COLUMN_MIME_TYPE, getDocumentType(file))
+            add(Document.COLUMN_MIME_TYPE, getDocumentType(file))
         }
     }
 
     private fun getDocumentType(file: File): String {
         return if (file.isDirectory) {
-            DocumentsContract.Document.MIME_TYPE_DIR
+            Document.MIME_TYPE_DIR
         } else {
             "application/octet-stream"
         }

android/app/src/main/kotlin/com/follow/clash/FlClashApplication.kt

@@ -0,0 +1,18 @@
+package com.follow.clash;
+
+import android.app.Application
+import android.content.Context
+
+class FlClashApplication : Application() {
+    companion object {
+        private lateinit var instance: FlClashApplication
+        fun getAppContext(): Context {
+            return instance.applicationContext
+        }
+    }
+
+    override fun onCreate() {
+        super.onCreate()
+        instance = this
+    }
+}

android/app/src/main/kotlin/com/follow/clash/GlobalState.kt

@@ -0,0 +1,112 @@
+package com.follow.clash
+
+import androidx.lifecycle.MutableLiveData
+import com.follow.clash.plugins.AppPlugin
+import com.follow.clash.plugins.TilePlugin
+import com.follow.clash.plugins.VpnPlugin
+import io.flutter.FlutterInjector
+import io.flutter.embedding.engine.FlutterEngine
+import io.flutter.embedding.engine.dart.DartExecutor
+import java.util.concurrent.locks.ReentrantLock
+import kotlin.concurrent.withLock
+
+enum class RunState {
+    START,
+    PENDING,
+    STOP
+}
+
+
+object GlobalState {
+    val runLock = ReentrantLock()
+
+    const val NOTIFICATION_CHANNEL = "FlClash"
+
+    const val NOTIFICATION_ID = 1
+
+    val runState: MutableLiveData<RunState> = MutableLiveData<RunState>(RunState.STOP)
+    var flutterEngine: FlutterEngine? = null
+    private var serviceEngine: FlutterEngine? = null
+
+    fun getCurrentAppPlugin(): AppPlugin? {
+        val currentEngine = if (flutterEngine != null) flutterEngine else serviceEngine
+        return currentEngine?.plugins?.get(AppPlugin::class.java) as AppPlugin?
+    }
+
+    suspend fun getText(text: String): String {
+        return getCurrentAppPlugin()?.getText(text) ?: ""
+    }
+
+    fun getCurrentTilePlugin(): TilePlugin? {
+        val currentEngine = if (flutterEngine != null) flutterEngine else serviceEngine
+        return currentEngine?.plugins?.get(TilePlugin::class.java) as TilePlugin?
+    }
+
+    fun getCurrentVPNPlugin(): VpnPlugin? {
+        return serviceEngine?.plugins?.get(VpnPlugin::class.java) as VpnPlugin?
+    }
+
+    fun handleToggle() {
+        val starting = handleStart()
+        if (!starting) {
+            handleStop()
+        }
+    }
+
+    fun handleStart(): Boolean {
+        if (runState.value == RunState.STOP) {
+            runState.value = RunState.PENDING
+            runLock.lock()
+            val tilePlugin = getCurrentTilePlugin()
+            if (tilePlugin != null) {
+                tilePlugin.handleStart()
+            } else {
+                initServiceEngine()
+            }
+            return true
+        }
+        return false
+    }
+
+    fun handleStop() {
+        if (runState.value == RunState.START) {
+            runState.value = RunState.PENDING
+            runLock.lock()
+            getCurrentTilePlugin()?.handleStop()
+        }
+    }
+
+    fun handleTryDestroy() {
+        if (flutterEngine == null) {
+            destroyServiceEngine()
+        }
+    }
+
+    fun destroyServiceEngine() {
+        runLock.withLock {
+            serviceEngine?.destroy()
+            serviceEngine = null
+        }
+    }
+
+    fun initServiceEngine() {
+        if (serviceEngine != null) return
+        destroyServiceEngine()
+        runLock.withLock {
+            serviceEngine = FlutterEngine(FlClashApplication.getAppContext())
+            serviceEngine?.plugins?.add(VpnPlugin)
+            serviceEngine?.plugins?.add(AppPlugin())
+            serviceEngine?.plugins?.add(TilePlugin())
+            val vpnService = DartExecutor.DartEntrypoint(
+                FlutterInjector.instance().flutterLoader().findAppBundlePath(),
+                "_service"
+            )
+            serviceEngine?.dartExecutor?.executeDartEntrypoint(
+                vpnService,
+                if (flutterEngine == null) listOf("quick") else null
+            )
+        }
+    }
+}
+
+

android/app/src/main/kotlin/com/follow/clash/MainActivity.kt

@@ -1,41 +1,22 @@
 package com.follow.clash
 
-import android.os.Bundle
-import androidx.lifecycle.lifecycleScope
-import com.follow.clash.common.GlobalState
 import com.follow.clash.plugins.AppPlugin
 import com.follow.clash.plugins.ServicePlugin
 import com.follow.clash.plugins.TilePlugin
 import io.flutter.embedding.android.FlutterActivity
 import io.flutter.embedding.engine.FlutterEngine
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.launch
-
-class MainActivity : FlutterActivity(),
-    CoroutineScope by CoroutineScope(SupervisorJob() + Dispatchers.Default) {
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        lifecycleScope.launch {
-            State.destroyServiceEngine()
-        }
-    }
 
+class MainActivity : FlutterActivity() {
     override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
         super.configureFlutterEngine(flutterEngine)
         flutterEngine.plugins.add(AppPlugin())
-        flutterEngine.plugins.add(ServicePlugin())
+        flutterEngine.plugins.add(ServicePlugin)
         flutterEngine.plugins.add(TilePlugin())
-        State.flutterEngine = flutterEngine
+        GlobalState.flutterEngine = flutterEngine
     }
 
     override fun onDestroy() {
-        GlobalState.launch {
-            Service.setEventListener(null)
-        }
-        State.flutterEngine = null
+        GlobalState.flutterEngine = null
         super.onDestroy()
     }
 }

android/app/src/main/kotlin/com/follow/clash/Service.kt

@@ -1,147 +0,0 @@
-package com.follow.clash
-
-import com.follow.clash.common.ServiceDelegate
-import com.follow.clash.common.formatString
-import com.follow.clash.common.intent
-import com.follow.clash.service.IAckInterface
-import com.follow.clash.service.ICallbackInterface
-import com.follow.clash.service.IEventInterface
-import com.follow.clash.service.IRemoteInterface
-import com.follow.clash.service.IResultInterface
-import com.follow.clash.service.RemoteService
-import com.follow.clash.service.models.NotificationParams
-import com.follow.clash.service.models.VpnOptions
-import kotlinx.coroutines.suspendCancellableCoroutine
-import kotlin.coroutines.resume
-import kotlin.coroutines.resumeWithException
-
-object Service {
-    private val delegate by lazy {
-        ServiceDelegate<IRemoteInterface>(
-            RemoteService::class.intent, ::handleServiceDisconnected
-        ) {
-            IRemoteInterface.Stub.asInterface(it)
-        }
-    }
-
-    var onServiceDisconnected: ((String) -> Unit)? = null
-
-    private fun handleServiceDisconnected(message: String) {
-        onServiceDisconnected?.let {
-            it(message)
-        }
-    }
-
-    fun bind() {
-        delegate.bind()
-    }
-
-    fun unbind() {
-        delegate.unbind()
-    }
-
-    suspend fun invokeAction(data: String, cb: (result: String) -> Unit): Result<Unit> {
-        val res = mutableListOf<ByteArray>()
-        return delegate.useService {
-            it.invokeAction(
-                data, object : ICallbackInterface.Stub() {
-                    override fun onResult(
-                        result: ByteArray?, isSuccess: Boolean, ack: IAckInterface?
-                    ) {
-                        res.add(result ?: byteArrayOf())
-                        ack?.onAck()
-                        if (isSuccess) {
-                            cb(res.formatString())
-                        }
-                    }
-                })
-        }
-    }
-
-    suspend fun setEventListener(
-        cb: ((result: String?) -> Unit)?
-    ): Result<Unit> {
-        val results = HashMap<String, MutableList<ByteArray>>()
-        return delegate.useService {
-            it.setEventListener(
-                when (cb != null) {
-                true -> object : IEventInterface.Stub() {
-                    override fun onEvent(
-                        id: String, data: ByteArray?, isSuccess: Boolean, ack: IAckInterface?
-                    ) {
-                        if (results[id] == null) {
-                            results[id] = mutableListOf()
-                        }
-                        results[id]?.add(data ?: byteArrayOf())
-                        ack?.onAck()
-                        if (isSuccess) {
-                            cb(results[id]?.formatString())
-                            results.remove(id)
-                        }
-                    }
-                }
-
-                false -> null
-            })
-        }
-    }
-
-    suspend fun updateNotificationParams(
-        params: NotificationParams
-    ): Result<Unit> {
-        return delegate.useService {
-            it.updateNotificationParams(params)
-        }
-    }
-
-    suspend fun setCrashlytics(
-        enable: Boolean
-    ): Result<Unit> {
-        return delegate.useService {
-            it.setCrashlytics(enable)
-        }
-    }
-
-    private suspend fun awaitIResultInterface(
-        block: (IResultInterface) -> Unit
-    ): Long = suspendCancellableCoroutine { continuation ->
-        val callback = object : IResultInterface.Stub() {
-            override fun onResult(time: Long) {
-                if (continuation.isActive) {
-                    continuation.resume(time)
-                }
-            }
-        }
-
-        try {
-            block(callback)
-        } catch (e: Exception) {
-            if (continuation.isActive) {
-                continuation.resumeWithException(e)
-            }
-        }
-    }
-
-
-    suspend fun startService(options: VpnOptions, runTime: Long): Long {
-        return delegate.useService {
-            awaitIResultInterface { callback ->
-                it.startService(options, runTime, callback)
-            }
-        }.getOrNull() ?: 0L
-    }
-
-    suspend fun stopService(): Long {
-        return delegate.useService {
-            awaitIResultInterface { callback ->
-                it.stopService(callback)
-            }
-        }.getOrNull() ?: 0L
-    }
-
-    suspend fun getRunTime(): Long {
-        return delegate.useService {
-            it.runTime
-        }.getOrNull() ?: 0L
-    }
-}

android/app/src/main/kotlin/com/follow/clash/State.kt

@@ -1,179 +0,0 @@
-package com.follow.clash
-
-import com.follow.clash.common.GlobalState
-import com.follow.clash.plugins.AppPlugin
-import com.follow.clash.plugins.ServicePlugin
-import com.follow.clash.plugins.TilePlugin
-import io.flutter.FlutterInjector
-import io.flutter.embedding.engine.FlutterEngine
-import io.flutter.embedding.engine.dart.DartExecutor
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
-import kotlinx.coroutines.withContext
-
-enum class RunState {
-    START, PENDING, STOP
-}
-
-
-object State {
-
-    val runLock = Mutex()
-
-    var runTime: Long = 0
-
-    val runStateFlow: MutableStateFlow<RunState> = MutableStateFlow(RunState.STOP)
-
-    var flutterEngine: FlutterEngine? = null
-    var serviceFlutterEngine: FlutterEngine? = null
-
-    val appPlugin: AppPlugin?
-        get() = flutterEngine?.plugin<AppPlugin>() ?: serviceFlutterEngine?.plugin<AppPlugin>()
-
-    val servicePlugin: ServicePlugin?
-        get() = flutterEngine?.plugin<ServicePlugin>()
-            ?: serviceFlutterEngine?.plugin<ServicePlugin>()
-
-    val tilePlugin: TilePlugin?
-        get() = flutterEngine?.plugin<TilePlugin>() ?: serviceFlutterEngine?.plugin<TilePlugin>()
-
-    suspend fun handleToggleAction() {
-        var action: (suspend () -> Unit)?
-        runLock.withLock {
-            action = when (runStateFlow.value) {
-                RunState.PENDING -> null
-                RunState.START -> ::handleStopServiceAction
-                RunState.STOP -> ::handleStartServiceAction
-            }
-        }
-        action?.invoke()
-    }
-
-    suspend fun handleSyncState() {
-        runLock.withLock {
-            try {
-                Service.bind()
-                runTime = Service.getRunTime()
-                val runState = when (runTime == 0L) {
-                    true -> RunState.STOP
-                    false -> RunState.START
-                }
-                runStateFlow.tryEmit(runState)
-            } catch (_: Exception) {
-                runStateFlow.tryEmit(RunState.STOP)
-            }
-        }
-    }
-
-    suspend fun handleStartServiceAction() {
-        runLock.withLock {
-            if (runStateFlow.value != RunState.STOP) {
-                return
-            }
-            tilePlugin?.handleStart()
-            if (flutterEngine != null) {
-                return
-            }
-            startServiceWithEngine()
-        }
-
-    }
-
-    suspend fun handleStopServiceAction() {
-        runLock.withLock {
-            if (runStateFlow.value != RunState.START) {
-                return
-            }
-            tilePlugin?.handleStop()
-            if (flutterEngine != null || serviceFlutterEngine != null) {
-                return
-            }
-            handleStopService()
-        }
-    }
-
-    fun handleStartService() {
-        val appPlugin = flutterEngine?.plugin<AppPlugin>()
-        if (appPlugin != null) {
-            appPlugin.requestNotificationsPermission {
-                startService()
-            }
-            return
-        }
-        startService()
-    }
-
-    fun handleStopService() {
-        GlobalState.launch {
-            runLock.withLock {
-                if (runStateFlow.value != RunState.START) {
-                    return@launch
-                }
-                runStateFlow.tryEmit(RunState.PENDING)
-                runTime = Service.stopService()
-                runStateFlow.tryEmit(RunState.STOP)
-            }
-            destroyServiceEngine()
-        }
-    }
-
-    suspend fun destroyServiceEngine() {
-        runLock.withLock {
-            GlobalState.log("Destroy service engine")
-            withContext(Dispatchers.Main) {
-                runCatching {
-                    serviceFlutterEngine?.destroy()
-                    serviceFlutterEngine = null
-                }
-            }
-        }
-    }
-
-    private fun startServiceWithEngine() {
-        GlobalState.launch {
-            runLock.withLock {
-                if (runStateFlow.value != RunState.STOP) {
-                    return@launch
-                }
-                GlobalState.log("Create service engine")
-                withContext(Dispatchers.Main) {
-                    serviceFlutterEngine?.destroy()
-                    serviceFlutterEngine = FlutterEngine(GlobalState.application)
-                    serviceFlutterEngine?.plugins?.add(ServicePlugin())
-                    serviceFlutterEngine?.plugins?.add(AppPlugin())
-                    serviceFlutterEngine?.plugins?.add(TilePlugin())
-                    val dartEntrypoint = DartExecutor.DartEntrypoint(
-                        FlutterInjector.instance().flutterLoader().findAppBundlePath(), "_service"
-                    )
-                    serviceFlutterEngine?.dartExecutor?.executeDartEntrypoint(dartEntrypoint)
-                }
-            }
-        }
-    }
-
-    private fun startService() {
-        GlobalState.launch {
-            runLock.withLock {
-                if (runStateFlow.value != RunState.STOP) {
-                    return@launch
-                }
-                runStateFlow.tryEmit(RunState.PENDING)
-                if (servicePlugin == null) {
-                    return@launch
-                }
-                val options = servicePlugin?.handleGetVpnOptions() ?: return@launch
-                appPlugin?.prepare(options.enable) {
-                    runTime = Service.startService(options, runTime)
-                    runStateFlow.tryEmit(RunState.START)
-                }
-            }
-        }
-
-    }
-}
-
-
-

android/app/src/main/kotlin/com/follow/clash/TempActivity.kt

@@ -2,36 +2,24 @@ package com.follow.clash
 
 import android.app.Activity
 import android.os.Bundle
-import com.follow.clash.common.QuickAction
-import com.follow.clash.common.action
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.launch
+import com.follow.clash.extensions.wrapAction
 
-class TempActivity : Activity(),
-    CoroutineScope by CoroutineScope(SupervisorJob() + Dispatchers.Default) {
+class TempActivity : Activity() {
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         when (intent.action) {
-            QuickAction.START.action -> {
-                launch {
-                    State.handleStartServiceAction()
-                }
+            wrapAction("START") -> {
+                GlobalState.handleStart()
             }
 
-            QuickAction.STOP.action -> {
-                launch {
-                    State.handleStopServiceAction()
-                }
+            wrapAction("STOP") -> {
+                GlobalState.handleStop()
             }
 
-            QuickAction.TOGGLE.action -> {
-                launch {
-                    State.handleToggleAction()
-                }
+            wrapAction("CHANGE") -> {
+                GlobalState.handleToggle()
             }
         }
-        finish()
+        finishAndRemoveTask()
     }
 }

android/app/src/main/kotlin/com/follow/clash/TileService.kt

@@ -1,61 +0,0 @@
-package com.follow.clash
-
-import android.annotation.SuppressLint
-import android.os.Build
-import android.service.quicksettings.Tile
-import android.service.quicksettings.TileService
-import com.follow.clash.common.QuickAction
-import com.follow.clash.common.quickIntent
-import com.follow.clash.common.toPendingIntent
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.cancel
-import kotlinx.coroutines.launch
-
-class TileService : TileService() {
-    private var scope: CoroutineScope? = null
-    private fun updateTile(runState: RunState) {
-        if (qsTile != null) {
-            qsTile.state = when (runState) {
-                RunState.START -> Tile.STATE_ACTIVE
-                RunState.PENDING -> Tile.STATE_UNAVAILABLE
-                RunState.STOP -> Tile.STATE_INACTIVE
-            }
-            qsTile.updateTile()
-        }
-    }
-
-    override fun onStartListening() {
-        super.onStartListening()
-        scope?.cancel()
-        scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
-        scope?.launch {
-            State.handleSyncState()
-            State.runStateFlow.collect {
-                updateTile(it)
-            }
-        }
-    }
-
-    @SuppressLint("StartActivityAndCollapseDeprecated")
-    private fun handleToggle() {
-        val intent = QuickAction.TOGGLE.quickIntent
-        val pendingIntent = intent.toPendingIntent
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
-            startActivityAndCollapse(pendingIntent)
-        } else {
-            @Suppress("DEPRECATION") startActivityAndCollapse(intent)
-        }
-    }
-
-    override fun onClick() {
-        super.onClick()
-        handleToggle()
-    }
-
-    override fun onStopListening() {
-        scope?.cancel()
-        super.onStopListening()
-    }
-}

android/app/src/main/kotlin/com/follow/clash/extensions/Ext.kt

@@ -0,0 +1,195 @@
+package com.follow.clash.extensions
+
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.graphics.Bitmap
+import android.graphics.drawable.Drawable
+import android.net.ConnectivityManager
+import android.net.Network
+import android.os.Build
+import android.system.OsConstants.IPPROTO_TCP
+import android.system.OsConstants.IPPROTO_UDP
+import android.util.Base64
+import androidx.core.graphics.drawable.toBitmap
+import com.follow.clash.TempActivity
+import com.follow.clash.models.CIDR
+import com.follow.clash.models.Metadata
+import com.follow.clash.models.VpnOptions
+import io.flutter.plugin.common.MethodChannel
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import java.io.ByteArrayOutputStream
+import java.net.Inet4Address
+import java.net.Inet6Address
+import java.net.InetAddress
+import java.util.concurrent.locks.ReentrantLock
+import kotlin.coroutines.resume
+import kotlin.coroutines.suspendCoroutine
+
+suspend fun Drawable.getBase64(): String {
+    val drawable = this
+    return withContext(Dispatchers.IO) {
+        val bitmap = drawable.toBitmap()
+        val byteArrayOutputStream = ByteArrayOutputStream()
+        bitmap.compress(Bitmap.CompressFormat.PNG, 100, byteArrayOutputStream)
+        Base64.encodeToString(byteArrayOutputStream.toByteArray(), Base64.NO_WRAP)
+    }
+}
+
+fun Metadata.getProtocol(): Int? {
+    if (network.startsWith("tcp")) return IPPROTO_TCP
+    if (network.startsWith("udp")) return IPPROTO_UDP
+    return null
+}
+
+fun VpnOptions.getIpv4RouteAddress(): List<CIDR> {
+    return routeAddress.filter {
+        it.isIpv4()
+    }.map {
+        it.toCIDR()
+    }
+}
+
+fun VpnOptions.getIpv6RouteAddress(): List<CIDR> {
+    return routeAddress.filter {
+        it.isIpv6()
+    }.map {
+        it.toCIDR()
+    }
+}
+
+fun String.isIpv4(): Boolean {
+    val parts = split("/")
+    if (parts.size != 2) {
+        throw IllegalArgumentException("Invalid CIDR format")
+    }
+    val address = InetAddress.getByName(parts[0])
+    return address.address.size == 4
+}
+
+fun String.isIpv6(): Boolean {
+    val parts = split("/")
+    if (parts.size != 2) {
+        throw IllegalArgumentException("Invalid CIDR format")
+    }
+    val address = InetAddress.getByName(parts[0])
+    return address.address.size == 16
+}
+
+fun String.toCIDR(): CIDR {
+    val parts = split("/")
+    if (parts.size != 2) {
+        throw IllegalArgumentException("Invalid CIDR format")
+    }
+    val ipAddress = parts[0]
+    val prefixLength = parts[1].toIntOrNull()
+        ?: throw IllegalArgumentException("Invalid prefix length")
+
+    val address = InetAddress.getByName(ipAddress)
+
+    val maxPrefix = if (address.address.size == 4) 32 else 128
+    if (prefixLength < 0 || prefixLength > maxPrefix) {
+        throw IllegalArgumentException("Invalid prefix length for IP version")
+    }
+
+    return CIDR(address, prefixLength)
+}
+
+fun ConnectivityManager.resolveDns(network: Network?): List<String> {
+    val properties = getLinkProperties(network) ?: return listOf()
+    return properties.dnsServers.map { it.asSocketAddressText(53) }
+}
+
+fun InetAddress.asSocketAddressText(port: Int): String {
+    return when (this) {
+        is Inet6Address ->
+            "[${numericToTextFormat(this.address)}]:$port"
+
+        is Inet4Address ->
+            "${this.hostAddress}:$port"
+
+        else -> throw IllegalArgumentException("Unsupported Inet type ${this.javaClass}")
+    }
+}
+
+fun Context.wrapAction(action: String): String {
+    return "${this.packageName}.action.$action"
+}
+
+fun Context.getActionIntent(action: String): Intent {
+    val actionIntent = Intent(this, TempActivity::class.java)
+    actionIntent.action = wrapAction(action)
+    return actionIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_MULTIPLE_TASK)
+}
+
+fun Context.getActionPendingIntent(action: String): PendingIntent {
+    return if (Build.VERSION.SDK_INT >= 31) {
+        PendingIntent.getActivity(
+            this,
+            0,
+            getActionIntent(action),
+            PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
+        )
+    } else {
+        PendingIntent.getActivity(
+            this,
+            0,
+            getActionIntent(action),
+            PendingIntent.FLAG_UPDATE_CURRENT
+        )
+    }
+}
+
+private fun numericToTextFormat(src: ByteArray): String {
+    val sb = StringBuilder(39)
+    for (i in 0 until 8) {
+        sb.append(
+            Integer.toHexString(
+                src[i shl 1].toInt() shl 8 and 0xff00
+                        or (src[(i shl 1) + 1].toInt() and 0xff)
+            )
+        )
+        if (i < 7) {
+            sb.append(":")
+        }
+    }
+    return sb.toString()
+}
+
+suspend fun <T> MethodChannel.awaitResult(
+    method: String,
+    arguments: Any? = null
+): T? = withContext(Dispatchers.Main) { // 切换到主线程
+    suspendCoroutine { continuation ->
+        invokeMethod(method, arguments, object : MethodChannel.Result {
+            override fun success(result: Any?) {
+                @Suppress("UNCHECKED_CAST")
+                continuation.resume(result as T)
+            }
+
+            override fun error(code: String, message: String?, details: Any?) {
+                continuation.resume(null)
+            }
+
+            override fun notImplemented() {
+                continuation.resume(null)
+            }
+        })
+    }
+}
+
+fun ReentrantLock.safeLock() {
+    if (this.isLocked) {
+        return
+    }
+    this.lock()
+}
+
+fun ReentrantLock.safeUnlock() {
+    if (!this.isLocked) {
+        return
+    }
+
+    this.unlock()
+}

android/app/src/main/kotlin/com/follow/clash/models/Process.kt

@@ -0,0 +1,15 @@
+package com.follow.clash.models
+
+data class Process(
+    val id: String,
+    val metadata: Metadata,
+)
+
+data class Metadata(
+    val network: String,
+    val sourceIP: String,
+    val sourcePort: Int,
+    val destinationIP: String,
+    val destinationPort: Int,
+    val host: String
+)

android/app/src/main/kotlin/com/follow/clash/models/Props.kt

@@ -0,0 +1,34 @@
+package com.follow.clash.models
+
+import java.net.InetAddress
+
+enum class AccessControlMode {
+    acceptSelected, rejectSelected,
+}
+
+data class AccessControl(
+    val enable: Boolean,
+    val mode: AccessControlMode,
+    val acceptList: List<String>,
+    val rejectList: List<String>,
+)
+
+data class CIDR(val address: InetAddress, val prefixLength: Int)
+
+data class VpnOptions(
+    val enable: Boolean,
+    val port: Int,
+    val accessControl: AccessControl,
+    val allowBypass: Boolean,
+    val systemProxy: Boolean,
+    val bypassDomain: List<String>,
+    val routeAddress: List<String>,
+    val ipv4Address: String,
+    val ipv6Address: String,
+    val dnsServerAddress: String,
+)
+
+data class StartForegroundParams(
+    val title: String,
+    val content: String,
+)

android/app/src/main/kotlin/com/follow/clash/models/State.kt

@@ -1,9 +0,0 @@
-package com.follow.clash.models
-
-
-data class AppState(
-    val crashlytics: Boolean = true,
-    val currentProfileName: String = "FlClash",
-    val stopText: String = "Stop",
-    val onlyStatisticsProxy: Boolean = false,
-)

android/app/src/main/kotlin/com/follow/clash/plugins/AppPlugin.kt

@@ -13,16 +13,17 @@ import android.widget.Toast
 import androidx.core.app.ActivityCompat
 import androidx.core.content.ContextCompat
 import androidx.core.content.ContextCompat.getSystemService
+import androidx.core.content.FileProvider
 import androidx.core.content.pm.ShortcutInfoCompat
 import androidx.core.content.pm.ShortcutManagerCompat
 import androidx.core.graphics.drawable.IconCompat
 import com.android.tools.smali.dexlib2.dexbacked.DexBackedDexFile
+import com.follow.clash.FlClashApplication
+import com.follow.clash.GlobalState
 import com.follow.clash.R
-import com.follow.clash.common.Components
-import com.follow.clash.common.GlobalState
-import com.follow.clash.common.QuickAction
-import com.follow.clash.common.quickIntent
-import com.follow.clash.getPackageIconPath
+import com.follow.clash.extensions.awaitResult
+import com.follow.clash.extensions.getActionIntent
+import com.follow.clash.extensions.getBase64
 import com.follow.clash.models.Package
 import com.google.gson.Gson
 import io.flutter.embedding.android.FlutterActivity
@@ -43,20 +44,15 @@ import java.util.zip.ZipFile
 
 class AppPlugin : FlutterPlugin, MethodChannel.MethodCallHandler, ActivityAware {
 
-    companion object {
-        const val VPN_PERMISSION_REQUEST_CODE = 1001
-        const val NOTIFICATION_PERMISSION_REQUEST_CODE = 1002
-    }
-
     private var activityRef: WeakReference<Activity>? = null
 
     private lateinit var channel: MethodChannel
 
     private lateinit var scope: CoroutineScope
 
-    private var vpnPrepareCallback: (suspend () -> Unit)? = null
+    private var vpnCallBack: (() -> Unit)? = null
 
-    private var requestNotificationCallback: (() -> Unit)? = null
+    private val iconMap = mutableMapOf<String, String?>()
 
     private val packages = mutableListOf<Package>()
 
@@ -115,8 +111,46 @@ class AppPlugin : FlutterPlugin, MethodChannel.MethodCallHandler, ActivityAware
         ("(" + chinaAppPrefixList.joinToString("|").replace(".", "\\.") + ").*").toRegex()
     }
 
+    val VPN_PERMISSION_REQUEST_CODE = 1001
+
+    val NOTIFICATION_PERMISSION_REQUEST_CODE = 1002
+
     private var isBlockNotification: Boolean = false
 
+    override fun onAttachedToEngine(flutterPluginBinding: FlutterPlugin.FlutterPluginBinding) {
+        scope = CoroutineScope(Dispatchers.Default)
+        channel = MethodChannel(flutterPluginBinding.binaryMessenger, "app")
+        channel.setMethodCallHandler(this)
+    }
+
+    private fun initShortcuts(label: String) {
+        val shortcut = ShortcutInfoCompat.Builder(FlClashApplication.getAppContext(), "toggle")
+            .setShortLabel(label)
+            .setIcon(
+                IconCompat.createWithResource(
+                    FlClashApplication.getAppContext(),
+                    R.mipmap.ic_launcher_round
+                )
+            )
+            .setIntent(FlClashApplication.getAppContext().getActionIntent("CHANGE"))
+            .build()
+        ShortcutManagerCompat.setDynamicShortcuts(
+            FlClashApplication.getAppContext(),
+            listOf(shortcut)
+        )
+    }
+
+    override fun onDetachedFromEngine(binding: FlutterPlugin.FlutterPluginBinding) {
+        channel.setMethodCallHandler(null)
+        scope.cancel()
+    }
+
+    private fun tip(message: String?) {
+        if (GlobalState.flutterEngine == null) {
+            Toast.makeText(FlClashApplication.getAppContext(), message, Toast.LENGTH_LONG).show()
+        }
+    }
+
     override fun onMethodCall(call: MethodCall, result: Result) {
         when (call.method) {
             "moveTaskToBack" -> {
@@ -148,7 +182,26 @@ class AppPlugin : FlutterPlugin, MethodChannel.MethodCallHandler, ActivityAware
             }
 
             "getPackageIcon" -> {
-                handleGetPackageIcon(call, result)
+                scope.launch {
+                    val packageName = call.argument<String>("packageName")
+                    if (packageName == null) {
+                        result.success(null)
+                        return@launch
+                    }
+                    val packageIcon = getPackageIcon(packageName)
+                    packageIcon.let {
+                        if (it != null) {
+                            result.success(it)
+                            return@launch
+                        }
+                        if (iconMap["default"] == null) {
+                            iconMap["default"] =
+                                FlClashApplication.getAppContext().packageManager?.defaultActivityIcon?.getBase64()
+                        }
+                        result.success(iconMap["default"])
+                        return@launch
+                    }
+                }
             }
 
             "tip" -> {
@@ -157,48 +210,56 @@ class AppPlugin : FlutterPlugin, MethodChannel.MethodCallHandler, ActivityAware
                 result.success(true)
             }
 
+            "openFile" -> {
+                val path = call.argument<String>("path")!!
+                openFile(path)
+                result.success(true)
+            }
+
             else -> {
                 result.notImplemented()
             }
         }
     }
 
-    private fun handleGetPackageIcon(call: MethodCall, result: Result) {
-        scope.launch {
-            val packageName = call.argument<String>("packageName")
-            if (packageName == null) {
-                result.success("")
-                return@launch
-            }
-            val path = GlobalState.application.packageManager.getPackageIconPath(packageName)
-            result.success(path)
-        }
-    }
-
-    private fun initShortcuts(label: String) {
-        val shortcut = with(ShortcutInfoCompat.Builder(GlobalState.application, "toggle")) {
-            setShortLabel(label)
-            setIcon(
-                IconCompat.createWithResource(
-                    GlobalState.application,
-                    R.mipmap.ic_launcher_round,
-                )
-            )
-            setIntent(QuickAction.TOGGLE.quickIntent)
-            build()
-        }
-        ShortcutManagerCompat.setDynamicShortcuts(
-            GlobalState.application, listOf(shortcut)
+    private fun openFile(path: String) {
+        val file = File(path)
+        val uri = FileProvider.getUriForFile(
+            FlClashApplication.getAppContext(),
+            "${FlClashApplication.getAppContext().packageName}.fileProvider",
+            file
         )
+
+        val intent = Intent(Intent.ACTION_VIEW).setDataAndType(
+            uri,
+            "text/plain"
+        )
+
+        val flags =
+            Intent.FLAG_GRANT_WRITE_URI_PERMISSION or Intent.FLAG_GRANT_READ_URI_PERMISSION
+
+        val resInfoList = FlClashApplication.getAppContext().packageManager.queryIntentActivities(
+            intent, PackageManager.MATCH_DEFAULT_ONLY
+        )
+
+        for (resolveInfo in resInfoList) {
+            val packageName = resolveInfo.activityInfo.packageName
+            FlClashApplication.getAppContext().grantUriPermission(
+                packageName,
+                uri,
+                flags
+            )
+        }
+
+        try {
+            activityRef?.get()?.startActivity(intent)
+        } catch (e: Exception) {
+            println(e)
+        }
     }
 
-    private fun tip(message: String?) {
-        Toast.makeText(GlobalState.application, message, Toast.LENGTH_LONG).show()
-    }
-
-    @Suppress("DEPRECATION")
     private fun updateExcludeFromRecents(value: Boolean?) {
-        val am = getSystemService(GlobalState.application, ActivityManager::class.java)
+        val am = getSystemService(FlClashApplication.getAppContext(), ActivityManager::class.java)
         val task = am?.appTasks?.firstOrNull {
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
                 it.taskInfo.taskId == activityRef?.get()?.taskId
@@ -214,18 +275,31 @@ class AppPlugin : FlutterPlugin, MethodChannel.MethodCallHandler, ActivityAware
         }
     }
 
+    private suspend fun getPackageIcon(packageName: String): String? {
+        val packageManager = FlClashApplication.getAppContext().packageManager
+        if (iconMap[packageName] == null) {
+            iconMap[packageName] = try {
+                packageManager?.getApplicationIcon(packageName)?.getBase64()
+            } catch (_: Exception) {
+                null
+            }
+
+        }
+        return iconMap[packageName]
+    }
 
     private fun getPackages(): List<Package> {
-        val packageManager = GlobalState.application.packageManager
+        val packageManager = FlClashApplication.getAppContext().packageManager
         if (packages.isNotEmpty()) return packages
         packageManager?.getInstalledPackages(PackageManager.GET_META_DATA or PackageManager.GET_PERMISSIONS)
             ?.filter {
-                it.packageName != GlobalState.application.packageName && it.packageName != "android"
+                it.packageName != FlClashApplication.getAppContext().packageName || it.packageName == "android"
+
             }?.map {
                 Package(
                     packageName = it.packageName,
                     label = it.applicationInfo?.loadLabel(packageManager).toString(),
-                    system = (it.applicationInfo?.flags?.and(ApplicationInfo.FLAG_SYSTEM)) != 0,
+                    system = (it.applicationInfo?.flags?.and(ApplicationInfo.FLAG_SYSTEM)) == 1,
                     lastUpdateTime = it.lastUpdateTime,
                     internet = it.requestedPermissions?.contains(Manifest.permission.INTERNET) == true
                 )
@@ -247,66 +321,52 @@ class AppPlugin : FlutterPlugin, MethodChannel.MethodCallHandler, ActivityAware
         }
     }
 
-    fun requestNotificationsPermission(callBack: () -> Unit) {
-        requestNotificationCallback = callBack
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-            val permission = ContextCompat.checkSelfPermission(
-                GlobalState.application, Manifest.permission.POST_NOTIFICATIONS
-            )
-            if (permission == PackageManager.PERMISSION_GRANTED || isBlockNotification) {
-                invokeRequestNotificationCallback()
-                return
-            }
-            activityRef?.get()?.let {
-                ActivityCompat.requestPermissions(
-                    it,
-                    arrayOf(Manifest.permission.POST_NOTIFICATIONS),
-                    NOTIFICATION_PERMISSION_REQUEST_CODE
-                )
-            }
-            return
-        } else {
-            invokeRequestNotificationCallback()
-        }
-
-    }
-
-    fun invokeRequestNotificationCallback() {
-        requestNotificationCallback?.invoke()
-        requestNotificationCallback = null
-    }
-
-    fun prepare(needPrepare: Boolean, callBack: (suspend () -> Unit)) {
-        vpnPrepareCallback = callBack
-        if (!needPrepare) {
-            invokeVpnPrepareCallback()
-            return
-        }
-        val intent = VpnService.prepare(GlobalState.application)
+    fun requestVpnPermission(callBack: () -> Unit) {
+        vpnCallBack = callBack
+        val intent = VpnService.prepare(FlClashApplication.getAppContext())
         if (intent != null) {
             activityRef?.get()?.startActivityForResult(intent, VPN_PERMISSION_REQUEST_CODE)
             return
         }
-        invokeVpnPrepareCallback()
+        vpnCallBack?.invoke()
     }
 
-    fun invokeVpnPrepareCallback() {
-        GlobalState.launch {
-            vpnPrepareCallback?.invoke()
-            vpnPrepareCallback = null
+    fun requestNotificationsPermission() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            val permission = ContextCompat.checkSelfPermission(
+                FlClashApplication.getAppContext(),
+                Manifest.permission.POST_NOTIFICATIONS
+            )
+            if (permission != PackageManager.PERMISSION_GRANTED) {
+                if (isBlockNotification) return
+                if (activityRef?.get() == null) return
+                activityRef?.get()?.let {
+                    ActivityCompat.requestPermissions(
+                        it,
+                        arrayOf(Manifest.permission.POST_NOTIFICATIONS),
+                        NOTIFICATION_PERMISSION_REQUEST_CODE
+                    )
+                    return
+                }
+            }
         }
     }
 
+    suspend fun getText(text: String): String? {
+        return withContext(Dispatchers.Default) {
+            channel.awaitResult<String>("getText", text)
+        }
+    }
 
-    @Suppress("DEPRECATION")
     private fun isChinaPackage(packageName: String): Boolean {
-        val packageManager = GlobalState.application.packageManager ?: return false
+        val packageManager = FlClashApplication.getAppContext().packageManager ?: return false
         skipPrefixList.forEach {
             if (packageName == it || packageName.startsWith("$it.")) return false
         }
         val packageManagerFlags = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
             PackageManager.MATCH_UNINSTALLED_PACKAGES or PackageManager.GET_ACTIVITIES or PackageManager.GET_SERVICES or PackageManager.GET_RECEIVERS or PackageManager.GET_PROVIDERS
         } else {
+            @Suppress("DEPRECATION")
             PackageManager.GET_UNINSTALLED_PACKAGES or PackageManager.GET_ACTIVITIES or PackageManager.GET_SERVICES or PackageManager.GET_RECEIVERS or PackageManager.GET_PROVIDERS
         }
         if (packageName.matches(chinaAppRegex)) {
@@ -315,7 +375,8 @@ class AppPlugin : FlutterPlugin, MethodChannel.MethodCallHandler, ActivityAware
         try {
             val packageInfo = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
                 packageManager.getPackageInfo(
-                    packageName, PackageManager.PackageInfoFlags.of(packageManagerFlags.toLong())
+                    packageName,
+                    PackageManager.PackageInfoFlags.of(packageManagerFlags.toLong())
                 )
             } else {
                 packageManager.getPackageInfo(
@@ -366,18 +427,6 @@ class AppPlugin : FlutterPlugin, MethodChannel.MethodCallHandler, ActivityAware
         return false
     }
 
-    override fun onAttachedToEngine(flutterPluginBinding: FlutterPlugin.FlutterPluginBinding) {
-        scope = CoroutineScope(Dispatchers.Default)
-        channel =
-            MethodChannel(flutterPluginBinding.binaryMessenger, "${Components.PACKAGE_NAME}/app")
-        channel.setMethodCallHandler(this)
-    }
-
-    override fun onDetachedFromEngine(binding: FlutterPlugin.FlutterPluginBinding) {
-        channel.setMethodCallHandler(null)
-        scope.cancel()
-    }
-
     override fun onAttachedToActivity(binding: ActivityPluginBinding) {
         activityRef = WeakReference(binding.activity)
         binding.addActivityResultListener(::onActivityResult)
@@ -400,19 +449,21 @@ class AppPlugin : FlutterPlugin, MethodChannel.MethodCallHandler, ActivityAware
     private fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?): Boolean {
         if (requestCode == VPN_PERMISSION_REQUEST_CODE) {
             if (resultCode == FlutterActivity.RESULT_OK) {
-                invokeVpnPrepareCallback()
+                GlobalState.initServiceEngine()
+                vpnCallBack?.invoke()
             }
         }
         return true
     }
 
     private fun onRequestPermissionsResultListener(
-        requestCode: Int, permissions: Array<String>, grantResults: IntArray
+        requestCode: Int,
+        permissions: Array<String>,
+        grantResults: IntArray
     ): Boolean {
         if (requestCode == NOTIFICATION_PERMISSION_REQUEST_CODE) {
             isBlockNotification = true
         }
-        invokeRequestNotificationCallback()
         return true
     }
 }

android/app/src/main/kotlin/com/follow/clash/plugins/ServicePlugin.kt

@@ -1,34 +1,19 @@
 package com.follow.clash.plugins
 
-import com.follow.clash.RunState
-import com.follow.clash.Service
-import com.follow.clash.State
-import com.follow.clash.awaitResult
-import com.follow.clash.common.Components
-import com.follow.clash.common.GlobalState
-import com.follow.clash.invokeMethodOnMainThread
-import com.follow.clash.models.AppState
-import com.follow.clash.service.models.NotificationParams
-import com.follow.clash.service.models.VpnOptions
+import com.follow.clash.GlobalState
+import com.follow.clash.models.VpnOptions
 import com.google.gson.Gson
 import io.flutter.embedding.engine.plugins.FlutterPlugin
 import io.flutter.plugin.common.MethodCall
 import io.flutter.plugin.common.MethodChannel
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.sync.Semaphore
-import kotlinx.coroutines.sync.withPermit
 
-class ServicePlugin : FlutterPlugin, MethodChannel.MethodCallHandler,
-    CoroutineScope by CoroutineScope(SupervisorJob() + Dispatchers.Default) {
+
+data object ServicePlugin : FlutterPlugin, MethodChannel.MethodCallHandler {
+
     private lateinit var flutterMethodChannel: MethodChannel
 
     override fun onAttachedToEngine(flutterPluginBinding: FlutterPlugin.FlutterPluginBinding) {
-        flutterMethodChannel = MethodChannel(
-            flutterPluginBinding.binaryMessenger, "${Components.PACKAGE_NAME}/service"
-        )
+        flutterMethodChannel = MethodChannel(flutterPluginBinding.binaryMessenger, "service")
         flutterMethodChannel.setMethodCallHandler(this)
     }
 
@@ -37,32 +22,28 @@ class ServicePlugin : FlutterPlugin, MethodChannel.MethodCallHandler,
     }
 
     override fun onMethodCall(call: MethodCall, result: MethodChannel.Result) = when (call.method) {
+        "startVpn" -> {
+            val data = call.argument<String>("data")
+            val options = Gson().fromJson(data, VpnOptions::class.java)
+            GlobalState.getCurrentVPNPlugin()?.handleStart(options)
+            result.success(true)
+        }
+
+        "stopVpn" -> {
+            GlobalState.getCurrentVPNPlugin()?.handleStop()
+            result.success(true)
+        }
+
         "init" -> {
-            handleInit(call, result)
+            GlobalState.getCurrentAppPlugin()
+                ?.requestNotificationsPermission()
+            GlobalState.initServiceEngine()
+            result.success(true)
         }
 
-        "shutdown" -> {
-            handleShutdown(result)
-        }
-
-        "invokeAction" -> {
-            handleInvokeAction(call, result)
-        }
-
-        "getRunTime" -> {
-            handleGetRunTime(result)
-        }
-
-        "syncState" -> {
-            handleSyncState(call, result)
-        }
-
-        "start" -> {
-            handleStart(result)
-        }
-
-        "stop" -> {
-            handleStop(result)
+        "destroy" -> {
+            handleDestroy()
+            result.success(true)
         }
 
         else -> {
@@ -70,91 +51,7 @@ class ServicePlugin : FlutterPlugin, MethodChannel.MethodCallHandler,
         }
     }
 
-    private fun handleInvokeAction(call: MethodCall, result: MethodChannel.Result) {
-        launch {
-            val data = call.arguments<String>()!!
-            Service.invokeAction(data) {
-                result.success(it)
-            }
-        }
-    }
-
-    private fun handleShutdown(result: MethodChannel.Result) {
-        Service.unbind()
-        result.success(true)
-    }
-
-    private fun handleStart(result: MethodChannel.Result) {
-        State.handleStartService()
-        result.success(true)
-    }
-
-    private fun handleStop(result: MethodChannel.Result) {
-        State.handleStopService()
-        result.success(true)
-    }
-
-    suspend fun handleGetVpnOptions(): VpnOptions? {
-        val res = flutterMethodChannel.awaitResult<String>("getVpnOptions", null)
-        return Gson().fromJson(res, VpnOptions::class.java)
-    }
-
-    val semaphore = Semaphore(10)
-
-    fun handleSendEvent(value: String?) {
-        launch(Dispatchers.Main) {
-            semaphore.withPermit {
-                flutterMethodChannel.invokeMethod("event", value)
-            }
-        }
-    }
-
-    private fun onServiceDisconnected(message: String) {
-        State.runStateFlow.tryEmit(RunState.STOP)
-        flutterMethodChannel.invokeMethodOnMainThread<Any>("crash", message)
-    }
-
-    private fun handleSyncState(call: MethodCall, result: MethodChannel.Result) {
-        val data = call.arguments<String>()!!
-        val params = Gson().fromJson(data, AppState::class.java)
-        GlobalState.setCrashlytics(params.crashlytics)
-        launch {
-            Service.updateNotificationParams(
-                NotificationParams(
-                    title = params.currentProfileName,
-                    stopText = params.stopText,
-                    onlyStatisticsProxy = params.onlyStatisticsProxy
-                )
-            )
-            Service.setCrashlytics(params.crashlytics)
-            result.success("")
-        }
-    }
-
-    fun handleInit(call: MethodCall, result: MethodChannel.Result) {
-        Service.bind()
-        launch {
-            val needSetEventListener = call.arguments<Boolean>() ?: false
-            when (needSetEventListener) {
-                true -> Service.setEventListener {
-                    handleSendEvent(it)
-                }
-
-                false -> Service.setEventListener(null)
-            }.onSuccess {
-                result.success("")
-            }.onFailure {
-                result.success(it.message)
-            }
-
-        }
-        Service.onServiceDisconnected = ::onServiceDisconnected
-    }
-
-    private fun handleGetRunTime(result: MethodChannel.Result) {
-        launch {
-            State.handleSyncState()
-            result.success(State.runTime)
-        }
+    private fun handleDestroy() {
+        GlobalState.destroyServiceEngine()
     }
 }

android/app/src/main/kotlin/com/follow/clash/plugins/TilePlugin.kt

@@ -1,7 +1,5 @@
 package com.follow.clash.plugins
 
-import com.follow.clash.common.Components
-import com.follow.clash.invokeMethodOnMainThread
 import io.flutter.embedding.engine.plugins.FlutterPlugin
 import io.flutter.plugin.common.MethodCall
 import io.flutter.plugin.common.MethodChannel
@@ -11,21 +9,25 @@ class TilePlugin : FlutterPlugin, MethodChannel.MethodCallHandler {
     private lateinit var channel: MethodChannel
 
     override fun onAttachedToEngine(flutterPluginBinding: FlutterPlugin.FlutterPluginBinding) {
-        channel =
-            MethodChannel(flutterPluginBinding.binaryMessenger, "${Components.PACKAGE_NAME}/tile")
+        channel = MethodChannel(flutterPluginBinding.binaryMessenger, "tile")
         channel.setMethodCallHandler(this)
     }
 
     override fun onDetachedFromEngine(binding: FlutterPlugin.FlutterPluginBinding) {
+        handleDetached()
         channel.setMethodCallHandler(null)
     }
 
     fun handleStart() {
-        channel.invokeMethodOnMainThread<Any>("start", null)
+        channel.invokeMethod("start", null)
     }
 
     fun handleStop() {
-        channel.invokeMethodOnMainThread<Any>("stop", null)
+        channel.invokeMethod("stop", null)
+    }
+
+    private fun handleDetached() {
+        channel.invokeMethod("detached", null)
     }
 
 

android/app/src/main/kotlin/com/follow/clash/plugins/VpnPlugin.kt

@@ -0,0 +1,268 @@
+package com.follow.clash.plugins
+
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.content.ServiceConnection
+import android.net.ConnectivityManager
+import android.net.Network
+import android.net.NetworkCapabilities
+import android.net.NetworkRequest
+import android.os.Build
+import android.os.IBinder
+import androidx.core.content.getSystemService
+import com.follow.clash.FlClashApplication
+import com.follow.clash.GlobalState
+import com.follow.clash.RunState
+import com.follow.clash.core.Core
+import com.follow.clash.extensions.awaitResult
+import com.follow.clash.extensions.resolveDns
+import com.follow.clash.models.StartForegroundParams
+import com.follow.clash.models.VpnOptions
+import com.follow.clash.services.BaseServiceInterface
+import com.follow.clash.services.FlClashService
+import com.follow.clash.services.FlClashVpnService
+import com.google.gson.Gson
+import io.flutter.embedding.engine.plugins.FlutterPlugin
+import io.flutter.plugin.common.MethodCall
+import io.flutter.plugin.common.MethodChannel
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import java.net.InetSocketAddress
+import kotlin.concurrent.withLock
+
+data object VpnPlugin : FlutterPlugin, MethodChannel.MethodCallHandler {
+    private lateinit var flutterMethodChannel: MethodChannel
+    private var flClashService: BaseServiceInterface? = null
+    private var options: VpnOptions? = null
+    private var isBind: Boolean = false
+    private lateinit var scope: CoroutineScope
+    private var lastStartForegroundParams: StartForegroundParams? = null
+    private var timerJob: Job? = null
+    private val uidPageNameMap = mutableMapOf<Int, String>()
+
+    private val connectivity by lazy {
+        FlClashApplication.getAppContext().getSystemService<ConnectivityManager>()
+    }
+
+    private val connection = object : ServiceConnection {
+        override fun onServiceConnected(className: ComponentName, service: IBinder) {
+            isBind = true
+            flClashService = when (service) {
+                is FlClashVpnService.LocalBinder -> service.getService()
+                is FlClashService.LocalBinder -> service.getService()
+                else -> throw Exception("invalid binder")
+            }
+            handleStartService()
+        }
+
+        override fun onServiceDisconnected(arg: ComponentName) {
+            isBind = false
+            flClashService = null
+        }
+    }
+
+    override fun onAttachedToEngine(flutterPluginBinding: FlutterPlugin.FlutterPluginBinding) {
+        scope = CoroutineScope(Dispatchers.Default)
+        scope.launch {
+            registerNetworkCallback()
+        }
+        flutterMethodChannel = MethodChannel(flutterPluginBinding.binaryMessenger, "vpn")
+        flutterMethodChannel.setMethodCallHandler(this)
+    }
+
+    override fun onDetachedFromEngine(flutterPluginBinding: FlutterPlugin.FlutterPluginBinding) {
+        unRegisterNetworkCallback()
+        flutterMethodChannel.setMethodCallHandler(null)
+    }
+
+    override fun onMethodCall(call: MethodCall, result: MethodChannel.Result) {
+        when (call.method) {
+            "start" -> {
+                val data = call.argument<String>("data")
+                result.success(handleStart(Gson().fromJson(data, VpnOptions::class.java)))
+            }
+
+            "stop" -> {
+                handleStop()
+                result.success(true)
+            }
+
+            else -> {
+                result.notImplemented()
+            }
+        }
+    }
+
+    fun handleStart(options: VpnOptions): Boolean {
+        if (options.enable != this.options?.enable) {
+            this.flClashService = null
+        }
+        this.options = options
+        when (options.enable) {
+            true -> handleStartVpn()
+            false -> handleStartService()
+        }
+        return true
+    }
+
+    private fun handleStartVpn() {
+        GlobalState.getCurrentAppPlugin()?.requestVpnPermission {
+            handleStartService()
+        }
+    }
+
+    fun requestGc() {
+        flutterMethodChannel.invokeMethod("gc", null)
+    }
+
+    val networks = mutableSetOf<Network>()
+
+    fun onUpdateNetwork() {
+        val dns = networks.flatMap { network ->
+            connectivity?.resolveDns(network) ?: emptyList()
+        }.toSet().joinToString(",")
+        scope.launch {
+            withContext(Dispatchers.Main) {
+                flutterMethodChannel.invokeMethod("dnsChanged", dns)
+            }
+        }
+    }
+
+    private val callback = object : ConnectivityManager.NetworkCallback() {
+        override fun onAvailable(network: Network) {
+            networks.add(network)
+            onUpdateNetwork()
+        }
+
+        override fun onLost(network: Network) {
+            networks.remove(network)
+            onUpdateNetwork()
+        }
+    }
+
+    private val request = NetworkRequest.Builder().apply {
+        addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_VPN)
+        addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
+        addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED)
+    }.build()
+
+    private fun registerNetworkCallback() {
+        networks.clear()
+        connectivity?.registerNetworkCallback(request, callback)
+    }
+
+    private fun unRegisterNetworkCallback() {
+        connectivity?.unregisterNetworkCallback(callback)
+        networks.clear()
+        onUpdateNetwork()
+    }
+
+    private suspend fun startForeground() {
+        GlobalState.runLock.lock()
+        try {
+            if (GlobalState.runState.value != RunState.START) return
+            val data = flutterMethodChannel.awaitResult<String>("getStartForegroundParams")
+            val startForegroundParams = if (data != null) Gson().fromJson(
+                data, StartForegroundParams::class.java
+            ) else StartForegroundParams(
+                title = "", content = ""
+            )
+            if (lastStartForegroundParams != startForegroundParams) {
+                lastStartForegroundParams = startForegroundParams
+                flClashService?.startForeground(
+                    startForegroundParams.title,
+                    startForegroundParams.content,
+                )
+            }
+        } finally {
+            GlobalState.runLock.unlock()
+        }
+    }
+
+    private fun startForegroundJob() {
+        stopForegroundJob()
+        timerJob = CoroutineScope(Dispatchers.Main).launch {
+            while (isActive) {
+                startForeground()
+                delay(1000)
+            }
+        }
+    }
+
+    private fun stopForegroundJob() {
+        timerJob?.cancel()
+        timerJob = null
+    }
+
+    private fun handleStartService() {
+        if (flClashService == null) {
+            bindService()
+            return
+        }
+        GlobalState.runLock.withLock {
+            if (GlobalState.runState.value == RunState.START) return
+            GlobalState.runState.value = RunState.START
+            val fd = flClashService?.start(options!!)
+            Core.startTun(
+                fd = fd ?: 0,
+                protect = this::protect,
+                resolverProcess = this::resolverProcess,
+            )
+            startForegroundJob()
+        }
+    }
+
+    private fun protect(fd: Int): Boolean {
+        return (flClashService as? FlClashVpnService)?.protect(fd) == true
+    }
+
+    private fun resolverProcess(
+        protocol: Int,
+        source: InetSocketAddress,
+        target: InetSocketAddress,
+        uid: Int,
+    ): String {
+        val nextUid = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            connectivity?.getConnectionOwnerUid(protocol, source, target) ?: -1
+        } else {
+            uid
+        }
+        if (nextUid == -1) {
+            return ""
+        }
+        if (!uidPageNameMap.containsKey(nextUid)) {
+            uidPageNameMap[nextUid] =
+                FlClashApplication.getAppContext().packageManager?.getPackagesForUid(nextUid)
+                    ?.first() ?: ""
+        }
+        return uidPageNameMap[nextUid] ?: ""
+    }
+
+    fun handleStop() {
+        GlobalState.runLock.withLock {
+            if (GlobalState.runState.value == RunState.STOP) return
+            GlobalState.runState.value = RunState.STOP
+            stopForegroundJob()
+            Core.stopTun()
+            flClashService?.stop()
+            GlobalState.handleTryDestroy()
+        }
+    }
+
+    private fun bindService() {
+        if (isBind) {
+            FlClashApplication.getAppContext().unbindService(connection)
+        }
+        val intent = when (options?.enable == true) {
+            true -> Intent(FlClashApplication.getAppContext(), FlClashVpnService::class.java)
+            false -> Intent(FlClashApplication.getAppContext(), FlClashService::class.java)
+        }
+        FlClashApplication.getAppContext().bindService(intent, connection, Context.BIND_AUTO_CREATE)
+    }
+}

android/app/src/main/kotlin/com/follow/clash/services/BaseServiceInterface.kt

@@ -0,0 +1,98 @@
+package com.follow.clash.services
+
+import android.annotation.SuppressLint
+import android.app.Notification
+import android.app.Notification.FOREGROUND_SERVICE_IMMEDIATE
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.app.Service
+import android.content.Intent
+import android.content.pm.ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC
+import android.os.Build
+import androidx.core.app.NotificationCompat
+import com.follow.clash.GlobalState
+import com.follow.clash.MainActivity
+import com.follow.clash.R
+import com.follow.clash.extensions.getActionPendingIntent
+import com.follow.clash.models.VpnOptions
+import io.flutter.Log
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Deferred
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+
+interface BaseServiceInterface {
+
+    fun start(options: VpnOptions): Int
+
+    fun stop()
+
+    suspend fun startForeground(title: String, content: String)
+}
+
+fun Service.createFlClashNotificationBuilder(): Deferred<NotificationCompat.Builder> =
+    CoroutineScope(Dispatchers.Main).async {
+        val stopText = GlobalState.getText("stop")
+        val intent = Intent(this@createFlClashNotificationBuilder, MainActivity::class.java)
+
+        val pendingIntent = if (Build.VERSION.SDK_INT >= 31) {
+            PendingIntent.getActivity(
+                this@createFlClashNotificationBuilder,
+                0,
+                intent,
+                PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
+            )
+        } else {
+            PendingIntent.getActivity(
+                this@createFlClashNotificationBuilder, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT
+            )
+        }
+
+        with(
+            NotificationCompat.Builder(
+                this@createFlClashNotificationBuilder, GlobalState.NOTIFICATION_CHANNEL
+            )
+        ) {
+            setSmallIcon(R.drawable.ic_stat_name)
+            setContentTitle("FlClash")
+            setContentIntent(pendingIntent)
+            setCategory(NotificationCompat.CATEGORY_SERVICE)
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                foregroundServiceBehavior = FOREGROUND_SERVICE_IMMEDIATE
+            }
+            setOngoing(true)
+            addAction(
+                0, stopText, getActionPendingIntent("STOP")
+            )
+            setShowWhen(false)
+            setOnlyAlertOnce(true)
+        }
+    }
+
+@SuppressLint("ForegroundServiceType")
+fun Service.startForeground(notification: Notification) {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        val manager = getSystemService(NotificationManager::class.java)
+        var channel = manager?.getNotificationChannel(GlobalState.NOTIFICATION_CHANNEL)
+        if (channel == null) {
+            Log.d("[FlClash]","createNotificationChannel===>")
+            channel = NotificationChannel(
+                GlobalState.NOTIFICATION_CHANNEL, "FlClash", NotificationManager.IMPORTANCE_LOW
+            )
+            manager?.createNotificationChannel(channel)
+        }
+    }
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+        try {
+            startForeground(
+                GlobalState.NOTIFICATION_ID, notification, FOREGROUND_SERVICE_TYPE_DATA_SYNC
+            )
+        } catch (_: Exception) {
+            startForeground(GlobalState.NOTIFICATION_ID, notification)
+        }
+    } else {
+        startForeground(GlobalState.NOTIFICATION_ID, notification)
+    }
+}

android/app/src/main/kotlin/com/follow/clash/services/FlClashService.kt

@@ -0,0 +1,67 @@
+package com.follow.clash.services
+
+import android.annotation.SuppressLint
+import android.app.Service
+import android.content.Intent
+import android.os.Binder
+import android.os.Build
+import android.os.IBinder
+import androidx.core.app.NotificationCompat
+import com.follow.clash.GlobalState
+import com.follow.clash.models.VpnOptions
+
+
+class FlClashService : Service(), BaseServiceInterface {
+
+    override fun start(options: VpnOptions) = 0
+
+    override fun stop() {
+        stopSelf()
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            stopForeground(STOP_FOREGROUND_REMOVE)
+        }
+    }
+    
+    private var cachedBuilder: NotificationCompat.Builder? = null
+
+    private suspend fun notificationBuilder(): NotificationCompat.Builder {
+        if (cachedBuilder == null) {
+            cachedBuilder = createFlClashNotificationBuilder().await()
+        }
+        return cachedBuilder!!
+    }
+
+    @SuppressLint("ForegroundServiceType")
+    override suspend fun startForeground(title: String, content: String) {
+        startForeground(
+            notificationBuilder()
+                .setContentTitle(title)
+                .setContentText(content).build()
+        )
+    }
+
+    override fun onTrimMemory(level: Int) {
+        super.onTrimMemory(level)
+        GlobalState.getCurrentVPNPlugin()?.requestGc()
+    }
+
+
+    private val binder = LocalBinder()
+
+    inner class LocalBinder : Binder() {
+        fun getService(): FlClashService = this@FlClashService
+    }
+
+    override fun onBind(intent: Intent): IBinder {
+        return binder
+    }
+
+    override fun onUnbind(intent: Intent?): Boolean {
+        return super.onUnbind(intent)
+    }
+
+    override fun onDestroy() {
+        stop()
+        super.onDestroy()
+    }
+}

android/app/src/main/kotlin/com/follow/clash/services/FlClashTileService.kt

@@ -0,0 +1,76 @@
+package com.follow.clash.services
+
+import android.annotation.SuppressLint
+import android.app.PendingIntent
+import android.content.Intent
+import android.os.Build
+import android.service.quicksettings.Tile
+import android.service.quicksettings.TileService
+import androidx.annotation.RequiresApi
+import androidx.lifecycle.Observer
+import com.follow.clash.GlobalState
+import com.follow.clash.RunState
+import com.follow.clash.TempActivity
+
+
+@RequiresApi(Build.VERSION_CODES.N)
+class FlClashTileService : TileService() {
+
+    private val observer = Observer<RunState> { runState ->
+        updateTile(runState)
+    }
+
+    private fun updateTile(runState: RunState) {
+        if (qsTile != null) {
+            qsTile.state = when (runState) {
+                RunState.START -> Tile.STATE_ACTIVE
+                RunState.PENDING -> Tile.STATE_UNAVAILABLE
+                RunState.STOP -> Tile.STATE_INACTIVE
+            }
+            qsTile.updateTile()
+        }
+    }
+
+    override fun onStartListening() {
+        super.onStartListening()
+        GlobalState.runState.value?.let { updateTile(it) }
+        GlobalState.runState.observeForever(observer)
+    }
+
+    @SuppressLint("StartActivityAndCollapseDeprecated")
+    private fun activityTransfer() {
+        val intent = Intent(this, TempActivity::class.java)
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_MULTIPLE_TASK)
+        val pendingIntent = if (Build.VERSION.SDK_INT >= 31) {
+            PendingIntent.getActivity(
+                this,
+                0,
+                intent,
+                PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
+            )
+        } else {
+            PendingIntent.getActivity(
+                this,
+                0,
+                intent,
+                PendingIntent.FLAG_UPDATE_CURRENT
+            )
+        }
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+            startActivityAndCollapse(pendingIntent)
+        } else {
+            startActivityAndCollapse(intent)
+        }
+    }
+
+    override fun onClick() {
+        super.onClick()
+        activityTransfer()
+        GlobalState.handleToggle()
+    }
+
+    override fun onDestroy() {
+        GlobalState.runState.removeObserver(observer)
+        super.onDestroy()
+    }
+}

android/app/src/main/kotlin/com/follow/clash/services/FlClashVpnService.kt

@@ -0,0 +1,194 @@
+package com.follow.clash.services
+
+import android.annotation.SuppressLint
+import android.app.PendingIntent
+import android.content.Intent
+import android.net.ProxyInfo
+import android.net.VpnService
+import android.os.Binder
+import android.os.Build
+import android.os.IBinder
+import android.os.Parcel
+import android.os.RemoteException
+import android.util.Log
+import androidx.core.app.NotificationCompat
+import com.follow.clash.GlobalState
+import com.follow.clash.extensions.getIpv4RouteAddress
+import com.follow.clash.extensions.getIpv6RouteAddress
+import com.follow.clash.extensions.toCIDR
+import com.follow.clash.models.AccessControlMode
+import com.follow.clash.models.VpnOptions
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+
+
+class FlClashVpnService : VpnService(), BaseServiceInterface {
+    override fun onCreate() {
+        super.onCreate()
+        GlobalState.initServiceEngine()
+    }
+
+    override fun start(options: VpnOptions): Int {
+        return with(Builder()) {
+            if (options.ipv4Address.isNotEmpty()) {
+                val cidr = options.ipv4Address.toCIDR()
+                addAddress(cidr.address, cidr.prefixLength)
+                Log.d(
+                    "addAddress",
+                    "address: ${cidr.address} prefixLength:${cidr.prefixLength}"
+                )
+                val routeAddress = options.getIpv4RouteAddress()
+                if (routeAddress.isNotEmpty()) {
+                    try {
+                        routeAddress.forEach { i ->
+                            Log.d(
+                                "addRoute4",
+                                "address: ${i.address} prefixLength:${i.prefixLength}"
+                            )
+                            addRoute(i.address, i.prefixLength)
+                        }
+                    } catch (_: Exception) {
+                        addRoute("0.0.0.0", 0)
+                    }
+                } else {
+                    addRoute("0.0.0.0", 0)
+                }
+            } else {
+                addRoute("0.0.0.0", 0)
+            }
+            try {
+                if (options.ipv6Address.isNotEmpty()) {
+                    val cidr = options.ipv6Address.toCIDR()
+                    Log.d(
+                        "addAddress6",
+                        "address: ${cidr.address} prefixLength:${cidr.prefixLength}"
+                    )
+                    addAddress(cidr.address, cidr.prefixLength)
+                    val routeAddress = options.getIpv6RouteAddress()
+                    if (routeAddress.isNotEmpty()) {
+                        try {
+                            routeAddress.forEach { i ->
+                                Log.d(
+                                    "addRoute6",
+                                    "address: ${i.address} prefixLength:${i.prefixLength}"
+                                )
+                                addRoute(i.address, i.prefixLength)
+                            }
+                        } catch (_: Exception) {
+                            addRoute("::", 0)
+                        }
+                    } else {
+                        addRoute("::", 0)
+                    }
+                }
+            }catch (_:Exception){
+                Log.d(
+                    "addAddress6",
+                    "IPv6 is not supported."
+                )
+            }
+            addDnsServer(options.dnsServerAddress)
+            setMtu(9000)
+            options.accessControl.let { accessControl ->
+                if (accessControl.enable) {
+                    when (accessControl.mode) {
+                        AccessControlMode.acceptSelected -> {
+                            (accessControl.acceptList + packageName).forEach {
+                                addAllowedApplication(it)
+                            }
+                        }
+
+                        AccessControlMode.rejectSelected -> {
+                            (accessControl.rejectList - packageName).forEach {
+                                addDisallowedApplication(it)
+                            }
+                        }
+                    }
+                }
+            }
+            setSession("FlClash")
+            setBlocking(false)
+            if (Build.VERSION.SDK_INT >= 29) {
+                setMetered(false)
+            }
+            if (options.allowBypass) {
+                allowBypass()
+            }
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q && options.systemProxy) {
+                setHttpProxy(
+                    ProxyInfo.buildDirectProxy(
+                        "127.0.0.1",
+                        options.port,
+                        options.bypassDomain
+                    )
+                )
+            }
+            establish()?.detachFd()
+                ?: throw NullPointerException("Establish VPN rejected by system")
+        }
+    }
+
+    override fun stop() {
+        stopSelf()
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            stopForeground(STOP_FOREGROUND_REMOVE)
+        }
+    }
+
+    private var cachedBuilder: NotificationCompat.Builder? = null
+
+    private suspend fun notificationBuilder(): NotificationCompat.Builder {
+        if (cachedBuilder == null) {
+            cachedBuilder = createFlClashNotificationBuilder().await()
+        }
+        return cachedBuilder!!
+    }
+
+    @SuppressLint("ForegroundServiceType")
+    override suspend fun startForeground(title: String, content: String) {
+        startForeground(
+            notificationBuilder()
+                .setContentTitle(title)
+                .setContentText(content).build()
+        )
+    }
+
+    override fun onTrimMemory(level: Int) {
+        super.onTrimMemory(level)
+        GlobalState.getCurrentVPNPlugin()?.requestGc()
+    }
+
+    private val binder = LocalBinder()
+
+    inner class LocalBinder : Binder() {
+        fun getService(): FlClashVpnService = this@FlClashVpnService
+
+        override fun onTransact(code: Int, data: Parcel, reply: Parcel?, flags: Int): Boolean {
+            try {
+                val isSuccess = super.onTransact(code, data, reply, flags)
+                if (!isSuccess) {
+                    CoroutineScope(Dispatchers.Main).launch {
+                        GlobalState.getCurrentTilePlugin()?.handleStop()
+                    }
+                }
+                return isSuccess
+            } catch (e: RemoteException) {
+                throw e
+            }
+        }
+    }
+
+    override fun onBind(intent: Intent): IBinder {
+        return binder
+    }
+
+    override fun onUnbind(intent: Intent?): Boolean {
+        return super.onUnbind(intent)
+    }
+
+    override fun onDestroy() {
+        stop()
+        super.onDestroy()
+    }
+}

android/app/src/main/res/drawable/ic_launcher_foreground.xml

@@ -1,25 +1,25 @@
 <vector xmlns:android="http://schemas.android.com/apk/res/android"
-        android:width="108dp"
-        android:height="108dp"
-        android:viewportWidth="240"
-        android:viewportHeight="240">
-    <group android:scaleX="0.924"
-           android:scaleY="0.924"
-           android:translateX="9.12"
-           android:translateY="9.12">
-        <group android:scaleX="0.63461536"
-               android:scaleY="0.63461536"
-               android:translateX="45.96154"
-               android:translateY="43.846153">
-            <path
-                    android:pathData="M60.65,89.6L154.18,35.6A18,18 107.59,0 1,178.77 42.19L178.77,42.19A18,18 107.59,0 1,172.18 66.78L78.65,120.78A18,18 106.67,0 1,54.06 114.19L54.06,114.19A18,18 106.67,0 1,60.65 89.6z"
-                    android:fillColor="#6666FB"/>
-            <path
-                    android:pathData="M84.65,131.17L131.42,104.17A18,18 107.83,0 1,156 110.76L156,110.76A18,18 107.83,0 1,149.42 135.35L102.65,162.35A18,18 106.67,0 1,78.06 155.76L78.06,155.76A18,18 106.67,0 1,84.65 131.17z"
-                    android:fillColor="#336AB6"/>
-            <path
-                    android:pathData="M108.65,172.74L108.65,172.74A18,18 116.03,0 1,133.24 179.33L133.24,179.33A18,18 116.03,0 1,126.65 203.92L126.65,203.92A18,18 116.03,0 1,102.06 197.33L102.06,197.33A18,18 116.03,0 1,108.65 172.74z"
-                    android:fillColor="#5CA8E9"/>
-        </group>
+    android:width="108dp"
+    android:height="108dp"
+    android:viewportWidth="240"
+    android:viewportHeight="240">
+  <group android:scaleX="0.924"
+      android:scaleY="0.924"
+      android:translateX="9.12"
+      android:translateY="9.12">
+    <group android:scaleX="0.63461536"
+        android:scaleY="0.63461536"
+        android:translateX="45.96154"
+        android:translateY="43.846153">
+      <path
+          android:pathData="M60.65,89.6L154.18,35.6A18,18 107.59,0 1,178.77 42.19L178.77,42.19A18,18 107.59,0 1,172.18 66.78L78.65,120.78A18,18 106.67,0 1,54.06 114.19L54.06,114.19A18,18 106.67,0 1,60.65 89.6z"
+          android:fillColor="#6666FB"/>
+      <path
+          android:pathData="M84.65,131.17L131.42,104.17A18,18 107.83,0 1,156 110.76L156,110.76A18,18 107.83,0 1,149.42 135.35L102.65,162.35A18,18 106.67,0 1,78.06 155.76L78.06,155.76A18,18 106.67,0 1,84.65 131.17z"
+          android:fillColor="#336AB6"/>
+      <path
+          android:pathData="M108.65,172.74L108.65,172.74A18,18 116.03,0 1,133.24 179.33L133.24,179.33A18,18 116.03,0 1,126.65 203.92L126.65,203.92A18,18 116.03,0 1,102.06 197.33L102.06,197.33A18,18 116.03,0 1,108.65 172.74z"
+          android:fillColor="#5CA8E9"/>
     </group>
+  </group>
 </vector>

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

@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
-    <string name="FlClash">FlClash</string>
+    <string name="fl_clash">FlClash</string>
 </resources>

android/build.gradle

@@ -0,0 +1,33 @@
+buildscript {
+    ext.kotlin_version = "${kotlin_version}"
+    repositories {
+        google()
+        mavenCentral()
+    }
+
+    dependencies {
+        classpath "com.android.tools.build:gradle:$agp_version"
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    }
+}
+
+allprojects {
+    repositories {
+        google()
+        mavenCentral()
+    }
+}
+
+rootProject.buildDir = '../build'
+subprojects {
+    project.buildDir = "${rootProject.buildDir}/${project.name}"
+}
+subprojects {
+    project.evaluationDependsOn(':app')
+    project.evaluationDependsOn(':core')
+}
+
+tasks.register("clean", Delete) {
+    delete rootProject.buildDir
+}
+

android/build.gradle.kts

@@ -1,34 +0,0 @@
-buildscript {
-    dependencies {
-        classpath(libs.build.kotlin)
-    }
-}
-
-plugins {
-    id("com.android.library") apply false
-}
-
-allprojects {
-    repositories {
-        google()
-        mavenCentral()
-    }
-}
-val newBuildDir: Directory =
-    rootProject.layout.buildDirectory
-        .dir("../../build")
-        .get()
-rootProject.layout.buildDirectory.value(newBuildDir)
-
-subprojects {
-    val newSubprojectBuildDir: Directory = newBuildDir.dir(project.name)
-    project.layout.buildDirectory.value(newSubprojectBuildDir)
-}
-subprojects {
-    project.evaluationDependsOn(":app")
-}
-
-tasks.register<Delete>("clean") {
-    delete(rootProject.layout.buildDirectory)
-}
-

android/common/.gitignore

@@ -1 +0,0 @@
-/build

android/common/build.gradle.kts

@@ -1,45 +0,0 @@
-import org.jetbrains.kotlin.gradle.dsl.JvmTarget
-
-plugins {
-    id("com.android.library")
-    id("org.jetbrains.kotlin.android")
-}
-
-android {
-    namespace = "com.follow.clash.common"
-    compileSdk = libs.versions.compileSdk.get().toInt()
-
-    defaultConfig {
-        minSdk = 21
-        consumerProguardFiles("consumer-rules.pro")
-    }
-
-    buildTypes {
-        release {
-            proguardFiles(
-                getDefaultProguardFile("proguard-android-optimize.txt"),
-                "proguard-rules.pro"
-            )
-        }
-    }
-
-    compileOptions {
-        sourceCompatibility = JavaVersion.VERSION_17
-        targetCompatibility = JavaVersion.VERSION_17
-    }
-
-}
-
-kotlin {
-    compilerOptions {
-        jvmTarget.set(JvmTarget.JVM_17)
-    }
-}
-
-dependencies {
-    implementation(libs.androidx.core)
-    implementation(libs.gson)
-    implementation(platform(libs.firebase.bom))
-    implementation(libs.firebase.crashlytics.ndk)
-    implementation(libs.firebase.analytics)
-}

android/common/src/main/AndroidManifest.xml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
-
-    <permission
-        android:name="${applicationId}.permission.RECEIVE_BROADCASTS"
-        android:protectionLevel="signature" />
-
-    <uses-permission android:name="${applicationId}.permission.RECEIVE_BROADCASTS" />
-</manifest>

android/common/src/main/java/com/follow/clash/common/Components.kt

@@ -1,16 +0,0 @@
-package com.follow.clash.common
-
-import android.content.ComponentName
-
-object Components {
-    const val PACKAGE_NAME = "com.follow.clash"
-
-    val MAIN_ACTIVITY =
-        ComponentName(GlobalState.packageName, "${PACKAGE_NAME}.MainActivity")
-
-    val TEMP_ACTIVITY =
-        ComponentName(GlobalState.packageName, "${PACKAGE_NAME}.TempActivity")
-
-    val BROADCAST_RECEIVER =
-        ComponentName(GlobalState.packageName, "${PACKAGE_NAME}.BroadcastReceiver")
-}

android/common/src/main/java/com/follow/clash/common/Enums.kt

@@ -1,23 +0,0 @@
-package com.follow.clash.common
-
-import com.google.gson.annotations.SerializedName
-
-
-enum class QuickAction {
-    STOP,
-    START,
-    TOGGLE,
-}
-
-enum class BroadcastAction {
-    SERVICE_CREATED,
-    SERVICE_DESTROYED,
-}
-
-enum class AccessControlMode {
-    @SerializedName("acceptSelected")
-    ACCEPT_SELECTED,
-
-    @SerializedName("rejectSelected")
-    REJECT_SELECTED,
-}

android/common/src/main/java/com/follow/clash/common/Ext.kt

@@ -1,250 +0,0 @@
-package com.follow.clash.common
-
-import android.annotation.SuppressLint
-import android.app.ActivityManager
-import android.app.Notification
-import android.app.NotificationChannel
-import android.app.NotificationManager
-import android.app.PendingIntent
-import android.app.Service
-import android.content.BroadcastReceiver
-import android.content.ComponentName
-import android.content.Context
-import android.content.Context.RECEIVER_NOT_EXPORTED
-import android.content.Intent
-import android.content.IntentFilter
-import android.content.ServiceConnection
-import android.content.pm.ServiceInfo.FOREGROUND_SERVICE_TYPE_SPECIAL_USE
-import android.os.Build
-import android.os.Handler
-import android.os.IBinder
-import android.os.Looper
-import android.os.RemoteException
-import android.util.Log
-import androidx.core.content.getSystemService
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.channels.awaitClose
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.callbackFlow
-import kotlinx.coroutines.flow.retryWhen
-import kotlinx.coroutines.withContext
-import java.nio.charset.Charset
-import kotlin.reflect.KClass
-
-//fun Context.startForegroundServiceCompat(intent: Intent?) {
-//    if (Build.VERSION.SDK_INT >= 26) {
-//        startForegroundService(intent)
-//    } else {
-//        startService(intent)
-//    }
-//}
-
-val KClass<*>.intent: Intent
-    get() = Intent(GlobalState.application, this.java)
-
-fun Service.startForegroundCompat(id: Int, notification: Notification) {
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
-        startForeground(id, notification, FOREGROUND_SERVICE_TYPE_SPECIAL_USE)
-    } else {
-        startForeground(id, notification)
-    }
-}
-
-val ComponentName.intent: Intent
-    get() = Intent().apply {
-        setComponent(this@intent)
-        setPackage(GlobalState.packageName)
-    }
-
-val QuickAction.action: String
-    get() = "${GlobalState.application.packageName}.action.${this.name}"
-
-val QuickAction.quickIntent: Intent
-    get() = Components.TEMP_ACTIVITY.intent.apply {
-        action = this@quickIntent.action
-        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_MULTIPLE_TASK)
-    }
-
-val BroadcastAction.action: String
-    get() = "${GlobalState.application.packageName}.intent.action.${this.name}"
-
-val Context.processName: String?
-    get() {
-        val pid = android.os.Process.myPid()
-        val activityManager = getSystemService<ActivityManager>()
-        activityManager?.runningAppProcesses?.find { it.pid == pid }?.let {
-            return it.processName
-        }
-        return null
-    }
-
-val BroadcastAction.quickIntent: Intent
-    get() = Components.BROADCAST_RECEIVER.intent.apply {
-        action = this@quickIntent.action
-    }
-
-fun BroadcastAction.sendBroadcast() {
-    val intent = Intent().apply {
-        action = this@sendBroadcast.action
-        Log.d("[sendBroadcast]", "$action")
-        setPackage(GlobalState.packageName)
-    }
-    GlobalState.application.sendBroadcast(
-        intent, GlobalState.RECEIVE_BROADCASTS_PERMISSIONS
-    )
-}
-
-
-val Intent.toPendingIntent: PendingIntent
-    get() = PendingIntent.getActivity(
-        GlobalState.application,
-        0,
-        this,
-        PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
-    )
-
-
-fun Service.startForeground(notification: Notification) {
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-        val manager = getSystemService(NotificationManager::class.java)
-        var channel = manager?.getNotificationChannel(GlobalState.NOTIFICATION_CHANNEL)
-        if (channel == null) {
-            channel = NotificationChannel(
-                GlobalState.NOTIFICATION_CHANNEL,
-                "SERVICE_CHANNEL",
-                NotificationManager.IMPORTANCE_LOW
-            )
-            manager?.createNotificationChannel(channel)
-        }
-    }
-    startForegroundCompat(GlobalState.NOTIFICATION_ID, notification)
-}
-
-@SuppressLint("UnspecifiedRegisterReceiverFlag")
-fun Context.registerReceiverCompat(
-    receiver: BroadcastReceiver,
-    filter: IntentFilter,
-) = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-    registerReceiver(receiver, filter, RECEIVER_NOT_EXPORTED)
-} else {
-    registerReceiver(receiver, filter)
-}
-
-fun Context.receiveBroadcastFlow(
-    configure: IntentFilter.() -> Unit,
-): Flow<Intent> = callbackFlow {
-    val filter = IntentFilter().apply(configure)
-    val receiver = object : BroadcastReceiver() {
-        override fun onReceive(context: Context?, intent: Intent?) {
-            if (context == null || intent == null) return
-            trySend(intent)
-        }
-    }
-    registerReceiverCompat(receiver, filter)
-    awaitClose { unregisterReceiver(receiver) }
-}
-
-
-inline fun <reified T : IBinder> Context.bindServiceFlow(
-    intent: Intent,
-    flags: Int = Context.BIND_AUTO_CREATE,
-    maxRetries: Int = 10,
-    retryDelayMillis: Long = 200L
-): Flow<Pair<IBinder?, String>> = callbackFlow {
-    val connection = object : ServiceConnection {
-        override fun onServiceConnected(name: ComponentName?, binder: IBinder?) {
-            if (binder != null) {
-                try {
-                    @Suppress("UNCHECKED_CAST") val casted = binder as? T
-                    if (casted != null) {
-                        trySend(Pair(casted, ""))
-                    } else {
-                        trySend(Pair(null, "Binder is not of type ${T::class.java}"))
-                    }
-                } catch (e: RemoteException) {
-                    trySend(Pair(null, "Failed to link to death: ${e.message}"))
-                }
-            } else {
-                trySend(Pair(null, "Binder empty"))
-            }
-        }
-
-        override fun onServiceDisconnected(name: ComponentName?) {
-            trySend(Pair(null, "Service disconnected"))
-        }
-    }
-
-    val success = withContext(Dispatchers.Main) {
-        bindService(intent, connection, flags)
-    }
-
-    if (!success) {
-        throw IllegalStateException("bindService() failed, will retry")
-    }
-
-    awaitClose {
-        Handler(Looper.getMainLooper()).post {
-            unbindService(connection)
-            trySend(Pair(null, ""))
-        }
-    }
-}.retryWhen { cause, attempt ->
-    if (attempt < maxRetries && cause is Exception) {
-        delay(retryDelayMillis)
-        true
-    } else {
-        false
-    }
-}
-
-
-val Long.formatBytes: String
-    get() {
-        val units = arrayOf("B", "KB", "MB", "GB", "TB")
-        var size = this.toDouble()
-        var unitIndex = 0
-
-        while (size >= 1024 && unitIndex < units.size - 1) {
-            size /= 1024
-            unitIndex++
-        }
-
-        return if (unitIndex == 0) {
-            "${size.toLong()}${units[unitIndex]}"
-        } else {
-            "%.1f${units[unitIndex]}".format(size)
-        }
-    }
-
-fun String.chunkedForAidl(charset: Charset = Charsets.UTF_8): List<ByteArray> {
-    val allBytes = toByteArray(charset)
-    val total = allBytes.size
-    val maxBytes = when {
-        total <= 100 * 1024 -> total
-        total <= 1024 * 1024 -> 64 * 1024
-        total <= 10 * 1024 * 1024 -> 128 * 1024
-        else -> 256 * 1024
-    }
-
-    val result = mutableListOf<ByteArray>()
-    var index = 0
-    while (index < total) {
-        val end = minOf(index + maxBytes, total)
-        result.add(allBytes.copyOfRange(index, end))
-        index = end
-    }
-    return result
-}
-
-
-fun <T : List<ByteArray>> T.formatString(charset: Charset = Charsets.UTF_8): String {
-    val totalSize = this.sumOf { it.size }
-    val combined = ByteArray(totalSize)
-    var offset = 0
-    forEach { byteArray ->
-        byteArray.copyInto(combined, offset)
-        offset += byteArray.size
-    }
-    return String(combined, charset)
-}

android/common/src/main/java/com/follow/clash/common/GlobalState.kt

@@ -1,47 +0,0 @@
-package com.follow.clash.common
-
-
-import android.app.Application
-import android.util.Log
-import com.google.firebase.FirebaseApp
-import com.google.firebase.crashlytics.FirebaseCrashlytics
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-
-object GlobalState : CoroutineScope by CoroutineScope(Dispatchers.Default) {
-
-    const val NOTIFICATION_CHANNEL = "FlClash"
-
-    const val NOTIFICATION_ID = 1
-
-    val packageName: String
-        get() = application.packageName
-
-    val RECEIVE_BROADCASTS_PERMISSIONS: String
-        get() = "${packageName}.permission.RECEIVE_BROADCASTS"
-
-
-    private var _application: Application? = null
-
-    val application: Application
-        get() = _application!!
-
-
-    fun log(text: String) {
-        Log.d("[FlClash]", text)
-    }
-
-    fun init(application: Application) {
-        _application = application
-    }
-
-    fun setCrashlytics(enable: Boolean) {
-        _application?.let {
-            FirebaseApp.initializeApp(it)
-            FirebaseCrashlytics.getInstance().isCrashlyticsCollectionEnabled = enable
-            if (enable) {
-                log("init crashlytics ${it.processName}")
-            }
-        }
-    }
-}

android/common/src/main/java/com/follow/clash/common/Service.kt

@@ -1,78 +0,0 @@
-package com.follow.clash.common
-
-import android.content.Intent
-import android.os.IBinder
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.filterNotNull
-import kotlinx.coroutines.flow.first
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
-import kotlinx.coroutines.withTimeout
-import java.util.concurrent.atomic.AtomicBoolean
-
-class ServiceDelegate<T>(
-    private val intent: Intent,
-    private val onServiceDisconnected: ((String) -> Unit)? = null,
-    private val interfaceCreator: (IBinder) -> T,
-) : CoroutineScope by CoroutineScope(SupervisorJob() + Dispatchers.Default) {
-
-    private val _bindingState = AtomicBoolean(false)
-
-    private var _serviceState = MutableStateFlow<Pair<T?, String>?>(null)
-
-    val serviceState: StateFlow<Pair<T?, String>?> = _serviceState
-    private var job: Job? = null
-
-    private fun handleBind(data: Pair<IBinder?, String>) {
-        data.first?.let {
-            _serviceState.value = Pair(interfaceCreator(it), data.second)
-        } ?: run {
-            _serviceState.value = Pair(null, data.second)
-            unbind()
-            onServiceDisconnected?.invoke(data.second)
-            _bindingState.set(false)
-        }
-    }
-
-    fun bind() {
-        if (_bindingState.compareAndSet(false, true)) {
-            job?.cancel()
-            job = null
-            _serviceState.value = null
-            job = launch {
-                runCatching {
-                    GlobalState.application.bindServiceFlow<IBinder>(intent)
-                        .collect { handleBind(it) }
-                }
-            }
-        }
-    }
-
-    suspend inline fun <R> useService(
-        timeoutMillis: Long = 5000, crossinline block: suspend (T) -> R
-    ): Result<R> {
-        return runCatching {
-            withTimeout(timeoutMillis) {
-                val state = serviceState.filterNotNull().first()
-                state.first?.let {
-                    withContext(Dispatchers.Default) {
-                        block(it)
-                    }
-                } ?: throw Exception(state.second)
-            }
-        }
-    }
-
-    fun unbind() {
-        if (_bindingState.compareAndSet(true, false)) {
-            job?.cancel()
-            job = null
-            _serviceState.value = null
-        }
-    }
-}

android/common/src/main/java/com/follow/clash/common/Utils.kt

@@ -1,14 +0,0 @@
-package com.follow.clash.common
-
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.flow
-
-
-fun tickerFlow(delayMillis: Long, initialDelayMillis: Long = delayMillis): Flow<Unit> = flow {
-    delay(initialDelayMillis)
-    while (true) {
-        emit(Unit)
-        delay(delayMillis)
-    }
-}

android/core/build.gradle.kts

@@ -1,4 +1,4 @@
-import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+import com.android.build.gradle.tasks.MergeSourceSetFolders
 
 plugins {
     id("com.android.library")
@@ -7,13 +7,22 @@ plugins {
 
 android {
     namespace = "com.follow.clash.core"
-    compileSdk = libs.versions.compileSdk.get().toInt()
-    ndkVersion = libs.versions.ndkVersion.get()
+    compileSdk = 35
+    ndkVersion = "28.0.13004108"
 
     defaultConfig {
-        minSdk = libs.versions.minSdk.get().toInt()
+        minSdk = 21
+        consumerProguardFiles("consumer-rules.pro")
     }
 
+    buildTypes {
+        release {
+            proguardFiles(
+                getDefaultProguardFile("proguard-android-optimize.txt"),
+                "proguard-rules.pro"
+            )
+        }
+    }
 
     sourceSets {
         getByName("main") {
@@ -29,53 +38,28 @@ android {
     }
 
     compileOptions {
-        sourceCompatibility = JavaVersion.VERSION_17
-        targetCompatibility = JavaVersion.VERSION_17
+        sourceCompatibility = JavaVersion.VERSION_11
+        targetCompatibility = JavaVersion.VERSION_11
     }
-
-    buildTypes {
-        release {
-            proguardFiles(
-                getDefaultProguardFile("proguard-android-optimize.txt"),
-                "proguard-rules.pro"
-            )
-        }
+    kotlinOptions {
+        jvmTarget = "11"
     }
 }
 
-kotlin {
-    compilerOptions {
-        jvmTarget.set(JvmTarget.JVM_17)
-    }
-}
-
-
-dependencies {
-    implementation(libs.annotation.jvm)
-}
-
 val copyNativeLibs by tasks.register<Copy>("copyNativeLibs") {
     doFirst {
         delete("src/main/jniLibs")
     }
     from("../../libclash/android")
     into("src/main/jniLibs")
-
-    doLast {
-        val includesDir = file("src/main/jniLibs/includes")
-        val targetDir = file("src/main/cpp/includes")
-        if (includesDir.exists()) {
-            copy {
-                from(includesDir)
-                into(targetDir)
-            }
-            delete(includesDir)
-        }
-    }
 }
 
 afterEvaluate {
     tasks.named("preBuild") {
         dependsOn(copyNativeLibs)
     }
+}
+
+dependencies {
+    implementation("androidx.core:core-ktx:1.16.0")
 }

android/core/proguard-rules.pro

@@ -0,0 +1,21 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# 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 *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile

android/core/src/main/AndroidManifest.xml

@@ -1,5 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
 
-    <uses-permission android:name="android.permission.INTERNET" />
 </manifest>

android/core/src/main/cpp/CMakeLists.txt

@@ -4,13 +4,23 @@ project("core")
 
 message("CMAKE_SOURCE_DIR ${CMAKE_SOURCE_DIR}")
 
-message("CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE}")
-
-
 if (NOT "${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
-    set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type" FORCE)
-    add_compile_options(-O3 -flto -g0 -fno-exceptions -fno-rtti)
-    add_link_options(-flto -Wl,--gc-sections,--strip-all)
+    add_compile_options(-O3)
+
+    add_compile_options(-flto)
+
+    add_compile_options(-g0)
+
+    add_compile_options(-ffunction-sections -fdata-sections)
+
+    add_compile_options(-fno-exceptions -fno-rtti)
+
+    add_link_options(
+            -flto
+            -Wl,--gc-sections
+            -Wl,--strip-all
+            -Wl,--exclude-libs=ALL
+    )
 endif ()
 
 set(LIB_CLASH_PATH "${CMAKE_SOURCE_DIR}/../jniLibs/${ANDROID_ABI}/libclash.so")
@@ -19,7 +29,7 @@ message("LIB_CLASH_PATH ${LIB_CLASH_PATH}")
 if (EXISTS ${LIB_CLASH_PATH})
     message("Found libclash.so for ABI ${ANDROID_ABI}")
     add_compile_definitions(LIBCLASH)
-    include_directories(${CMAKE_SOURCE_DIR}/../cpp/includes/${ANDROID_ABI})
+    include_directories(${CMAKE_SOURCE_DIR}/../jniLibs/${ANDROID_ABI})
     link_directories(${CMAKE_SOURCE_DIR}/../jniLibs/${ANDROID_ABI})
     add_library(${CMAKE_PROJECT_NAME} SHARED
             jni_helper.cpp

android/core/src/main/cpp/core.cpp

@@ -1,17 +1,16 @@
 #include <jni.h>
 
 #ifdef LIBCLASH
-
+#include <jni.h>
+#include <string>
 #include "jni_helper.h"
 #include "libclash.h"
-#include "bride.h"
 
 extern "C"
 JNIEXPORT void JNICALL
-Java_com_follow_clash_core_Core_startTun(JNIEnv *env, jobject thiz, jint fd, jobject cb,
-                                         jstring stack, jstring address, jstring dns) {
-    const auto interface = new_global(cb);
-    startTUN(interface, fd, get_string(stack), get_string(address), get_string(dns));
+Java_com_follow_clash_core_Core_startTun(JNIEnv *env, jobject thiz, jint fd, jobject cb) {
+    auto interface = new_global(cb);
+    startTUN(fd, interface);
 }
 
 extern "C"
@@ -20,175 +19,57 @@ Java_com_follow_clash_core_Core_stopTun(JNIEnv *env, jobject thiz) {
     stopTun();
 }
 
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_follow_clash_core_Core_forceGC(JNIEnv *env, jobject thiz) {
-    forceGC();
-}
-
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_follow_clash_core_Core_updateDNS(JNIEnv *env, jobject thiz, jstring dns) {
-    updateDns(get_string(dns));
-}
-
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_follow_clash_core_Core_invokeAction(JNIEnv *env, jobject thiz, jstring data, jobject cb) {
-    const auto interface = new_global(cb);
-    invokeAction(interface, get_string(data));
-}
-
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_follow_clash_core_Core_setEventListener(JNIEnv *env, jobject thiz, jobject cb) {
-    if (cb != nullptr) {
-        const auto interface = new_global(cb);
-        setEventListener(interface);
-    } else {
-        setEventListener(nullptr);
-    }
-}
-
-extern "C"
-JNIEXPORT jstring JNICALL
-Java_com_follow_clash_core_Core_getTraffic(JNIEnv *env, jobject thiz,
-                                           const jboolean only_statistics_proxy) {
-    return new_string(getTraffic(only_statistics_proxy));
-}
-
-extern "C"
-JNIEXPORT jstring JNICALL
-Java_com_follow_clash_core_Core_getTotalTraffic(JNIEnv *env, jobject thiz,
-                                                const jboolean only_statistics_proxy) {
-    return new_string(getTotalTraffic(only_statistics_proxy));
-}
-
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_follow_clash_core_Core_suspended(JNIEnv *env, jobject thiz, jboolean suspended) {
-    suspend(suspended);
-}
-
 
 static jmethodID m_tun_interface_protect;
 static jmethodID m_tun_interface_resolve_process;
-static jmethodID m_invoke_interface_result;
 
 
 static void release_jni_object_impl(void *obj) {
     ATTACH_JNI();
-    del_global(static_cast<jobject>(obj));
+    del_global((jobject) obj);
 }
 
-static void free_string_impl(char *str) {
-    free(str);
-}
-
-static void call_tun_interface_protect_impl(void *tun_interface, const int fd) {
+static void call_tun_interface_protect_impl(void *tun_interface, int fd) {
     ATTACH_JNI();
-    env->CallVoidMethod(static_cast<jobject>(tun_interface),
-                        m_tun_interface_protect,
-                        fd);
+    env->CallVoidMethod((jobject) tun_interface,
+                        (jmethodID) m_tun_interface_protect,
+                        (jint) fd);
 }
 
-static char *
-call_tun_interface_resolve_process_impl(void *tun_interface, const int protocol,
-                                        const char *source,
-                                        const char *target,
-                                        const int uid) {
+static const char*
+call_tun_interface_resolve_process_impl(void *tun_interface, int protocol,
+                                         const char *source,
+                                         const char *target,
+                                         int uid) {
     ATTACH_JNI();
-    const auto packageName = reinterpret_cast<jstring>(env->CallObjectMethod(
-        static_cast<jobject>(tun_interface),
-        m_tun_interface_resolve_process,
-        protocol,
-        new_string(source),
-        new_string(target),
-        uid));
+    jstring packageName = (jstring)env->CallObjectMethod((jobject) tun_interface,
+                              (jmethodID) m_tun_interface_resolve_process,
+                              (jint) protocol,
+                              (jstring) new_string(source),
+                              (jstring) new_string(target),
+                              (jint) uid);
     return get_string(packageName);
 }
 
-static void call_invoke_interface_result_impl(void *invoke_interface, const char *data) {
-    ATTACH_JNI();
-    env->CallVoidMethod(static_cast<jobject>(invoke_interface),
-                        m_invoke_interface_result,
-                        new_string(data));
-}
-
 extern "C"
 JNIEXPORT jint JNICALL
-JNI_OnLoad(JavaVM *vm, void *) {
+JNI_OnLoad(JavaVM *vm, void *reserved) {
     JNIEnv *env = nullptr;
-    if (vm->GetEnv(reinterpret_cast<void **>(&env), JNI_VERSION_1_6) != JNI_OK) {
+    if (vm->GetEnv((void **) &env, JNI_VERSION_1_6) != JNI_OK) {
         return JNI_ERR;
     }
 
     initialize_jni(vm, env);
 
-    const auto c_tun_interface = find_class("com/follow/clash/core/TunInterface");
-
-    const auto c_invoke_interface = find_class("com/follow/clash/core/InvokeInterface");
+    jclass c_tun_interface = find_class("com/follow/clash/core/TunInterface");
 
     m_tun_interface_protect = find_method(c_tun_interface, "protect", "(I)V");
     m_tun_interface_resolve_process = find_method(c_tun_interface, "resolverProcess",
-                                                  "(ILjava/lang/String;Ljava/lang/String;I)Ljava/lang/String;");
-    m_invoke_interface_result = find_method(c_invoke_interface, "onResult",
-                                            "(Ljava/lang/String;)V");
-
-
-    protect_func = &call_tun_interface_protect_impl;
-    resolve_process_func = &call_tun_interface_resolve_process_impl;
-    result_func = &call_invoke_interface_result_impl;
-    release_object_func = &release_jni_object_impl;
-    free_string_func = &free_string_impl;
+                                                   "(ILjava/lang/String;Ljava/lang/String;I)Ljava/lang/String;");
 
+    registerCallbacks(&call_tun_interface_protect_impl,
+                      &call_tun_interface_resolve_process_impl,
+                      &release_jni_object_impl);
     return JNI_VERSION_1_6;
 }
-#else
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_follow_clash_core_Core_startTun(JNIEnv *env, jobject thiz, jint fd, jobject cb,
-                                         jstring stack, jstring address, jstring dns) {
-}
-
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_follow_clash_core_Core_stopTun(JNIEnv *env, jobject thiz) {
-}
-
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_follow_clash_core_Core_invokeAction(JNIEnv *env, jobject thiz, jstring data, jobject cb) {
-}
-
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_follow_clash_core_Core_forceGC(JNIEnv *env, jobject thiz) {
-}
-
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_follow_clash_core_Core_updateDNS(JNIEnv *env, jobject thiz, jstring dns) {
-}
-
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_follow_clash_core_Core_setEventListener(JNIEnv *env, jobject thiz, jobject cb) {
-}
-
-extern "C"
-JNIEXPORT jstring JNICALL
-Java_com_follow_clash_core_Core_getTraffic(JNIEnv *env, jobject thiz,
-                                           const jboolean only_statistics_proxy) {
-}
-extern "C"
-JNIEXPORT jstring JNICALL
-Java_com_follow_clash_core_Core_getTotalTraffic(JNIEnv *env, jobject thiz,
-                                                const jboolean only_statistics_proxy) {
-}
-
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_follow_clash_core_Core_suspended(JNIEnv *env, jobject thiz, jboolean suspended) {
-}
-#endif
+#endif

android/core/src/main/cpp/jni_helper.cpp

@@ -1,6 +1,5 @@
 #include "jni_helper.h"
 
-#include <cstdlib>
 #include <malloc.h>
 #include <cstring>
 
@@ -13,7 +12,7 @@ static jmethodID m_get_bytes;
 void initialize_jni(JavaVM *vm, JNIEnv *env) {
     global_vm = vm;
 
-    c_string = reinterpret_cast<jclass>(new_global(find_class("java/lang/String")));
+    c_string = (jclass) new_global(find_class("java/lang/String"));
     m_new_string = find_method(c_string, "<init>", "([B)V");
     m_get_bytes = find_method(c_string, "getBytes", "()[B");
 }
@@ -23,23 +22,23 @@ JavaVM *global_java_vm() {
 }
 
 char *jni_get_string(JNIEnv *env, jstring str) {
-    const auto array = reinterpret_cast<jbyteArray>(env->CallObjectMethod(str, m_get_bytes));
-    const int length = env->GetArrayLength(array);
-    const auto content = static_cast<char *>(malloc(length + 1));
-    env->GetByteArrayRegion(array, 0, length, reinterpret_cast<jbyte *>(content));
+    auto array = (jbyteArray) env->CallObjectMethod(str, m_get_bytes);
+    int length = env->GetArrayLength(array);
+    char *content = (char *) malloc(length + 1);
+    env->GetByteArrayRegion(array, 0, length, (jbyte *) content);
     content[length] = 0;
     return content;
 }
 
 jstring jni_new_string(JNIEnv *env, const char *str) {
-    const auto length = static_cast<int>(strlen(str));
-    const auto array = env->NewByteArray(length);
-    env->SetByteArrayRegion(array, 0, length, reinterpret_cast<const jbyte *>(str));
-    return reinterpret_cast<jstring>(env->NewObject(c_string, m_new_string, array));
+    auto length = (int) strlen(str);
+    jbyteArray array = env->NewByteArray(length);
+    env->SetByteArrayRegion(array, 0, length, (const jbyte *) str);
+    return (jstring) env->NewObject(c_string, m_new_string, array);
 }
 
 int jni_catch_exception(JNIEnv *env) {
-    const int result = env->ExceptionCheck();
+    int result = env->ExceptionCheck();
     if (result) {
         env->ExceptionDescribe();
         env->ExceptionClear();
@@ -47,9 +46,9 @@ int jni_catch_exception(JNIEnv *env) {
     return result;
 }
 
-void jni_attach_thread(scoped_jni *jni) {
+void jni_attach_thread(struct scoped_jni *jni) {
     JavaVM *vm = global_java_vm();
-    if (vm->GetEnv(reinterpret_cast<void **>(&jni->env), JNI_VERSION_1_6) == JNI_OK) {
+    if (vm->GetEnv((void **) &jni->env, JNI_VERSION_1_6) == JNI_OK) {
         jni->require_release = 0;
         return;
     }
@@ -59,9 +58,9 @@ void jni_attach_thread(scoped_jni *jni) {
     jni->require_release = 1;
 }
 
-void jni_detach_thread(const scoped_jni *env) {
+void jni_detach_thread(struct scoped_jni *jni) {
     JavaVM *vm = global_java_vm();
-    if (env->require_release) {
+    if (jni->require_release) {
         vm->DetachCurrentThread();
     }
 }

android/core/src/main/cpp/jni_helper.h

@@ -1,6 +1,9 @@
 #pragma once
 
 #include <jni.h>
+#include <cstdint>
+#include <cstdlib>
+#include <malloc.h>
 
 struct scoped_jni {
     JNIEnv *env;
@@ -15,14 +18,14 @@ extern char *jni_get_string(JNIEnv *env, jstring str);
 
 extern int jni_catch_exception(JNIEnv *env);
 
-extern void jni_attach_thread(scoped_jni *jni);
+extern void jni_attach_thread(struct scoped_jni *jni);
 
-extern void jni_detach_thread(const scoped_jni *env);
+extern void jni_detach_thread(struct scoped_jni *env);
 
-extern void release_string( char **str);
+extern void release_string(char **str);
 
 #define ATTACH_JNI() __attribute__((unused, cleanup(jni_detach_thread))) \
-                    scoped_jni _jni{}; \
+                    struct scoped_jni _jni; \
                     jni_attach_thread(&_jni); \
                     JNIEnv *env = _jni.env
 
@@ -33,4 +36,4 @@ extern void release_string( char **str);
 #define new_global(obj) env->NewGlobalRef(obj)
 #define del_global(obj) env->DeleteGlobalRef(obj)
 #define get_string(jstr) jni_get_string(env, jstr)
-#define new_string(cstr) jni_new_string(env, cstr)
+#define new_string(cstr) jni_new_string(env, cstr)

android/core/src/main/java/com/follow/clash/core/Core.kt

@@ -7,17 +7,7 @@ import java.net.URL
 data object Core {
     private external fun startTun(
         fd: Int,
-        cb: TunInterface,
-        stack: String,
-        address: String,
-        dns: String,
-    )
-
-    external fun forceGC(
-    )
-
-    external fun updateDNS(
-        dns: String,
+        cb: TunInterface
     )
 
     private fun parseInetSocketAddress(address: String): InetSocketAddress {
@@ -29,85 +19,31 @@ data object Core {
     fun startTun(
         fd: Int,
         protect: (Int) -> Boolean,
-        resolverProcess: (protocol: Int, source: InetSocketAddress, target: InetSocketAddress, uid: Int) -> String,
-        stack: String,
-        address: String,
-        dns: String,
+        resolverProcess: (protocol: Int, source: InetSocketAddress, target: InetSocketAddress, uid: Int) -> String
     ) {
-        startTun(
-            fd,
-            object : TunInterface {
-                override fun protect(fd: Int) {
-                    protect(fd)
-                }
+        startTun(fd, object : TunInterface {
+            override fun protect(fd: Int) {
+                protect(fd)
+            }
 
-                override fun resolverProcess(
-                    protocol: Int,
-                    source: String,
-                    target: String,
-                    uid: Int
-                ): String {
-                    return resolverProcess(
-                        protocol,
-                        parseInetSocketAddress(source),
-                        parseInetSocketAddress(target),
-                        uid,
-                    )
-                }
-            },
-            stack,
-            address,
-            dns
-        )
-    }
-
-    external fun suspended(
-        suspended: Boolean,
-    )
-
-    private external fun invokeAction(
-        data: String,
-        cb: InvokeInterface
-    )
-
-    fun invokeAction(
-        data: String,
-        cb: (result: String?) -> Unit
-    ) {
-        invokeAction(
-            data,
-            object : InvokeInterface {
-                override fun onResult(result: String?) {
-                    cb(result)
-                }
-            },
-        )
-    }
-
-    private external fun setEventListener(cb: InvokeInterface?)
-
-    fun callSetEventListener(
-        cb: ((result: String?) -> Unit)?
-    ) {
-        when (cb != null) {
-            true -> setEventListener(
-                object : InvokeInterface {
-                    override fun onResult(result: String?) {
-                        cb(result)
-                    }
-                },
-            )
-
-            false -> setEventListener(null)
-        }
+            override fun resolverProcess(
+                protocol: Int,
+                source: String,
+                target: String,
+                uid: Int
+            ): String {
+                return resolverProcess(
+                    protocol,
+                    parseInetSocketAddress(source),
+                    parseInetSocketAddress(target),
+                    uid,
+                )
+            }
+        });
     }
 
     external fun stopTun()
 
-    external fun getTraffic(onlyStatisticsProxy: Boolean): String
-
-    external fun getTotalTraffic(onlyStatisticsProxy: Boolean): String
-
     init {
         System.loadLibrary("core")
     }

android/core/src/main/java/com/follow/clash/core/InvokeInterface.kt

@@ -1,8 +0,0 @@
-package com.follow.clash.core
-
-import androidx.annotation.Keep
-
-@Keep
-interface InvokeInterface {
-    fun onResult(result: String?)
-}

android/gradle.properties

@@ -1,3 +1,5 @@
 org.gradle.jvmargs=-Xmx4G
 android.useAndroidX=true
 android.enableJetifier=true
+kotlin_version=1.9.22
+agp_version=8.9.1

android/gradle/libs.versions.toml

@@ -1,28 +0,0 @@
-[versions]
-#agp = "8.10.1"
-firebaseBom = "34.2.0"
-minSdk = "23"
-targetSdk = "36"
-compileSdk = "36"
-ndkVersion = "28.0.13004108"
-coreKtx = "1.17.0"
-annotationJvm = "1.9.1"
-coreSplashscreen = "1.0.1"
-gson = "2.13.1"
-kotlin = "2.2.10"
-smaliDexlib2 = "3.0.9"
-firebaseCrashlyticsKtx = "20.0.1"
-firebaseCommonKtx = "22.0.0"
-
-[libraries]
-build-kotlin = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kotlin" }
-androidx-core = { module = "androidx.core:core-ktx", version.ref = "coreKtx" }
-annotation-jvm = { module = "androidx.annotation:annotation-jvm", version.ref = "annotationJvm" }
-core-splashscreen = { module = "androidx.core:core-splashscreen", version.ref = "coreSplashscreen" }
-firebase-analytics = { module = "com.google.firebase:firebase-analytics" }
-firebase-bom = { module = "com.google.firebase:firebase-bom", version.ref = "firebaseBom" }
-firebase-crashlytics-ndk = { module = "com.google.firebase:firebase-crashlytics-ndk" }
-gson = { module = "com.google.code.gson:gson", version.ref = "gson" }
-smali-dexlib2 = { module = "com.android.tools.smali:smali-dexlib2", version.ref = "smaliDexlib2" }
-firebase-crashlytics-ktx = { group = "com.google.firebase", name = "firebase-crashlytics-ktx", version.ref = "firebaseCrashlyticsKtx" }
-firebase-common-ktx = { group = "com.google.firebase", name = "firebase-common-ktx", version.ref = "firebaseCommonKtx" }

android/gradle/wrapper/gradle-wrapper.properties

@@ -2,5 +2,5 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.13-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.11.1-all.zip
 

android/service/.gitignore

@@ -1 +0,0 @@
-/build

android/service/build.gradle.kts

@@ -1,48 +0,0 @@
-import org.jetbrains.kotlin.gradle.dsl.JvmTarget
-
-plugins {
-    id("com.android.library")
-    id("org.jetbrains.kotlin.android")
-    id("kotlin-parcelize")
-}
-
-android {
-    namespace = "com.follow.clash.service"
-    compileSdk = 36
-
-    defaultConfig {
-        minSdk = libs.versions.minSdk.get().toInt()
-    }
-
-    buildFeatures {
-        aidl = true
-    }
-
-    compileOptions {
-        sourceCompatibility = JavaVersion.VERSION_17
-        targetCompatibility = JavaVersion.VERSION_17
-    }
-
-    buildTypes {
-        release {
-            proguardFiles(
-                getDefaultProguardFile("proguard-android-optimize.txt"),
-                "proguard-rules.pro"
-            )
-        }
-    }
-}
-
-kotlin {
-    compilerOptions {
-        jvmTarget.set(JvmTarget.JVM_17)
-    }
-}
-
-
-dependencies {
-    implementation(project(":core"))
-    implementation(project(":common"))
-    implementation(libs.gson)
-    implementation(libs.androidx.core)
-}

android/service/src/main/AndroidManifest.xml

@@ -1,49 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
-
-    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
-
-    <application>
-        <service
-            android:name=".VpnService"
-            android:exported="false"
-            android:foregroundServiceType="specialUse"
-            android:permission="android.permission.BIND_VPN_SERVICE"
-            android:process=":remote">
-            <intent-filter>
-                <action android:name="android.net.VpnService" />
-            </intent-filter>
-            <property
-                android:name="android.app.PROPERTY_SPECIAL_USE_FGS_SUBTYPE"
-                android:value="vpn" />
-        </service>
-
-        <service
-            android:name=".CommonService"
-            android:exported="false"
-            android:foregroundServiceType="specialUse"
-            android:process=":remote">
-            <property
-                android:name="android.app.PROPERTY_SPECIAL_USE_FGS_SUBTYPE"
-                android:value="proxy" />
-        </service>
-
-        <service
-            android:name=".RemoteService"
-            android:enabled="true"
-            android:exported="false"
-            android:process=":remote" />
-
-        <provider
-            android:name=".FilesProvider"
-            android:authorities="${applicationId}.files"
-            android:exported="true"
-            android:grantUriPermissions="true"
-            android:permission="android.permission.MANAGE_DOCUMENTS"
-            android:process=":remote">
-            <intent-filter>
-                <action android:name="android.content.action.DOCUMENTS_PROVIDER" />
-            </intent-filter>
-        </provider>
-    </application>
-</manifest>

android/service/src/main/aidl/com/follow/clash/service/IAckInterface.aidl

@@ -1,8 +0,0 @@
-// IAckInterface.aidl
-package com.follow.clash.service;
-
-import com.follow.clash.service.IAckInterface;
-
-interface IAckInterface {
-   oneway void onAck();
-}

android/service/src/main/aidl/com/follow/clash/service/ICallbackInterface.aidl

@@ -1,8 +0,0 @@
-// ICallbackInterface.aidl
-package com.follow.clash.service;
-
-import com.follow.clash.service.IAckInterface;
-
-interface ICallbackInterface {
-    oneway void onResult(in byte[] data,in boolean isSuccess, in IAckInterface ack);
-}

android/service/src/main/aidl/com/follow/clash/service/IEventInterface.aidl

@@ -1,8 +0,0 @@
-// IEventInterface.aidl
-package com.follow.clash.service;
-
-import com.follow.clash.service.IAckInterface;
-
-interface IEventInterface {
-    oneway void onEvent(in String id, in byte[] data,in boolean isSuccess, in IAckInterface ack);
-}

android/service/src/main/aidl/com/follow/clash/service/IRemoteInterface.aidl

@@ -1,18 +0,0 @@
-// IRemoteInterface.aidl
-package com.follow.clash.service;
-
-import com.follow.clash.service.ICallbackInterface;
-import com.follow.clash.service.IEventInterface;
-import com.follow.clash.service.IResultInterface;
-import com.follow.clash.service.models.VpnOptions;
-import com.follow.clash.service.models.NotificationParams;
-
-interface IRemoteInterface {
-    void invokeAction(in String data, in ICallbackInterface callback);
-    void updateNotificationParams(in NotificationParams params);
-    void startService(in VpnOptions options, in long runTime, in IResultInterface result);
-    void stopService(in IResultInterface result);
-    void setEventListener(in IEventInterface event);
-    void setCrashlytics(in boolean enable);
-    long getRunTime();
-}

android/service/src/main/aidl/com/follow/clash/service/IResultInterface.aidl

@@ -1,6 +0,0 @@
-// IResultInterface.aidl
-package com.follow.clash.service;
-
-interface IResultInterface {
-    oneway void onResult(in long runTime);
-}

android/service/src/main/aidl/com/follow/clash/service/models/AccessControl.aidl

@@ -1,4 +0,0 @@
-//AccessControl.aidl
-package com.follow.clash.service.models;
-
-parcelable AccessControl;

android/service/src/main/aidl/com/follow/clash/service/models/NotificationParams.aidl

@@ -1,4 +0,0 @@
-//NotificationParams.aidl
-package com.follow.clash.service.models;
-
-parcelable NotificationParams;

android/service/src/main/aidl/com/follow/clash/service/models/VpnOptions.aidl

@@ -1,6 +0,0 @@
-//VpnOptions.aidl
-package com.follow.clash.service.models;
-
-import com.follow.clash.service.models.AccessControl;
-
-parcelable VpnOptions;

android/service/src/main/java/com/follow/clash/service/CommonService.kt

@@ -1,64 +0,0 @@
-package com.follow.clash.service
-
-import android.app.Service
-import android.content.Intent
-import android.os.Binder
-import android.os.IBinder
-import com.follow.clash.core.Core
-import com.follow.clash.service.modules.NetworkObserveModule
-import com.follow.clash.service.modules.NotificationModule
-import com.follow.clash.service.modules.SuspendModule
-import com.follow.clash.service.modules.moduleLoader
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-
-class CommonService : Service(), IBaseService,
-    CoroutineScope by CoroutineScope(Dispatchers.Default) {
-
-    private val self: CommonService
-        get() = this
-
-    private val loader = moduleLoader {
-        install(NetworkObserveModule(self))
-        install(NotificationModule(self))
-        install(SuspendModule(self))
-    }
-
-    override fun onCreate() {
-        super.onCreate()
-        handleCreate()
-    }
-
-    override fun onDestroy() {
-        handleDestroy()
-        super.onDestroy()
-    }
-
-    override fun onLowMemory() {
-        Core.forceGC()
-        super.onLowMemory()
-    }
-
-    private val binder = LocalBinder()
-
-    inner class LocalBinder : Binder() {
-        fun getService(): CommonService = this@CommonService
-    }
-
-    override fun onBind(intent: Intent): IBinder {
-        return binder
-    }
-
-    override fun start() {
-        try {
-            loader.load()
-        } catch (_: Exception) {
-            stop()
-        }
-    }
-
-    override fun stop() {
-        loader.cancel()
-        stopSelf()
-    }
-}

android/service/src/main/java/com/follow/clash/service/IBaseService.kt

@@ -1,21 +0,0 @@
-package com.follow.clash.service
-
-import com.follow.clash.common.BroadcastAction
-import com.follow.clash.common.GlobalState
-import com.follow.clash.common.sendBroadcast
-
-interface IBaseService {
-    fun handleCreate() {
-        GlobalState.log("Service create")
-        BroadcastAction.SERVICE_CREATED.sendBroadcast()
-    }
-
-    fun handleDestroy() {
-        GlobalState.log("Service destroy")
-        BroadcastAction.SERVICE_DESTROYED.sendBroadcast()
-    }
-
-    fun start()
-
-    fun stop()
-}

android/service/src/main/java/com/follow/clash/service/RemoteService.kt

@@ -1,166 +0,0 @@
-package com.follow.clash.service
-
-import android.app.Service
-import android.content.Intent
-import android.os.IBinder
-import com.follow.clash.common.GlobalState
-import com.follow.clash.common.ServiceDelegate
-import com.follow.clash.common.chunkedForAidl
-import com.follow.clash.common.intent
-import com.follow.clash.core.Core
-import com.follow.clash.service.State.delegate
-import com.follow.clash.service.State.intent
-import com.follow.clash.service.State.runLock
-import com.follow.clash.service.models.NotificationParams
-import com.follow.clash.service.models.VpnOptions
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.suspendCancellableCoroutine
-import kotlinx.coroutines.sync.withLock
-import java.util.UUID
-import kotlin.coroutines.resume
-
-class RemoteService : Service(),
-    CoroutineScope by CoroutineScope(SupervisorJob() + Dispatchers.Default) {
-    private fun handleStopService(result: IResultInterface) {
-        launch {
-            runLock.withLock {
-                delegate?.useService { service ->
-                    service.stop()
-                    delegate?.unbind()
-                }
-                State.runTime = 0
-                result.onResult(0)
-            }
-        }
-    }
-
-    private fun handleServiceDisconnected(message: String) {
-        GlobalState.log("Background service disconnected: $message")
-        intent = null
-        delegate = null
-    }
-
-    private fun handleStartService(runTime: Long, result: IResultInterface) {
-        launch {
-            runLock.withLock {
-                val nextIntent = when (State.options?.enable == true) {
-                    true -> VpnService::class.intent
-                    false -> CommonService::class.intent
-                }
-                if (intent != nextIntent) {
-                    delegate?.unbind()
-                    delegate = ServiceDelegate(nextIntent, ::handleServiceDisconnected) { binder ->
-                        when (binder) {
-                            is VpnService.LocalBinder -> binder.getService()
-                            is CommonService.LocalBinder -> binder.getService()
-                            else -> throw IllegalArgumentException("Invalid binder type")
-                        }
-                    }
-                    intent = nextIntent
-                    delegate?.bind()
-                }
-                delegate?.useService { service ->
-                    service.start()
-                }
-                State.runTime = when (runTime != 0L) {
-                    true -> runTime
-                    false -> System.currentTimeMillis()
-                }
-                result.onResult(State.runTime)
-            }
-        }
-    }
-
-    private val binder = object : IRemoteInterface.Stub() {
-        override fun invokeAction(data: String, callback: ICallbackInterface) {
-            Core.invokeAction(data) {
-                launch {
-                    runCatching {
-                        val chunks = it?.chunkedForAidl() ?: listOf()
-                        for ((index, chunk) in chunks.withIndex()) {
-                            suspendCancellableCoroutine { cont ->
-                                callback.onResult(
-                                    chunk,
-                                    index == chunks.lastIndex,
-                                    object : IAckInterface.Stub() {
-                                        override fun onAck() {
-                                            cont.resume(Unit)
-                                        }
-                                    },
-                                )
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        override fun updateNotificationParams(params: NotificationParams?) {
-            State.notificationParamsFlow.tryEmit(params)
-        }
-
-
-        override fun startService(
-            options: VpnOptions,
-            runtime: Long,
-            result: IResultInterface,
-        ) {
-            State.options = options
-            handleStartService(runtime, result)
-        }
-
-        override fun stopService(result: IResultInterface) {
-            handleStopService(result)
-        }
-
-        override fun setEventListener(eventListener: IEventInterface?) {
-            GlobalState.log("RemoveEventListener ${eventListener == null}")
-            when (eventListener != null) {
-                true -> Core.callSetEventListener {
-                    launch {
-                        runCatching {
-                            val id = UUID.randomUUID().toString()
-                            val chunks = it?.chunkedForAidl() ?: listOf()
-                            for ((index, chunk) in chunks.withIndex()) {
-                                suspendCancellableCoroutine { cont ->
-                                    eventListener.onEvent(
-                                        id,
-                                        chunk,
-                                        index == chunks.lastIndex,
-                                        object : IAckInterface.Stub() {
-                                            override fun onAck() {
-                                                cont.resume(Unit)
-                                            }
-                                        },
-                                    )
-                                }
-                            }
-                        }
-                    }
-                }
-
-                false -> Core.callSetEventListener(null)
-            }
-        }
-
-        override fun setCrashlytics(enable: Boolean) {
-            GlobalState.setCrashlytics(enable)
-        }
-
-        override fun getRunTime(): Long {
-            return State.runTime
-        }
-    }
-
-    override fun onBind(intent: Intent?): IBinder {
-        return binder
-    }
-
-    override fun onDestroy() {
-        GlobalState.log("Remote service destroy")
-        super.onDestroy()
-    }
-}

android/service/src/main/java/com/follow/clash/service/State.kt

@@ -1,22 +0,0 @@
-package com.follow.clash.service
-
-import android.content.Intent
-import com.follow.clash.common.ServiceDelegate
-import com.follow.clash.service.models.NotificationParams
-import com.follow.clash.service.models.VpnOptions
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.sync.Mutex
-
-object State {
-    var options: VpnOptions? = null
-    var notificationParamsFlow: MutableStateFlow<NotificationParams?> = MutableStateFlow(
-        NotificationParams()
-    )
-
-    val runLock = Mutex()
-    var runTime: Long = 0L
-
-    var delegate: ServiceDelegate<IBaseService>? = null
-
-    var intent: Intent? = null
-}

android/service/src/main/java/com/follow/clash/service/VpnService.kt

@@ -1,261 +0,0 @@
-package com.follow.clash.service
-
-import android.content.Intent
-import android.net.ConnectivityManager
-import android.net.ProxyInfo
-import android.os.Binder
-import android.os.Build
-import android.os.IBinder
-import android.os.Parcel
-import android.os.RemoteException
-import android.util.Log
-import androidx.core.content.getSystemService
-import com.follow.clash.common.AccessControlMode
-import com.follow.clash.common.GlobalState
-import com.follow.clash.core.Core
-import com.follow.clash.service.models.VpnOptions
-import com.follow.clash.service.models.getIpv4RouteAddress
-import com.follow.clash.service.models.getIpv6RouteAddress
-import com.follow.clash.service.models.toCIDR
-import com.follow.clash.service.modules.NetworkObserveModule
-import com.follow.clash.service.modules.NotificationModule
-import com.follow.clash.service.modules.SuspendModule
-import com.follow.clash.service.modules.moduleLoader
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import java.net.InetSocketAddress
-import android.net.VpnService as SystemVpnService
-
-class VpnService : SystemVpnService(), IBaseService,
-    CoroutineScope by CoroutineScope(Dispatchers.Default) {
-
-    private val self: VpnService
-        get() = this
-
-    private val loader = moduleLoader {
-        install(NetworkObserveModule(self))
-        install(NotificationModule(self))
-        install(SuspendModule(self))
-    }
-
-    override fun onCreate() {
-        super.onCreate()
-        handleCreate()
-    }
-
-    override fun onDestroy() {
-        handleDestroy()
-        super.onDestroy()
-    }
-
-    private val connectivity by lazy {
-        getSystemService<ConnectivityManager>()
-    }
-    private val uidPageNameMap = mutableMapOf<Int, String>()
-
-    private fun resolverProcess(
-        protocol: Int,
-        source: InetSocketAddress,
-        target: InetSocketAddress,
-        uid: Int,
-    ): String {
-        val nextUid = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-            connectivity?.getConnectionOwnerUid(protocol, source, target) ?: -1
-        } else {
-            uid
-        }
-        if (nextUid == -1) {
-            return ""
-        }
-        if (!uidPageNameMap.containsKey(nextUid)) {
-            uidPageNameMap[nextUid] = this.packageManager?.getPackagesForUid(nextUid)?.first() ?: ""
-        }
-        return uidPageNameMap[nextUid] ?: ""
-    }
-
-    val VpnOptions.address
-        get(): String = buildString {
-            append(IPV4_ADDRESS)
-            if (ipv6) {
-                append(",")
-                append(IPV6_ADDRESS)
-            }
-        }
-
-    val VpnOptions.dns
-        get(): String {
-            if (dnsHijacking) {
-                return NET_ANY
-            }
-            return buildString {
-                append(DNS)
-                if (ipv6) {
-                    append(",")
-                    append(DNS6)
-                }
-            }
-        }
-
-
-    override fun onLowMemory() {
-        Core.forceGC()
-        super.onLowMemory()
-    }
-
-    private val binder = LocalBinder()
-
-    inner class LocalBinder : Binder() {
-        fun getService(): VpnService = this@VpnService
-
-        override fun onTransact(code: Int, data: Parcel, reply: Parcel?, flags: Int): Boolean {
-            try {
-                val isSuccess = super.onTransact(code, data, reply, flags)
-                if (!isSuccess) {
-                    GlobalState.log("VpnService disconnected")
-                    handleDestroy()
-                }
-                return isSuccess
-            } catch (e: RemoteException) {
-                GlobalState.log("VpnService onTransact $e")
-                return false
-            }
-        }
-    }
-
-    override fun onBind(intent: Intent): IBinder {
-        return binder
-    }
-
-    private fun handleStart(options: VpnOptions) {
-        val fd = with(Builder()) {
-            val cidr = IPV4_ADDRESS.toCIDR()
-            addAddress(cidr.address, cidr.prefixLength)
-            Log.d(
-                "addAddress", "address: ${cidr.address} prefixLength:${cidr.prefixLength}"
-            )
-            val routeAddress = options.getIpv4RouteAddress()
-            if (routeAddress.isNotEmpty()) {
-                try {
-                    routeAddress.forEach { i ->
-                        Log.d(
-                            "addRoute4", "address: ${i.address} prefixLength:${i.prefixLength}"
-                        )
-                        addRoute(i.address, i.prefixLength)
-                    }
-                } catch (_: Exception) {
-                    addRoute(NET_ANY, 0)
-                }
-            } else {
-                addRoute(NET_ANY, 0)
-            }
-            if (options.ipv6) {
-                try {
-                    val cidr = IPV6_ADDRESS.toCIDR()
-                    Log.d(
-                        "addAddress6", "address: ${cidr.address} prefixLength:${cidr.prefixLength}"
-                    )
-                    addAddress(cidr.address, cidr.prefixLength)
-                } catch (_: Exception) {
-                    Log.d(
-                        "addAddress6", "IPv6 is not supported."
-                    )
-                }
-
-                try {
-                    val routeAddress = options.getIpv6RouteAddress()
-                    if (routeAddress.isNotEmpty()) {
-                        try {
-                            routeAddress.forEach { i ->
-                                Log.d(
-                                    "addRoute6",
-                                    "address: ${i.address} prefixLength:${i.prefixLength}"
-                                )
-                                addRoute(i.address, i.prefixLength)
-                            }
-                        } catch (_: Exception) {
-                            addRoute("::", 0)
-                        }
-                    } else {
-                        addRoute(NET_ANY6, 0)
-                    }
-                } catch (_: Exception) {
-                    addRoute(NET_ANY6, 0)
-                }
-            }
-            addDnsServer(DNS)
-            if (options.ipv6) {
-                addDnsServer(DNS6)
-            }
-            setMtu(9000)
-            options.accessControl.let { accessControl ->
-                if (accessControl.enable) {
-                    when (accessControl.mode) {
-                        AccessControlMode.ACCEPT_SELECTED -> {
-                            (accessControl.acceptList + packageName).forEach {
-                                addAllowedApplication(it)
-                            }
-                        }
-
-                        AccessControlMode.REJECT_SELECTED -> {
-                            (accessControl.rejectList - packageName).forEach {
-                                addDisallowedApplication(it)
-                            }
-                        }
-                    }
-                }
-            }
-            setSession("FlClash")
-            setBlocking(false)
-            if (Build.VERSION.SDK_INT >= 29) {
-                setMetered(false)
-            }
-            if (options.allowBypass) {
-                allowBypass()
-            }
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q && options.systemProxy) {
-                GlobalState.log("Open http proxy")
-                setHttpProxy(
-                    ProxyInfo.buildDirectProxy(
-                        "127.0.0.1", options.port, options.bypassDomain
-                    )
-                )
-            }
-            establish()?.detachFd()
-                ?: throw NullPointerException("Establish VPN rejected by system")
-        }
-        Core.startTun(
-            fd,
-            protect = this::protect,
-            resolverProcess = this::resolverProcess,
-            options.stack,
-            options.address,
-            options.dns
-        )
-    }
-
-    override fun start() {
-        try {
-            loader.load()
-            State.options?.let {
-                handleStart(it)
-            }
-        } catch (_: Exception) {
-            stop()
-        }
-    }
-
-    override fun stop() {
-        loader.cancel()
-        Core.stopTun()
-        stopSelf()
-    }
-
-    companion object {
-        private const val IPV4_ADDRESS = "172.19.0.1/30"
-        private const val IPV6_ADDRESS = "fdfe:dcba:9876::1/126"
-        private const val DNS = "172.19.0.2"
-        private const val DNS6 = "fdfe:dcba:9876::2"
-        private const val NET_ANY = "0.0.0.0"
-        private const val NET_ANY6 = "::"
-    }
-}

android/service/src/main/java/com/follow/clash/service/models/NotificationParams.kt

@@ -1,11 +0,0 @@
-package com.follow.clash.service.models
-
-import android.os.Parcelable
-import kotlinx.parcelize.Parcelize
-
-@Parcelize
-data class NotificationParams(
-    val title: String = "FlClash",
-    val stopText: String = "STOP",
-    val onlyStatisticsProxy: Boolean = false,
-) : Parcelable

android/service/src/main/java/com/follow/clash/service/models/Traffic.kt

@@ -1,25 +0,0 @@
-package com.follow.clash.service.models
-
-import com.follow.clash.common.GlobalState
-import com.follow.clash.common.formatBytes
-import com.follow.clash.core.Core
-import com.google.gson.Gson
-
-data class Traffic(
-    val up: Long,
-    val down: Long,
-)
-
-val Traffic.speedText: String
-    get() = "${up.formatBytes}/s↑  ${down.formatBytes}/s↓"
-
-fun Core.getSpeedTrafficText(onlyStatisticsProxy: Boolean): String {
-    try {
-        val res = getTraffic(onlyStatisticsProxy)
-        val traffic = Gson().fromJson(res, Traffic::class.java)
-        return traffic.speedText
-    } catch (e: Exception) {
-        GlobalState.log(e.message + "")
-        return ""
-    }
-}

android/service/src/main/java/com/follow/clash/service/models/VpnOptions.kt

@@ -1,83 +0,0 @@
-package com.follow.clash.service.models
-
-import android.os.Parcelable
-import com.follow.clash.common.AccessControlMode
-import kotlinx.parcelize.Parcelize
-import java.net.InetAddress
-
-@Parcelize
-data class AccessControl(
-    val enable: Boolean,
-    val mode: AccessControlMode,
-    val acceptList: List<String>,
-    val rejectList: List<String>,
-) : Parcelable
-
-@Parcelize
-data class VpnOptions(
-    val enable: Boolean,
-    val port: Int,
-    val ipv6: Boolean,
-    val dnsHijacking: Boolean,
-    val accessControl: AccessControl,
-    val allowBypass: Boolean,
-    val systemProxy: Boolean,
-    val bypassDomain: List<String>,
-    val stack: String,
-    val routeAddress: List<String>,
-) : Parcelable
-
-data class CIDR(val address: InetAddress, val prefixLength: Int)
-
-fun VpnOptions.getIpv4RouteAddress(): List<CIDR> {
-    return routeAddress.filter {
-        it.isIpv4()
-    }.map {
-        it.toCIDR()
-    }
-}
-
-fun VpnOptions.getIpv6RouteAddress(): List<CIDR> {
-    return routeAddress.filter {
-        it.isIpv6()
-    }.map {
-        it.toCIDR()
-    }
-}
-
-fun String.isIpv4(): Boolean {
-    val parts = split("/")
-    if (parts.size != 2) {
-        throw IllegalArgumentException("Invalid CIDR format")
-    }
-    val address = InetAddress.getByName(parts[0])
-    return address.address.size == 4
-}
-
-fun String.isIpv6(): Boolean {
-    val parts = split("/")
-    if (parts.size != 2) {
-        throw IllegalArgumentException("Invalid CIDR format")
-    }
-    val address = InetAddress.getByName(parts[0])
-    return address.address.size == 16
-}
-
-fun String.toCIDR(): CIDR {
-    val parts = split("/")
-    if (parts.size != 2) {
-        throw IllegalArgumentException("Invalid CIDR format")
-    }
-    val ipAddress = parts[0]
-    val prefixLength =
-        parts[1].toIntOrNull() ?: throw IllegalArgumentException("Invalid prefix length")
-
-    val address = InetAddress.getByName(ipAddress)
-
-    val maxPrefix = if (address.address.size == 4) 32 else 128
-    if (prefixLength < 0 || prefixLength > maxPrefix) {
-        throw IllegalArgumentException("Invalid prefix length for IP version")
-    }
-
-    return CIDR(address, prefixLength)
-}

android/service/src/main/java/com/follow/clash/service/modules/Module.kt

@@ -1,19 +0,0 @@
-package com.follow.clash.service.modules
-
-abstract class Module {
-
-    private var isInstall: Boolean = false
-
-    protected abstract fun onInstall()
-    protected abstract fun onUninstall()
-
-    fun install() {
-        isInstall = true
-        onInstall()
-    }
-
-    fun uninstall() {
-        onUninstall()
-        isInstall = false
-    }
-}

android/service/src/main/java/com/follow/clash/service/modules/ModuleLoader.kt

@@ -1,51 +0,0 @@
-package com.follow.clash.service.modules
-
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
-
-interface ModuleLoaderScope {
-    fun <T : Module> install(module: T): T
-}
-
-interface ModuleLoader {
-    fun load()
-
-    fun cancel()
-}
-
-private val mutex = Mutex()
-fun CoroutineScope.moduleLoader(block: suspend ModuleLoaderScope.() -> Unit): ModuleLoader {
-    val modules = mutableListOf<Module>()
-    var job: Job? = null
-
-    return object : ModuleLoader {
-        override fun load() {
-            job = launch(Dispatchers.IO) {
-                mutex.withLock {
-                    val scope = object : ModuleLoaderScope {
-                        override fun <T : Module> install(module: T): T {
-                            modules.add(module)
-                            module.install()
-                            return module
-                        }
-                    }
-                    scope.block()
-                }
-            }
-        }
-
-        override fun cancel() {
-            launch(Dispatchers.IO) {
-                job?.cancel()
-                mutex.withLock {
-                    modules.asReversed().forEach { it.uninstall() }
-                    modules.clear()
-                }
-            }
-        }
-    }
-}

android/service/src/main/java/com/follow/clash/service/modules/NetworkObserveModule.kt

@@ -1,149 +0,0 @@
-package com.follow.clash.service.modules
-
-import android.app.Service
-import android.net.ConnectivityManager
-import android.net.LinkProperties
-import android.net.Network
-import android.net.NetworkCapabilities
-import android.net.NetworkCapabilities.TRANSPORT_SATELLITE
-import android.net.NetworkCapabilities.TRANSPORT_USB
-import android.net.NetworkRequest
-import android.os.Build
-import androidx.core.content.getSystemService
-import com.follow.clash.core.Core
-import java.net.Inet4Address
-import java.net.Inet6Address
-import java.net.InetAddress
-import java.util.concurrent.ConcurrentHashMap
-
-private data class NetworkInfo(
-    @Volatile var losingMs: Long = 0, @Volatile var dnsList: List<InetAddress> = emptyList()
-) {
-    fun isAvailable(): Boolean = losingMs < System.currentTimeMillis()
-}
-
-class NetworkObserveModule(private val service: Service) : Module() {
-
-    private val networkInfos = ConcurrentHashMap<Network, NetworkInfo>()
-    private val connectivity by lazy {
-        service.getSystemService<ConnectivityManager>()
-    }
-    private var preDnsList = listOf<String>()
-
-    private val request = NetworkRequest.Builder().apply {
-        addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_VPN)
-        addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
-            addCapability(NetworkCapabilities.NET_CAPABILITY_FOREGROUND)
-        }
-        addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED)
-    }.build()
-
-    private val callback = object : ConnectivityManager.NetworkCallback() {
-        override fun onAvailable(network: Network) {
-            networkInfos[network] = NetworkInfo()
-            onUpdateNetwork()
-            super.onAvailable(network)
-        }
-
-        override fun onLosing(network: Network, maxMsToLive: Int) {
-            networkInfos[network]?.losingMs = System.currentTimeMillis() + maxMsToLive
-            onUpdateNetwork()
-            setUnderlyingNetworks(network)
-            super.onLosing(network, maxMsToLive)
-        }
-
-        override fun onLost(network: Network) {
-            networkInfos.remove(network)
-            onUpdateNetwork()
-            setUnderlyingNetworks(network)
-            super.onLost(network)
-        }
-
-        override fun onLinkPropertiesChanged(network: Network, linkProperties: LinkProperties) {
-            networkInfos[network]?.dnsList = linkProperties.dnsServers
-            onUpdateNetwork()
-            setUnderlyingNetworks(network)
-            super.onLinkPropertiesChanged(network, linkProperties)
-        }
-    }
-
-
-    override fun onInstall() {
-        onUpdateNetwork()
-        connectivity?.registerNetworkCallback(request, callback)
-    }
-
-    private fun networkToInt(entry: Map.Entry<Network, NetworkInfo>): Int {
-        val capabilities = connectivity?.getNetworkCapabilities(entry.key)
-        return when {
-            capabilities == null -> 100
-            capabilities.hasTransport(NetworkCapabilities.TRANSPORT_VPN) -> 90
-            capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) -> 0
-            capabilities.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET) -> 1
-            Build.VERSION.SDK_INT >= Build.VERSION_CODES.S && capabilities.hasTransport(
-                TRANSPORT_USB
-            ) -> 2
-
-            capabilities.hasTransport(NetworkCapabilities.TRANSPORT_BLUETOOTH) -> 3
-            capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) -> 4
-            Build.VERSION.SDK_INT >= Build.VERSION_CODES.VANILLA_ICE_CREAM && capabilities.hasTransport(
-                TRANSPORT_SATELLITE
-            ) -> 5
-
-            else -> 20
-        } + (if (entry.value.isAvailable()) 0 else 10)
-    }
-
-    fun onUpdateNetwork() {
-        val dnsList = (networkInfos.asSequence().minByOrNull { networkToInt(it) }?.value?.dnsList
-            ?: emptyList()).map { x -> x.asSocketAddressText(53) }
-        if (dnsList == preDnsList) {
-            return
-        }
-        preDnsList = dnsList
-        Core.updateDNS(dnsList.toSet().joinToString(","))
-    }
-
-    fun setUnderlyingNetworks(network: Network) {
-//        if (service is VpnService && Build.VERSION.SDK_INT in 22..28) {
-//            service.setUnderlyingNetworks(arrayOf(network))
-//        }
-    }
-
-    override fun onUninstall() {
-        connectivity?.unregisterNetworkCallback(callback)
-        networkInfos.clear()
-        onUpdateNetwork()
-    }
-}
-
-fun InetAddress.asSocketAddressText(port: Int): String {
-    return when (this) {
-        is Inet6Address -> "[${numericToTextFormat(this)}]:$port"
-
-        is Inet4Address -> "${this.hostAddress}:$port"
-
-        else -> throw IllegalArgumentException("Unsupported Inet type ${this.javaClass}")
-    }
-}
-
-private fun numericToTextFormat(address: Inet6Address): String {
-    val src = address.address
-    val sb = StringBuilder(39)
-    for (i in 0 until 8) {
-        sb.append(
-            Integer.toHexString(
-                src[i shl 1].toInt() shl 8 and 0xff00 or (src[(i shl 1) + 1].toInt() and 0xff)
-            )
-        )
-        if (i < 7) {
-            sb.append(":")
-        }
-    }
-    if (address.scopeId > 0) {
-        sb.append("%")
-        sb.append(address.scopeId)
-    }
-    return sb.toString()
-}

android/service/src/main/java/com/follow/clash/service/modules/NotificationModule.kt

@@ -1,127 +0,0 @@
-package com.follow.clash.service.modules
-
-import android.app.Notification.FOREGROUND_SERVICE_IMMEDIATE
-import android.app.Service
-import android.app.Service.STOP_FOREGROUND_REMOVE
-import android.content.Intent
-import android.os.Build
-import android.os.PowerManager
-import androidx.core.app.NotificationCompat
-import androidx.core.content.getSystemService
-import com.follow.clash.common.Components
-import com.follow.clash.common.GlobalState
-import com.follow.clash.common.QuickAction
-import com.follow.clash.common.quickIntent
-import com.follow.clash.common.receiveBroadcastFlow
-import com.follow.clash.common.startForeground
-import com.follow.clash.common.tickerFlow
-import com.follow.clash.common.toPendingIntent
-import com.follow.clash.core.Core
-import com.follow.clash.service.R
-import com.follow.clash.service.State
-import com.follow.clash.service.models.NotificationParams
-import com.follow.clash.service.models.getSpeedTrafficText
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.cancel
-import kotlinx.coroutines.flow.combine
-import kotlinx.coroutines.flow.distinctUntilChanged
-import kotlinx.coroutines.flow.filter
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.onStart
-import kotlinx.coroutines.launch
-
-data class ExtendedNotificationParams(
-    val title: String,
-    val stopText: String,
-    val onlyStatisticsProxy: Boolean,
-    val contentText: String,
-)
-
-val NotificationParams.extended: ExtendedNotificationParams
-    get() = ExtendedNotificationParams(
-        title, stopText, onlyStatisticsProxy, Core.getSpeedTrafficText(onlyStatisticsProxy)
-    )
-
-class NotificationModule(private val service: Service) : Module() {
-    private val scope = CoroutineScope(Dispatchers.Default)
-
-    override fun onInstall() {
-        scope.launch {
-            val screenFlow = service.receiveBroadcastFlow {
-                addAction(Intent.ACTION_SCREEN_ON)
-                addAction(Intent.ACTION_SCREEN_OFF)
-            }.map { intent ->
-                intent.action == Intent.ACTION_SCREEN_ON
-            }.onStart {
-                emit(isScreenOn())
-            }
-
-            combine(
-                tickerFlow(1000, 0), State.notificationParamsFlow, screenFlow
-            ) { _, params, screenOn ->
-                params?.extended to screenOn
-            }.filter { (params, screenOn) -> params != null && screenOn }
-                .distinctUntilChanged { old, new -> old.first == new.first && old.second == new.second }
-                .collect { (params, _) ->
-                    update(params!!)
-                }
-
-            State.notificationParamsFlow.value?.let {
-                update(it.extended)
-            } ?: run {
-                update(NotificationParams().extended)
-            }
-        }
-    }
-
-    private fun isScreenOn(): Boolean {
-        val pm = service.getSystemService<PowerManager>()
-        return when (pm != null) {
-            true -> pm.isInteractive
-            false -> true
-        }
-    }
-
-    private val notificationBuilder: NotificationCompat.Builder by lazy {
-        val intent = Intent().setComponent(Components.MAIN_ACTIVITY)
-        with(
-            NotificationCompat.Builder(
-                service, GlobalState.NOTIFICATION_CHANNEL
-            )
-        ) {
-            setSmallIcon(R.drawable.ic)
-            setContentTitle("FlClash")
-            setContentIntent(intent.toPendingIntent)
-            setPriority(NotificationCompat.PRIORITY_HIGH)
-            setCategory(NotificationCompat.CATEGORY_SERVICE)
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-                foregroundServiceBehavior = FOREGROUND_SERVICE_IMMEDIATE
-            }
-            setOngoing(true)
-            setShowWhen(true)
-            setOnlyAlertOnce(true)
-        }
-    }
-
-    private fun update(params: ExtendedNotificationParams) {
-        service.startForeground(
-            with(notificationBuilder) {
-                setContentTitle(params.title)
-                setContentText(params.contentText)
-                clearActions()
-                addAction(
-                    0, params.stopText, QuickAction.STOP.quickIntent.toPendingIntent
-                ).build()
-            })
-    }
-
-    override fun onUninstall() {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-            service.stopForeground(STOP_FOREGROUND_REMOVE)
-        } else {
-            service.stopForeground(true)
-        }
-        scope.cancel()
-    }
-}

android/service/src/main/java/com/follow/clash/service/modules/SuspendModule.kt

@@ -1,61 +0,0 @@
-package com.follow.clash.service.modules
-
-import android.app.Service
-import android.content.Intent
-import android.os.PowerManager
-import androidx.core.content.getSystemService
-import com.follow.clash.common.receiveBroadcastFlow
-import com.follow.clash.core.Core
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.cancel
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.onStart
-import kotlinx.coroutines.launch
-
-
-class SuspendModule(private val service: Service) : Module() {
-    private val scope = CoroutineScope(Dispatchers.Default)
-
-    private fun isScreenOn(): Boolean {
-        val pm = service.getSystemService<PowerManager>()
-        return when (pm != null) {
-            true -> pm.isInteractive
-            false -> true
-        }
-    }
-
-    val isDeviceIdleMode: Boolean
-        get() {
-            return service.getSystemService<PowerManager>()?.isDeviceIdleMode ?: true
-        }
-
-    private fun onUpdate(isScreenOn: Boolean) {
-        if (isScreenOn) {
-            Core.suspended(false)
-            return
-        }
-        Core.suspended(isDeviceIdleMode)
-    }
-
-    override fun onInstall() {
-        scope.launch {
-            val screenFlow = service.receiveBroadcastFlow {
-                addAction(Intent.ACTION_SCREEN_ON)
-                addAction(Intent.ACTION_SCREEN_OFF)
-            }.map { intent ->
-                intent.action == Intent.ACTION_SCREEN_ON
-            }.onStart {
-                emit(isScreenOn())
-            }
-
-            screenFlow.collect {
-                    onUpdate(it)
-                }
-        }
-    }
-
-    override fun onUninstall() {
-        scope.cancel()
-    }
-}

android/service/src/main/res/drawable/ic.xml

@@ -1,17 +0,0 @@
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:tools="http://schemas.android.com/tools"
-    android:width="240dp"
-    android:height="240dp"
-    android:viewportWidth="240"
-    android:viewportHeight="240"
-    tools:ignore="VectorRaster">
-  <path
-      android:pathData="M48.1,80.89L168.44,11.41c11.08,-6.4 25.24,-2.6 31.64,8.48 0,0 0,0 0,0h0c6.4,11.08 2.6,25.24 -8.48,31.64 0,0 0,0 0,0l-120.34,69.48c-11.08,6.4 -25.24,2.6 -31.64,-8.48 0,0 0,0 0,0h0c-6.4,-11.08 -2.6,-25.24 8.48,-31.64 0,0 0,0 0,0Z"
-      android:fillColor="#FFFFFF"/>
-  <path
-      android:pathData="M78.98,134.37l60.18,-34.74c11.07,-6.39 25.23,-2.59 31.63,8.48h0c6.4,11.07 2.61,25.24 -8.47,31.64l-60.18,34.74c-11.08,6.4 -25.24,2.6 -31.64,-8.48 0,0 0,0 0,0h0c-6.4,-11.08 -2.6,-25.24 8.48,-31.64h0Z"
-      android:fillColor="#FFFFFF"/>
-  <path
-      android:pathData="M109.86,187.86h0c11.08,-6.4 25.24,-2.6 31.64,8.48 0,0 0,0 0,0h0c6.4,11.08 2.6,25.24 -8.48,31.64 0,0 0,0 0,0h0c-11.08,6.4 -25.24,2.6 -31.64,-8.48 0,0 0,0 0,0h0c-6.4,-11.08 -2.6,-25.24 8.48,-31.64 0,0 0,0 0,0Z"
-      android:fillColor="#FFFFFF"/>
-</vector>

android/service/src/main/res/drawable/ic_service.xml

@@ -1,17 +0,0 @@
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:tools="http://schemas.android.com/tools"
-    android:width="240dp"
-    android:height="240dp"
-    android:viewportWidth="240"
-    android:viewportHeight="240"
-    tools:ignore="VectorRaster">
-  <path
-      android:pathData="M48.1,80.89L168.44,11.41c11.08,-6.4 25.24,-2.6 31.64,8.48 0,0 0,0 0,0h0c6.4,11.08 2.6,25.24 -8.48,31.64 0,0 0,0 0,0l-120.34,69.48c-11.08,6.4 -25.24,2.6 -31.64,-8.48 0,0 0,0 0,0h0c-6.4,-11.08 -2.6,-25.24 8.48,-31.64 0,0 0,0 0,0Z"
-      android:fillColor="#6666FB"/>
-  <path
-      android:pathData="M78.98,134.37l60.18,-34.74c11.07,-6.39 25.23,-2.59 31.63,8.48h0c6.4,11.07 2.61,25.24 -8.47,31.64l-60.18,34.74c-11.08,6.4 -25.24,2.6 -31.64,-8.48 0,0 0,0 0,0h0c-6.4,-11.08 -2.6,-25.24 8.48,-31.64h0Z"
-      android:fillColor="#336AB6"/>
-  <path
-      android:pathData="M109.86,187.86h0c11.08,-6.4 25.24,-2.6 31.64,8.48 0,0 0,0 0,0h0c6.4,11.08 2.6,25.24 -8.48,31.64 0,0 0,0 0,0h0c-11.08,6.4 -25.24,2.6 -31.64,-8.48 0,0 0,0 0,0h0c-6.4,-11.08 -2.6,-25.24 8.48,-31.64 0,0 0,0 0,0Z"
-      android:fillColor="#5CA8E9"/>
-</vector>

android/settings.gradle

@@ -0,0 +1,27 @@
+pluginManagement {
+    def flutterSdkPath = {
+        def properties = new Properties()
+        file("local.properties").withInputStream { properties.load(it) }
+        def flutterSdkPath = properties.getProperty("flutter.sdk")
+        assert flutterSdkPath != null, "flutter.sdk not set in local.properties"
+        return flutterSdkPath
+    }
+    settings.ext.flutterSdkPath = flutterSdkPath()
+
+    includeBuild("${settings.ext.flutterSdkPath}/packages/flutter_tools/gradle")
+
+    repositories {
+        google()
+        mavenCentral()
+        gradlePluginPortal()
+    }
+}
+
+plugins {
+    id "dev.flutter.flutter-plugin-loader" version "1.0.0"
+    id "com.android.application" version "$agp_version" apply false
+    id "org.jetbrains.kotlin.android" version "$kotlin_version" apply false
+}
+
+include ":app"
+include ':core'

android/settings.gradle.kts

@@ -1,31 +0,0 @@
-pluginManagement {
-    val flutterSdkPath = run {
-        val properties = java.util.Properties()
-        file("local.properties").inputStream().use { properties.load(it) }
-        val flutterSdkPath = properties.getProperty("flutter.sdk")
-        require(flutterSdkPath != null) { "flutter.sdk not set in local.properties" }
-        flutterSdkPath
-    }
-
-    includeBuild("$flutterSdkPath/packages/flutter_tools/gradle")
-
-    repositories {
-        google()
-        mavenCentral()
-        gradlePluginPortal()
-    }
-}
-
-plugins {
-    id("dev.flutter.flutter-plugin-loader") version "1.0.0"
-    id("com.android.application") version "8.12.2" apply false
-    id("org.jetbrains.kotlin.android") version "2.2.10" apply false
-    id("com.google.gms.google-services") version ("4.3.15") apply false
-    id("com.google.firebase.crashlytics") version ("2.8.1") apply false
-}
-
-
-include(":app")
-include(":core")
-include(":service")
-include(":common")

arb/intl_en.arb

@@ -13,6 +13,7 @@
   "resourcesDesc": "External resource related info",
   "trafficUsage": "Traffic usage",
   "coreInfo": "Core info",
+  "nullCoreInfoDesc": "Unable to obtain core info",
   "networkSpeed": "Network speed",
   "outboundMode": "Outbound mode",
   "networkDetection": "Network detection",
@@ -21,6 +22,7 @@
   "noProxy": "No proxy",
   "noProxyDesc": "Please create a profile or add a valid profile",
   "nullProfileDesc": "No profile, Please add a profile",
+  "nullLogsDesc": "No logs",
   "settings": "Settings",
   "language": "Language",
   "defaultText": "Default",
@@ -147,6 +149,8 @@
   "addressHelp": "WebDAV server address",
   "addressTip": "Please enter a valid WebDAV address",
   "password": "Password",
+  "passwordTip": "Password cannot be empty",
+  "accountTip": "Account cannot be empty",
   "checkUpdate": "Check for updates",
   "discoverNewVersion": "Discover the new version",
   "checkUpdateError": "The current application is already the latest version",
@@ -181,6 +185,8 @@
   "expirationTime": "Expiration time",
   "connections": "Connections",
   "connectionsDesc": "View current connections data",
+  "nullRequestsDesc": "No requests",
+  "nullConnectionsDesc": "No connections",
   "intranetIP": "Intranet IP",
   "view": "View",
   "cut": "Cut",
@@ -213,6 +219,7 @@
   "autoCloseConnectionsDesc": "Auto close connections after change node",
   "onlyStatisticsProxy": "Only statistics proxy",
   "onlyStatisticsProxyDesc": "When turned on, only statistics proxy traffic",
+  "deleteProfileTip": "Sure you want to delete the current profile?",
   "pureBlackMode": "Pure black mode",
   "keepAliveIntervalDesc": "Tcp keep alive interval",
   "entries": " entries",
@@ -243,6 +250,7 @@
   "dnsDesc": "Update DNS related settings",
   "key": "Key",
   "value": "Value",
+  "notEmpty": "Cannot be empty",
   "hostsDesc": "Add Hosts",
   "vpnTip": "Changes take effect after restarting the VPN",
   "vpnEnableDesc": "Auto routes all system traffic through VpnService",
@@ -329,36 +337,44 @@
   "fileIsUpdate": "The file has been modified. Do you want to save the changes?",
   "profileHasUpdate": "The profile has been modified. Do you want to disable auto update?",
   "hasCacheChange": "Do you want to cache the changes?",
+  "nullProxies": "No proxies",
   "copySuccess": "Copy success",
   "copyLink": "Copy link",
   "exportFile": "Export file",
   "cacheCorrupt": "The cache is corrupt. Do you want to clear it?",
   "detectionTip": "Relying on third-party api is for reference only",
   "listen": "Listen",
+  "keyExists": "The current key already exists",
+  "valueExists": "The current value already exists",
   "undo": "undo",
   "redo": "redo",
   "none": "none",
   "basicConfig": "Basic configuration",
   "basicConfigDesc": "Modify the basic configuration globally",
-  "advancedConfig": "Advanced configuration",
-  "advancedConfigDesc": "Provide diverse configuration options",
   "selectedCountTitle": "{count} items have been selected",
   "addRule": "Add rule",
+  "ruleProviderEmptyTip": "Rule provider cannot be empty",
   "ruleName": "Rule name",
   "content": "Content",
+  "contentEmptyTip": "Content cannot be empty",
   "subRule": "Sub rule",
+  "subRuleEmptyTip": "Sub rule content cannot be empty",
   "ruleTarget": "Rule target",
+  "ruleTargetEmptyTip": "Rule target cannot be empty",
   "sourceIp": "Source IP",
   "noResolve": "No resolve IP",
   "getOriginRules": "Get original rules",
   "overrideOriginRules": "Override the original rule",
   "addedOriginRules": "Attach on the original rules",
   "enableOverride": "Enable override",
+  "deleteRuleTip": "Are you sure you want to delete the selected rule?",
   "saveChanges": "Do you want to save the changes?",
   "generalDesc": "Modify general settings",
   "findProcessModeDesc": "There is a certain performance loss after opening",
   "tabAnimationDesc": "Effective only in mobile view",
   "saveTip": "Are you sure you want to save?",
+  "deleteColorTip": "Are you sure you want to delete the current color?",
+  "colorExists": "Current color already exists",
   "colorSchemes": "Color schemes",
   "palette": "Palette",
   "tonalSpotScheme": "TonalSpot",
@@ -379,92 +395,5 @@
   "textScale": "Text Scaling",
   "internet": "Internet",
   "systemApp": "System APP",
-  "noNetworkApp": "No network APP",
-  "contactMe": "Contact me",
-  "recoveryStrategy": "Recovery strategy",
-  "recoveryStrategy_override": "Override",
-  "recoveryStrategy_compatible": "Compatible",
-  "logsTest": "Logs test",
-  "emptyTip": "{label} cannot be empty",
-  "urlTip": "{label} must be a url",
-  "numberTip": "{label} must be a number",
-  "interval": "Interval",
-  "existsTip": "Current {label} already exists",
-  "deleteTip": "Are you sure you want to delete the current {label}?",
-  "deleteMultipTip": "Are you sure you want to delete the selected {label}?",
-  "nullTip": "No {label} yet",
-  "script": "Script",
-  "color": "Color",
-  "rename": "Rename",
-  "unnamed": "Unnamed",
-  "pleaseEnterScriptName": "Please enter a script name",
-  "overrideInvalidTip": "Does not take effect in script mode",
-  "mixedPort": "Mixed Port",
-  "socksPort": "Socks Port",
-  "redirPort": "Redir Port",
-  "tproxyPort": "Tproxy Port",
-  "portTip": "{label} must be between 1024 and 49151",
-  "portConflictTip": "Please enter a different port",
-  "import": "Import",
-  "importFile": "Import from file",
-  "importUrl": "Import from URL",
-  "autoSetSystemDns": "Auto set system DNS",
-  "details": "{label} details",
-  "creationTime": "Creation time",
-  "process": "Process",
-  "host": "Host",
-  "destination": "Destination",
-  "destinationGeoIP": "Destination GeoIP",
-  "destinationIPASN": "Destination IPASN",
-  "specialProxy": "Special proxy",
-  "specialRules": "special rules",
-  "remoteDestination": "Remote destination",
-  "networkType": "Network type",
-  "proxyChains": "Proxy chains",
-  "log": "Log",
-  "connection": "Connection",
-  "request": "Request",
-  "connected": "Connected",
-  "disconnected": "Disconnected",
-  "connecting": "Connecting...",
-  "restartCoreTip": "Are you sure you want to restart the core?",
-  "forceRestartCoreTip": "Are you sure you want to force restart the core?",
-  "dnsHijacking": "DNS hijacking",
-  "coreStatus": "Core status",
-  "dataCollectionTip": "Data Collection Notice",
-  "dataCollectionContent": "This app uses Firebase Crashlytics to collect crash information to improve app stability.\nThe collected data includes device information and crash details, but does not contain personal sensitive data.\nYou can disable this feature in settings.",
-  "crashlytics": "Crash Analysis",
-  "crashlyticsTip": "When enabled, automatically uploads crash logs without sensitive information when the app crashes",
-  "appendSystemDns": "Append System DNS",
-  "appendSystemDnsTip": "Forcefully append system DNS to the configuration",
-  "editRule": "Edit rule",
-  "overrideMode": "Override mode",
-  "standardModeDesc": "Standard mode, override basic configuration, provide simple rule addition capability",
-  "scriptModeDesc": "Script mode, use external extension scripts, provide one-click override configuration capability",
-  "addedRules": "Added rules",
-  "controlGlobalAddedRules": "Control global added rules",
-  "overrideScript": "Override script",
-  "goToConfigureScript": "Go to configure script",
-  "editGlobalRules": "Edit global rules",
-  "externalFetch": "External fetch",
-  "confirmForceCrashCore": "Are you sure you want to force crash the core?",
-  "confirmClearAllData": "Are you sure you want to clear all data?",
-  "loading": "Loading...",
-  "loadTest": "Load test",
-  "yearsAgo": "{count, plural, =1{1 year ago} other{{count} years ago}}",
-  "monthsAgo": "{count, plural, =1{1 month ago} other{{count} months ago}}",
-  "daysAgo": "{count, plural, =1{1 day ago} other{{count} days ago}}",
-  "hoursAgo": "{count, plural, =1{1 hour ago} other{{count} hours ago}}",
-  "minutesAgo": "{count, plural, =1{1 minute ago} other{{count} minutes ago}}",
-  "justNow": "Just now",
-  "noLongerRemind": "Don't remind again",
-  "accessControlSettings": "Access Control Settings",
-  "turnOn": "Turn On",
-  "turnOff": "Turn Off",
-  "coreConfigChangeDetected": "Core configuration change detected",
-  "reload": "Reload",
-  "vpnConfigChangeDetected": "VPN configuration change detected",
-  "restart": "Restart",
-  "speedStatistics": "Speed statistics",
-  "resetPageChangesTip": "The current page has changes. Are you sure you want to reset?"
+  "noNetworkApp": "No network App"
 }

arb/intl_ja.arb

@@ -13,6 +13,7 @@
   "resourcesDesc": "外部リソース関連情報",
   "trafficUsage": "トラフィック使用量",
   "coreInfo": "コア情報",
+  "nullCoreInfoDesc": "コア情報を取得できません",
   "networkSpeed": "ネットワーク速度",
   "outboundMode": "アウトバウンドモード",
   "networkDetection": "ネットワーク検出",
@@ -21,6 +22,7 @@
   "noProxy": "プロキシなし",
   "noProxyDesc": "プロファイルを作成するか、有効なプロファイルを追加してください",
   "nullProfileDesc": "プロファイルがありません。追加してください",
+  "nullLogsDesc": "ログがありません",
   "settings": "設定",
   "language": "言語",
   "defaultText": "デフォルト",
@@ -147,6 +149,8 @@
   "addressHelp": "WebDAVサーバーアドレス",
   "addressTip": "有効なWebDAVアドレスを入力",
   "password": "パスワード",
+  "passwordTip": "パスワードは必須です",
+  "accountTip": "アカウントは必須です",
   "checkUpdate": "更新を確認",
   "discoverNewVersion": "新バージョンを発見",
   "checkUpdateError": "アプリは最新版です",
@@ -181,6 +185,8 @@
   "expirationTime": "有効期限",
   "connections": "接続",
   "connectionsDesc": "現在の接続データを表示",
+  "nullRequestsDesc": "リクエストなし",
+  "nullConnectionsDesc": "接続なし",
   "intranetIP": "イントラネットIP",
   "view": "表示",
   "cut": "切り取り",
@@ -213,6 +219,7 @@
   "autoCloseConnectionsDesc": "ノード変更後に接続を自動閉じる",
   "onlyStatisticsProxy": "プロキシのみ統計",
   "onlyStatisticsProxyDesc": "有効化するとプロキシトラフィックのみ統計",
+  "deleteProfileTip": "現在のプロファイルを削除しますか？",
   "pureBlackMode": "純黒モード",
   "keepAliveIntervalDesc": "TCPキープアライブ間隔",
   "entries": " エントリ",
@@ -243,6 +250,7 @@
   "dnsDesc": "DNS関連設定の更新",
   "key": "キー",
   "value": "値",
+  "notEmpty": "空欄不可",
   "hostsDesc": "ホストを追加",
   "vpnTip": "変更はVPN再起動後に有効",
   "vpnEnableDesc": "VpnService経由で全システムトラフィックをルーティング",
@@ -329,36 +337,44 @@
   "fileIsUpdate": "ファイルが変更されました。保存しますか？",
   "profileHasUpdate": "プロファイルが変更されました。自動更新を無効化しますか？",
   "hasCacheChange": "変更をキャッシュしますか？",
+  "nullProxies": "プロキシなし",
   "copySuccess": "コピー成功",
   "copyLink": "リンクをコピー",
   "exportFile": "ファイルをエクスポート",
   "cacheCorrupt": "キャッシュが破損しています。クリアしますか？",
   "detectionTip": "サードパーティAPIに依存（参考値）",
   "listen": "リスン",
+  "keyExists": "現在のキーは既に存在します",
+  "valueExists": "現在の値は既に存在します",
   "undo": "元に戻す",
   "redo": "やり直す",
   "none": "なし",
   "basicConfig": "基本設定",
   "basicConfigDesc": "基本設定をグローバルに変更",
-  "advancedConfig": "高度な設定",
-  "advancedConfigDesc": "多様な設定を提供",
   "selectedCountTitle": "{count} 項目が選択されています",
   "addRule": "ルールを追加",
+  "ruleProviderEmptyTip": "ルールプロバイダーは必須です",
   "ruleName": "ルール名",
   "content": "内容",
+  "contentEmptyTip": "内容は必須です",
   "subRule": "サブルール",
+  "subRuleEmptyTip": "サブルールの内容は必須です",
   "ruleTarget": "ルール対象",
+  "ruleTargetEmptyTip": "ルール対象は必須です",
   "sourceIp": "送信元IP",
   "noResolve": "IPを解決しない",
   "getOriginRules": "元のルールを取得",
   "overrideOriginRules": "元のルールを上書き",
   "addedOriginRules": "元のルールに追加",
   "enableOverride": "上書きを有効化",
+  "deleteRuleTip": "選択したルールを削除しますか？",
   "saveChanges": "変更を保存しますか？",
   "generalDesc": "一般設定を変更",
   "findProcessModeDesc": "有効化するとパフォーマンスが若干低下します",
   "tabAnimationDesc": "モバイル表示でのみ有効",
   "saveTip": "保存してもよろしいですか？",
+  "deleteColorTip": "現在の色を削除しますか？",
+  "colorExists": "この色は既に存在します",
   "colorSchemes": "カラースキーム",
   "palette": "パレット",
   "tonalSpotScheme": "トーンスポット",
@@ -380,92 +396,5 @@
   "textScale": "テキストスケーリング",
   "internet": "インターネット",
   "systemApp": "システムアプリ",
-  "noNetworkApp": "ネットワークなしアプリ",
-  "contactMe": "連絡する",
-  "recoveryStrategy": "リカバリー戦略",
-  "recoveryStrategy_override": "オーバーライド",
-  "recoveryStrategy_compatible": "互換性",
-  "logsTest": "ログテスト",
-  "emptyTip": "{label}は空欄にできません",
-  "urlTip": "{label}はURLである必要があります",
-  "numberTip": "{label}は数字でなければなりません",
-  "interval": "インターバル",
-  "existsTip": "現在の{label}は既に存在しています",
-  "deleteTip": "現在の{label}を削除してもよろしいですか？",
-  "deleteMultipTip": "選択された{label}を削除してもよろしいですか？",
-  "nullTip": "まだ{label}はありません",
-  "script": "スクリプト",
-  "color": "カラー",
-  "rename": "リネーム",
-  "unnamed": "無題",
-  "pleaseEnterScriptName": "スクリプト名を入力してください",
-  "overrideInvalidTip": "スクリプトモードでは有効になりません",
-  "mixedPort": "混合ポート",
-  "socksPort": "Socksポート",
-  "redirPort": "Redirポート",
-  "tproxyPort": "Tproxyポート",
-  "portTip": "{label} は 1024 から 49151 の間でなければなりません",
-  "portConflictTip": "別のポートを入力してください",
-  "import": "インポート",
-  "importFile": "ファイルからインポート",
-  "importUrl": "URLからインポート",
-  "autoSetSystemDns": "オートセットシステムDNS",
-  "details": "{label}詳細",
-  "creationTime": "作成時間",
-  "process": "プロセス",
-  "host": "ホスト",
-  "destination": "宛先",
-  "destinationGeoIP": "宛先地理情報",
-  "destinationIPASN": "宛先IP ASN",
-  "specialProxy": "特殊プロキシ",
-  "specialRules": "特殊ルール",
-  "remoteDestination": "リモート宛先",
-  "networkType": "ネットワーク種別",
-  "proxyChains": "プロキシチェーン",
-  "log": "ログ",
-  "connection": "接続",
-  "request": "リクエスト",
-  "connected": "接続済み",
-  "disconnected": "切断済み",
-  "connecting": "接続中...",
-  "restartCoreTip": "コアを再起動してもよろしいですか？",
-  "forceRestartCoreTip": "コアを強制再起動してもよろしいですか？",
-  "dnsHijacking": "DNSハイジャッキング",
-  "coreStatus": "コアステータス",
-  "dataCollectionTip": "データ収集説明",
-  "dataCollectionContent": "本アプリはFirebase Crashlyticsを使用してクラッシュ情報を収集し、アプリの安定性を向上させます。\n収集されるデータにはデバイス情報とクラッシュ詳細が含まれますが、個人の機密データは含まれません。\n設定でこの機能を無効にすることができます。",
-  "crashlytics": "クラッシュ分析",
-  "crashlyticsTip": "有効にすると、アプリがクラッシュした際に機密情報を含まないクラッシュログを自動的にアップロードします",
-  "appendSystemDns": "システムDNSを追加",
-  "appendSystemDnsTip": "設定にシステムDNSを強制的に追加します",
-  "editRule": "ルールを編集",
-  "overrideMode": "上書きモード",
-  "standardModeDesc": "標準モード、基本設定を上書きし、シンプルなルール追加機能を提供",
-  "scriptModeDesc": "スクリプトモード、外部拡張スクリプトを使用し、ワンクリックで設定を上書きする機能を提供",
-  "addedRules": "追加ルール",
-  "controlGlobalAddedRules": "グローバル追加ルールを制御",
-  "overrideScript": "上書きスクリプト",
-  "goToConfigureScript": "スクリプト設定に移動",
-  "editGlobalRules": "グローバルルールを編集",
-  "externalFetch": "外部取得",
-  "confirmForceCrashCore": "コアを強制的にクラッシュさせてもよろしいですか？",
-  "confirmClearAllData": "すべてのデータをクリアしてもよろしいですか？",
-  "loading": "読み込み中...",
-  "loadTest": "読み込みテスト",
-  "yearsAgo": "{count}年前",
-  "monthsAgo": "{count}ヶ月前",
-  "daysAgo": "{count}日前",
-  "hoursAgo": "{count}時間前",
-  "minutesAgo": "{count}分前",
-  "justNow": "たった今",
-  "noLongerRemind": "今後表示しない",
-  "accessControlSettings": "アクセス制御設定",
-  "turnOn": "オン",
-  "turnOff": "オフ",
-  "coreConfigChangeDetected": "コア設定の変更が検出されました",
-  "reload": "リロード",
-  "vpnConfigChangeDetected": "VPN設定の変更が検出されました",
-  "restart": "再起動",
-  "speedStatistics": "速度統計",
-  "resetPageChangesTip": "現在のページに変更があります。リセットしてもよろしいですか？"
+  "noNetworkApp": "ネットワークなしアプリ"
 }

arb/intl_ru.arb

@@ -13,6 +13,7 @@
   "resourcesDesc": "Информация, связанная с внешними ресурсами",
   "trafficUsage": "Использование трафика",
   "coreInfo": "Информация о ядре",
+  "nullCoreInfoDesc": "Не удалось получить информацию о ядре",
   "networkSpeed": "Скорость сети",
   "outboundMode": "Режим исходящего трафика",
   "networkDetection": "Обнаружение сети",
@@ -21,6 +22,7 @@
   "noProxy": "Нет прокси",
   "noProxyDesc": "Пожалуйста, создайте профиль или добавьте действительный профиль",
   "nullProfileDesc": "Нет профиля, пожалуйста, добавьте профиль",
+  "nullLogsDesc": "Нет логов",
   "settings": "Настройки",
   "language": "Язык",
   "defaultText": "По умолчанию",
@@ -147,6 +149,8 @@
   "addressHelp": "Адрес сервера WebDAV",
   "addressTip": "Пожалуйста, введите действительный адрес WebDAV",
   "password": "Пароль",
+  "passwordTip": "Пароль не может быть пустым",
+  "accountTip": "Аккаунт не может быть пустым",
   "checkUpdate": "Проверить обновления",
   "discoverNewVersion": "Обнаружена новая версия",
   "checkUpdateError": "Текущее приложение уже является последней версией",
@@ -181,6 +185,8 @@
   "expirationTime": "Время истечения",
   "connections": "Соединения",
   "connectionsDesc": "Просмотр текущих данных о соединениях",
+  "nullRequestsDesc": "Нет запросов",
+  "nullConnectionsDesc": "Нет соединений",
   "intranetIP": "Внутренний IP",
   "view": "Просмотр",
   "cut": "Вырезать",
@@ -213,6 +219,7 @@
   "autoCloseConnectionsDesc": "Автоматически закрывать соединения после смены узла",
   "onlyStatisticsProxy": "Только статистика прокси",
   "onlyStatisticsProxyDesc": "При включении будет учитываться только трафик прокси",
+  "deleteProfileTip": "Вы уверены, что хотите удалить текущий профиль?",
   "pureBlackMode": "Чисто черный режим",
   "keepAliveIntervalDesc": "Интервал поддержания TCP-соединения",
   "entries": " записей",
@@ -243,6 +250,7 @@
   "dnsDesc": "Обновление настроек, связанных с DNS",
   "key": "Ключ",
   "value": "Значение",
+  "notEmpty": "Не может быть пустым",
   "hostsDesc": "Добавить Hosts",
   "vpnTip": "Изменения вступят в силу после перезапуска VPN",
   "vpnEnableDesc": "Автоматически направляет весь системный трафик через VpnService",
@@ -329,36 +337,44 @@
   "fileIsUpdate": "Файл был изменен. Хотите сохранить изменения?",
   "profileHasUpdate": "Профиль был изменен. Хотите отключить автообновление?",
   "hasCacheChange": "Хотите сохранить изменения в кэше?",
+  "nullProxies": "Нет прокси",
   "copySuccess": "Копирование успешно",
   "copyLink": "Копировать ссылку",
   "exportFile": "Экспорт файла",
   "cacheCorrupt": "Кэш поврежден. Хотите очистить его?",
   "detectionTip": "Опирается на сторонний API, только для справки",
   "listen": "Слушать",
+  "keyExists": "Текущий ключ уже существует",
+  "valueExists": "Текущее значение уже существует",
   "undo": "Отменить",
   "redo": "Повторить",
   "none": "Нет",
   "basicConfig": "Базовая конфигурация",
   "basicConfigDesc": "Глобальное изменение базовых настроек",
-  "advancedConfig": "Расширенная конфигурация",
-  "advancedConfigDesc": "Предоставляет разнообразные варианты конфигурации",
   "selectedCountTitle": "Выбрано {count} элементов",
   "addRule": "Добавить правило",
+  "ruleProviderEmptyTip": "Поставщик правил не может быть пустым",
   "ruleName": "Название правила",
   "content": "Содержание",
+  "contentEmptyTip": "Содержание не может быть пустым",
   "subRule": "Подправило",
+  "subRuleEmptyTip": "Содержание подправила не может быть пустым",
   "ruleTarget": "Цель правила",
+  "ruleTargetEmptyTip": "Цель правила не может быть пустой",
   "sourceIp": "Исходный IP",
   "noResolve": "Не разрешать IP",
   "getOriginRules": "Получить оригинальные правила",
   "overrideOriginRules": "Переопределить оригинальное правило",
   "addedOriginRules": "Добавить к оригинальным правилам",
   "enableOverride": "Включить переопределение",
+  "deleteRuleTip": "Вы уверены, что хотите удалить выбранное правило?",
   "saveChanges": "Сохранить изменения?",
   "generalDesc": "Изменение общих настроек",
   "findProcessModeDesc": "При включении возможны небольшие потери производительности",
   "tabAnimationDesc": "Действительно только в мобильном виде",
   "saveTip": "Вы уверены, что хотите сохранить?",
+  "deleteColorTip": "Удалить текущий цвет?",
+  "colorExists": "Этот цвет уже существует",
   "colorSchemes": "Цветовые схемы",
   "palette": "Палитра",
   "tonalSpotScheme": "Тональный акцент",
@@ -380,92 +396,5 @@
   "textScale": "Масштабирование текста",
   "internet": "Интернет",
   "systemApp": "Системное приложение",
-  "noNetworkApp": "Приложение без сети",
-  "contactMe": "Свяжитесь со мной",
-  "recoveryStrategy": "Стратегия восстановления",
-  "recoveryStrategy_override": "Переопределение",
-  "recoveryStrategy_compatible": "Совместимый",
-  "logsTest": "Тест журналов",
-  "emptyTip": "{label} не может быть пустым",
-  "urlTip": "{label} должен быть URL",
-  "numberTip": "{label} должно быть числом",
-  "interval": "Интервал",
-  "existsTip": "Текущий {label} уже существует",
-  "deleteTip": "Вы уверены, что хотите удалить текущий {label}?",
-  "deleteMultipTip": "Вы уверены, что хотите удалить выбранные {label}?",
-  "nullTip": "{label} пока отсутствуют",
-  "script": "Скрипт",
-  "color": "Цвет",
-  "rename": "Переименовать",
-  "unnamed": "Без имени",
-  "pleaseEnterScriptName": "Пожалуйста, введите название скрипта",
-  "overrideInvalidTip": "В скриптовом режиме не действует",
-  "mixedPort": "Смешанный порт",
-  "socksPort": "Socks-порт",
-  "redirPort": "Redir-порт",
-  "tproxyPort": "Tproxy-порт",
-  "portTip": "{label} должен быть числом от 1024 до 49151",
-  "portConflictTip": "Введите другой порт",
-  "import": "Импорт",
-  "importFile": "Импорт из файла",
-  "importUrl": "Импорт по URL",
-  "autoSetSystemDns": "Автоматическая настройка системного DNS",
-  "details": "Детали {}",
-  "creationTime": "Время создания",
-  "process": "процесс",
-  "host": "Хост",
-  "destination": "Назначение",
-  "destinationGeoIP": "Геолокация назначения",
-  "destinationIPASN": "ASN назначения",
-  "specialProxy": "Специальный прокси",
-  "specialRules": "Специальные правила",
-  "remoteDestination": "Удалённое назначение",
-  "networkType": "Тип сети",
-  "proxyChains": "Цепочки прокси",
-  "log": "Журнал",
-  "connection": "Соединение",
-  "request": "Запрос",
-  "connected": "Подключено",
-  "disconnected": "Отключено",
-  "connecting": "Подключение...",
-  "restartCoreTip": "Вы уверены, что хотите перезапустить ядро?",
-  "forceRestartCoreTip": "Вы уверены, что хотите принудительно перезапустить ядро?",
-  "dnsHijacking": "DNS-перехват",
-  "coreStatus": "Основной статус",
-  "dataCollectionTip": "Уведомление о сборе данных",
-  "dataCollectionContent": "Это приложение использует Firebase Crashlytics для сбора информации о сбоях nhằm улучшения стабильности приложения.\nСобираемые данные включают информацию об устройстве и подробности о сбоях, но не содержат персональных конфиденциальных данных.\nВы можете отключить эту функцию в настройках.",
-  "crashlytics": "Анализ сбоев",
-  "crashlyticsTip": "При включении автоматически загружает журналы сбоев без конфиденциальной информации, когда приложение выходит из строя",
-  "appendSystemDns": "Добавить системный DNS",
-  "appendSystemDnsTip": "Принудительно добавить системный DNS к конфигурации",
-  "editRule": "Редактировать правило",
-  "overrideMode": "Режим переопределения",
-  "standardModeDesc": "Стандартный режим, переопределение базовой конфигурации, предоставление возможности простого добавления правил",
-  "scriptModeDesc": "Режим скрипта, использование внешних расширяющих скриптов, предоставление возможности переопределения конфигурации одним кликом",
-  "addedRules": "Добавленные правила",
-  "controlGlobalAddedRules": "Управление глобальными добавленными правилами",
-  "overrideScript": "Скрипт переопределения",
-  "goToConfigureScript": "Перейти к настройке скрипта",
-  "editGlobalRules": "Редактировать глобальные правила",
-  "externalFetch": "Внешнее получение",
-  "confirmForceCrashCore": "Вы уверены, что хотите принудительно аварийно завершить работу ядра?",
-  "confirmClearAllData": "Вы уверены, что хотите очистить все данные?",
-  "loading": "Загрузка...",
-  "loadTest": "Тест загрузки",
-  "yearsAgo": "{count, plural, one{{count} год назад} few{{count} года назад} many{{count} лет назад} other{{count} года назад}}",
-  "monthsAgo": "{count, plural, one{{count} месяц назад} few{{count} месяца назад} many{{count} месяцев назад} other{{count} месяца назад}}",
-  "daysAgo": "{count, plural, one{{count} день назад} few{{count} дня назад} many{{count} дней назад} other{{count} дня назад}}",
-  "hoursAgo": "{count, plural, one{{count} час назад} few{{count} часа назад} many{{count} часов назад} other{{count} часа назад}}",
-  "minutesAgo": "{count, plural, one{{count} минута назад} few{{count} минуты назад} many{{count} минут назад} other{{count} минуты назад}}",
-  "justNow": "Только что",
-  "noLongerRemind": "Больше не напоминать",
-  "accessControlSettings": "Настройки контроля доступа",
-  "turnOn": "Включить",
-  "turnOff": "Выключить",
-  "coreConfigChangeDetected": "Обнаружено изменение конфигурации ядра",
-  "reload": "Перезагрузить",
-  "vpnConfigChangeDetected": "Обнаружено изменение конфигурации VPN",
-  "restart": "Перезапустить",
-  "speedStatistics": "Статистика скорости",
-  "resetPageChangesTip": "На текущей странице есть изменения. Вы уверены, что хотите сбросить?"
+  "noNetworkApp": "Приложение без сети"
 }

arb/intl_zh_CN.arb

@@ -13,6 +13,7 @@
   "resourcesDesc": "外部资源相关信息",
   "trafficUsage": "流量统计",
   "coreInfo": "内核信息",
+  "nullCoreInfoDesc": "无法获取内核信息",
   "networkSpeed": "网络速度",
   "outboundMode": "出站模式",
   "networkDetection": "网络检测",
@@ -21,6 +22,7 @@
   "noProxy": "暂无代理",
   "noProxyDesc": "请创建配置文件或者添加有效配置文件",
   "nullProfileDesc": "没有配置文件,请先添加配置文件",
+  "nullLogsDesc": "暂无日志",
   "settings": "设置",
   "language": "语言",
   "defaultText": "默认",
@@ -147,6 +149,8 @@
   "addressHelp": "WebDAV服务器地址",
   "addressTip": "请输入有效的WebDAV地址",
   "password": "密码",
+  "passwordTip": "密码不能为空",
+  "accountTip": "账号不能为空",
   "checkUpdate": "检查更新",
   "discoverNewVersion": "发现新版本",
   "checkUpdateError": "当前应用已经是最新版了",
@@ -181,6 +185,8 @@
   "expirationTime": "到期时间",
   "connections": "连接",
   "connectionsDesc": "查看当前连接数据",
+  "nullRequestsDesc": "暂无请求",
+  "nullConnectionsDesc": "暂无连接",
   "intranetIP": "内网 IP",
   "view": "查看",
   "cut": "剪切",
@@ -213,6 +219,7 @@
   "autoCloseConnectionsDesc": "切换节点后自动关闭连接",
   "onlyStatisticsProxy": "仅统计代理",
   "onlyStatisticsProxyDesc": "开启后，将只统计代理流量",
+  "deleteProfileTip": "确定要删除当前配置吗?",
   "pureBlackMode": "纯黑模式",
   "keepAliveIntervalDesc": "TCP保持活动间隔",
   "entries": "个条目",
@@ -243,6 +250,7 @@
   "dnsDesc": "更新DNS相关设置",
   "key": "键",
   "value": "值",
+  "notEmpty": "不能为空",
   "hostsDesc": "追加Hosts",
   "vpnTip": "重启VPN后改变生效",
   "vpnEnableDesc": "通过VpnService自动路由系统所有流量",
@@ -329,36 +337,44 @@
   "fileIsUpdate": "文件有修改，是否保存修改",
   "profileHasUpdate": "配置文件已经修改,是否关闭自动更新 ",
   "hasCacheChange": "是否缓存修改",
+  "nullProxies": "暂无代理",
   "copySuccess": "复制成功",
   "copyLink": "复制链接",
   "exportFile": "导出文件",
   "cacheCorrupt": "缓存已损坏，是否清空？",
   "detectionTip": "依赖第三方api，仅供参考",
   "listen": "监听",
+  "keyExists": "当前键已存在",
+  "valueExists": "当前值已存在",
   "undo": "撤销",
   "redo": "重做",
   "none": "无",
   "basicConfig": "基本配置",
   "basicConfigDesc": "全局修改基本配置",
-  "advancedConfig": "进阶配置",
-  "advancedConfigDesc": "提供多样化配置",
   "selectedCountTitle": "已选择 {count} 项",
   "addRule": "添加规则",
+  "ruleProviderEmptyTip": "规则提供者不能为空",
   "ruleName": "规则名称",
   "content": "内容",
+  "contentEmptyTip": "内容不能为空",
   "subRule": "子规则",
+  "subRuleEmptyTip": "子规则内容不能为空",
   "ruleTarget": "规则目标",
+  "ruleTargetEmptyTip": "规则目标不能为空",
   "sourceIp": "源IP",
   "noResolve": "不解析IP",
   "getOriginRules": "获取原始规则",
   "overrideOriginRules": "覆盖原始规则",
   "addedOriginRules": "附加到原始规则",
   "enableOverride": "启用覆写",
+  "deleteRuleTip": "确定要删除选中的规则吗？",
   "saveChanges": "是否保存更改？",
   "generalDesc": "修改通用设置",
   "findProcessModeDesc": "开启后会有一定性能损耗",
   "tabAnimationDesc": "仅在移动视图中有效",
   "saveTip": "确定要保存吗？",
+  "deleteColorTip": "确定删除当前颜色吗？",
+  "colorExists": "该颜色已存在",
   "colorSchemes": "配色方案",
   "palette": "调色板",
   "tonalSpotScheme": "调性点缀",
@@ -380,92 +396,5 @@
   "textScale": "文本缩放",
   "internet": "互联网",
   "systemApp": "系统应用",
-  "noNetworkApp": "无网络应用",
-  "contactMe": "联系我",
-  "recoveryStrategy": "恢复策略",
-  "recoveryStrategy_override": "覆盖",
-  "recoveryStrategy_compatible": "兼容",
-  "logsTest": "日志测试",
-  "emptyTip": "{label}不能为空",
-  "urlTip": "{label}必须为URL",
-  "numberTip": "{label}必须为数字",
-  "interval": "间隔",
-  "existsTip": "{label}当前已存在",
-  "deleteTip": "确定删除当前{label}吗？",
-  "deleteMultipTip": "确定删除选中的{label}吗？",
-  "nullTip": "暂无{label}",
-  "script": "脚本",
-  "color": "颜色",
-  "rename": "重命名",
-  "unnamed": "未命名",
-  "pleaseEnterScriptName": "请输入脚本名称",
-  "overrideInvalidTip": "在脚本模式下不生效",
-  "mixedPort": "混合端口",
-  "socksPort": "Socks端口",
-  "redirPort": "Redir端口",
-  "tproxyPort": "Tproxy端口",
-  "portTip": "{label} 必须在 1024 到 49151 之间",
-  "portConflictTip": "请输入不同的端口",
-  "import": "导入",
-  "importFile": "通过文件导入",
-  "importUrl": "通过URL导入",
-  "autoSetSystemDns": "自动设置系统DNS",
-  "details": "{label}详情",
-  "creationTime": "创建时间",
-  "process": "进程",
-  "host": "主机",
-  "destination": "目标地址",
-  "destinationGeoIP": "目标地理定位",
-  "destinationIPASN": "目标IP ASN",
-  "specialProxy": "特殊代理",
-  "specialRules": "特殊规则",
-  "remoteDestination": "远程目标",
-  "networkType": "网络类型",
-  "proxyChains": "代理链",
-  "log": "日志",
-  "connection": "连接",
-  "request": "请求",
-  "connected": "已连接",
-  "disconnected": "已断开",
-  "connecting": "连接中...",
-  "restartCoreTip": "您确定要重启核心吗？",
-  "forceRestartCoreTip": "您确定要强制重启核心吗？",
-  "dnsHijacking": "DNS劫持",
-  "coreStatus": "核心状态",
-  "dataCollectionTip": "数据收集说明",
-  "dataCollectionContent": "本应用使用 Firebase Crashlytics 收集崩溃信息以改进应用稳定性。\n收集的数据包括设备信息和崩溃详情，不包含个人敏感数据。\n您可以在设置中关闭此功能。",
-  "crashlytics": "崩溃分析",
-  "crashlyticsTip": "开启后，应用崩溃时自动上传不包含敏感信息的崩溃日志",
-  "appendSystemDns": "追加系统DNS",
-  "appendSystemDnsTip": "强制为配置附加系统DNS",
-  "editRule": "编辑规则",
-  "overrideMode": "覆写模式",
-  "standardModeDesc": "标准模式，覆写基本配置，提供简单追加规则能力",
-  "scriptModeDesc": "脚本模式，使用外部扩展脚本，提供一键覆写配置的能力",
-  "addedRules": "附加规则",
-  "controlGlobalAddedRules": "控制全局附加规则",
-  "overrideScript": "覆写脚本",
-  "goToConfigureScript": "前往配置脚本",
-  "editGlobalRules": "编辑全局规则",
-  "externalFetch": "外部获取",
-  "confirmForceCrashCore": "确定要强制崩溃核心？",
-  "confirmClearAllData": "确定要清除所有数据？",
-  "loading": "加载中...",
-  "loadTest": "加载测试",
-  "yearsAgo": "{count} 年前",
-  "monthsAgo": "{count} 个月前",
-  "daysAgo": "{count} 天前",
-  "hoursAgo": "{count} 小时前",
-  "minutesAgo": "{count} 分钟前",
-  "justNow": "刚刚",
-  "noLongerRemind": "不再提示",
-  "accessControlSettings": "访问控制设置",
-  "turnOn": "开启",
-  "turnOff": "关闭",
-  "coreConfigChangeDetected": "检测到核心配置更改",
-  "reload": "重载",
-  "vpnConfigChangeDetected": "检测到VPN相关配置改动",
-  "restart": "重启",
-  "speedStatistics": "网速统计",
-  "resetPageChangesTip": "当前页面存在更改，确定重置吗？"
+  "noNetworkApp": "无网络应用"
 }