Add custom overwrite

Optimize windows ipc

Optimize windows arm64

Optimize some details

Update core

.claude/commands/i18n.md

@@ -0,0 +1,93 @@
+Scan `lib/` for hardcoded Chinese strings and internationalize them following the project's ARB conventions.
+
+## Instructions
+
+You are performing i18n extraction for a Flutter project that uses the Flutter Intl plugin with ARB files.
+
+### Project localization context
+
+- **ARB files**: `arb/intl_en.arb`, `arb/intl_zh_CN.arb`, `arb/intl_ja.arb`, `arb/intl_ru.arb`
+- **Key conventions**: camelCase, flat keys (no nesting, no `@` metadata), semantic naming
+  - Short labels: `rule`, `global`, `direct`, `edit`, `confirm`
+  - Descriptive suffix `Desc`: `themeDesc`, `tunDesc`, `logsDesc`
+  - Validation suffix: `profileNameNullValidationDesc`
+- **Generated code**: `lib/l10n/l10n.dart` (DO NOT edit generated files)
+- **Access patterns**:
+  - In widgets with BuildContext: `context.appLocalizations.key` (import `common.dart`)
+  - In controllers/providers/non-widget code: `currentAppLocalizations.key` (import `app_localizations.dart`)
+
+### Step 1: Find hardcoded Chinese strings
+
+Use Grep to search `lib/` for Chinese characters. The regex pattern for Chinese characters is `[\x{4e00}-\x{9fff}]`.
+
+Important filters:
+- **Exclude** `lib/l10n/` (generated localization files)
+- **Exclude** lines that already use `appLocalizations` or `currentAppLocalizations`
+- **Exclude** false positives that are NOT Chinese text:
+  - Arrow symbols: `↑` `↓` `←` `→` (Unicode arrows, not CJK)
+  - Middle dot: `·` (U+00B7, not CJK)
+  - Command symbol: `⌘` (U+2318, not CJK)
+  - Other CJK punctuation that is used as UI symbols, not translatable text
+
+For each match, read the surrounding context (5-10 lines) to understand:
+- What the string represents (label, error message, tooltip, dialog text, etc.)
+- Whether it's inside a widget (has `BuildContext` available) or non-widget code
+- Whether it appears in a `Text()`, `TextSpan()`, `title:`, `label:`, or other text position
+
+### Step 2: Generate ARB keys
+
+For each hardcoded Chinese string:
+
+1. **Choose a key name** following project conventions:
+   - Use the Chinese meaning to derive an English camelCase key
+   - Keep it concise: `createConfig` not `createAConfigurationForTheProfile`
+   - Use `Desc` suffix for descriptive/explanatory text
+   - Use existing similar keys as reference (check `arb/intl_en.arb` for patterns)
+
+2. **Determine the English translation** (the value for `intl_en.arb`)
+
+3. **Determine the Chinese translation** (the value for `intl_zh_CN.arb`) — this is the original hardcoded string
+
+4. **For ja and ru**: use the English translation as a placeholder (translators will fill these in later)
+
+### Step 3: Update ARB files
+
+For each new key, add it to all 4 ARB files. Read each ARB file first to find the right insertion point (alphabetical order is not required, but appending near the end is clean).
+
+Format: add a new line like `"keyName": "value",` before the closing `}`.
+
+### Step 4: Replace hardcoded strings in Dart files
+
+Replace each hardcoded Chinese string with the appropriate localization call:
+
+- If inside a widget BuildContext: `context.appLocalizations.keyName`
+- If in controller/provider code: `currentAppLocalizations.keyName`
+
+Ensure the correct import exists:
+- For `context.appLocalizations`: the file should import `common.dart` (check if it already does)
+- For `currentAppLocalizations`: the file should import `app_localizations.dart` (check if it already does)
+
+If the file uses string interpolation (e.g., `'创建 $name 配置'`), convert to the ARB parameterized format:
+- In ARB: `"keyName": "Create $name config"`
+- In Dart: `currentAppLocalizations.keyName(name)`
+
+### Step 5: Report changes
+
+After all modifications, output a summary:
+1. List each file modified and what changed
+2. List each new ARB key added with its translations
+3. Remind the user to run code generation if needed:
+   ```
+   dart run build_runner build --delete-conflicting-outputs
+   ```
+   or trigger Flutter Intl regeneration in their IDE.
+
+### Important notes
+
+- Only extract strings that are user-facing UI text. Do NOT extract:
+  - Comments (lines starting with `//`)
+  - Log messages (unless they appear in the UI)
+  - Variable names or identifiers
+  - String literals used as keys/identifiers (not displayed to users)
+- If a Chinese string is split across multiple lines or concatenations, merge them into a single ARB entry
+- If a string contains dynamic content (variables, URLs), use ARB parameter syntax `$variableName`

.github/workflows/build.yaml

@@ -8,7 +8,33 @@ env:
   IS_STABLE: ${{ !contains(github.ref, '-') }}
 
 jobs:
+  test:
+    name: Test
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Setup Flutter
+        uses: subosito/flutter-action@v2
+        with:
+          channel: stable
+          flutter-version: 3.41.9
+          cache: true
+
+      - name: Install dependencies
+        run: flutter pub get
+
+      - name: Analyze
+        run: flutter analyze --no-fatal-infos
+
+      - name: Run tests
+        run: flutter test --reporter expanded
+
   build:
+    needs: [ test ]
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
@@ -16,13 +42,13 @@ jobs:
           - platform: android
             os: ubuntu-latest
           - platform: windows
-            os: windows-latest
+            os: Windows-2022
             arch: amd64
           - platform: linux
             os: ubuntu-22.04
             arch: amd64
           - platform: macos
-            os: macos-13
+            os: macos-15-intel
             arch: amd64
           - platform: macos
             os: macos-latest
@@ -52,6 +78,7 @@ jobs:
         if: startsWith(matrix.platform,'android')
         run: |
           echo "${{ secrets.KEYSTORE }}" | base64 --decode > android/app/keystore.jks
+          echo "${{ secrets.SERVICE_JSON }}" | base64 --decode > android/app/google-services.json
           echo "keyAlias=${{ secrets.KEY_ALIAS }}" >> android/local.properties
           echo "storePassword=${{ secrets.STORE_PASSWORD }}" >> android/local.properties
           echo "keyPassword=${{ secrets.KEY_PASSWORD }}" >> android/local.properties
@@ -63,22 +90,29 @@ jobs:
           cache-dependency-path: |
             core/go.sum
 
-      - 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: 'master'
-          cache: true
+      - name: Enable git long paths (Windows)
+        if: startsWith(matrix.os, 'windows')
+        run: git config --global core.longpaths 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'
+          channel: stable
+          flutter-version: 3.41.9
+          cache: true
+      - name: Setup Flutter With Other
+        if: startsWith(matrix.os, 'windows-11-arm') || startsWith(matrix.os, 'ubuntu-24.04-arm')
+        uses: subosito/flutter-action@v2
+        with:
+          channel: master
+          flutter-version: 3.44.0-0.1.pre
           cache: true
-      #          flutter-version: 3.29.3
 
       - name: Get Flutter Dependency
-        run: flutter pub get
+        run: |
+          flutter --version
+          flutter pub get
 
       - name: Setup
         run: dart setup.dart ${{ matrix.platform }} ${{ matrix.arch && format('--arch {0}', matrix.arch) }} ${{ env.IS_STABLE == 'true' && '--env stable' || '' }}
@@ -103,34 +137,26 @@ jobs:
       - name: Generate
         if: ${{ env.IS_STABLE == 'true' }}
         run: |
-          tags=($(git tag --merged $(git rev-parse HEAD) --sort=-creatordate))
-          preTag=$(grep -oP '^## \K.*' CHANGELOG.md | head -n 1)
-          currentTag=""
-          for ((i = 0; i <= ${#tags[@]}; i++)); do
-            if (( i < ${#tags[@]} )); then
-              tag=${tags[$i]}
-            else
-              tag=""
-            fi
-            if [ -n "$currentTag" ]; then
-              if [ "$(echo -e "$currentTag\n$preTag" | sort -V | head -n 1)" == "$currentTag" ]; then
-                break
-              fi
-            fi
-            if [ -n "$currentTag" ]; then
-              echo "## $currentTag" >> NEW_CHANGELOG.md
-              echo "" >> NEW_CHANGELOG.md
-              if [ -n "$tag" ]; then
-                git log --pretty=format:"%B" "$tag..$currentTag" | awk 'NF {print "- " $0} !NF {print ""}' >> NEW_CHANGELOG.md
-              else
-                git log --pretty=format:"%B" "$currentTag" | awk 'NF {print "- " $0} !NF {print ""}' >> NEW_CHANGELOG.md
-              fi
-              echo "" >> NEW_CHANGELOG.md
-            fi
-            currentTag=$tag
+          last_ver=$(grep -m1 '^## ' CHANGELOG.md 2>/dev/null | sed 's/^## //')
+          
+          tags=($(git tag --merged HEAD --sort=-creatordate))
+          
+          temp="NEW_CHANGELOG.md" > "$temp"
+          
+          for i in "${!tags[@]}"; do
+              curr="${tags[i]}"
+              [[ "$curr" == "$last_ver" ]] && break
+          
+              prev="${tags[i+1]}"
+              range="${prev:+$prev..}$curr"
+          
+              echo -e "## $curr\n" >> "$temp"
+              git log --no-merges --pretty=format:"%B" "$range" | \
+              awk '!/Update changelog/ && NF {print "- " $0 "\n"}' >> "$temp"
           done
-          cat CHANGELOG.md >> NEW_CHANGELOG.md
-          cat NEW_CHANGELOG.md > CHANGELOG.md
+          [ -f CHANGELOG.md ] && cat CHANGELOG.md >> "$temp"
+          
+          mv "$temp" CHANGELOG.md
 
       - name: Commit
         if: ${{ env.IS_STABLE == 'true' }}
@@ -180,31 +206,24 @@ jobs:
 
       - name: Generate release.md
         run: |
-          tags=($(git tag --merged $(git rev-parse HEAD) --sort=-creatordate))
-          preTag=$(curl --silent "https://api.github.com/repos/chen08209/FlClash/releases/latest" | grep -Po '"tag_name": "\K.*?(?=")' || echo "")
-          currentTag=""
-          for ((i = 0; i <= ${#tags[@]}; i++)); do
-            if (( i < ${#tags[@]} )); then
-              tag=${tags[$i]}
-            else
-              tag=""
-            fi
-            if [ -n "$currentTag" ]; then
-              if [ "$(echo -e "$currentTag\n$preTag" | sort -V | head -n 1)" == "$currentTag" ]; then
-                break
-              fi
-            fi
-            if [ -n "$currentTag" ]; then
-              if [ -n "$tag" ]; then
-                git log --pretty=format:"%B" "$tag..$currentTag" | awk 'NF {print "- " $0} !NF {print ""}' >> release.md
-              else
-                git log --pretty=format:"%B" "$currentTag" | awk 'NF {print "- " $0} !NF {print ""}' >> release.md
-              fi
-              echo "" >> release.md
-            fi
-            currentTag=$tag
+          tags=($(git tag --merged HEAD --sort=-creatordate))
+          preTag=$(curl -s "https://api.github.com/repos/chen08209/FlClash/releases/latest" | \
+          sed -nE 's/.*"tag_name": "([^"]+)".*/\1/p')
+          
+          [ -z "$preTag" ] && preTag=""
+          
+          out="release.md" > "$out"
+          
+          for i in "${!tags[@]}"; do
+            curr="${tags[i]}"
+            [[ "$curr" == "$preTag" ]] && break
+          
+            prev="${tags[i+1]}"
+            range="${prev:+$prev..}$curr"
+          
+            git log --no-merges --pretty=format:"%B" "$range" | \
+            awk '!/Update changelog/ && NF {print "- " $0 "\n"}' >> "$out"
           done
-
       - name: Push to telegram
         env:
           TELEGRAM_BOT_TOKEN: ${{ secrets.TELEGRAM_BOT_TOKEN }}

.gitignore

@@ -21,7 +21,7 @@ migrate_working_dir/
 # The .vscode folder contains launch configuration and tasks you configure in
 # VS Code which you may wish to be included in version control, so this line
 # is commented out by default.
-#.vscode/
+.vscode/
 
 # Flutter/Dart/Pub related
 **/doc/api/
@@ -41,15 +41,29 @@ app.*.symbols
 # Obfuscation related
 app.*.map.json
 
+# Claude Code - ignore user-specific settings only
+.claude/settings.local.json
+
+
 # Android Studio will place build artifacts here
 /android/app/debug
 /android/app/profile
 /android/app/release
+/android/**/.cxx
+/android/**/build
+/android/common/**/.**/
+/android/common/local.*
+/android/core/**/includes/
+/android/core/**/cmake-build-*/
+/android/core/**/jniLibs/
 
-
-
-#libclash
+#FlClash
 /libclash/
-
-#jniLibs
 /android/app/src/main/jniLibs/
+/services/helper/target
+/macos/**/Package.resolved
+devtools_options.yaml
+
+# FVM Version Cache
+.fvm/
+.fvmrc

.gitmodules

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

.metadata

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

.run/main.dart.run.xml

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

CHANGELOG.md

@@ -1,3 +1,83 @@
+## v0.8.92
+
+- Add sqlite store
+
+- Optimize android quick action
+
+- Optimize backup and restore
+
+- Optimize more details
+
+## v0.8.91
+
+- Fix windows some issues
+
+- Optimize overwrite handle
+
+- Optimize access control page
+
+- Optimize some details
+
+## v0.8.90
+
+- Fix android tile service
+
+- Support append system DNS
+
+- Fix some issues
+
+- Update changelog
+
+## v0.8.89
+
+- Fix some issues
+
+- Optimize Windows service mode
+
+- Update core
+
+- Update changelog
+
+## v0.8.88
+
+- Add android separates the core process
+
+- Support core status check and force restart
+
+- Optimize proxies page and access page
+
+- Update flutter and pub dependencies
+
+- Update go version
+
+- Optimize more details
+
+- Update changelog
+
+## v0.8.87
+
+- Optimize desktop view
+
+- Optimize logs, requests, connection pages
+
+- Optimize windows tray auto hide
+
+- Optimize some details
+
+- Update core
+
+- Update changelog
+
+## v0.8.86
+
+- Fix windows tun issues
+
+- Optimize android get system dns
+
+- Optimize more details
+
+- Update changelog
+
 ## v0.8.85
 
 - Support override script

CLAUDE.md

@@ -0,0 +1,182 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+FlClash is a multi-platform proxy client based on ClashMeta (mihomo), built with Flutter. Supports Android, Windows,
+macOS, and Linux. Material You design with Surfboard-like UI.
+
+## Common Development Commands
+
+### Building
+
+```bash
+# Update submodules first (ClashMeta Go core lives in core/Clash.Meta/)
+git submodule update --init --recursive
+
+# Build core + Flutter app via setup.dart
+dart ./setup.dart android --arch arm64
+dart ./setup.dart android --arch arm --arch-name armeabi-v7a
+dart ./setup.dart android --arch amd64 --arch-name x86_64
+dart ./setup.dart macos --arch arm64
+dart ./setup.dart macos --arch amd64
+dart ./setup.dart linux --arch amd64
+dart ./setup.dart windows --arch amd64
+
+# Build only the Go core (skip Flutter packaging)
+dart ./setup.dart android --arch arm64 --out core
+dart ./setup.dart macos --arch arm64 --out core
+```
+
+### Flutter Development
+
+```bash
+flutter pub get
+flutter run        # Run on connected device/desktop
+flutter test        # Run all tests (use flutter test, not dart test — models pull in Flutter types)
+```
+
+### Code Generation
+
+Required after modifying models, providers, or database schema:
+
+```bash
+dart run build_runner build --delete-conflicting-outputs
+dart run build_runner watch  # Continuous regeneration
+```
+
+Code generation covers: Riverpod providers (`riverpod_generator`), models (`freezed`, `json_serializable`), and database
+tables (`drift_dev`).
+
+### Testing
+
+Tests use `package:test/test.dart` for pure Dart logic (common utils, models) and `flutter_test` for provider/widget tests.
+`mocktail` is the mocking framework.
+
+```bash
+flutter test test/models/      # Model serialization & extension round-trip tests
+flutter test test/core/        # CoreController tests (mocked CoreHandlerInterface)
+flutter test test/providers/   # Riverpod provider tests (config & app state notifiers)
+flutter test test/common/      # Utility function tests (utils, string, iterable, fixed, etc.)
+flutter test test/database/    # Database type converter tests
+```
+
+**Mocking `CoreHandlerInterface`:** Use `CoreController.test(mock)` to inject a mock interface. Call
+`CoreController.resetInstance()` in `tearDown` to clean up the singleton between tests. Remember to
+`registerFallbackValue()` for freezed params used with `any()` matchers.
+
+**Provider tests:** Use `ProviderContainer` directly (no widget tree needed for simple notifiers). The Riverpod
+generated `update()` method takes a callback: `notifier.update((state) => newValue)`.
+
+**Model round-trip tests:** Always go through `jsonEncode`/`jsonDecode` when testing freezed models with
+nested objects — `toJson()` stores child objects directly (not as maps), so direct `fromJson(toJson())`
+fails for nested freezed types.
+
+### Build Dependencies
+
+**Linux:** `sudo apt-get install libayatana-appindicator3-dev libkeybinder-3.0-dev`
+
+**Windows:** GCC and Inno Setup. `ANDROID_NDK` env var for Android builds.
+
+**macOS:** `npm install -g appdmg` for DMG creation.
+
+## Architecture
+
+### Core Integration (Go ClashMeta <-> Flutter)
+
+This is the most important architectural concept. The Go proxy core (`core/`) operates in two modes:
+
+- **Android (lib mode):** Go core compiled as C shared library (`libclash.so`) via `go build -buildmode=c-shared` with
+  CGO. Flutter calls it via FFI through the `service` plugin. Dart-side: `lib/core/lib.dart` (`CoreLib` class).
+
+- **Desktop (core mode):** Go core runs as a separate process with `CGO_ENABLED=0`. Flutter communicates via
+  JSON-over-socket (Unix socket on macOS/Linux, TCP on Windows). Dart-side: `lib/core/service.dart` (`CoreService`
+  class).
+
+`lib/core/controller.dart` (`CoreController`) selects the implementation based on platform. `lib/core/interface.dart`
+defines the shared `CoreHandlerInterface`.
+
+Go core key files: `core/hub.go` (handler functions), `core/action.go` (dispatch), `core/lib.go` (CGO exports),
+`core/server.go` (socket server).
+
+### State Management (Riverpod)
+
+Provider files in `lib/providers/`:
+
+- `app.dart` - Runtime/UI state (logs, traffic, delays, loading, navigation)
+- `config.dart` - Persistent config providers (app settings, theme, VPN, proxy style)
+- `state.dart` - Derived/computed providers (navigation, proxy, tray, color scheme)
+- `action.dart` - Business logic notifiers (setup, backup, core lifecycle, proxy selection)
+- `database.dart` - Drift database provider wrappers
+
+`globalState` (`lib/state.dart`) is a singleton holding app lifecycle, timers, theme, and the start/stop state.
+Providers are generated into `lib/providers/generated/`.
+
+### Database (Drift/SQLite)
+
+Type-safe SQLite via Drift in `lib/database/`. Tables: `Profiles`, `Scripts`, `ProxyGroups`, `GlobalRules`,
+`ProfileAddedRules`, `ProfileCustomRules`, `ProfileDisabledRuleIds`, `Icons`, `Links`. Uses fractional indexing for
+ordering.
+
+### Manager Stack (Widget Tree)
+
+Managers are nested InheritedWidgets/StatefulWidgets in `lib/application.dart`:
+
+```
+AppEnvManager > StatusManager > ThemeManager
+  > [Desktop: WindowManager > TrayManager > HotKeyManager > ProxyManager]
+  > ConnectivityManager > CoreManager > AppStateManager
+  > [Mobile: AndroidManager > VpnManager | Desktop: WindowHeaderContainer]
+```
+
+Each manager in `lib/manager/` handles a specific platform concern. Desktop-only managers are conditionally inserted.
+
+### Core Controller + Actions
+
+`lib/core/controller.dart` (`CoreController`) is a singleton facade over `CoreHandlerInterface`. All 25+ public methods
+delegate to the platform-specific interface (Android FFI or desktop socket). Has `@visibleForTesting` constructor and
+`resetInstance()` for test injection.
+
+Business logic lives in Riverpod notifier classes in `lib/providers/action.dart` (~960 lines, should be split):
+
+- `CommonAction` — update check, common UI operations
+- `SetupAction` — config setup, TUN management
+- `BackupAction` — backup/restore with WebDAV sync
+- `CoreAction` — core lifecycle (init, connect, restart, shutdown)
+- `SystemAction` — system integration (tray, exit, brightness)
+- `StoreAction` — profile storage operations
+- `ThemeAction` — theme state updates
+- `ProxiesAction` — group management, proxy selection
+- `ProfilesAction` — profile CRUD, auto-update, import
+
+### Platform Managers (`lib/manager/`)
+
+Desktop: `WindowManager`, `TrayManager`, `HotKeyManager`, `ProxyManager`
+Mobile: `AndroidManager`, `TileManager`, `VpnManager`
+Shared: `ConnectivityManager`, `CoreManager`, `AppStateManager`, `StatusManager`, `ThemeManager`
+
+### Local Plugins (`plugins/`)
+
+- `proxy` - System proxy configuration
+- `rust_api` - Flutter Rust Bridge FFI plugin (named pipe / local socket communication)
+- `tray_manager` - System tray (forked/custom)
+- `wifi_ssid` - Wi-Fi SSID detection
+- `window_ext` - Window extensions
+- `flutter_distributor` - App packaging/distribution
+
+### Rust Helper Service (`services/helper/`)
+
+Windows-only privileged helper for starting the core as admin and managing TUN. Built with
+`cargo build --release --features windows-service`. Token-based auth with Flutter app.
+
+### Localization
+
+ARB files in `arb/`. Generated via `flutter_intl` into `lib/l10n/`. Use `AppLocalizations.of(context)!` for strings.
+
+**Supported locales:** `en`, `zh_CN`, `ja`, `ru`
+
+**Access patterns:**
+
+- In widgets with BuildContext: `context.appLocalizations.key` (import `common.dart`)
+- In controllers/providers/non-widget code: `currentAppLocalizations.key` (import `app_localizations.dart`)

Makefile

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

README.md

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

@@ -54,7 +54,7 @@ on Mobile:
     
     com.follow.clash.action.STOP
     
-    com.follow.clash.action.CHANGE
+    com.follow.clash.action.TOGGLE
    ```
 
 ## Download

analysis_options.yaml

@@ -1 +1,43 @@
 include: package:flutter_lints/flutter.yaml
+analyzer:
+  exclude:
+    - build/**
+    - lib/l10n/intl/**
+    - lib/**/generated/**
+    - plugins/**
+  errors:
+    invalid_annotation_target: ignore
+
+linter:
+  rules:
+    # Style
+    prefer_single_quotes: true
+    require_trailing_commas: true
+    sort_child_properties_last: true
+
+    # Avoid unnecessary code
+    unnecessary_new: true
+    unnecessary_this: true
+    unnecessary_const: true
+    avoid_print: true
+    avoid_unnecessary_containers: true
+    sized_box_for_whitespace: true
+
+    # Prefer best practices
+    prefer_const_constructors: true
+    prefer_const_declarations: true
+    prefer_final_locals: true
+    prefer_final_in_for_each: true
+    prefer_is_empty: true
+    prefer_is_not_empty: true
+    prefer_interpolation_to_compose_strings: true
+
+    # Type safety
+    always_declare_return_types: true
+    annotate_overrides: true
+    use_key_in_widget_constructors: true
+    no_leading_underscores_for_local_identifiers: true
+
+    # Async
+    use_build_context_synchronously: true
+    unnecessary_await_in_return: true

android/app/build.gradle.kts

@@ -1,9 +1,12 @@
+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")
@@ -17,29 +20,26 @@ 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
+val isRelease =
+    mStoreFile.exists() && mStorePassword != null && mKeyAlias != null && mKeyPassword != null
+
 
 android {
     namespace = "com.follow.clash"
-    compileSdk = 35
-    ndkVersion = "28.0.13004108"
+    compileSdk = libs.versions.compileSdk.get().toInt()
+    ndkVersion = libs.versions.ndkVersion.get()
+
+
 
     compileOptions {
         sourceCompatibility = JavaVersion.VERSION_17
         targetCompatibility = JavaVersion.VERSION_17
     }
 
-    kotlinOptions {
-        jvmTarget = JavaVersion.VERSION_17.toString()
-    }
-
     defaultConfig {
         applicationId = "com.follow.clash"
         minSdk = flutter.minSdkVersion
-        targetSdk = flutter.targetSdkVersion
+        targetSdk = libs.versions.targetSdk.get().toInt()
         versionCode = flutter.versionCode
         versionName = flutter.versionName
     }
@@ -55,39 +55,55 @@ android {
         }
     }
 
+    packaging {
+        jniLibs {
+            useLegacyPackaging = true
+        }
+    }
+
     buildTypes {
         debug {
             isMinifyEnabled = false
-            applicationIdSuffix = ".debug"
+            applicationIdSuffix = ".dev"
         }
 
         release {
             isMinifyEnabled = true
-            isDebuggable = false
-
-            signingConfig = if (isRelease) {
-                signingConfigs.getByName("release")
+            isShrinkResources = true
+            if (isRelease) {
+                signingConfig = signingConfigs.getByName("release")
             } else {
-                signingConfigs.getByName("debug")
+                signingConfig = signingConfigs.getByName("debug")
+                applicationIdSuffix = ".dev"
             }
 
             proguardFiles(
-                getDefaultProguardFile("proguard-android-optimize.txt"),
-                "proguard-rules.pro"
+                getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro"
             )
         }
     }
 }
 
+kotlin {
+    compilerOptions {
+        jvmTarget.set(JvmTarget.JVM_17)
+    }
+}
+
 flutter {
     source = "../.."
 }
 
+
 dependencies {
-    implementation(project(":core"))
-    implementation("androidx.core:core-splashscreen:1.0.1")
-    implementation("com.google.code.gson:gson:2.10.1")
-    implementation("com.android.tools.smali:smali-dexlib2:3.0.9") {
+    implementation(project(":service"))
+    implementation(project(":common"))
+    implementation(libs.core.splashscreen)
+    implementation(libs.gson)
+    implementation(libs.smali.dexlib2) {
         exclude(group = "com.google.guava", module = "guava")
     }
+    implementation(platform(libs.firebase.bom))
+    implementation(libs.firebase.crashlytics.ndk)
+    implementation(libs.firebase.analytics)
 }

android/app/google-services.json

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

android/app/proguard-rules.pro

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

android/app/src/debug/AndroidManifest.xml

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

android/app/src/main/AndroidManifest.xml

@@ -1,3 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools">
 
@@ -13,40 +14,38 @@
 
     <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
-    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
     <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
     <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
-    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
-
     <uses-permission
         android:name="android.permission.QUERY_ALL_PACKAGES"
         tools:ignore="QueryAllPackagesPermission" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_SPECIAL_USE" />
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+    <uses-permission android:name="android.permission.POST_PROMOTED_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>
@@ -67,12 +66,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>
@@ -85,17 +81,16 @@
             </intent-filter>
             <intent-filter>
                 <category android:name="android.intent.category.DEFAULT" />
-                <action android:name="${applicationId}.action.CHANGE" />
+                <action android:name="${applicationId}.action.TOGGLE" />
             </intent-filter>
         </activity>
 
         <service
-            android:name=".services.FlClashTileService"
+            android:name=".TileService"
             android:exported="true"
             android:icon="@drawable/ic"
             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>
@@ -104,49 +99,16 @@
                 android:value="true" />
         </service>
 
-        <provider
-            android:name=".FilesProvider"
-            android:authorities="${applicationId}.files"
+        <receiver
+            android:name=".BroadcastReceiver"
+            android:enabled="true"
             android:exported="true"
-            android:grantUriPermissions="true"
-            android:permission="android.permission.MANAGE_DOCUMENTS"
-            android:process=":background">
+            android:permission="${applicationId}.permission.RECEIVE_BROADCASTS">
             <intent-filter>
-                <action android:name="android.content.action.DOCUMENTS_PROVIDER" />
+                <action android:name="${applicationId}.intent.action.SERVICE_CREATED" />
+                <action android:name="${applicationId}.intent.action.SERVICE_DESTROYED" />
             </intent-filter>
-        </provider>
-
-        <provider
-            android:name="androidx.core.content.FileProvider"
-            android:authorities="${applicationId}.fileProvider"
-            android:exported="false"
-            android:grantUriPermissions="true">
-            <meta-data
-                android:name="android.support.FILE_PROVIDER_PATHS"
-                android:resource="@xml/file_paths" />
-        </provider>
-
-        <service
-            android:name=".services.FlClashVpnService"
-            android:exported="false"
-            android:foregroundServiceType="dataSync"
-            android:permission="android.permission.BIND_VPN_SERVICE">
-            <intent-filter>
-                <action android:name="android.net.VpnService" />
-            </intent-filter>
-            <property
-                android:name="android.app.PROPERTY_SPECIAL_USE_FGS_SUBTYPE"
-                android:value="vpn" />
-        </service>
-
-        <service
-            android:name=".services.FlClashService"
-            android:exported="false"
-            android:foregroundServiceType="dataSync">
-            <property
-                android:name="android.app.PROPERTY_SPECIAL_USE_FGS_SUBTYPE"
-                android:value="service" />
-        </service>
+        </receiver>
 
         <meta-data
             android:name="flutterEmbedding"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,200 +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)}]:$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(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()
-}
-
-suspend fun <T> MethodChannel.awaitResult(
-    method: String,
-    arguments: Any? = null
-): T? = withContext(Dispatchers.Main) { // 切换到主线程
-    suspendCoroutine { continuation ->
-        invokeMethod(method, arguments, object : MethodChannel.Result {
-            override fun success(result: Any?) {
-                @Suppress("UNCHECKED_CAST")
-                continuation.resume(result as T)
-            }
-
-            override fun error(code: String, message: String?, details: Any?) {
-                continuation.resume(null)
-            }
-
-            override fun notImplemented() {
-                continuation.resume(null)
-            }
-        })
-    }
-}
-
-fun ReentrantLock.safeLock() {
-    if (this.isLocked) {
-        return
-    }
-    this.lock()
-}
-
-fun ReentrantLock.safeUnlock() {
-    if (!this.isLocked) {
-        return
-    }
-
-    this.unlock()
-}

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

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

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

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

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

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

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

@@ -9,22 +9,23 @@ import android.content.pm.ComponentInfo
 import android.content.pm.PackageManager
 import android.net.VpnService
 import android.os.Build
-import android.widget.Toast
+import android.os.PowerManager
+import android.provider.Settings
 import androidx.core.app.ActivityCompat
 import androidx.core.content.ContextCompat
 import androidx.core.content.ContextCompat.getSystemService
-import androidx.core.content.FileProvider
 import androidx.core.content.pm.ShortcutInfoCompat
 import androidx.core.content.pm.ShortcutManagerCompat
 import androidx.core.graphics.drawable.IconCompat
 import com.android.tools.smali.dexlib2.dexbacked.DexBackedDexFile
-import com.follow.clash.FlClashApplication
-import com.follow.clash.GlobalState
 import com.follow.clash.R
-import com.follow.clash.extensions.awaitResult
-import com.follow.clash.extensions.getActionIntent
-import com.follow.clash.extensions.getBase64
+import com.follow.clash.common.Components
+import com.follow.clash.common.GlobalState
+import com.follow.clash.common.QuickAction
+import com.follow.clash.common.quickIntent
+import com.follow.clash.getPackageIconPath
 import com.follow.clash.models.Package
+import com.follow.clash.showToast
 import com.google.gson.Gson
 import io.flutter.embedding.android.FlutterActivity
 import io.flutter.embedding.engine.plugins.FlutterPlugin
@@ -44,15 +45,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 +117,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 +150,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,10 +159,16 @@ class AppPlugin : FlutterPlugin, MethodChannel.MethodCallHandler, ActivityAware
                 result.success(true)
             }
 
-            "openFile" -> {
-                val path = call.argument<String>("path")!!
-                openFile(path)
-                result.success(true)
+            "isBatteryOptimizationDisabled" -> {
+                result.success(isBatteryOptimizationDisabled())
+            }
+
+            "openBatteryOptimizationSettings" -> {
+                result.success(openBatteryOptimizationSettings())
+            }
+
+            "openAppSettings" -> {
+                result.success(openAppSettings())
             }
 
             else -> {
@@ -222,44 +177,72 @@ class AppPlugin : FlutterPlugin, MethodChannel.MethodCallHandler, ActivityAware
         }
     }
 
-    private fun openFile(path: String) {
-        val file = File(path)
-        val uri = FileProvider.getUriForFile(
-            FlClashApplication.getAppContext(),
-            "${FlClashApplication.getAppContext().packageName}.fileProvider",
-            file
-        )
-
-        val intent = Intent(Intent.ACTION_VIEW).setDataAndType(
-            uri,
-            "text/plain"
-        )
-
-        val flags =
-            Intent.FLAG_GRANT_WRITE_URI_PERMISSION or Intent.FLAG_GRANT_READ_URI_PERMISSION
-
-        val resInfoList = FlClashApplication.getAppContext().packageManager.queryIntentActivities(
-            intent, PackageManager.MATCH_DEFAULT_ONLY
-        )
-
-        for (resolveInfo in resInfoList) {
-            val packageName = resolveInfo.activityInfo.packageName
-            FlClashApplication.getAppContext().grantUriPermission(
-                packageName,
-                uri,
-                flags
-            )
-        }
-
-        try {
-            activityRef?.get()?.startActivity(intent)
-        } catch (e: Exception) {
-            println(e)
+    private fun handleGetPackageIcon(call: MethodCall, result: Result) {
+        scope.launch {
+            val packageName = call.argument<String>("packageName")
+            if (packageName == null) {
+                result.success("")
+                return@launch
+            }
+            val path = GlobalState.application.packageManager.getPackageIconPath(packageName)
+            result.success(path)
         }
     }
 
+    private fun initShortcuts(label: String) {
+        val shortcut = with(ShortcutInfoCompat.Builder(GlobalState.application, "toggle")) {
+            setShortLabel(label)
+            setIcon(
+                IconCompat.createWithResource(
+                    GlobalState.application,
+                    R.mipmap.ic_launcher_round,
+                )
+            )
+            setIntent(QuickAction.TOGGLE.quickIntent)
+            build()
+        }
+        ShortcutManagerCompat.setDynamicShortcuts(
+            GlobalState.application, listOf(shortcut)
+        )
+    }
+
+    private fun tip(message: String?) {
+        GlobalState.application.showToast(message)
+    }
+
+    private fun isBatteryOptimizationDisabled(): Boolean {
+        val powerManager = getSystemService(GlobalState.application, PowerManager::class.java)
+        return powerManager?.isIgnoringBatteryOptimizations(GlobalState.application.packageName)
+            ?: false
+    }
+
+    private fun openBatteryOptimizationSettings(): Boolean {
+        return try {
+            val intent = Intent(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS).apply {
+                data = android.net.Uri.parse("package:${GlobalState.application.packageName}")
+            }
+            activityRef?.get()?.startActivity(intent)
+            true
+        } catch (_: Exception) {
+            false
+        }
+    }
+
+    private fun openAppSettings(): Boolean {
+        return try {
+            val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS).apply {
+                data = android.net.Uri.parse("package:${GlobalState.application.packageName}")
+            }
+            activityRef?.get()?.startActivity(intent)
+            true
+        } catch (_: Exception) {
+            false
+        }
+    }
+
+    @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,31 +258,18 @@ class AppPlugin : FlutterPlugin, MethodChannel.MethodCallHandler, ActivityAware
         }
     }
 
-    private suspend fun getPackageIcon(packageName: String): String? {
-        val packageManager = FlClashApplication.getAppContext().packageManager
-        if (iconMap[packageName] == null) {
-            iconMap[packageName] = try {
-                packageManager?.getApplicationIcon(packageName)?.getBase64()
-            } catch (_: Exception) {
-                null
-            }
-
-        }
-        return iconMap[packageName]
-    }
 
     private fun getPackages(): List<Package> {
-        val packageManager = FlClashApplication.getAppContext().packageManager
+        val packageManager = GlobalState.application.packageManager
         if (packages.isNotEmpty()) return packages
         packageManager?.getInstalledPackages(PackageManager.GET_META_DATA or PackageManager.GET_PERMISSIONS)
             ?.filter {
-                it.packageName != FlClashApplication.getAppContext().packageName || it.packageName == "android"
-
+                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)) == 1,
+                    system = (it.applicationInfo?.flags?.and(ApplicationInfo.FLAG_SYSTEM)) != 0,
                     lastUpdateTime = it.lastUpdateTime,
                     internet = it.requestedPermissions?.contains(Manifest.permission.INTERNET) == true
                 )
@@ -321,52 +291,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 +359,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(
@@ -427,6 +410,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)
@@ -449,21 +444,19 @@ class AppPlugin : FlutterPlugin, MethodChannel.MethodCallHandler, ActivityAware
     private fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?): Boolean {
         if (requestCode == VPN_PERMISSION_REQUEST_CODE) {
             if (resultCode == FlutterActivity.RESULT_OK) {
-                GlobalState.initServiceEngine()
-                vpnCallBack?.invoke()
+                invokeVpnPrepareCallback()
             }
         }
         return true
     }
 
     private fun onRequestPermissionsResultListener(
-        requestCode: Int,
-        permissions: Array<String>,
-        grantResults: IntArray
+        requestCode: Int, permissions: Array<String>, grantResults: IntArray
     ): Boolean {
         if (requestCode == NOTIFICATION_PERMISSION_REQUEST_CODE) {
             isBlockNotification = true
         }
+        invokeRequestNotificationCallback()
         return true
     }
 }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

android/build.gradle.kts

@@ -1,4 +1,3 @@
-
 allprojects {
     repositories {
         google()
@@ -6,7 +5,10 @@ allprojects {
     }
 }
 
-val newBuildDir: Directory = rootProject.layout.buildDirectory.dir("../../build").get()
+val newBuildDir: Directory =
+    rootProject.layout.buildDirectory
+        .dir("../../build")
+        .get()
 rootProject.layout.buildDirectory.value(newBuildDir)
 
 subprojects {

android/common/.gitignore

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

android/common/build.gradle.kts

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

android/common/src/main/AndroidManifest.xml

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

android/core/build.gradle.kts

@@ -1,4 +1,4 @@
-import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.argumentsWithVarargAsSingleArray
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 
 plugins {
     id("com.android.library")
@@ -7,22 +7,13 @@ plugins {
 
 android {
     namespace = "com.follow.clash.core"
-    compileSdk = 35
-    ndkVersion = "28.0.13004108"
+    compileSdk = libs.versions.compileSdk.get().toInt()
+    ndkVersion = libs.versions.ndkVersion.get()
 
     defaultConfig {
-        minSdk = 21
+        minSdk = libs.versions.minSdk.get().toInt()
     }
 
-    buildTypes {
-        release {
-            isJniDebuggable = false
-            proguardFiles(
-                getDefaultProguardFile("proguard-android-optimize.txt"),
-                "proguard-rules.pro"
-            )
-        }
-    }
 
     sourceSets {
         getByName("main") {
@@ -37,17 +28,30 @@ android {
         }
     }
 
-    kotlinOptions {
-        jvmTarget = "17"
-    }
-
     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("androidx.annotation:annotation-jvm:1.9.1")
+    implementation(libs.annotation.jvm)
 }
 
 val copyNativeLibs by tasks.register<Copy>("copyNativeLibs") {
@@ -56,6 +60,18 @@ val copyNativeLibs by tasks.register<Copy>("copyNativeLibs") {
     }
     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 {

android/core/proguard-rules.pro

@@ -1,21 +0,0 @@
-# Add project specific ProGuard rules here.
-# You can control the set of applied configuration files using the
-# proguardFiles setting in build.gradle.
-#
-# For more details, see
-#   http://developer.android.com/guide/developing/tools/proguard.html
-
-# If your project uses WebView with JS, uncomment the following
-# and specify the fully qualified class name to the JavaScript interface
-# class:
-#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
-#   public *;
-#}
-
-# Uncomment this to preserve the line number information for
-# debugging stack traces.
-#-keepattributes SourceFile,LineNumberTable
-
-# If you keep the line number information, uncomment this to
-# hide the original source file name.
-#-renamesourcefileattribute SourceFile

android/core/src/main/AndroidManifest.xml

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

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

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

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

@@ -1,24 +1,87 @@
-#ifdef LIBCLASH
 #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, const jint fd, jobject cb) {
+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(fd, interface);
+    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 *) {
+Java_com_follow_clash_core_Core_stopTun(JNIEnv *env, jobject thiz) {
     stopTun();
 }
 
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_follow_clash_core_Core_forceGC(JNIEnv *env, jobject thiz) {
+    forceGC();
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_follow_clash_core_Core_updateDNS(JNIEnv *env, jobject thiz, jstring dns) {
+    updateDns(get_string(dns));
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_follow_clash_core_Core_invokeAction(JNIEnv *env, jobject thiz, jstring data, jobject cb) {
+    const auto interface = new_global(cb);
+    invokeAction(interface, get_string(data));
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_follow_clash_core_Core_setEventListener(JNIEnv *env, jobject thiz, jobject cb) {
+    if (cb != nullptr) {
+        const auto interface = new_global(cb);
+        setEventListener(interface);
+    } else {
+        setEventListener(nullptr);
+    }
+}
+
+extern "C"
+JNIEXPORT jstring JNICALL
+Java_com_follow_clash_core_Core_getTraffic(JNIEnv *env, jobject thiz,
+                                           const jboolean only_statistics_proxy) {
+    return new_string(getTraffic(only_statistics_proxy));
+}
+
+extern "C"
+JNIEXPORT jstring JNICALL
+Java_com_follow_clash_core_Core_getTotalTraffic(JNIEnv *env, jobject thiz,
+                                                const jboolean only_statistics_proxy) {
+    return new_string(getTotalTraffic(only_statistics_proxy));
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_follow_clash_core_Core_suspended(JNIEnv *env, jobject thiz, jboolean suspended) {
+    suspend(suspended);
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_follow_clash_core_Core_quickSetup(JNIEnv *env, jobject thiz, jstring init_params_string,
+                                           jstring setup_params_string, jobject cb) {
+    const auto interface = new_global(cb);
+    quickSetup(interface, get_string(init_params_string), get_string(setup_params_string));
+}
+
 
 static jmethodID m_tun_interface_protect;
 static jmethodID m_tun_interface_resolve_process;
+static jmethodID m_invoke_interface_result;
 
 
 static void release_jni_object_impl(void *obj) {
@@ -26,6 +89,10 @@ static void release_jni_object_impl(void *obj) {
     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),
@@ -33,21 +100,29 @@ static void call_tun_interface_protect_impl(void *tun_interface, const int fd) {
                         fd);
 }
 
-static const char *
-call_tun_interface_resolve_process_impl(void *tun_interface, int protocol,
+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));
+    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 *) {
@@ -60,13 +135,74 @@ JNI_OnLoad(JavaVM *vm, void *) {
 
     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;
 
-    registerCallbacks(&call_tun_interface_protect_impl,
-                      &call_tun_interface_resolve_process_impl,
-                      &release_jni_object_impl);
     return JNI_VERSION_1_6;
 }
-#endif
+#else
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_follow_clash_core_Core_startTun(JNIEnv *env, jobject thiz, jint fd, jobject cb,
+                                         jstring stack, jstring address, jstring dns) {
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_follow_clash_core_Core_stopTun(JNIEnv *env, jobject thiz) {
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_follow_clash_core_Core_invokeAction(JNIEnv *env, jobject thiz, jstring data, jobject cb) {
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_follow_clash_core_Core_forceGC(JNIEnv *env, jobject thiz) {
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_follow_clash_core_Core_updateDNS(JNIEnv *env, jobject thiz, jstring dns) {
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_follow_clash_core_Core_setEventListener(JNIEnv *env, jobject thiz, jobject cb) {
+}
+
+extern "C"
+JNIEXPORT jstring JNICALL
+Java_com_follow_clash_core_Core_getTraffic(JNIEnv *env, jobject thiz,
+                                           const jboolean only_statistics_proxy) {
+}
+extern "C"
+JNIEXPORT jstring JNICALL
+Java_com_follow_clash_core_Core_getTotalTraffic(JNIEnv *env, jobject thiz,
+                                                const jboolean only_statistics_proxy) {
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_follow_clash_core_Core_suspended(JNIEnv *env, jobject thiz, jboolean suspended) {
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_follow_clash_core_Core_quickSetup(JNIEnv *env, jobject thiz, jstring init_params_string,
+                                           jstring setup_params_string, jobject cb) {
+}
+#endif

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

@@ -19,7 +19,7 @@ extern void jni_attach_thread(scoped_jni *jni);
 
 extern void jni_detach_thread(const scoped_jni *env);
 
-extern void release_string(char **str);
+extern void release_string( char **str);
 
 #define ATTACH_JNI() __attribute__((unused, cleanup(jni_detach_thread))) \
                     scoped_jni _jni{}; \

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

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

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

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

android/gradle.properties

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

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.2.13676358"
+coreKtx = "1.17.0"
+annotationJvm = "1.9.1"
+coreSplashscreen = "1.0.1"
+gson = "2.13.1"
+kotlin = "2.2.10"
+smaliDexlib2 = "3.0.9"
+firebaseCrashlyticsKtx = "20.0.1"
+firebaseCommonKtx = "22.0.0"
+
+[libraries]
+build-kotlin = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kotlin" }
+androidx-core = { module = "androidx.core:core-ktx", version.ref = "coreKtx" }
+annotation-jvm = { module = "androidx.annotation:annotation-jvm", version.ref = "annotationJvm" }
+core-splashscreen = { module = "androidx.core:core-splashscreen", version.ref = "coreSplashscreen" }
+firebase-analytics = { module = "com.google.firebase:firebase-analytics" }
+firebase-bom = { module = "com.google.firebase:firebase-bom", version.ref = "firebaseBom" }
+firebase-crashlytics-ndk = { module = "com.google.firebase:firebase-crashlytics-ndk" }
+gson = { module = "com.google.code.gson:gson", version.ref = "gson" }
+smali-dexlib2 = { module = "com.android.tools.smali:smali-dexlib2", version.ref = "smaliDexlib2" }
+firebase-crashlytics-ktx = { group = "com.google.firebase", name = "firebase-crashlytics-ktx", version.ref = "firebaseCrashlyticsKtx" }
+firebase-common-ktx = { group = "com.google.firebase", name = "firebase-common-ktx", version.ref = "firebaseCommonKtx" }

android/gradle/wrapper/gradle-wrapper.properties

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

android/service/.gitignore

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

android/service/build.gradle.kts

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

android/service/src/main/AndroidManifest.xml

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,11 +1,12 @@
 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
-    }
+    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")
 
@@ -16,14 +17,16 @@ pluginManagement {
     }
 }
 
-
-
 plugins {
     id("dev.flutter.flutter-plugin-loader") version "1.0.0"
-    id("com.android.application") version "8.9.2" apply false
-    id("org.jetbrains.kotlin.android") version "1.9.22" apply false
+    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

@@ -129,14 +129,8 @@
   "compatibleDesc": "Opening it will lose part of its application ability and gain the support of full amount of Clash.",
   "notSelectedTip": "The current proxy group cannot be selected.",
   "tip": "tip",
-  "backupAndRecovery": "Backup and Recovery",
-  "backupAndRecoveryDesc": "Sync data via WebDAV or file",
   "account": "Account",
   "backup": "Backup",
-  "recovery": "Recovery",
-  "recoveryProfiles": "Only recovery profiles",
-  "recoveryAll": "Recovery all data",
-  "recoverySuccess": "Recovery success",
   "backupSuccess": "Backup success",
   "noInfo": "No info",
   "pleaseBindWebDAV": "Please bind WebDAV",
@@ -219,9 +213,7 @@
   "local": "Local",
   "remote": "Remote",
   "remoteBackupDesc": "Backup local data to WebDAV",
-  "remoteRecoveryDesc": "Recovery data from WebDAV",
   "localBackupDesc": "Backup local data to local",
-  "localRecoveryDesc": "Recovery data from file",
   "mode": "Mode",
   "time": "Time",
   "source": "Source",
@@ -340,6 +332,8 @@
   "none": "none",
   "basicConfig": "Basic configuration",
   "basicConfigDesc": "Modify the basic configuration globally",
+  "advancedConfig": "Advanced configuration",
+  "advancedConfigDesc": "Provide diverse configuration options",
   "selectedCountTitle": "{count} items have been selected",
   "addRule": "Add rule",
   "ruleName": "Rule name",
@@ -379,9 +373,9 @@
   "systemApp": "System APP",
   "noNetworkApp": "No network APP",
   "contactMe": "Contact me",
-  "recoveryStrategy": "Recovery strategy",
-  "recoveryStrategy_override": "Override",
-  "recoveryStrategy_compatible": "Compatible",
+  "restoreStrategy": "Restore strategy",
+  "restoreStrategy_override": "Override",
+  "restoreStrategy_compatible": "Compatible",
   "logsTest": "Logs test",
   "emptyTip": "{label} cannot be empty",
   "urlTip": "{label} must be a url",
@@ -390,7 +384,7 @@
   "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",
+  "nullTip": "No {label} yet",
   "script": "Script",
   "color": "Color",
   "rename": "Rename",
@@ -406,5 +400,190 @@
   "import": "Import",
   "importFile": "Import from file",
   "importUrl": "Import from URL",
-  "autoSetSystemDns": "Auto set system DNS"
+  "autoSetSystemDns": "Auto set system DNS",
+  "details": "{label} details",
+  "creationTime": "Creation time",
+  "process": "Process",
+  "host": "Host",
+  "destination": "Destination",
+  "destinationGeoIP": "Destination GeoIP",
+  "destinationIPASN": "Destination IPASN",
+  "specialProxy": "Special proxy",
+  "specialRules": "special rules",
+  "remoteDestination": "Remote destination",
+  "networkType": "Network type",
+  "proxyChains": "Proxy chains",
+  "log": "Log",
+  "connection": "Connection",
+  "request": "Request",
+  "connected": "Connected",
+  "disconnected": "Disconnected",
+  "connecting": "Connecting...",
+  "restartCoreTip": "Are you sure you want to restart the core?",
+  "forceRestartCoreTip": "Are you sure you want to force restart the core?",
+  "dnsHijacking": "DNS hijacking",
+  "coreStatus": "Core status",
+  "dataCollectionTip": "Data Collection Notice",
+  "dataCollectionContent": "This app uses Firebase Crashlytics to collect crash information to improve app stability.\nThe collected data includes device information and crash details, but does not contain personal sensitive data.\nYou can disable this feature in settings.",
+  "crashlytics": "Crash Analysis",
+  "crashlyticsTip": "When enabled, automatically uploads crash logs without sensitive information when the app crashes",
+  "appendSystemDns": "Append System DNS",
+  "appendSystemDnsTip": "Forcefully append system DNS to the configuration",
+  "editRule": "Edit rule",
+  "overrideMode": "Override mode",
+  "standardModeDesc": "Standard mode, override basic configuration, provide simple rule addition capability",
+  "scriptModeDesc": "Script mode, use external extension scripts, provide one-click override configuration capability",
+  "addedRules": "Added rules",
+  "controlGlobalAddedRules": "Control global added rules",
+  "overrideScript": "Override script",
+  "goToConfigureScript": "Go to configure script",
+  "editGlobalRules": "Edit global rules",
+  "externalFetch": "External fetch",
+  "confirmForceCrashCore": "Are you sure you want to force crash the core?",
+  "confirmClearAllData": "Are you sure you want to clear all data?",
+  "loading": "Loading...",
+  "loadTest": "Load test",
+  "yearsAgo": "{count, plural, =1{1 year ago} other{{count} years ago}}",
+  "monthsAgo": "{count, plural, =1{1 month ago} other{{count} months ago}}",
+  "daysAgo": "{count, plural, =1{1 day ago} other{{count} days ago}}",
+  "hoursAgo": "{count, plural, =1{1 hour ago} other{{count} hours ago}}",
+  "minutesAgo": "{count, plural, =1{1 minute ago} other{{count} minutes ago}}",
+  "justNow": "Just now",
+  "noLongerRemind": "Don't remind again",
+  "accessControlSettings": "Access Control Settings",
+  "turnOn": "Turn On",
+  "turnOff": "Turn Off",
+  "coreConfigChangeDetected": "Core configuration change detected",
+  "reload": "Reload",
+  "vpnConfigChangeDetected": "VPN configuration change detected",
+  "restart": "Restart",
+  "speedStatistics": "Speed statistics",
+  "resetPageChangesTip": "The current page has changes. Are you sure you want to reset?",
+  "overwriteTypeCustom": "Custom",
+  "overwriteTypeCustomDesc": "Custom mode, fully customize proxy groups and rules",
+  "unknownNetworkError": "Unknown network error",
+  "networkRequestException": "Network request exception, please try again later.",
+  "restoreException": "Recovery exception",
+  "networkException": "Network exception, please check your connection and try again",
+  "invalidBackupFile": "Invalid backup file",
+  "pruneCache": "Prune cache",
+  "backupAndRestore": "Backup and Restore",
+  "backupAndRestoreDesc": "Sync data via WebDAV or files",
+  "restore": "Restore",
+  "restoreSuccess": "Restore success",
+  "restoreFromWebDAVDesc": "Restore data via WebDAV",
+  "restoreFromFileDesc": "Restore data via file",
+  "restoreOnlyConfig": "Restore configuration files only",
+  "restoreAllData": "Restore all data",
+  "addProfile": "Add Profile",
+  "delayTest": "Delay Test",
+  "proxyGroupEmpty": "Proxy group is empty",
+  "proxyGroupNameEmpty": "Proxy group name cannot be empty",
+  "proxyGroupNameDuplicate": "Proxy group name is duplicate",
+  "confirmExitWindow": "Are you sure you want to exit the current window?",
+  "dataChangedSave": "Data changes detected, do you want to save?",
+  "selectProxyProviders": "Select proxy providers",
+  "proxyFilter": "Proxy filter",
+  "optional": "Optional",
+  "maxFailedTimes": "Max failed times",
+  "testInterval": "Test interval",
+  "excludeProxyFilter": "Exclude proxy filter",
+  "excludeType": "Exclude type",
+  "expectedStatus": "Expected status",
+  "selectProxies": "Select proxies",
+  "inputProxyGroupName": "Input proxy group name",
+  "hideFromList": "Hide from list",
+  "testWhenUsed": "Test when used",
+  "disableUDP": "Disable UDP",
+  "confirmDeleteProxyGroup": "Are you sure you want to delete the current proxy group?",
+  "ruleEmpty": "Rule is empty",
+  "inputRuleContent": "Input rule content",
+  "ruleSet": "Rule set",
+  "selectRuleSet": "Please select rule set",
+  "splitStrategy": "Split strategy",
+  "selectSplitStrategy": "Please select split strategy",
+  "selectSubRule": "Please select sub rule",
+  "noResolveHostname": "No resolve hostname",
+  "matchSourceIp": "Match source IP",
+  "basicInfo": "Basic info",
+  "additionalParameters": "Additional parameters",
+  "proxyType": "Proxy type",
+  "basicStrategy": "Basic strategy",
+  "editProxy": "Edit proxy",
+  "includeAllProxyProviders": "Include all proxy providers",
+  "includeAllProxyProvidersTip": "When enabled, it will override the imported proxy providers",
+  "addProxyProviders": "Add proxy providers",
+  "includeAllProxies": "Include all proxies",
+  "includeAllProxiesTip": "Import all proxies not containing proxy groups, additional proxy groups can be added below",
+  "proxiesEmpty": "Proxies is empty",
+  "addProxies": "Add proxies",
+  "addProxyGroup": "Add proxy group",
+  "editProxyGroup": "Edit proxy group",
+  "confirmOverwriteTip": "Existing data will be overwritten after confirmation",
+  "configDataDetected": "Data detected in configuration",
+  "quickFill": "Quick fill",
+  "iconUrl": "Icon URL",
+  "iconRecords": "Icon records",
+  "noRecords": "No records",
+  "custom": "Custom",
+  "ruleActionDomainDesc": "Match full domain",
+  "ruleActionDomainSuffixDesc": "Match domain suffix",
+  "ruleActionDomainKeywordDesc": "Match domain keyword",
+  "ruleActionDomainRegexDesc": "Wildcard match, only supports * and ? wildcards",
+  "ruleActionGeositeDesc": "Match domains within Geosite",
+  "ruleActionIpCidrDesc": "Match IP address range",
+  "ruleActionIpCidr6Desc": "Match IP address range, IP-CIDR6 is just an alias",
+  "ruleActionIpSuffixDesc": "Match IP suffix range",
+  "ruleActionIpAsnDesc": "Match IP's ASN",
+  "ruleActionGeoipDesc": "Match IP's country code",
+  "ruleActionSrcGeoipDesc": "Match source IP's country code",
+  "ruleActionSrcIpAsnDesc": "Match source IP's ASN",
+  "ruleActionSrcIpCidrDesc": "Match source IP address range",
+  "ruleActionSrcIpSuffixDesc": "Match source IP suffix range",
+  "ruleActionDstPortDesc": "Match request target port range",
+  "ruleActionSrcPortDesc": "Match request source port range",
+  "ruleActionInPortDesc": "Match inbound port",
+  "ruleActionInTypeDesc": "Match inbound type",
+  "ruleActionInUserDesc": "Match inbound username, supports multiple usernames separated by /",
+  "ruleActionInNameDesc": "Match inbound name",
+  "ruleActionProcessPathDesc": "Match using full process path",
+  "ruleActionProcessPathRegexDesc": "Match using process path regex",
+  "ruleActionProcessNameDesc": "Match using process name, matches package name on Android",
+  "ruleActionProcessNameRegexDesc": "Match using process name regex, matches package name on Android",
+  "ruleActionUidDesc": "Match Linux USER ID",
+  "ruleActionNetworkDesc": "Match TCP or UDP",
+  "ruleActionDscpDesc": "Match DSCP mark (tproxy udp inbound only)",
+  "ruleActionRuleSetDesc": "Reference rule set, requires rule-providers configuration",
+  "ruleActionAndDesc": "Logical rule AND",
+  "ruleActionOrDesc": "Logical rule OR",
+  "ruleActionNotDesc": "Logical rule NOT",
+  "ruleActionSubRuleDesc": "Match to sub-rule, pay attention to the use of parentheses",
+  "ruleActionMatchDesc": "Match all requests, no conditions needed",
+  "subRuleEmpty": "Sub rule is empty",
+  "proxyProvidersNotEmpty": "Proxy providers cannot be empty",
+  "contentNotEmpty": "Content cannot be empty",
+  "subRuleNotEmpty": "Sub rule cannot be empty",
+  "splitStrategyNotEmpty": "Split strategy cannot be empty",
+  "proxyProvidersEmpty": "Proxy providers is empty",
+  "timeout": "Timeout",
+  "invalidSubRule": "{subRule} is an invalid SUB_RULE",
+  "invalidPolicy": "{target} is an invalid policy",
+  "invalidProxyProvider": "{providerName} is an invalid proxy provider",
+  "invalidProxy": "{proxyName} is an invalid proxy",
+  "proxyGroupDetectedAbnormal": "Detected current proxy group is abnormal",
+  "proxyProviderDetectedAbnormal": "Detected selected proxy providers are abnormal",
+  "proxyDetectedAbnormal": "Detected selected proxies are abnormal",
+  "createProfile": "Create Profile",
+  "locationPermissionRequired": "Location Permission Required",
+  "locationPermissionGuide": "1. Open System Settings > Privacy & Security\n2. Choose Location Services\n3. Find and check {appName} in the right list\n\nAfter completing the setup, return to the app and use it normally. Thank you for your cooperation.",
+  "prerequisites": "Prerequisites",
+  "ignoreBatteryOptimization": "Ignore Battery Optimization",
+  "batteryOptimizationDesc": "To ensure background operation, please disable battery optimization for this app. Tap to go to settings.",
+  "locationPermission": "Location Permission",
+  "locationPermissionDesc": "According to system requirements, obtaining the Wi-Fi name requires you to grant location permission.",
+  "excludeSsids": "Exclude SSIDs",
+  "excludeSsidsDesc": "When connected to an excluded SSID Wi-Fi, the app running state will be automatically switched.",
+  "ssidsEmpty": "SSIDs is empty",
+  "onDemand": "On Demand",
+  "onDemandDesc": "Configure the program running state for specific scenarios"
 }

arb/intl_ja.arb

@@ -129,14 +129,8 @@
   "compatibleDesc": "有効化すると一部機能を失いますが、Clashの完全サポートを獲得",
   "notSelectedTip": "現在のプロキシグループは選択できません",
   "tip": "ヒント",
-  "backupAndRecovery": "バックアップと復元",
-  "backupAndRecoveryDesc": "WebDAVまたはファイルでデータを同期",
   "account": "アカウント",
   "backup": "バックアップ",
-  "recovery": "復元",
-  "recoveryProfiles": "プロファイルのみ復元",
-  "recoveryAll": "全データ復元",
-  "recoverySuccess": "復元成功",
   "backupSuccess": "バックアップ成功",
   "noInfo": "情報なし",
   "pleaseBindWebDAV": "WebDAVをバインドしてください",
@@ -219,9 +213,7 @@
   "local": "ローカル",
   "remote": "リモート",
   "remoteBackupDesc": "WebDAVにデータをバックアップ",
-  "remoteRecoveryDesc": "WebDAVからデータを復元",
   "localBackupDesc": "ローカルにデータをバックアップ",
-  "localRecoveryDesc": "ファイルからデータを復元",
   "mode": "モード",
   "time": "時間",
   "source": "ソース",
@@ -340,6 +332,8 @@
   "none": "なし",
   "basicConfig": "基本設定",
   "basicConfigDesc": "基本設定をグローバルに変更",
+  "advancedConfig": "高度な設定",
+  "advancedConfigDesc": "多様な設定を提供",
   "selectedCountTitle": "{count} 項目が選択されています",
   "addRule": "ルールを追加",
   "ruleName": "ルール名",
@@ -380,9 +374,9 @@
   "systemApp": "システムアプリ",
   "noNetworkApp": "ネットワークなしアプリ",
   "contactMe": "連絡する",
-  "recoveryStrategy": "リカバリー戦略",
-  "recoveryStrategy_override": "オーバーライド",
-  "recoveryStrategy_compatible": "互換性",
+  "restoreStrategy": "復元ストラテジー",
+  "restoreStrategy_override": "上書き",
+  "restoreStrategy_compatible": "互換",
   "logsTest": "ログテスト",
   "emptyTip": "{label}は空欄にできません",
   "urlTip": "{label}はURLである必要があります",
@@ -391,7 +385,7 @@
   "existsTip": "現在の{label}は既に存在しています",
   "deleteTip": "現在の{label}を削除してもよろしいですか？",
   "deleteMultipTip": "選択された{label}を削除してもよろしいですか？",
-  "nullTip": "現在{label}はありません",
+  "nullTip": "まだ{label}はありません",
   "script": "スクリプト",
   "color": "カラー",
   "rename": "リネーム",
@@ -407,5 +401,190 @@
   "import": "インポート",
   "importFile": "ファイルからインポート",
   "importUrl": "URLからインポート",
-  "autoSetSystemDns": "オートセットシステムDNS"
-}
+  "autoSetSystemDns": "オートセットシステムDNS",
+  "details": "{label}詳細",
+  "creationTime": "作成時間",
+  "process": "プロセス",
+  "host": "ホスト",
+  "destination": "宛先",
+  "destinationGeoIP": "宛先地理情報",
+  "destinationIPASN": "宛先IP ASN",
+  "specialProxy": "特殊プロキシ",
+  "specialRules": "特殊ルール",
+  "remoteDestination": "リモート宛先",
+  "networkType": "ネットワーク種別",
+  "proxyChains": "プロキシチェーン",
+  "log": "ログ",
+  "connection": "接続",
+  "request": "リクエスト",
+  "connected": "接続済み",
+  "disconnected": "切断済み",
+  "connecting": "接続中...",
+  "restartCoreTip": "コアを再起動してもよろしいですか？",
+  "forceRestartCoreTip": "コアを強制再起動してもよろしいですか？",
+  "dnsHijacking": "DNSハイジャッキング",
+  "coreStatus": "コアステータス",
+  "dataCollectionTip": "データ収集説明",
+  "dataCollectionContent": "本アプリはFirebase Crashlyticsを使用してクラッシュ情報を収集し、アプリの安定性を向上させます。\n収集されるデータにはデバイス情報とクラッシュ詳細が含まれますが、個人の機密データは含まれません。\n設定でこの機能を無効にすることができます。",
+  "crashlytics": "クラッシュ分析",
+  "crashlyticsTip": "有効にすると、アプリがクラッシュした際に機密情報を含まないクラッシュログを自動的にアップロードします",
+  "appendSystemDns": "システムDNSを追加",
+  "appendSystemDnsTip": "設定にシステムDNSを強制的に追加します",
+  "editRule": "ルールを編集",
+  "overrideMode": "上書きモード",
+  "standardModeDesc": "標準モード、基本設定を上書きし、シンプルなルール追加機能を提供",
+  "scriptModeDesc": "スクリプトモード、外部拡張スクリプトを使用し、ワンクリックで設定を上書きする機能を提供",
+  "addedRules": "追加ルール",
+  "controlGlobalAddedRules": "グローバル追加ルールを制御",
+  "overrideScript": "上書きスクリプト",
+  "goToConfigureScript": "スクリプト設定に移動",
+  "editGlobalRules": "グローバルルールを編集",
+  "externalFetch": "外部取得",
+  "confirmForceCrashCore": "コアを強制的にクラッシュさせてもよろしいですか？",
+  "confirmClearAllData": "すべてのデータをクリアしてもよろしいですか？",
+  "loading": "読み込み中...",
+  "loadTest": "読み込みテスト",
+  "yearsAgo": "{count}年前",
+  "monthsAgo": "{count}ヶ月前",
+  "daysAgo": "{count}日前",
+  "hoursAgo": "{count}時間前",
+  "minutesAgo": "{count}分前",
+  "justNow": "たった今",
+  "noLongerRemind": "今後表示しない",
+  "accessControlSettings": "アクセス制御設定",
+  "turnOn": "オン",
+  "turnOff": "オフ",
+  "coreConfigChangeDetected": "コア設定の変更が検出されました",
+  "reload": "リロード",
+  "vpnConfigChangeDetected": "VPN設定の変更が検出されました",
+  "restart": "再起動",
+  "speedStatistics": "速度統計",
+  "resetPageChangesTip": "現在のページに変更があります。リセットしてもよろしいですか？",
+  "overwriteTypeCustom": "カスタム",
+  "overwriteTypeCustomDesc": "カスタムモード、プロキシグループとルールを完全にカスタマイズ可能",
+  "unknownNetworkError": "不明なネットワークエラー",
+  "networkRequestException": "ネットワーク要求例外、後でもう一度試してください。",
+  "restoreException": "復元例外",
+  "networkException": "ネットワーク例外、接続を確認してもう一度お試しください",
+  "invalidBackupFile": "無効なバックアップファイル",
+  "pruneCache": "キャッシュの削除",
+  "backupAndRestore": "バックアップと復元",
+  "backupAndRestoreDesc": "WebDAVまたはファイルを介してデータを同期する",
+  "restore": "復元",
+  "restoreSuccess": "復元に成功しました",
+  "restoreFromWebDAVDesc": "WebDAVを介してデータを復元する",
+  "restoreFromFileDesc": "ファイルを介してデータを復元する",
+  "restoreOnlyConfig": "設定ファイルのみを復元する",
+  "restoreAllData": "すべてのデータを復元する",
+  "addProfile": "プロファイルを追加",
+  "delayTest": "遅延テスト",
+  "proxyGroupEmpty": "プロキシグループが空です",
+  "proxyGroupNameEmpty": "プロキシグループ名は空にできません",
+  "proxyGroupNameDuplicate": "プロキシグループ名が重複しています",
+  "confirmExitWindow": "現在のウィンドウを閉じてもよろしいですか？",
+  "dataChangedSave": "データの変更が検出されました。保存しますか？",
+  "selectProxyProviders": "プロキシプロバイダーを選択",
+  "proxyFilter": "プロキシフィルター",
+  "optional": "オプション",
+  "maxFailedTimes": "最大失敗回数",
+  "testInterval": "テスト間隔",
+  "excludeProxyFilter": "除外プロキシフィルター",
+  "excludeType": "除外タイプ",
+  "expectedStatus": "期待されるステータス",
+  "selectProxies": "プロキシを選択",
+  "inputProxyGroupName": "プロキシグループ名を入力",
+  "hideFromList": "リストから隠す",
+  "testWhenUsed": "使用時にテスト",
+  "disableUDP": "UDPを無効化",
+  "confirmDeleteProxyGroup": "現在のプロキシグループを削除してもよろしいですか？",
+  "ruleEmpty": "ルールが空です",
+  "inputRuleContent": "ルール内容を入力",
+  "ruleSet": "ルールセット",
+  "selectRuleSet": "ルールセットを選択してください",
+  "splitStrategy": "分流戦略",
+  "selectSplitStrategy": "分流戦略を選択してください",
+  "selectSubRule": "サブルールを選択してください",
+  "noResolveHostname": "ホスト名を解決しない",
+  "matchSourceIp": "送信元IPをマッチング",
+  "basicInfo": "基本情報",
+  "additionalParameters": "追加パラメータ",
+  "proxyType": "プロキシタイプ",
+  "basicStrategy": "基本戦略",
+  "editProxy": "プロキシを編集",
+  "includeAllProxyProviders": "すべてのプロキシプロバイダーを含める",
+  "includeAllProxyProvidersTip": "有効にすると、インポートされたプロキシプロバイダーを上書きします",
+  "addProxyProviders": "プロキシプロバイダーを追加",
+  "includeAllProxies": "すべてのプロキシを含める",
+  "includeAllProxiesTip": "プロキシグループに含まれないすべてのプロキシをインポートします。下でさらにプロキシグループを追加できます",
+  "proxiesEmpty": "プロキシが空です",
+  "addProxies": "プロキシを追加",
+  "addProxyGroup": "プロキシグループを追加",
+  "editProxyGroup": "プロキシグループを編集",
+  "confirmOverwriteTip": "確認後、既存のデータは上書きされます",
+  "configDataDetected": "設定内にデータが検出されました",
+  "quickFill": "クイック入力",
+  "iconUrl": "アイコンURL",
+  "iconRecords": "アイコン履歴",
+  "noRecords": "履歴なし",
+  "custom": "カスタム",
+  "ruleActionDomainDesc": "完全なドメインをマッチング",
+  "ruleActionDomainSuffixDesc": "ドメイン接尾辞をマッチング",
+  "ruleActionDomainKeywordDesc": "ドメインキーワードをマッチング",
+  "ruleActionDomainRegexDesc": "ワイルドカードマッチング（*と?のみサポート）",
+  "ruleActionGeositeDesc": "Match domains within Geosite",
+  "ruleActionIpCidrDesc": "IPアドレス範囲をマッチング",
+  "ruleActionIpCidr6Desc": "IPアドレス範囲をマッチング（IP-CIDR6はエイリアスです）",
+  "ruleActionIpSuffixDesc": "IP接尾辞範囲をマッチング",
+  "ruleActionIpAsnDesc": "IPのASNをマッチング",
+  "ruleActionGeoipDesc": "IPの国コードをマッチング",
+  "ruleActionSrcGeoipDesc": "送信元IPの国コードをマッチング",
+  "ruleActionSrcIpAsnDesc": "送信元IPのASNをマッチング",
+  "ruleActionSrcIpCidrDesc": "送信元IPアドレス範囲をマッチング",
+  "ruleActionSrcIpSuffixDesc": "送信元IP接尾辞範囲をマッチング",
+  "ruleActionDstPortDesc": "宛先ポート範囲をマッチング",
+  "ruleActionSrcPortDesc": "送信元ポート範囲をマッチング",
+  "ruleActionInPortDesc": "インバウンドポートをマッチング",
+  "ruleActionInTypeDesc": "インバウンドタイプをマッチング",
+  "ruleActionInUserDesc": "インバウンドユーザー名をマッチング（/で複数指定可）",
+  "ruleActionInNameDesc": "インバウンド名をマッチング",
+  "ruleActionProcessPathDesc": "フルプロセスパスでマッチング",
+  "ruleActionProcessPathRegexDesc": "プロセスパス正規表現でマッチング",
+  "ruleActionProcessNameDesc": "プロセス名でマッチング（Androidではパッケージ名）",
+  "ruleActionProcessNameRegexDesc": "プロセス名正規表現でマッチング（Androidではパッケージ名）",
+  "ruleActionUidDesc": "Linux USER IDをマッチング",
+  "ruleActionNetworkDesc": "TCPまたはUDPをマッチング",
+  "ruleActionDscpDesc": "DSCPマークをマッチング (tproxy udp inboundのみ)",
+  "ruleActionRuleSetDesc": "ルールセットを参照。rule-providersの設定が必要",
+  "ruleActionAndDesc": "論理ルール AND",
+  "ruleActionOrDesc": "論理ルール OR",
+  "ruleActionNotDesc": "論理ルール NOT",
+  "ruleActionSubRuleDesc": "サブルールにマッチング。括弧の使用に注意",
+  "ruleActionMatchDesc": "すべてのリクエストにマッチ（条件なし）",
+  "subRuleEmpty": "サブルールが空です",
+  "proxyProvidersNotEmpty": "プロキシプロバイダーは空にできません",
+  "contentNotEmpty": "内容は空にできません",
+  "subRuleNotEmpty": "サブルールは空にできません",
+  "splitStrategyNotEmpty": "分流戦略は空にできません",
+  "proxyProvidersEmpty": "プロキシプロバイダーが空です",
+  "timeout": "タイムアウト",
+  "invalidSubRule": "{subRule} は無効なSUB_RULEです",
+  "invalidPolicy": "{target} は無効なポリシーです",
+  "invalidProxyProvider": "{providerName} は無効なプロキシプロバイダーです",
+  "invalidProxy": "{proxyName} は無効なプロキシです",
+  "proxyGroupDetectedAbnormal": "現在のプロキシグループが異常であることを検出しました",
+  "proxyProviderDetectedAbnormal": "選択されたプロキシプロバイダーに異常があることを検出しました",
+  "proxyDetectedAbnormal": "選択されたプロキシに異常があることを検出しました",
+  "createProfile": "Create Profile",
+  "locationPermissionRequired": "Location Permission Required",
+  "locationPermissionGuide": "1. Open System Settings > Privacy & Security\n2. Choose Location Services\n3. Find and check {appName} in the right list\n\nAfter completing the setup, return to the app and use it normally. Thank you for your cooperation.",
+  "prerequisites": "Prerequisites",
+  "ignoreBatteryOptimization": "Ignore Battery Optimization",
+  "batteryOptimizationDesc": "To ensure background operation, please disable battery optimization for this app. Tap to go to settings.",
+  "locationPermission": "Location Permission",
+  "locationPermissionDesc": "According to system requirements, obtaining the Wi-Fi name requires you to grant location permission.",
+  "excludeSsids": "Exclude SSIDs",
+  "excludeSsidsDesc": "When connected to an excluded SSID Wi-Fi, the app running state will be automatically switched.",
+  "ssidsEmpty": "SSIDs is empty",
+  "onDemand": "On Demand",
+  "onDemandDesc": "Configure the program running state for specific scenarios"
+}

arb/intl_ru.arb

@@ -340,6 +340,8 @@
   "none": "Нет",
   "basicConfig": "Базовая конфигурация",
   "basicConfigDesc": "Глобальное изменение базовых настроек",
+  "advancedConfig": "Расширенная конфигурация",
+  "advancedConfigDesc": "Предоставляет разнообразные варианты конфигурации",
   "selectedCountTitle": "Выбрано {count} элементов",
   "addRule": "Добавить правило",
   "ruleName": "Название правила",
@@ -380,9 +382,9 @@
   "systemApp": "Системное приложение",
   "noNetworkApp": "Приложение без сети",
   "contactMe": "Свяжитесь со мной",
-  "recoveryStrategy": "Стратегия восстановления",
-  "recoveryStrategy_override": "Переопределение",
-  "recoveryStrategy_compatible": "Совместимый",
+  "restoreStrategy": "Стратегия восстановления",
+  "restoreStrategy_override": "Перезаписать",
+  "restoreStrategy_compatible": "Совместимый",
   "logsTest": "Тест журналов",
   "emptyTip": "{label} не может быть пустым",
   "urlTip": "{label} должен быть URL",
@@ -391,7 +393,7 @@
   "existsTip": "Текущий {label} уже существует",
   "deleteTip": "Вы уверены, что хотите удалить текущий {label}?",
   "deleteMultipTip": "Вы уверены, что хотите удалить выбранные {label}?",
-  "nullTip": "Сейчас {label} нет",
+  "nullTip": "{label} пока отсутствуют",
   "script": "Скрипт",
   "color": "Цвет",
   "rename": "Переименовать",
@@ -407,5 +409,190 @@
   "import": "Импорт",
   "importFile": "Импорт из файла",
   "importUrl": "Импорт по URL",
-  "autoSetSystemDns": "Автоматическая настройка системного DNS"
-}
+  "autoSetSystemDns": "Автоматическая настройка системного DNS",
+  "details": "Детали {}",
+  "creationTime": "Время создания",
+  "process": "процесс",
+  "host": "Хост",
+  "destination": "Назначение",
+  "destinationGeoIP": "Геолокация назначения",
+  "destinationIPASN": "ASN назначения",
+  "specialProxy": "Специальный прокси",
+  "specialRules": "Специальные правила",
+  "remoteDestination": "Удалённое назначение",
+  "networkType": "Тип сети",
+  "proxyChains": "Цепочки прокси",
+  "log": "Журнал",
+  "connection": "Соединение",
+  "request": "Запрос",
+  "connected": "Подключено",
+  "disconnected": "Отключено",
+  "connecting": "Подключение...",
+  "restartCoreTip": "Вы уверены, что хотите перезапустить ядро?",
+  "forceRestartCoreTip": "Вы уверены, что хотите принудительно перезапустить ядро?",
+  "dnsHijacking": "DNS-перехват",
+  "coreStatus": "Основной статус",
+  "dataCollectionTip": "Уведомление о сборе данных",
+  "dataCollectionContent": "Это приложение использует Firebase Crashlytics для сбора информации о сбоях nhằm улучшения стабильности приложения.\nСобираемые данные включают информацию об устройстве и подробности о сбоях, но не содержат персональных конфиденциальных данных.\nВы можете отключить эту функцию в настройках.",
+  "crashlytics": "Анализ сбоев",
+  "crashlyticsTip": "При включении автоматически загружает журналы сбоев без конфиденциальной информации, когда приложение выходит из строя",
+  "appendSystemDns": "Добавить системный DNS",
+  "appendSystemDnsTip": "Принудительно добавить системный DNS к конфигурации",
+  "editRule": "Редактировать правило",
+  "overrideMode": "Режим переопределения",
+  "standardModeDesc": "Стандартный режим, переопределение базовой конфигурации, предоставление возможности простого добавления правил",
+  "scriptModeDesc": "Режим скрипта, использование внешних расширяющих скриптов, предоставление возможности переопределения конфигурации одним кликом",
+  "addedRules": "Добавленные правила",
+  "controlGlobalAddedRules": "Управление глобальными добавленными правилами",
+  "overrideScript": "Скрипт переопределения",
+  "goToConfigureScript": "Перейти к настройке скрипта",
+  "editGlobalRules": "Редактировать глобальные правила",
+  "externalFetch": "Внешнее получение",
+  "confirmForceCrashCore": "Вы уверены, что хотите принудительно аварийно завершить работу ядра?",
+  "confirmClearAllData": "Вы уверены, что хотите очистить все данные?",
+  "loading": "Загрузка...",
+  "loadTest": "Тест загрузки",
+  "yearsAgo": "{count, plural, one{{count} год назад} few{{count} года назад} many{{count} лет назад} other{{count} года назад}}",
+  "monthsAgo": "{count, plural, one{{count} месяц назад} few{{count} месяца назад} many{{count} месяцев назад} other{{count} месяца назад}}",
+  "daysAgo": "{count, plural, one{{count} день назад} few{{count} дня назад} many{{count} дней назад} other{{count} дня назад}}",
+  "hoursAgo": "{count, plural, one{{count} час назад} few{{count} часа назад} many{{count} часов назад} other{{count} часа назад}}",
+  "minutesAgo": "{count, plural, one{{count} минута назад} few{{count} минуты назад} many{{count} минут назад} other{{count} минуты назад}}",
+  "justNow": "Только что",
+  "noLongerRemind": "Больше не напоминать",
+  "accessControlSettings": "Настройки контроля доступа",
+  "turnOn": "Включить",
+  "turnOff": "Выключить",
+  "coreConfigChangeDetected": "Обнаружено изменение конфигурации ядра",
+  "reload": "Перезагрузить",
+  "vpnConfigChangeDetected": "Обнаружено изменение конфигурации VPN",
+  "restart": "Перезапустить",
+  "speedStatistics": "Статистика скорости",
+  "resetPageChangesTip": "На текущей странице есть изменения. Вы уверены, что хотите сбросить?",
+  "overwriteTypeCustom": "Пользовательский",
+  "overwriteTypeCustomDesc": "Пользовательский режим, полная настройка групп прокси и правил",
+  "unknownNetworkError": "Неизвестная сетевая ошибка",
+  "networkRequestException": "Исключение сетевого запроса, пожалуйста, попробуйте позже.",
+  "restoreException": "Ошибка восстановления",
+  "networkException": "Ошибка сети, проверьте соединение и попробуйте еще раз",
+  "invalidBackupFile": "Неверный файл резервной копии",
+  "pruneCache": "Очистить кэш",
+  "backupAndRestore": "Резервное копирование и восстановление",
+  "backupAndRestoreDesc": "Синхронизация данных через WebDAV или файлы",
+  "restore": "Восстановить",
+  "restoreSuccess": "Восстановление успешно",
+  "restoreFromWebDAVDesc": "Восстановить данные через WebDAV",
+  "restoreFromFileDesc": "Восстановить данные из файла",
+  "restoreOnlyConfig": "Восстановить только файлы конфигурации",
+  "restoreAllData": "Восстановить все данные",
+  "addProfile": "Добавить профиль",
+  "delayTest": "Тест задержки",
+  "proxyGroupEmpty": "Группа прокси пуста",
+  "proxyGroupNameEmpty": "Имя группы прокси не может быть пустым",
+  "proxyGroupNameDuplicate": "Имя группы прокси дублируется",
+  "confirmExitWindow": "Вы уверены, что хотите выйти из текущего окна?",
+  "dataChangedSave": "Обнаружены изменения данных, хотите сохранить?",
+  "selectProxyProviders": "Выбрать провайдеров прокси",
+  "proxyFilter": "Фильтр прокси",
+  "optional": "Необязательно",
+  "maxFailedTimes": "Макс. количество неудач",
+  "testInterval": "Интервал тестирования",
+  "excludeProxyFilter": "Исключить фильтр прокси",
+  "excludeType": "Тип исключения",
+  "expectedStatus": "Ожидаемый статус",
+  "selectProxies": "Выбрать прокси",
+  "inputProxyGroupName": "Введите имя группы прокси",
+  "hideFromList": "Скрыть из списка",
+  "testWhenUsed": "Тестировать при использовании",
+  "disableUDP": "Отключить UDP",
+  "confirmDeleteProxyGroup": "Вы уверены, что хотите удалить текущую группу прокси?",
+  "ruleEmpty": "Правило пусто",
+  "inputRuleContent": "Введите содержимое правила",
+  "ruleSet": "Набор правил",
+  "selectRuleSet": "Пожалуйста, выберите набор правил",
+  "splitStrategy": "Стратегия разделения",
+  "selectSplitStrategy": "Пожалуйста, выберите стратегию разделения",
+  "selectSubRule": "Пожалуйста, выберите подправило",
+  "noResolveHostname": "Не разрешать имя хоста",
+  "matchSourceIp": "Сопоставить исходный IP",
+  "basicInfo": "Основная информация",
+  "additionalParameters": "Дополнительные параметры",
+  "proxyType": "Тип прокси",
+  "basicStrategy": "Базовая стратегия",
+  "editProxy": "Редактировать прокси",
+  "includeAllProxyProviders": "Включить всех провайдеров прокси",
+  "includeAllProxyProvidersTip": "При включении это переопределит импортированных провайдеров прокси",
+  "addProxyProviders": "Добавить провайдеров прокси",
+  "includeAllProxies": "Включить все прокси",
+  "includeAllProxiesTip": "Импорт всех прокси, не содержащих группы прокси, дополнительные группы прокси можно добавить ниже",
+  "proxiesEmpty": "Список прокси пуст",
+  "addProxies": "Добавить прокси",
+  "addProxyGroup": "Добавить группу прокси",
+  "editProxyGroup": "Редактировать группу прокси",
+  "confirmOverwriteTip": "Существующие данные будут перезаписаны после подтверждения",
+  "configDataDetected": "Данные обнаружены в конфигурации",
+  "quickFill": "Быстрое заполнение",
+  "iconUrl": "URL иконки",
+  "iconRecords": "История иконок",
+  "noRecords": "Нет записей",
+  "custom": "Пользовательский",
+  "ruleActionDomainDesc": "Сопоставить полный домен",
+  "ruleActionDomainSuffixDesc": "Сопоставить суффикс домена",
+  "ruleActionDomainKeywordDesc": "Сопоставить ключевое слово домена",
+  "ruleActionDomainRegexDesc": "Сопоставление по маске, поддерживает только * и ?",
+  "ruleActionGeositeDesc": "Сопоставить домены внутри Geosite",
+  "ruleActionIpCidrDesc": "Сопоставить диапазон IP-адресов",
+  "ruleActionIpCidr6Desc": "Сопоставить диапазон IP-адресов (IP-CIDR6 — это просто псевдоним)",
+  "ruleActionIpSuffixDesc": "Сопоставить диапазон суффиксов IP",
+  "ruleActionIpAsnDesc": "Сопоставить ASN IP-адреса",
+  "ruleActionGeoipDesc": "Сопоставить код страны IP-адреса",
+  "ruleActionSrcGeoipDesc": "Сопоставить код страны исходного IP",
+  "ruleActionSrcIpAsnDesc": "Сопоставить ASN исходного IP",
+  "ruleActionSrcIpCidrDesc": "Сопоставить диапазон исходных IP-адресов",
+  "ruleActionSrcIpSuffixDesc": "Сопоставить диапазон исходных суффиксов IP",
+  "ruleActionDstPortDesc": "Сопоставить диапазон портов назначения запроса",
+  "ruleActionSrcPortDesc": "Сопоставить диапазон портов источника запроса",
+  "ruleActionInPortDesc": "Сопоставить входящий порт",
+  "ruleActionInTypeDesc": "Сопоставить входящий тип",
+  "ruleActionInUserDesc": "Сопоставить входящее имя пользователя, поддерживает несколько имен через /",
+  "ruleActionInNameDesc": "Сопоставить входящее имя",
+  "ruleActionProcessPathDesc": "Сопоставить по полному пути процесса",
+  "ruleActionProcessPathRegexDesc": "Сопоставить по регулярному выражению пути процесса",
+  "ruleActionProcessNameDesc": "Сопоставить по имени процесса, на Android соответствует имени пакета",
+  "ruleActionProcessNameRegexDesc": "Сопоставить по регулярному выражению имени процесса, на Android соответствует имени пакета",
+  "ruleActionUidDesc": "Сопоставить Linux USER ID",
+  "ruleActionNetworkDesc": "Сопоставить TCP или UDP",
+  "ruleActionDscpDesc": "Сопоставить метку DSCP (только для tproxy udp inbound)",
+  "ruleActionRuleSetDesc": "Ссылка на набор правил, требуется настройка rule-providers",
+  "ruleActionAndDesc": "Логическое правило AND",
+  "ruleActionOrDesc": "Логическое правило OR",
+  "ruleActionNotDesc": "Логическое правило NOT",
+  "ruleActionSubRuleDesc": "Сопоставить с подправилом, обратите внимание на использование скобок",
+  "ruleActionMatchDesc": "Сопоставить все запросы, условия не требуются",
+  "subRuleEmpty": "Подправило пусто",
+  "proxyProvidersNotEmpty": "Провайдеры прокси не могут быть пустыми",
+  "contentNotEmpty": "Содержимое не может быть пустым",
+  "subRuleNotEmpty": "Подправило не может быть пустым",
+  "splitStrategyNotEmpty": "Стратегия разделения не может быть пустой",
+  "proxyProvidersEmpty": "Провайдеры прокси пусты",
+  "timeout": "Таймаут",
+  "invalidSubRule": "{subRule} является недопустимым подправилом",
+  "invalidPolicy": "{target} является недопустимой политикой",
+  "invalidProxyProvider": "{providerName} является недопустимым провайдером прокси",
+  "invalidProxy": "{proxyName} является недопустимым прокси",
+  "proxyGroupDetectedAbnormal": "Обнаружена аномалия текущей группы прокси",
+  "proxyProviderDetectedAbnormal": "Обнаружена аномалия выбранных провайдеров прокси",
+  "proxyDetectedAbnormal": "Обнаружена аномалия выбранных прокси",
+  "createProfile": "Create Profile",
+  "locationPermissionRequired": "Location Permission Required",
+  "locationPermissionGuide": "1. Open System Settings > Privacy & Security\n2. Choose Location Services\n3. Find and check {appName} in the right list\n\nAfter completing the setup, return to the app and use it normally. Thank you for your cooperation.",
+  "prerequisites": "Prerequisites",
+  "ignoreBatteryOptimization": "Ignore Battery Optimization",
+  "batteryOptimizationDesc": "To ensure background operation, please disable battery optimization for this app. Tap to go to settings.",
+  "locationPermission": "Location Permission",
+  "locationPermissionDesc": "According to system requirements, obtaining the Wi-Fi name requires you to grant location permission.",
+  "excludeSsids": "Exclude SSIDs",
+  "excludeSsidsDesc": "When connected to an excluded SSID Wi-Fi, the app running state will be automatically switched.",
+  "ssidsEmpty": "SSIDs is empty",
+  "onDemand": "On Demand",
+  "onDemandDesc": "Configure the program running state for specific scenarios"
+}

arb/intl_zh_CN.arb

@@ -129,14 +129,8 @@
   "compatibleDesc": "开启将失去部分应用能力，获得全量的Clash的支持",
   "notSelectedTip": "当前代理组无法选中",
   "tip": "提示",
-  "backupAndRecovery": "备份与恢复",
-  "backupAndRecoveryDesc": "通过WebDAV或者文件同步数据",
   "account": "账号",
   "backup": "备份",
-  "recovery": "恢复",
-  "recoveryProfiles": "仅恢复配置文件",
-  "recoveryAll": "恢复所有数据",
-  "recoverySuccess": "恢复成功",
   "backupSuccess": "备份成功",
   "noInfo": "暂无信息",
   "pleaseBindWebDAV": "请绑定WebDAV",
@@ -205,7 +199,7 @@
   "sort": "排序",
   "columns": "列数",
   "proxiesSetting": "代理设置",
-  "proxyGroup": "代理组",
+  "proxyGroup": "策略组",
   "go": "前往",
   "externalLink": "外部链接",
   "otherContributors": "其他贡献者",
@@ -219,9 +213,7 @@
   "local": "本地",
   "remote": "远程",
   "remoteBackupDesc": "备份数据到WebDAV",
-  "remoteRecoveryDesc": "通过WebDAV恢复数据",
   "localBackupDesc": "备份数据到本地",
-  "localRecoveryDesc": "通过文件恢复数据",
   "mode": "模式",
   "time": "时间",
   "source": "来源",
@@ -250,8 +242,8 @@
   "loopback": "回环解锁工具",
   "loopbackDesc": "用于UWP回环解锁",
   "providers": "提供者",
-  "proxyProviders": "代理提供者",
-  "ruleProviders": "规则提供者",
+  "proxyProviders": "代理集",
+  "ruleProviders": "规则集",
   "overrideDns": "覆写DNS",
   "overrideDnsDesc": "开启后将覆盖配置中的DNS选项",
   "status": "状态",
@@ -340,6 +332,8 @@
   "none": "无",
   "basicConfig": "基本配置",
   "basicConfigDesc": "全局修改基本配置",
+  "advancedConfig": "进阶配置",
+  "advancedConfigDesc": "提供多样化配置",
   "selectedCountTitle": "已选择 {count} 项",
   "addRule": "添加规则",
   "ruleName": "规则名称",
@@ -380,9 +374,9 @@
   "systemApp": "系统应用",
   "noNetworkApp": "无网络应用",
   "contactMe": "联系我",
-  "recoveryStrategy": "恢复策略",
-  "recoveryStrategy_override": "覆盖",
-  "recoveryStrategy_compatible": "兼容",
+  "restoreStrategy": "恢复策略",
+  "restoreStrategy_override": "覆盖",
+  "restoreStrategy_compatible": "兼容",
   "logsTest": "日志测试",
   "emptyTip": "{label}不能为空",
   "urlTip": "{label}必须为URL",
@@ -407,5 +401,190 @@
   "import": "导入",
   "importFile": "通过文件导入",
   "importUrl": "通过URL导入",
-  "autoSetSystemDns": "自动设置系统DNS"
+  "autoSetSystemDns": "自动设置系统DNS",
+  "details": "{label}详情",
+  "creationTime": "创建时间",
+  "process": "进程",
+  "host": "主机",
+  "destination": "目标地址",
+  "destinationGeoIP": "目标地理定位",
+  "destinationIPASN": "目标IP ASN",
+  "specialProxy": "特殊代理",
+  "specialRules": "特殊规则",
+  "remoteDestination": "远程目标",
+  "networkType": "网络类型",
+  "proxyChains": "代理链",
+  "log": "日志",
+  "connection": "连接",
+  "request": "请求",
+  "connected": "已连接",
+  "disconnected": "已断开",
+  "connecting": "连接中...",
+  "restartCoreTip": "您确定要重启核心吗？",
+  "forceRestartCoreTip": "您确定要强制重启核心吗？",
+  "dnsHijacking": "DNS劫持",
+  "coreStatus": "核心状态",
+  "dataCollectionTip": "数据收集说明",
+  "dataCollectionContent": "本应用使用 Firebase Crashlytics 收集崩溃信息以改进应用稳定性。\n收集的数据包括设备信息和崩溃详情，不包含个人敏感数据。\n您可以在设置中关闭此功能。",
+  "crashlytics": "崩溃分析",
+  "crashlyticsTip": "开启后，应用崩溃时自动上传不包含敏感信息的崩溃日志",
+  "appendSystemDns": "追加系统DNS",
+  "appendSystemDnsTip": "强制为配置附加系统DNS",
+  "editRule": "编辑规则",
+  "overrideMode": "覆写模式",
+  "standardModeDesc": "标准模式，覆写基本配置，提供简单追加规则能力",
+  "scriptModeDesc": "脚本模式，使用外部扩展脚本，提供一键覆写配置的能力",
+  "addedRules": "附加规则",
+  "controlGlobalAddedRules": "控制全局附加规则",
+  "overrideScript": "覆写脚本",
+  "goToConfigureScript": "前往配置脚本",
+  "editGlobalRules": "编辑全局规则",
+  "externalFetch": "外部获取",
+  "confirmForceCrashCore": "确定要强制崩溃核心？",
+  "confirmClearAllData": "确定要清除所有数据？",
+  "loading": "加载中...",
+  "loadTest": "加载测试",
+  "yearsAgo": "{count} 年前",
+  "monthsAgo": "{count} 个月前",
+  "daysAgo": "{count} 天前",
+  "hoursAgo": "{count} 小时前",
+  "minutesAgo": "{count} 分钟前",
+  "justNow": "刚刚",
+  "noLongerRemind": "不再提示",
+  "accessControlSettings": "访问控制设置",
+  "turnOn": "开启",
+  "turnOff": "关闭",
+  "coreConfigChangeDetected": "检测到核心配置更改",
+  "reload": "重载",
+  "vpnConfigChangeDetected": "检测到VPN相关配置改动",
+  "restart": "重启",
+  "speedStatistics": "网速统计",
+  "resetPageChangesTip": "当前页面存在更改，确定重置吗？",
+  "overwriteTypeCustom": "自定义",
+  "overwriteTypeCustomDesc": "自定义模式，支持完全自定义修改代理组以及规则",
+  "unknownNetworkError": "未知网络错误",
+  "networkRequestException": "网络请求异常，请稍后再试。",
+  "restoreException": "恢复异常",
+  "networkException": "网络异常，请检查连接后重试",
+  "invalidBackupFile": "无效备份文件",
+  "pruneCache": "修剪缓存",
+  "backupAndRestore": "备份与恢复",
+  "backupAndRestoreDesc": "通过WebDAV或者文件同步数据",
+  "restore": "恢复",
+  "restoreSuccess": "恢复成功",
+  "restoreFromWebDAVDesc": "通过WebDAV恢复数据",
+  "restoreFromFileDesc": "通过文件恢复数据",
+  "restoreOnlyConfig": "仅恢复配置文件",
+  "restoreAllData": "恢复所有数据",
+  "addProfile": "添加配置",
+  "delayTest": "延迟测试",
+  "proxyGroupEmpty": "策略组为空",
+  "proxyGroupNameEmpty": "策略组名称不能为空",
+  "proxyGroupNameDuplicate": "策略组名称重复",
+  "confirmExitWindow": "确定要退出当前窗口吗?",
+  "dataChangedSave": "检测到数据有更改，是否保存",
+  "selectProxyProviders": "选择代理集",
+  "proxyFilter": "节点过滤器",
+  "optional": "可选",
+  "maxFailedTimes": "最大失败次数",
+  "testInterval": "测试间隔",
+  "excludeProxyFilter": "排除节点过滤器",
+  "excludeType": "排除类型",
+  "expectedStatus": "预期状态",
+  "selectProxies": "选择代理",
+  "inputProxyGroupName": "输入策略组名称",
+  "hideFromList": "从列表中隐藏",
+  "testWhenUsed": "使用时测试",
+  "disableUDP": "禁用UDP",
+  "confirmDeleteProxyGroup": "确定要删除当前策略组吗？",
+  "ruleEmpty": "规则为空",
+  "inputRuleContent": "输入规则内容",
+  "ruleSet": "规则集",
+  "selectRuleSet": "请选择规则集",
+  "splitStrategy": "分流策略",
+  "selectSplitStrategy": "请选择分流策略",
+  "selectSubRule": "请选择子规则",
+  "noResolveHostname": "不解析主机名",
+  "matchSourceIp": "匹配来源IP",
+  "basicInfo": "基础信息",
+  "additionalParameters": "附加参数",
+  "proxyType": "代理类型",
+  "basicStrategy": "基础策略",
+  "editProxy": "编辑代理",
+  "includeAllProxyProviders": "包含所有代理集",
+  "includeAllProxyProvidersTip": "开启后将覆盖引入的代理集",
+  "addProxyProviders": "添加代理集",
+  "includeAllProxies": "包含所有代理",
+  "includeAllProxiesTip": "引入不包含策略组的所有代理，可在下方额外添加策略组",
+  "proxiesEmpty": "代理为空",
+  "addProxies": "添加代理",
+  "addProxyGroup": "添加策略组",
+  "editProxyGroup": "编辑策略组",
+  "confirmOverwriteTip": "确定后将会覆盖已有数据",
+  "configDataDetected": "检测到配置中存在数据",
+  "quickFill": "一键填入",
+  "iconUrl": "图标链接",
+  "iconRecords": "图标记录",
+  "noRecords": "暂无记录",
+  "custom": "自定义",
+  "ruleActionDomainDesc": "匹配完整域名",
+  "ruleActionDomainSuffixDesc": "匹配域名后缀",
+  "ruleActionDomainKeywordDesc": "匹配域名关键字",
+  "ruleActionDomainRegexDesc": "通配符匹配，仅支持*和?通配符",
+  "ruleActionGeositeDesc": "匹配 Geosite 内的域名",
+  "ruleActionIpCidrDesc": "匹配 IP 地址范围",
+  "ruleActionIpCidr6Desc": "匹配 IP 地址范围, IP-CIDR6 只是一个别名",
+  "ruleActionIpSuffixDesc": "匹配 IP 后缀范围",
+  "ruleActionIpAsnDesc": "匹配 IP 所属 ASN",
+  "ruleActionGeoipDesc": "匹配 IP 所属国家代码",
+  "ruleActionSrcGeoipDesc": "匹配来源 IP 所属国家代码",
+  "ruleActionSrcIpAsnDesc": "匹配来源 IP 所属 ASN",
+  "ruleActionSrcIpCidrDesc": "匹配来源 IP 地址范围",
+  "ruleActionSrcIpSuffixDesc": "匹配来源 IP 后缀范围",
+  "ruleActionDstPortDesc": "匹配请求目标端口范围",
+  "ruleActionSrcPortDesc": "匹配请求来源端口范围",
+  "ruleActionInPortDesc": "匹配入站端口",
+  "ruleActionInTypeDesc": "匹配入站类型",
+  "ruleActionInUserDesc": "匹配入站用户名，支持使用 / 分隔多个用户名",
+  "ruleActionInNameDesc": "匹配入站名称",
+  "ruleActionProcessPathDesc": "使用完整进程路径匹配",
+  "ruleActionProcessPathRegexDesc": "使用进程路径正则表达式匹配",
+  "ruleActionProcessNameDesc": "使用进程匹配，在Android平台可以匹配包名",
+  "ruleActionProcessNameRegexDesc": "使用进程名称正则表达式匹配，在Android平台可以匹配包名",
+  "ruleActionUidDesc": "匹配 Linux USER ID",
+  "ruleActionNetworkDesc": "匹配TCP或者UDP",
+  "ruleActionDscpDesc": "匹配DSCP标记 (仅限 tproxy udp 入站)",
+  "ruleActionRuleSetDesc": "引用规则集合，需配置rule-providers",
+  "ruleActionAndDesc": "逻辑规则 AND",
+  "ruleActionOrDesc": "逻辑规则 OR",
+  "ruleActionNotDesc": "逻辑规则 NOT",
+  "ruleActionSubRuleDesc": "匹配至子规则,需要注意括号的使用",
+  "ruleActionMatchDesc": "匹配所有请求，无需条件",
+  "subRuleEmpty": "子规则为空",
+  "proxyProvidersNotEmpty": "代理集不能为空",
+  "contentNotEmpty": "内容不能为空",
+  "subRuleNotEmpty": "子规则不能为空",
+  "splitStrategyNotEmpty": "分流策略不能为空",
+  "proxyProvidersEmpty": "代理集为空",
+  "timeout": "超时",
+  "invalidSubRule": "{subRule} 是一个无效的SUB_RULE",
+  "invalidPolicy": "{target} 是一个无效的策略",
+  "invalidProxyProvider": "{providerName} 是一个无效的代理集",
+  "invalidProxy": "{proxyName} 是一个无效的代理",
+  "proxyGroupDetectedAbnormal": "检测到当前策略组异常",
+  "proxyProviderDetectedAbnormal": "检测到选中的代理集存在异常",
+  "proxyDetectedAbnormal": "检测到选中的代理存在异常",
+  "createProfile": "创建配置",
+  "locationPermissionRequired": "需要位置权限",
+  "locationPermissionGuide": "1. 打开 系统设置 > 隐私与安全性\n2. 选择 定位服务\n3. 在右侧列表中找到并勾选 {appName}\n\n完成设置后，返回应用即可正常使用。感谢您的配合。",
+  "prerequisites": "前置条件",
+  "ignoreBatteryOptimization": "忽略电池优化",
+  "batteryOptimizationDesc": "为保证后台运行，请关闭本应用的电池优化。点击前往设置。",
+  "locationPermission": "位置权限",
+  "locationPermissionDesc": "根据系统要求，获取Wi-Fi名称需要您授予位置权限。",
+  "excludeSsids": "排除SSIDs",
+  "excludeSsidsDesc": "连接到被排除SSID的WIFI时，将会自动切换应用运行状态",
+  "ssidsEmpty": "SSIDs为空",
+  "onDemand": "按需运行",
+  "onDemandDesc": "配置程序特定场景运行状态"
 }