Add android separates the core process

Support core status check and force restart

Optimize proxies page and access page

Update flutter and pub dependencies

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

@@ -4,6 +4,8 @@ on:
   push:
     tags:
       - 'v*'
+env:
+  IS_STABLE: ${{ !contains(github.ref, '-') }}
 
 jobs:
   build:
@@ -14,10 +16,10 @@ 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
@@ -25,56 +27,62 @@ jobs:
           - platform: macos
             os: macos-latest
             arch: arm64
+          - platform: windows
+            os: windows-11-arm
+            arch: arm64
+          - platform: linux
+            os: ubuntu-24.04-arm
+            arch: arm64
 
     steps:
+      - name: Setup rust
+        if: startsWith(matrix.os, 'windows-11-arm')
+        run: |
+          Invoke-WebRequest -Uri "https://win.rustup.rs/aarch64" -OutFile rustup-init.exe
+          .\rustup-init.exe -y --default-toolchain stable
+          $cargoPath = "$env:USERPROFILE\.cargo\bin"
+          Add-Content $env:GITHUB_PATH $cargoPath
+
       - name: Checkout
         uses: actions/checkout@v4
         with:
           submodules: recursive
 
-      - name: Setup JAVA
-        if: startsWith(matrix.platform,'android')
-        uses: actions/setup-java@v4
-        with:
-          distribution: 'zulu'
-          java-version: 17
-
-      - name: Setup NDK
-        if: startsWith(matrix.platform,'android')
-        uses: nttld/setup-ndk@v1
-        id: setup-ndk
-        with:
-          ndk-version: r26b
-          add-to-path: true
-          link-to-sdk: true
-
       - name: Setup Android Signing
         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
 
-
       - name: Setup Go
         uses: actions/setup-go@v5
         with:
-          go-version: 'stable'
+          go-version: '1.24.0'
           cache-dependency-path: |
             core/go.sum
 
-      - name: Setup Flutter
+      - name: Setup Flutter Master
+        if: startsWith(matrix.os, 'windows-11-arm') || startsWith(matrix.os, 'ubuntu-24.04-arm')
         uses: subosito/flutter-action@v2
         with:
-          channel: stable
+          channel: 'master'
           cache: true
+      - name: Setup Flutter
+        if: ${{ !(startsWith(matrix.os, 'windows-11-arm') || startsWith(matrix.os, 'ubuntu-24.04-arm')) }}
+        uses: subosito/flutter-action@v2
+        with:
+          channel: 'stable'
+          cache: true
+      #          flutter-version: 3.29.3
 
       - name: Get Flutter Dependency
         run: flutter pub get
 
       - name: Setup
-        run: dart setup.dart ${{ matrix.platform }} ${{ matrix.arch && format('--arch {0}', matrix.arch) }}
+        run: dart setup.dart ${{ matrix.platform }} ${{ matrix.arch && format('--arch {0}', matrix.arch) }} ${{ env.IS_STABLE == 'true' && '--env stable' || '' }}
 
       - name: Upload
         uses: actions/upload-artifact@v4
@@ -88,14 +96,13 @@ jobs:
     needs: [ build ]
     steps:
       - name: Checkout
-        if: ${{ !contains(github.ref, '+') }}
         uses: actions/checkout@v4
+        if: ${{ env.IS_STABLE == 'true' }}
         with:
           fetch-depth: 0
           ref: refs/heads/main
-
       - name: Generate
-        if: ${{ !contains(github.ref, '+') }}
+        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)
@@ -127,7 +134,7 @@ jobs:
           cat NEW_CHANGELOG.md > CHANGELOG.md
 
       - name: Commit
-        if: ${{ !contains(github.ref, '+') }}
+        if: ${{ env.IS_STABLE == 'true' }}
         run: |
           git add CHANGELOG.md
           if ! git diff --cached --quiet; then
@@ -203,32 +210,41 @@ jobs:
         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
-          python release.py
+          python release_telegram.py
 
       - name: Patch release.md
         run: |
           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: ${{ !contains(github.ref, '+') }}
+        if: ${{ env.IS_STABLE == 'true' }}
         uses: softprops/action-gh-release@v2
         with:
           files: ./dist/*
           body_path: './release.md'
 
       - name: Create Fdroid Source Dir
-        if: ${{ !contains(github.ref, '+') }}
+        if: ${{ env.IS_STABLE == 'true' }}
         run: |
           mkdir -p ./tmp
           cp ./dist/*android-arm64-v8a* ./tmp/ || true
           echo "Files copied successfully"
 
       - name: Push to fdroid repo
-        if: ${{ !contains(github.ref, '+') }}
+        if: ${{ env.IS_STABLE == 'true' }}
         uses: cpina/github-action-push-to-another-repository@v1.7.2
         env:
           SSH_DEPLOY_KEY: ${{ secrets.SSH_DEPLOY_KEY }}
@@ -238,7 +254,7 @@ jobs:
           destination-repository-name: FlClash-fdroid-repo
           user-name: 'github-actions[bot]'
           user-email: 'github-actions[bot]@users.noreply.github.com'
-          target-branch: action-pr
+          target-branch: main
           commit-message: Update from ${{ github.ref_name }}
           target-directory: /tmp/
 

.gitmodules

@@ -1,14 +1,10 @@
 [submodule "core/Clash.Meta"]
 	path = core/Clash.Meta
 	url = git@github.com:chen08209/Clash.Meta.git
-	branch = FlClash-Alpha
+	branch = FlClash
 [submodule "plugins/flutter_distributor"]
 	path = plugins/flutter_distributor
 	url = git@github.com:chen08209/flutter_distributor.git
 	branch = FlClash
-[submodule "plugins/tray_manager"]
-	path = plugins/tray_manager
-	url = git@github.com:chen08209/tray_manager.git
-	branch = main
 
 

CHANGELOG.md

@@ -1,3 +1,119 @@
+## 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
+
+- Update core
+
+- Optimize more details
+
+- Update changelog
+
+## v0.8.80
+
+- Optimize dashboard performance
+
+- Fix some issues
+
+- Fix unselected proxy group delay issues
+
+- Fix asn url issues
+
+- Update changelog
+
 ## v0.8.79
 
 - Fix tab delay view issues

Makefile

@@ -0,0 +1,10 @@
+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,8 +1,10 @@
 include: package:flutter_lints/flutter.yaml
+analyzer:
+  exclude:
+    - lib/l10n/intl/**
+  errors:
+    invalid_annotation_target: ignore
 
 linter:
   rules:
-
-analyzer:
-  plugins:
-    - custom_lint
+    prefer_single_quotes: true

android/app/build.gradle

@@ -1,114 +0,0 @@
-import com.android.build.gradle.tasks.MergeSourceSetFolders
-
-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"
-    compileSdkVersion 34
-    ndkVersion "27.1.12297006"
-
-    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 34
-        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"
-        }
-    }
-}
-
-tasks.register('copyNativeLibs', Copy) {
-    delete('src/main/jniLibs')
-    from('../../libclash/android')
-    into('src/main/jniLibs')
-}
-
-tasks.withType(MergeSourceSetFolders).configureEach {
-    dependsOn copyNativeLibs
-}
-
-flutter {
-    source '../..'
-}
-
-dependencies {
-    implementation 'androidx.core:core-splashscreen:1.0.1'
-    implementation 'com.google.code.gson:gson:2.10'
-    implementation("com.android.tools.smali:smali-dexlib2:3.0.7") {
-        exclude group: "com.google.guava", module: "guava"
-    }
-}
-
-
-afterEvaluate {
-    assembleDebug.dependsOn copyNativeLibs
-
-    assembleRelease.dependsOn copyNativeLibs
-}

android/app/build.gradle.kts

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

android/app/google-services.json

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

android/app/proguard-rules.pro

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

@@ -1,13 +1,16 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
     <!-- The INTERNET permission is required for development. Specifically,
          the Flutter tool needs it to communicate with the running application
          to allow setting breakpoints, to provide hot reload, etc.
     -->
-    <application android:label="FlClash Debug" tools:replace="android:label">
+    <application
+        android:icon="@mipmap/ic_launcher"
+        android:label="FlClash Debug"
+        tools:replace="android:label">
         <service
-                android:name=".services.FlClashTileService"
-                android:label="FlClash Debug"
-                tools:replace="android:label">
-        </service>
+            android:name=".TileService"
+            android:label="FlClash Debug"
+            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,45 +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.FOREGROUND_SERVICE_SPECIAL_USE"
-        tools:ignore="SystemPermissionTypo" />
-    <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.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS" />
     <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" />
@@ -64,10 +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,18 +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:foregroundServiceType="specialUse"
-            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>
@@ -100,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="specialUse"
-            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="specialUse">
-            <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,27 @@
+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")
+                State.handleStopServiceAction()
+            }
+        }
+    }
+}

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

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

android/app/src/main/kotlin/com/follow/clash/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,110 +0,0 @@
-package com.follow.clash
-
-import android.content.Context
-import androidx.lifecycle.MutableLiveData
-import com.follow.clash.plugins.AppPlugin
-import com.follow.clash.plugins.ServicePlugin
-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,22 +1,41 @@
 package com.follow.clash
 
+import android.os.Bundle
+import androidx.lifecycle.lifecycleScope
+import com.follow.clash.common.GlobalState
 import com.follow.clash.plugins.AppPlugin
 import com.follow.clash.plugins.ServicePlugin
 import com.follow.clash.plugins.TilePlugin
 import io.flutter.embedding.android.FlutterActivity
 import io.flutter.embedding.engine.FlutterEngine
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+
+class MainActivity : FlutterActivity(),
+    CoroutineScope by CoroutineScope(SupervisorJob() + Dispatchers.Default) {
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        lifecycleScope.launch {
+            State.destroyServiceEngine()
+        }
+    }
 
-class MainActivity : FlutterActivity() {
     override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
         super.configureFlutterEngine(flutterEngine)
         flutterEngine.plugins.add(AppPlugin())
-        flutterEngine.plugins.add(ServicePlugin)
+        flutterEngine.plugins.add(ServicePlugin())
         flutterEngine.plugins.add(TilePlugin())
-        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,143 @@
+package com.follow.clash
+
+import com.follow.clash.common.ServiceDelegate
+import com.follow.clash.common.formatString
+import com.follow.clash.common.intent
+import com.follow.clash.service.ICallbackInterface
+import com.follow.clash.service.IEventInterface
+import com.follow.clash.service.IRemoteInterface
+import com.follow.clash.service.IResultInterface
+import com.follow.clash.service.RemoteService
+import com.follow.clash.service.models.NotificationParams
+import com.follow.clash.service.models.VpnOptions
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+
+object Service {
+    private val delegate by lazy {
+        ServiceDelegate<IRemoteInterface>(
+            RemoteService::class.intent, ::handleServiceDisconnected
+        ) {
+            IRemoteInterface.Stub.asInterface(it)
+        }
+    }
+
+    var onServiceDisconnected: ((String) -> Unit)? = null
+
+    private fun handleServiceDisconnected(message: String) {
+        onServiceDisconnected?.let {
+            it(message)
+        }
+    }
+
+    fun bind() {
+        delegate.bind()
+    }
+
+    fun unbind() {
+        delegate.unbind()
+    }
+
+    suspend fun invokeAction(data: String, cb: (result: String) -> Unit): Result<Unit> {
+        val res = mutableListOf<ByteArray>()
+        return delegate.useService {
+            it.invokeAction(
+                data, object : ICallbackInterface.Stub() {
+                    override fun onResult(result: ByteArray?, isSuccess: Boolean) {
+                        res.add(result ?: byteArrayOf())
+                        if (isSuccess) {
+                            cb(res.formatString())
+                        }
+                    }
+                })
+        }
+    }
+
+    suspend fun setEventListener(
+        cb: ((result: String?) -> Unit)?
+    ): Result<Unit> {
+        val results = HashMap<String, MutableList<ByteArray>>()
+        return delegate.useService {
+            it.setEventListener(
+                when (cb != null) {
+                    true -> object : IEventInterface.Stub() {
+                        override fun onEvent(
+                            id: String, data: ByteArray?, isSuccess: Boolean
+                        ) {
+                            if (results[id] == null) {
+                                results[id] = mutableListOf()
+                            }
+                            results[id]?.add(data ?: byteArrayOf())
+                            if (isSuccess) {
+                                cb(results[id]?.formatString())
+                                results.remove(id)
+                            }
+                        }
+                    }
+
+                    false -> null
+                }
+            )
+        }
+    }
+
+    suspend fun updateNotificationParams(
+        params: NotificationParams
+    ): Result<Unit> {
+        return delegate.useService {
+            it.updateNotificationParams(params)
+        }
+    }
+
+    suspend fun setCrashlytics(
+        enable: Boolean
+    ): Result<Unit> {
+        return delegate.useService {
+            it.setCrashlytics(enable)
+        }
+    }
+
+    private suspend fun awaitIResultInterface(
+        block: (IResultInterface) -> Unit
+    ): Long = suspendCancellableCoroutine { continuation ->
+        val callback = object : IResultInterface.Stub() {
+            override fun onResult(time: Long) {
+                if (continuation.isActive) {
+                    continuation.resume(time)
+                }
+            }
+        }
+
+        try {
+            block(callback)
+        } catch (e: Exception) {
+            if (continuation.isActive) {
+                continuation.resumeWithException(e)
+            }
+        }
+    }
+
+
+    suspend fun startService(options: VpnOptions, runTime: Long): Long {
+        return delegate.useService {
+            awaitIResultInterface { callback ->
+                it.startService(options, runTime, callback)
+            }
+        }.getOrNull() ?: 0L
+    }
+
+    suspend fun stopService(): Long {
+        return delegate.useService {
+            awaitIResultInterface { callback ->
+                it.stopService(callback)
+            }
+        }.getOrNull() ?: 0L
+    }
+
+    suspend fun getRunTime(): Long {
+        return delegate.useService {
+            it.runTime
+        }.getOrNull() ?: 0L
+    }
+}

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

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

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

@@ -2,24 +2,34 @@ 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 -> {
+                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,62 @@
+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,9 @@
+package com.follow.clash.models
+
+
+data class AppState(
+    val crashlytics: Boolean = true,
+    val currentProfileName: String = "FlClash",
+    val stopText: String = "Stop",
+    val onlyStatisticsProxy: Boolean = false,
+)

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

@@ -13,17 +13,16 @@ 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.google.gson.Gson
 import io.flutter.embedding.android.FlutterActivity
@@ -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?) {
+        Toast.makeText(GlobalState.application, message, Toast.LENGTH_LONG).show()
+    }
+
+    @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,35 +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)?.filter {
-            it.packageName != FlClashApplication.getAppContext().packageName
-                    || it.requestedPermissions?.contains(Manifest.permission.INTERNET) == true
-                    || 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) }
+        packageManager?.getInstalledPackages(PackageManager.GET_META_DATA or PackageManager.GET_PERMISSIONS)
+            ?.filter {
+                it.packageName != GlobalState.application.packageName && it.packageName != "android"
+            }?.map {
+                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
     }
 
@@ -321,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)) {
@@ -375,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(
@@ -391,31 +330,33 @@ class AppPlugin : FlutterPlugin, MethodChannel.MethodCallHandler, ActivityAware
             }.forEach {
                 if (it.name.matches(chinaAppRegex)) return true
             }
-            ZipFile(File(packageInfo.applicationInfo.publicSourceDir)).use {
-                for (packageEntry in it.entries()) {
-                    if (packageEntry.name.startsWith("firebase-")) return false
-                }
-                for (packageEntry in it.entries()) {
-                    if (!(packageEntry.name.startsWith("classes") && packageEntry.name.endsWith(
-                            ".dex"
-                        ))
-                    ) {
-                        continue
+            packageInfo.applicationInfo?.publicSourceDir?.let {
+                ZipFile(File(it)).use {
+                    for (packageEntry in it.entries()) {
+                        if (packageEntry.name.startsWith("firebase-")) return false
                     }
-                    if (packageEntry.size > 15000000) {
-                        return true
-                    }
-                    val input = it.getInputStream(packageEntry).buffered()
-                    val dexFile = try {
-                        DexBackedDexFile.fromInputStream(null, input)
-                    } catch (e: Exception) {
-                        return false
-                    }
-                    for (clazz in dexFile.classes) {
-                        val clazzName =
-                            clazz.type.substring(1, clazz.type.length - 1).replace("/", ".")
-                                .replace("$", ".")
-                        if (clazzName.matches(chinaAppRegex)) return true
+                    for (packageEntry in it.entries()) {
+                        if (!(packageEntry.name.startsWith("classes") && packageEntry.name.endsWith(
+                                ".dex"
+                            ))
+                        ) {
+                            continue
+                        }
+                        if (packageEntry.size > 15000000) {
+                            return true
+                        }
+                        val input = it.getInputStream(packageEntry).buffered()
+                        val dexFile = try {
+                            DexBackedDexFile.fromInputStream(null, input)
+                        } catch (e: Exception) {
+                            return false
+                        }
+                        for (clazz in dexFile.classes) {
+                            val clazzName =
+                                clazz.type.substring(1, clazz.type.length - 1).replace("/", ".")
+                                    .replace("$", ".")
+                            if (clazzName.matches(chinaAppRegex)) return true
+                        }
                     }
                 }
             }
@@ -425,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)
@@ -447,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,20 +1,34 @@
 package com.follow.clash.plugins
 
-import com.follow.clash.FlClashApplication
-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.awaitResult
+import com.follow.clash.common.Components
+import com.follow.clash.common.GlobalState
+import com.follow.clash.invokeMethodOnMainThread
+import com.follow.clash.models.AppState
+import com.follow.clash.service.models.NotificationParams
+import com.follow.clash.service.models.VpnOptions
 import com.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)
     }
 
@@ -23,28 +37,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(call, 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 -> {
@@ -52,8 +70,91 @@ data object ServicePlugin : FlutterPlugin, MethodChannel.MethodCallHandler {
         }
     }
 
-    private fun handleDestroy() {
-        GlobalState.getCurrentVPNPlugin()?.handleStop()
-        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)
+    }
+
+    suspend fun handleGetVpnOptions(): VpnOptions? {
+        val res = flutterMethodChannel.awaitResult<String>("getVpnOptions", null)
+        return Gson().fromJson(res, VpnOptions::class.java)
+    }
+
+    val semaphore = Semaphore(10)
+
+    fun handleSendEvent(value: String?) {
+        launch(Dispatchers.Main) {
+            semaphore.withPermit {
+                flutterMethodChannel.invokeMethod("event", value)
+            }
+        }
+    }
+
+    private fun onServiceDisconnected(message: String) {
+        State.runStateFlow.tryEmit(RunState.STOP)
+        flutterMethodChannel.invokeMethodOnMainThread<Any>("crash", message)
+    }
+
+    private fun handleSyncState(call: MethodCall, result: MethodChannel.Result) {
+        val data = call.arguments<String>()!!
+        val params = Gson().fromJson(data, AppState::class.java)
+        GlobalState.setCrashlytics(params.crashlytics)
+        launch {
+            Service.updateNotificationParams(
+                NotificationParams(
+                    title = params.currentProfileName,
+                    stopText = params.stopText,
+                    onlyStatisticsProxy = params.onlyStatisticsProxy
+                )
+            )
+            Service.setCrashlytics(params.crashlytics)
+            result.success("")
+        }
+    }
+
+    fun handleInit(call: MethodCall, result: MethodChannel.Result) {
+        Service.bind()
+        launch {
+            val needSetEventListener = call.arguments<Boolean>() ?: false
+            when (needSetEventListener) {
+                true -> Service.setEventListener {
+                    handleSendEvent(it)
+                }
+
+                false -> Service.setEventListener(null)
+            }.onSuccess {
+                result.success("")
+            }.onFailure {
+                result.success(it.message)
+            }
+
+        }
+        Service.onServiceDisconnected = ::onServiceDisconnected
+    }
+
+    private fun handleGetRunTime(result: MethodChannel.Result) {
+        launch {
+            State.handleSyncState()
+            result.success(State.runTime)
+        }
     }
 }

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,285 +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 android.util.Log
-import androidx.core.content.getSystemService
-import com.follow.clash.FlClashApplication
-import com.follow.clash.GlobalState
-import com.follow.clash.RunState
-import com.follow.clash.extensions.awaitResult
-import com.follow.clash.extensions.getProtocol
-import com.follow.clash.extensions.resolveDns
-import com.follow.clash.models.Process
-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 lateinit var options: VpnOptions
-    private lateinit var scope: CoroutineScope
-    private var lastStartForegroundParams: StartForegroundParams? = null
-    private var timerJob: Job? = null
-
-    private val connectivity by lazy {
-        FlClashApplication.getAppContext().getSystemService<ConnectivityManager>()
-    }
-
-    private val connection = object : ServiceConnection {
-        override fun onServiceConnected(className: ComponentName, service: IBinder) {
-            flClashService = when (service) {
-                is FlClashVpnService.LocalBinder -> service.getService()
-                is FlClashService.LocalBinder -> service.getService()
-                else -> throw Exception("invalid binder")
-            }
-            handleStartService()
-        }
-
-        override fun onServiceDisconnected(arg: ComponentName) {
-            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)
-            }
-
-            "setProtect" -> {
-                val fd = call.argument<Int>("fd")
-                if (fd != null && flClashService is FlClashVpnService) {
-                    try {
-                        (flClashService as FlClashVpnService).protect(fd)
-                        result.success(true)
-                    } catch (e: RuntimeException) {
-                        result.success(false)
-                    }
-                } else {
-                    result.success(false)
-                }
-            }
-
-            "resolverProcess" -> {
-                val data = call.argument<String>("data")
-                val process = if (data != null) Gson().fromJson(
-                    data, Process::class.java
-                ) else null
-                val metadata = process?.metadata
-                if (metadata == null) {
-                    result.success(null)
-                    return
-                }
-                val protocol = metadata.getProtocol()
-                if (protocol == null) {
-                    result.success(null)
-                    return
-                }
-                scope.launch {
-                    withContext(Dispatchers.Default) {
-                        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
-                            result.success(null)
-                            return@withContext
-                        }
-                        val src = InetSocketAddress(metadata.sourceIP, metadata.sourcePort)
-                        val dst = InetSocketAddress(
-                            metadata.destinationIP.ifEmpty { metadata.host },
-                            metadata.destinationPort
-                        )
-                        val uid = try {
-                            connectivity?.getConnectionOwnerUid(protocol, src, dst)
-                        } catch (_: Exception) {
-                            null
-                        }
-                        if (uid == null || uid == -1) {
-                            result.success(null)
-                            return@withContext
-                        }
-                        val packages =
-                            FlClashApplication.getAppContext().packageManager?.getPackagesForUid(uid)
-                        result.success(packages?.first())
-                    }
-                }
-            }
-
-            else -> {
-                result.notImplemented()
-            }
-        }
-    }
-
-    fun handleStart(options: VpnOptions): Boolean {
-        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() {
-        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)
-            flutterMethodChannel.invokeMethod(
-                "started", fd
-            )
-            startForegroundJob();
-        }
-    }
-
-    fun handleStop() {
-        GlobalState.runLock.withLock {
-            if (GlobalState.runState.value == RunState.STOP) return
-            GlobalState.runState.value = RunState.STOP
-            stopForegroundJob()
-            flClashService?.stop()
-            GlobalState.handleTryDestroy()
-        }
-    }
-
-    private fun bindService() {
-        val intent = when (options.enable) {
-            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,124 +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_SPECIAL_USE
-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", "WrongConstant")
-    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) {
-            startForeground(notificationId, notification, FOREGROUND_SERVICE_TYPE_SPECIAL_USE)
-        } 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,228 +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_SPECIAL_USE
-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()) {
-                    routeAddress.forEach { i ->
-                        Log.d("addRoute4", "address: ${i.address} prefixLength:${i.prefixLength}")
-                        addRoute(i.address, i.prefixLength)
-                    }
-                } 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()) {
-                    routeAddress.forEach { i ->
-                        Log.d("addRoute6", "address: ${i.address} prefixLength:${i.prefixLength}")
-                        addRoute(i.address, i.prefixLength)
-                    }
-                } 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", "WrongConstant")
-    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) {
-            startForeground(notificationId, notification, FOREGROUND_SERVICE_TYPE_SPECIAL_USE)
-        } 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/build.gradle

@@ -1,32 +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')
-}
-
-tasks.register("clean", Delete) {
-    delete rootProject.buildDir
-}
-

android/build.gradle.kts

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

android/common/.gitignore

@@ -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,251 @@
+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,75 @@
+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.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 {
+                    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/.gitignore

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

android/core/build.gradle.kts

@@ -0,0 +1,81 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
+plugins {
+    id("com.android.library")
+    id("org.jetbrains.kotlin.android")
+}
+
+android {
+    namespace = "com.follow.clash.core"
+    compileSdk = libs.versions.compileSdk.get().toInt()
+    ndkVersion = libs.versions.ndkVersion.get()
+
+    defaultConfig {
+        minSdk = libs.versions.minSdk.get().toInt()
+    }
+
+
+    sourceSets {
+        getByName("main") {
+            jniLibs.srcDirs("src/main/jniLibs")
+        }
+    }
+
+    externalNativeBuild {
+        cmake {
+            path("src/main/cpp/CMakeLists.txt")
+            version = "3.22.1"
+        }
+    }
+
+    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(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)
+    }
+}

android/core/src/main/AndroidManifest.xml

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

@@ -0,0 +1,51 @@
+cmake_minimum_required(VERSION 3.22.1)
+
+project("core")
+
+message("CMAKE_SOURCE_DIR ${CMAKE_SOURCE_DIR}")
+
+message("CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE}")
+
+
+if (NOT "${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
+    #    set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type" FORCE)
+    add_compile_options(-O3)
+
+    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
+    )
+
+    add_compile_options(-fvisibility=hidden -fvisibility-inlines-hidden)
+endif ()
+
+set(LIB_CLASH_PATH "${CMAKE_SOURCE_DIR}/../jniLibs/${ANDROID_ABI}/libclash.so")
+
+message("LIB_CLASH_PATH ${LIB_CLASH_PATH}")
+if (EXISTS ${LIB_CLASH_PATH})
+    message("Found libclash.so for ABI ${ANDROID_ABI}")
+    add_compile_definitions(LIBCLASH)
+    include_directories(${CMAKE_SOURCE_DIR}/../cpp/includes/${ANDROID_ABI})
+    link_directories(${CMAKE_SOURCE_DIR}/../jniLibs/${ANDROID_ABI})
+    add_library(${CMAKE_PROJECT_NAME} SHARED
+            jni_helper.cpp
+            core.cpp)
+    target_link_libraries(${CMAKE_PROJECT_NAME}
+            clash)
+else ()
+    message("Not found libclash.so for ABI ${ANDROID_ABI}")
+    add_library(${CMAKE_PROJECT_NAME} SHARED
+            jni_helper.cpp
+            core.cpp)
+    target_link_libraries(${CMAKE_PROJECT_NAME})
+endif ()

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

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

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

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

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

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <jni.h>
+
+struct scoped_jni {
+    JNIEnv *env;
+    int require_release;
+};
+
+extern void initialize_jni(JavaVM *vm, JNIEnv *env);
+
+extern jstring jni_new_string(JNIEnv *env, const char *str);
+
+extern char *jni_get_string(JNIEnv *env, jstring str);
+
+extern int jni_catch_exception(JNIEnv *env);
+
+extern void jni_attach_thread(scoped_jni *jni);
+
+extern void jni_detach_thread(const scoped_jni *env);
+
+extern void release_string( char **str);
+
+#define ATTACH_JNI() __attribute__((unused, cleanup(jni_detach_thread))) \
+                    scoped_jni _jni{}; \
+                    jni_attach_thread(&_jni); \
+                    JNIEnv *env = _jni.env
+
+#define scoped_string __attribute__((cleanup(release_string))) char*
+
+#define find_class(name) env->FindClass(name)
+#define find_method(cls, name, signature) env->GetMethodID(cls, name, signature)
+#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)

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

@@ -0,0 +1,114 @@
+package com.follow.clash.core
+
+import java.net.InetAddress
+import java.net.InetSocketAddress
+import java.net.URL
+
+data object Core {
+    private external fun startTun(
+        fd: Int,
+        cb: TunInterface,
+        stack: String,
+        address: String,
+        dns: String,
+    )
+
+    external fun forceGC(
+    )
+
+    external fun updateDNS(
+        dns: String,
+    )
+
+    private fun parseInetSocketAddress(address: String): InetSocketAddress {
+        val url = URL("https://$address")
+
+        return InetSocketAddress(InetAddress.getByName(url.host), url.port)
+    }
+
+    fun startTun(
+        fd: Int,
+        protect: (Int) -> Boolean,
+        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)
+                }
+
+                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)
+        }
+    }
+
+    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/core/src/main/java/com/follow/clash/core/TunInterface.kt

@@ -0,0 +1,9 @@
+package com.follow.clash.core
+
+import androidx.annotation.Keep
+
+@Keep
+interface TunInterface {
+    fun protect(fd: Int)
+    fun resolverProcess(protocol: Int, source: String, target: String, uid: Int): 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.2.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.2-bin.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="service" />
+        </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/ICallbackInterface.aidl

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

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

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

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

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

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

@@ -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/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,60 @@
+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() {
+        loader.load()
+    }
+
+    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,140 @@
+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.sync.withLock
+import java.util.UUID
+
+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) {
+                runCatching {
+                    val chunks = it?.chunkedForAidl() ?: listOf()
+                    val totalSize = chunks.size
+                    chunks.forEachIndexed { index, chunk ->
+                        callback.onResult(chunk, totalSize - 1 == index)
+                    }
+                }
+            }
+        }
+
+        override fun updateNotificationParams(params: NotificationParams?) {
+            State.notificationParamsFlow.tryEmit(params)
+        }
+
+        override fun startService(
+            options: VpnOptions,
+            runtime: Long,
+            result: IResultInterface,
+        ) {
+            State.options = options
+            handleStartService(runtime, result)
+        }
+
+        override fun stopService(result: IResultInterface) {
+            handleStopService(result)
+        }
+
+        override fun setEventListener(eventListener: IEventInterface?) {
+            GlobalState.log("RemoveEventListener ${eventListener == null}")
+            when (eventListener != null) {
+                true -> Core.callSetEventListener {
+                    runCatching {
+                        val id = UUID.randomUUID().toString()
+                        val chunks = it?.chunkedForAidl() ?: listOf()
+                        val totalSize = chunks.size
+                        chunks.forEachIndexed { index, chunk ->
+                            eventListener.onEvent(id, chunk, totalSize - 1 == index)
+                        }
+                    }
+                }
+
+                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,256 @@
+package com.follow.clash.service
+
+import android.content.Intent
+import android.net.ConnectivityManager
+import android.net.ProxyInfo
+import android.os.Binder
+import android.os.Build
+import android.os.IBinder
+import android.os.Parcel
+import android.os.RemoteException
+import android.util.Log
+import androidx.core.content.getSystemService
+import com.follow.clash.common.AccessControlMode
+import com.follow.clash.common.GlobalState
+import com.follow.clash.core.Core
+import com.follow.clash.service.models.VpnOptions
+import com.follow.clash.service.models.getIpv4RouteAddress
+import com.follow.clash.service.models.getIpv6RouteAddress
+import com.follow.clash.service.models.toCIDR
+import com.follow.clash.service.modules.NetworkObserveModule
+import com.follow.clash.service.modules.NotificationModule
+import com.follow.clash.service.modules.SuspendModule
+import com.follow.clash.service.modules.moduleLoader
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import java.net.InetSocketAddress
+import android.net.VpnService as SystemVpnService
+
+class VpnService : SystemVpnService(), IBaseService,
+    CoroutineScope by CoroutineScope(Dispatchers.Default) {
+
+    private val self: VpnService
+        get() = this
+
+    private val loader = moduleLoader {
+        install(NetworkObserveModule(self))
+        install(NotificationModule(self))
+        install(SuspendModule(self))
+    }
+
+    override fun onCreate() {
+        super.onCreate()
+        handleCreate()
+    }
+
+    override fun onDestroy() {
+        handleDestroy()
+        super.onDestroy()
+    }
+
+    private val connectivity by lazy {
+        getSystemService<ConnectivityManager>()
+    }
+    private val uidPageNameMap = mutableMapOf<Int, String>()
+
+    private fun resolverProcess(
+        protocol: Int,
+        source: InetSocketAddress,
+        target: InetSocketAddress,
+        uid: Int,
+    ): String {
+        val nextUid = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            connectivity?.getConnectionOwnerUid(protocol, source, target) ?: -1
+        } else {
+            uid
+        }
+        if (nextUid == -1) {
+            return ""
+        }
+        if (!uidPageNameMap.containsKey(nextUid)) {
+            uidPageNameMap[nextUid] = this.packageManager?.getPackagesForUid(nextUid)?.first() ?: ""
+        }
+        return uidPageNameMap[nextUid] ?: ""
+    }
+
+    val VpnOptions.address
+        get(): String = buildString {
+            append(IPV4_ADDRESS)
+            if (ipv6) {
+                append(",")
+                append(IPV6_ADDRESS)
+            }
+        }
+
+    val VpnOptions.dns
+        get(): String {
+            if (dnsHijacking) {
+                return NET_ANY
+            }
+            return buildString {
+                append(DNS)
+                if (ipv6) {
+                    append(",")
+                    append(DNS6)
+                }
+            }
+        }
+
+
+    override fun onLowMemory() {
+        Core.forceGC()
+        super.onLowMemory()
+    }
+
+    private val binder = LocalBinder()
+
+    inner class LocalBinder : Binder() {
+        fun getService(): VpnService = this@VpnService
+
+        override fun onTransact(code: Int, data: Parcel, reply: Parcel?, flags: Int): Boolean {
+            try {
+                val isSuccess = super.onTransact(code, data, reply, flags)
+                if (!isSuccess) {
+                    GlobalState.log("VpnService disconnected")
+                    handleDestroy()
+                }
+                return isSuccess
+            } catch (e: RemoteException) {
+                GlobalState.log("VpnService onTransact $e")
+                return false
+            }
+        }
+    }
+
+    override fun onBind(intent: Intent): IBinder {
+        return binder
+    }
+
+    private fun handleStart(options: VpnOptions) {
+        val fd = with(Builder()) {
+            val cidr = IPV4_ADDRESS.toCIDR()
+            addAddress(cidr.address, cidr.prefixLength)
+            Log.d(
+                "addAddress", "address: ${cidr.address} prefixLength:${cidr.prefixLength}"
+            )
+            val routeAddress = options.getIpv4RouteAddress()
+            if (routeAddress.isNotEmpty()) {
+                try {
+                    routeAddress.forEach { i ->
+                        Log.d(
+                            "addRoute4", "address: ${i.address} prefixLength:${i.prefixLength}"
+                        )
+                        addRoute(i.address, i.prefixLength)
+                    }
+                } catch (_: Exception) {
+                    addRoute(NET_ANY, 0)
+                }
+            } else {
+                addRoute(NET_ANY, 0)
+            }
+            if (options.ipv6) {
+                try {
+                    val cidr = IPV6_ADDRESS.toCIDR()
+                    Log.d(
+                        "addAddress6", "address: ${cidr.address} prefixLength:${cidr.prefixLength}"
+                    )
+                    addAddress(cidr.address, cidr.prefixLength)
+                } catch (_: Exception) {
+                    Log.d(
+                        "addAddress6", "IPv6 is not supported."
+                    )
+                }
+
+                try {
+                    val routeAddress = options.getIpv6RouteAddress()
+                    if (routeAddress.isNotEmpty()) {
+                        try {
+                            routeAddress.forEach { i ->
+                                Log.d(
+                                    "addRoute6",
+                                    "address: ${i.address} prefixLength:${i.prefixLength}"
+                                )
+                                addRoute(i.address, i.prefixLength)
+                            }
+                        } catch (_: Exception) {
+                            addRoute("::", 0)
+                        }
+                    } else {
+                        addRoute(NET_ANY6, 0)
+                    }
+                } catch (_: Exception) {
+                    addRoute(NET_ANY6, 0)
+                }
+            }
+            addDnsServer(DNS)
+            if (options.ipv6) {
+                addDnsServer(DNS6)
+            }
+            setMtu(9000)
+            options.accessControl.let { accessControl ->
+                if (accessControl.enable) {
+                    when (accessControl.mode) {
+                        AccessControlMode.ACCEPT_SELECTED -> {
+                            (accessControl.acceptList + packageName).forEach {
+                                addAllowedApplication(it)
+                            }
+                        }
+
+                        AccessControlMode.REJECT_SELECTED -> {
+                            (accessControl.rejectList - packageName).forEach {
+                                addDisallowedApplication(it)
+                            }
+                        }
+                    }
+                }
+            }
+            setSession("FlClash")
+            setBlocking(false)
+            if (Build.VERSION.SDK_INT >= 29) {
+                setMetered(false)
+            }
+            if (options.allowBypass) {
+                allowBypass()
+            }
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q && options.systemProxy) {
+                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() {
+        loader.load()
+        State.options?.let {
+            handleStart(it)
+        }
+    }
+
+    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,23 @@
+package com.follow.clash.service.models
+
+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 (_: Exception) {
+        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 AccessControl(
+    val enable: Boolean,
+    val mode: AccessControlMode,
+    val acceptList: List<String>,
+    val rejectList: List<String>,
+) : Parcelable
+
+@Parcelize
+data class VpnOptions(
+    val enable: Boolean,
+    val port: Int,
+    val ipv6: Boolean,
+    val dnsHijacking: Boolean,
+    val accessControl: AccessControl,
+    val allowBypass: Boolean,
+    val systemProxy: Boolean,
+    val bypassDomain: List<String>,
+    val stack: String,
+    val routeAddress: List<String>,
+) : Parcelable
+
+data class CIDR(val address: InetAddress, val prefixLength: Int)
+
+fun VpnOptions.getIpv4RouteAddress(): List<CIDR> {
+    return routeAddress.filter {
+        it.isIpv4()
+    }.map {
+        it.toCIDR()
+    }
+}
+
+fun VpnOptions.getIpv6RouteAddress(): List<CIDR> {
+    return routeAddress.filter {
+        it.isIpv6()
+    }.map {
+        it.toCIDR()
+    }
+}
+
+fun String.isIpv4(): Boolean {
+    val parts = split("/")
+    if (parts.size != 2) {
+        throw IllegalArgumentException("Invalid CIDR format")
+    }
+    val address = InetAddress.getByName(parts[0])
+    return address.address.size == 4
+}
+
+fun String.isIpv6(): Boolean {
+    val parts = split("/")
+    if (parts.size != 2) {
+        throw IllegalArgumentException("Invalid CIDR format")
+    }
+    val address = InetAddress.getByName(parts[0])
+    return address.address.size == 16
+}
+
+fun String.toCIDR(): CIDR {
+    val parts = split("/")
+    if (parts.size != 2) {
+        throw IllegalArgumentException("Invalid CIDR format")
+    }
+    val ipAddress = parts[0]
+    val prefixLength =
+        parts[1].toIntOrNull() ?: throw IllegalArgumentException("Invalid prefix length")
+
+    val address = InetAddress.getByName(ipAddress)
+
+    val maxPrefix = if (address.address.size == 4) 32 else 128
+    if (prefixLength < 0 || prefixLength > maxPrefix) {
+        throw IllegalArgumentException("Invalid prefix length for IP version")
+    }
+
+    return CIDR(address, prefixLength)
+}

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

@@ -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,124 @@
+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() {
+        State.notificationParamsFlow.value?.let {
+            update(it.extended)
+        }
+        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!!)
+                }
+        }
+    }
+
+    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>

android/service/src/main/res/drawable/ic_service.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="#6666FB"/>
+  <path
+      android:pathData="M78.98,134.37l60.18,-34.74c11.07,-6.39 25.23,-2.59 31.63,8.48h0c6.4,11.07 2.61,25.24 -8.47,31.64l-60.18,34.74c-11.08,6.4 -25.24,2.6 -31.64,-8.48 0,0 0,0 0,0h0c-6.4,-11.08 -2.6,-25.24 8.48,-31.64h0Z"
+      android:fillColor="#336AB6"/>
+  <path
+      android:pathData="M109.86,187.86h0c11.08,-6.4 25.24,-2.6 31.64,8.48 0,0 0,0 0,0h0c6.4,11.08 2.6,25.24 -8.48,31.64 0,0 0,0 0,0h0c-11.08,6.4 -25.24,2.6 -31.64,-8.48 0,0 0,0 0,0h0c-6.4,-11.08 -2.6,-25.24 8.48,-31.64 0,0 0,0 0,0Z"
+      android:fillColor="#5CA8E9"/>
+</vector>

android/settings.gradle

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

android/settings.gradle.kts

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

arb/intl_en.arb

@@ -13,7 +13,6 @@
   "resourcesDesc": "External resource related info",
   "trafficUsage": "Traffic usage",
   "coreInfo": "Core info",
-  "nullCoreInfoDesc": "Unable to obtain core info",
   "networkSpeed": "Network speed",
   "outboundMode": "Outbound mode",
   "networkDetection": "Network detection",
@@ -22,7 +21,6 @@
   "noProxy": "No proxy",
   "noProxyDesc": "Please create a profile or add a valid profile",
   "nullProfileDesc": "No profile, Please add a profile",
-  "nullLogsDesc": "No logs",
   "settings": "Settings",
   "language": "Language",
   "defaultText": "Default",
@@ -123,7 +121,6 @@
   "project": "Project",
   "core": "Core",
   "tabAnimation": "Tab animation",
-  "tabAnimationDesc": "When enabled, the home tab will add a toggle animation",
   "desc": "A multi-platform proxy client based on ClashMeta, simple and easy to use, open-source and ad-free.",
   "startVpn": "Starting VPN...",
   "stopVpn": "Stopping VPN...",
@@ -150,8 +147,6 @@
   "addressHelp": "WebDAV server address",
   "addressTip": "Please enter a valid WebDAV address",
   "password": "Password",
-  "passwordTip": "Password cannot be empty",
-  "accountTip": "Account cannot be empty",
   "checkUpdate": "Check for updates",
   "discoverNewVersion": "Discover the new version",
   "checkUpdateError": "The current application is already the latest version",
@@ -181,14 +176,11 @@
   "requests": "Requests",
   "requestsDesc": "View recently request records",
   "findProcessMode": "Find process",
-  "findProcessModeDesc": "There is a risk of flashback after opening",
   "init": "Init",
   "infiniteTime": "Long term effective",
   "expirationTime": "Expiration time",
   "connections": "Connections",
   "connectionsDesc": "View current connections data",
-  "nullRequestsDesc": "No requests",
-  "nullConnectionsDesc": "No connections",
   "intranetIP": "Intranet IP",
   "view": "View",
   "cut": "Cut",
@@ -221,7 +213,6 @@
   "autoCloseConnectionsDesc": "Auto close connections after change node",
   "onlyStatisticsProxy": "Only statistics proxy",
   "onlyStatisticsProxyDesc": "When turned on, only statistics proxy traffic",
-  "deleteProfileTip": "Sure you want to delete the current profile?",
   "pureBlackMode": "Pure black mode",
   "keepAliveIntervalDesc": "Tcp keep alive interval",
   "entries": " entries",
@@ -249,11 +240,9 @@
   "stop": "Stop",
   "appDesc": "Processing app related settings",
   "vpnDesc": "Modify VPN related settings",
-  "generalDesc": "Overwrite general settings",
   "dnsDesc": "Update DNS related settings",
   "key": "Key",
   "value": "Value",
-  "notEmpty": "Cannot be empty",
   "hostsDesc": "Add Hosts",
   "vpnTip": "Changes take effect after restarting the VPN",
   "vpnEnableDesc": "Auto routes all system traffic through VpnService",
@@ -340,11 +329,108 @@
   "fileIsUpdate": "The file has been modified. Do you want to save the changes?",
   "profileHasUpdate": "The profile has been modified. Do you want to disable auto update?",
   "hasCacheChange": "Do you want to cache the changes?",
-  "nullProxies": "No proxies",
   "copySuccess": "Copy success",
   "copyLink": "Copy link",
   "exportFile": "Export file",
   "cacheCorrupt": "The cache is corrupt. Do you want to clear it?",
   "detectionTip": "Relying on third-party api is for reference only",
-  "listen": "Listen"
+  "listen": "Listen",
+  "undo": "undo",
+  "redo": "redo",
+  "none": "none",
+  "basicConfig": "Basic configuration",
+  "basicConfigDesc": "Modify the basic configuration globally",
+  "selectedCountTitle": "{count} items have been selected",
+  "addRule": "Add rule",
+  "ruleName": "Rule name",
+  "content": "Content",
+  "subRule": "Sub rule",
+  "ruleTarget": "Rule target",
+  "sourceIp": "Source IP",
+  "noResolve": "No resolve IP",
+  "getOriginRules": "Get original rules",
+  "overrideOriginRules": "Override the original rule",
+  "addedOriginRules": "Attach on the original rules",
+  "enableOverride": "Enable override",
+  "saveChanges": "Do you want to save the changes?",
+  "generalDesc": "Modify general settings",
+  "findProcessModeDesc": "There is a certain performance loss after opening",
+  "tabAnimationDesc": "Effective only in mobile view",
+  "saveTip": "Are you sure you want to save?",
+  "colorSchemes": "Color schemes",
+  "palette": "Palette",
+  "tonalSpotScheme": "TonalSpot",
+  "fidelityScheme": "Fidelity",
+  "monochromeScheme": "Monochrome",
+  "neutralScheme": "Neutral",
+  "vibrantScheme": "Vibrant",
+  "expressiveScheme": "Expressive",
+  "contentScheme": "Content",
+  "rainbowScheme": "Rainbow",
+  "fruitSaladScheme": "FruitSalad",
+  "developerMode": "Developer mode",
+  "developerModeEnableTip": "Developer mode is enabled.",
+  "messageTest": "Message test",
+  "messageTestTip": "This is a message.",
+  "crashTest": "Crash test",
+  "clearData": "Clear Data",
+  "textScale": "Text Scaling",
+  "internet": "Internet",
+  "systemApp": "System APP",
+  "noNetworkApp": "No network APP",
+  "contactMe": "Contact me",
+  "recoveryStrategy": "Recovery strategy",
+  "recoveryStrategy_override": "Override",
+  "recoveryStrategy_compatible": "Compatible",
+  "logsTest": "Logs test",
+  "emptyTip": "{label} cannot be empty",
+  "urlTip": "{label} must be a url",
+  "numberTip": "{label} must be a number",
+  "interval": "Interval",
+  "existsTip": "Current {label} already exists",
+  "deleteTip": "Are you sure you want to delete the current {label}?",
+  "deleteMultipTip": "Are you sure you want to delete the selected {label}?",
+  "nullTip": "No {label} at the moment",
+  "script": "Script",
+  "color": "Color",
+  "rename": "Rename",
+  "unnamed": "Unnamed",
+  "pleaseEnterScriptName": "Please enter a script name",
+  "overrideInvalidTip": "Does not take effect in script mode",
+  "mixedPort": "Mixed Port",
+  "socksPort": "Socks Port",
+  "redirPort": "Redir Port",
+  "tproxyPort": "Tproxy Port",
+  "portTip": "{label} must be between 1024 and 49151",
+  "portConflictTip": "Please enter a different port",
+  "import": "Import",
+  "importFile": "Import from file",
+  "importUrl": "Import from URL",
+  "autoSetSystemDns": "Auto set system DNS",
+  "details": "{label} details",
+  "creationTime": "Creation time",
+  "process": "Process",
+  "host": "Host",
+  "destination": "Destination",
+  "destinationGeoIP": "Destination GeoIP",
+  "destinationIPASN": "Destination IPASN",
+  "specialProxy": "Special proxy",
+  "specialRules": "special rules",
+  "remoteDestination": "Remote destination",
+  "networkType": "Network type",
+  "proxyChains": "Proxy chains",
+  "log": "Log",
+  "connection": "Connection",
+  "request": "Request",
+  "connected": "Connected",
+  "disconnected": "Disconnected",
+  "connecting": "Connecting...",
+  "restartCoreTip": "Are you sure you want to restart the core?",
+  "forceRestartCoreTip": "Are you sure you want to force restart the core?",
+  "dnsHijacking": "DNS hijacking",
+  "coreStatus": "Core status",
+  "dataCollectionTip": "Data Collection Notice",
+  "dataCollectionContent": "This app uses Firebase Crashlytics to collect crash information to improve app stability.\nThe collected data includes device information and crash details, but does not contain personal sensitive data.\nYou can disable this feature in settings.",
+  "crashlytics": "Crash Analysis",
+  "crashlyticsTip": "When enabled, automatically uploads crash logs without sensitive information when the app crashes"
 }

arb/intl_ja.arb

@@ -13,7 +13,6 @@
   "resourcesDesc": "外部リソース関連情報",
   "trafficUsage": "トラフィック使用量",
   "coreInfo": "コア情報",
-  "nullCoreInfoDesc": "コア情報を取得できません",
   "networkSpeed": "ネットワーク速度",
   "outboundMode": "アウトバウンドモード",
   "networkDetection": "ネットワーク検出",
@@ -22,7 +21,6 @@
   "noProxy": "プロキシなし",
   "noProxyDesc": "プロファイルを作成するか、有効なプロファイルを追加してください",
   "nullProfileDesc": "プロファイルがありません。追加してください",
-  "nullLogsDesc": "ログがありません",
   "settings": "設定",
   "language": "言語",
   "defaultText": "デフォルト",
@@ -123,7 +121,6 @@
   "project": "プロジェクト",
   "core": "コア",
   "tabAnimation": "タブアニメーション",
-  "tabAnimationDesc": "有効化するとホームタブに切り替えアニメーションを追加",
   "desc": "ClashMetaベースのマルチプラットフォームプロキシクライアント。シンプルで使いやすく、オープンソースで広告なし。",
   "startVpn": "VPNを開始中...",
   "stopVpn": "VPNを停止中...",
@@ -150,8 +147,6 @@
   "addressHelp": "WebDAVサーバーアドレス",
   "addressTip": "有効なWebDAVアドレスを入力",
   "password": "パスワード",
-  "passwordTip": "パスワードは必須です",
-  "accountTip": "アカウントは必須です",
   "checkUpdate": "更新を確認",
   "discoverNewVersion": "新バージョンを発見",
   "checkUpdateError": "アプリは最新版です",
@@ -181,14 +176,11 @@
   "requests": "リクエスト",
   "requestsDesc": "最近のリクエスト記録を表示",
   "findProcessMode": "プロセス検出",
-  "findProcessModeDesc": "有効化するとフラッシュバックのリスクあり",
   "init": "初期化",
   "infiniteTime": "長期有効",
   "expirationTime": "有効期限",
   "connections": "接続",
   "connectionsDesc": "現在の接続データを表示",
-  "nullRequestsDesc": "リクエストなし",
-  "nullConnectionsDesc": "接続なし",
   "intranetIP": "イントラネットIP",
   "view": "表示",
   "cut": "切り取り",
@@ -221,7 +213,6 @@
   "autoCloseConnectionsDesc": "ノード変更後に接続を自動閉じる",
   "onlyStatisticsProxy": "プロキシのみ統計",
   "onlyStatisticsProxyDesc": "有効化するとプロキシトラフィックのみ統計",
-  "deleteProfileTip": "現在のプロファイルを削除しますか？",
   "pureBlackMode": "純黒モード",
   "keepAliveIntervalDesc": "TCPキープアライブ間隔",
   "entries": " エントリ",
@@ -249,11 +240,9 @@
   "stop": "停止",
   "appDesc": "アプリ関連設定の処理",
   "vpnDesc": "VPN関連設定の変更",
-  "generalDesc": "一般設定の上書き",
   "dnsDesc": "DNS関連設定の更新",
   "key": "キー",
   "value": "値",
-  "notEmpty": "空欄不可",
   "hostsDesc": "ホストを追加",
   "vpnTip": "変更はVPN再起動後に有効",
   "vpnEnableDesc": "VpnService経由で全システムトラフィックをルーティング",
@@ -340,11 +329,109 @@
   "fileIsUpdate": "ファイルが変更されました。保存しますか？",
   "profileHasUpdate": "プロファイルが変更されました。自動更新を無効化しますか？",
   "hasCacheChange": "変更をキャッシュしますか？",
-  "nullProxies": "プロキシなし",
   "copySuccess": "コピー成功",
   "copyLink": "リンクをコピー",
   "exportFile": "ファイルをエクスポート",
   "cacheCorrupt": "キャッシュが破損しています。クリアしますか？",
   "detectionTip": "サードパーティAPIに依存（参考値）",
-  "listen": "リスン"
+  "listen": "リスン",
+  "undo": "元に戻す",
+  "redo": "やり直す",
+  "none": "なし",
+  "basicConfig": "基本設定",
+  "basicConfigDesc": "基本設定をグローバルに変更",
+  "selectedCountTitle": "{count} 項目が選択されています",
+  "addRule": "ルールを追加",
+  "ruleName": "ルール名",
+  "content": "内容",
+  "subRule": "サブルール",
+  "ruleTarget": "ルール対象",
+  "sourceIp": "送信元IP",
+  "noResolve": "IPを解決しない",
+  "getOriginRules": "元のルールを取得",
+  "overrideOriginRules": "元のルールを上書き",
+  "addedOriginRules": "元のルールに追加",
+  "enableOverride": "上書きを有効化",
+  "saveChanges": "変更を保存しますか？",
+  "generalDesc": "一般設定を変更",
+  "findProcessModeDesc": "有効化するとパフォーマンスが若干低下します",
+  "tabAnimationDesc": "モバイル表示でのみ有効",
+  "saveTip": "保存してもよろしいですか？",
+  "colorSchemes": "カラースキーム",
+  "palette": "パレット",
+  "tonalSpotScheme": "トーンスポット",
+  "fidelityScheme": "ハイファイデリティー",
+  "monochromeScheme": "モノクローム",
+  "neutralScheme": "ニュートラル",
+  "vibrantScheme": "ビブラント",
+  "expressiveScheme": "エクスプレッシブ",
+  "contentScheme": "コンテンツテーマ",
+  "rainbowScheme": "レインボー",
+  "fruitSaladScheme": "フルーツサラダ",
+  "developerMode": "デベロッパーモード",
+  "developerModeEnableTip": "デベロッパーモードが有効になりました。",
+  "messageTest": "メッセージテスト",
+  "messageTestTip": "これはメッセージです。",
+  "crashTest": "クラッシュテスト",
+  "clearData": "データを消去",
+  "zoom": "ズーム",
+  "textScale": "テキストスケーリング",
+  "internet": "インターネット",
+  "systemApp": "システムアプリ",
+  "noNetworkApp": "ネットワークなしアプリ",
+  "contactMe": "連絡する",
+  "recoveryStrategy": "リカバリー戦略",
+  "recoveryStrategy_override": "オーバーライド",
+  "recoveryStrategy_compatible": "互換性",
+  "logsTest": "ログテスト",
+  "emptyTip": "{label}は空欄にできません",
+  "urlTip": "{label}はURLである必要があります",
+  "numberTip": "{label}は数字でなければなりません",
+  "interval": "インターバル",
+  "existsTip": "現在の{label}は既に存在しています",
+  "deleteTip": "現在の{label}を削除してもよろしいですか？",
+  "deleteMultipTip": "選択された{label}を削除してもよろしいですか？",
+  "nullTip": "現在{label}はありません",
+  "script": "スクリプト",
+  "color": "カラー",
+  "rename": "リネーム",
+  "unnamed": "無題",
+  "pleaseEnterScriptName": "スクリプト名を入力してください",
+  "overrideInvalidTip": "スクリプトモードでは有効になりません",
+  "mixedPort": "混合ポート",
+  "socksPort": "Socksポート",
+  "redirPort": "Redirポート",
+  "tproxyPort": "Tproxyポート",
+  "portTip": "{label} は 1024 から 49151 の間でなければなりません",
+  "portConflictTip": "別のポートを入力してください",
+  "import": "インポート",
+  "importFile": "ファイルからインポート",
+  "importUrl": "URLからインポート",
+  "autoSetSystemDns": "オートセットシステムDNS",
+  "details": "{label}詳細",
+  "creationTime": "作成時間",
+  "process": "プロセス",
+  "host": "ホスト",
+  "destination": "宛先",
+  "destinationGeoIP": "宛先地理情報",
+  "destinationIPASN": "宛先IP ASN",
+  "specialProxy": "特殊プロキシ",
+  "specialRules": "特殊ルール",
+  "remoteDestination": "リモート宛先",
+  "networkType": "ネットワーク種別",
+  "proxyChains": "プロキシチェーン",
+  "log": "ログ",
+  "connection": "接続",
+  "request": "リクエスト",
+  "connected": "接続済み",
+  "disconnected": "切断済み",
+  "connecting": "接続中...",
+  "restartCoreTip": "コアを再起動してもよろしいですか？",
+  "forceRestartCoreTip": "コアを強制再起動してもよろしいですか？",
+  "dnsHijacking": "DNSハイジャッキング",
+  "coreStatus": "コアステータス",
+  "dataCollectionTip": "データ収集説明",
+  "dataCollectionContent": "本アプリはFirebase Crashlyticsを使用してクラッシュ情報を収集し、アプリの安定性を向上させます。\n収集されるデータにはデバイス情報とクラッシュ詳細が含まれますが、個人の機密データは含まれません。\n設定でこの機能を無効にすることができます。",
+  "crashlytics": "クラッシュ分析",
+  "crashlyticsTip": "有効にすると、アプリがクラッシュした際に機密情報を含まないクラッシュログを自動的にアップロードします"
 }