Add sqlite store

Optimize android quick action

Optimize backup and restore

Optimize more details

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,57 @@
+name: 问题反馈 / Bug report
+title: "[BUG] "
+description: 反馈你遇到的问题 / Report the issue you are experiencing
+
+body:
+  - type: markdown
+    attributes:
+      value: |
+        ## 在提交问题之前，请确认以下事项：
+        1. 请务必给issue填写一个简洁明了的标题，以便他人快速检索
+        2. 请确保[已有的问题](https://github.com/chen08209/FlClash/issues?q=is%3Aissue) 中没有人提交过相似issue，否则请在已有的issue下进行讨论
+        3. 请务必按照模板规范详细描述问题，否则issue将会被直接关闭
+        ## Before submitting the issue, please make sure of the following checklist:
+        1. Please be sure to fill in a concise and clear title for the issue so that others can quickly search
+        2. Please make sure there is no similar issue in the [existing issues](https://github.com/chen08209/FlClash/issues?q=is%3Aissue), otherwise please discuss under the existing issue
+        3. Please describe the problem in detail according to the template specification, otherwise issue will be closed directly.
+  - type: textarea
+    id: description
+    attributes:
+      label: 问题描述 / Describe the bug
+      description: 详细清晰地描述你遇到的问题，并配合截图 / Describe the problem you encountered in detail and clearly, and provide screenshots
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: 软件版本 / Version
+      description: 请提供FlClash的具体版本 / Please provide the specific version of FlClash.
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: 复现步骤 / To Reproduce
+      description: 请提供复现问题的步骤 / Steps to reproduce the behavior
+    validations:
+      required: true
+  - type: dropdown
+    attributes:
+      label: 操作系统 / OS
+      options:
+        - Android
+        - Windows
+        - MacOS
+        - Linux
+    validations:
+      required: true
+  - type: input
+    attributes:
+      label: 操作系统版本 / OS Version
+      description: 请提供你的操作系统版本，Linux请额外提供桌面环境及窗口系统 / Please provide your OS version, for Linux, please also provide the desktop environment and window system
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: 日志(勿上传日志文件，请粘贴日志内容) / Log (Do not upload the log file, paste the log content directly)
+      description: 请提供完整或相关部分的Debug日志（请在“软件左侧菜单”->“设置”->“日志等级”调整到debug / Please provide a complete or relevant Debug log (please adjust it to debug in the left menu of software-> Settings-> Log Level)
+    validations:
+      required: true

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,4 @@
+contact_links:
+  - name: 讨论交流 / Communication
+    url: https://t.me/+G-veVtwBOl4wODc1
+    about: 在 Telegram 群组中与其他用户讨论交流 / Communicate with other users in the Telegram group

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,42 @@
+name: 功能请求 / Feature request
+title: "[Feature] "
+description: 提出你的功能请求 / Propose your feature request
+
+body:
+  - type: markdown
+    attributes:
+      value: |
+        ## 在提交问题之前，请确认以下事项：
+        1. 请务必给issue填写一个简洁明了的标题，以便他人快速检索
+        2. 请确保[已有的问题](https://github.com/chen08209/FlClash/issues?q=is%3Aissue) 中没有人提交过相似issue，否则请在已有的issue下进行讨论
+        3. 请务必按照模板规范详细描述问题，否则issue将会被直接关闭
+        ## Before submitting the issue, please make sure of the following checklist:
+        1. Please be sure to fill in a concise and clear title for the issue so that others can quickly search
+        2. Please make sure there is no similar issue in the [existing issues](https://github.com/chen08209/FlClash/issues?q=is%3Aissue), otherwise please discuss under the existing issue
+        3. Please describe the problem in detail according to the template specification, otherwise issue will be closed directly.
+
+  - type: textarea
+    id: description
+    attributes:
+      label: 功能描述 / Feature description
+      description: 详细清晰地描述你的功能请求 / A clear and concise description of what the feature is
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: 使用场景 / Use case
+      description: 请描述你的功能请求的使用场景 / Please describe the use case of your feature request
+    validations:
+      required: true
+  - type: checkboxes
+    id: os-labels
+    attributes:
+      label: 适用系统 / Target OS
+      description: 请选择该功能适用的操作系统（至少选择一个） / Please select the operating system(s) for this feature request (select at least one)
+      options:
+        - label: Android
+        - label: Windows
+        - label: MacOS
+        - label: Linux
+    validations:
+      required: true

.github/workflows/build.yaml

@@ -16,20 +16,20 @@ jobs:
           - platform: android
             os: ubuntu-latest
           - platform: windows
-            os: windows-latest
+            os: Windows-2022
             arch: amd64
           - platform: linux
-            os: ubuntu-latest
+            os: ubuntu-22.04
             arch: amd64
           - platform: macos
-            os: macos-13
+            os: macos-15-intel
             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,6 +52,7 @@ 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
@@ -64,13 +65,24 @@ 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: ${{ (startsWith(matrix.os, 'windows-11-arm') || startsWith(matrix.os, 'ubuntu-24.04-arm')) && 'master' || 'stable' }}
+          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
           cache: true
 
       - name: Get Flutter Dependency
-        run: flutter pub get
+        run: |
+          flutter --version
+          flutter pub get
 
       - name: Setup
         run: dart setup.dart ${{ matrix.platform }} ${{ matrix.arch && format('--arch {0}', matrix.arch) }} ${{ env.IS_STABLE == 'true' && '--env stable' || '' }}
@@ -95,34 +107,26 @@ jobs:
       - name: Generate
         if: ${{ env.IS_STABLE == 'true' }}
         run: |
-          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
+          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"
           done
-          cat CHANGELOG.md >> NEW_CHANGELOG.md
-          cat NEW_CHANGELOG.md > CHANGELOG.md
+          [ -f CHANGELOG.md ] && cat CHANGELOG.md >> "$temp"
+          
+          mv "$temp" CHANGELOG.md
 
       - name: Commit
         if: ${{ env.IS_STABLE == 'true' }}
@@ -172,35 +176,29 @@ jobs:
 
       - name: Generate release.md
         run: |
-          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
+          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"
           done
-
       - name: Push to telegram
         env:
           TELEGRAM_BOT_TOKEN: ${{ secrets.TELEGRAM_BOT_TOKEN }}
           TAG: ${{ github.ref_name }}
+          RUN_ID: ${{ github.run_id }}
         run: |
           python -m pip install --upgrade pip
           pip install requests
@@ -211,6 +209,14 @@ jobs:
           version=$(echo "${{ github.ref_name }}" | sed 's/^v//')
           sed "s|VERSION|$version|g" ./.github/release_template.md >> release.md
 
+      - name: Generate sha256
+        if: env.IS_STABLE == 'true'
+        run: |
+          cd ./dist
+          for file in $(find . -type f -not -name "*.sha256"); do
+            sha256sum "$file" > "${file}.sha256"
+          done  
+
       - name: Release
         if: ${{ env.IS_STABLE == 'true' }}
         uses: softprops/action-gh-release@v2

.gitignore

@@ -21,7 +21,7 @@ migrate_working_dir/
 # The .vscode folder contains launch configuration and tasks you configure in
 # VS Code which you may wish to be included in version control, so this line
 # is commented out by default.
-#.vscode/
+.vscode/
 
 # Flutter/Dart/Pub related
 **/doc/api/
@@ -41,15 +41,30 @@ app.*.symbols
 # Obfuscation related
 app.*.map.json
 
+#AI generated
+CLAUDE.md
+/.claude
+
+
 # Android Studio will place build artifacts here
 /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/
 
-
-
-#libclash
+#FlClash
 /libclash/
-
-#jniLibs
 /android/app/src/main/jniLibs/
+/services/helper/target
+/macos/**/Package.resolved
+devtools_options.yaml
+
+# FVM Version Cache
+.fvm/
+.fvmrc

.gitmodules

@@ -6,5 +6,9 @@
 	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
 
 

.metadata

@@ -1,11 +1,11 @@
 # This file tracks properties of this Flutter project.
 # Used by Flutter tool to assess capabilities and perform upgrades etc.
 #
-# This file should be version controlled.
+# This file should be version controlled and should not be manually edited.
 
 version:
-  revision: 796c8ef79279f9c774545b3771238c3098dbefab
-  channel: stable
+  revision: "adc901062556672b4138e18a4dc62a4be8f4b3c2"
+  channel: "stable"
 
 project_type: app
 
@@ -13,26 +13,11 @@ project_type: app
 migration:
   platforms:
     - platform: root
-      create_revision: 796c8ef79279f9c774545b3771238c3098dbefab
-      base_revision: 796c8ef79279f9c774545b3771238c3098dbefab
-    - platform: android
-      create_revision: 796c8ef79279f9c774545b3771238c3098dbefab
-      base_revision: 796c8ef79279f9c774545b3771238c3098dbefab
-    - platform: ios
-      create_revision: 796c8ef79279f9c774545b3771238c3098dbefab
-      base_revision: 796c8ef79279f9c774545b3771238c3098dbefab
-    - platform: linux
-      create_revision: 796c8ef79279f9c774545b3771238c3098dbefab
-      base_revision: 796c8ef79279f9c774545b3771238c3098dbefab
-    - platform: macos
-      create_revision: 796c8ef79279f9c774545b3771238c3098dbefab
-      base_revision: 796c8ef79279f9c774545b3771238c3098dbefab
-    - platform: web
-      create_revision: 796c8ef79279f9c774545b3771238c3098dbefab
-      base_revision: 796c8ef79279f9c774545b3771238c3098dbefab
+      create_revision: adc901062556672b4138e18a4dc62a4be8f4b3c2
+      base_revision: adc901062556672b4138e18a4dc62a4be8f4b3c2
     - platform: windows
-      create_revision: 796c8ef79279f9c774545b3771238c3098dbefab
-      base_revision: 796c8ef79279f9c774545b3771238c3098dbefab
+      create_revision: adc901062556672b4138e18a4dc62a4be8f4b3c2
+      base_revision: adc901062556672b4138e18a4dc62a4be8f4b3c2
 
   # User provided section
 

.run/main.dart.run.xml

@@ -0,0 +1,7 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="main.dart" type="FlutterRunConfigurationType" factoryName="Flutter">
+    <option name="additionalArgs" value="--dart-define-from-file env.json" />
+    <option name="filePath" value="$PROJECT_DIR$/lib/main.dart" />
+    <method v="2" />
+  </configuration>
+</component>

CHANGELOG.md

@@ -1,3 +1,133 @@
+## v0.8.90
+
+- Fix android tile service
+
+- Support append system DNS
+
+- Fix some issues
+
+- Update changelog
+
+## v0.8.89
+
+- Fix some issues
+
+- Optimize Windows service mode
+
+- Update core
+
+- Update changelog
+
+## v0.8.88
+
+- Add android separates the core process
+
+- Support core status check and force restart
+
+- Optimize proxies page and access page
+
+- Update flutter and pub dependencies
+
+- Update go version
+
+- Optimize more details
+
+- Update changelog
+
+## v0.8.87
+
+- Optimize desktop view
+
+- Optimize logs, requests, connection pages
+
+- Optimize windows tray auto hide
+
+- Optimize some details
+
+- Update core
+
+- Update changelog
+
+## v0.8.86
+
+- Fix windows tun issues
+
+- Optimize android get system dns
+
+- Optimize more details
+
+- Update changelog
+
+## v0.8.85
+
+- Support override script
+
+- Support proxies search
+
+- Support svg display
+
+- Optimize config persistence
+
+- Add some scenes auto close connections
+
+- Update core
+
+- Optimize more details
+
+## v0.8.84
+
+- Fix windows service verify issues
+
+- Update changelog
+
+## v0.8.83
+
+- Add windows server mode start process verify
+
+- Add linux deb dependencies
+
+- Add backup recovery strategy select
+
+- Support custom text scaling
+
+- Optimize the display of different text scale
+
+- Optimize windows setup experience
+
+- Optimize startTun performance
+
+- Optimize android tv experience
+
+- Optimize default option
+
+- Optimize computed text size
+
+- Optimize hyperOS freeform window
+
+- Add developer mode
+
+- Update core
+
+- Optimize more details
+
+- Add issues template
+
+- Update changelog
+
+## 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

Makefile

@@ -1,10 +0,0 @@
-android_arm64:
-	dart ./setup.dart android --arch arm64
-macos_arm64:
-	dart ./setup.dart macos --arch arm64
-android_app:
-	dart ./setup.dart android
-android_arm64_core:
-	dart ./setup.dart android --arch arm64 --out core
-macos_arm64_core:
-	dart ./setup.dart macos --arch arm64  --out core

README.md

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

README_zh_CN.md

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

analysis_options.yaml

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

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

@@ -0,0 +1,109 @@
+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 = ".dev"
+        }
+
+        release {
+            isMinifyEnabled = true
+            isShrinkResources = true
+            if (isRelease) {
+                signingConfig = signingConfigs.getByName("release")
+            } else {
+                signingConfig = signingConfigs.getByName("debug")
+                applicationIdSuffix = ".dev"
+            }
+
+            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

@@ -0,0 +1,65 @@
+{
+  "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": []
+        }
+      }
+    },
+    {
+      "client_info": {
+        "mobilesdk_app_id": "1:000000000000:android:0000000000000000",
+        "android_client_info": {
+          "package_name": "com.follow.clash.dev"
+        }
+      },
+      "oauth_client": [],
+      "api_key": [
+        {
+          "current_key": "0"
+        }
+      ],
+      "services": {
+        "appinvite_service": {
+          "other_platform_oauth_client": []
+        }
+      }
+    }
+  ]
+}

android/app/proguard-rules.pro

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

android/app/src/debug/AndroidManifest.xml

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

android/app/src/main/AndroidManifest.xml

@@ -1,3 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools">
 
@@ -7,43 +8,44 @@
     <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=".FlClashApplication"
+        android:name=".Application"
+        android:banner="@mipmap/ic_banner"
         android:hardwareAccelerated="true"
         android:icon="@mipmap/ic_launcher"
         android:label="FlClash">
         <activity
-            android:name="com.follow.clash.MainActivity"
+            android:name=".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>
             <intent-filter>
                 <action android:name="android.service.quicksettings.action.QS_TILE_PREFERENCES" />
@@ -62,12 +64,9 @@
             </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>
@@ -80,17 +79,16 @@
             </intent-filter>
             <intent-filter>
                 <category android:name="android.intent.category.DEFAULT" />
-                <action android:name="${applicationId}.action.CHANGE" />
+                <action android:name="${applicationId}.action.TOGGLE" />
             </intent-filter>
         </activity>
 
         <service
-            android:name=".services.FlClashTileService"
+            android:name=".TileService"
             android:exported="true"
-            android:icon="@drawable/ic_stat_name"
+            android:icon="@drawable/ic"
             android:label="FlClash"
-            android:permission="android.permission.BIND_QUICK_SETTINGS_TILE"
-            tools:targetApi="n">
+            android:permission="android.permission.BIND_QUICK_SETTINGS_TILE">
             <intent-filter>
                 <action android:name="android.service.quicksettings.action.QS_TILE" />
             </intent-filter>
@@ -99,49 +97,16 @@
                 android:value="true" />
         </service>
 
-        <provider
-            android:name=".FilesProvider"
-            android:authorities="${applicationId}.files"
+        <receiver
+            android:name=".BroadcastReceiver"
+            android:enabled="true"
             android:exported="true"
-            android:grantUriPermissions="true"
-            android:permission="android.permission.MANAGE_DOCUMENTS"
-            android:process=":background">
+            android:permission="${applicationId}.permission.RECEIVE_BROADCASTS">
             <intent-filter>
-                <action android:name="android.content.action.DOCUMENTS_PROVIDER" />
+                <action android:name="${applicationId}.intent.action.SERVICE_CREATED" />
+                <action android:name="${applicationId}.intent.action.SERVICE_DESTROYED" />
             </intent-filter>
-        </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>
+        </receiver>
 
         <meta-data
             android:name="flutterEmbedding"

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

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

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

@@ -0,0 +1,150 @@
+package com.follow.clash
+
+import android.app.Application
+import android.content.Context.MODE_PRIVATE
+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 android.widget.Toast
+import androidx.core.graphics.drawable.toBitmap
+import com.follow.clash.common.GlobalState
+import com.follow.clash.models.SharedState
+import com.google.gson.Gson
+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
+
+val Application.sharedState: SharedState
+    get() {
+        try {
+            val sp = getSharedPreferences("FlutterSharedPreferences", MODE_PRIVATE)
+            val res = sp.getString("flutter.sharedState", "")
+            return Gson().fromJson(res, SharedState::class.java)
+        } catch (_: Exception) {
+            return SharedState()
+        }
+    }
+
+
+private var lastToast: Toast? = null
+
+fun Application.showToast(text: String?) {
+    Handler(Looper.getMainLooper()).post {
+        lastToast?.cancel()
+        lastToast = Toast.makeText(this, text, Toast.LENGTH_LONG).apply {
+            show()
+        }
+    }
+
+}
+
+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/FlClashApplication.kt

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

@@ -1,108 +0,0 @@
-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()
-
-    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,23 +1,37 @@
 package com.follow.clash
 
-import com.follow.clash.core.Core
+import android.os.Bundle
+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)
+    }
 
-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())
-        GlobalState.flutterEngine = flutterEngine
+        State.flutterEngine = flutterEngine
     }
 
     override fun onDestroy() {
-        GlobalState.flutterEngine = null
+        GlobalState.launch {
+            Service.setEventListener(null)
+        }
+        State.flutterEngine = null
         super.onDestroy()
     }
 }

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

@@ -0,0 +1,187 @@
+package com.follow.clash
+
+import com.follow.clash.common.GlobalState
+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.IVoidInterface
+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?.let { cb ->
+                                cb(res.formatString())
+                            }
+                        }
+                    }
+                })
+        }
+    }
+
+    suspend fun quickSetup(
+        initParamsString: String,
+        setupParamsString: String,
+        onStarted: (() -> Unit)?,
+        onResult: ((result: String) -> Unit)?,
+    ): Result<Unit> {
+        val res = mutableListOf<ByteArray>()
+        return delegate.useService {
+            it.quickSetup(
+                initParamsString,
+                setupParamsString,
+                object : ICallbackInterface.Stub() {
+                    override fun onResult(
+                        result: ByteArray?, isSuccess: Boolean, ack: IAckInterface?
+                    ) {
+                        res.add(result ?: byteArrayOf())
+                        ack?.onAck()
+                        if (isSuccess) {
+                            onResult?.let { cb ->
+                                cb(res.formatString())
+                            }
+                        }
+                    }
+                },
+                object : IVoidInterface.Stub() {
+                    override fun invoke() {
+                        onStarted?.let { onStarted ->
+                            onStarted()
+                        }
+                    }
+                }
+            )
+        }
+    }
+
+    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) {
+            GlobalState.log("awaitIResultInterface $e")
+            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

@@ -0,0 +1,205 @@
+package com.follow.clash
+
+import android.net.VpnService
+import com.follow.clash.common.GlobalState
+import com.follow.clash.models.SharedState
+import com.follow.clash.plugins.AppPlugin
+import com.follow.clash.plugins.TilePlugin
+import com.follow.clash.service.models.NotificationParams
+import com.google.gson.Gson
+import io.flutter.embedding.engine.FlutterEngine
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+
+enum class RunState {
+    START, PENDING, STOP
+}
+
+
+object State {
+
+    val runLock = Mutex()
+
+    var runTime: Long = 0
+
+    var sharedState: SharedState = SharedState()
+
+    val runStateFlow: MutableStateFlow<RunState> = MutableStateFlow(RunState.STOP)
+
+    var flutterEngine: FlutterEngine? = null
+
+    val appPlugin: AppPlugin?
+        get() = flutterEngine?.plugin<AppPlugin>()
+
+    val tilePlugin: TilePlugin?
+        get() = flutterEngine?.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
+            }
+            startServiceWithPref()
+        }
+
+    }
+
+    suspend fun handleStopServiceAction() {
+        runLock.withLock {
+            if (runStateFlow.value != RunState.START) {
+                return
+            }
+            tilePlugin?.handleStop()
+            if (flutterEngine != null) {
+                return
+            }
+            GlobalState.application.showToast(sharedState.stopTip)
+            handleStopService()
+        }
+    }
+
+    fun handleStartService() {
+        val appPlugin = flutterEngine?.plugin<AppPlugin>()
+        if (appPlugin != null) {
+            appPlugin.requestNotificationsPermission {
+                startService()
+            }
+            return
+        }
+        startService()
+    }
+
+    private fun startServiceWithPref() {
+        GlobalState.launch {
+            runLock.withLock {
+                if (runStateFlow.value != RunState.STOP) {
+                    return@launch
+                }
+                sharedState = GlobalState.application.sharedState
+                setupAndStart()
+            }
+        }
+    }
+
+    suspend fun syncState() {
+        GlobalState.setCrashlytics(sharedState.crashlytics)
+        Service.updateNotificationParams(
+            NotificationParams(
+                title = sharedState.currentProfileName,
+                stopText = sharedState.stopText,
+                onlyStatisticsProxy = sharedState.onlyStatisticsProxy
+            )
+        )
+        Service.setCrashlytics(sharedState.crashlytics)
+    }
+
+    private suspend fun setupAndStart() {
+        Service.bind()
+        syncState()
+        GlobalState.application.showToast(sharedState.startTip)
+        val initParams = mutableMapOf<String, Any>()
+        initParams["home-dir"] = GlobalState.application.filesDir.path
+        initParams["version"] = android.os.Build.VERSION.SDK_INT
+        val initParamsString = Gson().toJson(initParams)
+        val setupParamsString = Gson().toJson(sharedState.setupParams)
+        Service.quickSetup(
+            initParamsString,
+            setupParamsString,
+            onStarted = {
+                startService()
+            },
+            onResult = {
+                if (it.isNotEmpty()) {
+                    GlobalState.application.showToast(it)
+                }
+            },
+        )
+    }
+
+    private fun startService() {
+        GlobalState.launch {
+            runLock.withLock {
+                if (runStateFlow.value != RunState.STOP) {
+                    return@launch
+                }
+                try {
+                    runStateFlow.tryEmit(RunState.PENDING)
+                    val options = sharedState.vpnOptions ?: return@launch
+                    appPlugin?.let {
+                        it.prepare(options.enable) {
+                            runTime = Service.startService(options, runTime)
+                            runStateFlow.tryEmit(RunState.START)
+                        }
+                    } ?: run {
+                        val intent = VpnService.prepare(GlobalState.application)
+                        if (intent != null) {
+                            return@launch
+                        }
+                        runTime = Service.startService(options, runTime)
+                        runStateFlow.tryEmit(RunState.START)
+                    }
+                } finally {
+                    if (runStateFlow.value == RunState.PENDING) {
+                        runStateFlow.tryEmit(RunState.STOP)
+                    }
+                }
+            }
+        }
+    }
+
+    fun handleStopService() {
+        GlobalState.launch {
+            runLock.withLock {
+                if (runStateFlow.value != RunState.START) {
+                    return@launch
+                }
+                try {
+                    runStateFlow.tryEmit(RunState.PENDING)
+                    runTime = Service.stopService()
+                    runStateFlow.tryEmit(RunState.STOP)
+                } finally {
+                    if (runStateFlow.value == RunState.PENDING) {
+                        runStateFlow.tryEmit(RunState.START)
+                    }
+                }
+            }
+        }
+    }
+}
+
+
+

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

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

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

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

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

@@ -3,6 +3,7 @@ package com.follow.clash.models
 data class Package(
     val packageName: String,
     val label: String,
-    val isSystem: Boolean,
+    val system: Boolean,
+    val internet: Boolean,
     val lastUpdateTime: Long,
 )

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

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

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

@@ -0,0 +1,22 @@
+package com.follow.clash.models
+
+import com.follow.clash.service.models.VpnOptions
+import com.google.gson.annotations.SerializedName
+
+data class SharedState(
+    val startTip: String = "Starting VPN...",
+    val stopTip: String = "Stopping VPN...",
+    val crashlytics: Boolean = true,
+    val currentProfileName: String = "FlClash",
+    val stopText: String = "Stop",
+    val onlyStatisticsProxy: Boolean = false,
+    val vpnOptions: VpnOptions? = null,
+    val setupParams: SetupParams? = null,
+)
+
+data class SetupParams(
+    @SerializedName("test-url")
+    val testUrl: String,
+    @SerializedName("selected-map")
+    val selectedMap: Map<String, String>,
+)

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

@@ -9,22 +9,21 @@ import android.content.pm.ComponentInfo
 import android.content.pm.PackageManager
 import android.net.VpnService
 import android.os.Build
-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.extensions.awaitResult
-import com.follow.clash.extensions.getActionIntent
-import com.follow.clash.extensions.getBase64
+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.models.Package
+import com.follow.clash.showToast
 import com.google.gson.Gson
 import io.flutter.embedding.android.FlutterActivity
 import io.flutter.embedding.engine.plugins.FlutterPlugin
@@ -44,15 +43,20 @@ 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 vpnCallBack: (() -> Unit)? = null
+    private var vpnPrepareCallback: (suspend () -> Unit)? = null
 
-    private val iconMap = mutableMapOf<String, String?>()
+    private var requestNotificationCallback: (() -> Unit)? = null
 
     private val packages = mutableListOf<Package>()
 
@@ -111,46 +115,8 @@ 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" -> {
@@ -182,26 +148,7 @@ class AppPlugin : FlutterPlugin, MethodChannel.MethodCallHandler, ActivityAware
             }
 
             "getPackageIcon" -> {
-                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
-                    }
-                }
+                handleGetPackageIcon(call, result)
             }
 
             "tip" -> {
@@ -210,56 +157,48 @@ 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 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 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 tip(message: String?) {
+        GlobalState.application.showToast(message)
+    }
+
+    @Suppress("DEPRECATION")
     private fun updateExcludeFromRecents(value: Boolean?) {
-        val am = getSystemService(FlClashApplication.getAppContext(), ActivityManager::class.java)
+        val am = getSystemService(GlobalState.application, ActivityManager::class.java)
         val task = am?.appTasks?.firstOrNull {
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
                 it.taskInfo.taskId == activityRef?.get()?.taskId
@@ -275,37 +214,22 @@ 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 = FlClashApplication.getAppContext().packageManager
+        val packageManager = GlobalState.application.packageManager
         if (packages.isNotEmpty()) return packages
         packageManager?.getInstalledPackages(PackageManager.GET_META_DATA or PackageManager.GET_PERMISSIONS)
             ?.filter {
-                it.packageName != FlClashApplication.getAppContext().packageName && (
-                        it.requestedPermissions?.contains(Manifest.permission.INTERNET) == true
-                                || it.packageName == "android"
-                        )
-
+                it.packageName != GlobalState.application.packageName && it.packageName != "android"
             }?.map {
-            Package(
-                packageName = it.packageName,
-                label = it.applicationInfo?.loadLabel(packageManager).toString(),
-                isSystem = (it.applicationInfo?.flags?.and(ApplicationInfo.FLAG_SYSTEM)) == 1,
-                lastUpdateTime = it.lastUpdateTime
-            )
-        }?.let { packages.addAll(it) }
+                Package(
+                    packageName = it.packageName,
+                    label = it.applicationInfo?.loadLabel(packageManager).toString(),
+                    system = (it.applicationInfo?.flags?.and(ApplicationInfo.FLAG_SYSTEM)) != 0,
+                    lastUpdateTime = it.lastUpdateTime,
+                    internet = it.requestedPermissions?.contains(Manifest.permission.INTERNET) == true
+                )
+            }?.let { packages.addAll(it) }
         return packages
     }
 
@@ -323,52 +247,66 @@ class AppPlugin : FlutterPlugin, MethodChannel.MethodCallHandler, ActivityAware
         }
     }
 
-    fun requestVpnPermission(callBack: () -> Unit) {
-        vpnCallBack = callBack
-        val intent = VpnService.prepare(FlClashApplication.getAppContext())
+    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)
         if (intent != null) {
             activityRef?.get()?.startActivityForResult(intent, VPN_PERMISSION_REQUEST_CODE)
             return
         }
-        vpnCallBack?.invoke()
+        invokeVpnPrepareCallback()
     }
 
-    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
-                }
-            }
+    fun invokeVpnPrepareCallback() {
+        GlobalState.launch {
+            vpnPrepareCallback?.invoke()
+            vpnPrepareCallback = null
         }
     }
 
-    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 = FlClashApplication.getAppContext().packageManager ?: return false
+        val packageManager = GlobalState.application.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)) {
@@ -377,8 +315,7 @@ 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(
@@ -429,6 +366,18 @@ 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)
@@ -451,21 +400,19 @@ 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) {
-                GlobalState.initServiceEngine()
-                vpnCallBack?.invoke()
+                invokeVpnPrepareCallback()
             }
         }
         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,19 +1,30 @@
 package com.follow.clash.plugins
 
-import com.follow.clash.GlobalState
-import com.follow.clash.models.VpnOptions
+import com.follow.clash.RunState
+import com.follow.clash.Service
+import com.follow.clash.State
+import com.follow.clash.common.Components
+import com.follow.clash.invokeMethodOnMainThread
+import com.follow.clash.models.SharedState
 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
 
-
-data object ServicePlugin : FlutterPlugin, MethodChannel.MethodCallHandler {
-
+class ServicePlugin : FlutterPlugin, MethodChannel.MethodCallHandler,
+    CoroutineScope by CoroutineScope(SupervisorJob() + Dispatchers.Default) {
     private lateinit var flutterMethodChannel: MethodChannel
 
     override fun onAttachedToEngine(flutterPluginBinding: FlutterPlugin.FlutterPluginBinding) {
-        flutterMethodChannel = MethodChannel(flutterPluginBinding.binaryMessenger, "service")
+        flutterMethodChannel = MethodChannel(
+            flutterPluginBinding.binaryMessenger, "${Components.PACKAGE_NAME}/service"
+        )
         flutterMethodChannel.setMethodCallHandler(this)
     }
 
@@ -22,28 +33,32 @@ data object 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" -> {
-            GlobalState.getCurrentAppPlugin()
-                ?.requestNotificationsPermission()
-            GlobalState.initServiceEngine()
-            result.success(true)
+            handleInit(result)
         }
 
-        "destroy" -> {
-            handleDestroy()
-            result.success(true)
+        "shutdown" -> {
+            handleShutdown(result)
+        }
+
+        "invokeAction" -> {
+            handleInvokeAction(call, result)
+        }
+
+        "getRunTime" -> {
+            handleGetRunTime(result)
+        }
+
+        "syncState" -> {
+            handleSyncState(call, result)
+        }
+
+        "start" -> {
+            handleStart(result)
+        }
+
+        "stop" -> {
+            handleStop(result)
         }
 
         else -> {
@@ -51,7 +66,74 @@ data object ServicePlugin : FlutterPlugin, MethodChannel.MethodCallHandler {
         }
     }
 
-    private fun handleDestroy() {
-        GlobalState.destroyServiceEngine()
+    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)
+    }
+
+    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>()!!
+        State.sharedState = Gson().fromJson(data, SharedState::class.java)
+        launch {
+            State.syncState()
+            result.success("")
+        }
+    }
+
+
+    fun handleInit(result: MethodChannel.Result) {
+        Service.bind()
+        launch {
+            Service.setEventListener {
+                handleSendEvent(it)
+            }.onSuccess {
+                result.success("")
+            }.onFailure {
+                result.success(it.message)
+            }
+
+        }
+        Service.onServiceDisconnected = ::onServiceDisconnected
+    }
+
+    private fun handleGetRunTime(result: MethodChannel.Result) {
+        launch {
+            State.handleSyncState()
+            result.success(State.runTime)
+        }
     }
 }

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

@@ -1,5 +1,7 @@
 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
@@ -9,25 +11,21 @@ class TilePlugin : FlutterPlugin, MethodChannel.MethodCallHandler {
     private lateinit var channel: MethodChannel
 
     override fun onAttachedToEngine(flutterPluginBinding: FlutterPlugin.FlutterPluginBinding) {
-        channel = MethodChannel(flutterPluginBinding.binaryMessenger, "tile")
+        channel =
+            MethodChannel(flutterPluginBinding.binaryMessenger, "${Components.PACKAGE_NAME}/tile")
         channel.setMethodCallHandler(this)
     }
 
     override fun onDetachedFromEngine(binding: FlutterPlugin.FlutterPluginBinding) {
-        handleDetached()
         channel.setMethodCallHandler(null)
     }
 
     fun handleStart() {
-        channel.invokeMethod("start", null)
+        channel.invokeMethodOnMainThread<Any>("start", null)
     }
 
     fun handleStop() {
-        channel.invokeMethod("stop", null)
-    }
-
-    private fun handleDetached() {
-        channel.invokeMethod("detached", null)
+        channel.invokeMethodOnMainThread<Any>("stop", null)
     }
 
 

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

@@ -1,266 +0,0 @@
-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 = Gson().fromJson(
-                data, StartForegroundParams::class.java
-            )
-            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

@@ -1,12 +0,0 @@
-package com.follow.clash.services
-
-import com.follow.clash.models.VpnOptions
-
-interface BaseServiceInterface {
-
-    fun start(options: VpnOptions): Int
-
-    fun stop()
-
-    suspend fun startForeground(title: String, content: String)
-}

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

@@ -1,130 +0,0 @@
-package com.follow.clash.services
-
-import android.annotation.SuppressLint
-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.Binder
-import android.os.Build
-import android.os.IBinder
-import androidx.core.app.NotificationCompat
-import com.follow.clash.GlobalState
-import com.follow.clash.MainActivity
-import com.follow.clash.extensions.getActionPendingIntent
-import com.follow.clash.models.VpnOptions
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Deferred
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.async
-
-
-class FlClashService : Service(), BaseServiceInterface {
-
-    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)
-    }
-
-    private val CHANNEL = "FlClash"
-
-    private val notificationId: Int = 1
-
-    private val notificationBuilderDeferred: Deferred<NotificationCompat.Builder> by lazy {
-        CoroutineScope(Dispatchers.Main).async {
-            val stopText = GlobalState.getText("stop")
-
-            val intent = Intent(
-                this@FlClashService, MainActivity::class.java
-            )
-
-            val pendingIntent = if (Build.VERSION.SDK_INT >= 31) {
-                PendingIntent.getActivity(
-                    this@FlClashService,
-                    0,
-                    intent,
-                    PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
-                )
-            } else {
-                PendingIntent.getActivity(
-                    this@FlClashService,
-                    0,
-                    intent,
-                    PendingIntent.FLAG_UPDATE_CURRENT
-                )
-            }
-
-            with(NotificationCompat.Builder(this@FlClashService, CHANNEL)) {
-                setSmallIcon(com.follow.clash.R.drawable.ic_stat_name)
-                setContentTitle("FlClash")
-                setContentIntent(pendingIntent)
-                setCategory(NotificationCompat.CATEGORY_SERVICE)
-                priority = NotificationCompat.PRIORITY_MIN
-                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-                    foregroundServiceBehavior = FOREGROUND_SERVICE_IMMEDIATE
-                }
-                addAction(
-                    0,
-                    stopText, // 使用 suspend 函数获取的文本
-                    getActionPendingIntent("STOP")
-                )
-                setOngoing(true)
-                setShowWhen(false)
-                setOnlyAlertOnce(true)
-                setAutoCancel(true)
-            }
-        }
-    }
-
-    private suspend fun getNotificationBuilder(): NotificationCompat.Builder {
-        return notificationBuilderDeferred.await()
-    }
-
-    override fun start(options: VpnOptions) = 0
-
-    override fun stop() {
-        stopSelf()
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-            stopForeground(STOP_FOREGROUND_REMOVE)
-        }
-    }
-
-
-    @SuppressLint("ForegroundServiceType")
-    override suspend fun startForeground(title: String, content: String) {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            val manager = getSystemService(NotificationManager::class.java)
-            var channel = manager?.getNotificationChannel(CHANNEL)
-            if (channel == null) {
-                channel =
-                    NotificationChannel(CHANNEL, "FlClash", NotificationManager.IMPORTANCE_LOW)
-                manager?.createNotificationChannel(channel)
-            }
-        }
-        val notification =
-            getNotificationBuilder()
-                .setContentTitle(title)
-                .setContentText(content).build()
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
-            try {
-                startForeground(notificationId, notification, FOREGROUND_SERVICE_TYPE_DATA_SYNC)
-            } catch (_: Exception) {
-                startForeground(notificationId, notification)
-            }
-        } else {
-            startForeground(notificationId, notification)
-        }
-    }
-}

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

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

@@ -1,246 +0,0 @@
-package com.follow.clash.services
-
-import android.annotation.SuppressLint
-import android.app.Notification.FOREGROUND_SERVICE_IMMEDIATE
-import android.app.NotificationChannel
-import android.app.NotificationManager
-import android.app.PendingIntent
-import android.content.Intent
-import android.content.pm.ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC
-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.MainActivity
-import com.follow.clash.R
-import com.follow.clash.extensions.getActionPendingIntent
-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.Deferred
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.async
-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)
-                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)
-                }
-            }
-            if (options.ipv6Address.isNotEmpty()) {
-                val cidr = options.ipv6Address.toCIDR()
-                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)
-                }
-            }
-            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 val CHANNEL = "FlClash"
-
-    private val notificationId: Int = 1
-
-    private val notificationBuilderDeferred: Deferred<NotificationCompat.Builder> by lazy {
-        CoroutineScope(Dispatchers.Main).async {
-            val stopText = GlobalState.getText("stop")
-            val intent = Intent(this@FlClashVpnService, MainActivity::class.java)
-
-            val pendingIntent = if (Build.VERSION.SDK_INT >= 31) {
-                PendingIntent.getActivity(
-                    this@FlClashVpnService,
-                    0,
-                    intent,
-                    PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
-                )
-            } else {
-                PendingIntent.getActivity(
-                    this@FlClashVpnService,
-                    0,
-                    intent,
-                    PendingIntent.FLAG_UPDATE_CURRENT
-                )
-            }
-
-            with(NotificationCompat.Builder(this@FlClashVpnService, CHANNEL)) {
-                setSmallIcon(R.drawable.ic_stat_name)
-                setContentTitle("FlClash")
-                setContentIntent(pendingIntent)
-                setCategory(NotificationCompat.CATEGORY_SERVICE)
-                priority = NotificationCompat.PRIORITY_MIN
-                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-                    foregroundServiceBehavior = FOREGROUND_SERVICE_IMMEDIATE
-                }
-                setOngoing(true)
-                addAction(
-                    0,
-                    stopText,
-                    getActionPendingIntent("STOP")
-                )
-                setShowWhen(false)
-                setOnlyAlertOnce(true)
-                setAutoCancel(true)
-            }
-        }
-    }
-
-    private suspend fun getNotificationBuilder(): NotificationCompat.Builder {
-        return notificationBuilderDeferred.await()
-    }
-
-    @SuppressLint("ForegroundServiceType")
-    override suspend fun startForeground(title: String, content: String) {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            val manager = getSystemService(NotificationManager::class.java)
-            var channel = manager?.getNotificationChannel(CHANNEL)
-            if (channel == null) {
-                channel =
-                    NotificationChannel(CHANNEL, "FlClash", NotificationManager.IMPORTANCE_LOW)
-                manager?.createNotificationChannel(channel)
-            }
-        }
-        val notification =
-            getNotificationBuilder()
-                .setContentTitle(title)
-                .setContentText(content)
-                .build()
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
-            try {
-                startForeground(notificationId, notification, FOREGROUND_SERVICE_TYPE_DATA_SYNC)
-            } catch (_: Exception) {
-                startForeground(notificationId, notification)
-            }
-        } else {
-            startForeground(notificationId, notification)
-        }
-    }
-
-    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"/>
+        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>
-  </group>
 </vector>

android/build.gradle

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

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

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

android/common/build.gradle.kts

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

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

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

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

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

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

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

@@ -0,0 +1,14 @@
+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/common/src/main/res/values/strings.xml

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

android/core/build.gradle.kts

@@ -1,4 +1,4 @@
-import com.android.build.gradle.tasks.MergeSourceSetFolders
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 
 plugins {
     id("com.android.library")
@@ -7,22 +7,13 @@ plugins {
 
 android {
     namespace = "com.follow.clash.core"
-    compileSdk = 35
-    ndkVersion = "28.0.13004108"
+    compileSdk = libs.versions.compileSdk.get().toInt()
+    ndkVersion = libs.versions.ndkVersion.get()
 
     defaultConfig {
-        minSdk = 21
-        consumerProguardFiles("consumer-rules.pro")
+        minSdk = libs.versions.minSdk.get().toInt()
     }
 
-    buildTypes {
-        release {
-            proguardFiles(
-                getDefaultProguardFile("proguard-android-optimize.txt"),
-                "proguard-rules.pro"
-            )
-        }
-    }
 
     sourceSets {
         getByName("main") {
@@ -38,28 +29,53 @@ android {
     }
 
     compileOptions {
-        sourceCompatibility = JavaVersion.VERSION_11
-        targetCompatibility = JavaVersion.VERSION_11
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
     }
-    kotlinOptions {
-        jvmTarget = "11"
+
+    buildTypes {
+        release {
+            proguardFiles(
+                getDefaultProguardFile("proguard-android-optimize.txt"),
+                "proguard-rules.pro"
+            )
+        }
     }
 }
 
+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

@@ -1,21 +0,0 @@
-# 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,4 +1,5 @@
 <?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,23 +4,13 @@ project("core")
 
 message("CMAKE_SOURCE_DIR ${CMAKE_SOURCE_DIR}")
 
+message("CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE}")
+
+
 if (NOT "${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
-    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
-    )
+    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)
 endif ()
 
 set(LIB_CLASH_PATH "${CMAKE_SOURCE_DIR}/../jniLibs/${ANDROID_ABI}/libclash.so")
@@ -29,7 +19,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}/../jniLibs/${ANDROID_ABI})
+    include_directories(${CMAKE_SOURCE_DIR}/../cpp/includes/${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,16 +1,17 @@
 #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) {
-    auto interface = new_global(cb);
-    startTUN(fd, interface);
+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));
 }
 
 extern "C"
@@ -19,57 +20,189 @@ 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);
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_follow_clash_core_Core_quickSetup(JNIEnv *env, jobject thiz, jstring init_params_string,
+                                           jstring setup_params_string, jobject cb) {
+    const auto interface = new_global(cb);
+    quickSetup(interface, get_string(init_params_string), get_string(setup_params_string));
+}
+
 
 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((jobject) obj);
+    del_global(static_cast<jobject>(obj));
 }
 
-static void call_tun_interface_protect_impl(void *tun_interface, int fd) {
-    ATTACH_JNI();
-    env->CallVoidMethod((jobject) tun_interface,
-                        (jmethodID) m_tun_interface_protect,
-                        (jint) fd);
+static void free_string_impl(char *str) {
+    free(str);
 }
 
-static const char*
-call_tun_interface_resolve_process_impl(void *tun_interface, int protocol,
-                                         const char *source,
-                                         const char *target,
-                                         int uid) {
+static void call_tun_interface_protect_impl(void *tun_interface, const int fd) {
     ATTACH_JNI();
-    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);
+    env->CallVoidMethod(static_cast<jobject>(tun_interface),
+                        m_tun_interface_protect,
+                        fd);
+}
+
+static char *
+call_tun_interface_resolve_process_impl(void *tun_interface, const int protocol,
+                                        const char *source,
+                                        const char *target,
+                                        const 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));
     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 *reserved) {
+JNI_OnLoad(JavaVM *vm, void *) {
     JNIEnv *env = nullptr;
-    if (vm->GetEnv((void **) &env, JNI_VERSION_1_6) != JNI_OK) {
+    if (vm->GetEnv(reinterpret_cast<void **>(&env), JNI_VERSION_1_6) != JNI_OK) {
         return JNI_ERR;
     }
 
     initialize_jni(vm, env);
 
-    jclass c_tun_interface = find_class("com/follow/clash/core/TunInterface");
+    const auto c_tun_interface = find_class("com/follow/clash/core/TunInterface");
+
+    const auto c_invoke_interface = find_class("com/follow/clash/core/InvokeInterface");
 
     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;");
+                                                  "(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;
 
-    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) {
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_follow_clash_core_Core_quickSetup(JNIEnv *env, jobject thiz, jstring init_params_string,
+                                           jstring setup_params_string, jobject cb) {
+}
 #endif

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

@@ -1,5 +1,6 @@
 #include "jni_helper.h"
 
+#include <cstdlib>
 #include <malloc.h>
 #include <cstring>
 
@@ -12,7 +13,7 @@ static jmethodID m_get_bytes;
 void initialize_jni(JavaVM *vm, JNIEnv *env) {
     global_vm = vm;
 
-    c_string = (jclass) new_global(find_class("java/lang/String"));
+    c_string = reinterpret_cast<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");
 }
@@ -22,23 +23,23 @@ JavaVM *global_java_vm() {
 }
 
 char *jni_get_string(JNIEnv *env, jstring str) {
-    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);
+    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));
     content[length] = 0;
     return content;
 }
 
 jstring jni_new_string(JNIEnv *env, const char *str) {
-    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);
+    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));
 }
 
 int jni_catch_exception(JNIEnv *env) {
-    int result = env->ExceptionCheck();
+    const int result = env->ExceptionCheck();
     if (result) {
         env->ExceptionDescribe();
         env->ExceptionClear();
@@ -46,9 +47,9 @@ int jni_catch_exception(JNIEnv *env) {
     return result;
 }
 
-void jni_attach_thread(struct scoped_jni *jni) {
+void jni_attach_thread(scoped_jni *jni) {
     JavaVM *vm = global_java_vm();
-    if (vm->GetEnv((void **) &jni->env, JNI_VERSION_1_6) == JNI_OK) {
+    if (vm->GetEnv(reinterpret_cast<void **>(&jni->env), JNI_VERSION_1_6) == JNI_OK) {
         jni->require_release = 0;
         return;
     }
@@ -58,9 +59,9 @@ void jni_attach_thread(struct scoped_jni *jni) {
     jni->require_release = 1;
 }
 
-void jni_detach_thread(struct scoped_jni *jni) {
+void jni_detach_thread(const scoped_jni *env) {
     JavaVM *vm = global_java_vm();
-    if (jni->require_release) {
+    if (env->require_release) {
         vm->DetachCurrentThread();
     }
 }

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

@@ -1,9 +1,6 @@
 #pragma once
 
 #include <jni.h>
-#include <cstdint>
-#include <cstdlib>
-#include <malloc.h>
 
 struct scoped_jni {
     JNIEnv *env;
@@ -18,14 +15,14 @@ extern char *jni_get_string(JNIEnv *env, jstring str);
 
 extern int jni_catch_exception(JNIEnv *env);
 
-extern void jni_attach_thread(struct scoped_jni *jni);
+extern void jni_attach_thread(scoped_jni *jni);
 
-extern void jni_detach_thread(struct scoped_jni *env);
+extern void jni_detach_thread(const scoped_jni *env);
 
-extern void release_string(char **str);
+extern void release_string( char **str);
 
 #define ATTACH_JNI() __attribute__((unused, cleanup(jni_detach_thread))) \
-                    struct scoped_jni _jni; \
+                    scoped_jni _jni{}; \
                     jni_attach_thread(&_jni); \
                     JNIEnv *env = _jni.env
 
@@ -36,4 +33,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,7 +7,17 @@ import java.net.URL
 data object Core {
     private external fun startTun(
         fd: Int,
-        cb: TunInterface
+        cb: TunInterface,
+        stack: String,
+        address: String,
+        dns: String,
+    )
+
+    external fun forceGC(
+    )
+
+    external fun updateDNS(
+        dns: String,
     )
 
     private fun parseInetSocketAddress(address: String): InetSocketAddress {
@@ -19,31 +29,107 @@ data object Core {
     fun startTun(
         fd: Int,
         protect: (Int) -> Boolean,
-        resolverProcess: (protocol: Int, source: InetSocketAddress, target: InetSocketAddress, uid: Int) -> String
+        resolverProcess: (protocol: Int, source: InetSocketAddress, target: InetSocketAddress, uid: Int) -> String,
+        stack: String,
+        address: String,
+        dns: 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,
-                )
-            }
-        });
+                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)
+        }
+    }
+
+    fun quickSetup(
+        initParamsString: String,
+        setupParamsString: String,
+        cb: (result: String?) -> Unit,
+    ) {
+        quickSetup(
+            initParamsString,
+            setupParamsString,
+            object : InvokeInterface {
+                override fun onResult(result: String?) {
+                    cb(result)
+                }
+            },
+        )
+    }
+
+    private external fun quickSetup(
+        initParamsString: String,
+        setupParamsString: String,
+        cb: InvokeInterface
+    )
+
     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

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

android/gradle.properties

@@ -1,5 +1,3 @@
 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

@@ -0,0 +1,28 @@
+[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.11.1-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.13-all.zip
 

android/service/.gitignore

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

android/service/build.gradle.kts

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

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

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

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

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

@@ -0,0 +1,20 @@
+// 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.IVoidInterface;
+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 quickSetup(in String initParamsString, in String setupParamsString, in ICallbackInterface callback, in IVoidInterface onStarted);
+    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

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

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

@@ -0,0 +1,6 @@
+// IVoidInterface.aidl
+package com.follow.clash.service;
+
+interface IVoidInterface {
+    oneway void invoke();
+}

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

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

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

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

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

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

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

@@ -1,35 +1,33 @@
-package com.follow.clash
+package com.follow.clash.service
 
 import android.database.Cursor
 import android.database.MatrixCursor
 import android.os.CancellationSignal
 import android.os.ParcelFileDescriptor
-import android.provider.DocumentsContract.Document
-import android.provider.DocumentsContract.Root
+import android.provider.DocumentsContract
 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(
-            Document.COLUMN_DOCUMENT_ID,
-            Document.COLUMN_DISPLAY_NAME,
-            Document.COLUMN_MIME_TYPE,
-            Document.COLUMN_FLAGS,
-            Document.COLUMN_SIZE,
+            DocumentsContract.Document.COLUMN_DOCUMENT_ID,
+            DocumentsContract.Document.COLUMN_DISPLAY_NAME,
+            DocumentsContract.Document.COLUMN_MIME_TYPE,
+            DocumentsContract.Document.COLUMN_FLAGS,
+            DocumentsContract.Document.COLUMN_SIZE,
         )
         private val DEFAULT_ROOT_COLUMNS = arrayOf(
-            Root.COLUMN_ROOT_ID,
-            Root.COLUMN_FLAGS,
-            Root.COLUMN_ICON,
-            Root.COLUMN_TITLE,
-            Root.COLUMN_SUMMARY,
-            Root.COLUMN_DOCUMENT_ID
+            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
         )
     }
 
@@ -40,12 +38,12 @@ class FilesProvider : DocumentsProvider() {
     override fun queryRoots(projection: Array<String>?): Cursor {
         return MatrixCursor(projection ?: DEFAULT_ROOT_COLUMNS).apply {
             newRow().apply {
-                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, "/")
+                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, "/")
             }
         }
     }
@@ -87,20 +85,20 @@ class FilesProvider : DocumentsProvider() {
 
     private fun includeFile(result: MatrixCursor, file: File) {
         result.newRow().apply {
-            add(Document.COLUMN_DOCUMENT_ID, file.absolutePath)
-            add(Document.COLUMN_DISPLAY_NAME, file.name)
-            add(Document.COLUMN_SIZE, file.length())
+            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_FLAGS,
-                Document.FLAG_SUPPORTS_WRITE or Document.FLAG_SUPPORTS_DELETE
+                DocumentsContract.Document.COLUMN_FLAGS,
+                DocumentsContract.Document.FLAG_SUPPORTS_WRITE or DocumentsContract.Document.FLAG_SUPPORTS_DELETE
             )
-            add(Document.COLUMN_MIME_TYPE, getDocumentType(file))
+            add(DocumentsContract.Document.COLUMN_MIME_TYPE, getDocumentType(file))
         }
     }
 
     private fun getDocumentType(file: File): String {
         return if (file.isDirectory) {
-            Document.MIME_TYPE_DIR
+            DocumentsContract.Document.MIME_TYPE_DIR
         } else {
             "application/octet-stream"
         }

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

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

@@ -0,0 +1,196 @@
+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 quickSetup(
+            initParamsString: String,
+            setupParamsString: String,
+            callback: ICallbackInterface,
+            onStarted: IVoidInterface
+        ) {
+            Core.quickSetup(initParamsString, setupParamsString) {
+                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)
+                                        }
+                                    },
+                                )
+                            }
+                        }
+                    }
+                }
+            }
+            onStarted()
+        }
+
+        override fun updateNotificationParams(params: NotificationParams?) {
+            State.notificationParamsFlow.tryEmit(params)
+        }
+
+
+        override fun startService(
+            options: VpnOptions,
+            runtime: Long,
+            result: IResultInterface,
+        ) {
+            GlobalState.log("remote startService")
+            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

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

@@ -0,0 +1,261 @@
+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.accessControlProps.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

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

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

@@ -0,0 +1,83 @@
+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 AccessControlProps(
+    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 accessControlProps: AccessControlProps,
+    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

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

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

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

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

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

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