docs: Add instructions for manually integrating susfs

* New translations strings.xml (Russian)

* New translations strings.xml (Vietnamese)

* New translations strings.xml (Chinese Traditional, Hong Kong)

.github/dependabot.yml

@@ -1,28 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: github-actions
-    directory: /
-    schedule:
-      interval: daily
-    groups:
-      actions:
-        patterns:
-          - "*"
-  - package-ecosystem: cargo
-    directory: userspace/ksud
-    schedule:
-      interval: daily
-    allow:
-      - dependency-type: "all"
-    groups:
-      crates:
-        patterns:
-          - "*"
-  - package-ecosystem: gradle
-    directory: manager
-    schedule:
-      interval: daily
-    groups:
-      maven:
-        patterns:
-          - "*"

.github/workflows/build-lkm-local.yml

@@ -0,0 +1,74 @@
+name: Build LKM for KernelSU Local
+on:
+  workflow_call:
+    inputs:
+      upload:
+        required: true
+        type: boolean
+        default: true
+        description: "Whether to upload to branch"
+    secrets:
+      # username:github_pat
+      TOKEN:
+        required: true
+  workflow_dispatch:
+    inputs:
+      upload:
+        required: true
+        type: boolean
+        default: true
+        description: "Whether to upload to branch"
+jobs:
+  build-lkm:
+    strategy:
+      matrix:
+        include:
+          - version: "android12-5.10"
+            sub_level: 236
+            os_patch_level: 2025-05
+          - version: "android13-5.10"
+            sub_level: 234
+            os_patch_level: 2025-03
+          - version: "android13-5.15"
+            sub_level: 178
+            os_patch_level: 2025-03
+          - version: "android14-5.15"
+            sub_level: 178
+            os_patch_level: 2025-03
+          - version: "android14-6.1"
+            sub_level: 134
+            os_patch_level: 2025-05
+          - version: "android15-6.6"
+            sub_level: 87
+            os_patch_level: 2025-05
+    # uses: ./.github/workflows/gki-kernel-mock.yml when debugging
+    uses: ./.github/workflows/gki-kernel-local.yml
+    with:
+      version: ${{ matrix.version }}
+      version_name: ${{ matrix.version }}.${{ matrix.sub_level }}
+      tag: ${{ matrix.version }}-${{ matrix.os_patch_level }}
+      os_patch_level: ${{ matrix.os_patch_level }}
+      build_lkm: true
+
+  push-to-branch:
+    needs: [build-lkm]
+    runs-on: self-hosted
+    if: ${{ inputs.upload }}
+    steps:
+      - name: Download all workflow run artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: bin/
+          merge-multiple: true
+      - name: Push to branch LKM
+        run: |
+          cd bin
+          git config --global init.defaultBranch lkm
+          git init
+          git remote add origin https://${{ secrets.TOKEN }}@github.com/${{ github.repository }}
+          git config --local user.name "github-actions[bot]"
+          git config --local user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          find . -type f
+          git add .
+          git commit -m "Upload LKM from ${{ github.sha }}" -m "https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}"
+          git push --force --set-upstream origin lkm

.github/workflows/build-lkm.yml

@@ -3,9 +3,9 @@ on:
   workflow_call:
     inputs:
       upload:
-        required: false
+        required: true
         type: boolean
-        default: false
+        default: true
         description: "Whether to upload to branch"
     secrets:
       # username:github_pat
@@ -14,9 +14,9 @@ on:
   workflow_dispatch:
     inputs:
       upload:
-        required: false
+        required: true
         type: boolean
-        default: false
+        default: true
         description: "Whether to upload to branch"
 jobs:
   build-lkm:
@@ -24,23 +24,23 @@ jobs:
       matrix:
         include:
           - version: "android12-5.10"
-            sub_level: 233
-            os_patch_level: 2025-02
+            sub_level: 236
+            os_patch_level: 2025-05
           - version: "android13-5.10"
-            sub_level: 228
-            os_patch_level: 2025-01
+            sub_level: 234
+            os_patch_level: 2025-03
           - version: "android13-5.15"
-            sub_level: 170
-            os_patch_level: 2025-01
+            sub_level: 178
+            os_patch_level: 2025-03
           - version: "android14-5.15"
-            sub_level: 170
-            os_patch_level: 2025-01
+            sub_level: 178
+            os_patch_level: 2025-03
           - version: "android14-6.1"
-            sub_level: 128
-            os_patch_level: 2025-03
+            sub_level: 134
+            os_patch_level: 2025-05
           - version: "android15-6.6"
-            sub_level: 77
-            os_patch_level: 2025-03
+            sub_level: 87
+            os_patch_level: 2025-05
     # uses: ./.github/workflows/gki-kernel-mock.yml when debugging
     uses: ./.github/workflows/gki-kernel.yml
     with:

.github/workflows/build-manager-manual.yml

@@ -0,0 +1,252 @@
+name: Build Manager Manual
+
+on:
+  workflow_dispatch:
+    inputs:
+      build_lkm:
+        required: true
+        type: choice
+        default: "auto"
+        options:
+          - "true"
+          - "false"
+          - "auto"
+        description: "Whether to build lkm"
+      upload_lkm:
+        required: true
+        type: boolean
+        default: true
+        description: "Whether to upload lkm"
+jobs:
+  check-build-lkm:
+    runs-on: self-hosted
+    outputs:
+      build_lkm: ${{ steps.check-build.outputs.build_lkm }}
+      upload_lkm: ${{ steps.check-build.outputs.upload_lkm }}
+    steps:
+      - name: check build
+        id: check-build
+        run: |
+          if [ "${{ github.event_name }}" == "workflow_dispatch" ] && [ "${{ inputs.build_lkm }}" != "auto" ]; then
+            kernel_changed="${{ inputs.build_lkm }}"
+          else
+            kernel_changed=true
+            mkdir tmp
+            cd tmp
+            git config --global init.defaultBranch bot
+            git config --global user.name 'Bot'
+            git config --global user.email 'bot@github.shirkneko.io'
+            git init .
+            git remote add origin https://github.com/${{ github.repository }}
+            CURRENT_COMMIT="${{ github.event.head_commit.id }}"
+            git fetch origin $CURRENT_COMMIT --depth=1
+            git fetch origin lkm --depth=1
+            LKM_COMMIT="$(git log --format=%B -n 1 origin/lkm | head -n 1)"
+            LKM_COMMIT="${LKM_COMMIT#Upload LKM from }"
+            LKM_COMMIT=$(echo "$LKM_COMMIT" | tr -d '[:space:]')
+            echo "LKM_COMMIT=$LKM_COMMIT"
+            git fetch origin "$LKM_COMMIT" --depth=1
+            git diff --quiet "$LKM_COMMIT" "$CURRENT_COMMIT" -- kernel :!kernel/setup.sh .github/workflows/build-lkm-local.yml .github/workflows/build-kernel-*.yml && kernel_changed=false
+            cd ..
+            rm -rf tmp
+          fi
+          if [ "${{ github.event_name }}" == "push" ] && [ "${{ github.ref }}" == 'refs/heads/main' ]; then
+            need_upload=true
+          elif [ "${{ github.event_name }}" == "workflow_dispatch" ]; then
+            need_upload="${{ inputs.upload_lkm }}"
+          else
+            need_upload=false
+          fi
+          echo "kernel changed: $kernel_changed"
+          echo "need upload: $need_upload"
+          echo "build_lkm=$kernel_changed" >> "$GITHUB_OUTPUT"
+          echo "upload_lkm=$need_upload" >> "$GITHUB_OUTPUT"
+
+  build-lkm:
+    needs: check-build-lkm
+    uses: ./.github/workflows/build-lkm-local.yml
+    if: ${{ needs.check-build-lkm.outputs.build_lkm == 'true' }}
+    with:
+      upload: ${{ needs.check-build-lkm.outputs.upload_lkm == 'true' }}
+    secrets: inherit
+  build-susfs:
+    if: ${{ always() }}
+    needs: [ check-build-lkm, build-lkm ]
+    strategy:
+      matrix:
+        include:
+          - target: aarch64-linux-android
+            os: ubuntu-latest
+    uses: ./.github/workflows/susfs.yml
+    with:
+      target: ${{ matrix.target }}
+      os: ${{ matrix.os }}
+      
+  build-kpmmgr:
+    if: ${{ always() }}
+    needs: [ check-build-lkm, build-lkm ]
+    strategy:
+      matrix:
+        include:
+          - target: aarch64-linux-android
+            os: ubuntu-latest
+    uses: ./.github/workflows/kpmmgr.yml
+    with:
+      target: ${{ matrix.target }}
+      os: ${{ matrix.os }}
+
+  build-ksud:
+    if: ${{ always() }}
+    needs: [ check-build-lkm, build-lkm ]
+    strategy:
+      matrix:
+        include:
+          - target: aarch64-linux-android
+            os: ubuntu-latest
+          - target: x86_64-linux-android
+            os: ubuntu-latest
+          - target: armv7-linux-androideabi
+            os: ubuntu-latest
+    uses: ./.github/workflows/ksud.yml
+    with:
+      target: ${{ matrix.target }}
+      os: ${{ matrix.os }}
+      pack_lkm: true
+      pull_lkm: ${{ needs.check-build-lkm.outputs.build_lkm != 'true' }}
+
+  build-manager:
+    if: ${{ always() }}
+    needs: build-ksud
+    runs-on: self-hosted
+    defaults:
+      run:
+        working-directory: ./manager
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup need_upload
+        id: need_upload
+        run: |
+          if [ ! -z "${{ secrets.BOT_TOKEN }}" ]; then
+            echo "UPLOAD=true" >> $GITHUB_OUTPUT
+          else
+            echo "UPLOAD=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Write key
+        if: ${{ ( github.event_name != 'pull_request' && github.ref == 'refs/heads/main' ) || github.ref == 'refs/heads/susfs' || github.ref_type == 'tag' }}
+        run: |
+          if [ ! -z "${{ secrets.KEYSTORE }}" ]; then
+            {
+              echo KEYSTORE_PASSWORD='${{ secrets.KEYSTORE_PASSWORD }}'
+              echo KEY_ALIAS='${{ secrets.KEY_ALIAS }}'
+              echo KEY_PASSWORD='${{ secrets.KEY_PASSWORD }}'
+              echo KEYSTORE_FILE='key.jks'
+            } >> gradle.properties
+            echo "${{ secrets.KEYSTORE }}" | base64 -d > key.jks
+          fi
+                  
+      - name: Download arm64 susfs
+        uses: actions/download-artifact@v4
+        with:
+          name: susfs-aarch64-linux-android
+          path: .
+
+      - name: Download arm64 kpmmgr
+        uses: actions/download-artifact@v4
+        with:
+          name: kpmmgr-aarch64-linux-android
+          path: .
+
+      - name: Download arm64 ksud
+        uses: actions/download-artifact@v4
+        with:
+          name: ksud-aarch64-linux-android
+          path: .
+
+      - name: Download x86_64 ksud
+        uses: actions/download-artifact@v4
+        with:
+          name: ksud-x86_64-linux-android
+          path: .
+
+      - name: Download arm ksud
+        uses: actions/download-artifact@v4
+        with:
+          name: ksud-armv7-linux-androideabi
+          path: .
+  
+      - name: Copy ksud to app jniLibs
+        run: |
+          mkdir -p app/src/main/jniLibs/arm64-v8a
+          mkdir -p app/src/main/jniLibs/x86_64
+          mkdir -p app/src/main/jniLibs/armeabi-v7a
+          cp -f ../aarch64-linux-android/release/zakozako ../manager/app/src/main/jniLibs/arm64-v8a/libzakozako.so
+          cp -f ../x86_64-linux-android/release/zakozako ../manager/app/src/main/jniLibs/x86_64/libzakozako.so
+          cp -f ../armv7-linux-androideabi/release/zakozako ../manager/app/src/main/jniLibs/armeabi-v7a/libzakozako.so
+
+      - name: Copy kpmmgr to app jniLibs
+        run: |
+          mkdir -p app/src/main/jniLibs/arm64-v8a
+          cp -f ../arm64-v8a/kpmmgr ../manager/app/src/main/jniLibs/arm64-v8a/libkpmmgr.so
+      
+      - name: Copy susfs to app jniLibs
+        run: |
+          mkdir -p app/src/main/jniLibs/arm64-v8a
+          cp -f ../arm64-v8a/zakozakozako ../manager/app/src/main/jniLibs/arm64-v8a/libzakozakozako.so
+
+      - name: Build with Gradle
+        run: |
+          export ANDROID_HOME=/root/.android/sdk
+          export PATH=$ANDROID_HOME/platform-tools:$ANDROID_HOME/tools:$ANDROID_HOME/tools/bin:$PATH
+          {
+            echo 'org.gradle.parallel=true'
+            echo 'org.gradle.vfs.watch=true'
+            echo 'org.gradle.jvmargs=-Xmx2048m'
+            echo 'android.native.buildOutput=verbose'
+          } >> gradle.properties
+          sed -i 's/org.gradle.configuration-cache=true//g' gradle.properties
+          ./gradlew clean assembleRelease
+
+      - name: Upload build artifact
+        uses: actions/upload-artifact@v4
+        if: ${{ ( github.event_name != 'pull_request' && github.ref == 'refs/heads/main' ) || github.ref_type == 'tag' }}
+        with:
+          name: manager
+          path: manager/app/build/outputs/apk/release/*.apk
+
+      - name: Upload mappings
+        uses: actions/upload-artifact@v4
+        if: ${{ ( github.event_name != 'pull_request' && github.ref == 'refs/heads/main' ) || github.ref_type == 'tag' }}
+        with:
+          name: "mappings"
+          path: "manager/app/build/outputs/mapping/release/"
+      
+      - name: Bot session cache
+        if: github.event_name != 'pull_request' && steps.need_upload.outputs.UPLOAD == 'true'
+        id: bot_session_cache
+        uses: actions/cache@v4
+        with:
+          path: scripts/ksubot.session
+          key: ${{ runner.os }}-bot-session
+
+      - name: Upload to telegram
+        if: github.event_name != 'pull_request' && steps.need_upload.outputs.UPLOAD == 'true'
+        env:
+          CHAT_ID: ${{ vars.CHAT_ID }}
+          BOT_TOKEN: ${{ secrets.BOT_TOKEN }}
+          MESSAGE_THREAD_ID: ${{ vars.MESSAGE_THREAD_ID }}
+          COMMIT_MESSAGE: ${{ github.event.head_commit.message }}
+          COMMIT_URL: ${{ github.event.head_commit.url }}
+          RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+          TITLE: Manager
+        run: |
+          if [ ! -z "${{ secrets.BOT_TOKEN }}" ]; then
+            export VERSION=$(git rev-list --count HEAD)
+            APK=$(find ./app/build/outputs/apk/release -name "*.apk")
+            python3 $GITHUB_WORKSPACE/scripts/ksubot.py $APK
+          fi

.github/workflows/build-manager.yml

@@ -8,7 +8,7 @@ on:
       - 'manager/**'
       - 'kernel/**'
       - 'userspace/ksud/**'
-      - 'userspace/zakomksd/**'
+      - 'userspace/susfs/**'
       - 'userspace/kpmmgr/**'
   pull_request:
     branches: [ "main" ]
@@ -29,7 +29,7 @@ on:
       upload_lkm:
         required: true
         type: boolean
-        default: false
+        default: true
         description: "Whether to upload lkm"
 jobs:
   check-build-lkm:
@@ -64,7 +64,7 @@ jobs:
             cd ..
             rm -rf tmp
           fi
-          if [ "${{ github.event_name }}" == "push" ] && [ "${{ github.ref }}" == 'refs/heads/susfs' ]; then
+          if [ "${{ github.event_name }}" == "push" ] && [ "${{ github.ref }}" == 'refs/heads/main' ]; then
             need_upload=true
           elif [ "${{ github.event_name }}" == "workflow_dispatch" ]; then
             need_upload="${{ inputs.upload_lkm }}"
@@ -83,7 +83,7 @@ jobs:
     with:
       upload: ${{ needs.check-build-lkm.outputs.upload_lkm == 'true' }}
     secrets: inherit
-  build-zakomksd:
+  build-susfs:
     if: ${{ always() }}
     needs: [ check-build-lkm, build-lkm ]
     strategy:
@@ -91,7 +91,7 @@ jobs:
         include:
           - target: aarch64-linux-android
             os: ubuntu-latest
-    uses: ./.github/workflows/zakomksd.yml
+    uses: ./.github/workflows/susfs.yml
     with:
       target: ${{ matrix.target }}
       os: ${{ matrix.os }}
@@ -119,6 +119,8 @@ jobs:
             os: ubuntu-latest
           - target: x86_64-linux-android
             os: ubuntu-latest
+          - target: armv7-linux-androideabi
+            os: ubuntu-latest
     uses: ./.github/workflows/ksud.yml
     with:
       target: ${{ matrix.target }}
@@ -174,10 +176,10 @@ jobs:
       - name: Setup Android SDK
         uses: android-actions/setup-android@v3
 
-      - name: Download arm64 zakomksd
+      - name: Download arm64 susfs
         uses: actions/download-artifact@v4
         with:
-          name: zakomksd-aarch64-linux-android
+          name: susfs-aarch64-linux-android
           path: .
 
       - name: Download arm64 kpmmgr
@@ -198,22 +200,30 @@ jobs:
           name: ksud-x86_64-linux-android
           path: .
 
+      - name: Download arm ksud
+        uses: actions/download-artifact@v4
+        with:
+          name: ksud-armv7-linux-androideabi
+          path: .
+  
       - name: Copy ksud to app jniLibs
         run: |
           mkdir -p app/src/main/jniLibs/arm64-v8a
           mkdir -p app/src/main/jniLibs/x86_64
-          cp -f ../aarch64-linux-android/release/zakomk ../manager/app/src/main/jniLibs/arm64-v8a/libzakomk.so
-          cp -f ../x86_64-linux-android/release/zakomk ../manager/app/src/main/jniLibs/x86_64/libzakomk.so
+          mkdir -p app/src/main/jniLibs/armeabi-v7a
+          cp -f ../aarch64-linux-android/release/zakozako ../manager/app/src/main/jniLibs/arm64-v8a/libzakozako.so
+          cp -f ../x86_64-linux-android/release/zakozako ../manager/app/src/main/jniLibs/x86_64/libzakozako.so
+          cp -f ../armv7-linux-androideabi/release/zakozako ../manager/app/src/main/jniLibs/armeabi-v7a/libzakozako.so
 
       - name: Copy kpmmgr to app jniLibs
         run: |
           mkdir -p app/src/main/jniLibs/arm64-v8a
           cp -f ../arm64-v8a/kpmmgr ../manager/app/src/main/jniLibs/arm64-v8a/libkpmmgr.so
       
-      - name: Copy zakomksd to app jniLibs
+      - name: Copy susfs to app jniLibs
         run: |
           mkdir -p app/src/main/jniLibs/arm64-v8a
-          cp -f ../arm64-v8a/zakomksd ../manager/app/src/main/jniLibs/arm64-v8a/libzakomksd.so
+          cp -f ../arm64-v8a/zakozakozako ../manager/app/src/main/jniLibs/arm64-v8a/libzakozakozako.so
 
       - name: Build with Gradle
         run: |

.github/workflows/crowdin.yml

@@ -0,0 +1,38 @@
+name: Crowdin Action
+
+on:
+  push:
+    branches: [ main ]
+    paths:
+      - 'manager/app/src/main/res/**'
+
+jobs:
+  synchronize-with-crowdin:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: crowdin action
+        uses: crowdin/github-action@master
+        with:
+          upload_sources: true
+          upload_translations: true
+          download_translations: true
+          localization_branch_name: "Crowdin"
+          crowdin_branch_name: "main"
+          create_pull_request: true
+          pull_request_title: 'New Crowdin Translations'
+          pull_request_body: 'New Crowdin translations by [Crowdin GH Action](https://github.com/crowdin/github-action)'
+          pull_request_base_branch_name: 'main'
+          skip_untranslated_files: true
+        env:
+          # A classic GitHub Personal Access Token with the 'repo' scope selected (the user should have write access to the repository).
+          GITHUB_TOKEN: ${{ secrets.GH_TOKEN }}
+
+          # A numeric ID, found at https://crowdin.com/project/<projectName>/tools/api
+          CROWDIN_PROJECT_ID: ${{ secrets.CROWDIN_PROJECT_ID }}
+
+          # Visit https://crowdin.com/settings#api-key to create this token
+          CROWDIN_PERSONAL_TOKEN: ${{ secrets.CROWDIN_PERSONAL_TOKEN }}

.github/workflows/gki-kernel-local.yml

@@ -0,0 +1,252 @@
+name: GKI Kernel Build Local
+
+on:
+  workflow_call:
+    inputs:
+      version:
+        required: true
+        type: string
+        description: >
+          Output directory of gki,
+          for example: android12-5.10
+      version_name:
+        required: true
+        type: string
+        description: >
+          With SUBLEVEL of kernel,
+          for example: android12-5.10.66
+      tag:
+        required: true
+        type: string
+        description: >
+          Part of branch name of common kernel manifest,
+          for example: android12-5.10-2021-11
+      os_patch_level:
+        required: false
+        type: string
+        description: >
+          Patch level of common kernel manifest,
+          for example: 2021-11
+        default: 2022-05
+      patch_path:
+        required: false
+        type: string
+        description: >
+          Directory name of .github/patches/<patch_path>
+          for example: 5.10
+      use_cache:
+        required: false
+        type: boolean
+        default: true
+      embed_ksud:
+        required: false
+        type: string
+        default: ksud-aarch64-linux-android
+        description: >
+          Artifact name of prebuilt ksud to be embedded
+          for example: ksud-aarch64-linux-android
+      debug:
+        required: false
+        type: boolean
+        default: false
+      build_lkm:
+        required: false
+        type: boolean
+        default: false
+    secrets:
+      BOOT_SIGN_KEY:
+        required: false
+      CHAT_ID:
+        required: false
+      BOT_TOKEN:
+        required: false
+      MESSAGE_THREAD_ID:
+        required: false
+
+jobs:
+  build:
+    name: Build ${{ inputs.version_name }}
+    runs-on: self-hosted
+    env:
+      CCACHE_COMPILERCHECK: "%compiler% -dumpmachine; %compiler% -dumpversion"
+      CCACHE_NOHASHDIR: "true"
+      CCACHE_HARDLINK: "true"
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          path: KernelSU
+          fetch-depth: 0
+
+      - name: Setup need_upload
+        id: need_upload
+        run: |
+          if [ ! -z "${{ secrets.BOT_TOKEN }}" ]; then
+            echo "UPLOAD=true" >> $GITHUB_OUTPUT
+          else
+            echo "UPLOAD=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Setup kernel source
+        run: |
+          echo "Free space:"
+          df -h
+          cd $GITHUB_WORKSPACE
+          sudo apt-get install repo -y
+          export REPO_URL='https://mirrors.tuna.tsinghua.edu.cn/git/git-repo'
+          mkdir android-kernel && cd android-kernel
+          repo init --depth=1 --u https://mirrors.tuna.tsinghua.edu.cn/git/AOSP/kernel/manifest -b common-${{ inputs.tag }} --repo-rev=v2.35
+          REMOTE_BRANCH=$(git ls-remote https://mirrors.tuna.tsinghua.edu.cn/git/AOSP/kernel/common ${{ inputs.tag }})
+          DEFAULT_MANIFEST_PATH=.repo/manifests/default.xml
+          if grep -q deprecated <<< $REMOTE_BRANCH; then
+            echo "Found deprecated branch: ${{ inputs.tag }}"
+            sed -i 's/"${{ inputs.tag }}"/"deprecated\/${{ inputs.tag }}"/g' $DEFAULT_MANIFEST_PATH
+            cat $DEFAULT_MANIFEST_PATH
+          fi
+          repo --version
+          repo --trace sync -c -j$(nproc --all) --no-tags
+          df -h
+
+      - name: Setup KernelSU
+        env:
+          PATCH_PATH: ${{ inputs.patch_path }}
+          IS_DEBUG_KERNEL: ${{ inputs.debug }}
+        run: |
+          cd $GITHUB_WORKSPACE/android-kernel
+          echo "[+] KernelSU setup"
+          GKI_ROOT=$(pwd)
+          echo "[+] GKI_ROOT: $GKI_ROOT"
+          echo "[+] Copy KernelSU driver to $GKI_ROOT/common/drivers"
+          ln -sf $GITHUB_WORKSPACE/KernelSU/kernel $GKI_ROOT/common/drivers/kernelsu
+          echo "[+] Add KernelSU driver to Makefile"
+          DRIVER_MAKEFILE=$GKI_ROOT/common/drivers/Makefile
+          DRIVER_KCONFIG=$GKI_ROOT/common/drivers/Kconfig
+          grep -q "kernelsu" "$DRIVER_MAKEFILE" || printf "\nobj-\$(CONFIG_KSU) += kernelsu/\n" >> "$DRIVER_MAKEFILE"
+          grep -q "kernelsu" "$DRIVER_KCONFIG" || sed -i "/endmenu/i\\source \"drivers/kernelsu/Kconfig\"" "$DRIVER_KCONFIG"
+          echo "[+] Apply Compilation Patches"
+          if [ ! -e build/build.sh ]; then
+            GLIBC_VERSION=$(ldd --version 2>/dev/null | head -n 1 | awk '{print $NF}')
+            echo "GLIBC_VERSION: $GLIBC_VERSION"
+            if [ "$(printf '%s\n' "2.38" "$GLIBC_VERSION" | sort -V | head -n1)" = "2.38" ]; then
+              echo "Patching resolve_btfids/Makefile"
+              cd $GKI_ROOT/common/ && sed -i '/\$(Q)\$(MAKE) -C \$(SUBCMD_SRC) OUTPUT=\$(abspath \$(dir \$@))\/ \$(abspath \$@)/s//$(Q)$(MAKE) -C $(SUBCMD_SRC) EXTRA_CFLAGS="$(CFLAGS)" OUTPUT=$(abspath $(dir $@))\/ $(abspath $@)/' tools/bpf/resolve_btfids/Makefile || echo "No patch needed."
+            fi
+          fi
+
+          if [ "$IS_DEBUG_KERNEL" = "true" ]; then
+            echo "[+] Enable debug features for kernel"
+            printf "\nccflags-y += -DCONFIG_KSU_DEBUG\n" >> $GITHUB_WORKSPACE/KernelSU/kernel/Makefile
+          fi
+          repo status
+          echo "[+] KernelSU setup done."
+
+      - name: Symbol magic
+        run: |
+          echo "[+] Export all symbol from abi_gki_aarch64.xml"
+          COMMON_ROOT=$GITHUB_WORKSPACE/android-kernel/common
+          KSU_ROOT=$GITHUB_WORKSPACE/KernelSU
+          ABI_XML=$COMMON_ROOT/android/abi_gki_aarch64.xml
+          SYMBOL_LIST=$COMMON_ROOT/android/abi_gki_aarch64
+          # python3 $KSU_ROOT/scripts/abi_gki_all.py $ABI_XML > $SYMBOL_LIST
+          echo "[+] Add KernelSU symbols"
+          cat $KSU_ROOT/kernel/export_symbol.txt | awk '{sub("[ \t]+","");print "  "$0}' >> $SYMBOL_LIST
+
+      - name: Setup ccache
+        if: inputs.use_cache == true
+        uses: hendrikmuhs/ccache-action@v1
+        with:
+          key: gki-kernel-aarch64-${{ inputs.version_name }}
+          max-size: 2G
+          save: ${{ github.event_name == 'push' && github.ref == 'refs/heads/main' }}
+
+      - name: Setup for LKM
+        if: ${{ inputs.build_lkm == true }}
+        working-directory: android-kernel
+        run: |
+          pip install ast-grep-cli
+          sudo apt-get install llvm-15 -y
+          ast-grep -U -p '$$$ check_exports($$$) {$$$}' -r '' common/scripts/mod/modpost.c
+          ast-grep -U -p 'check_exports($$$);' -r '' common/scripts/mod/modpost.c
+          sed -i '/config KSU/,/help/{s/default y/default m/}' common/drivers/kernelsu/Kconfig
+          echo "drivers/kernelsu/kernelsu.ko" >> common/android/gki_aarch64_modules
+
+          # bazel build, android14-5.15, android14-6.1 use bazel
+          if [ ! -e build/build.sh ]; then
+            sed -i 's/needs unknown symbol/Dont abort when unknown symbol/g' build/kernel/*.sh || echo "No unknown symbol scripts found"
+            if [ -e common/modules.bzl ]; then
+              sed -i 's/_COMMON_GKI_MODULES_LIST = \[/_COMMON_GKI_MODULES_LIST = \[ "drivers\/kernelsu\/kernelsu.ko",/g' common/modules.bzl
+            fi
+          else
+            TARGET_FILE="build/kernel/build.sh"
+            if [ ! -e "$TARGET_FILE" ]; then
+              TARGET_FILE="build/build.sh"
+            fi
+            sed -i 's/needs unknown symbol/Dont abort when unknown symbol/g' $TARGET_FILE || echo "No unknown symbol in $TARGET_FILE"
+            sed -i 's/if ! diff -u "\${KERNEL_DIR}\/\${MODULES_ORDER}" "\${OUT_DIR}\/modules\.order"; then/if false; then/g' $TARGET_FILE
+            sed -i 's@${ROOT_DIR}/build/abi/compare_to_symbol_list@echo@g' $TARGET_FILE
+            sed -i 's/needs unknown symbol/Dont abort when unknown symbol/g' build/kernel/*.sh || echo "No unknown symbol scripts found"
+          fi
+
+      - name: Make working directory clean to avoid dirty
+        working-directory: android-kernel
+        run: |
+          if [  -e common/BUILD.bazel ]; then
+            sed -i '/^[[:space:]]*"protected_exports_list"[[:space:]]*:[[:space:]]*"android\/abi_gki_protected_exports_aarch64",$/d' common/BUILD.bazel
+          fi
+          rm common/android/abi_gki_protected_exports_* || echo "No protected exports!"
+          git config --global user.email "bot@kernelsu.org"
+          git config --global user.name "KernelSUBot"
+          cd common/ && git add -A && git commit -a -m "Add KernelSU"
+          repo status
+
+      - name: Build Kernel/LKM
+        working-directory: android-kernel
+        run: |
+          if [ ! -z ${{ vars.EXPECTED_SIZE }} ] && [ ! -z ${{ vars.EXPECTED_HASH }} ]; then
+            export KSU_EXPECTED_SIZE=${{ vars.EXPECTED_SIZE }}
+            export KSU_EXPECTED_HASH=${{ vars.EXPECTED_HASH }}
+          fi
+          if [ -e build/build.sh ]; then
+            LTO=thin BUILD_CONFIG=common/build.config.gki.aarch64 build/build.sh CC="/usr/bin/ccache clang"
+          else
+            tools/bazel run --disk_cache=/home/runner/.cache/bazel --config=fast --config=stamp --lto=thin //common:kernel_aarch64_dist -- --dist_dir=dist
+          fi
+
+      - name: Prepare artifacts
+        id: prepareArtifacts
+        run: |
+          OUTDIR=android-kernel/out/${{ inputs.version }}/dist
+          if [ ! -e $OUTDIR ]; then
+            OUTDIR=android-kernel/dist
+          fi
+          mkdir output
+          if [ "${{ inputs.build_lkm}}" = "true" ]; then 
+            llvm-strip-15 -d $OUTDIR/kernelsu.ko
+            mv $OUTDIR/kernelsu.ko ./output/${{ inputs.version }}_kernelsu.ko
+          else
+            cp $OUTDIR/Image ./output/
+            cp $OUTDIR/Image.lz4 ./output/
+            git clone https://github.com/Kernel-SU/AnyKernel3
+            rm -rf ./AnyKernel3/.git
+            cp $OUTDIR/Image ./AnyKernel3/
+          fi
+
+      - name: Upload Image and Image.gz
+        uses: actions/upload-artifact@v4
+        if: ${{ inputs.build_lkm == false }}
+        with:
+          name: Image-${{ inputs.version_name }}_${{ inputs.os_patch_level }}
+          path: ./output/*
+
+      - name: Upload AnyKernel3
+        if: ${{ inputs.build_lkm == false }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: AnyKernel3-${{ inputs.version_name }}_${{ inputs.os_patch_level }}
+          path: ./AnyKernel3/*
+
+      - name: Upload LKM
+        uses: actions/upload-artifact@v4
+        if: ${{ inputs.build_lkm == true }}
+        with:
+          name: ${{ inputs.version }}-lkm
+          path: ./output/*_kernelsu.ko

.github/workflows/gki-kernel.yml

@@ -198,6 +198,9 @@ jobs:
       - name: Make working directory clean to avoid dirty
         working-directory: android-kernel
         run: |
+          if [  -e common/BUILD.bazel ]; then
+            sed -i '/^[[:space:]]*"protected_exports_list"[[:space:]]*:[[:space:]]*"android\/abi_gki_protected_exports_aarch64",$/d' common/BUILD.bazel
+          fi
           rm common/android/abi_gki_protected_exports_* || echo "No protected exports!"
           git config --global user.email "bot@kernelsu.org"
           git config --global user.name "KernelSUBot"

.github/workflows/ksud.yml

@@ -71,4 +71,4 @@ jobs:
       uses: actions/upload-artifact@v4
       with:
         name: ksud-${{ inputs.target }}
-        path: userspace/ksud/target/**/release/zakomk*
+        path: userspace/ksud/target/**/release/zakozako*

.github/workflows/susfs.yml

@@ -1,11 +1,11 @@
-name: Build zakomksd
+name: Build susfs
 
 on:
   push:
     branches: [ "mian" ]
     paths:
-      - '.github/workflows/zakomksd.yml'
-      - 'userspace/zakomksd/**'
+      - '.github/workflows/susfs.yml'
+      - 'userspace/susfs/**'
   workflow_dispatch:
   workflow_call:
     inputs:
@@ -19,7 +19,7 @@ on:
 
 jobs:
   build-susfs:
-    name: Build userspace zakomksd
+    name: Build userspace susfs
     runs-on: ubuntu-latest
 
     steps:
@@ -28,13 +28,13 @@ jobs:
         with:
           fetch-depth: 0
 
-      - name: Build zakomksd
-        working-directory: ./userspace/zakomksd
+      - name: Build susfs
+        working-directory: ./userspace/susfs
         run: |
           $ANDROID_NDK_HOME/ndk-build
 
       - name: Upload a Build Artifact
         uses: actions/upload-artifact@v4
         with:
-          name: zakomksd-aarch64-linux-android
-          path: ./userspace/zakomksd/libs
+          name: susfs-aarch64-linux-android
+          path: ./userspace/susfs/libs

crowdin.yml

@@ -0,0 +1,3 @@
+files:
+  - source: /manager/app/src/main/res/values/strings.xml
+    translation: /manager/app/src/main/res/values-%two_letters_code%/strings.xml

docs/README-en.md

@@ -1,101 +1,141 @@
-# SukiSU
+# SukiSU Ultra
 
-**Enlish** | [简体中文](README.md)
+**English** | [简体中文](README.md) | [日本語](README-ja.md) | [Türkçe](README-tr.md)
 
+Android device root solution based on [KernelSU](https://github.com/tiann/KernelSU)
 
-Android device root solution based on [KernelSU](https://github.com/KernelSU/KernelSU)
-
-**Experimental! Use at your own risk! **This solution is based on [KernelSU]() and is experimental!
+**Experimental! Use at your own risk!** This solution is based on [KernelSU](https://github.com/tiann/KernelSU) and is experimental!
 
+> This is an unofficial fork. All rights are reserved to [@tiann](https://github.com/tiann)
 >
-> This is an unofficial fork, all rights reserved [@tiann](https://github.com/tiann)
->
-
-- Fully adapted for non-GKI devices (susfs-dev and unsusfs-patched dev branches only)
+> However, we will be a separately maintained branch of KSU in the future
 
 ## How to add
 
-Using the susfs-dev branch (integrated susfs with support for non-GKI devices)
+Using main branching (non-GKI device builds are not supported) (requires manual integration of susfs)
 ```
-curl -LSs "https://raw.githubusercontent.com/ShirkNeko/SukiSU-Ultra/main/kernel/setup.sh" | bash -s susfs-dev
+curl -LSs "https://raw.githubusercontent.com/SukiSU-Ultra/SukiSU-Ultra/main/kernel/setup.sh" | bash -s main
 ```
 
-Use main branching (no longer with support for non-GKI devices)
+Using branches that support non-GKI devices (requires manual integration of susfs)
 ```
-curl -LSs "https://raw.githubusercontent.com/ShirkNeko/SukiSU-Ultra/main/kernel/setup.sh" | bash -s main
+curl -LSs "https://raw.githubusercontent.com/SukiSU-Ultra/SukiSU-Ultra/main/kernel/setup.sh" | bash -s nongki
 ```
 
 ## How to use integrated susfs
 
-Use the susfs-dev branch directly without any patching
+1. Use the susfs-dev branch directly without any patching
+
+```
+curl -LSs "https://raw.githubusercontent.com/SukiSU-Ultra/SukiSU-Ultra/main/kernel/setup.sh" | bash -s susfs-dev
+```
+
+## KPM Support
+
+- Based on KernelPatch, we have removed duplicates of KSU and kept only KPM support.
+- We will introduce more APatch-compatible functions to ensure the integrity of KPM functionality.
+
+We will introduce more APatch-compatible functions to ensure the completeness of KPM functionality.
+
+KPM templates: https://github.com/udochina/KPM-Build-Anywhere
+
+> [!Note]
+> 1. `CONFIG_KPM=y` needs to be added.
+> 2. Non-GKI devices need to add `CONFIG_KALLSYMS=y` and `CONFIG_KALLSYMS_ALL=y` as well.
+> 3. Some kernel source code below `4.19` also needs to be backport from `4.19` to the header file `set_memory.h`.
+
+## How to do a system update to retain ROOT
+- After OTA, don't reboot first, go to the manager flashing/patching kernel interface, find `GKI/non_GKI install` and select the Anykernel3 kernel zip file that needs to be flashed, select the slot that is opposite to the current running slot of the system for flashing, and then reboot to retain the GKI mode update （This method is not supported for all non-GKI devices, so please try it yourself. It is the safest way to use TWRP for non-GKI devices.）
+- Or use LKM mode to install to the unused slot (after OTA).
+
+## Compatibility Status
+- KernelSU (versions prior to v1.0.0) officially supports Android GKI 2.0 devices (kernel 5.10+)
+
+- Older kernels (4.4+) are also compatible, but the kernel must be built manually
+
+- KernelSU can support 3.x kernels (3.4-3.18) through additional reverse ports
+
+- Currently supports `arm64-v8a`, `armeabi-v7a (bare)` and some `X86_64`
 
 
 ## More links
+
+**If you need to submit a translation for the manager go to** https://crowdin.com/project/SukiSU-Ultra
+
 Projects compiled based on Sukisu and susfs
 - [GKI](https://github.com/ShirkNeko/GKI_KernelSU_SUSFS) 
 - [OnePlus](https://github.com/ShirkNeko/Action_OnePlus_MKSU_SUSFS)
 
 ## Hook method
-- This method references the hook manual to (https://github.com/rsuntk/KernelSU)
+- This method references the hook method from (https://github.com/rsuntk/KernelSU)
 
 1. **KPROBES hook:**
-    - This fork only supports GKI (5.10 - 6.x) kernels, all non-GKI kernels must use manual hooks.
-    - For Loadable Kernel Modules (LKM)
-    - Default hooking method for GKI kernels
-    - Requires `CONFIG_KPROBES=y`. 2.
-2. **Hooks manual:**
-    - For GKI (5.10 - 6.x) kernels, add `CONFIG_KSU_MANUAL_HOOK=y` to the kernel defconfig and make sure to protect KernelSU hooks by using `#ifdef CONFIG_KSU_MANUAL_HOOK` instead of `#ifdef CONFIG_KSU`.
-    - Standard KernelSU hooks: https://kernelsu.org/guide/how-to-integrate-for-non-gki.html#manually-modify-the-kernel-source
-    - backslashxx syscall hooks: https://github.com/backslashxx/KernelSU/issues/5
-    - Some non-GKI devices that manually integrate KPROBES do not require the manual VFS hook `new_hook.patch` patch
+    - Also used for Loadable Kernel Module (LKM)
+    - Default hook method on GKI kernels.
+    - Need `CONFIG_KPROBES=y`
 
+2. **Manual hook:**
+    - Standard KernelSU hook: https://kernelsu.org/guide/how-to-integrate-for-non-gki.html#manually-modify-the-kernel-source
+    - backslashxx's syscall manual hook: https://github.com/backslashxx/KernelSU/issues/5
+    - Default hook method on Non-GKI kernels.
+    - Need `CONFIG_KSU_MANUAL_HOOK=y`
 
 ## Usage
-[GKI]
-1. such as millet redmi samsung and other devices (does not include the magic kernel manufacturers such as: meizu, a plus real me oppo)
-2. find more links in the GKI build project to find the device kernel version directly download with TWRP or kernel flashing tool to brush into the zip with AnyKernel3 suffix can be
-3. General without the suffix of the .zip compressed package is universal, gz suffix for the special TianGui models, lz4 suffix for Google models, general brush without the suffix can be!
 
-[OnePlus]
-1. Find the Yiga project in the More link and fill in your own, then build it with cloud compilation, and finally brush in the zip with AnyKernel3 suffix.
-Note: You only need to fill in the first two kernel versions, such as 5.10, 5.15, 6.1, 6.6.
-- Please search for the processor codename by yourself, usually it is all English without numbers.
-- Branching and configuration files, please fill in the kernel open source address.
+### Universal GKI
+
+Please **all** refer to https://kernelsu.org/zh_CN/guide/installation.html
+
+> [!Note]
+> 1. for devices with GKI 2.0 such as Xiaomi, Redmi, Samsung, etc. (excludes kernel-modified manufacturers such as Meizu, OnePlus, Zenith, and oppo)
+> 2. Find the GKI build in [more links](#%E6%9B%B4%E5%A4%9A%E9%93%BE%E6%8E%A5). Find the device kernel version. Then download it and use TWRP or kernel flashing tool to flash the zip file with AnyKernel3 suffix.
+> 3. The .zip archive without suffix is uncompressed, the gz suffix is the compression used by Tenguet models.
 
 
+### OnePlus
+
+1. Use the link mentioned in the 'More Links' section to create a customized build with your device information, and then flash the zip file with the AnyKernel3 suffix.
+
+> [!Note]
+> - You only need to fill in the first two parts of kernel versions, such as 5.10, 5.15, 6.1, or 6.6.
+> - Please search for the processor codename by yourself, usually it is all English without numbers.
+> - You can find the branch and configuration files from the OnePlus open-source kernel repository.
 
 ## Features
 
 1. Kernel-based `su` and root access management.
-2. Not based on [OverlayFS](https://en.wikipedia.org/wiki/OverlayFS) module system. 3.
-3. [Application Profiles](https://kernelsu.org/guide/app-profile.html): Lock root privileges in a cage. 4.
+2. Not based on [OverlayFS](https://en.wikipedia.org/wiki/OverlayFS) module system, but based on [Magic Mount](https://github.com/5ec1cff/KernelSU) from 5ec1cff
+3. [App Profile](https://kernelsu.org/guide/app-profile.html): Lock root privileges in a cage. 
 4. Bringing back non-GKI/GKI 1.0 support
 5. More customization
-
-
+6. Support for KPM kernel modules
 
 ## License
 
-- The file in the “kernel” directory is [GPL-2.0-only](https://www.gnu.org/licenses/old-licenses/gpl-2.0.en.html).
-- All other parts except the “kernel” directory are [GPL-3.0 or later](https://www.gnu.org/licenses/gpl-3.0.html).
+- The file in the “kernel” directory is under [GPL-2.0-only](https://www.gnu.org/licenses/old-licenses/gpl-2.0.en.html) license.
+
+- The images of the files `ic_launcher*` with anime character emoticons are copyrighted by [五十根大虾仁](https://space.bilibili.com/370927), the Brand Intellectual Property in the images is owned by [明风OuO](https://space.bilibili.com/274939213), and the vectorization is done by @MiRinChan. Before using these files, in addition to complying with [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode.txt), you also need to comply with the authorization of the two authors to use these artistic contents.
+
+- Except for the files or directories mentioned above, all other parts are under [GPL-3.0 or later](https://www.gnu.org/licenses/gpl-3.0.html) license.
 
 ## Sponsorship list
+
 - [Ktouls](https://github.com/Ktouls) Thanks so much for bringing me support
 - [zaoqi123](https://github.com/zaoqi123) It's not a bad idea to buy me a milk tea
 - [wswzgdg](https://github.com/wswzgdg) Many thanks for supporting this project
+- [yspbwx2010](https://github.com/yspbwx2010) Many thanks
+- [DARKWWEE](https://github.com/DARKWWEE) Thanks for the 100 USDT Lao
 
-
-
-
-How the above list does not have your name, I will keep you updated, thanks again for your support!
+If the above list does not have your name, I will update it as soon as possible, and thanks again for your support!
 
 ## Contributions
 
 - [KernelSU](https://github.com/tiann/KernelSU): original project
 - [MKSU](https://github.com/5ec1cff/KernelSU): Used project
-- [RKSU](https://github.com/rsuntk/KernelsU)：Re-support of non-GKI devices using the kernel of this project
+- [RKSU](https://github.com/rsuntk/KernelsU): Reintroduced the support of non-GKI devices using the kernel of this project
 - [susfs](https://gitlab.com/simonpunk/susfs4ksu)：Used susfs file system
 - [KernelSU](https://git.zx2c4.com/kernel-assisted-superuser/about/): KernelSU conceptualization
 - [Magisk](https://github.com/topjohnwu/Magisk): Powerful root utility
 - [genuine](https://github.com/brevent/genuine/): APK v2 Signature Verification
-- [Diamorphine](https://github.com/m0nad/Diamorphine): Some rootkit skills.
+- [Diamorphine](https://github.com/m0nad/Diamorphine): Some rootkit utilities.
+- [KernelPatch](https://github.com/bmax121/KernelPatch): KernelPatch is a key part of the APatch implementation of the kernel module

docs/README-ja.md

@@ -0,0 +1,137 @@
+# SukiSU Ultra
+
+**日本語** | [简体中文](README.md) | [English](README-en.md) | [Türkçe](README-tr.md)
+
+[KernelSU](https://github.com/tiann/KernelSU) をベースとした Android デバイスの root ソリューション
+
+**試験中なビルドです！自己責任で使用してください！**<br>
+このソリューションは [KernelSU](https://github.com/tiann/KernelSU) に基づいていますが、試験中なビルドです。
+
+> これは非公式なフォークです。すべての権利は [@tiann](https://github.com/tiann) に帰属します。
+>
+> ただし、将来的には KSU とは別に管理されるブランチとなる予定です。
+
+## 追加方法
+
+メイン分岐の使用（GKI デバイス以外のビルドはサポートされていません。） (手動によるサスフ統合が必要)
+```
+curl -LSs "https://raw.githubusercontent.com/SukiSU-Ultra/SukiSU-Ultra/main/kernel/setup.sh" | bash -s main
+```
+
+GKI以外のデバイスをサポートするブランチを使用する (手動によるサスフ統合が必要)
+```
+curl -LSs "https://raw.githubusercontent.com/SukiSU-Ultra/SukiSU-Ultra/main/kernel/setup.sh" | bash -s nongki
+```
+
+## 統合された susfs の使い方
+
+1. パッチを当てずに susfs-dev ブランチを直接使用してください。
+```
+curl -LSs "https://raw.githubusercontent.com/SukiSU-Ultra/SukiSU-Ultra/main/kernel/setup.sh" | bash -s susfs-dev
+```
+
+## KPM に対応
+
+- KernelPatch に基づいて重複した KSU の機能を削除、KPM の対応を維持させています。
+- KPM 機能の整合性を確保するために、APatch の互換機能を更に向上させる予定です。
+
+オープンソースアドレス: https://github.com/ShirkNeko/SukiSU_KernelPatch_patch
+
+KPM テンプレートのアドレス: https://github.com/udochina/KPM-Build-Anywhere
+
+> [!Note]
+> 1. `CONFIG_KPM=y` が必要である。
+> 2.非 GKI デバイスには `CONFIG_KALLSYMS=y` と `CONFIG_KALLSYMS_ALL=y` も必要です。
+> 3.いくつかのカーネル `4.19` およびそれ以降のソースコードでは、 `4.19` からバックポートされた `set_memory.h` ヘッダーファイルも必要です。
+
+
+## ROOT を保持するシステムアップデートの方法
+- OTAの後、最初に再起動せず、マネージャのフラッシュ/パッチカーネルインターフェイスに移動し、`GKI/non_GKI 取り付け`を見つけ、フラッシュする必要があるAnykernel3カーネルzipファイルを選択し、フラッシュするためにシステムの現在の実行スロットと反対のスロットを選択し、GKIモードアップデートを保持するために再起動します（この方法は、現時点ではすべてのnon_GKIデバイスでサポートされていませんので、各自でお試しください。 (この方法は、すべての非GKIデバイスでサポートされていませんので、ご自身でお試しください)。
+- または、LKMモードを使用して未使用のスロットにインストールします(OTA後)。
+
+## 互換性ステータス
+- KernelSU（v1.0.0より前のバージョン）はAndroid GKI 2.0デバイス（カーネル5.10以上）を公式にサポートしています。
+
+- 古いカーネル（4.4+）も互換性がありますが、カーネルは手動でビルドする必要があります。
+
+- KernelSU は追加のリバースポートを通じて 3.x カーネル (3.4-3.18) をサポートしています。
+
+- 現在は `arm64-v8a`、`armeabi-v7a (bare)`、いくつかの `X86_64` をサポートしています。
+
+## その他のリンク
+
+**監督に翻訳を提出する必要がある場合は、https://crowdin.com/project/SukiSU-Ultra。
+
+- [GKI](https://github.com/ShirkNeko/GKI_KernelSU_SUSFS) 
+- [OnePlus](https://github.com/ShirkNeko/Action_OnePlus_MKSU_SUSFS)
+
+## フックの方式
+
+- この方式は (https://github.com/rsuntk/KernelSU) のフック方式を参照してください。
+
+1. **KPROBES フック:**
+    - 読み込み可能なカーネルモジュールの場合 (LKM)
+    - GKI カーネルのデフォルトとなるフック方式
+    - `CONFIG_KPROBES=y` が必要です
+
+2. **手動でフック:**
+    - 標準の KernelSU フック: https://kernelsu.org/guide/how-to-integrate-for-non-gki.html#manually-modify-the-kernel-source
+    - backslashxx syscall フック: https://github.com/backslashxx/KernelSU/issues/5
+    - 非 GKI カーネル用のデフォルトフッキングメソッド
+    - `CONFIG_KSU_MANUAL_HOOK=y` が必要です
+
+## 使い方
+
+### ユニバーサルGKI
+
+https://kernelsu.org/zh_CN/guide/installation.html をご参照ください。
+
+> [!Note]
+> 1.Xiaomi、Redmi、Samsung などの GKI 2.0 を搭載したデバイス用 (Meizu、Yiga、Zenith、oppo などのマジックカーネルを搭載したメーカーは除く)。
+> 2. [more links](#%E6%9B%B4%E5%A4%9A%E9%93%BE%E6%8E%A5) で GKI ビルドを検索します。 デバイスのカーネルバージョンを検索します。 次に、それをダウンロードし、TWRPまたはカーネルフラッシングツールを使用して、AnyKernel3の接尾辞が付いたzipファイルをフラッシュします。
+> 接尾辞なしの.zipアーカイブは非圧縮で、接尾辞gzはTenguetモデルで使用されている圧縮方法です。
+### OnePlus
+
+1. `その他のリンク`の項目に記載されているリンクを開き、デバイス情報を使用してカスタマイズされたカーネルをビルドし、AnyKernel3 の接頭辞を持つ .zip ファイルをフラッシュします。
+
+> [!Note]
+> - 5.10、5.15、6.1、6.6 などのカーネルバージョンの最初の 2 文字のみを入力する必要があります。
+> - SoC のコードネームは自分で検索してください。通常は、数字がなく英語表記のみです。
+> - ブランチと構成ファイルは、OnePlus オープンソースカーネルリポジトリから見つけることができます。
+
+## 機能
+
+1. カーネルベースな `su` および root アクセスの管理。
+2. [OverlayFS](https://en.wikipedia.org/wiki/OverlayFS) モジュールシステムではなく、 5ec1cff 氏の [Magic Mount](https://github.com/5ec1cff/KernelSU) に基づいています。
+3. [アプリプロファイル](https://kernelsu.org/guide/app-profile.html): root 権限をケージ内にロックします。 
+4. 非 GKI / GKI 1.0 の対応を復活
+5. その他のカスタマイズ
+6. KPM カーネルモジュールに対応
+
+## ライセンス
+
+- `kernel` ディレクトリ以下のファイルは[GPL-2.0-only](https://www.gnu.org/licenses/old-licenses/gpl-2.0.en.html)です。
+- アニメキャラクターの絵文字を含むファイル `ic_launcher*` の画像は[五十根大虾仁](https://space.bilibili.com/370927)が著作権を所有しており、画像内のブランド知的財産権は[明风OuO](https://space.bilibili.com/274939213)が所有しています。ベクトル化は @MiRinChan が行っています。これらのファイルを使用する前に、[Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode.txt)に準拠することに加えて、これらの芸術コンテンツを使用するには、2人の著者の許可にも従う必要があります。
+- 上記のファイルまたはディレクトリを除き、その他のすべての部分は[GPL-3.0以降](https://www.gnu.org/licenses/gpl-3.0.html)です。
+
+## スポンサーシップの一覧
+
+- [Ktouls](https://github.com/Ktouls) 応援をしてくれたことに感謝。
+- [zaoqi123](https://github.com/zaoqi123) ミルクティーを買ってあげるのも良い考えですね。
+- [wswzgdg](https://github.com/wswzgdg) このプロジェクトを支援していただき、ありがとうございます。
+- [yspbwx2010](https://github.com/yspbwx2010) どうもありがとう。
+- [DARKWWEE](https://github.com/DARKWWEE) ラオウ100USDTありがとう！
+
+上記の一覧にあなたの名前がない場合は、できるだけ早急に更新しますので再度ご支援をお願いします。
+
+## 貢献者
+
+- [KernelSU](https://github.com/tiann/KernelSU): オリジナルのプロジェクトです。
+- [MKSU](https://github.com/5ec1cff/KernelSU): 使用しているプロジェクトです。
+- [RKSU](https://github.com/rsuntk/KernelsU): このプロジェクトのカーネルを使用して非 GKI デバイスのサポートを追加しています。
+- [susfs](https://gitlab.com/simonpunk/susfs4ksu)：使用している susfs ファイルシステムです。
+- [KernelSU](https://git.zx2c4.com/kernel-assisted-superuser/about/): KernelSU について。
+- [Magisk](https://github.com/topjohnwu/Magisk): パワフルな root ユーティリティです。
+- [genuine](https://github.com/brevent/genuine/): APK v2 署名認証で使用しています。
+- [Diamorphine](https://github.com/m0nad/Diamorphine): いくつかの rootkit ユーティリティを使用しています。
+- [KernelPatch](https://github.com/bmax121/KernelPatch): KernelPatch はカーネルモジュールの APatch 実装での重要な部分となります。

docs/README-tr.md

@@ -0,0 +1,151 @@
+# SukiSU Ultra
+
+**Türkçe** | [简体中文](README.md) | [English](README-en.md) | [日本語](README-ja.md)
+
+[KernelSU](https://github.com/tiann/KernelSU) tabanlı Android cihaz root çözümü
+
+**Deneysel! Kullanım riski size aittir!**
+
+> Bu resmi olmayan bir daldır, tüm hakları saklıdır [@tiann](https://github.com/tiann)
+>
+> Ancak, gelecekte ayrı bir KSU dalı olarak devam edeceğiz
+
+## Nasıl Eklenir
+
+Çekirdek kaynak kodunun kök dizininde aşağıdaki komutları çalıştırın:
+
+Ana dalı kullanın (GKI olmayan cihazlar için desteklenmez)
+
+```
+curl -LSs "https://raw.githubusercontent.com/SukiSU-Ultra/SukiSU-Ultra/main/kernel/setup.sh" | bash -s main
+```
+
+GKI olmayan cihazları destekleyen dalı kullanın
+
+```
+curl -LSs "https://raw.githubusercontent.com/SukiSU-Ultra/SukiSU-Ultra/main/kernel/setup.sh" | bash -s nongki
+```
+
+## susfs Nasıl Entegre Edilir
+
+1. Doğrudan susfs-stable veya susfs-dev dalını kullanın, susfs entegrasyonuna gerek yok
+
+```
+curl -LSs "https://raw.githubusercontent.com/SukiSU-Ultra/SukiSU-Ultra/main/kernel/setup.sh" | bash -s susfs-dev
+```
+
+## Kanca Yöntemleri
+
+- Bu bölüm [rsuntk\'nin kanca yöntemlerinden](https://github.com/rsuntk/KernelSU) alıntılanmıştır
+
+1. **KPROBES Kancası:**
+
+   - Yüklenebilir çekirdek modülleri (LKM) için kullanılır
+   - GKI 2.0 çekirdeğinin varsayılan kanca yöntemi
+   - `CONFIG_KPROBES=y` gerektirir
+
+2. **Manuel Kanca:**
+   - Standart KernelSU kancası: https://kernelsu.org/guide/how-to-integrate-for-non-gki.html#manually-modify-the-kernel-source
+   - backslashxx\'nin syscall manuel kancası: https://github.com/backslashxx/KernelSU/issues/5
+   - GKI olmayan çekirdeğin varsayılan kanca yöntemi
+   - `CONFIG_KSU_MANUAL_HOOK=y` gerektirir
+
+## KPM Desteği
+
+- KernelPatch tabanlı olarak KSU ile çakışan işlevleri kaldırdık ve yalnızca KPM desteğini koruduk
+- APatch ile daha fazla uyumlu fonksiyon ekleyerek KPM işlevlerinin bütünlüğünü sağlayacağız
+
+Kaynak kodu: https://github.com/ShirkNeko/SukiSU_KernelPatch_patch
+
+KPM şablonu: https://github.com/udochina/KPM-Build-Anywhere
+
+> [!Note]
+>
+> 1. `CONFIG_KPM=y` gerektirir
+> 2. GKI olmayan cihazlar ayrıca `CONFIG_KALLSYMS=y` ve `CONFIG_KALLSYMS_ALL=y` gerektirir
+> 3. Bazı çekirdek `4.19` altı kaynak kodları, `4.19`dan geri taşınan başlık dosyası `set_memory.h` gerektirir
+
+## Sistem Güncellemesini Yaparak ROOT\'u Koruma
+
+- OTA\'dan sonra hemen yeniden başlatmayın, yöneticiye girin ve çekirdek yazma/onarma arayüzüne gidin, `GKI/non_GKI yükleme` seçeneğini bulun ve Anykernel3 çekirdek sıkıştırma dosyasını seçin, şu anda sistemin çalıştığı yuva ile zıt yuvaya yazın ve yeniden başlatın, böylece GKI modu güncellemesini koruyabilirsiniz (şu anda tüm GKI olmayan cihazlar bu yöntemi desteklemiyor, lütfen kendiniz deneyin. GKI olmayan cihazlar için TWRP kullanmak en güvenlidir)
+- Veya kullanılmayan yuvaya LKM modunu kullanarak yükleyin (OTA\'dan sonra)
+
+## Uyumluluk Durumu
+
+- KernelSU (v1.0.0 öncesi sürümler) resmi olarak Android GKI 2.0 cihazlarını destekler (çekirdek 5.10+)
+
+- Eski çekirdekler (4.4+) de uyumludur, ancak çekirdeği manuel olarak oluşturmanız gerekir
+
+- Daha fazla geri taşımayla KernelSU, 3.x çekirdeğini (3.4-3.18) destekleyebilir
+
+- Şu anda `arm64-v8a`, `armeabi-v7a (bare)` ve bazı `X86_64` desteklenmektedir
+
+## Daha Fazla Bağlantı
+
+SukiSU ve susfs tabanlı derlenen projeler
+
+- [GKI](https://github.com/ShirkNeko/GKI_KernelSU_SUSFS)
+- [OnePlus](https://github.com/ShirkNeko/Action_OnePlus_MKSU_SUSFS)
+
+## Kullanım Yöntemi
+
+### Evrensel GKI
+
+Lütfen **tümünü** https://kernelsu.org/zh_CN/guide/installation.html adresinden inceleyin
+
+> [!Note]
+>
+> 1. Xiaomi, Redmi, Samsung gibi GKI 2.0 cihazlar için uygundur (Meizu, OnePlus, Realme ve Oppo gibi değiştirilmiş çekirdekli üreticiler hariç)
+> 2. [Daha fazla bağlantı](#daha-fazla-bağlantı) bölümündeki GKI tabanlı projeleri bulun. Cihaz çekirdek sürümünü bulun. Ardından indirin ve TWRP veya çekirdek yazma aracı kullanarak AnyKernel3 soneki olan sıkıştırılmış paketi yazın
+> 3. Genellikle sonek olmayan .zip sıkıştırılmış paketler sıkıştırılmamıştır, gz soneki olanlar ise Dimensity modelleri için kullanılan sıkıştırma yöntemidir
+
+### OnePlus
+
+1. Daha fazla bağlantı bölümündeki OnePlus projesini bulun ve kendiniz doldurun, ardından bulut derleme yapın ve AnyKernel3 soneki olan sıkıştırılmış paketi yazın
+
+> [!Note]
+>
+> - Çekirdek sürümü için yalnızca ilk iki haneyi doldurmanız yeterlidir, örneğin 5.10, 5.15, 6.1, 6.6
+> - İşlemci kod adını kendiniz arayın, genellikle tamamen İngilizce ve sayı içermeden oluşur
+> - Dal ve yapılandırma dosyasını kendiniz OnePlus çekirdek kaynak kodundan doldurun
+
+## Özellikler
+
+1. Çekirdek tabanlı `su` ve root erişim yönetimi
+2. 5ec1cff\'nin [Magic Mount](https://github.com/5ec1cff/KernelSU) tabanlı modül sistemi
+3. [App Profile](https://kernelsu.org/guide/app-profile.html): root yetkilerini kafeste kilitleyin
+4. GKI 2.0 olmayan çekirdekler için desteğin geri getirilmesi
+5. Daha fazla özelleştirme özelliği
+6. KPM çekirdek modülleri için destek
+
+## Lisans
+
+- `kernel` dizinindeki dosyalar [GPL-2.0-only](https://www.gnu.org/licenses/old-licenses/gpl-2.0.en.html) lisansı altındadır.
+- Anime karakter ifadeleri içeren `ic_launcher*` dosyalarının görüntüleri [五十根大虾仁](https://space.bilibili.com/370927) tarafından telif hakkıyla korunmaktadır, görüntülerdeki Marka Fikri Mülkiyeti [明风 OuO](https://space.bilibili.com/274939213)'ye aittir ve vektörleştirme @MiRinChan tarafından yapılmıştır. Bu dosyaları kullanmadan önce, [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode.txt) ile uyumlu olmanın yanı sıra, bu sanatsal içerikleri kullanmak için iki yazarın yetkilendirmesine de uymanız gerekir.
+- Yukarıda belirtilen dosyalar veya dizinler hariç, diğer tüm parçalar [GPL-3.0 veya üzeri](https://www.gnu.org/licenses/gpl-3.0.html)'dir.
+
+## Afdian Bağlantısı
+
+- https://afdian.com/a/shirkneko
+
+## Sponsor Listesi
+
+- [Ktouls](https://github.com/Ktouls) Bana sağladığınız destek için çok teşekkür ederim
+- [zaoqi123](https://github.com/zaoqi123) Bana sütlü çay ısmarlamanız da güzel
+- [wswzgdg](https://github.com/wswzgdg) Bu projeye olan desteğiniz için çok teşekkür ederim
+- [yspbwx2010](https://github.com/yspbwx2010) Çok teşekkür ederim
+- [DARKWWEE](https://github.com/DARKWWEE) 100 USDT için teşekkürler
+
+Eğer yukarıdaki listede adınız yoksa, zamanında güncelleyeceğim, herkese tekrar teşekkür ederim
+
+## Katkıda Bulunanlar
+
+- [KernelSU](https://github.com/tiann/KernelSU): Orijinal proje
+- [MKSU](https://github.com/5ec1cff/KernelSU): Kullanılan proje
+- [RKSU](https://github.com/rsuntk/KernelsU): GKI olmayan cihazlar için destek sağlayan proje
+- [susfs4ksu](https://gitlab.com/simonpunk/susfs4ksu): Kullanılan susfs dosya sistemi
+- [kernel-assisted-superuser](https://git.zx2c4.com/kernel-assisted-superuser/about/): KernelSU fikri
+- [Magisk](https://github.com/topjohnwu/Magisk): Güçlü root aracı
+- [genuine](https://github.com/brevent/genuine/): APK v2 imza doğrulama
+- [Diamorphine](https://github.com/m0nad/Diamorphine): Bazı rootkit becerileri
+- [KernelPatch](https://github.com/bmax121/KernelPatch): KernelPatch, APatch\'in çekirdek modüllerini uygulamak için kritik bir parçadır

docs/README.md

@@ -1,103 +1,153 @@
-# SukiSU
+# SukiSU Ultra
 
-**简体中文** | [English](README-en.md)
+**简体中文** | [English](README-en.md) | [日本語](README-ja.md) | [Türkçe](README-tr.md)
 
 基于 [KernelSU](https://github.com/tiann/KernelSU) 的安卓设备 root 解决方案
 
-**实验性!使用风险自负!**
+**实验性! 使用风险自负!**
 
-
->
 > 这是非官方分支，保留所有权利 [@tiann](https://github.com/tiann)
 >
-
+> 但是，我们将会在未来成为一个单独维护的 KSU 分支
 
 ## 如何添加
+
 在内核源码的根目录下执行以下命令：
 
-使用 susfs-dev 分支（已集成susfs，带非GKI设备的支持）
+使用 main 分支 (不支持非 GKI 设备构建) (需要手动集成 susfs)
+
 ```
-curl -LSs "https://raw.githubusercontent.com/ShirkNeko/SukiSU-Ultra/main/kernel/setup.sh" | bash -s susfs-dev
+curl -LSs "https://raw.githubusercontent.com/SukiSU-Ultra/SukiSU-Ultra/main/kernel/setup.sh" | bash -s main
 ```
 
-使用 main 分支（不再带非GKI设备的支持）
+使用支持非 GKI 设备的分支 (需要手动集成 susfs)
+
 ```
-curl -LSs "https://raw.githubusercontent.com/ShirkNeko/SukiSU-Ultra/main/kernel/setup.sh" | bash -s main
+curl -LSs "https://raw.githubusercontent.com/SukiSU-Ultra/SukiSU-Ultra/main/kernel/setup.sh" | bash -s nongki
 ```
 
 ## 如何集成 susfs
 
-1. 直接使用 susfs-dev 分支，不需要再集成 susfs
+1. 直接使用 susfs-stable 或者 susfs-dev 分支，不需要再集成 susfs
 
+```
+curl -LSs "https://raw.githubusercontent.com/SukiSU-Ultra/SukiSU-Ultra/main/kernel/setup.sh" | bash -s susfs-dev
+```
 
 ## 钩子方法
+
 - 此部分引用自 [rsuntk 的钩子方法](https://github.com/rsuntk/KernelSU)
 
 1. **KPROBES 钩子：**
-    - 此方法仅支持 GKI 2.0（5.10 - 6.x）内核,所有非 GKI 2.0 内核都必须使用手动钩子
-    - 用于可加载内核模块 (LKM)
-    - GKI 2.0 内核的默认钩子方法
-    - 需要 `CONFIG_KPROBES=y`
-2. **手动钩子：**
-    - 对于 GKI 2.0（5.10 - 6.x）内核，需要在对应设备的 defconfig 文件中添加 `CONFIG_KSU_MANUAL_HOOK=y` 并确保使用 `#ifdef CONFIG_KSU_MANUAL_HOOK` 而不是 `#ifdef CONFIG_KSU` 来保护 KernelSU 钩子
-    - 标准的 KernelSU 钩子：https://kernelsu.org/guide/how-to-integrate-for-non-gki.html#manually-modify-the-kernel-source
-    - backslashxx 的 syscall 手动钩子：https://github.com/backslashxx/KernelSU/issues/5
-    - 部分手动集成KPROBES的非 GKI 2.0 设备不需要手动 VFS 钩子 `new_hook.patch` 补丁
 
+   - 用于可加载内核模块 (LKM)
+   - GKI 2.0 内核的默认钩子方法
+   - 需要 `CONFIG_KPROBES=y`
+
+2. **手动钩子：**
+   - 标准的 KernelSU 钩子：https://kernelsu.org/guide/how-to-integrate-for-non-gki.html#manually-modify-the-kernel-source
+   - backslashxx 的 syscall 手动钩子：https://github.com/backslashxx/KernelSU/issues/5
+   - 非 GKI 内核的默认挂钩方法
+   - 需要 `CONFIG_KSU_MANUAL_HOOK=y`
+
+## KPM 支持
+
+- 我们基于 KernelPatch 去掉了和 KSU 重复的功能，仅保留了 KPM 支持
+- 我们将会引入更多的兼容 APatch 的函数来确保 KPM 功能的完整性
+
+开源地址: https://github.com/ShirkNeko/SukiSU_KernelPatch_patch
+
+KPM 模板地址: https://github.com/udochina/KPM-Build-Anywhere
+
+> [!Note]
+>
+> 1. 需要 `CONFIG_KPM=y`
+> 2. 非 GKI 设备还需要 `CONFIG_KALLSYMS=y` 和 `CONFIG_KALLSYMS_ALL=y`
+> 3. 部分内核 `4.19` 以下源码还需要从 `4.19` 向后移植头文件 `set_memory.h`
+
+## 如何进行系统更新保留 ROOT
+
+- OTA 后先不要重启，进入管理器刷写/修补内核界面，找到 `GKI/non_GKI安装` 选择需要刷写的 Anykernel3 内核压缩文件，选择与现在系统运行槽位相反的槽位进行刷写并重启即可保留 GKI 模式更新（暂不支持所有非 GKI 设备使用这种方法，请自行尝试。非 GKI 设备使用 TWRP 刷写是最稳妥的）
+- 或者使用 LKM 模式的安装到未使用的槽位（OTA 后）
+
+## 兼容状态
+
+- KernelSU（v1.0.0 之前版本）正式支持 Android GKI 2.0 设备（内核 5.10+）
+
+- 旧内核（4.4+）也兼容，但必须手动构建内核
+
+- 通过更多的反向移植，KernelSU 可以支持 3.x 内核（3.4-3.18）
+
+- 目前支持 `arm64-v8a` ，`armeabi-v7a (bare)` 和部分 `X86_64`
 
 ## 更多链接
+
+**如果你需要为管理器提交翻译请前往** https://crowdin.com/project/SukiSU-Ultra
+
 基于 SukiSU 和 susfs 编译的项目
+
 - [GKI](https://github.com/ShirkNeko/GKI_KernelSU_SUSFS)
 - [一加](https://github.com/ShirkNeko/Action_OnePlus_MKSU_SUSFS)
 
-
 ## 使用方法
 
-### GKI
-1. 适用于如小米红米三星等的 GKI 2.0 的设备（不包含魔改内核的厂商如魅族、一加、真我和 oppo）
-2. 找到更多链接里的 GKI 构建的项目找到设备内核版本直接下载用TWRP或者内核刷写工具刷入带 AnyKernel3 后缀的压缩包即可
-3. 一般不带后缀的 .zip 压缩包是通用，gz 后缀的为天玑机型专用，lz4 后缀的为谷歌系机型专用，一般刷不带后缀的即可
+### 普适的 GKI
+
+请**全部**参考 https://kernelsu.org/zh_CN/guide/installation.html
+
+> [!Note]
+>
+> 1. 适用于如小米、红米、三星等的 GKI 2.0 的设备 (不包含魔改内核的厂商如魅族、一加、真我和 oppo)
+> 2. 找到[更多链接](#%E6%9B%B4%E5%A4%9A%E9%93%BE%E6%8E%A5)里的 GKI 构建的项目。找到设备内核版本。然后下载下来，用 TWRP 或者内核刷写工具刷入带 AnyKernel3 后缀的压缩包即可
+> 3. 一般不带后缀的 .zip 压缩包是未压缩的，gz 后缀的为天玑机型所使用的压缩方式
 
 ### 一加
+
 1.找到更多链接里的一加项目进行自行填写，然后云编译构建，最后刷入带 AnyKernel3 后缀的压缩包即可
 
-注意事项：
-- 内核版本只需要填写前两位即可，如 5.10，5.15，6.1，6.6
-- 处理器代号请自行搜索，一般为全英文不带数字的代号
-- 分支和配置文件请自行到一加内核开源地址进行填写
-
+> [!Note]
+>
+> - 内核版本只需要填写前两位即可，如 5.10，5.15，6.1，6.6
+> - 处理器代号请自行搜索，一般为全英文不带数字的代号
+> - 分支和配置文件请自行到一加内核开源地址进行填写
 
 ## 特点
 
 1. 基于内核的 `su` 和 root 访问管理
 2. 基于 5ec1cff 的 [Magic Mount](https://github.com/5ec1cff/KernelSU) 的模块系统
 3. [App Profile](https://kernelsu.org/guide/app-profile.html)：将 root 权限锁在笼子里
-4. 恢复对非 GKI 2.0 内核的支持（仅限susfs-dev和未进行susfs补丁的dev分支）
+4. 恢复对非 GKI 2.0 内核的支持
 5. 更多自定义功能
-
+6. 对 KPM 内核模块的支持
 
 ## 许可证
 
 - `kernel` 目录下的文件是 [GPL-2.0-only](https://www.gnu.org/licenses/old-licenses/gpl-2.0.en.html)。
-- 除 `kernel` 目录外，所有其他部分均为 [GPL-3.0 或更高版本](https://www.gnu.org/licenses/gpl-3.0.html)。
+- 有动漫人物图片表情包的这些文件 `ic_launcher*` 的图像版权为[五十根大虾仁](https://space.bilibili.com/370927)所有，图像中的 Brand Intellectual Property 由[明风OuO](https://space.bilibili.com/274939213)所有，矢量化由 @MiRinChan 完成，在使用这些文件之前，除了必须遵守 [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode.txt) 以外，还需要遵守向前两者索要使用这些艺术内容的授权。
+- 除了以上所述的文件或目录外，所有其他部分均为 [GPL-3.0 或更高版本](https://www.gnu.org/licenses/gpl-3.0.html)。
+
+## 爱发电链接
+
+- https://afdian.com/a/shirkneko
 
 ## 赞助名单
+
 - [Ktouls](https://github.com/Ktouls) 非常感谢你给我带来的支持
 - [zaoqi123](https://github.com/zaoqi123) 请我喝奶茶也不错
 - [wswzgdg](https://github.com/wswzgdg) 非常感谢对此项目的支持
+- [yspbwx2010](https://github.com/yspbwx2010) 非常感谢
+- [DARKWWEE](https://github.com/DARKWWEE) 感谢老哥的 100 USDT
 
-
-
-
-如何以上名单没有你的名称，我会及时更新，再次感谢大家的支持
+如果以上名单没有你的名称，我会及时更新，再次感谢大家的支持
 
 ## 贡献
 
 - [KernelSU](https://github.com/tiann/KernelSU)：原始项目
 - [MKSU](https://github.com/5ec1cff/KernelSU)：使用的项目
-- [RKSU](https://github.com/rsuntk/KernelsU)：使用该项目的 kernel 对非GKI设备重新进行支持
+- [RKSU](https://github.com/rsuntk/KernelsU)：使用该项目的 kernel 对非 GKI 设备重新进行支持
 - [susfs4ksu](https://gitlab.com/simonpunk/susfs4ksu)：使用的 susfs 文件系统
 - [kernel-assisted-superuser](https://git.zx2c4.com/kernel-assisted-superuser/about/)：KernelSU 的构想
 - [Magisk](https://github.com/topjohnwu/Magisk)：强大的 root 工具
 - [genuine](https://github.com/brevent/genuine/)：APK v2 签名验证
 - [Diamorphine](https://github.com/m0nad/Diamorphine)：一些 rootkit 技能
+- [KernelPatch](https://github.com/bmax121/KernelPatch): KernelPatch 是 APatch 实现内核模块的关键部分

kernel/Kconfig

@@ -16,19 +16,13 @@ config KSU_DEBUG
 	help
 	  Enable KernelSU debug mode.
 
-config KSU_HOOK
-	bool "Enable KernelSU Hook"
-	default n
-	help
-	  This option enables the KernelSU Hook feature. If enabled, it will
-	  override the kernel version check and enable the hook functionality.
-
 config KPM
-	bool "Enable KernelSU KPM"
+	bool "Enable SukiSU KPM"
+	depends on KSU && 64BIT
 	default n
 	help
-	  This option enables the KernelSU KPM feature. If enabled, it will
-	  override the kernel version check and enable the hook functionality.
-
+	  Enabling this option will activate the KPM feature of SukiSU.
+	  This option is suitable for scenarios where you need to force KPM to be enabled.
+	  but it may affect system stability.
 
 endmenu

kernel/Makefile

@@ -22,7 +22,7 @@ obj-$(CONFIG_KPM) += kpm/
 # .git is a text file while the module is imported by 'git submodule add'.
 ifeq ($(shell test -e $(srctree)/$(src)/../.git; echo $$?),0)
 $(shell cd $(srctree)/$(src); /usr/bin/env PATH="$$PATH":/usr/bin:/usr/local/bin [ -f ../.git/shallow ] && git fetch --unshallow)
-KSU_GIT_VERSION := $(shell cd $(srctree)/$(src); /usr/bin/env PATH="$$PATH":/usr/bin:/usr/local/bin git rev-list --count HEAD)
+KSU_GIT_VERSION := $(shell cd $(srctree)/$(src); /usr/bin/env PATH="$$PATH":/usr/bin:/usr/local/bin git rev-list --count main)
 # ksu_version: major * 10000 + git version + 606 for historical reasons
 $(eval KSU_VERSION=$(shell expr 10000 + $(KSU_GIT_VERSION) + 606))
 $(info -- KernelSU version: $(KSU_VERSION))
@@ -42,14 +42,32 @@ endif
 
 ifdef KSU_MANAGER_PACKAGE
 ccflags-y += -DKSU_MANAGER_PACKAGE=\"$(KSU_MANAGER_PACKAGE)\"
-$(info -- KernelSU Manager package name: $(KSU_MANAGER_PACKAGE))
+$(info -- SukiSU Manager package name: $(KSU_MANAGER_PACKAGE))
 endif
 
-$(info -- KernelSU Manager signature size: $(KSU_EXPECTED_SIZE))
-$(info -- KernelSU Manager signature hash: $(KSU_EXPECTED_HASH))
-$(info -- Supported Unofficial Manager: ShirkNeko (GKI) (Non-GKI))
+$(info -- SukiSU Manager signature size: $(KSU_EXPECTED_SIZE))
+$(info -- SukiSU Manager signature hash: $(KSU_EXPECTED_HASH))
+$(info -- Supported Unofficial Manager: 5ec1cff (GKI) ShirkNeko udochina (GKI and KPM))
 KERNEL_VERSION := $(VERSION).$(PATCHLEVEL)
+KERNEL_TYPE := Non-GKI
+# Check for GKI 2.0 (5.10+ or 6.x+)
+ifneq ($(shell test \( $(VERSION) -ge 5 -a $(PATCHLEVEL) -ge 10 \) -o $(VERSION) -ge 6; echo $$?),0)
+# Check for GKI 1.0 (5.4)
+ifeq ($(shell test $(VERSION)-$(PATCHLEVEL) = 5-4; echo $$?),0)
+KERNEL_TYPE := GKI 1.0
+endif
+else
+KERNEL_TYPE := GKI 2.0
+endif
 $(info -- KERNEL_VERSION: $(KERNEL_VERSION))
+$(info -- KERNEL_TYPE: $(KERNEL_TYPE))
+
+$(info -- KERNEL_VERSION: $(KERNEL_VERSION))
+ifeq ($(CONFIG_KPM),y)
+$(info -- KPM is enabled)
+else
+$(info -- KPM is disabled)
+endif
 
 
 ccflags-y += -DEXPECTED_SIZE=$(KSU_EXPECTED_SIZE)

kernel/core_hook.c

@@ -226,6 +226,7 @@ int ksu_handle_rename(struct dentry *old_dentry, struct dentry *new_dentry)
 	return 0;
 }
 
+#ifdef CONFIG_EXT4_FS
 static void nuke_ext4_sysfs() {
 	struct path path;
 	int err = kern_path("/data/adb/modules", 0, &path);
@@ -243,6 +244,9 @@ static void nuke_ext4_sysfs() {
 
 	ext4_unregister_sysfs(sb);
 }
+#else
+static inline void nuke_ext4_sysfs() { }
+#endif
 
 int ksu_handle_prctl(int option, unsigned long arg2, unsigned long arg3,
 		     unsigned long arg4, unsigned long arg5)
@@ -419,15 +423,19 @@ int ksu_handle_prctl(int option, unsigned long arg2, unsigned long arg3,
 
 		pr_info("KPM: calling before arg2=%d\n", (int) arg2);
 		
-		res = sukisu_handle_kpm(arg2, arg3, arg4);
-		copy_to_user(result, &res, sizeof(res));
-
-		pr_info("KPM: calling before arg2=%d res=%d\n", (int) arg2, (int) res);
+		res = sukisu_handle_kpm(arg2, arg3, arg4, arg5);
 
 		return 0;
 	}
 	#endif
 
+	if (arg2 == CMD_ENABLE_KPM) {
+    	bool KPM_Enabled = IS_ENABLED(CONFIG_KPM);
+    	if (copy_to_user((void __user *)arg3, &KPM_Enabled, sizeof(KPM_Enabled)))
+        	pr_info("KPM: copy_to_user() failed\n");
+    	return 0;
+	}
+
 	// all other cmds are for 'root manager'
 	if (!from_manager) {
 		return 0;

kernel/kpm/Makefile

@@ -1,2 +1,6 @@
 obj-y += kpm.o
 obj-y += compact.o
+obj-y += super_access.o
+
+ccflags-y += -Wno-implicit-function-declaration -Wno-strict-prototypes -Wno-int-conversion -Wno-gcc-compat
+ccflags-y += -Wno-declaration-after-statement -Wno-unused-function

kernel/kpm/compact.c

@@ -26,37 +26,56 @@
 #include <linux/slab.h>
 #include "kpm.h"
 #include "compact.h"
+#include "../allowlist.h"
+#include "../manager.h"
 
 unsigned long sukisu_compact_find_symbol(const char* name);
 
 // ======================================================================
+// 兼容函数 for KPM
 
-const char* kpver = "0.10";
+static
+int sukisu_is_su_allow_uid(uid_t uid) {
+    return ksu_is_allow_uid(uid) ? 1 : 0;
+}
+
+static
+int sukisu_get_ap_mod_exclude(uid_t uid) {
+    // Not supported
+    return 0;
+}
+
+static
+int sukisu_is_uid_should_umount(uid_t uid) {
+    return ksu_uid_should_umount(uid) ? 1 : 0;
+}
+
+static
+int sukisu_is_current_uid_manager() {
+    return is_manager();
+}
+
+static
+uid_t sukisu_get_manager_uid() {
+    return ksu_manager_uid;
+}
+
+// ======================================================================
 
 struct CompactAddressSymbol {
     const char* symbol_name;
     void* addr;
 };
 
-struct CompactAliasSymbol {
-    const char* symbol_name;
-    const char* compact_symbol_name;
-};
-
-struct CompactAddressSymbol address_symbol [] = {
+static struct CompactAddressSymbol address_symbol [] = {
     { "kallsyms_lookup_name", &kallsyms_lookup_name },
     { "compact_find_symbol", &sukisu_compact_find_symbol },
-    { "compat_copy_to_user", &copy_to_user },
-    { "compat_strncpy_from_user", &strncpy_from_user },
-    { "kpver", &kpver },
-    { "is_run_in_sukisu_ultra", (void*)1 }
-};
-
-struct CompactAliasSymbol alias_symbol[] = {
-    {"kf_strncat", "strncat"},
-    {"kf_strlen", "strlen" },
-    {"kf_strcpy", "strcpy"},
-    {"compat_copy_to_user", "__arch_copy_to_user"}
+    { "is_run_in_sukisu_ultra", (void*)1 },
+    { "is_su_allow_uid", &sukisu_is_su_allow_uid },
+    { "get_ap_mod_exclude", &sukisu_get_ap_mod_exclude },
+    { "is_uid_should_umount", &sukisu_is_uid_should_umount },
+    { "is_current_uid_manager", &sukisu_is_current_uid_manager },
+    { "get_manager_uid", &sukisu_get_manager_uid }
 };
 
 unsigned long sukisu_compact_find_symbol(const char* name) {
@@ -71,30 +90,13 @@ unsigned long sukisu_compact_find_symbol(const char* name) {
         }
     }
 
-    /* 如果符号名以 "kf__" 开头，尝试解析去掉前缀的部分 */
-    if (strncmp(name, "kf__", 4) == 0) {
-        const char *real_name = name + 4;  // 去掉 "kf__"
-        addr = (unsigned long)kallsyms_lookup_name(real_name);
-        if (addr) {
-            return addr;
-        }
-    }
-
     // 通过内核来查
     addr = kallsyms_lookup_name(name);
     if(addr) {
         return addr;
     }
 
-    // 查不到就查查兼容的符号
-    for(i = 0; i < (sizeof(alias_symbol) / sizeof(struct CompactAliasSymbol)); i++) {
-        struct CompactAliasSymbol* symbol = &alias_symbol[i];
-        if(strcmp(name, symbol->symbol_name) == 0) {
-            addr = kallsyms_lookup_name(symbol->compact_symbol_name);
-            if(addr)
-                return addr;
-        }
-    }
-
     return 0;
 }
+
+EXPORT_SYMBOL(sukisu_compact_find_symbol);

kernel/kpm/kpm.h

@@ -1,44 +1,44 @@
 #ifndef ___SUKISU_KPM_H
 #define ___SUKISU_KPM_H
 
-int sukisu_handle_kpm(unsigned long arg3, unsigned long arg4, unsigned long arg5);
+int sukisu_handle_kpm(unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5);
 int sukisu_is_kpm_control_code(unsigned long arg2);
 
 // KPM控制代码
 #define CMD_KPM_CONTROL 28
-#define CMD_KPM_CONTROL_MAX 34
+#define CMD_KPM_CONTROL_MAX 35
 
 // 控制代码
 
-// prctl(xxx, xxx, 1, "PATH", "ARGS")
+// prctl(xxx, 28, "PATH", "ARGS")
 // success return 0, error return -N
 #define SUKISU_KPM_LOAD 28
 
-// prctl(xxx, xxx, 2, "NAME")
+// prctl(xxx, 29, "NAME")
 // success return 0, error return -N
 #define SUKISU_KPM_UNLOAD 29
 
-// num = prctl(xxx, xxx, 3)
+// num = prctl(xxx, 30)
 // error return -N
 // success return +num or 0
 #define SUKISU_KPM_NUM 30
 
-// prctl(xxx, xxx, 4, Buffer, BufferSize)
+// prctl(xxx, 31, Buffer, BufferSize)
 // success return +out, error return -N
 #define SUKISU_KPM_LIST 31
 
-// prctl(xxx, xxx, 5, "NAME", Buffer[256])
+// prctl(xxx, 32, "NAME", Buffer[256])
 // success return +out, error return -N
 #define SUKISU_KPM_INFO 32
 
-// prctl(xxx, xxx, 6, "NAME", "ARGS")
+// prctl(xxx, 33, "NAME", "ARGS")
 // success return KPM's result value
 // error return -N
 #define SUKISU_KPM_CONTROL 33
 
-// prctl(xxx, xxx, 7)
-// success will printf to stdout and return 0
-// error will return -1
-#define SUKISU_KPM_PRINT 34
+// prctl(xxx, 34, buffer, bufferSize)
+// success return KPM's result value
+// error return -N
+#define SUKISU_KPM_VERSION 34
 
 #endif

kernel/kpm/super_access.c

@@ -0,0 +1,289 @@
+#include <linux/export.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/kernfs.h>
+#include <linux/file.h>
+#include <linux/slab.h>
+#include <linux/vmalloc.h>
+#include <linux/uaccess.h>
+#include <linux/elf.h>
+#include <linux/kallsyms.h>
+#include <linux/version.h>
+#include <linux/list.h>
+#include <linux/spinlock.h>
+#include <linux/rcupdate.h>
+#include <asm/elf.h>    /* 包含 ARM64 重定位类型定义 */
+#include <linux/vmalloc.h>
+#include <linux/mm.h>
+#include <linux/string.h>
+#include <asm/cacheflush.h>
+#include <linux/module.h>
+#include <linux/vmalloc.h>
+#include <linux/set_memory.h>
+#include <linux/version.h>
+#include <linux/export.h>
+#include <linux/slab.h>
+#include "kpm.h"
+#include "compact.h"
+#include <linux/types.h>
+#include <linux/stddef.h>
+
+// 结构体成员元数据
+struct DynamicStructMember {
+    const char* name;
+    size_t size;
+    size_t offset;
+};
+
+// 结构体元数据（包含总大小）
+struct DynamicStructInfo {
+    const char* name;
+    size_t count;
+    size_t total_size;
+    struct DynamicStructMember* members;
+};
+
+// 定义结构体元数据的宏（直接使用 struct 名称）
+#define DYNAMIC_STRUCT_BEGIN(struct_name) \
+    static struct DynamicStructMember struct_name##_members[] = {
+
+#define DEFINE_MEMBER(struct_name, member) \
+    { \
+        .name = #member, \
+        .size = sizeof(((struct struct_name*)0)->member), \
+        .offset = offsetof(struct struct_name, member) \
+    },
+
+#define DYNAMIC_STRUCT_END(struct_name) \
+    }; \
+    static struct DynamicStructInfo struct_name##_info = { \
+        .name = #struct_name, \
+        .count = sizeof(struct_name##_members) / sizeof(struct DynamicStructMember), \
+        .total_size = sizeof(struct struct_name), \
+        .members = struct_name##_members \
+    };
+
+// ==================================================================================
+
+#include <linux/version.h>
+
+#define KERNEL_VERSION_6_1 KERNEL_VERSION(6, 1, 0)
+#define KERNEL_VERSION_5_15 KERNEL_VERSION(5, 15, 0)
+
+#include <../fs/mount.h>
+#include <linux/mount.h>
+
+// 定义元数据
+DYNAMIC_STRUCT_BEGIN(mount)
+    DEFINE_MEMBER(mount, mnt_parent)
+    DEFINE_MEMBER(mount, mnt)
+    DEFINE_MEMBER(mount, mnt_id)
+    DEFINE_MEMBER(mount, mnt_group_id)
+    DEFINE_MEMBER(mount, mnt_expiry_mark)
+    DEFINE_MEMBER(mount, mnt_master)
+    DEFINE_MEMBER(mount, mnt_devname)
+DYNAMIC_STRUCT_END(mount)
+
+DYNAMIC_STRUCT_BEGIN(vfsmount)
+    DEFINE_MEMBER(vfsmount, mnt_root)
+    DEFINE_MEMBER(vfsmount, mnt_sb)
+    DEFINE_MEMBER(vfsmount, mnt_flags)
+DYNAMIC_STRUCT_END(vfsmount)
+
+DYNAMIC_STRUCT_BEGIN(mnt_namespace)
+    DEFINE_MEMBER(mnt_namespace, ns)
+    DEFINE_MEMBER(mnt_namespace, root)
+    DEFINE_MEMBER(mnt_namespace, seq)
+    DEFINE_MEMBER(mnt_namespace, mounts)
+#if LINUX_VERSION_CODE < KERNEL_VERSION_5_15
+    DEFINE_MEMBER(mnt_namespace, count)
+#endif
+DYNAMIC_STRUCT_END(mnt_namespace)
+
+#include <linux/kprobes.h>
+
+#ifdef CONFIG_KPROBES
+DYNAMIC_STRUCT_BEGIN(kprobe)
+    DEFINE_MEMBER(kprobe, addr)
+    DEFINE_MEMBER(kprobe, symbol_name)
+    DEFINE_MEMBER(kprobe, offset)
+    DEFINE_MEMBER(kprobe, pre_handler)
+    DEFINE_MEMBER(kprobe, post_handler)
+#if LINUX_VERSION_CODE < KERNEL_VERSION_5_15
+    DEFINE_MEMBER(kprobe, fault_handler)
+#endif
+    DEFINE_MEMBER(kprobe, flags)
+DYNAMIC_STRUCT_END(kprobe)
+#endif
+
+#include <linux/mm.h>
+#include <linux/mm_types.h>
+
+DYNAMIC_STRUCT_BEGIN(vm_area_struct)
+    DEFINE_MEMBER(vm_area_struct,vm_start)
+    DEFINE_MEMBER(vm_area_struct,vm_end)
+    DEFINE_MEMBER(vm_area_struct,vm_flags)
+    DEFINE_MEMBER(vm_area_struct,anon_vma)
+    DEFINE_MEMBER(vm_area_struct,vm_pgoff)
+    DEFINE_MEMBER(vm_area_struct,vm_file)
+    DEFINE_MEMBER(vm_area_struct,vm_private_data)
+    #ifdef CONFIG_ANON_VMA_NAME
+    DEFINE_MEMBER(vm_area_struct, anon_name)
+    #endif
+    DEFINE_MEMBER(vm_area_struct, vm_ops)
+DYNAMIC_STRUCT_END(vm_area_struct)
+
+DYNAMIC_STRUCT_BEGIN(vm_operations_struct)
+    DEFINE_MEMBER(vm_operations_struct, open)
+    DEFINE_MEMBER(vm_operations_struct, close)
+    DEFINE_MEMBER(vm_operations_struct, name)
+    DEFINE_MEMBER(vm_operations_struct, access)
+DYNAMIC_STRUCT_END(vm_operations_struct)
+
+#include <linux/netlink.h>
+
+DYNAMIC_STRUCT_BEGIN(netlink_kernel_cfg)
+    DEFINE_MEMBER(netlink_kernel_cfg, groups)
+    DEFINE_MEMBER(netlink_kernel_cfg, flags)
+    DEFINE_MEMBER(netlink_kernel_cfg, input)
+    DEFINE_MEMBER(netlink_kernel_cfg, cb_mutex)
+    DEFINE_MEMBER(netlink_kernel_cfg, bind)
+    DEFINE_MEMBER(netlink_kernel_cfg, unbind)
+#if LINUX_VERSION_CODE < KERNEL_VERSION_6_1
+    DEFINE_MEMBER(netlink_kernel_cfg, compare)
+#endif
+DYNAMIC_STRUCT_END(netlink_kernel_cfg)
+
+
+#include <linux/sched.h>
+DYNAMIC_STRUCT_BEGIN(task_struct)
+    DEFINE_MEMBER(task_struct, pid)
+    DEFINE_MEMBER(task_struct, tgid)
+    DEFINE_MEMBER(task_struct, cred)
+    DEFINE_MEMBER(task_struct, real_cred)
+    DEFINE_MEMBER(task_struct, comm)
+    DEFINE_MEMBER(task_struct, parent)
+    DEFINE_MEMBER(task_struct, group_leader)
+    DEFINE_MEMBER(task_struct, mm)
+    DEFINE_MEMBER(task_struct, active_mm)
+#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 19, 0) 
+    DEFINE_MEMBER(task_struct, pids[PIDTYPE_PID].pid)
+#else
+    DEFINE_MEMBER(task_struct, thread_pid)
+#endif
+    DEFINE_MEMBER(task_struct, files)
+    DEFINE_MEMBER(task_struct, seccomp)
+#ifdef CONFIG_THREAD_INFO_IN_TASK
+    DEFINE_MEMBER(task_struct, thread_info)
+#endif
+#ifdef CONFIG_CGROUPS
+    DEFINE_MEMBER(task_struct, cgroups)
+#endif
+#ifdef CONFIG_SECURITY
+    DEFINE_MEMBER(task_struct, security)
+#endif
+    DEFINE_MEMBER(task_struct, thread)
+DYNAMIC_STRUCT_END(task_struct)
+
+// =====================================================================================================================
+
+#define STRUCT_INFO(name) &(name##_info)
+
+static
+struct DynamicStructInfo* dynamic_struct_infos[] = {
+    STRUCT_INFO(mount),
+    STRUCT_INFO(vfsmount),
+    STRUCT_INFO(mnt_namespace),
+    #ifdef CONFIG_KPROBES
+        STRUCT_INFO(kprobe),
+    #endif
+    STRUCT_INFO(vm_area_struct),
+    STRUCT_INFO(vm_operations_struct),
+    STRUCT_INFO(netlink_kernel_cfg),
+    STRUCT_INFO(task_struct)
+};
+
+// return 0 if successful
+// return -1 if struct not defined
+int sukisu_super_find_struct(
+    const char* struct_name,
+    size_t* out_size,
+    int* out_members
+) {
+    for(size_t i = 0; i < (sizeof(dynamic_struct_infos) / sizeof(dynamic_struct_infos[0])); i++) {
+        struct DynamicStructInfo* info = dynamic_struct_infos[i];
+        if(strcmp(struct_name, info->name) == 0) {
+            if(out_size)
+                *out_size = info->total_size;
+            if(out_members)
+                *out_members = info->count;
+            return 0;
+        }
+    }
+    return -1;
+}
+EXPORT_SYMBOL(sukisu_super_find_struct);
+
+// Dynamic access struct
+// return 0 if successful
+// return -1 if struct not defined
+// return -2 if member not defined
+int sukisu_super_access (
+    const char* struct_name,
+    const char* member_name,
+    size_t* out_offset,
+    size_t* out_size
+) {
+    for(size_t i = 0; i < (sizeof(dynamic_struct_infos) / sizeof(dynamic_struct_infos[0])); i++) {
+        struct DynamicStructInfo* info = dynamic_struct_infos[i];
+        if(strcmp(struct_name, info->name) == 0) {
+            for (size_t i1 = 0; i1 < info->count; i1++) {
+                if (strcmp(info->members[i1].name, member_name) == 0) {
+                    if(out_offset)
+                        *out_offset = info->members[i].offset;
+                    if(out_size)
+                        *out_size = info->members[i].size;
+                    return 0;
+                }
+            }
+            return -2;
+        }
+    }
+    return -1;
+}
+EXPORT_SYMBOL(sukisu_super_access);
+
+// 动态 container_of 宏
+#define DYNAMIC_CONTAINER_OF(offset, member_ptr) ({ \
+    (offset != (size_t)-1) ? (void*)((char*)(member_ptr) - offset) : NULL; \
+})
+
+// Dynamic container_of
+// return 0 if success
+// return -1 if current struct not defined
+// return -2 if target member not defined
+int sukisu_super_container_of(
+    const char* struct_name,
+    const char* member_name,
+    void* ptr,
+    void** out_ptr
+) {
+    if(ptr == NULL) {
+        return -3;
+    }
+    for(size_t i = 0; i < (sizeof(dynamic_struct_infos) / sizeof(dynamic_struct_infos[0])); i++) {
+        struct DynamicStructInfo* info = dynamic_struct_infos[i];
+        if(strcmp(struct_name, info->name) == 0) {
+            for (size_t i1 = 0; i1 < info->count; i1++) {
+                if (strcmp(info->members[i1].name, member_name) == 0) {
+                    *out_ptr = (void*) DYNAMIC_CONTAINER_OF(info->members[i1].offset, ptr);
+                    return 0;
+                }
+            }
+            return -2;
+        }
+    }
+    return -1;
+}
+EXPORT_SYMBOL(sukisu_super_container_of);

kernel/kpm/super_access.h

@@ -0,0 +1,39 @@
+#ifndef __SUKISU_SUPER_ACCESS_H
+#define __SUKISU_SUPER_ACCESS_H
+
+#include <linux/types.h>
+#include <linux/stddef.h>
+#include "kpm.h"
+#include "compact.h"
+
+// return 0 if successful
+// return -1 if struct not defined
+int sukisu_super_find_struct(
+    const char* struct_name,
+    size_t* out_size,
+    int* out_members
+);
+
+// Dynamic access struct
+// return 0 if successful
+// return -1 if struct not defined
+// return -2 if member not defined
+int sukisu_super_access (
+    const char* struct_name,
+    const char* member_name,
+    size_t* out_offset,
+    size_t* out_size
+);
+
+// Dynamic container_of
+// return 0 if success
+// return -1 if current struct not defined
+// return -2 if target member not defined
+int sukisu_super_container_of(
+    const char* struct_name,
+    const char* member_name,
+    void* ptr,
+    void** out_ptr
+);
+
+#endif

kernel/ksu.h

@@ -23,6 +23,7 @@
 #define CMD_UID_SHOULD_UMOUNT 13
 #define CMD_IS_SU_ENABLED 14
 #define CMD_ENABLE_SU 15
+#define CMD_ENABLE_KPM 100
 
 #define EVENT_POST_FS_DATA 1
 #define EVENT_BOOT_COMPLETED 2

kernel/ksud.c

@@ -63,6 +63,10 @@ u32 ksu_devpts_sid;
 // Detect whether it is on or not
 static bool is_boot_phase = true;
 
+#ifdef CONFIG_COMPAT
+bool ksu_is_compat __read_mostly = false;
+#endif
+
 void on_post_fs_data(void)
 {
 	static bool done = false;
@@ -107,6 +111,7 @@ static const char __user *get_user_arg_ptr(struct user_arg_ptr argv, int nr)
 		if (get_user(compat, argv.ptr.compat + nr))
 			return ERR_PTR(-EFAULT);
 
+		ksu_is_compat = true;
 		return compat_ptr(compat);
 	}
 #endif

kernel/selinux/rules.c

@@ -137,17 +137,45 @@ void apply_kernelsu_rules()
 #define CMD_TYPE_CHANGE 8
 #define CMD_GENFSCON 9
 
+#ifdef CONFIG_64BIT
 struct sepol_data {
 	u32 cmd;
 	u32 subcmd;
-	char __user *sepol1;
-	char __user *sepol2;
-	char __user *sepol3;
-	char __user *sepol4;
-	char __user *sepol5;
-	char __user *sepol6;
-	char __user *sepol7;
+	u64 field_sepol1;
+	u64 field_sepol2;
+	u64 field_sepol3;
+	u64 field_sepol4;
+	u64 field_sepol5;
+	u64 field_sepol6;
+	u64 field_sepol7;
 };
+#ifdef CONFIG_COMPAT
+extern bool ksu_is_compat __read_mostly;
+struct sepol_compat_data {
+	u32 cmd;
+	u32 subcmd;
+	u32 field_sepol1;
+	u32 field_sepol2;
+	u32 field_sepol3;
+	u32 field_sepol4;
+	u32 field_sepol5;
+	u32 field_sepol6;
+	u32 field_sepol7;
+};
+#endif // CONFIG_COMPAT
+#else
+struct sepol_data {
+	u32 cmd;
+	u32 subcmd;
+	u32 field_sepol1;
+	u32 field_sepol2;
+	u32 field_sepol3;
+	u32 field_sepol4;
+	u32 field_sepol5;
+	u32 field_sepol6;
+	u32 field_sepol7;
+};
+#endif // CONFIG_64BIT
 
 static int get_object(char *buf, char __user *user_object, size_t buf_sz,
 		      char **object)
@@ -192,14 +220,58 @@ int handle_sepolicy(unsigned long arg3, void __user *arg4)
 		pr_info("SELinux permissive or disabled when handle policy!\n");
 	}
 	
+	u32 cmd, subcmd;
+	char __user *sepol1, *sepol2, *sepol3, *sepol4, *sepol5, *sepol6, *sepol7;
+
+#if defined(CONFIG_64BIT) && defined(CONFIG_COMPAT)
+	if (unlikely(ksu_is_compat)) {
+		struct sepol_compat_data compat_data;
+		if (copy_from_user(&compat_data, arg4, sizeof(struct sepol_compat_data))) {
+			pr_err("sepol: copy sepol_data failed.\n");
+			return -1;
+		}
+		sepol1 = compat_ptr(compat_data.field_sepol1);
+		sepol2 = compat_ptr(compat_data.field_sepol2);
+		sepol3 = compat_ptr(compat_data.field_sepol3);
+		sepol4 = compat_ptr(compat_data.field_sepol4);
+		sepol5 = compat_ptr(compat_data.field_sepol5);
+		sepol6 = compat_ptr(compat_data.field_sepol6);
+		sepol7 = compat_ptr(compat_data.field_sepol7);
+		cmd = compat_data.cmd;
+		subcmd = compat_data.subcmd;
+	} else {
+		struct sepol_data data;
+		if (copy_from_user(&data, arg4, sizeof(struct sepol_data))) {
+			pr_err("sepol: copy sepol_data failed.\n");
+			return -1;
+		}
+		sepol1 = data.field_sepol1;
+		sepol2 = data.field_sepol2;
+		sepol3 = data.field_sepol3;
+		sepol4 = data.field_sepol4;
+		sepol5 = data.field_sepol5;
+		sepol6 = data.field_sepol6;
+		sepol7 = data.field_sepol7;
+		cmd = data.cmd;
+		subcmd = data.subcmd;
+	}
+#else 
+	// basically for full native, say (64BIT=y COMPAT=n) || (64BIT=n)
 	struct sepol_data data;
 	if (copy_from_user(&data, arg4, sizeof(struct sepol_data))) {
 		pr_err("sepol: copy sepol_data failed.\n");
 		return -1;
 	}
-
-	u32 cmd = data.cmd;
-	u32 subcmd = data.subcmd;
+	sepol1 = data.field_sepol1;
+	sepol2 = data.field_sepol2;
+	sepol3 = data.field_sepol3;
+	sepol4 = data.field_sepol4;
+	sepol5 = data.field_sepol5;
+	sepol6 = data.field_sepol6;
+	sepol7 = data.field_sepol7;
+	cmd = data.cmd;
+	subcmd = data.subcmd;
+#endif
 
 	rcu_read_lock();
 
@@ -213,22 +285,22 @@ int handle_sepolicy(unsigned long arg3, void __user *arg4)
 		char perm_buf[MAX_SEPOL_LEN];
 
 		char *s, *t, *c, *p;
-		if (get_object(src_buf, data.sepol1, sizeof(src_buf), &s) < 0) {
+		if (get_object(src_buf, sepol1, sizeof(src_buf), &s) < 0) {
 			pr_err("sepol: copy src failed.\n");
 			goto exit;
 		}
 
-		if (get_object(tgt_buf, data.sepol2, sizeof(tgt_buf), &t) < 0) {
+		if (get_object(tgt_buf, sepol2, sizeof(tgt_buf), &t) < 0) {
 			pr_err("sepol: copy tgt failed.\n");
 			goto exit;
 		}
 
-		if (get_object(cls_buf, data.sepol3, sizeof(cls_buf), &c) < 0) {
+		if (get_object(cls_buf, sepol3, sizeof(cls_buf), &c) < 0) {
 			pr_err("sepol: copy cls failed.\n");
 			goto exit;
 		}
 
-		if (get_object(perm_buf, data.sepol4, sizeof(perm_buf), &p) <
+		if (get_object(perm_buf, sepol4, sizeof(perm_buf), &p) <
 		    0) {
 			pr_err("sepol: copy perm failed.\n");
 			goto exit;
@@ -258,24 +330,24 @@ int handle_sepolicy(unsigned long arg3, void __user *arg4)
 		char perm_set[MAX_SEPOL_LEN];
 
 		char *s, *t, *c;
-		if (get_object(src_buf, data.sepol1, sizeof(src_buf), &s) < 0) {
+		if (get_object(src_buf, sepol1, sizeof(src_buf), &s) < 0) {
 			pr_err("sepol: copy src failed.\n");
 			goto exit;
 		}
-		if (get_object(tgt_buf, data.sepol2, sizeof(tgt_buf), &t) < 0) {
+		if (get_object(tgt_buf, sepol2, sizeof(tgt_buf), &t) < 0) {
 			pr_err("sepol: copy tgt failed.\n");
 			goto exit;
 		}
-		if (get_object(cls_buf, data.sepol3, sizeof(cls_buf), &c) < 0) {
+		if (get_object(cls_buf, sepol3, sizeof(cls_buf), &c) < 0) {
 			pr_err("sepol: copy cls failed.\n");
 			goto exit;
 		}
-		if (strncpy_from_user(operation, data.sepol4,
+		if (strncpy_from_user(operation, sepol4,
 				      sizeof(operation)) < 0) {
 			pr_err("sepol: copy operation failed.\n");
 			goto exit;
 		}
-		if (strncpy_from_user(perm_set, data.sepol5, sizeof(perm_set)) <
+		if (strncpy_from_user(perm_set, sepol5, sizeof(perm_set)) <
 		    0) {
 			pr_err("sepol: copy perm_set failed.\n");
 			goto exit;
@@ -295,7 +367,7 @@ int handle_sepolicy(unsigned long arg3, void __user *arg4)
 	} else if (cmd == CMD_TYPE_STATE) {
 		char src[MAX_SEPOL_LEN];
 
-		if (strncpy_from_user(src, data.sepol1, sizeof(src)) < 0) {
+		if (strncpy_from_user(src, sepol1, sizeof(src)) < 0) {
 			pr_err("sepol: copy src failed.\n");
 			goto exit;
 		}
@@ -315,11 +387,11 @@ int handle_sepolicy(unsigned long arg3, void __user *arg4)
 		char type[MAX_SEPOL_LEN];
 		char attr[MAX_SEPOL_LEN];
 
-		if (strncpy_from_user(type, data.sepol1, sizeof(type)) < 0) {
+		if (strncpy_from_user(type, sepol1, sizeof(type)) < 0) {
 			pr_err("sepol: copy type failed.\n");
 			goto exit;
 		}
-		if (strncpy_from_user(attr, data.sepol2, sizeof(attr)) < 0) {
+		if (strncpy_from_user(attr, sepol2, sizeof(attr)) < 0) {
 			pr_err("sepol: copy attr failed.\n");
 			goto exit;
 		}
@@ -339,7 +411,7 @@ int handle_sepolicy(unsigned long arg3, void __user *arg4)
 	} else if (cmd == CMD_ATTR) {
 		char attr[MAX_SEPOL_LEN];
 
-		if (strncpy_from_user(attr, data.sepol1, sizeof(attr)) < 0) {
+		if (strncpy_from_user(attr, sepol1, sizeof(attr)) < 0) {
 			pr_err("sepol: copy attr failed.\n");
 			goto exit;
 		}
@@ -356,28 +428,28 @@ int handle_sepolicy(unsigned long arg3, void __user *arg4)
 		char default_type[MAX_SEPOL_LEN];
 		char object[MAX_SEPOL_LEN];
 
-		if (strncpy_from_user(src, data.sepol1, sizeof(src)) < 0) {
+		if (strncpy_from_user(src, sepol1, sizeof(src)) < 0) {
 			pr_err("sepol: copy src failed.\n");
 			goto exit;
 		}
-		if (strncpy_from_user(tgt, data.sepol2, sizeof(tgt)) < 0) {
+		if (strncpy_from_user(tgt, sepol2, sizeof(tgt)) < 0) {
 			pr_err("sepol: copy tgt failed.\n");
 			goto exit;
 		}
-		if (strncpy_from_user(cls, data.sepol3, sizeof(cls)) < 0) {
+		if (strncpy_from_user(cls, sepol3, sizeof(cls)) < 0) {
 			pr_err("sepol: copy cls failed.\n");
 			goto exit;
 		}
-		if (strncpy_from_user(default_type, data.sepol4,
+		if (strncpy_from_user(default_type, sepol4,
 				      sizeof(default_type)) < 0) {
 			pr_err("sepol: copy default_type failed.\n");
 			goto exit;
 		}
 		char *real_object;
-		if (data.sepol5 == NULL) {
+		if (sepol5 == NULL) {
 			real_object = NULL;
 		} else {
-			if (strncpy_from_user(object, data.sepol5,
+			if (strncpy_from_user(object, sepol5,
 					      sizeof(object)) < 0) {
 				pr_err("sepol: copy object failed.\n");
 				goto exit;
@@ -396,19 +468,19 @@ int handle_sepolicy(unsigned long arg3, void __user *arg4)
 		char cls[MAX_SEPOL_LEN];
 		char default_type[MAX_SEPOL_LEN];
 
-		if (strncpy_from_user(src, data.sepol1, sizeof(src)) < 0) {
+		if (strncpy_from_user(src, sepol1, sizeof(src)) < 0) {
 			pr_err("sepol: copy src failed.\n");
 			goto exit;
 		}
-		if (strncpy_from_user(tgt, data.sepol2, sizeof(tgt)) < 0) {
+		if (strncpy_from_user(tgt, sepol2, sizeof(tgt)) < 0) {
 			pr_err("sepol: copy tgt failed.\n");
 			goto exit;
 		}
-		if (strncpy_from_user(cls, data.sepol3, sizeof(cls)) < 0) {
+		if (strncpy_from_user(cls, sepol3, sizeof(cls)) < 0) {
 			pr_err("sepol: copy cls failed.\n");
 			goto exit;
 		}
-		if (strncpy_from_user(default_type, data.sepol4,
+		if (strncpy_from_user(default_type, sepol4,
 				      sizeof(default_type)) < 0) {
 			pr_err("sepol: copy default_type failed.\n");
 			goto exit;
@@ -429,15 +501,15 @@ int handle_sepolicy(unsigned long arg3, void __user *arg4)
 		char name[MAX_SEPOL_LEN];
 		char path[MAX_SEPOL_LEN];
 		char context[MAX_SEPOL_LEN];
-		if (strncpy_from_user(name, data.sepol1, sizeof(name)) < 0) {
+		if (strncpy_from_user(name, sepol1, sizeof(name)) < 0) {
 			pr_err("sepol: copy name failed.\n");
 			goto exit;
 		}
-		if (strncpy_from_user(path, data.sepol2, sizeof(path)) < 0) {
+		if (strncpy_from_user(path, sepol2, sizeof(path)) < 0) {
 			pr_err("sepol: copy path failed.\n");
 			goto exit;
 		}
-		if (strncpy_from_user(context, data.sepol3, sizeof(context)) <
+		if (strncpy_from_user(context, sepol3, sizeof(context)) <
 		    0) {
 			pr_err("sepol: copy context failed.\n");
 			goto exit;

kernel/setup.sh

@@ -41,7 +41,7 @@ setup_kernelsu() {
     echo "[+] Setting up KernelSU..."
     # Clone the repository and rename it to KernelSU
     if [ ! -d "$GKI_ROOT/KernelSU" ]; then
-        git clone https://github.com/ShirkNeko/SukiSU-Ultra SukiSU-Ultra
+        git clone https://github.com/SukiSU-Ultra/SukiSU-Ultra SukiSU-Ultra
         mv SukiSU-Ultra KernelSU
         echo "[+] Repository cloned and renamed to KernelSU."
     fi

kernel/sucompat.c

@@ -22,6 +22,10 @@
 
 extern void escape_to_root();
 
+#ifndef CONFIG_KPROBES
+static bool ksu_sucompat_non_kp __read_mostly = true;
+#endif
+
 static void __user *userspace_stack_buffer(const void *d, size_t len)
 {
 	/* To avoid having to mmap a page in userspace, just write below the stack
@@ -50,6 +54,12 @@ int ksu_handle_faccessat(int *dfd, const char __user **filename_user, int *mode,
 {
 	const char su[] = SU_PATH;
 
+#ifndef CONFIG_KPROBES
+	if (!ksu_sucompat_non_kp) {
+ 		return 0;
+ 	}
+#endif
+
 	if (!ksu_is_allow_uid(current_uid().val)) {
 		return 0;
 	}
@@ -71,6 +81,11 @@ int ksu_handle_stat(int *dfd, const char __user **filename_user, int *flags)
 	// const char sh[] = SH_PATH;
 	const char su[] = SU_PATH;
 
+#ifndef CONFIG_KPROBES
+	if (!ksu_sucompat_non_kp) {
+ 		return 0;
+ 	}
+#endif
 	if (!ksu_is_allow_uid(current_uid().val)) {
 		return 0;
 	}
@@ -115,6 +130,11 @@ int ksu_handle_execveat_sucompat(int *fd, struct filename **filename_ptr,
 	const char sh[] = KSUD_PATH;
 	const char su[] = SU_PATH;
 
+#ifndef CONFIG_KPROBES
+	if (!ksu_sucompat_non_kp) {
+ 		return 0;
+ 	}
+#endif
 	if (unlikely(!filename_ptr))
 		return 0;
 
@@ -144,6 +164,11 @@ int ksu_handle_execve_sucompat(int *fd, const char __user **filename_user,
 	const char su[] = SU_PATH;
 	char path[sizeof(su) + 1];
 
+#ifndef CONFIG_KPROBES
+	if (!ksu_sucompat_non_kp){
+ 		return 0;
+ 	}
+#endif
 	if (unlikely(!filename_user))
 		return 0;
 
@@ -237,6 +262,9 @@ void ksu_sucompat_init()
 	su_kps[0] = init_kprobe(SYS_EXECVE_SYMBOL, execve_handler_pre);
 	su_kps[1] = init_kprobe(SYS_FACCESSAT_SYMBOL, faccessat_handler_pre);
 	su_kps[2] = init_kprobe(SYS_NEWFSTATAT_SYMBOL, newfstatat_handler_pre);
+#else
+	ksu_sucompat_non_kp = true;
+ 	pr_info("ksu_sucompat_init: hooks enabled: execve/execveat_su, faccessat, stat\n");
 #endif
 }
 
@@ -246,5 +274,8 @@ void ksu_sucompat_exit()
 	for (int i = 0; i < ARRAY_SIZE(su_kps); i++) {
 		destroy_kprobe(&su_kps[i]);
 	}
+#else
+	ksu_sucompat_non_kp = false;
+ 	pr_info("ksu_sucompat_exit: hooks disabled: execve/execveat_su, faccessat, stat\n");
 #endif
 }

kernel/throne_tracker.c

@@ -358,12 +358,14 @@ void track_throne()
 		if (ksu_is_manager_uid_valid()) {
 			pr_info("manager is uninstalled, invalidate it!\n");
 			ksu_invalidate_manager_uid();
+			goto prune;
 		}
 		pr_info("Searching manager...\n");
 		search_manager("/data/app", 2, &uid_list);
 		pr_info("Search manager finished\n");
 	}
 
+prune:
 	// then prune the allowlist
 	ksu_prune_allowlist(is_uid_exist, &uid_list);
 out:

manager/app/build.gradle.kts

@@ -1,5 +1,6 @@
 @file:Suppress("UnstableApiUsage")
 
+import com.android.build.api.dsl.ApkSigningConfig
 import com.android.build.gradle.internal.api.BaseVariantOutputImpl
 import com.android.build.gradle.tasks.PackageAndroidArtifact
 
@@ -24,8 +25,18 @@ apksign {
     keyPasswordProperty = "KEY_PASSWORD"
 }
 
+
 android {
-    namespace = "shirkneko.zako.sukisu"
+
+    /**signingConfigs {
+        create("Debug") {
+            storeFile = file("D:\\other\\AndroidTool\\android_key\\keystore\\release-key.keystore")
+            storePassword = ""
+            keyAlias = ""
+            keyPassword = ""
+        }
+    }**/
+    namespace = "com.sukisu.ultra"
 
     buildTypes {
         release {
@@ -33,10 +44,12 @@ android {
             isShrinkResources = true
             proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
         }
+        /**debug {
+            signingConfig = signingConfigs.named("Debug").get() as ApkSigningConfig
+        }**/
     }
 
     buildFeatures {
-        aidl = true
         buildConfig = true
         compose = true
         prefab = true
@@ -95,6 +108,7 @@ android {
 }
 
 dependencies {
+    implementation(libs.gson)
     implementation(libs.androidx.activity.compose)
     implementation(libs.androidx.navigation.compose)
 
@@ -140,4 +154,9 @@ dependencies {
 
     implementation(libs.com.github.topjohnwu.libsu.core)
 
+    implementation(libs.mmrl.platform)
+    compileOnly(libs.mmrl.hidden.api)
+    implementation(libs.mmrl.webui)
+    implementation(libs.mmrl.ui)
+
 }

manager/app/proguard-rules.pro

@@ -0,0 +1,47 @@
+-verbose
+-optimizationpasses 5
+
+-dontwarn org.conscrypt.**
+-dontwarn kotlinx.serialization.**
+
+# Please add these rules to your existing keep rules in order to suppress warnings.
+# This is generated automatically by the Android Gradle plugin.
+-dontwarn com.google.auto.service.AutoService
+-dontwarn com.google.j2objc.annotations.RetainedWith
+-dontwarn javax.lang.model.SourceVersion
+-dontwarn javax.lang.model.element.AnnotationMirror
+-dontwarn javax.lang.model.element.AnnotationValue
+-dontwarn javax.lang.model.element.Element
+-dontwarn javax.lang.model.element.ElementKind
+-dontwarn javax.lang.model.element.ElementVisitor
+-dontwarn javax.lang.model.element.ExecutableElement
+-dontwarn javax.lang.model.element.Modifier
+-dontwarn javax.lang.model.element.Name
+-dontwarn javax.lang.model.element.PackageElement
+-dontwarn javax.lang.model.element.TypeElement
+-dontwarn javax.lang.model.element.TypeParameterElement
+-dontwarn javax.lang.model.element.VariableElement
+-dontwarn javax.lang.model.type.ArrayType
+-dontwarn javax.lang.model.type.DeclaredType
+-dontwarn javax.lang.model.type.ExecutableType
+-dontwarn javax.lang.model.type.TypeKind
+-dontwarn javax.lang.model.type.TypeMirror
+-dontwarn javax.lang.model.type.TypeVariable
+-dontwarn javax.lang.model.type.TypeVisitor
+-dontwarn javax.lang.model.util.AbstractAnnotationValueVisitor8
+-dontwarn javax.lang.model.util.AbstractTypeVisitor8
+-dontwarn javax.lang.model.util.ElementFilter
+-dontwarn javax.lang.model.util.Elements
+-dontwarn javax.lang.model.util.SimpleElementVisitor8
+-dontwarn javax.lang.model.util.SimpleTypeVisitor7
+-dontwarn javax.lang.model.util.SimpleTypeVisitor8
+-dontwarn javax.lang.model.util.Types
+-dontwarn javax.tools.Diagnostic$Kind
+
+
+# MMRL:webui reflection
+-keep class com.dergoogler.mmrl.webui.model.ModId { *; }
+-keep class com.dergoogler.mmrl.webui.interfaces.** { *; }
+-keep class com.sukisu.ultra.ui.webui.WebViewInterface { *; }
+
+-keep,allowobfuscation class * extends com.dergoogler.mmrl.platform.content.IService { *; }

manager/app/src/main/AndroidManifest.xml

@@ -3,8 +3,10 @@
     xmlns:tools="http://schemas.android.com/tools">
 
     <uses-permission android:name="android.permission.INTERNET" />
-    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
-    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"
+        tools:ignore="ScopedStorage" />
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"
+        tools:ignore="ScopedStorage" />
 
 
     <application
@@ -37,6 +39,13 @@
             android:exported="false"
             android:theme="@style/Theme.KernelSU.WebUI" />
 
+        <activity
+            android:name=".ui.webui.WebUIXActivity"
+            android:autoRemoveFromRecents="true"
+            android:documentLaunchMode="intoExisting"
+            android:exported="false"
+            android:theme="@style/Theme.KernelSU.WebUI" />
+
         <provider
             android:name="androidx.core.content.FileProvider"
             android:authorities="${applicationId}.fileprovider"

manager/app/src/main/aidl/shirkneko/zako/sukisu/IKsuInterface.aidl

@@ -1,9 +0,0 @@
-// IKsuInterface.aidl
-package shirkneko.zako.sukisu;
-
-import android.content.pm.PackageInfo;
-import rikka.parcelablelist.ParcelableListSlice;
-
-interface IKsuInterface {
-    ParcelableListSlice<PackageInfo> getPackages(int flags);
-}

manager/app/src/main/cpp/jni.cc

@@ -12,7 +12,7 @@
 
 extern "C"
 JNIEXPORT jboolean JNICALL
-Java_shirkneko_zako_sukisu_Natives_becomeManager(JNIEnv *env, jobject, jstring pkg) {
+Java_com_sukisu_ultra_Natives_becomeManager(JNIEnv *env, jobject, jstring pkg) {
     auto cpkg = env->GetStringUTFChars(pkg, nullptr);
     auto result = become_manager(cpkg);
     env->ReleaseStringUTFChars(pkg, cpkg);
@@ -21,13 +21,13 @@ Java_shirkneko_zako_sukisu_Natives_becomeManager(JNIEnv *env, jobject, jstring p
 
 extern "C"
 JNIEXPORT jint JNICALL
-Java_shirkneko_zako_sukisu_Natives_getVersion(JNIEnv *env, jobject) {
+Java_com_sukisu_ultra_Natives_getVersion(JNIEnv *env, jobject) {
     return get_version();
 }
 
 extern "C"
 JNIEXPORT jintArray JNICALL
-Java_shirkneko_zako_sukisu_Natives_getAllowList(JNIEnv *env, jobject) {
+Java_com_sukisu_ultra_Natives_getAllowList(JNIEnv *env, jobject) {
     int uids[1024];
     int size = 0;
     bool result = get_allow_list(uids, &size);
@@ -42,13 +42,13 @@ Java_shirkneko_zako_sukisu_Natives_getAllowList(JNIEnv *env, jobject) {
 
 extern "C"
 JNIEXPORT jboolean JNICALL
-Java_shirkneko_zako_sukisu_Natives_isSafeMode(JNIEnv *env, jclass clazz) {
+Java_com_sukisu_ultra_Natives_isSafeMode(JNIEnv *env, jclass clazz) {
     return is_safe_mode();
 }
 
 extern "C"
 JNIEXPORT jboolean JNICALL
-Java_shirkneko_zako_sukisu_Natives_isLkmMode(JNIEnv *env, jclass clazz) {
+Java_com_sukisu_ultra_Natives_isLkmMode(JNIEnv *env, jclass clazz) {
     return is_lkm_mode();
 }
 
@@ -111,7 +111,7 @@ static void fillArrayWithList(JNIEnv *env, jobject list, int *data, int count) {
 
 extern "C"
 JNIEXPORT jobject JNICALL
-Java_shirkneko_zako_sukisu_Natives_getAppProfile(JNIEnv *env, jobject, jstring pkg, jint uid) {
+Java_com_sukisu_ultra_Natives_getAppProfile(JNIEnv *env, jobject, jstring pkg, jint uid) {
     if (env->GetStringLength(pkg) > KSU_MAX_PACKAGE_NAME) {
         return nullptr;
     }
@@ -129,7 +129,7 @@ Java_shirkneko_zako_sukisu_Natives_getAppProfile(JNIEnv *env, jobject, jstring p
 
     bool useDefaultProfile = !get_app_profile(key, &profile);
 
-    auto cls = env->FindClass("shirkneko/zako/sukisu/Natives$Profile");
+    auto cls = env->FindClass("com/sukisu/ultra/Natives$Profile");
     auto constructor = env->GetMethodID(cls, "<init>", "()V");
     auto obj = env->NewObject(cls, constructor);
     auto keyField = env->GetFieldID(cls, "name", "Ljava/lang/String;");
@@ -207,8 +207,8 @@ Java_shirkneko_zako_sukisu_Natives_getAppProfile(JNIEnv *env, jobject, jstring p
 
 extern "C"
 JNIEXPORT jboolean JNICALL
-Java_shirkneko_zako_sukisu_Natives_setAppProfile(JNIEnv *env, jobject clazz, jobject profile) {
-    auto cls = env->FindClass("shirkneko/zako/sukisu/Natives$Profile");
+Java_com_sukisu_ultra_Natives_setAppProfile(JNIEnv *env, jobject clazz, jobject profile) {
+    auto cls = env->FindClass("com/sukisu/ultra/Natives$Profile");
 
     auto keyField = env->GetFieldID(cls, "name", "Ljava/lang/String;");
     auto currentUidField = env->GetFieldID(cls, "currentUid", "I");
@@ -293,16 +293,21 @@ Java_shirkneko_zako_sukisu_Natives_setAppProfile(JNIEnv *env, jobject clazz, job
 }
 extern "C"
 JNIEXPORT jboolean JNICALL
-Java_shirkneko_zako_sukisu_Natives_uidShouldUmount(JNIEnv *env, jobject thiz, jint uid) {
+Java_com_sukisu_ultra_Natives_uidShouldUmount(JNIEnv *env, jobject thiz, jint uid) {
     return uid_should_umount(uid);
 }
 extern "C"
 JNIEXPORT jboolean JNICALL
-Java_shirkneko_zako_sukisu_Natives_isSuEnabled(JNIEnv *env, jobject thiz) {
+Java_com_sukisu_ultra_Natives_isSuEnabled(JNIEnv *env, jobject thiz) {
     return is_su_enabled();
 }
 extern "C"
 JNIEXPORT jboolean JNICALL
-Java_shirkneko_zako_sukisu_Natives_setSuEnabled(JNIEnv *env, jobject thiz, jboolean enabled) {
+Java_com_sukisu_ultra_Natives_setSuEnabled(JNIEnv *env, jobject thiz, jboolean enabled) {
     return set_su_enabled(enabled);
 }
+
+extern "C" JNIEXPORT jboolean JNICALL
+Java_com_sukisu_ultra_Natives_isKPMEnabled(JNIEnv *env, jobject) {
+    return is_KPM_enable();
+}

manager/app/src/main/cpp/ksu.cc

@@ -29,6 +29,7 @@
 #define CMD_IS_UID_SHOULD_UMOUNT 13
 #define CMD_IS_SU_ENABLED 14
 #define CMD_ENABLE_SU 15
+#define CMD_ENABLE_KPM 100
 
 static bool ksuctl(int cmd, void* arg1, void* arg2) {
     int32_t result = 0;
@@ -97,3 +98,8 @@ bool is_su_enabled() {
     ksuctl(CMD_IS_SU_ENABLED, &enabled, nullptr);
     return enabled;
 }
+
+bool is_KPM_enable() {
+    bool enabled = false;
+    return ksuctl(CMD_ENABLE_KPM, &enabled, nullptr), enabled;
+}

manager/app/src/main/cpp/ksu.h

@@ -83,4 +83,6 @@ bool set_su_enabled(bool enabled);
 
 bool is_su_enabled();
 
+bool is_KPM_enable();
+
 #endif //KERNELSU_KSU_H

manager/app/src/main/java/com/sukisu/ultra/KernelSUApplication.kt

@@ -0,0 +1,110 @@
+package com.sukisu.ultra
+
+import android.annotation.SuppressLint
+import android.app.Application
+import android.content.Context
+import android.content.res.Configuration
+import android.content.res.Resources
+import android.os.Build
+import coil.Coil
+import coil.ImageLoader
+import com.dergoogler.mmrl.platform.Platform
+import me.zhanghai.android.appiconloader.coil.AppIconFetcher
+import me.zhanghai.android.appiconloader.coil.AppIconKeyer
+import java.io.File
+import java.util.Locale
+
+lateinit var ksuApp: KernelSUApplication
+
+class KernelSUApplication : Application() {
+
+    override fun attachBaseContext(base: Context) {
+        val prefs = base.getSharedPreferences("settings", MODE_PRIVATE)
+        val languageCode = prefs.getString("app_language", "") ?: ""
+
+        var context = base
+        if (languageCode.isNotEmpty()) {
+            val locale = Locale.forLanguageTag(languageCode)
+            Locale.setDefault(locale)
+
+            val config = Configuration(base.resources.configuration)
+            config.setLocale(locale)
+
+            context = base.createConfigurationContext(config)
+        }
+
+        super.attachBaseContext(context)
+    }
+
+    @SuppressLint("ObsoleteSdkInt")
+    override fun getResources(): Resources {
+        val resources = super.getResources()
+        val prefs = getSharedPreferences("settings", MODE_PRIVATE)
+        val languageCode = prefs.getString("app_language", "") ?: ""
+
+        if (languageCode.isNotEmpty()) {
+            val locale = Locale.forLanguageTag(languageCode)
+            val config = Configuration(resources.configuration)
+            config.setLocale(locale)
+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+                return createConfigurationContext(config).resources
+            } else {
+                @Suppress("DEPRECATION")
+                resources.updateConfiguration(config, resources.displayMetrics)
+            }
+        }
+
+        return resources
+    }
+
+    override fun onCreate() {
+        super.onCreate()
+        ksuApp = this
+
+        Platform.setHiddenApiExemptions()
+
+        val context = this
+        val iconSize = resources.getDimensionPixelSize(android.R.dimen.app_icon_size)
+        Coil.setImageLoader(
+            ImageLoader.Builder(context)
+                .components {
+                    add(AppIconKeyer())
+                    add(AppIconFetcher.Factory(iconSize, false, context))
+                }
+                .build()
+        )
+
+        val webroot = File(dataDir, "webroot")
+        if (!webroot.exists()) {
+            webroot.mkdir()
+        }
+    }
+
+    override fun onConfigurationChanged(newConfig: Configuration) {
+        super.onConfigurationChanged(newConfig)
+        applyLanguageSetting()
+    }
+
+    @SuppressLint("ObsoleteSdkInt")
+    private fun applyLanguageSetting() {
+        val prefs = getSharedPreferences("settings", MODE_PRIVATE)
+        val languageCode = prefs.getString("app_language", "") ?: ""
+
+        if (languageCode.isNotEmpty()) {
+            val locale = Locale.forLanguageTag(languageCode)
+            Locale.setDefault(locale)
+
+            val resources = resources
+            val config = Configuration(resources.configuration)
+            config.setLocale(locale)
+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+                createConfigurationContext(config)
+            } else {
+                @Suppress("DEPRECATION")
+                resources.updateConfiguration(config, resources.displayMetrics)
+            }
+        }
+    }
+}

manager/app/src/main/java/com/sukisu/ultra/Kernels.kt

@@ -1,4 +1,4 @@
-package shirkneko.zako.sukisu
+package com.sukisu.ultra
 
 import android.system.Os
 
@@ -8,24 +8,13 @@ import android.system.Os
  */
 
 data class KernelVersion(val major: Int, val patchLevel: Int, val subLevel: Int) {
-    override fun toString(): String {
-        return "$major.$patchLevel.$subLevel"
-    }
-
-    fun isGKI(): Boolean {
-
-        // kernel 6.x
-        if (major > 5) {
-            return true
-        }
-
-        // kernel 5.10.x
-        if (major == 5) {
-            return patchLevel >= 10
-        }
-
-        return false
+    override fun toString(): String = "$major.$patchLevel.$subLevel"
+    fun isGKI(): Boolean = when {
+        major > 5 -> true
+        major == 5 && patchLevel >= 10 -> true
+        else -> false
     }
+    fun isGKI1(): Boolean = (major == 4 && patchLevel >= 19) || (major == 5 && patchLevel < 10)
 }
 
 fun parseKernelVersion(version: String): KernelVersion {

manager/app/src/main/java/com/sukisu/ultra/Natives.kt

@@ -1,4 +1,4 @@
-package shirkneko.zako.sukisu
+package com.sukisu.ultra
 
 import android.os.Parcelable
 import androidx.annotation.Keep
@@ -26,6 +26,8 @@ object Natives {
     const val MINIMAL_SUPPORTED_SU_COMPAT = 12040
     const val KERNEL_SU_DOMAIN = "u:r:su:s0"
 
+    const val MINIMAL_SUPPORTED_KPM = 12800
+
     const val ROOT_UID = 0
     const val ROOT_GID = 0
 
@@ -66,6 +68,7 @@ object Natives {
      */
     external fun isSuEnabled(): Boolean
     external fun setSuEnabled(enabled: Boolean): Boolean
+    external fun isKPMEnabled(): Boolean
 
     private const val NON_ROOT_DEFAULT_PROFILE_KEY = "$"
     private const val NOBODY_UID = 9999

manager/app/src/main/java/com/sukisu/ultra/flash/KernelFlash.kt

@@ -0,0 +1,451 @@
+package com.sukisu.ultra.flash
+
+import android.app.Activity
+import android.content.Context
+import android.net.Uri
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.CheckCircle
+import androidx.compose.material.icons.filled.Error
+import androidx.compose.material3.*
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import androidx.documentfile.provider.DocumentFile
+import com.sukisu.ultra.R
+import com.sukisu.ultra.utils.AssetsUtil
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import java.io.File
+import java.io.FileOutputStream
+import java.io.IOException
+
+
+/**
+ * @author ShirkNeko
+ * @date 2025/5/31.
+ */
+data class FlashState(
+    val isFlashing: Boolean = false,
+    val isCompleted: Boolean = false,
+    val progress: Float = 0f,
+    val currentStep: String = "",
+    val logs: List<String> = emptyList(),
+    val error: String = ""
+)
+
+class HorizonKernelState {
+    private val _state = MutableStateFlow(FlashState())
+    val state: StateFlow<FlashState> = _state.asStateFlow()
+
+    fun updateProgress(progress: Float) {
+        _state.update { it.copy(progress = progress) }
+    }
+
+    fun updateStep(step: String) {
+        _state.update { it.copy(currentStep = step) }
+    }
+
+    fun addLog(log: String) {
+        _state.update {
+            it.copy(logs = it.logs + log)
+        }
+    }
+
+    fun setError(error: String) {
+        _state.update { it.copy(error = error) }
+    }
+
+    fun startFlashing() {
+        _state.update {
+            it.copy(
+                isFlashing = true,
+                isCompleted = false,
+                progress = 0f,
+                currentStep = "under preparation...",
+                logs = emptyList(),
+                error = ""
+            )
+        }
+    }
+
+    fun completeFlashing() {
+        _state.update { it.copy(isCompleted = true, progress = 1f) }
+    }
+
+    fun reset() {
+        _state.value = FlashState()
+    }
+}
+
+class HorizonKernelWorker(
+    private val context: Context,
+    private val state: HorizonKernelState,
+    private val slot: String? = null
+) : Thread() {
+    var uri: Uri? = null
+    private lateinit var filePath: String
+    private lateinit var binaryPath: String
+
+    private var onFlashComplete: (() -> Unit)? = null
+    private var originalSlot: String? = null
+
+    fun setOnFlashCompleteListener(listener: () -> Unit) {
+        onFlashComplete = listener
+    }
+
+    override fun run() {
+        state.startFlashing()
+        state.updateStep(context.getString(R.string.horizon_preparing))
+
+        filePath = "${context.filesDir.absolutePath}/${DocumentFile.fromSingleUri(context, uri!!)?.name}"
+        binaryPath = "${context.filesDir.absolutePath}/META-INF/com/google/android/update-binary"
+
+        try {
+            state.updateStep(context.getString(R.string.horizon_cleaning_files))
+            state.updateProgress(0.1f)
+            cleanup()
+
+            if (!rootAvailable()) {
+                state.setError(context.getString(R.string.root_required))
+                return
+            }
+
+            state.updateStep(context.getString(R.string.horizon_copying_files))
+            state.updateProgress(0.2f)
+            copy()
+
+            if (!File(filePath).exists()) {
+                state.setError(context.getString(R.string.horizon_copy_failed))
+                return
+            }
+
+            state.updateStep(context.getString(R.string.horizon_extracting_tool))
+            state.updateProgress(0.4f)
+            getBinary()
+
+            state.updateStep(context.getString(R.string.horizon_patching_script))
+            state.updateProgress(0.6f)
+            patch()
+
+            state.updateStep(context.getString(R.string.horizon_flashing))
+            state.updateProgress(0.7f)
+
+            val isAbDevice = isAbDevice()
+
+            if (isAbDevice && slot != null) {
+                state.updateStep(context.getString(R.string.horizon_getting_original_slot))
+                state.updateProgress(0.72f)
+                originalSlot = runCommandGetOutput(true, "getprop ro.boot.slot_suffix")
+
+                state.updateStep(context.getString(R.string.horizon_setting_target_slot))
+                state.updateProgress(0.74f)
+                runCommand(true, "resetprop -n ro.boot.slot_suffix _$slot")
+            }
+
+            flash()
+
+            if (isAbDevice && !originalSlot.isNullOrEmpty()) {
+                state.updateStep(context.getString(R.string.horizon_restoring_original_slot))
+                state.updateProgress(0.8f)
+                runCommand(true, "resetprop ro.boot.slot_suffix $originalSlot")
+            }
+
+            state.updateStep(context.getString(R.string.horizon_flash_complete_status))
+            state.completeFlashing()
+
+            (context as? Activity)?.runOnUiThread {
+                onFlashComplete?.invoke()
+            }
+        } catch (e: Exception) {
+            state.setError(e.message ?: context.getString(R.string.horizon_unknown_error))
+
+            if (isAbDevice() && !originalSlot.isNullOrEmpty()) {
+                state.updateStep(context.getString(R.string.horizon_restoring_original_slot))
+                state.updateProgress(0.8f)
+                runCommand(true, "resetprop ro.boot.slot_suffix $originalSlot")
+            }
+        }
+    }
+
+    // 检查设备是否为AB分区设备
+    private fun isAbDevice(): Boolean {
+        val abUpdate = runCommandGetOutput(true, "getprop ro.build.ab_update")?.trim() ?: ""
+        if (abUpdate.equals("false", ignoreCase = true) || abUpdate.isEmpty()) {
+            return false
+        }
+
+        val slotSuffix = runCommandGetOutput(true, "getprop ro.boot.slot_suffix")
+        return !slotSuffix.isNullOrEmpty()
+    }
+
+    private fun cleanup() {
+        runCommand(false, "find ${context.filesDir.absolutePath} -type f ! -name '*.jpg' ! -name '*.png' -delete")
+    }
+
+    private fun copy() {
+        uri?.let { safeUri ->
+            context.contentResolver.openInputStream(safeUri)?.use { input ->
+                FileOutputStream(File(filePath)).use { output ->
+                    input.copyTo(output)
+                }
+            }
+        }
+    }
+
+    private fun getBinary() {
+        runCommand(false, "unzip \"$filePath\" \"*/update-binary\" -d ${context.filesDir.absolutePath}")
+        if (!File(binaryPath).exists()) {
+            throw IOException("Failed to extract update-binary")
+        }
+    }
+
+    private fun patch() {
+        val kernelVersion = runCommandGetOutput(true, "cat /proc/version")
+        val versionRegex = """\d+\.\d+\.\d+""".toRegex()
+        val version = kernelVersion?.let { versionRegex.find(it) }?.value ?: ""
+        val toolName = if (version.isNotEmpty()) {
+            val parts = version.split('.')
+            if (parts.size >= 2) {
+                val major = parts[0].toIntOrNull() ?: 0
+                val minor = parts[1].toIntOrNull() ?: 0
+                if (major < 5 || (major == 5 && minor <= 10)) "5_10" else "5_15+"
+            } else {
+                "5_15+"
+            }
+        } else {
+            "5_15+"
+        }
+        val toolPath = "${context.filesDir.absolutePath}/mkbootfs"
+        AssetsUtil.exportFiles(context, "$toolName-mkbootfs", toolPath)
+        state.addLog("${context.getString(R.string.kernel_version_log, version)} ${context.getString(R.string.tool_version_log, toolName)}")
+        runCommand(false, "sed -i '/chmod -R 755 tools bin;/i cp -f $toolPath \$AKHOME/tools;' $binaryPath")
+    }
+
+    private fun flash() {
+        val process = ProcessBuilder("su")
+            .redirectErrorStream(true)
+            .start()
+
+        try {
+            process.outputStream.bufferedWriter().use { writer ->
+                writer.write("export POSTINSTALL=${context.filesDir.absolutePath}\n")
+
+                // 写入槽位信息到临时文件
+                slot?.let { selectedSlot ->
+                    writer.write("echo \"$selectedSlot\" > ${context.filesDir.absolutePath}/bootslot\n")
+                }
+
+                // 构建刷写命令
+                val flashCommand = buildString {
+                    append("sh $binaryPath 3 1 \"$filePath\"")
+                    if (slot != null) {
+                        append(" \"$(cat ${context.filesDir.absolutePath}/bootslot)\"")
+                    }
+                    append(" && touch ${context.filesDir.absolutePath}/done\n")
+                }
+
+                writer.write(flashCommand)
+                writer.write("exit\n")
+                writer.flush()
+            }
+
+            process.inputStream.bufferedReader().use { reader ->
+                reader.lineSequence().forEach { line ->
+                    if (line.startsWith("ui_print")) {
+                        val logMessage = line.removePrefix("ui_print").trim()
+                        state.addLog(logMessage)
+
+                        when {
+                            logMessage.contains("extracting", ignoreCase = true) -> {
+                                state.updateProgress(0.75f)
+                            }
+                            logMessage.contains("installing", ignoreCase = true) -> {
+                                state.updateProgress(0.85f)
+                            }
+                            logMessage.contains("complete", ignoreCase = true) -> {
+                                state.updateProgress(0.95f)
+                            }
+                        }
+                    }
+                }
+            }
+        } finally {
+            process.destroy()
+        }
+
+        if (!File("${context.filesDir.absolutePath}/done").exists()) {
+            throw IOException(context.getString(R.string.flash_failed_message))
+        }
+    }
+
+    private fun runCommand(su: Boolean, cmd: String): Int {
+        val process = ProcessBuilder(if (su) "su" else "sh")
+            .redirectErrorStream(true)
+            .start()
+
+        return try {
+            process.outputStream.bufferedWriter().use { writer ->
+                writer.write("$cmd\n")
+                writer.write("exit\n")
+                writer.flush()
+            }
+            process.waitFor()
+        } finally {
+            process.destroy()
+        }
+    }
+
+    private fun runCommandGetOutput(su: Boolean, cmd: String): String? {
+        val process = ProcessBuilder(if (su) "su" else "sh")
+            .redirectErrorStream(true)
+            .start()
+
+        return try {
+            process.outputStream.bufferedWriter().use { writer ->
+                writer.write("$cmd\n")
+                writer.write("exit\n")
+                writer.flush()
+            }
+            process.inputStream.bufferedReader().use { reader ->
+                reader.readText().trim()
+            }
+        } catch (_: Exception) {
+            ""
+        } finally {
+            process.destroy()
+        }
+    }
+
+    private fun rootAvailable(): Boolean {
+        return try {
+            val process = Runtime.getRuntime().exec("su -c id")
+            val exitValue = process.waitFor()
+            exitValue == 0
+        } catch (_: Exception) {
+            false
+        }
+    }
+}
+
+@Composable
+fun HorizonKernelFlashProgress(state: FlashState) {
+    Card(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(16.dp),
+        colors = CardDefaults.cardColors(
+            containerColor = MaterialTheme.colorScheme.surfaceVariant
+        )
+    ) {
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(16.dp),
+            horizontalAlignment = Alignment.CenterHorizontally
+        ) {
+            Text(
+                text = stringResource(id = R.string.horizon_flash_title),
+                style = MaterialTheme.typography.titleMedium,
+                modifier = Modifier.padding(bottom = 8.dp)
+            )
+
+            LinearProgressIndicator(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(vertical = 8.dp),
+                progress = { state.progress },
+            )
+
+            Text(
+                text = state.currentStep,
+                style = MaterialTheme.typography.bodyMedium,
+                modifier = Modifier.padding(vertical = 4.dp)
+            )
+
+            if (state.logs.isNotEmpty()) {
+                Text(
+                    text = stringResource(id = R.string.horizon_logs_label),
+                    style = MaterialTheme.typography.labelMedium,
+                    modifier = Modifier
+                        .align(Alignment.Start)
+                        .padding(top = 8.dp, bottom = 4.dp)
+                )
+
+                Surface(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .heightIn(max = 230.dp)
+                        .padding(vertical = 4.dp),
+                    color = MaterialTheme.colorScheme.surface,
+                    tonalElevation = 1.dp,
+                    shape = MaterialTheme.shapes.small
+                ) {
+                    Column(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .padding(8.dp)
+                            .verticalScroll(rememberScrollState())
+                    ) {
+                        state.logs.forEach { log ->
+                            Text(
+                                text = log,
+                                style = MaterialTheme.typography.bodySmall,
+                                modifier = Modifier.padding(vertical = 2.dp),
+                                overflow = TextOverflow.Ellipsis,
+                                maxLines = 1
+                            )
+                        }
+                    }
+                }
+            }
+
+            if (state.error.isNotEmpty()) {
+                Row(
+                    verticalAlignment = Alignment.CenterVertically,
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(top = 8.dp)
+                ) {
+                    Icon(
+                        imageVector = Icons.Default.Error,
+                        contentDescription = null,
+                        tint = MaterialTheme.colorScheme.error,
+                        modifier = Modifier.padding(end = 8.dp)
+                    )
+                    Text(
+                        text = state.error,
+                        style = MaterialTheme.typography.bodyMedium,
+                        color = MaterialTheme.colorScheme.error
+                    )
+                }
+            } else if (state.isCompleted) {
+                Row(
+                    verticalAlignment = Alignment.CenterVertically,
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(top = 8.dp)
+                ) {
+                    Icon(
+                        imageVector = Icons.Default.CheckCircle,
+                        contentDescription = null,
+                        tint = MaterialTheme.colorScheme.primary,
+                        modifier = Modifier.padding(end = 8.dp)
+                    )
+                    Text(
+                        text = stringResource(id = R.string.horizon_flash_complete),
+                        style = MaterialTheme.typography.bodyMedium,
+                        color = MaterialTheme.colorScheme.primary
+                    )
+                }
+            }
+        }
+    }
+}

manager/app/src/main/java/com/sukisu/ultra/profile/Capabilities.kt

@@ -1,4 +1,4 @@
-package shirkneko.zako.sukisu.profile
+package com.sukisu.ultra.profile
 
 /**
  * @author weishu

manager/app/src/main/java/com/sukisu/ultra/profile/Groups.kt

@@ -1,4 +1,4 @@
-package shirkneko.zako.sukisu.profile
+package com.sukisu.ultra.profile
 
 /**
  * https://cs.android.com/android/platform/superproject/main/+/main:system/core/libcutils/include/private/android_filesystem_config.h

manager/app/src/main/java/com/sukisu/ultra/ui/MainActivity.kt

@@ -0,0 +1,369 @@
+package com.sukisu.ultra.ui
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.content.res.Configuration
+import android.database.ContentObserver
+import android.os.Build
+import android.os.Bundle
+import android.os.Handler
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.activity.enableEdgeToEdge
+import androidx.compose.animation.*
+import androidx.compose.animation.core.tween
+import androidx.compose.foundation.layout.*
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.navigation.NavBackStackEntry
+import androidx.navigation.NavHostController
+import androidx.navigation.compose.rememberNavController
+import com.ramcosta.composedestinations.DestinationsNavHost
+import com.ramcosta.composedestinations.animations.NavHostAnimatedDestinationStyle
+import com.ramcosta.composedestinations.generated.NavGraphs
+import com.ramcosta.composedestinations.generated.destinations.ExecuteModuleActionScreenDestination
+import com.ramcosta.composedestinations.spec.NavHostGraphSpec
+import com.ramcosta.composedestinations.spec.RouteOrDirection
+import com.ramcosta.composedestinations.utils.isRouteOnBackStackAsState
+import com.ramcosta.composedestinations.utils.rememberDestinationsNavigator
+import io.sukisu.ultra.UltraToolInstall
+import com.sukisu.ultra.Natives
+import com.sukisu.ultra.ksuApp
+import com.sukisu.ultra.ui.screen.BottomBarDestination
+import com.sukisu.ultra.ui.theme.*
+import com.sukisu.ultra.ui.theme.CardConfig.cardAlpha
+import com.sukisu.ultra.ui.util.*
+import androidx.core.content.edit
+import com.sukisu.ultra.ui.theme.CardConfig.cardElevation
+import com.sukisu.ultra.ui.webui.initPlatform
+import java.util.Locale
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.slideInVertically
+import androidx.compose.animation.slideOutVertically
+import androidx.navigation.compose.currentBackStackEntryAsState
+import androidx.lifecycle.lifecycleScope
+import com.sukisu.ultra.ui.viewmodel.HomeViewModel
+import com.sukisu.ultra.ui.viewmodel.SuperUserViewModel
+import kotlinx.coroutines.launch
+
+class MainActivity : ComponentActivity() {
+    private lateinit var superUserViewModel: SuperUserViewModel
+    private lateinit var homeViewModel: HomeViewModel
+
+    private inner class ThemeChangeContentObserver(
+        handler: Handler,
+        private val onThemeChanged: () -> Unit
+    ) : ContentObserver(handler) {
+        override fun onChange(selfChange: Boolean) {
+            super.onChange(selfChange)
+            onThemeChanged()
+        }
+    }
+
+    // 应用保存的语言设置
+    @SuppressLint("ObsoleteSdkInt")
+    private fun applyLanguageSetting() {
+        val prefs = getSharedPreferences("settings", MODE_PRIVATE)
+        val languageCode = prefs.getString("app_language", "") ?: ""
+
+        if (languageCode.isNotEmpty()) {
+            val locale = Locale.forLanguageTag(languageCode)
+            Locale.setDefault(locale)
+
+            val resources = resources
+            val config = Configuration(resources.configuration)
+            config.setLocale(locale)
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+                createConfigurationContext(config)
+            } else {
+                @Suppress("DEPRECATION")
+                resources.updateConfiguration(config, resources.displayMetrics)
+            }
+        }
+    }
+
+    override fun attachBaseContext(newBase: Context) {
+        val prefs = newBase.getSharedPreferences("settings", MODE_PRIVATE)
+        val languageCode = prefs.getString("app_language", "") ?: ""
+
+        var context = newBase
+        if (languageCode.isNotEmpty()) {
+            val locale = Locale.forLanguageTag(languageCode)
+            Locale.setDefault(locale)
+
+            val config = Configuration(newBase.resources.configuration)
+            config.setLocale(locale)
+            context = newBase.createConfigurationContext(config)
+        }
+
+        super.attachBaseContext(context)
+    }
+
+    @SuppressLint("RestrictedApi")
+    override fun onCreate(savedInstanceState: Bundle?) {
+        // 确保应用正确的语言设置
+        applyLanguageSetting()
+
+        // 应用自定义 DPI
+        applyCustomDpi()
+
+        // Enable edge to edge
+        enableEdgeToEdge()
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            window.isNavigationBarContrastEnforced = false
+        }
+
+        super.onCreate(savedInstanceState)
+
+        // 初始化 SuperUserViewModel
+        superUserViewModel = SuperUserViewModel()
+
+        lifecycleScope.launch {
+            superUserViewModel.fetchAppList()
+        }
+
+        // 初始化 HomeViewModel
+        homeViewModel = HomeViewModel()
+
+        // 预加载数据
+        lifecycleScope.launch {
+            homeViewModel.initializeData()
+        }
+
+        val prefs = getSharedPreferences("settings", MODE_PRIVATE)
+        val isFirstRun = prefs.getBoolean("is_first_run", true)
+
+        if (isFirstRun) {
+            ThemeConfig.preventBackgroundRefresh = false
+            getSharedPreferences("theme_prefs", MODE_PRIVATE).edit {
+                putBoolean("prevent_background_refresh", false)
+            }
+            prefs.edit { putBoolean("is_first_run", false) }
+        }
+
+        // 加载保存的背景设置
+        loadThemeMode()
+        loadThemeColors()
+        loadDynamicColorState()
+        CardConfig.load(applicationContext)
+
+        val contentObserver = ThemeChangeContentObserver(Handler(mainLooper)) {
+            runOnUiThread {
+                if (!ThemeConfig.preventBackgroundRefresh) {
+                    ThemeConfig.backgroundImageLoaded = false
+                    loadCustomBackground()
+                }
+            }
+        }
+
+        contentResolver.registerContentObserver(
+            android.provider.Settings.System.getUriFor("ui_night_mode"),
+            false,
+            contentObserver
+        )
+
+        val destroyListeners = mutableListOf<() -> Unit>()
+        destroyListeners.add {
+            contentResolver.unregisterContentObserver(contentObserver)
+        }
+
+        val isManager = Natives.becomeManager(ksuApp.packageName)
+        if (isManager) {
+            install()
+            UltraToolInstall.tryToInstall()
+        }
+
+        setContent {
+            KernelSUTheme {
+                val navController = rememberNavController()
+                val snackBarHostState = remember { SnackbarHostState() }
+                val currentDestination = navController.currentBackStackEntryAsState().value?.destination
+
+                val showBottomBar = when (currentDestination?.route) {
+                    ExecuteModuleActionScreenDestination.route -> false // Hide for ExecuteModuleActionScreen
+                    else -> true
+                }
+
+                // pre-init platform to faster start WebUI X activities
+                LaunchedEffect(Unit) {
+                    initPlatform()
+                }
+
+                Scaffold(
+                    bottomBar = {
+                        AnimatedVisibility(
+                            visible = showBottomBar,
+                            enter = slideInVertically(initialOffsetY = { it }) + fadeIn(),
+                            exit = slideOutVertically(targetOffsetY = { it }) + fadeOut()
+                        ) {
+                            BottomBar(navController)
+                        }
+                    },
+                    contentWindowInsets = WindowInsets(0, 0, 0, 0)
+                ) { innerPadding ->
+                    CompositionLocalProvider(
+                        LocalSnackbarHost provides snackBarHostState
+                    ) {
+                        DestinationsNavHost(
+                            modifier = Modifier.padding(innerPadding),
+                            navGraph = NavGraphs.root as NavHostGraphSpec,
+                            navController = navController,
+                            defaultTransitions = object : NavHostAnimatedDestinationStyle() {
+                                override val enterTransition: AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition
+                                    get() = { fadeIn(animationSpec = tween(340)) }
+                                override val exitTransition: AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition
+                                    get() = { fadeOut(animationSpec = tween(340)) }
+                            }
+                        )
+                    }
+                }
+            }
+        }
+    }
+
+    // 应用自定义DPI设置
+    private fun applyCustomDpi() {
+        val prefs = getSharedPreferences("settings", MODE_PRIVATE)
+        val customDpi = prefs.getInt("app_dpi", 0)
+
+        if (customDpi > 0) {
+            try {
+                val resources = resources
+                val metrics = resources.displayMetrics
+                metrics.density = customDpi / 160f
+                @Suppress("DEPRECATION")
+                metrics.scaledDensity = customDpi / 160f
+                metrics.densityDpi = customDpi
+            } catch (e: Exception) {
+                e.printStackTrace()
+            }
+        }
+    }
+
+    override fun onPause() {
+        super.onPause()
+        CardConfig.save(applicationContext)
+        getSharedPreferences("theme_prefs", MODE_PRIVATE).edit {
+            putBoolean("prevent_background_refresh", true)
+        }
+        ThemeConfig.preventBackgroundRefresh = true
+    }
+
+    override fun onResume() {
+        super.onResume()
+        applyLanguageSetting()
+
+        if (!ThemeConfig.backgroundImageLoaded && !ThemeConfig.preventBackgroundRefresh) {
+            loadCustomBackground()
+        }
+
+        lifecycleScope.launch {
+            superUserViewModel.fetchAppList()
+        }
+
+        lifecycleScope.launch {
+            homeViewModel.initializeData()
+        }
+    }
+
+    private val destroyListeners = mutableListOf<() -> Unit>()
+
+    override fun onDestroy() {
+        destroyListeners.forEach { it() }
+        super.onDestroy()
+    }
+
+    override fun onConfigurationChanged(newConfig: Configuration) {
+        super.onConfigurationChanged(newConfig)
+        applyLanguageSetting()
+    }
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun BottomBar(navController: NavHostController) {
+    val navigator = navController.rememberDestinationsNavigator()
+    val isManager = Natives.becomeManager(ksuApp.packageName)
+    val fullFeatured = isManager && !Natives.requireNewKernel() && rootAvailable()
+    val kpmVersion = getKpmVersion()
+    val cardColor = MaterialTheme.colorScheme.surfaceContainer
+
+    // 检查是否显示KPM
+    val showKpmInfo = LocalContext.current.getSharedPreferences("settings", Context.MODE_PRIVATE)
+        .getBoolean("show_kpm_info", true)
+
+    NavigationBar(
+        modifier = Modifier.windowInsetsPadding(
+            WindowInsets.navigationBars.only(WindowInsetsSides.Horizontal)
+        ),
+        containerColor = TopAppBarDefaults.topAppBarColors(
+            containerColor = cardColor.copy(alpha = cardAlpha),
+            scrolledContainerColor = cardColor.copy(alpha = cardAlpha)
+        ).containerColor,
+        tonalElevation = cardElevation
+    ) {
+        BottomBarDestination.entries.forEach { destination ->
+            if (destination == BottomBarDestination.Kpm) {
+                if (kpmVersion.isNotEmpty() && !kpmVersion.startsWith("Error") && showKpmInfo && Natives.version >= Natives.MINIMAL_SUPPORTED_KPM) {
+                    if (!fullFeatured && destination.rootRequired) return@forEach
+                    val isCurrentDestOnBackStack by navController.isRouteOnBackStackAsState(destination.direction)
+                    NavigationBarItem(
+                        selected = isCurrentDestOnBackStack,
+                        onClick = {
+                            if (!isCurrentDestOnBackStack) {
+                                navigator.popBackStack(destination.direction, false)
+                            }
+                            navigator.navigate(destination.direction) {
+                                popUpTo(NavGraphs.root as RouteOrDirection) {
+                                    saveState = true
+                                }
+                                launchSingleTop = true
+                                restoreState = true
+                            }
+                        },
+                        icon = {
+                            if (isCurrentDestOnBackStack) {
+                                Icon(destination.iconSelected, stringResource(destination.label))
+                            } else {
+                                Icon(destination.iconNotSelected, stringResource(destination.label))
+                            }
+                        },
+                        label = { Text(stringResource(destination.label),style = MaterialTheme.typography.labelMedium) },
+                        alwaysShowLabel = false
+                    )
+                }
+            } else {
+                if (!fullFeatured && destination.rootRequired) return@forEach
+                val isCurrentDestOnBackStack by navController.isRouteOnBackStackAsState(destination.direction)
+                NavigationBarItem(
+                    selected = isCurrentDestOnBackStack,
+                    onClick = {
+                        if (isCurrentDestOnBackStack) {
+                            navigator.popBackStack(destination.direction, false)
+                        }
+                        navigator.navigate(destination.direction) {
+                            popUpTo(NavGraphs.root) {
+                                saveState = true
+                            }
+                            launchSingleTop = true
+                            restoreState = true
+                        }
+                    },
+                    icon = {
+                        if (isCurrentDestOnBackStack) {
+                            Icon(destination.iconSelected, stringResource(destination.label))
+                        } else {
+                            Icon(destination.iconNotSelected, stringResource(destination.label))
+                        }
+                    },
+                    label = { Text(stringResource(destination.label),style = MaterialTheme.typography.labelMedium) },
+                    alwaysShowLabel = false
+                )
+            }
+        }
+    }
+}

manager/app/src/main/java/com/sukisu/ultra/ui/component/AboutCard.kt

@@ -1,4 +1,4 @@
-package shirkneko.zako.sukisu.ui.component
+package com.sukisu.ultra.ui.component
 
 import androidx.compose.foundation.Image
 import androidx.compose.foundation.layout.Column
@@ -31,8 +31,8 @@ import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import androidx.compose.ui.window.Dialog
-import shirkneko.zako.sukisu.BuildConfig
-import shirkneko.zako.sukisu.R
+import com.sukisu.ultra.BuildConfig
+import com.sukisu.ultra.R
 
 @Preview
 @Composable
@@ -98,7 +98,7 @@ private fun AboutCardContent() {
                 val annotatedString = AnnotatedString.Companion.fromHtml(
                     htmlString = stringResource(
                         id = R.string.about_source_code,
-                        "<b><a href=\"https://github.com/ShirkNeko/KernelSU\">GitHub</a></b>",
+                        "<b><a href=\"https://github.com/ShirkNeko/SukiSU-Ultra\">GitHub</a></b>",
                         "<b><a href=\"https://t.me/SukiKSU\">Telegram</a></b>"
                     ),
                     linkStyles = TextLinkStyles(

manager/app/src/main/java/com/sukisu/ultra/ui/component/Dialog.kt

@@ -1,4 +1,4 @@
-package shirkneko.zako.sukisu.ui.component
+package com.sukisu.ultra.ui.component
 
 import android.graphics.text.LineBreaker
 import android.os.Build

manager/app/src/main/java/com/sukisu/ultra/ui/component/ImageEditorDialog.kt

@@ -0,0 +1,223 @@
+package com.sukisu.ultra.ui.component
+
+import android.net.Uri
+import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.foundation.background
+import androidx.compose.foundation.gestures.detectTransformGestures
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Check
+import androidx.compose.material.icons.filled.Close
+import androidx.compose.material.icons.filled.Fullscreen
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.window.Dialog
+import androidx.compose.ui.window.DialogProperties
+import coil.compose.AsyncImage
+import coil.request.ImageRequest
+import com.sukisu.ultra.R
+import com.sukisu.ultra.ui.util.BackgroundTransformation
+import com.sukisu.ultra.ui.util.saveTransformedBackground
+import kotlinx.coroutines.launch
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.ui.geometry.Size
+import androidx.compose.ui.layout.onSizeChanged
+import kotlin.math.max
+
+@Composable
+fun ImageEditorDialog(
+    imageUri: Uri,
+    onDismiss: () -> Unit,
+    onConfirm: (Uri) -> Unit
+) {
+    var scale by remember { mutableFloatStateOf(1f) }
+    var offsetX by remember { mutableFloatStateOf(0f) }
+    var offsetY by remember { mutableFloatStateOf(0f) }
+    val context = LocalContext.current
+    val scope = rememberCoroutineScope()
+    var lastScale by remember { mutableFloatStateOf(1f) }
+    var lastOffsetX by remember { mutableFloatStateOf(0f) }
+    var lastOffsetY by remember { mutableFloatStateOf(0f) }
+    var imageSize by remember { mutableStateOf(Size.Zero) }
+    var screenSize by remember { mutableStateOf(Size.Zero) }
+    val animatedScale by animateFloatAsState(
+        targetValue = scale,
+        label = "ScaleAnimation"
+    )
+    val animatedOffsetX by animateFloatAsState(
+        targetValue = offsetX,
+        label = "OffsetXAnimation"
+    )
+    val animatedOffsetY by animateFloatAsState(
+        targetValue = offsetY,
+        label = "OffsetYAnimation"
+    )
+    val updateTransformation = remember {
+        { newScale: Float, newOffsetX: Float, newOffsetY: Float ->
+            val scaleDiff = kotlin.math.abs(newScale - lastScale)
+            val offsetXDiff = kotlin.math.abs(newOffsetX - lastOffsetX)
+            val offsetYDiff = kotlin.math.abs(newOffsetY - lastOffsetY)
+            if (scaleDiff > 0.01f || offsetXDiff > 1f || offsetYDiff > 1f) {
+                scale = newScale
+                offsetX = newOffsetX
+                offsetY = newOffsetY
+                lastScale = newScale
+                lastOffsetX = newOffsetX
+                lastOffsetY = newOffsetY
+            }
+        }
+    }
+    val scaleToFullScreen = remember {
+        {
+            if (imageSize.height > 0 && screenSize.height > 0) {
+                val newScale = screenSize.height / imageSize.height
+                updateTransformation(newScale, 0f, 0f)
+            }
+        }
+    }
+
+    Dialog(
+        onDismissRequest = onDismiss,
+        properties = DialogProperties(
+            dismissOnBackPress = true,
+            dismissOnClickOutside = false,
+            usePlatformDefaultWidth = false
+        )
+    ) {
+        Box(
+            modifier = Modifier
+                .fillMaxSize()
+                .background(Color.Black.copy(alpha = 0.9f))
+                .onSizeChanged { size ->
+                    screenSize = Size(size.width.toFloat(), size.height.toFloat())
+                }
+        ) {
+            AsyncImage(
+                model = ImageRequest.Builder(LocalContext.current)
+                    .data(imageUri)
+                    .crossfade(true)
+                    .build(),
+                contentDescription = stringResource(R.string.settings_custom_background),
+                contentScale = ContentScale.Fit,
+                modifier = Modifier
+                    .fillMaxSize()
+                    .graphicsLayer(
+                        scaleX = animatedScale,
+                        scaleY = animatedScale,
+                        translationX = animatedOffsetX,
+                        translationY = animatedOffsetY
+                    )
+                    .pointerInput(Unit) {
+                        detectTransformGestures { _, pan, zoom, _ ->
+                            scope.launch {
+                                try {
+                                    val newScale = (scale * zoom).coerceIn(0.5f, 3f)
+                                    val maxOffsetX = max(0f, size.width * (newScale - 1) / 2)
+                                    val maxOffsetY = max(0f, size.height * (newScale - 1) / 2)
+                                    val newOffsetX = if (maxOffsetX > 0) {
+                                        (offsetX + pan.x).coerceIn(-maxOffsetX, maxOffsetX)
+                                    } else {
+                                        0f
+                                    }
+                                    val newOffsetY = if (maxOffsetY > 0) {
+                                        (offsetY + pan.y).coerceIn(-maxOffsetY, maxOffsetY)
+                                    } else {
+                                        0f
+                                    }
+                                    updateTransformation(newScale, newOffsetX, newOffsetY)
+                                } catch (e: Exception) {
+                                    updateTransformation(lastScale, lastOffsetX, lastOffsetY)
+                                }
+                            }
+                        }
+                    }
+                    .onSizeChanged { size ->
+                        imageSize = Size(size.width.toFloat(), size.height.toFloat())
+                    }
+            )
+            Row(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(16.dp)
+                    .align(Alignment.TopCenter),
+                horizontalArrangement = Arrangement.SpaceBetween
+            ) {
+                IconButton(
+                    onClick = onDismiss,
+                    modifier = Modifier
+                        .clip(RoundedCornerShape(8.dp))
+                        .background(Color.Black.copy(alpha = 0.6f))
+                ) {
+                    Icon(
+                        imageVector = Icons.Default.Close,
+                        contentDescription = stringResource(R.string.cancel),
+                        tint = Color.White
+                    )
+                }
+                IconButton(
+                    onClick = { scaleToFullScreen() },
+                    modifier = Modifier
+                        .clip(RoundedCornerShape(8.dp))
+                        .background(Color.Black.copy(alpha = 0.6f))
+                ) {
+                    Icon(
+                        imageVector = Icons.Default.Fullscreen,
+                        contentDescription = stringResource(R.string.reprovision),
+                        tint = Color.White
+                    )
+                }
+                IconButton(
+                    onClick = {
+                        scope.launch {
+                            try {
+                                val transformation = BackgroundTransformation(scale, offsetX, offsetY)
+                                val savedUri = context.saveTransformedBackground(imageUri, transformation)
+                                savedUri?.let { onConfirm(it) }
+                            } catch (e: Exception) {
+                                ""
+                            }
+                        }
+                    },
+                    modifier = Modifier
+                        .clip(RoundedCornerShape(8.dp))
+                        .background(Color.Black.copy(alpha = 0.6f))
+                ) {
+                    Icon(
+                        imageVector = Icons.Default.Check,
+                        contentDescription = stringResource(R.string.confirm),
+                        tint = Color.White
+                    )
+                }
+            }
+
+            Box(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(16.dp)
+                    .clip(RoundedCornerShape(8.dp))
+                    .background(Color.Black.copy(alpha = 0.6f))
+                    .padding(16.dp)
+                    .align(Alignment.BottomCenter)
+            ) {
+                Text(
+                    text = stringResource(id = R.string.image_editor_hint),
+                    color = Color.White,
+                    style = MaterialTheme.typography.bodyMedium
+                )
+            }
+        }
+    }
+}

manager/app/src/main/java/com/sukisu/ultra/ui/component/KeyEventBlocker.kt

@@ -1,4 +1,4 @@
-package shirkneko.zako.sukisu.ui.component
+package com.sukisu.ultra.ui.component
 
 import androidx.compose.foundation.focusable
 import androidx.compose.foundation.layout.Box

manager/app/src/main/java/com/sukisu/ultra/ui/component/KsuIsValidCheck.kt

@@ -0,0 +1,17 @@
+package com.sukisu.ultra.ui.component
+
+import androidx.compose.runtime.Composable
+import com.sukisu.ultra.Natives
+import com.sukisu.ultra.ksuApp
+
+@Composable
+fun KsuIsValid(
+    content: @Composable () -> Unit
+) {
+    val isManager = Natives.becomeManager(ksuApp.packageName)
+    val ksuVersion = if (isManager) Natives.version else null
+
+    if (ksuVersion != null) {
+        content()
+    }
+}

manager/app/src/main/java/com/sukisu/ultra/ui/component/SearchBar.kt

@@ -1,4 +1,4 @@
-package shirkneko.zako.sukisu.ui.component
+package com.sukisu.ultra.ui.component
 
 import android.util.Log
 import androidx.compose.animation.AnimatedVisibility
@@ -42,7 +42,7 @@ import androidx.compose.ui.platform.LocalSoftwareKeyboardController
 import androidx.compose.ui.text.input.ImeAction
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
-import shirkneko.zako.sukisu.ui.theme.CardConfig
+import com.sukisu.ultra.ui.theme.CardConfig
 
 private const val TAG = "SearchBar"
 
@@ -63,7 +63,7 @@ fun SearchAppBar(
     var onSearch by remember { mutableStateOf(false) }
 
     // 获取卡片颜色和透明度
-    val cardColor = MaterialTheme.colorScheme.secondaryContainer
+    val cardColor = MaterialTheme.colorScheme.surfaceContainerLow
     val cardAlpha = CardConfig.cardAlpha
 
     if (onSearch) {

manager/app/src/main/java/com/sukisu/ultra/ui/component/SettingsItem.kt

@@ -1,18 +1,21 @@
-package shirkneko.zako.sukisu.ui.component
+package com.sukisu.ultra.ui.component
 
 import androidx.compose.foundation.LocalIndication
 import androidx.compose.foundation.interaction.MutableInteractionSource
 import androidx.compose.foundation.selection.toggleable
 import androidx.compose.material3.Icon
 import androidx.compose.material3.ListItem
-import androidx.compose.material3.RadioButton
+import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Switch
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.alpha
 import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.semantics.Role
+import com.dergoogler.mmrl.ui.component.LabelItem
+import com.dergoogler.mmrl.ui.component.text.TextRow
 
 @Composable
 fun SwitchItem(
@@ -21,9 +24,11 @@ fun SwitchItem(
     summary: String? = null,
     checked: Boolean,
     enabled: Boolean = true,
-    onCheckedChange: (Boolean) -> Unit
+    beta: Boolean = false,
+    onCheckedChange: (Boolean) -> Unit,
 ) {
     val interactionSource = remember { MutableInteractionSource() }
+    val stateAlpha = remember(checked, enabled) { Modifier.alpha(if (enabled) 1f else 0.5f) }
 
     ListItem(
         modifier = Modifier
@@ -36,10 +41,31 @@ fun SwitchItem(
                 onValueChange = onCheckedChange
             ),
         headlineContent = {
-            Text(title)
+            TextRow(
+                leadingContent = if (beta) {
+                    {
+                        LabelItem(
+                            modifier = Modifier.then(stateAlpha),
+                            text = "Beta"
+                        )
+                    }
+                } else null
+            ) {
+                Text(
+                    modifier = Modifier.then(stateAlpha),
+                    text = title,
+                )
+            }
         },
         leadingContent = icon?.let {
-            { Icon(icon, title) }
+            {
+                Icon(
+                    modifier = Modifier.then(stateAlpha),
+                    imageVector = icon,
+                    contentDescription = title,
+                    tint = MaterialTheme.colorScheme.primary
+                )
+            }
         },
         trailingContent = {
             Switch(
@@ -51,24 +77,11 @@ fun SwitchItem(
         },
         supportingContent = {
             if (summary != null) {
-                Text(summary)
+                Text(
+                    modifier = Modifier.then(stateAlpha),
+                    text = summary
+                )
             }
         }
     )
 }
-
-@Composable
-fun RadioItem(
-    title: String,
-    selected: Boolean,
-    onClick: () -> Unit,
-) {
-    ListItem(
-        headlineContent = {
-            Text(title)
-        },
-        leadingContent = {
-            RadioButton(selected = selected, onClick = onClick)
-        }
-    )
-}

manager/app/src/main/java/com/sukisu/ultra/ui/component/SlotSelectionDialog.kt

@@ -0,0 +1,244 @@
+package com.sukisu.ultra.ui.component
+
+import android.content.Context
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.horizontalScroll
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import com.sukisu.ultra.R
+import com.sukisu.ultra.ui.theme.ThemeConfig
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.SdStorage
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.vector.ImageVector
+
+/**
+ * 槽位选择对话框组件
+ * 用于Kernel刷写时选择目标槽位
+ */
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun SlotSelectionDialog(
+    show: Boolean,
+    onDismiss: () -> Unit,
+    onSlotSelected: (String) -> Unit
+) {
+    val context = LocalContext.current
+    var currentSlot by remember { mutableStateOf<String?>(null) }
+    var errorMessage by remember { mutableStateOf<String?>(null) }
+
+    LaunchedEffect(Unit) {
+        try {
+            currentSlot = getCurrentSlot(context)
+            errorMessage = null
+        } catch (e: Exception) {
+            errorMessage = e.message
+            currentSlot = null
+        }
+    }
+
+    if (show) {
+        val cardColor = MaterialTheme.colorScheme.surfaceContainerHighest
+
+        AlertDialog(
+            onDismissRequest = onDismiss,
+            title = {
+                Text(
+                    text = stringResource(id = R.string.select_slot_title),
+                    style = MaterialTheme.typography.headlineSmall,
+                    color = MaterialTheme.colorScheme.onSurface
+                )
+            },
+            text = {
+                Column(
+                    modifier = Modifier.padding(vertical = 8.dp),
+                    verticalArrangement = Arrangement.spacedBy(16.dp)
+                ) {
+                    if (errorMessage != null) {
+                        Text(
+                            text = "Error: $errorMessage",
+                            style = MaterialTheme.typography.bodyMedium,
+                            color = MaterialTheme.colorScheme.error,
+                            textAlign = TextAlign.Center
+                        )
+                    } else {
+                        Text(
+                            text = stringResource(
+                                id = R.string.current_slot,
+                                currentSlot ?: "Unknown"
+                            ),
+                            style = MaterialTheme.typography.bodyMedium,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant,
+                            textAlign = TextAlign.Center
+                        )
+                    }
+
+                    Spacer(modifier = Modifier.height(12.dp))
+
+                    Text(
+                        text = stringResource(id = R.string.select_slot_description),
+                        style = MaterialTheme.typography.bodyMedium,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                        textAlign = TextAlign.Center
+                    )
+
+                    Spacer(modifier = Modifier.height(24.dp))
+
+                    // Horizontal arrangement for slot options with highlighted current slot
+                    Row(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .horizontalScroll(rememberScrollState()),
+                        horizontalArrangement = Arrangement.SpaceBetween
+                    ) {
+                        val slotOptions = listOf(
+                            ListOption(
+                                titleText = stringResource(id = R.string.slot_a),
+                                subtitleText = if (currentSlot == "a" || currentSlot == "_a") stringResource(id = R.string.currently_selected) else null,
+                                icon = Icons.Filled.SdStorage
+                            ),
+                            ListOption(
+                                titleText = stringResource(id = R.string.slot_b),
+                                subtitleText = if (currentSlot == "b" || currentSlot == "_b") stringResource(id = R.string.currently_selected) else null,
+                                icon = Icons.Filled.SdStorage
+                            )
+                        )
+
+                        slotOptions.forEachIndexed { index, option ->
+                            Column(
+                                modifier = Modifier
+                                    .weight(1f)
+                                    .padding(horizontal = 8.dp)
+                            ) {
+                                Row(
+                                    modifier = Modifier
+                                        .fillMaxWidth()
+                                        .clip(MaterialTheme.shapes.medium)
+                                        .background(
+                                            color = if (option.subtitleText != null) {
+                                                MaterialTheme.colorScheme.primary.copy(alpha = 0.9f)
+                                            } else {
+                                                MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.3f)
+                                            }
+                                        )
+                                        .clickable {
+                                            onSlotSelected(
+                                                when (index) {
+                                                    0 -> "a"
+                                                    else -> "b"
+                                                }
+                                            )
+                                        }
+                                        .padding(vertical = 12.dp, horizontal = 16.dp),
+                                    verticalAlignment = Alignment.CenterVertically
+                                ) {
+                                    Icon(
+                                        imageVector = option.icon,
+                                        contentDescription = null,
+                                        tint = if (option.subtitleText != null) {
+                                            MaterialTheme.colorScheme.onPrimary
+                                        } else {
+                                            MaterialTheme.colorScheme.primary
+                                        },
+                                        modifier = Modifier
+                                            .padding(end = 16.dp)
+                                            .size(24.dp)
+                                    )
+                                    Column(
+                                        modifier = Modifier.weight(1f)
+                                    ) {
+                                        Text(
+                                            text = option.titleText,
+                                            style = MaterialTheme.typography.titleMedium,
+                                            color = if (option.subtitleText != null) {
+                                                MaterialTheme.colorScheme.onPrimary
+                                            } else {
+                                                MaterialTheme.colorScheme.primary
+                                            }
+                                        )
+                                        option.subtitleText?.let {
+                                            Text(
+                                                text = it,
+                                                style = MaterialTheme.typography.bodyMedium,
+                                                color = if (true) {
+                                                    MaterialTheme.colorScheme.onPrimary.copy(alpha = 0.8f)
+                                                } else {
+                                                    MaterialTheme.colorScheme.onSurfaceVariant
+                                                }
+                                            )
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+            confirmButton = {
+                TextButton(
+                    onClick = {
+                        currentSlot?.let { onSlotSelected(it) }
+                        onDismiss()
+                    }
+                ) {
+                    Text(
+                        text = stringResource(android.R.string.ok),
+                        color = MaterialTheme.colorScheme.primary
+                    )
+                }
+            },
+            dismissButton = {
+                TextButton(
+                    onClick = onDismiss
+                ) {
+                    Text(
+                        text = stringResource(android.R.string.cancel),
+                        color = MaterialTheme.colorScheme.primary
+                    )
+                }
+            },
+            containerColor = cardColor,
+            shape = MaterialTheme.shapes.extraLarge,
+            tonalElevation = 4.dp
+        )
+    }
+}
+
+// Data class for list options
+data class ListOption(
+    val titleText: String,
+    val subtitleText: String?,
+    val icon: ImageVector
+)
+
+// Utility function to get current slot
+private fun getCurrentSlot(context: Context): String? {
+    return runCommandGetOutput(true, "getprop ro.boot.slot_suffix")?.let {
+        if (it.startsWith("_")) it.substring(1) else it
+    }
+}
+
+private fun runCommandGetOutput(su: Boolean, cmd: String): String? {
+    return try {
+        val process = ProcessBuilder(if (su) "su" else "sh").start()
+        process.outputStream.bufferedWriter().use { writer ->
+            writer.write("$cmd\n")
+            writer.write("exit\n")
+            writer.flush()
+        }
+        process.inputStream.bufferedReader().use { reader ->
+            reader.readText().trim()
+        }
+    } catch (_: Exception) {
+        null
+    }
+}

manager/app/src/main/java/com/sukisu/ultra/ui/component/SwitchItem.kt

@@ -0,0 +1,101 @@
+package com.sukisu.ultra.ui.component
+
+import androidx.compose.animation.animateColorAsState
+import androidx.compose.animation.core.tween
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.material3.Icon
+import androidx.compose.material3.ListItem
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Switch
+import androidx.compose.material3.SwitchDefaults
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+
+@Composable
+fun SwitchItem(
+    icon: ImageVector,
+    title: String,
+    summary: String? = null,
+    checked: Boolean,
+    enabled: Boolean = true,
+    onCheckedChange: (Boolean) -> Unit
+) {
+    // 颜色动画
+    val iconTint by animateColorAsState(
+        targetValue = if (checked) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f),
+        animationSpec = tween(300),
+        label = "iconTint"
+    )
+
+    // 开关颜色
+    val switchColors = SwitchDefaults.colors(
+        checkedThumbColor = MaterialTheme.colorScheme.primary,
+        checkedTrackColor = MaterialTheme.colorScheme.primaryContainer,
+        checkedBorderColor = MaterialTheme.colorScheme.primary,
+        checkedIconColor = MaterialTheme.colorScheme.onPrimary,
+        uncheckedThumbColor = MaterialTheme.colorScheme.outline,
+        uncheckedTrackColor = MaterialTheme.colorScheme.surfaceVariant,
+        uncheckedBorderColor = MaterialTheme.colorScheme.outline,
+        uncheckedIconColor = MaterialTheme.colorScheme.surfaceVariant,
+        disabledCheckedThumbColor = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.38f),
+        disabledCheckedTrackColor = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.12f),
+        disabledCheckedBorderColor = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.12f),
+        disabledCheckedIconColor = MaterialTheme.colorScheme.surfaceVariant,
+        disabledUncheckedThumbColor = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.38f),
+        disabledUncheckedTrackColor = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.12f),
+        disabledUncheckedBorderColor = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.12f),
+        disabledUncheckedIconColor = MaterialTheme.colorScheme.surfaceVariant
+    )
+
+    ListItem(
+        headlineContent = {
+            Text(
+                text = title,
+                style = MaterialTheme.typography.titleMedium,
+                maxLines = Int.MAX_VALUE,
+                overflow = TextOverflow.Ellipsis
+            )
+        },
+        supportingContent = summary?.let {
+            {
+                Text(
+                    text = it,
+                    style = MaterialTheme.typography.bodyMedium,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    maxLines = Int.MAX_VALUE,
+                    overflow = TextOverflow.Ellipsis
+                )
+            }
+        },
+        leadingContent = {
+            Icon(
+                imageVector = icon,
+                contentDescription = null,
+                modifier = Modifier.size(24.dp),
+                tint = iconTint
+            )
+        },
+        trailingContent = {
+            Switch(
+                checked = checked,
+                onCheckedChange = null,
+                enabled = enabled,
+                colors = switchColors
+            )
+        },
+        modifier = Modifier
+            .fillMaxWidth()
+            .clickable(enabled = enabled) {
+                onCheckedChange(!checked)
+            }
+            .padding(vertical = 4.dp)
+    )
+}

manager/app/src/main/java/com/sukisu/ultra/ui/component/profile/AppProfileConfig.kt

@@ -1,4 +1,4 @@
-package shirkneko.zako.sukisu.ui.component.profile
+package com.sukisu.ultra.ui.component.profile
 
 import androidx.compose.foundation.layout.Column
 import androidx.compose.material3.OutlinedTextField
@@ -11,9 +11,9 @@ import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.tooling.preview.Preview
-import shirkneko.zako.sukisu.Natives
-import shirkneko.zako.sukisu.R
-import shirkneko.zako.sukisu.ui.component.SwitchItem
+import com.sukisu.ultra.Natives
+import com.sukisu.ultra.R
+import com.sukisu.ultra.ui.component.SwitchItem
 
 @Composable
 fun AppProfileConfig(

manager/app/src/main/java/com/sukisu/ultra/ui/component/profile/RootProfileConfig.kt

@@ -1,4 +1,4 @@
-package shirkneko.zako.sukisu.ui.component.profile
+package com.sukisu.ultra.ui.component.profile
 
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Column
@@ -42,12 +42,12 @@ import com.maxkeppeler.sheets.input.models.ValidationResult
 import com.maxkeppeler.sheets.list.ListDialog
 import com.maxkeppeler.sheets.list.models.ListOption
 import com.maxkeppeler.sheets.list.models.ListSelection
-import shirkneko.zako.sukisu.Natives
-import shirkneko.zako.sukisu.R
-import shirkneko.zako.sukisu.profile.Capabilities
-import shirkneko.zako.sukisu.profile.Groups
-import shirkneko.zako.sukisu.ui.component.rememberCustomDialog
-import shirkneko.zako.sukisu.ui.util.isSepolicyValid
+import com.sukisu.ultra.Natives
+import com.sukisu.ultra.R
+import com.sukisu.ultra.profile.Capabilities
+import com.sukisu.ultra.profile.Groups
+import com.sukisu.ultra.ui.component.rememberCustomDialog
+import com.sukisu.ultra.ui.util.isSepolicyValid
 
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
@@ -206,28 +206,36 @@ fun GroupsPanel(selected: List<Groups>, closeSelection: (selection: Set<Groups>)
         }
 
         val selection = HashSet(selected)
-        ListDialog(
-            state = rememberUseCaseState(visible = true, onFinishedRequest = {
-                closeSelection(selection)
-            }, onCloseRequest = {
-                dismiss()
-            }),
-            header = Header.Default(
-                title = stringResource(R.string.profile_groups),
-            ),
-            selection = ListSelection.Multiple(
-                showCheckBoxes = true,
-                options = options,
-                maxChoices = 32, // Kernel only supports 32 groups at most
-            ) { indecies, _ ->
-                // Handle selection
-                selection.clear()
-                indecies.forEach { index ->
-                    val group = groups[index]
-                    selection.add(group)
+        val backgroundColor = MaterialTheme.colorScheme.surfaceContainerHighest
+
+        MaterialTheme(
+            colorScheme = MaterialTheme.colorScheme.copy(
+                surface = backgroundColor
+            )
+        ) {
+            ListDialog(
+                state = rememberUseCaseState(visible = true, onFinishedRequest = {
+                    closeSelection(selection)
+                }, onCloseRequest = {
+                    dismiss()
+                }),
+                header = Header.Default(
+                    title = stringResource(R.string.profile_groups),
+                ),
+                selection = ListSelection.Multiple(
+                    showCheckBoxes = true,
+                    options = options,
+                    maxChoices = 32, // Kernel only supports 32 groups at most
+                ) { indecies, _ ->
+                    // Handle selection
+                    selection.clear()
+                    indecies.forEach { index ->
+                        val group = groups[index]
+                        selection.add(group)
+                    }
                 }
-            }
-        )
+            )
+        }
     }
 
     OutlinedCard(
@@ -278,27 +286,35 @@ fun CapsPanel(
         }
 
         val selection = HashSet(selected)
-        ListDialog(
-            state = rememberUseCaseState(visible = true, onFinishedRequest = {
-                closeSelection(selection)
-            }, onCloseRequest = {
-                dismiss()
-            }),
-            header = Header.Default(
-                title = stringResource(R.string.profile_capabilities),
-            ),
-            selection = ListSelection.Multiple(
-                showCheckBoxes = true,
-                options = options
-            ) { indecies, _ ->
-                // Handle selection
-                selection.clear()
-                indecies.forEach { index ->
-                    val group = caps[index]
-                    selection.add(group)
+        val backgroundColor = MaterialTheme.colorScheme.surfaceContainerHighest
+
+        MaterialTheme(
+            colorScheme = MaterialTheme.colorScheme.copy(
+                surface = backgroundColor
+            )
+        ) {
+            ListDialog(
+                state = rememberUseCaseState(visible = true, onFinishedRequest = {
+                    closeSelection(selection)
+                }, onCloseRequest = {
+                    dismiss()
+                }),
+                header = Header.Default(
+                    title = stringResource(R.string.profile_capabilities),
+                ),
+                selection = ListSelection.Multiple(
+                    showCheckBoxes = true,
+                    options = options
+                ) { indecies, _ ->
+                    // Handle selection
+                    selection.clear()
+                    indecies.forEach { index ->
+                        val group = caps[index]
+                        selection.add(group)
+                    }
                 }
-            }
-        )
+            )
+        }
     }
 
     OutlinedCard(
@@ -425,24 +441,33 @@ private fun SELinuxPanel(
             )
         )
 
-        InputDialog(
-            state = rememberUseCaseState(visible = true,
-                onFinishedRequest = {
-                    onSELinuxChange(domain, rules)
-                },
-                onCloseRequest = {
-                    dismiss()
-                }),
-            header = Header.Default(
-                title = stringResource(R.string.profile_selinux_context),
-            ),
-            selection = InputSelection(
-                input = inputOptions,
-                onPositiveClick = { result ->
-                    // Handle selection
-                },
+        val backgroundColor = MaterialTheme.colorScheme.surfaceContainerHighest
+
+        MaterialTheme(
+            colorScheme = MaterialTheme.colorScheme.copy(
+                surface = backgroundColor
             )
-        )
+        ) {
+            InputDialog(
+                state = rememberUseCaseState(
+                    visible = true,
+                    onFinishedRequest = {
+                        onSELinuxChange(domain, rules)
+                    },
+                    onCloseRequest = {
+                        dismiss()
+                    }),
+                header = Header.Default(
+                    title = stringResource(R.string.profile_selinux_context),
+                ),
+                selection = InputSelection(
+                    input = inputOptions,
+                    onPositiveClick = { result ->
+                        // Handle selection
+                    },
+                )
+            )
+        }
     }
 
     ListItem(headlineContent = {

manager/app/src/main/java/com/sukisu/ultra/ui/component/profile/TemplateConfig.kt

@@ -1,4 +1,4 @@
-package shirkneko.zako.sukisu.ui.component.profile
+package com.sukisu.ultra.ui.component.profile
 
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.material.icons.Icons
@@ -23,11 +23,11 @@ import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
-import shirkneko.zako.sukisu.Natives
-import shirkneko.zako.sukisu.R
-import shirkneko.zako.sukisu.ui.util.listAppProfileTemplates
-import shirkneko.zako.sukisu.ui.util.setSepolicy
-import shirkneko.zako.sukisu.ui.viewmodel.getTemplateInfoById
+import com.sukisu.ultra.Natives
+import com.sukisu.ultra.R
+import com.sukisu.ultra.ui.util.listAppProfileTemplates
+import com.sukisu.ultra.ui.util.setSepolicy
+import com.sukisu.ultra.ui.viewmodel.getTemplateInfoById
 
 /**
  * @author weishu

manager/app/src/main/java/com/sukisu/ultra/ui/screen/AppProfile.kt

@@ -0,0 +1,593 @@
+package com.sukisu.ultra.ui.screen
+
+import android.annotation.SuppressLint
+import androidx.annotation.StringRes
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.Crossfade
+import androidx.compose.animation.expandVertically
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.shrinkVertically
+import androidx.compose.foundation.gestures.detectTapGestures
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.BoxWithConstraints
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.WindowInsets
+import androidx.compose.foundation.layout.WindowInsetsSides
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.only
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.safeDrawing
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.ArrowBack
+import androidx.compose.material.icons.filled.AccountCircle
+import androidx.compose.material.icons.filled.Android
+import androidx.compose.material.icons.filled.Security
+import androidx.compose.material3.DropdownMenu
+import androidx.compose.material3.DropdownMenuItem
+import androidx.compose.material3.ElevatedCard
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.FilterChip
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.IconButtonDefaults
+import androidx.compose.material3.ListItem
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.SnackbarHost
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBar
+import androidx.compose.material3.TopAppBarColors
+import androidx.compose.material3.TopAppBarDefaults
+import androidx.compose.material3.TopAppBarScrollBehavior
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.alpha
+import androidx.compose.ui.draw.shadow
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.input.nestedscroll.nestedScroll
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.DpOffset
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.dropUnlessResumed
+import coil.compose.AsyncImage
+import coil.request.ImageRequest
+import com.ramcosta.composedestinations.annotation.Destination
+import com.ramcosta.composedestinations.annotation.RootGraph
+import com.ramcosta.composedestinations.generated.destinations.AppProfileTemplateScreenDestination
+import com.ramcosta.composedestinations.generated.destinations.TemplateEditorScreenDestination
+import com.ramcosta.composedestinations.navigation.DestinationsNavigator
+import com.sukisu.ultra.Natives
+import com.sukisu.ultra.R
+import com.sukisu.ultra.ui.component.SwitchItem
+import com.sukisu.ultra.ui.component.profile.AppProfileConfig
+import com.sukisu.ultra.ui.component.profile.RootProfileConfig
+import com.sukisu.ultra.ui.component.profile.TemplateConfig
+import com.sukisu.ultra.ui.theme.CardConfig
+import com.sukisu.ultra.ui.util.LocalSnackbarHost
+import com.sukisu.ultra.ui.util.forceStopApp
+import com.sukisu.ultra.ui.util.getSepolicy
+import com.sukisu.ultra.ui.util.launchApp
+import com.sukisu.ultra.ui.util.restartApp
+import com.sukisu.ultra.ui.util.setSepolicy
+import com.sukisu.ultra.ui.viewmodel.SuperUserViewModel
+import com.sukisu.ultra.ui.viewmodel.getTemplateInfoById
+import kotlinx.coroutines.launch
+
+/**
+ * @author weishu
+ * @date 2023/5/16.
+ */
+@OptIn(ExperimentalMaterial3Api::class)
+@Destination<RootGraph>
+@Composable
+fun AppProfileScreen(
+    navigator: DestinationsNavigator,
+    appInfo: SuperUserViewModel.AppInfo,
+) {
+    val context = LocalContext.current
+    val snackBarHost = LocalSnackbarHost.current
+    val scrollBehavior = TopAppBarDefaults.pinnedScrollBehavior()
+    val scope = rememberCoroutineScope()
+    val failToUpdateAppProfile = stringResource(R.string.failed_to_update_app_profile).format(appInfo.label)
+    val failToUpdateSepolicy = stringResource(R.string.failed_to_update_sepolicy).format(appInfo.label)
+    val suNotAllowed = stringResource(R.string.su_not_allowed).format(appInfo.label)
+
+    val packageName = appInfo.packageName
+    val initialProfile = Natives.getAppProfile(packageName, appInfo.uid)
+    if (initialProfile.allowSu) {
+        initialProfile.rules = getSepolicy(packageName)
+    }
+    var profile by rememberSaveable {
+        mutableStateOf(initialProfile)
+    }
+
+    val cardColor = MaterialTheme.colorScheme.surfaceContainerLow
+    val cardAlpha = CardConfig.cardAlpha
+
+    Scaffold(
+        topBar = {
+            TopBar(
+                title = appInfo.label,
+                packageName = packageName,
+                colors = TopAppBarDefaults.topAppBarColors(
+                    containerColor = cardColor.copy(alpha = cardAlpha),
+                    scrolledContainerColor = cardColor.copy(alpha = cardAlpha)
+                ),
+                onBack = dropUnlessResumed { navigator.popBackStack() },
+                scrollBehavior = scrollBehavior
+            )
+        },
+        snackbarHost = { SnackbarHost(hostState = snackBarHost) },
+        contentWindowInsets = WindowInsets.safeDrawing.only(WindowInsetsSides.Top + WindowInsetsSides.Horizontal)
+    ) { paddingValues ->
+        AppProfileInner(
+            modifier = Modifier
+                .padding(paddingValues)
+                .nestedScroll(scrollBehavior.nestedScrollConnection)
+                .verticalScroll(rememberScrollState()),
+            packageName = appInfo.packageName,
+            appLabel = appInfo.label,
+            appIcon = {
+                AsyncImage(
+                    model = ImageRequest.Builder(context).data(appInfo.packageInfo).crossfade(true).build(),
+                    contentDescription = appInfo.label,
+                    modifier = Modifier
+                        .padding(4.dp)
+                        .width(48.dp)
+                        .height(48.dp)
+                )
+            },
+            profile = profile,
+            onViewTemplate = {
+                getTemplateInfoById(it)?.let { info ->
+                    navigator.navigate(TemplateEditorScreenDestination(info))
+                }
+            },
+            onManageTemplate = {
+                navigator.navigate(AppProfileTemplateScreenDestination())
+            },
+            onProfileChange = {
+                scope.launch {
+                    if (it.allowSu) {
+                        // sync with allowlist.c - forbid_system_uid
+                        if (appInfo.uid < 2000 && appInfo.uid != 1000) {
+                            snackBarHost.showSnackbar(suNotAllowed)
+                            return@launch
+                        }
+                        if (!it.rootUseDefault && it.rules.isNotEmpty() && !setSepolicy(profile.name, it.rules)) {
+                            snackBarHost.showSnackbar(failToUpdateSepolicy)
+                            return@launch
+                        }
+                    }
+                    if (!Natives.setAppProfile(it)) {
+                        snackBarHost.showSnackbar(failToUpdateAppProfile.format(appInfo.uid))
+                    } else {
+                        profile = it
+                    }
+                }
+            },
+        )
+    }
+}
+
+@Composable
+private fun AppProfileInner(
+    modifier: Modifier = Modifier,
+    packageName: String,
+    appLabel: String,
+    appIcon: @Composable () -> Unit,
+    profile: Natives.Profile,
+    onViewTemplate: (id: String) -> Unit = {},
+    onManageTemplate: () -> Unit = {},
+    onProfileChange: (Natives.Profile) -> Unit,
+) {
+    val isRootGranted = profile.allowSu
+
+    Column(modifier = modifier) {
+        ElevatedCard(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(horizontal = 16.dp, vertical = 8.dp),
+            shape = MaterialTheme.shapes.medium
+        ) {
+            AppMenuBox(packageName) {
+                ListItem(
+                    headlineContent = {
+                        Text(
+                            text = appLabel,
+                            style = MaterialTheme.typography.titleMedium
+                        )
+                    },
+                    supportingContent = {
+                        Text(
+                            text = packageName,
+                            style = MaterialTheme.typography.bodyMedium,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant
+                        )
+                    },
+                    leadingContent = appIcon,
+                )
+            }
+        }
+
+        ElevatedCard(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(horizontal = 16.dp, vertical = 8.dp),
+            shape = MaterialTheme.shapes.medium
+        ) {
+            SwitchItem(
+                icon = Icons.Filled.Security,
+                title = stringResource(id = R.string.superuser),
+                checked = isRootGranted,
+                onCheckedChange = { onProfileChange(profile.copy(allowSu = it)) },
+            )
+        }
+
+        Crossfade(
+            targetState = isRootGranted,
+            label = "RootAccess"
+        ) { current ->
+            Column(
+                modifier = Modifier.padding(bottom = 6.dp + 48.dp + 6.dp /* SnackBar height */)
+            ) {
+                if (current) {
+                    val initialMode = if (profile.rootUseDefault) {
+                        Mode.Default
+                    } else if (profile.rootTemplate != null) {
+                        Mode.Template
+                    } else {
+                        Mode.Custom
+                    }
+                    var mode by rememberSaveable {
+                        mutableStateOf(initialMode)
+                    }
+
+                    ElevatedCard(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .padding(horizontal = 16.dp, vertical = 8.dp),
+                        shape = MaterialTheme.shapes.medium
+                    ) {
+                        ProfileBox(mode, true) {
+                            // template mode shouldn't change profile here!
+                            if (it == Mode.Default || it == Mode.Custom) {
+                                onProfileChange(profile.copy(rootUseDefault = it == Mode.Default))
+                            }
+                            mode = it
+                        }
+                    }
+
+                    AnimatedVisibility(
+                        visible = mode != Mode.Default,
+                        enter = fadeIn() + expandVertically(),
+                        exit = fadeOut() + shrinkVertically()
+                    ) {
+                        ElevatedCard(
+                            modifier = Modifier
+                                .fillMaxWidth()
+                                .padding(horizontal = 16.dp, vertical = 8.dp),
+                            shape = MaterialTheme.shapes.medium
+                        ) {
+                            Column(modifier = Modifier.padding(vertical = 8.dp)) {
+                                Crossfade(targetState = mode, label = "ProfileMode") { currentMode ->
+                                    when (currentMode) {
+                                        Mode.Template -> {
+                                            TemplateConfig(
+                                                profile = profile,
+                                                onViewTemplate = onViewTemplate,
+                                                onManageTemplate = onManageTemplate,
+                                                onProfileChange = onProfileChange
+                                            )
+                                        }
+                                        Mode.Custom -> {
+                                            RootProfileConfig(
+                                                fixedName = true,
+                                                profile = profile,
+                                                onProfileChange = onProfileChange
+                                            )
+                                        }
+                                        else -> {}
+                                    }
+                                }
+                            }
+                        }
+                    }
+                } else {
+                    val mode = if (profile.nonRootUseDefault) Mode.Default else Mode.Custom
+
+                    ElevatedCard(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .padding(horizontal = 16.dp, vertical = 8.dp),
+                        shape = MaterialTheme.shapes.medium
+                    ) {
+                        ProfileBox(mode, false) {
+                            onProfileChange(profile.copy(nonRootUseDefault = (it == Mode.Default)))
+                        }
+                    }
+
+                    AnimatedVisibility(
+                        visible = mode == Mode.Custom,
+                        enter = fadeIn() + expandVertically(),
+                        exit = fadeOut() + shrinkVertically()
+                    ) {
+                        ElevatedCard(
+                            modifier = Modifier
+                                .fillMaxWidth()
+                                .padding(horizontal = 16.dp, vertical = 8.dp),
+                            shape = MaterialTheme.shapes.medium
+                        ) {
+                            Column(modifier = Modifier.padding(vertical = 8.dp)) {
+                                AppProfileConfig(
+                                    fixedName = true,
+                                    profile = profile,
+                                    enabled = mode == Mode.Custom,
+                                    onProfileChange = onProfileChange
+                                )
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+private enum class Mode(@StringRes private val res: Int) {
+    Default(R.string.profile_default), Template(R.string.profile_template), Custom(R.string.profile_custom);
+
+    val text: String
+        @Composable get() = stringResource(res)
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun TopBar(
+    title: String,
+    packageName: String,
+    onBack: () -> Unit,
+    colors: TopAppBarColors,
+    scrollBehavior: TopAppBarScrollBehavior? = null
+) {
+    TopAppBar(
+        title = {
+            Column {
+                Text(
+                    text = title,
+                    style = MaterialTheme.typography.titleMedium,
+                    color = MaterialTheme.colorScheme.onSurface
+                )
+                Text(
+                    text = packageName,
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    modifier = Modifier.alpha(0.8f)
+                )
+            }
+        },
+        colors = colors,
+        navigationIcon = {
+            IconButton(
+                onClick = onBack,
+                colors = IconButtonDefaults.iconButtonColors(
+                    contentColor = MaterialTheme.colorScheme.onSurface
+                )
+            ) {
+                Icon(
+                    imageVector = Icons.AutoMirrored.Filled.ArrowBack,
+                    contentDescription = stringResource(R.string.back)
+                )
+            }
+        },
+        windowInsets = WindowInsets.safeDrawing.only(
+            WindowInsetsSides.Top + WindowInsetsSides.Horizontal
+        ),
+        scrollBehavior = scrollBehavior,
+        modifier = Modifier.shadow(
+            elevation = if ((scrollBehavior?.state?.overlappedFraction ?: 0f) > 0.01f)
+                4.dp else 0.dp,
+            spotColor = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.1f)
+        )
+    )
+}
+
+@Composable
+private fun ProfileBox(
+    mode: Mode,
+    hasTemplate: Boolean,
+    onModeChange: (Mode) -> Unit,
+) {
+    Column(modifier = Modifier.padding(vertical = 8.dp)) {
+        ListItem(
+            headlineContent = {
+                Text(
+                    text = stringResource(R.string.profile),
+                    style = MaterialTheme.typography.titleMedium
+                )
+            },
+            supportingContent = {
+                Text(
+                    text = mode.text,
+                    style = MaterialTheme.typography.bodyMedium,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant
+                )
+            },
+            leadingContent = {
+                Icon(
+                    imageVector = Icons.Filled.AccountCircle,
+                    contentDescription = null,
+                )
+            },
+        )
+
+        HorizontalDivider(
+            thickness = Dp.Hairline,
+            color = MaterialTheme.colorScheme.outlineVariant
+        )
+
+        ListItem(
+            headlineContent = {
+                Row(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(vertical = 8.dp),
+                    horizontalArrangement = Arrangement.spacedBy(8.dp, Alignment.CenterHorizontally)
+                ) {
+                    FilterChip(
+                        selected = mode == Mode.Default,
+                        onClick = { onModeChange(Mode.Default) },
+                        label = {
+                            Text(
+                                text = stringResource(R.string.profile_default),
+                                style = MaterialTheme.typography.bodyMedium
+                            )
+                        },
+                        shape = MaterialTheme.shapes.small
+                    )
+
+                    if (hasTemplate) {
+                        FilterChip(
+                            selected = mode == Mode.Template,
+                            onClick = { onModeChange(Mode.Template) },
+                            label = {
+                                Text(
+                                    text = stringResource(R.string.profile_template),
+                                    style = MaterialTheme.typography.bodyMedium
+                                )
+                            },
+                            shape = MaterialTheme.shapes.small
+                        )
+                    }
+
+                    FilterChip(
+                        selected = mode == Mode.Custom,
+                        onClick = { onModeChange(Mode.Custom) },
+                        label = {
+                            Text(
+                                text = stringResource(R.string.profile_custom),
+                                style = MaterialTheme.typography.bodyMedium
+                            )
+                        },
+                        shape = MaterialTheme.shapes.small
+                    )
+                }
+            }
+        )
+    }
+}
+
+@SuppressLint("UnusedBoxWithConstraintsScope")
+@Composable
+private fun AppMenuBox(packageName: String, content: @Composable () -> Unit) {
+    var expanded by remember { mutableStateOf(false) }
+    var touchPoint: Offset by remember { mutableStateOf(Offset.Zero) }
+    val density = LocalDensity.current
+
+    BoxWithConstraints(
+        Modifier
+            .fillMaxSize()
+            .pointerInput(Unit) {
+                detectTapGestures(
+                    onLongPress = {
+                        touchPoint = it
+                        expanded = true
+                    }
+                )
+            }
+    ) {
+        content()
+
+        val (offsetX, offsetY) = with(density) {
+            (touchPoint.x.toDp()) to (touchPoint.y.toDp())
+        }
+
+        DropdownMenu(
+            expanded = expanded,
+            offset = DpOffset(offsetX, -offsetY),
+            onDismissRequest = {
+                expanded = false
+            },
+        ) {
+            AppMenuOption(
+                text = stringResource(id = R.string.launch_app),
+                onClick = {
+                    expanded = false
+                    launchApp(packageName)
+                }
+            )
+
+            AppMenuOption(
+                text = stringResource(id = R.string.force_stop_app),
+                onClick = {
+                    expanded = false
+                    forceStopApp(packageName)
+                }
+            )
+
+            AppMenuOption(
+                text = stringResource(id = R.string.restart_app),
+                onClick = {
+                    expanded = false
+                    restartApp(packageName)
+                }
+            )
+        }
+    }
+}
+
+@Composable
+private fun AppMenuOption(text: String, onClick: () -> Unit) {
+    DropdownMenuItem(
+        text = {
+            Text(
+                text = text,
+                style = MaterialTheme.typography.bodyMedium
+            )
+        },
+        onClick = onClick
+    )
+}
+
+@Preview
+@Composable
+private fun AppProfilePreview() {
+    var profile by remember { mutableStateOf(Natives.Profile("")) }
+    Surface {
+        AppProfileInner(
+            packageName = "icu.nullptr.test",
+            appLabel = "Test",
+            appIcon = {
+                Icon(
+                    imageVector = Icons.Filled.Android,
+                    contentDescription = null,
+                )
+            },
+            profile = profile,
+            onProfileChange = {
+                profile = it
+            },
+        )
+    }
+}

manager/app/src/main/java/com/sukisu/ultra/ui/screen/BottomBarDestination.kt

@@ -1,8 +1,9 @@
-package shirkneko.zako.sukisu.ui.screen
+package com.sukisu.ultra.ui.screen
 
 import androidx.annotation.StringRes
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.*
+import androidx.compose.material.icons.filled.Archive
 import androidx.compose.material.icons.outlined.*
 import androidx.compose.ui.graphics.vector.ImageVector
 import com.ramcosta.composedestinations.generated.destinations.HomeScreenDestination
@@ -11,7 +12,7 @@ import com.ramcosta.composedestinations.generated.destinations.SuperUserScreenDe
 import com.ramcosta.composedestinations.generated.destinations.SettingScreenDestination
 import com.ramcosta.composedestinations.generated.destinations.KpmScreenDestination
 import com.ramcosta.composedestinations.spec.DirectionDestinationSpec
-import shirkneko.zako.sukisu.R
+import com.sukisu.ultra.R
 
 enum class BottomBarDestination(
     val direction: DirectionDestinationSpec,
@@ -21,8 +22,8 @@ enum class BottomBarDestination(
     val rootRequired: Boolean,
 ) {
     Home(HomeScreenDestination, R.string.home, Icons.Filled.Home, Icons.Outlined.Home, false),
-    SuperUser(SuperUserScreenDestination, R.string.superuser, Icons.Filled.Security, Icons.Outlined.Security, true),
-    Module(ModuleScreenDestination, R.string.module, Icons.Filled.Apps, Icons.Outlined.Apps, true),
-    Kpm(KpmScreenDestination, R.string.kpm_title, Icons.Filled.Build, Icons.Outlined.Build, true),
+    Kpm(KpmScreenDestination, R.string.kpm_title, Icons.Filled.Archive, Icons.Outlined.Archive, true),
+    SuperUser(SuperUserScreenDestination, R.string.superuser, Icons.Filled.AdminPanelSettings, Icons.Outlined.AdminPanelSettings, true),
+    Module(ModuleScreenDestination, R.string.module, Icons.Filled.Extension, Icons.Outlined.Extension, true),
     Settings(SettingScreenDestination, R.string.settings, Icons.Filled.Settings, Icons.Outlined.Settings, false),
 }

manager/app/src/main/java/com/sukisu/ultra/ui/screen/ExecuteModuleAction.kt

@@ -1,15 +1,22 @@
-package shirkneko.zako.sukisu.ui.screen
+package com.sukisu.ultra.ui.screen
 
 import android.os.Environment
+import androidx.activity.compose.BackHandler
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.verticalScroll
+import androidx.compose.foundation.layout.WindowInsets
+import androidx.compose.foundation.layout.WindowInsetsSides
+import androidx.compose.foundation.layout.defaultMinSize
+import androidx.compose.foundation.layout.safeDrawing
+import androidx.compose.foundation.layout.only
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.automirrored.filled.ArrowBack
+import androidx.compose.material.icons.filled.Close
 import androidx.compose.material.icons.filled.Save
 import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.ExtendedFloatingActionButton
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
@@ -30,17 +37,16 @@ import androidx.compose.ui.input.key.key
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.font.FontFamily
 import androidx.compose.ui.unit.dp
-import androidx.lifecycle.compose.dropUnlessResumed
 import com.ramcosta.composedestinations.annotation.Destination
 import com.ramcosta.composedestinations.annotation.RootGraph
 import com.ramcosta.composedestinations.navigation.DestinationsNavigator
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
-import shirkneko.zako.sukisu.R
-import shirkneko.zako.sukisu.ui.component.KeyEventBlocker
-import shirkneko.zako.sukisu.ui.util.LocalSnackbarHost
-import shirkneko.zako.sukisu.ui.util.runModuleAction
+import com.sukisu.ultra.R
+import com.sukisu.ultra.ui.component.KeyEventBlocker
+import com.sukisu.ultra.ui.util.LocalSnackbarHost
+import com.sukisu.ultra.ui.util.runModuleAction
 import java.io.File
 import java.text.SimpleDateFormat
 import java.util.Date
@@ -55,7 +61,11 @@ fun ExecuteModuleActionScreen(navigator: DestinationsNavigator, moduleId: String
     val snackBarHost = LocalSnackbarHost.current
     val scope = rememberCoroutineScope()
     val scrollState = rememberScrollState()
-    var actionResult: Boolean
+    var isActionRunning by rememberSaveable { mutableStateOf(true) }
+
+    BackHandler(enabled = isActionRunning) {
+        // Disable back button if action is running
+    }
 
     LaunchedEffect(Unit) {
         if (text.isNotEmpty()) {
@@ -76,33 +86,43 @@ fun ExecuteModuleActionScreen(navigator: DestinationsNavigator, moduleId: String
                 onStderr = {
                     logContent.append(it).append("\n")
                 }
-            ).let {
-                actionResult = it
-            }
+            )
         }
-        if (actionResult) navigator.popBackStack()
+        isActionRunning = false
     }
 
     Scaffold(
         topBar = {
             TopBar(
-                onBack = dropUnlessResumed {
-                    navigator.popBackStack()
-                },
+                isActionRunning = isActionRunning,
                 onSave = {
-                    scope.launch {
-                        val format = SimpleDateFormat("yyyy-MM-dd-HH-mm-ss", Locale.getDefault())
-                        val date = format.format(Date())
-                        val file = File(
-                            Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS),
-                            "KernelSU_module_action_log_${date}.log"
-                        )
-                        file.writeText(logContent.toString())
-                        snackBarHost.showSnackbar("Log saved to ${file.absolutePath}")
+                    if (!isActionRunning) {
+                        scope.launch {
+                            val format = SimpleDateFormat("yyyy-MM-dd-HH-mm-ss", Locale.getDefault())
+                            val date = format.format(Date())
+                            val file = File(
+                                Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS),
+                                "KernelSU_module_action_log_${date}.log"
+                            )
+                            file.writeText(logContent.toString())
+                            snackBarHost.showSnackbar("Log saved to ${file.absolutePath}")
+                        }
                     }
                 }
             )
         },
+        floatingActionButton = {
+            if (!isActionRunning) {
+                ExtendedFloatingActionButton(
+                    text = { Text(text = stringResource(R.string.close)) },
+                    icon = { Icon(Icons.Filled.Close, contentDescription = null) },
+                    onClick = {
+                        navigator.popBackStack()
+                    }
+                )
+            }
+        },
+        contentWindowInsets = WindowInsets.safeDrawing,
         snackbarHost = { SnackbarHost(snackBarHost) }
     ) { innerPadding ->
         KeyEventBlocker {
@@ -130,16 +150,14 @@ fun ExecuteModuleActionScreen(navigator: DestinationsNavigator, moduleId: String
 
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
-private fun TopBar(onBack: () -> Unit = {}, onSave: () -> Unit = {}) {
+private fun TopBar(isActionRunning: Boolean, onSave: () -> Unit = {}) {
     TopAppBar(
         title = { Text(stringResource(R.string.action)) },
-        navigationIcon = {
-            IconButton(
-                onClick = onBack
-            ) { Icon(Icons.AutoMirrored.Filled.ArrowBack, contentDescription = null) }
-        },
         actions = {
-            IconButton(onClick = onSave) {
+            IconButton(
+                onClick = onSave,
+                enabled = !isActionRunning
+            ) {
                 Icon(
                     imageVector = Icons.Filled.Save,
                     contentDescription = stringResource(id = R.string.save_log),

manager/app/src/main/java/com/sukisu/ultra/ui/screen/Flash.kt

@@ -0,0 +1,564 @@
+package com.sukisu.ultra.ui.screen
+
+import android.net.Uri
+import android.os.Environment
+import android.os.Parcelable
+import androidx.activity.compose.BackHandler
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.animation.expandVertically
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.shrinkVertically
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.ArrowBack
+import androidx.compose.material.icons.filled.Error
+import androidx.compose.material.icons.filled.Refresh
+import androidx.compose.material.icons.filled.Save
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.input.key.Key
+import androidx.compose.ui.input.key.key
+import androidx.compose.ui.input.nestedscroll.nestedScroll
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import com.ramcosta.composedestinations.annotation.Destination
+import com.ramcosta.composedestinations.annotation.RootGraph
+import com.ramcosta.composedestinations.generated.destinations.FlashScreenDestination
+import com.ramcosta.composedestinations.generated.destinations.ModuleScreenDestination
+import com.ramcosta.composedestinations.navigation.DestinationsNavigator
+import com.ramcosta.composedestinations.navigation.EmptyDestinationsNavigator
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import kotlinx.parcelize.Parcelize
+import com.sukisu.ultra.ui.component.KeyEventBlocker
+import com.sukisu.ultra.ui.util.*
+import com.sukisu.ultra.R
+import com.sukisu.ultra.ui.theme.CardConfig
+import com.sukisu.ultra.ui.viewmodel.ModuleViewModel
+import androidx.lifecycle.viewmodel.compose.viewModel
+import java.io.File
+import java.text.SimpleDateFormat
+import java.util.*
+
+/**
+ * @author ShirkNeko
+ * @date 2025/5/31.
+ */
+enum class FlashingStatus {
+    FLASHING,
+    SUCCESS,
+    FAILED
+}
+
+private var currentFlashingStatus = mutableStateOf(FlashingStatus.FLASHING)
+
+// 添加模块安装状态跟踪
+data class ModuleInstallStatus(
+    val totalModules: Int = 0,
+    val currentModule: Int = 0,
+    val currentModuleName: String = "",
+    val failedModules: MutableList<String> = mutableListOf()
+)
+
+private var moduleInstallStatus = mutableStateOf(ModuleInstallStatus())
+
+fun setFlashingStatus(status: FlashingStatus) {
+    currentFlashingStatus.value = status
+}
+
+fun updateModuleInstallStatus(
+    totalModules: Int? = null,
+    currentModule: Int? = null,
+    currentModuleName: String? = null,
+    failedModule: String? = null
+) {
+    val current = moduleInstallStatus.value
+    moduleInstallStatus.value = current.copy(
+        totalModules = totalModules ?: current.totalModules,
+        currentModule = currentModule ?: current.currentModule,
+        currentModuleName = currentModuleName ?: current.currentModuleName
+    )
+
+    if (failedModule != null) {
+        val updatedFailedModules = current.failedModules.toMutableList()
+        updatedFailedModules.add(failedModule)
+        moduleInstallStatus.value = moduleInstallStatus.value.copy(
+            failedModules = updatedFailedModules
+        )
+    }
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+@Destination<RootGraph>
+fun FlashScreen(navigator: DestinationsNavigator, flashIt: FlashIt) {
+    val context = LocalContext.current
+    var text by rememberSaveable { mutableStateOf("") }
+    var tempText: String
+    val logContent = rememberSaveable { StringBuilder() }
+    var showFloatAction by rememberSaveable { mutableStateOf(false) }
+
+    val snackBarHost = LocalSnackbarHost.current
+    val scope = rememberCoroutineScope()
+    val scrollState = rememberScrollState()
+    val scrollBehavior = TopAppBarDefaults.pinnedScrollBehavior(rememberTopAppBarState())
+    val viewModel: ModuleViewModel = viewModel()
+
+    val errorCodeString = stringResource(R.string.error_code)
+    val checkLogString = stringResource(R.string.check_log)
+    val logSavedString = stringResource(R.string.log_saved)
+    val installingModuleString = stringResource(R.string.installing_module)
+
+    // 当前模块安装状态
+    val currentStatus = moduleInstallStatus.value
+
+    // 重置状态
+    LaunchedEffect(flashIt) {
+        if (flashIt is FlashIt.FlashModules && flashIt.currentIndex == 0) {
+            moduleInstallStatus.value = ModuleInstallStatus(
+                totalModules = flashIt.uris.size,
+                currentModule = 1
+            )
+        }
+    }
+
+    LaunchedEffect(Unit) {
+        if (text.isNotEmpty()) {
+            return@LaunchedEffect
+        }
+        withContext(Dispatchers.IO) {
+            setFlashingStatus(FlashingStatus.FLASHING)
+
+            if (flashIt is FlashIt.FlashModules) {
+                try {
+                    val currentUri = flashIt.uris[flashIt.currentIndex]
+                    val moduleName = getModuleNameFromUri(context, currentUri)
+                    updateModuleInstallStatus(
+                        currentModuleName = moduleName
+                    )
+                    text = installingModuleString.format(flashIt.currentIndex + 1, flashIt.uris.size, moduleName)
+                    logContent.append(text).append("\n")
+                } catch (_: Exception) {
+                    text = installingModuleString.format(flashIt.currentIndex + 1, flashIt.uris.size, "Module")
+                    logContent.append(text).append("\n")
+                }
+            }
+
+            flashIt(context, flashIt, onFinish = { showReboot, code ->
+                if (code != 0) {
+                    text += "$errorCodeString $code.\n$checkLogString\n"
+                    setFlashingStatus(FlashingStatus.FAILED)
+
+                    if (flashIt is FlashIt.FlashModules) {
+                        updateModuleInstallStatus(
+                            failedModule = moduleInstallStatus.value.currentModuleName
+                        )
+                    }
+                } else {
+                    setFlashingStatus(FlashingStatus.SUCCESS)
+                    viewModel.markNeedRefresh()
+                }
+                if (showReboot) {
+                    text += "\n\n\n"
+                    showFloatAction = true
+                }
+
+                if (flashIt is FlashIt.FlashModules && flashIt.currentIndex < flashIt.uris.size - 1) {
+                    val nextFlashIt = flashIt.copy(
+                        currentIndex = flashIt.currentIndex + 1
+                    )
+                    scope.launch {
+                        kotlinx.coroutines.delay(500)
+                        navigator.navigate(FlashScreenDestination(nextFlashIt))
+                    }
+                }
+            }, onStdout = {
+                tempText = "$it\n"
+                if (tempText.startsWith("[H[J")) { // clear command
+                    text = tempText.substring(6)
+                } else {
+                    text += tempText
+                }
+                logContent.append(it).append("\n")
+            }, onStderr = {
+                logContent.append(it).append("\n")
+            })
+        }
+    }
+
+    val onBack: () -> Unit = {
+        if (currentFlashingStatus.value != FlashingStatus.FLASHING) {
+            if (flashIt is FlashIt.FlashBoot) {
+                navigator.popBackStack()
+            } else {
+                viewModel.markNeedRefresh()
+                viewModel.fetchModuleList()
+                navigator.navigate(ModuleScreenDestination) {
+                }
+            }
+        }
+    }
+
+    BackHandler(enabled = true) {
+        onBack()
+    }
+
+    Scaffold(
+        topBar = {
+            TopBar(
+                currentFlashingStatus.value,
+                currentStatus,
+                navigator = navigator,
+                flashIt = flashIt,
+                onBack = onBack,
+                onSave = {
+                    scope.launch {
+                        val format = SimpleDateFormat("yyyy-MM-dd-HH-mm-ss", Locale.getDefault())
+                        val date = format.format(Date())
+                        val file = File(
+                            Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS),
+                            "KernelSU_install_log_${date}.log"
+                        )
+                        file.writeText(logContent.toString())
+                        snackBarHost.showSnackbar(logSavedString.format(file.absolutePath))
+                    }
+                },
+                scrollBehavior = scrollBehavior
+            )
+        },
+        floatingActionButton = {
+            if (showFloatAction) {
+                ExtendedFloatingActionButton(
+                    onClick = {
+                        scope.launch {
+                            withContext(Dispatchers.IO) {
+                                reboot()
+                            }
+                        }
+                    },
+                    icon = {
+                        Icon(
+                            Icons.Filled.Refresh,
+                            contentDescription = stringResource(id = R.string.reboot)
+                        )
+                    },
+                    text = {
+                        Text(text = stringResource(id = R.string.reboot))
+                    },
+                    containerColor = MaterialTheme.colorScheme.secondaryContainer,
+                    contentColor = MaterialTheme.colorScheme.onSecondaryContainer,
+                    expanded = true
+                )
+            }
+        },
+        snackbarHost = { SnackbarHost(hostState = snackBarHost) },
+        contentWindowInsets = WindowInsets.safeDrawing.only(WindowInsetsSides.Top + WindowInsetsSides.Horizontal),
+        containerColor = MaterialTheme.colorScheme.background
+    ) { innerPadding ->
+        KeyEventBlocker {
+            it.key == Key.VolumeDown || it.key == Key.VolumeUp
+        }
+
+        Column(
+            modifier = Modifier
+                .fillMaxSize(1f)
+                .padding(innerPadding)
+                .nestedScroll(scrollBehavior.nestedScrollConnection),
+        ) {
+            if (flashIt is FlashIt.FlashModules) {
+                ModuleInstallProgressBar(
+                    currentIndex = flashIt.currentIndex + 1,
+                    totalCount = flashIt.uris.size,
+                    currentModuleName = currentStatus.currentModuleName,
+                    status = currentFlashingStatus.value,
+                    failedModules = currentStatus.failedModules
+                )
+
+                Spacer(modifier = Modifier.height(8.dp))
+            }
+
+            Box(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .weight(1f)
+                    .verticalScroll(scrollState)
+            ) {
+                LaunchedEffect(text) {
+                    scrollState.animateScrollTo(scrollState.maxValue)
+                }
+                Text(
+                    modifier = Modifier.padding(16.dp),
+                    text = text,
+                    style = MaterialTheme.typography.bodyMedium,
+                    fontFamily = FontFamily.Monospace,
+                    color = MaterialTheme.colorScheme.onSurface
+                )
+            }
+        }
+    }
+}
+
+// 显示模块安装进度条和状态
+@Composable
+fun ModuleInstallProgressBar(
+    currentIndex: Int,
+    totalCount: Int,
+    currentModuleName: String,
+    status: FlashingStatus,
+    failedModules: List<String>
+) {
+    val progressColor = when(status) {
+        FlashingStatus.FLASHING -> MaterialTheme.colorScheme.primary
+        FlashingStatus.SUCCESS -> MaterialTheme.colorScheme.tertiary
+        FlashingStatus.FAILED -> MaterialTheme.colorScheme.error
+    }
+
+    val progress = animateFloatAsState(
+        targetValue = currentIndex.toFloat() / totalCount.toFloat(),
+        label = "InstallProgress"
+    )
+
+    Card(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(16.dp),
+        colors = CardDefaults.cardColors(
+            containerColor = MaterialTheme.colorScheme.surfaceVariant
+        )
+    ) {
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(16.dp)
+        ) {
+            // 模块名称和进度
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                verticalAlignment = Alignment.CenterVertically,
+                horizontalArrangement = Arrangement.SpaceBetween
+            ) {
+                Text(
+                    text = if (currentModuleName.isNotEmpty()) currentModuleName else stringResource(R.string.module),
+                    style = MaterialTheme.typography.titleMedium,
+                    fontWeight = FontWeight.Bold
+                )
+
+                Text(
+                    text = "$currentIndex/$totalCount",
+                    style = MaterialTheme.typography.titleMedium
+                )
+            }
+
+            Spacer(modifier = Modifier.height(8.dp))
+
+            // 进度条
+            LinearProgressIndicator(
+                progress = { progress.value },
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .height(8.dp),
+                color = progressColor,
+                trackColor = MaterialTheme.colorScheme.surfaceVariant
+            )
+
+            Spacer(modifier = Modifier.height(8.dp))
+
+            // 失败模块列表
+            AnimatedVisibility(
+                visible = failedModules.isNotEmpty(),
+                enter = fadeIn() + expandVertically(),
+                exit = fadeOut() + shrinkVertically()
+            ) {
+                Column {
+                    Row(
+                        verticalAlignment = Alignment.CenterVertically
+                    ) {
+                        Icon(
+                            imageVector = Icons.Default.Error,
+                            contentDescription = null,
+                            tint = MaterialTheme.colorScheme.error,
+                            modifier = Modifier.size(16.dp)
+                        )
+
+                        Spacer(modifier = Modifier.width(4.dp))
+
+                        Text(
+                            text = stringResource(R.string.module_failed_count, failedModules.size),
+                            style = MaterialTheme.typography.bodyMedium,
+                            color = MaterialTheme.colorScheme.error
+                        )
+                    }
+
+                    Spacer(modifier = Modifier.height(4.dp))
+
+                    // 失败模块列表
+                    Column(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .background(
+                                MaterialTheme.colorScheme.errorContainer.copy(alpha = 0.3f),
+                                shape = MaterialTheme.shapes.small
+                            )
+                            .padding(8.dp)
+                    ) {
+                        failedModules.forEach { moduleName ->
+                            Text(
+                                text = "• $moduleName",
+                                style = MaterialTheme.typography.bodySmall,
+                                color = MaterialTheme.colorScheme.onErrorContainer
+                            )
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun TopBar(
+    status: FlashingStatus,
+    moduleStatus: ModuleInstallStatus = ModuleInstallStatus(),
+    navigator: DestinationsNavigator,
+    flashIt: FlashIt,
+    onBack: () -> Unit,
+    onSave: () -> Unit = {},
+    scrollBehavior: TopAppBarScrollBehavior? = null
+) {
+    val cardColor = MaterialTheme.colorScheme.surfaceContainerLow
+    val cardAlpha = CardConfig.cardAlpha
+
+    val statusColor = when(status) {
+        FlashingStatus.FLASHING -> MaterialTheme.colorScheme.primary
+        FlashingStatus.SUCCESS -> MaterialTheme.colorScheme.tertiary
+        FlashingStatus.FAILED -> MaterialTheme.colorScheme.error
+    }
+
+    TopAppBar(
+        title = {
+            Column {
+                Text(
+                    text = stringResource(
+                        when (status) {
+                            FlashingStatus.FLASHING -> R.string.flashing
+                            FlashingStatus.SUCCESS -> R.string.flash_success
+                            FlashingStatus.FAILED -> R.string.flash_failed
+                        }
+                    ),
+                    style = MaterialTheme.typography.titleLarge,
+                    color = statusColor
+                )
+
+                if (moduleStatus.failedModules.isNotEmpty()) {
+                    Text(
+                        text = stringResource(R.string.module_failed_count, moduleStatus.failedModules.size),
+                        style = MaterialTheme.typography.bodySmall,
+                        color = MaterialTheme.colorScheme.error
+                    )
+                }
+            }
+        },
+        navigationIcon = {
+            IconButton(onClick = onBack) {
+                Icon(
+                    imageVector = Icons.AutoMirrored.Filled.ArrowBack,
+                    contentDescription = null,
+                    tint = MaterialTheme.colorScheme.onSurface
+                )
+            }
+        },
+        colors = TopAppBarDefaults.topAppBarColors(
+            containerColor = cardColor.copy(alpha = cardAlpha),
+            scrolledContainerColor = cardColor.copy(alpha = cardAlpha)
+        ),
+        actions = {
+            IconButton(onClick = onSave) {
+                Icon(
+                    imageVector = Icons.Filled.Save,
+                    contentDescription = stringResource(id = R.string.save_log),
+                    tint = MaterialTheme.colorScheme.onSurfaceVariant
+                )
+            }
+        },
+        windowInsets = WindowInsets.safeDrawing.only(WindowInsetsSides.Top + WindowInsetsSides.Horizontal),
+        scrollBehavior = scrollBehavior
+    )
+}
+
+suspend fun getModuleNameFromUri(context: android.content.Context, uri: Uri): String {
+    return withContext(Dispatchers.IO) {
+        try {
+            if (uri == Uri.EMPTY) {
+                return@withContext context.getString(R.string.unknown_module)
+            }
+            if (!ModuleUtils.isUriAccessible(context, uri)) {
+                return@withContext context.getString(R.string.unknown_module)
+            }
+            ModuleUtils.extractModuleName(context, uri)
+        } catch (_: Exception) {
+            context.getString(R.string.unknown_module)
+        }
+    }
+}
+
+@Parcelize
+sealed class FlashIt : Parcelable {
+    data class FlashBoot(val boot: Uri? = null, val lkm: LkmSelection, val ota: Boolean) : FlashIt()
+    data class FlashModule(val uri: Uri) : FlashIt()
+    data class FlashModules(val uris: List<Uri>, val currentIndex: Int = 0) : FlashIt()
+    data object FlashRestore : FlashIt()
+    data object FlashUninstall : FlashIt()
+}
+
+fun flashIt(
+    context: android.content.Context,
+    flashIt: FlashIt,
+    onFinish: (Boolean, Int) -> Unit,
+    onStdout: (String) -> Unit,
+    onStderr: (String) -> Unit
+) {
+    when (flashIt) {
+        is FlashIt.FlashBoot -> installBoot(
+            flashIt.boot,
+            flashIt.lkm,
+            flashIt.ota,
+            onFinish,
+            onStdout,
+            onStderr
+        )
+        is FlashIt.FlashModule -> flashModule(flashIt.uri, onFinish, onStdout, onStderr)
+        is FlashIt.FlashModules -> {
+            if (flashIt.uris.isEmpty() || flashIt.currentIndex >= flashIt.uris.size) {
+                onFinish(false, 0)
+                return
+            }
+
+            val currentUri = flashIt.uris[flashIt.currentIndex]
+            onStdout("\n")
+
+            flashModule(currentUri, onFinish, onStdout, onStderr)
+        }
+        FlashIt.FlashRestore -> restoreBoot(onFinish, onStdout, onStderr)
+        FlashIt.FlashUninstall -> uninstallPermanently(onFinish, onStdout, onStderr)
+    }
+}
+
+@Preview
+@Composable
+fun FlashScreenPreview() {
+    FlashScreen(EmptyDestinationsNavigator, FlashIt.FlashUninstall)
+}

manager/app/src/main/java/com/sukisu/ultra/ui/screen/Home.kt

@@ -0,0 +1,924 @@
+package com.sukisu.ultra.ui.screen
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.os.Build
+import android.os.PowerManager
+import android.system.Os
+import androidx.annotation.StringRes
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.core.Spring
+import androidx.compose.animation.core.spring
+import androidx.compose.animation.expandVertically
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.shrinkVertically
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.WindowInsets
+import androidx.compose.foundation.layout.WindowInsetsSides
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.only
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.safeDrawing
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.layout.wrapContentHeight
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.ExperimentalMaterialApi
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Android
+import androidx.compose.material.icons.filled.Archive
+import androidx.compose.material.icons.filled.Info
+import androidx.compose.material.icons.filled.Memory
+import androidx.compose.material.icons.filled.PhoneAndroid
+import androidx.compose.material.icons.filled.Refresh
+import androidx.compose.material.icons.filled.Security
+import androidx.compose.material.icons.filled.SettingsSuggest
+import androidx.compose.material.icons.filled.Storage
+import androidx.compose.material.icons.outlined.Block
+import androidx.compose.material.icons.outlined.TaskAlt
+import androidx.compose.material.icons.outlined.Warning
+import androidx.compose.material.pullrefresh.pullRefresh
+import androidx.compose.material.pullrefresh.rememberPullRefreshState
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.DropdownMenu
+import androidx.compose.material3.DropdownMenuItem
+import androidx.compose.material3.ElevatedCard
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBar
+import androidx.compose.material3.TopAppBarDefaults
+import androidx.compose.material3.TopAppBarScrollBehavior
+import androidx.compose.material3.pulltorefresh.PullToRefreshBox
+import androidx.compose.material3.rememberTopAppBarState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.produceState
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.composed
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.draw.shadow
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.input.nestedscroll.nestedScroll
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalUriHandler
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.core.content.pm.PackageInfoCompat
+import androidx.lifecycle.viewmodel.compose.viewModel
+import com.ramcosta.composedestinations.annotation.Destination
+import com.ramcosta.composedestinations.annotation.RootGraph
+import com.ramcosta.composedestinations.generated.destinations.InstallScreenDestination
+import com.ramcosta.composedestinations.navigation.DestinationsNavigator
+import com.sukisu.ultra.KernelVersion
+import com.sukisu.ultra.Natives
+import com.sukisu.ultra.R
+import com.sukisu.ultra.ui.component.KsuIsValid
+import com.sukisu.ultra.ui.component.rememberConfirmDialog
+import com.sukisu.ultra.ui.theme.CardConfig
+import com.sukisu.ultra.ui.theme.CardConfig.cardElevation
+import com.sukisu.ultra.ui.theme.getCardColors
+import com.sukisu.ultra.ui.util.checkNewVersion
+import com.sukisu.ultra.ui.util.getKpmModuleCount
+import com.sukisu.ultra.ui.util.getKpmVersion
+import com.sukisu.ultra.ui.util.getModuleCount
+import com.sukisu.ultra.ui.util.getSuperuserCount
+import com.sukisu.ultra.ui.util.module.LatestVersionInfo
+import com.sukisu.ultra.ui.util.reboot
+import com.sukisu.ultra.ui.viewmodel.HomeViewModel
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import kotlin.random.Random
+
+/**
+ * @author ShirkNeko
+ * @date 2025/5/31.
+ */
+@OptIn(ExperimentalMaterial3Api::class, ExperimentalMaterialApi::class)
+@Destination<RootGraph>(start = true)
+@Composable
+fun HomeScreen(navigator: DestinationsNavigator) {
+    val context = LocalContext.current
+    val viewModel = viewModel<HomeViewModel>()
+    val coroutineScope = rememberCoroutineScope()
+
+    LaunchedEffect(key1 = navigator) {
+        coroutineScope.launch {
+            viewModel.refreshAllData(context)
+        }
+    }
+
+    LaunchedEffect(Unit) {
+        viewModel.loadUserSettings(context)
+        viewModel.initializeData()
+        viewModel.checkForUpdates(context)
+    }
+
+    val scrollBehavior = TopAppBarDefaults.pinnedScrollBehavior(rememberTopAppBarState())
+    val scrollState = rememberScrollState()
+
+    Scaffold(
+        topBar = {
+            TopBar(
+                kernelVersion = viewModel.systemStatus.kernelVersion,
+                onInstallClick = { navigator.navigate(InstallScreenDestination) },
+                scrollBehavior = scrollBehavior
+            )
+        },
+        contentWindowInsets = WindowInsets.safeDrawing.only(
+            WindowInsetsSides.Top + WindowInsetsSides.Horizontal
+        )
+    ) { innerPadding ->
+        val pullRefreshState = rememberPullRefreshState(
+            refreshing = false,
+            onRefresh = {
+                coroutineScope.launch {
+                    viewModel.refreshAllData(context)
+                }
+            }
+        )
+
+        Box(
+            modifier = Modifier
+                .padding(innerPadding)
+                .fillMaxSize()
+                .pullRefresh(pullRefreshState)
+        ) {
+            Column(
+                modifier = Modifier
+                    .fillMaxSize()
+                    .verticalScroll(scrollState)
+                    .padding(top = 12.dp, start = 16.dp, end = 16.dp),
+                verticalArrangement = Arrangement.spacedBy(12.dp)
+            ) {
+                StatusCard(
+                    systemStatus = viewModel.systemStatus,
+                    onClickInstall = {
+                        navigator.navigate(InstallScreenDestination)
+                    }
+                )
+
+                if (viewModel.systemStatus.requireNewKernel) {
+                    WarningCard(
+                        stringResource(id = R.string.require_kernel_version).format(
+                            viewModel.systemStatus.ksuVersion,
+                            Natives.MINIMAL_SUPPORTED_KERNEL
+                        )
+                    )
+                }
+
+                if (viewModel.systemStatus.ksuVersion != null && !viewModel.systemStatus.isRootAvailable) {
+                    WarningCard(
+                        stringResource(id = R.string.grant_root_failed)
+                    )
+                }
+
+                val checkUpdate = context.getSharedPreferences("settings", Context.MODE_PRIVATE)
+                    .getBoolean("check_update", true)
+                if (checkUpdate) {
+                    UpdateCard()
+                }
+
+                InfoCard(
+                    systemInfo = viewModel.systemInfo,
+                    isSimpleMode = viewModel.isSimpleMode,
+                    isHideVersion = viewModel.isHideVersion,
+                    isHideOtherInfo = viewModel.isHideOtherInfo,
+                    isHideSusfsStatus = viewModel.isHideSusfsStatus,
+                    showKpmInfo = viewModel.showKpmInfo,
+                    lkmMode = viewModel.systemStatus.lkmMode,
+                )
+
+                if (!viewModel.isSimpleMode) {
+                    if (!viewModel.isHideLinkCard) {
+                        ContributionCard()
+                        DonateCard()
+                        LearnMoreCard()
+                    }
+                }
+                Spacer(Modifier.height(16.dp))
+            }
+        }
+    }
+}
+
+@Composable
+fun UpdateCard() {
+    val context = LocalContext.current
+    val latestVersionInfo = LatestVersionInfo()
+    val newVersion by produceState(initialValue = latestVersionInfo) {
+        value = withContext(Dispatchers.IO) {
+            checkNewVersion()
+        }
+    }
+
+    val currentVersionCode = getManagerVersion(context).second
+    val newVersionCode = newVersion.versionCode
+    val newVersionUrl = newVersion.downloadUrl
+    val changelog = newVersion.changelog
+
+    val uriHandler = LocalUriHandler.current
+    val title = stringResource(id = R.string.module_changelog)
+    val updateText = stringResource(id = R.string.module_update)
+
+    AnimatedVisibility(
+        visible = newVersionCode > currentVersionCode,
+        enter = fadeIn() + expandVertically(
+            animationSpec = spring(
+                dampingRatio = Spring.DampingRatioMediumBouncy,
+                stiffness = Spring.StiffnessLow
+            )
+        ),
+        exit = shrinkVertically() + fadeOut()
+    ) {
+        val updateDialog = rememberConfirmDialog(onConfirm = { uriHandler.openUri(newVersionUrl) })
+        WarningCard(
+            message = stringResource(id = R.string.new_version_available).format(newVersionCode),
+            color = MaterialTheme.colorScheme.surfaceVariant,
+            onClick = {
+                if (changelog.isEmpty()) {
+                    uriHandler.openUri(newVersionUrl)
+                } else {
+                    updateDialog.showConfirm(
+                        title = title,
+                        content = changelog,
+                        markdown = true,
+                        confirm = updateText
+                    )
+                }
+            }
+        )
+    }
+}
+
+@Composable
+fun RebootDropdownItem(@StringRes id: Int, reason: String = "") {
+    DropdownMenuItem(
+        text = { Text(stringResource(id)) },
+        onClick = { reboot(reason) },
+        leadingIcon = {
+            Icon(
+                imageVector = Icons.Filled.Refresh,
+                contentDescription = null,
+            )
+        }
+    )
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun TopBar(
+    kernelVersion: KernelVersion,
+    onInstallClick: () -> Unit,
+    scrollBehavior: TopAppBarScrollBehavior? = null
+) {
+    val cardColor = MaterialTheme.colorScheme.surfaceContainerLow
+    val cardAlpha = CardConfig.cardAlpha
+
+    TopAppBar(
+        title = {
+            Text(
+                text = stringResource(R.string.app_name),
+                style = MaterialTheme.typography.titleLarge
+            )
+        },
+        colors = TopAppBarDefaults.topAppBarColors(
+            containerColor = cardColor.copy(alpha = cardAlpha),
+            scrolledContainerColor = cardColor.copy(alpha = cardAlpha)
+        ),
+        actions = {
+            var showDropdown by remember { mutableStateOf(false) }
+            KsuIsValid {
+                IconButton(onClick = {
+                    showDropdown = true
+                }) {
+                    Icon(
+                        imageVector = Icons.Filled.Refresh,
+                        contentDescription = stringResource(id = R.string.reboot)
+                    )
+
+                    DropdownMenu(expanded = showDropdown, onDismissRequest = {
+                        showDropdown = false
+                    }) {
+                        RebootDropdownItem(id = R.string.reboot)
+
+                        val pm = LocalContext.current.getSystemService(Context.POWER_SERVICE) as PowerManager?
+                        @Suppress("DEPRECATION")
+                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R && pm?.isRebootingUserspaceSupported == true) {
+                            RebootDropdownItem(id = R.string.reboot_userspace, reason = "userspace")
+                        }
+                        RebootDropdownItem(id = R.string.reboot_recovery, reason = "recovery")
+                        RebootDropdownItem(id = R.string.reboot_bootloader, reason = "bootloader")
+                        RebootDropdownItem(id = R.string.reboot_download, reason = "download")
+                        RebootDropdownItem(id = R.string.reboot_edl, reason = "edl")
+                    }
+                }
+            }
+        },
+        windowInsets = WindowInsets.safeDrawing.only(WindowInsetsSides.Top + WindowInsetsSides.Horizontal),
+        scrollBehavior = scrollBehavior
+    )
+}
+
+@Composable
+private fun StatusCard(
+    systemStatus: HomeViewModel.SystemStatus,
+    onClickInstall: () -> Unit = {}
+) {
+    ElevatedCard(
+        colors = getCardColors(MaterialTheme.colorScheme.secondaryContainer),
+        elevation = CardDefaults.cardElevation(defaultElevation = cardElevation),
+        modifier = Modifier
+            .fillMaxWidth()
+            .clip(MaterialTheme.shapes.large)
+            .shadow(
+                elevation = cardElevation,
+                shape = MaterialTheme.shapes.large,
+                spotColor = MaterialTheme.colorScheme.surface.copy(alpha = 0.1f)
+            )
+    ) {
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .clickable {
+                    if (systemStatus.isRootAvailable || systemStatus.kernelVersion.isGKI()) {
+                        onClickInstall()
+                    }
+                }
+                .padding(24.dp),
+            verticalAlignment = Alignment.CenterVertically
+        ) {
+            when {
+                systemStatus.ksuVersion != null -> {
+
+                    val workingModeText = when {
+                        systemStatus.lkmMode == true -> "LKM"
+                        systemStatus.lkmMode == null && systemStatus.kernelVersion.isGKI1() -> "GKI-1.0"
+                        systemStatus.lkmMode == false || systemStatus.kernelVersion.isGKI() -> "GKI-2.0"
+                        else -> "N-GKI"
+                    }
+
+                    Icon(
+                        Icons.Outlined.TaskAlt,
+                        contentDescription = stringResource(R.string.home_working),
+                        tint = MaterialTheme.colorScheme.primary,
+                        modifier = Modifier.size(24.dp)
+                    )
+
+                    Column(Modifier.padding(start = 20.dp)) {
+                        Row(
+                            verticalAlignment = Alignment.CenterVertically,
+                            modifier = Modifier.fillMaxWidth()
+                        ) {
+                            Text(
+                                text = stringResource(id = R.string.home_working),
+                                style = MaterialTheme.typography.titleMedium,
+                                color = MaterialTheme.colorScheme.onSurface
+                            )
+
+                            Spacer(Modifier.width(8.dp))
+
+                            // 工作模式标签
+                            Surface(
+                                shape = RoundedCornerShape(4.dp),
+                                color = MaterialTheme.colorScheme.primary,
+                                modifier = Modifier
+                            ) {
+                                Text(
+                                    text = workingModeText,
+                                    style = MaterialTheme.typography.labelMedium,
+                                    color = MaterialTheme.colorScheme.onSecondary,
+                                    modifier = Modifier.padding(horizontal = 6.dp, vertical = 2.dp)
+                                )
+                            }
+
+                            Spacer(Modifier.width(6.dp))
+
+                            // 机器架构标签或者安全模式标签
+                            val labelText = if (Natives.isSafeMode) {
+                                stringResource(id = R.string.safe_mode)
+                            } else {
+                                Os.uname().machine
+                            }
+
+                            Surface(
+                                shape = RoundedCornerShape(4.dp),
+                                color = MaterialTheme.colorScheme.primary,
+                                modifier = Modifier
+                            ) {
+                                Text(
+                                    text = labelText,
+                                    style = MaterialTheme.typography.labelMedium,
+                                    color = MaterialTheme.colorScheme.onSecondary,
+                                    modifier = Modifier.padding(horizontal = 6.dp, vertical = 2.dp)
+                                )
+                            }
+                        }
+
+                        val isHideVersion = LocalContext.current.getSharedPreferences("settings", Context.MODE_PRIVATE)
+                            .getBoolean("is_hide_version", false)
+
+                        val isHideOtherInfo = LocalContext.current.getSharedPreferences("settings", Context.MODE_PRIVATE)
+                            .getBoolean("is_hide_other_info", false)
+
+                        val showKpmInfo = LocalContext.current.getSharedPreferences("settings", Context.MODE_PRIVATE)
+                            .getBoolean("show_kpm_info", true)
+
+                        if (!isHideVersion) {
+                            Spacer(Modifier.height(4.dp))
+                            Text(
+                                text = stringResource(R.string.home_working_version, systemStatus.ksuVersion),
+                                style = MaterialTheme.typography.bodyMedium,
+                                color = MaterialTheme.colorScheme.onSurfaceVariant
+                            )
+                        }
+
+                        if (!isHideOtherInfo) {
+                            Spacer(Modifier.height(4.dp))
+                            Text(
+                                text = stringResource(R.string.home_superuser_count, getSuperuserCount()),
+                                style = MaterialTheme.typography.bodyMedium,
+                                color = MaterialTheme.colorScheme.onSurfaceVariant
+                            )
+
+                            Spacer(Modifier.height(4.dp))
+                            Text(
+                                text = stringResource(R.string.home_module_count, getModuleCount()),
+                                style = MaterialTheme.typography.bodyMedium,
+                                color = MaterialTheme.colorScheme.onSurfaceVariant
+                            )
+
+                            val kpmVersion = getKpmVersion()
+                            if (kpmVersion.isNotEmpty() && !kpmVersion.startsWith("Error") && showKpmInfo && Natives.version >= Natives.MINIMAL_SUPPORTED_KPM) {
+                                Spacer(Modifier.height(4.dp))
+                                Text(
+                                    text = stringResource(R.string.home_kpm_module, getKpmModuleCount()),
+                                    style = MaterialTheme.typography.bodyMedium,
+                                    color = MaterialTheme.colorScheme.onSurfaceVariant
+                                )
+                            }
+                        }
+                    }
+                }
+
+                systemStatus.kernelVersion.isGKI() -> {
+                    Icon(
+                        Icons.Outlined.Warning,
+                        contentDescription = stringResource(R.string.home_not_installed),
+                        tint = MaterialTheme.colorScheme.error,
+                        modifier = Modifier.size(24.dp)
+                    )
+
+                    Column(Modifier.padding(start = 20.dp)) {
+                        Text(
+                            text = stringResource(R.string.home_not_installed),
+                            style = MaterialTheme.typography.titleMedium,
+                            color = MaterialTheme.colorScheme.error
+                        )
+
+                        Spacer(Modifier.height(4.dp))
+                        Text(
+                            text = stringResource(R.string.home_click_to_install),
+                            style = MaterialTheme.typography.bodyMedium,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant
+                        )
+                    }
+                }
+
+                else -> {
+                    Icon(
+                        Icons.Outlined.Block,
+                        contentDescription = stringResource(R.string.home_unsupported),
+                        tint = MaterialTheme.colorScheme.error,
+                        modifier = Modifier.size(24.dp)
+                    )
+
+                    Column(Modifier.padding(start = 20.dp)) {
+                        Text(
+                            text = stringResource(R.string.home_unsupported),
+                            style = MaterialTheme.typography.titleMedium,
+                            color = MaterialTheme.colorScheme.error
+                        )
+
+                        Spacer(Modifier.height(4.dp))
+                        Text(
+                            text = stringResource(R.string.home_unsupported_reason),
+                            style = MaterialTheme.typography.bodyMedium,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant
+                        )
+                    }
+                }
+            }
+        }
+    }
+}
+
+@Composable
+fun WarningCard(
+    message: String,
+    color: Color = MaterialTheme.colorScheme.error,
+    onClick: (() -> Unit)? = null
+) {
+    ElevatedCard(
+        colors = getCardColors(color),
+        elevation = CardDefaults.cardElevation(defaultElevation = cardElevation),
+        modifier = Modifier
+            .fillMaxWidth()
+            .clip(MaterialTheme.shapes.large)
+            .shadow(
+                elevation = cardElevation,
+                shape = MaterialTheme.shapes.large,
+            )
+    ) {
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .then(onClick?.let { Modifier.clickable { it() } } ?: Modifier)
+                .padding(24.dp),
+            verticalAlignment = Alignment.CenterVertically
+        ) {
+            Text(
+                text = message,
+                style = MaterialTheme.typography.bodyMedium,
+                color = MaterialTheme.colorScheme.onErrorContainer
+            )
+        }
+    }
+}
+
+@Composable
+fun ContributionCard() {
+    val uriHandler = LocalUriHandler.current
+    val links = listOf("https://github.com/ShirkNeko", "https://github.com/udochina")
+
+    ElevatedCard(
+        colors = getCardColors(MaterialTheme.colorScheme.surfaceContainer),
+        elevation = CardDefaults.cardElevation(defaultElevation = cardElevation),
+        modifier = Modifier
+            .fillMaxWidth()
+            .wrapContentHeight()
+            .clip(MaterialTheme.shapes.large)
+            .shadow(
+                elevation = cardElevation,
+                shape = MaterialTheme.shapes.large,
+                spotColor = MaterialTheme.colorScheme.tertiary.copy(alpha = 0.1f)
+            )
+    ) {
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .clickable {
+                    val randomIndex = Random.nextInt(links.size)
+                    uriHandler.openUri(links[randomIndex])
+                }
+                .padding(24.dp),
+            verticalAlignment = Alignment.CenterVertically
+        ) {
+            Column {
+                Text(
+                    text = stringResource(R.string.home_ContributionCard_kernelsu),
+                    style = MaterialTheme.typography.titleSmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant
+                )
+
+                Spacer(Modifier.height(4.dp))
+                Text(
+                    text = stringResource(R.string.home_click_to_ContributionCard_kernelsu),
+                    style = MaterialTheme.typography.bodyMedium,
+                    color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.8f)
+                )
+            }
+        }
+    }
+}
+
+@Composable
+fun LearnMoreCard() {
+    val uriHandler = LocalUriHandler.current
+    val url = stringResource(R.string.home_learn_kernelsu_url)
+
+    ElevatedCard(
+        colors = getCardColors(MaterialTheme.colorScheme.surfaceContainer),
+        elevation = CardDefaults.cardElevation(defaultElevation = cardElevation),
+        modifier = Modifier
+            .fillMaxWidth()
+            .clip(MaterialTheme.shapes.large)
+            .shadow(
+                elevation = cardElevation,
+                shape = MaterialTheme.shapes.large,
+                spotColor = MaterialTheme.colorScheme.primary.copy(alpha = 0.1f)
+            )
+    ) {
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .clickable {
+                    uriHandler.openUri(url)
+                }
+                .padding(24.dp),
+            verticalAlignment = Alignment.CenterVertically
+        ) {
+            Column {
+                Text(
+                    text = stringResource(R.string.home_learn_kernelsu),
+                    style = MaterialTheme.typography.titleSmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant
+                )
+
+                Spacer(Modifier.height(4.dp))
+                Text(
+                    text = stringResource(R.string.home_click_to_learn_kernelsu),
+                    style = MaterialTheme.typography.bodyMedium,
+                    color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.8f)
+                )
+            }
+        }
+    }
+}
+
+@Composable
+fun DonateCard() {
+    val uriHandler = LocalUriHandler.current
+
+    ElevatedCard(
+        colors = getCardColors(MaterialTheme.colorScheme.surfaceContainer),
+        elevation = CardDefaults.cardElevation(defaultElevation = cardElevation),
+        modifier = Modifier
+            .fillMaxWidth()
+            .clip(MaterialTheme.shapes.large)
+            .shadow(
+                elevation = cardElevation,
+                shape = MaterialTheme.shapes.large,
+                spotColor = MaterialTheme.colorScheme.secondary.copy(alpha = 0.1f)
+            )
+    ) {
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .clickable {
+                    uriHandler.openUri("https://patreon.com/weishu")
+                }
+                .padding(24.dp),
+            verticalAlignment = Alignment.CenterVertically
+        ) {
+            Column {
+                Text(
+                    text = stringResource(R.string.home_support_title),
+                    style = MaterialTheme.typography.titleSmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant
+                )
+
+                Spacer(Modifier.height(4.dp))
+                Text(
+                    text = stringResource(R.string.home_support_content),
+                    style = MaterialTheme.typography.bodyMedium,
+                    color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.8f)
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun InfoCard(
+    systemInfo: HomeViewModel.SystemInfo,
+    isSimpleMode: Boolean,
+    isHideVersion: Boolean,
+    isHideOtherInfo: Boolean,
+    isHideSusfsStatus: Boolean,
+    showKpmInfo: Boolean,
+    lkmMode: Boolean?
+) {
+    ElevatedCard(
+        colors = getCardColors(MaterialTheme.colorScheme.surfaceContainer),
+        elevation = CardDefaults.cardElevation(defaultElevation = cardElevation),
+        modifier = Modifier
+            .fillMaxWidth()
+            .clip(MaterialTheme.shapes.large)
+            .shadow(
+                elevation = cardElevation,
+                shape = MaterialTheme.shapes.large,
+                spotColor = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.05f)
+            )
+    ) {
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(start = 24.dp, top = 24.dp, end = 24.dp, bottom = 16.dp),
+        ) {
+            @Composable
+            fun InfoCardItem(
+                label: String,
+                content: String,
+                icon: ImageVector = Icons.Default.Info
+            ) {
+                Row(
+                    verticalAlignment = Alignment.CenterVertically,
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(vertical = 8.dp)
+                ) {
+                    Icon(
+                        imageVector = icon,
+                        contentDescription = label,
+                        modifier = Modifier.size(24.dp),
+                        tint = MaterialTheme.colorScheme.primary.copy(alpha = 0.7f),
+                    )
+                    Spacer(modifier = Modifier.width(16.dp))
+                    Column(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .weight(1f)
+                    ){
+                        Text(
+                            text = label,
+                            style = MaterialTheme.typography.labelLarge,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant
+                        )
+                        Text(
+                            text = content,
+                            style = MaterialTheme.typography.bodyMedium,
+                            color = MaterialTheme.colorScheme.onSurface,
+                            softWrap = true
+                        )
+                    }
+                }
+            }
+
+            InfoCardItem(
+                stringResource(R.string.home_kernel),
+                systemInfo.kernelRelease,
+                icon = Icons.Default.Memory,
+            )
+
+            if (!isSimpleMode) {
+                InfoCardItem(
+                    stringResource(R.string.home_android_version),
+                    systemInfo.androidVersion,
+                    icon = Icons.Default.Android,
+                )
+            }
+
+            InfoCardItem(
+                stringResource(R.string.home_device_model),
+                systemInfo.deviceModel,
+                icon = Icons.Default.PhoneAndroid,
+            )
+
+            InfoCardItem(
+                stringResource(R.string.home_manager_version),
+                "${systemInfo.managerVersion.first} (${systemInfo.managerVersion.second.toInt()})",
+                icon = Icons.Default.SettingsSuggest,
+            )
+
+            InfoCardItem(
+                stringResource(R.string.home_selinux_status),
+                systemInfo.seLinuxStatus,
+                icon = Icons.Default.Security,
+            )
+
+            if (!isSimpleMode) {
+                if (lkmMode != true) {
+                    // 根据showKpmInfo决定是否显示KPM信息
+                    if (showKpmInfo && Natives.version >= Natives.MINIMAL_SUPPORTED_KPM) {
+                        val displayVersion = if (systemInfo.kpmVersion.isEmpty() || systemInfo.kpmVersion.startsWith("Error")) {
+                            val statusText = if (Natives.isKPMEnabled()) {
+                                stringResource(R.string.kernel_patched)
+                            } else {
+                                stringResource(R.string.kernel_not_enabled)
+                            }
+                            "${stringResource(R.string.not_supported)} ($statusText)"
+                        } else {
+                            "${stringResource(R.string.supported)} (${systemInfo.kpmVersion})"
+                        }
+
+                        InfoCardItem(
+                            stringResource(R.string.home_kpm_version),
+                            displayVersion,
+                            icon = Icons.Default.Archive
+                        )
+                    }
+                }
+            }
+
+            if ((!isSimpleMode) && (!isHideSusfsStatus)) {
+                if (systemInfo.suSFSStatus == "Supported") {
+                    if (systemInfo.suSFSVersion.isNotEmpty()) {
+                        val isSUS_SU = systemInfo.suSFSFeatures == "CONFIG_KSU_SUSFS_SUS_SU"
+                        val infoText = buildString {
+                            append(systemInfo.suSFSVersion)
+                            append(if (isSUS_SU) " (${systemInfo.suSFSVariant})" else " (${stringResource(R.string.manual_hook)})")
+                            if (isSUS_SU) {
+                                if (systemInfo.susSUMode.isNotEmpty()) {
+                                    append(" ${stringResource(R.string.sus_su_mode)} ${systemInfo.susSUMode}")
+                                }
+                            }
+                        }
+
+                        InfoCardItem(
+                            stringResource(R.string.home_susfs_version),
+                            infoText,
+                            icon = Icons.Default.Storage
+                        )
+                    }
+                }
+            }
+        }
+    }
+}
+
+fun getManagerVersion(context: Context): Pair<String, Long> {
+    val packageInfo = context.packageManager.getPackageInfo(context.packageName, 0)!!
+    val versionCode = PackageInfoCompat.getLongVersionCode(packageInfo)
+    return Pair(packageInfo.versionName!!, versionCode)
+}
+
+@Preview
+@Composable
+private fun StatusCardPreview() {
+    Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+        StatusCard(
+            HomeViewModel.SystemStatus(
+                isManager = true,
+                ksuVersion = 1,
+                lkmMode = null,
+                kernelVersion = KernelVersion(5, 10, 101),
+                isRootAvailable = true
+            )
+        )
+
+        StatusCard(
+            HomeViewModel.SystemStatus(
+                isManager = true,
+                ksuVersion = 20000,
+                lkmMode = true,
+                kernelVersion = KernelVersion(5, 10, 101),
+                isRootAvailable = true
+            )
+        )
+
+        StatusCard(
+            HomeViewModel.SystemStatus(
+                isManager = false,
+                ksuVersion = null,
+                lkmMode = true,
+                kernelVersion = KernelVersion(5, 10, 101),
+                isRootAvailable = false
+            )
+        )
+
+        StatusCard(
+            HomeViewModel.SystemStatus(
+                isManager = false,
+                ksuVersion = null,
+                lkmMode = false,
+                kernelVersion = KernelVersion(4, 10, 101),
+                isRootAvailable = false
+            )
+        )
+    }
+}
+
+@Preview
+@Composable
+private fun WarningCardPreview() {
+    Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+        WarningCard(message = "Warning message")
+        WarningCard(
+            message = "Warning message ",
+            MaterialTheme.colorScheme.outlineVariant,
+            onClick = {})
+    }
+}
+
+@SuppressLint("UnnecessaryComposedModifier")
+fun Modifier.disableOverscroll(): Modifier = composed {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+        this
+    } else {
+        this
+    }
+}

manager/app/src/main/java/com/sukisu/ultra/ui/screen/Install.kt

@@ -0,0 +1,768 @@
+package com.sukisu.ultra.ui.screen
+
+import android.app.Activity
+import android.content.Intent
+import android.net.Uri
+import android.widget.Toast
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.annotation.StringRes
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.expandVertically
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.shrinkVertically
+import androidx.compose.foundation.LocalIndication
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.WindowInsets
+import androidx.compose.foundation.layout.WindowInsetsSides
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.only
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.safeDrawing
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.selection.toggleable
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.ArrowBack
+import androidx.compose.material.icons.filled.AutoFixHigh
+import androidx.compose.material.icons.filled.FileUpload
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Button
+import androidx.compose.material3.ButtonDefaults
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.ElevatedCard
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.ListItem
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.RadioButton
+import androidx.compose.material3.RadioButtonDefaults
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.material3.TopAppBar
+import androidx.compose.material3.TopAppBarDefaults
+import androidx.compose.material3.TopAppBarScrollBehavior
+import androidx.compose.material3.rememberTopAppBarState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.produceState
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.draw.shadow
+import androidx.compose.ui.input.nestedscroll.nestedScroll
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import com.maxkeppeker.sheets.core.models.base.Header
+import com.maxkeppeker.sheets.core.models.base.rememberUseCaseState
+import com.maxkeppeler.sheets.list.ListDialog
+import com.maxkeppeler.sheets.list.models.ListOption
+import com.maxkeppeler.sheets.list.models.ListSelection
+import com.ramcosta.composedestinations.annotation.Destination
+import com.ramcosta.composedestinations.annotation.RootGraph
+import com.ramcosta.composedestinations.generated.destinations.FlashScreenDestination
+import com.ramcosta.composedestinations.generated.destinations.KernelFlashScreenDestination
+import com.ramcosta.composedestinations.navigation.DestinationsNavigator
+import com.ramcosta.composedestinations.navigation.EmptyDestinationsNavigator
+import com.sukisu.ultra.R
+import com.sukisu.ultra.ui.component.DialogHandle
+import com.sukisu.ultra.ui.component.SlotSelectionDialog
+import com.sukisu.ultra.ui.component.rememberConfirmDialog
+import com.sukisu.ultra.ui.component.rememberCustomDialog
+import com.sukisu.ultra.ui.theme.CardConfig.cardAlpha
+import com.sukisu.ultra.ui.theme.CardConfig.cardElevation
+import com.sukisu.ultra.ui.theme.getCardColors
+import com.sukisu.ultra.ui.util.LkmSelection
+import com.sukisu.ultra.ui.util.getCurrentKmi
+import com.sukisu.ultra.ui.util.getSupportedKmis
+import com.sukisu.ultra.ui.util.isAbDevice
+import com.sukisu.ultra.ui.util.isInitBoot
+import com.sukisu.ultra.ui.util.rootAvailable
+import com.sukisu.ultra.getKernelVersion
+
+/**
+ * @author ShirkNeko
+ * @date 2025/5/31.
+ */
+@OptIn(ExperimentalMaterial3Api::class)
+@Destination<RootGraph>
+@Composable
+fun InstallScreen(navigator: DestinationsNavigator) {
+    var installMethod by remember { mutableStateOf<InstallMethod?>(null) }
+    var lkmSelection by remember { mutableStateOf<LkmSelection>(LkmSelection.KmiNone) }
+    val context = LocalContext.current
+    var showRebootDialog by remember { mutableStateOf(false) }
+    var showSlotSelectionDialog by remember { mutableStateOf(false) }
+    var tempKernelUri by remember { mutableStateOf<Uri?>(null) }
+    val kernelVersion = getKernelVersion()
+    val isGKI = kernelVersion.isGKI()
+    val isAbDevice = isAbDevice()
+    val summary = stringResource(R.string.horizon_kernel_summary)
+
+    if (showRebootDialog) {
+        RebootDialog(
+            show = true,
+            onDismiss = { showRebootDialog = false },
+            onConfirm = {
+                showRebootDialog = false
+                try {
+                    val process = Runtime.getRuntime().exec("su")
+                    process.outputStream.bufferedWriter().use { writer ->
+                        writer.write("svc power reboot\n")
+                        writer.write("exit\n")
+                    }
+                } catch (_: Exception) {
+                    Toast.makeText(context, R.string.failed_reboot, Toast.LENGTH_SHORT).show()
+                }
+            }
+        )
+    }
+
+    val onInstall = {
+        installMethod?.let { method ->
+            when (method) {
+                is InstallMethod.HorizonKernel -> {
+                    method.uri?.let { uri ->
+                        navigator.navigate(
+                            KernelFlashScreenDestination(
+                                kernelUri = uri,
+                                selectedSlot = method.slot
+                            )
+                        )
+                    }
+                }
+                else -> {
+                    val flashIt = FlashIt.FlashBoot(
+                        boot = if (method is InstallMethod.SelectFile) method.uri else null,
+                        lkm = lkmSelection,
+                        ota = method is InstallMethod.DirectInstallToInactiveSlot
+                    )
+                    navigator.navigate(FlashScreenDestination(flashIt))
+                }
+            }
+        }
+        Unit
+    }
+
+    // 槽位选择
+    SlotSelectionDialog(
+        show = showSlotSelectionDialog && isAbDevice,
+        onDismiss = { showSlotSelectionDialog = false },
+        onSlotSelected = { slot ->
+            showSlotSelectionDialog = false
+            val horizonMethod = InstallMethod.HorizonKernel(
+                uri = tempKernelUri,
+                slot = slot,
+                summary = summary
+            )
+            installMethod = horizonMethod
+        }
+    )
+
+    val currentKmi by produceState(initialValue = "") {
+        value = getCurrentKmi()
+    }
+
+    val selectKmiDialog = rememberSelectKmiDialog { kmi ->
+        kmi?.let {
+            lkmSelection = LkmSelection.KmiString(it)
+            onInstall()
+        }
+    }
+
+    val onClickNext = {
+        if (isGKI && lkmSelection == LkmSelection.KmiNone && currentKmi.isBlank()) {
+            selectKmiDialog.show()
+        } else {
+            onInstall()
+        }
+    }
+
+    val selectLkmLauncher = rememberLauncherForActivityResult(
+        contract = ActivityResultContracts.StartActivityForResult()
+    ) {
+        if (it.resultCode == Activity.RESULT_OK) {
+            it.data?.data?.let { uri ->
+                lkmSelection = LkmSelection.LkmUri(uri)
+            }
+        }
+    }
+
+    val onLkmUpload = {
+        selectLkmLauncher.launch(Intent(Intent.ACTION_GET_CONTENT).apply {
+            type = "application/octet-stream"
+        })
+    }
+
+    val scrollBehavior = TopAppBarDefaults.pinnedScrollBehavior(rememberTopAppBarState())
+
+    Scaffold(
+        topBar = {
+            TopBar(
+                onBack = { navigator.popBackStack() },
+                onLkmUpload = onLkmUpload,
+                scrollBehavior = scrollBehavior
+            )
+        },
+        contentWindowInsets = WindowInsets.safeDrawing.only(
+            WindowInsetsSides.Top + WindowInsetsSides.Horizontal
+        )
+    ) { innerPadding ->
+        Column(
+            modifier = Modifier
+                .padding(innerPadding)
+                .nestedScroll(scrollBehavior.nestedScrollConnection)
+                .verticalScroll(rememberScrollState())
+                .padding(top = 12.dp)
+        ) {
+            SelectInstallMethod(
+                isGKI = isGKI,
+                isAbDevice = isAbDevice,
+                onSelected = { method ->
+                    if (method is InstallMethod.HorizonKernel && method.uri != null) {
+                        if (isAbDevice) {
+                            tempKernelUri = method.uri
+                            showSlotSelectionDialog = true
+                        } else {
+                            installMethod = method
+                        }
+                    } else {
+                        installMethod = method
+                    }
+                }
+            )
+
+            Column(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(16.dp)
+            ) {
+                (lkmSelection as? LkmSelection.LkmUri)?.let {
+                    ElevatedCard(
+                        colors = getCardColors(MaterialTheme.colorScheme.surfaceVariant),
+                        elevation = CardDefaults.cardElevation(defaultElevation = cardElevation),
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .padding(bottom = 12.dp)
+                            .clip(MaterialTheme.shapes.medium)
+                            .shadow(
+                                elevation = cardElevation,
+                                shape = MaterialTheme.shapes.medium,
+                                spotColor = MaterialTheme.colorScheme.primary.copy(alpha = 0.1f)
+                            )
+                    ) {
+                        Text(
+                            text = stringResource(
+                                id = R.string.selected_lkm,
+                                it.uri.lastPathSegment ?: "(file)"
+                            ),
+                            style = MaterialTheme.typography.bodyMedium,
+                            modifier = Modifier.padding(16.dp)
+                        )
+                    }
+                }
+
+                (installMethod as? InstallMethod.HorizonKernel)?.let { method ->
+                    if (method.slot != null) {
+                        ElevatedCard(
+                            colors = getCardColors(MaterialTheme.colorScheme.surfaceVariant),
+                            elevation = CardDefaults.cardElevation(defaultElevation = cardElevation),
+                            modifier = Modifier
+                                .fillMaxWidth()
+                                .padding(bottom = 12.dp)
+                                .clip(MaterialTheme.shapes.medium)
+                                .shadow(
+                                    elevation = cardElevation,
+                                    shape = MaterialTheme.shapes.medium,
+                                    spotColor = MaterialTheme.colorScheme.primary.copy(alpha = 0.1f)
+                                )
+                        ) {
+                            Text(
+                                text = stringResource(
+                                    id = R.string.selected_slot,
+                                    if (method.slot == "a") stringResource(id = R.string.slot_a)
+                                    else stringResource(id = R.string.slot_b)
+                                ),
+                                style = MaterialTheme.typography.bodyMedium,
+                                modifier = Modifier.padding(16.dp)
+                            )
+                        }
+                    }
+                }
+
+                Button(
+                    modifier = Modifier.fillMaxWidth(),
+                    enabled = installMethod != null,
+                    onClick = onClickNext,
+                    shape = MaterialTheme.shapes.medium,
+                    colors = ButtonDefaults.buttonColors(
+                        containerColor = MaterialTheme.colorScheme.primary,
+                        contentColor = MaterialTheme.colorScheme.onPrimary,
+                        disabledContainerColor = MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.6f),
+                        disabledContentColor = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.6f)
+                    )
+                ) {
+                    Text(
+                        stringResource(id = R.string.install_next),
+                        style = MaterialTheme.typography.bodyMedium
+                    )
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun RebootDialog(
+    show: Boolean,
+    onDismiss: () -> Unit,
+    onConfirm: () -> Unit
+) {
+    if (show) {
+        AlertDialog(
+            onDismissRequest = onDismiss,
+            title = { Text(stringResource(id = R.string.reboot_complete_title)) },
+            text = { Text(stringResource(id = R.string.reboot_complete_msg)) },
+            confirmButton = {
+                TextButton(onClick = onConfirm) {
+                    Text(stringResource(id = R.string.yes))
+                }
+            },
+            dismissButton = {
+                TextButton(onClick = onDismiss) {
+                    Text(stringResource(id = R.string.no))
+                }
+            }
+        )
+    }
+}
+
+sealed class InstallMethod {
+    data class SelectFile(
+        val uri: Uri? = null,
+        @StringRes override val label: Int = R.string.select_file,
+        override val summary: String?
+    ) : InstallMethod()
+
+    data object DirectInstall : InstallMethod() {
+        override val label: Int
+            get() = R.string.direct_install
+    }
+
+    data object DirectInstallToInactiveSlot : InstallMethod() {
+        override val label: Int
+            get() = R.string.install_inactive_slot
+    }
+
+    data class HorizonKernel(
+        val uri: Uri? = null,
+        val slot: String? = null,
+        @StringRes override val label: Int = R.string.horizon_kernel,
+        override val summary: String? = null
+    ) : InstallMethod()
+
+    abstract val label: Int
+    open val summary: String? = null
+}
+
+@Composable
+private fun SelectInstallMethod(
+    isGKI: Boolean = false,
+    isAbDevice: Boolean = false,
+    onSelected: (InstallMethod) -> Unit = {}
+) {
+    val rootAvailable = rootAvailable()
+    val isAbDevice = isAbDevice()
+    val horizonKernelSummary = stringResource(R.string.horizon_kernel_summary)
+    val selectFileTip = stringResource(
+        id = R.string.select_file_tip,
+        if (isInitBoot()) "init_boot" else "boot"
+    )
+
+    val radioOptions = mutableListOf<InstallMethod>(
+        InstallMethod.SelectFile(summary = selectFileTip)
+    )
+
+    if (rootAvailable) {
+        radioOptions.add(InstallMethod.DirectInstall)
+        if (isAbDevice) {
+            radioOptions.add(InstallMethod.DirectInstallToInactiveSlot)
+        }
+        radioOptions.add(InstallMethod.HorizonKernel(summary = horizonKernelSummary))
+    }
+
+    var selectedOption by remember { mutableStateOf<InstallMethod?>(null) }
+    var currentSelectingMethod by remember { mutableStateOf<InstallMethod?>(null) }
+
+    val selectImageLauncher = rememberLauncherForActivityResult(
+        contract = ActivityResultContracts.StartActivityForResult()
+    ) {
+        if (it.resultCode == Activity.RESULT_OK) {
+            it.data?.data?.let { uri ->
+                val option = when (currentSelectingMethod) {
+                    is InstallMethod.SelectFile -> InstallMethod.SelectFile(
+                        uri,
+                        summary = selectFileTip
+                    )
+
+                    is InstallMethod.HorizonKernel -> InstallMethod.HorizonKernel(
+                        uri,
+                        summary = horizonKernelSummary
+                    )
+
+                    else -> null
+                }
+                option?.let {
+                    selectedOption = it
+                    onSelected(it)
+                }
+            }
+        }
+    }
+
+    val confirmDialog = rememberConfirmDialog(
+        onConfirm = {
+            selectedOption = InstallMethod.DirectInstallToInactiveSlot
+            onSelected(InstallMethod.DirectInstallToInactiveSlot)
+        },
+        onDismiss = null
+    )
+
+    val dialogTitle = stringResource(id = android.R.string.dialog_alert_title)
+    val dialogContent = stringResource(id = R.string.install_inactive_slot_warning)
+
+    val onClick = { option: InstallMethod ->
+        currentSelectingMethod = option
+        when (option) {
+            is InstallMethod.SelectFile, is InstallMethod.HorizonKernel -> {
+                selectImageLauncher.launch(Intent(Intent.ACTION_GET_CONTENT).apply {
+                    type = "application/*"
+                    putExtra(
+                        Intent.EXTRA_MIME_TYPES,
+                        arrayOf("application/octet-stream", "application/zip")
+                    )
+                })
+            }
+
+            is InstallMethod.DirectInstall -> {
+                selectedOption = option
+                onSelected(option)
+            }
+
+            is InstallMethod.DirectInstallToInactiveSlot -> {
+                confirmDialog.showConfirm(dialogTitle, dialogContent)
+            }
+        }
+    }
+
+    var LKMExpanded by remember { mutableStateOf(false) }
+    var GKIExpanded by remember { mutableStateOf(false) }
+
+    Column(
+        modifier = Modifier.padding(horizontal = 16.dp)
+    ) {
+        // LKM 安装/修补
+        if (isGKI) {
+            ElevatedCard(
+                colors = getCardColors(MaterialTheme.colorScheme.surfaceVariant),
+                elevation = CardDefaults.cardElevation(defaultElevation = cardElevation),
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(bottom = 12.dp)
+                    .clip(MaterialTheme.shapes.large)
+                    .shadow(
+                        elevation = cardElevation,
+                        shape = MaterialTheme.shapes.large,
+                        spotColor = MaterialTheme.colorScheme.primary.copy(alpha = 0.1f)
+                    )
+            ) {
+                ListItem(
+                    leadingContent = {
+                        Icon(
+                            Icons.Filled.AutoFixHigh,
+                            contentDescription = null,
+                            tint = MaterialTheme.colorScheme.primary
+                        )
+                    },
+                    headlineContent = {
+                        Text(
+                            stringResource(R.string.Lkm_install_methods),
+                            style = MaterialTheme.typography.titleMedium
+                        )
+                    },
+                    modifier = Modifier.clickable {
+                        LKMExpanded = !LKMExpanded
+                    }
+                )
+
+                AnimatedVisibility(
+                    visible = LKMExpanded,
+                    enter = fadeIn() + expandVertically(),
+                    exit = shrinkVertically() + fadeOut()
+                ) {
+                    Column(
+                        modifier = Modifier.padding(
+                            start = 16.dp,
+                            end = 16.dp,
+                            bottom = 16.dp
+                        )
+                    ) {
+                        radioOptions.take(3).forEach { option ->
+                            val interactionSource = remember { MutableInteractionSource() }
+                            Surface(
+                                color = if (option.javaClass == selectedOption?.javaClass)
+                                    MaterialTheme.colorScheme.secondaryContainer.copy(alpha = cardAlpha)
+                                else
+                                    MaterialTheme.colorScheme.surfaceContainerHighest.copy(alpha = cardAlpha),
+                                shape = MaterialTheme.shapes.medium,
+                                modifier = Modifier
+                                    .fillMaxWidth()
+                                    .padding(vertical = 4.dp)
+                                    .clip(MaterialTheme.shapes.medium)
+                            ) {
+                                Row(
+                                    verticalAlignment = Alignment.CenterVertically,
+                                    modifier = Modifier
+                                        .fillMaxWidth()
+                                        .toggleable(
+                                            value = option.javaClass == selectedOption?.javaClass,
+                                            onValueChange = { onClick(option) },
+                                            role = Role.RadioButton,
+                                            indication = LocalIndication.current,
+                                            interactionSource = interactionSource
+                                        )
+                                        .padding(vertical = 8.dp, horizontal = 12.dp)
+                                ) {
+                                    RadioButton(
+                                        selected = option.javaClass == selectedOption?.javaClass,
+                                        onClick = null,
+                                        interactionSource = interactionSource,
+                                        colors = RadioButtonDefaults.colors(
+                                            selectedColor = MaterialTheme.colorScheme.primary,
+                                            unselectedColor = MaterialTheme.colorScheme.onSurfaceVariant
+                                        )
+                                    )
+                                    Column(
+                                        modifier = Modifier
+                                            .padding(start = 10.dp)
+                                            .weight(1f)
+                                    ) {
+                                        Text(
+                                            text = stringResource(id = option.label),
+                                            style = MaterialTheme.typography.bodyLarge
+                                        )
+                                        option.summary?.let {
+                                            Text(
+                                                text = it,
+                                                style = MaterialTheme.typography.bodySmall,
+                                                color = MaterialTheme.colorScheme.onSurfaceVariant
+                                            )
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        // anykernel3 刷写
+        if (rootAvailable) {
+            ElevatedCard(
+                colors = getCardColors(MaterialTheme.colorScheme.surfaceVariant),
+                elevation = CardDefaults.cardElevation(defaultElevation = cardElevation),
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(bottom = 12.dp)
+                    .clip(MaterialTheme.shapes.large)
+                    .shadow(
+                        elevation = cardElevation,
+                        shape = MaterialTheme.shapes.large,
+                        spotColor = MaterialTheme.colorScheme.primary.copy(alpha = 0.1f)
+                    )
+            ) {
+                ListItem(
+                    leadingContent = {
+                        Icon(
+                            Icons.Filled.FileUpload,
+                            contentDescription = null,
+                            tint = MaterialTheme.colorScheme.primary
+                        )
+                    },
+                    headlineContent = {
+                        Text(
+                            stringResource(R.string.GKI_install_methods),
+                            style = MaterialTheme.typography.titleMedium
+                        )
+                    },
+                    modifier = Modifier.clickable {
+                        GKIExpanded = !GKIExpanded
+                    }
+                )
+
+                AnimatedVisibility(
+                    visible = GKIExpanded,
+                    enter = fadeIn() + expandVertically(),
+                    exit = shrinkVertically() + fadeOut()
+                ) {
+                    Column(
+                        modifier = Modifier.padding(
+                            start = 16.dp,
+                            end = 16.dp,
+                            bottom = 16.dp
+                        )
+                    ) {
+                        radioOptions.filterIsInstance<InstallMethod.HorizonKernel>().forEach { option ->
+                            val interactionSource = remember { MutableInteractionSource() }
+                            Surface(
+                                color = if (option.javaClass == selectedOption?.javaClass)
+                                    MaterialTheme.colorScheme.secondaryContainer.copy(alpha = cardAlpha)
+                                else
+                                    MaterialTheme.colorScheme.surfaceContainerHighest.copy(alpha = cardAlpha),
+                                shape = MaterialTheme.shapes.medium,
+                                modifier = Modifier
+                                    .fillMaxWidth()
+                                    .padding(vertical = 4.dp)
+                                    .clip(MaterialTheme.shapes.medium)
+                            ) {
+                                Row(
+                                    verticalAlignment = Alignment.CenterVertically,
+                                    modifier = Modifier
+                                        .fillMaxWidth()
+                                        .toggleable(
+                                            value = option.javaClass == selectedOption?.javaClass,
+                                            onValueChange = { onClick(option) },
+                                            role = Role.RadioButton,
+                                            indication = LocalIndication.current,
+                                            interactionSource = interactionSource
+                                        )
+                                        .padding(vertical = 8.dp, horizontal = 12.dp)
+                                ) {
+                                    RadioButton(
+                                        selected = option.javaClass == selectedOption?.javaClass,
+                                        onClick = null,
+                                        interactionSource = interactionSource,
+                                        colors = RadioButtonDefaults.colors(
+                                            selectedColor = MaterialTheme.colorScheme.primary,
+                                            unselectedColor = MaterialTheme.colorScheme.onSurfaceVariant
+                                        )
+                                    )
+                                    Column(
+                                        modifier = Modifier
+                                            .padding(start = 10.dp)
+                                            .weight(1f)
+                                    ) {
+                                        Text(
+                                            text = stringResource(id = option.label),
+                                            style = MaterialTheme.typography.bodyLarge
+                                        )
+                                        option.summary?.let {
+                                            Text(
+                                                text = it,
+                                                style = MaterialTheme.typography.bodySmall,
+                                                color = MaterialTheme.colorScheme.onSurfaceVariant
+                                            )
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun rememberSelectKmiDialog(onSelected: (String?) -> Unit): DialogHandle {
+    return rememberCustomDialog { dismiss ->
+        val supportedKmi by produceState(initialValue = emptyList<String>()) {
+            value = getSupportedKmis()
+        }
+        val options = supportedKmi.map { value ->
+            ListOption(
+                titleText = value
+            )
+        }
+
+        var selection by remember { mutableStateOf<String?>(null) }
+        val backgroundColor = MaterialTheme.colorScheme.surfaceContainerHighest
+
+        MaterialTheme(
+            colorScheme = MaterialTheme.colorScheme.copy(
+                surface = backgroundColor
+            )
+        ) {
+            ListDialog(state = rememberUseCaseState(visible = true, onFinishedRequest = {
+                onSelected(selection)
+            }, onCloseRequest = {
+                dismiss()
+            }), header = Header.Default(
+                title = stringResource(R.string.select_kmi),
+            ), selection = ListSelection.Single(
+                showRadioButtons = true,
+                options = options,
+            ) { _, option ->
+                selection = option.titleText
+            })
+        }
+    }
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun TopBar(
+    onBack: () -> Unit = {},
+    onLkmUpload: () -> Unit = {},
+    scrollBehavior: TopAppBarScrollBehavior? = null
+) {
+    val cardColor = MaterialTheme.colorScheme.surfaceContainerLow
+    val cardAlpha = cardAlpha
+
+    TopAppBar(
+        title = {
+            Text(
+                stringResource(R.string.install),
+                style = MaterialTheme.typography.titleLarge
+            )
+        },
+        colors = TopAppBarDefaults.topAppBarColors(
+            containerColor = cardColor.copy(alpha = cardAlpha),
+            scrolledContainerColor = cardColor.copy(alpha = cardAlpha)
+        ),
+        navigationIcon = {
+            IconButton(onClick = onBack) {
+                Icon(
+                    Icons.AutoMirrored.Filled.ArrowBack,
+                    contentDescription = stringResource(R.string.back)
+                )
+            }
+        },
+        windowInsets = WindowInsets.safeDrawing.only(
+            WindowInsetsSides.Top + WindowInsetsSides.Horizontal
+        ),
+        scrollBehavior = scrollBehavior
+    )
+}
+
+@Preview
+@Composable
+fun SelectInstallPreview() {
+    InstallScreen(EmptyDestinationsNavigator)
+}

manager/app/src/main/java/com/sukisu/ultra/ui/screen/KernelFlash.kt

@@ -0,0 +1,411 @@
+package com.sukisu.ultra.ui.screen
+
+import android.net.Uri
+import android.os.Environment
+import androidx.activity.compose.BackHandler
+import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.ArrowBack
+import androidx.compose.material.icons.filled.CheckCircle
+import androidx.compose.material.icons.filled.Error
+import androidx.compose.material.icons.filled.Refresh
+import androidx.compose.material.icons.filled.Save
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.input.nestedscroll.nestedScroll
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import com.ramcosta.composedestinations.annotation.Destination
+import com.ramcosta.composedestinations.annotation.RootGraph
+import com.ramcosta.composedestinations.navigation.DestinationsNavigator
+import com.sukisu.ultra.R
+import com.sukisu.ultra.flash.HorizonKernelState
+import com.sukisu.ultra.flash.HorizonKernelWorker
+import com.sukisu.ultra.ui.component.KeyEventBlocker
+import com.sukisu.ultra.ui.util.*
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import java.io.File
+import java.text.SimpleDateFormat
+import java.util.*
+import androidx.compose.ui.input.key.Key
+import androidx.compose.ui.input.key.key
+import com.sukisu.ultra.ui.theme.CardConfig
+
+/**
+ * @author ShirkNeko
+ * @date 2025/5/31.
+ */
+private object KernelFlashStateHolder {
+    var currentState: HorizonKernelState? = null
+    var currentUri: Uri? = null
+    var currentSlot: String? = null
+    var isFlashing = false
+}
+
+/**
+ * Kernel刷写界面
+ */
+@OptIn(ExperimentalMaterial3Api::class)
+@Destination<RootGraph>
+@Composable
+fun KernelFlashScreen(
+    navigator: DestinationsNavigator,
+    kernelUri: Uri,
+    selectedSlot: String? = null
+) {
+    val context = LocalContext.current
+    val scrollState = rememberScrollState()
+    val scrollBehavior = TopAppBarDefaults.pinnedScrollBehavior(rememberTopAppBarState())
+    val snackBarHost = LocalSnackbarHost.current
+    val scope = rememberCoroutineScope()
+    var logText by rememberSaveable { mutableStateOf("") }
+    var showFloatAction by rememberSaveable { mutableStateOf(false) }
+    val logContent = rememberSaveable { StringBuilder() }
+    val horizonKernelState = remember {
+        if (KernelFlashStateHolder.currentState != null &&
+            KernelFlashStateHolder.currentUri == kernelUri &&
+            KernelFlashStateHolder.currentSlot == selectedSlot) {
+            KernelFlashStateHolder.currentState!!
+        } else {
+            HorizonKernelState().also {
+                KernelFlashStateHolder.currentState = it
+                KernelFlashStateHolder.currentUri = kernelUri
+                KernelFlashStateHolder.currentSlot = selectedSlot
+                KernelFlashStateHolder.isFlashing = false
+            }
+        }
+    }
+
+    val flashState by horizonKernelState.state.collectAsState()
+    val logSavedString = stringResource(R.string.log_saved)
+
+    val onFlashComplete = {
+        showFloatAction = true
+        KernelFlashStateHolder.isFlashing = false
+    }
+
+    // 开始刷写
+    LaunchedEffect(Unit) {
+        if (!KernelFlashStateHolder.isFlashing && !flashState.isCompleted && flashState.error.isEmpty()) {
+            withContext(Dispatchers.IO) {
+                KernelFlashStateHolder.isFlashing = true
+                val worker = HorizonKernelWorker(
+                    context = context,
+                    state = horizonKernelState,
+                    slot = selectedSlot
+                )
+                worker.uri = kernelUri
+                worker.setOnFlashCompleteListener(onFlashComplete)
+                worker.start()
+
+                // 监听日志更新
+                while (!flashState.isCompleted && flashState.error.isEmpty()) {
+                    if (flashState.logs.isNotEmpty()) {
+                        logText = flashState.logs.joinToString("\n")
+                        logContent.clear()
+                        logContent.append(logText)
+                    }
+                    kotlinx.coroutines.delay(100)
+                }
+
+                if (flashState.error.isNotEmpty()) {
+                    logText += "\n${flashState.error}\n"
+                    logContent.append("\n${flashState.error}\n")
+                    KernelFlashStateHolder.isFlashing = false
+                } else if (flashState.isCompleted) {
+                    logText += "\n${context.getString(R.string.horizon_flash_complete)}\n\n\n"
+                    logContent.append("\n${context.getString(R.string.horizon_flash_complete)}\n\n\n")
+                }
+            }
+        } else {
+            logText = flashState.logs.joinToString("\n")
+            if (flashState.error.isNotEmpty()) {
+                logText += "\n${flashState.error}\n"
+            } else if (flashState.isCompleted) {
+                logText += "\n${context.getString(R.string.horizon_flash_complete)}\n\n\n"
+                showFloatAction = true
+            }
+        }
+    }
+
+    val onBack: () -> Unit = {
+        if (!flashState.isFlashing || flashState.isCompleted || flashState.error.isNotEmpty()) {
+            // 清理全局状态
+            if (flashState.isCompleted || flashState.error.isNotEmpty()) {
+                KernelFlashStateHolder.currentState = null
+                KernelFlashStateHolder.currentUri = null
+                KernelFlashStateHolder.currentSlot = null
+                KernelFlashStateHolder.isFlashing = false
+            }
+            navigator.popBackStack()
+        }
+    }
+
+    BackHandler(enabled = true) {
+        onBack()
+    }
+
+    Scaffold(
+        topBar = {
+            TopBar(
+                flashState = flashState,
+                onBack = onBack,
+                onSave = {
+                    scope.launch {
+                        val format = SimpleDateFormat("yyyy-MM-dd-HH-mm-ss", Locale.getDefault())
+                        val date = format.format(Date())
+                        val file = File(
+                            Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS),
+                            "KernelSU_kernel_flash_log_${date}.log"
+                        )
+                        file.writeText(logContent.toString())
+                        snackBarHost.showSnackbar(logSavedString.format(file.absolutePath))
+                    }
+                },
+                scrollBehavior = scrollBehavior
+            )
+        },
+        floatingActionButton = {
+            if (showFloatAction) {
+                ExtendedFloatingActionButton(
+                    onClick = {
+                        scope.launch {
+                            withContext(Dispatchers.IO) {
+                                reboot()
+                            }
+                        }
+                    },
+                    icon = {
+                        Icon(
+                            Icons.Filled.Refresh,
+                            contentDescription = stringResource(id = R.string.reboot)
+                        )
+                    },
+                    text = {
+                        Text(text = stringResource(id = R.string.reboot))
+                    },
+                    containerColor = MaterialTheme.colorScheme.secondaryContainer,
+                    contentColor = MaterialTheme.colorScheme.onSecondaryContainer,
+                    expanded = true
+                )
+            }
+        },
+        snackbarHost = { SnackbarHost(hostState = snackBarHost) },
+        contentWindowInsets = WindowInsets.safeDrawing.only(WindowInsetsSides.Top + WindowInsetsSides.Horizontal),
+        containerColor = MaterialTheme.colorScheme.background
+    ) { innerPadding ->
+        KeyEventBlocker {
+            it.key == Key.VolumeDown || it.key == Key.VolumeUp
+        }
+
+        Column(
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(innerPadding)
+                .nestedScroll(scrollBehavior.nestedScrollConnection),
+        ) {
+            FlashProgressIndicator(flashState)
+            Box(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .weight(1f)
+                    .verticalScroll(scrollState)
+            ) {
+                LaunchedEffect(logText) {
+                    scrollState.animateScrollTo(scrollState.maxValue)
+                }
+                Text(
+                    modifier = Modifier.padding(16.dp),
+                    text = logText,
+                    style = MaterialTheme.typography.bodyMedium,
+                    fontFamily = FontFamily.Monospace,
+                    color = MaterialTheme.colorScheme.onSurface
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun FlashProgressIndicator(flashState: com.sukisu.ultra.flash.FlashState) {
+    val progressColor = when {
+        flashState.error.isNotEmpty() -> MaterialTheme.colorScheme.error
+        flashState.isCompleted -> MaterialTheme.colorScheme.tertiary
+        else -> MaterialTheme.colorScheme.primary
+    }
+
+    val progress = animateFloatAsState(
+        targetValue = flashState.progress,
+        label = "FlashProgress"
+    )
+
+    Card(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(16.dp),
+        colors = CardDefaults.cardColors(
+            containerColor = MaterialTheme.colorScheme.surfaceVariant
+        )
+    ) {
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(16.dp)
+        ) {
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                verticalAlignment = Alignment.CenterVertically,
+                horizontalArrangement = Arrangement.SpaceBetween
+            ) {
+                Text(
+                    text = when {
+                        flashState.error.isNotEmpty() -> stringResource(R.string.flash_failed)
+                        flashState.isCompleted -> stringResource(R.string.flash_success)
+                        else -> stringResource(R.string.flashing)
+                    },
+                    style = MaterialTheme.typography.titleMedium,
+                    fontWeight = FontWeight.Bold,
+                    color = progressColor
+                )
+
+                when {
+                    flashState.error.isNotEmpty() -> {
+                        Icon(
+                            imageVector = Icons.Default.Error,
+                            contentDescription = null,
+                            tint = MaterialTheme.colorScheme.error
+                        )
+                    }
+                    flashState.isCompleted -> {
+                        Icon(
+                            imageVector = Icons.Default.CheckCircle,
+                            contentDescription = null,
+                            tint = MaterialTheme.colorScheme.tertiary
+                        )
+                    }
+                }
+            }
+
+            Spacer(modifier = Modifier.height(8.dp))
+
+            if (flashState.currentStep.isNotEmpty()) {
+                Text(
+                    text = flashState.currentStep,
+                    style = MaterialTheme.typography.bodyMedium,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant
+                )
+
+                Spacer(modifier = Modifier.height(8.dp))
+            }
+
+            LinearProgressIndicator(
+                progress = { progress.value },
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .height(8.dp),
+                color = progressColor,
+                trackColor = MaterialTheme.colorScheme.surfaceVariant
+            )
+
+            if (flashState.error.isNotEmpty()) {
+                Spacer(modifier = Modifier.height(8.dp))
+
+                Row(
+                    verticalAlignment = Alignment.CenterVertically
+                ) {
+                    Icon(
+                        imageVector = Icons.Default.Error,
+                        contentDescription = null,
+                        tint = MaterialTheme.colorScheme.error,
+                        modifier = Modifier.size(16.dp)
+                    )
+                }
+
+                Spacer(modifier = Modifier.height(4.dp))
+
+                Text(
+                    text = flashState.error,
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.error,
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .background(
+                            MaterialTheme.colorScheme.errorContainer.copy(alpha = 0.3f),
+                            shape = MaterialTheme.shapes.small
+                        )
+                        .padding(8.dp)
+                )
+            }
+        }
+    }
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun TopBar(
+    flashState: com.sukisu.ultra.flash.FlashState,
+    onBack: () -> Unit,
+    onSave: () -> Unit = {},
+    scrollBehavior: TopAppBarScrollBehavior? = null
+) {
+    val statusColor = when {
+        flashState.error.isNotEmpty() -> MaterialTheme.colorScheme.error
+        flashState.isCompleted -> MaterialTheme.colorScheme.tertiary
+        else -> MaterialTheme.colorScheme.primary
+    }
+
+    val cardColor = MaterialTheme.colorScheme.surfaceContainerLow
+    val cardAlpha = CardConfig.cardAlpha
+
+    TopAppBar(
+        title = {
+            Text(
+                text = stringResource(
+                    when {
+                        flashState.error.isNotEmpty() -> R.string.flash_failed
+                        flashState.isCompleted -> R.string.flash_success
+                        else -> R.string.kernel_flashing
+                    }
+                ),
+                style = MaterialTheme.typography.titleLarge,
+                color = statusColor
+            )
+        },
+        navigationIcon = {
+            IconButton(onClick = onBack) {
+                Icon(
+                    imageVector = Icons.AutoMirrored.Filled.ArrowBack,
+                    contentDescription = null,
+                    tint = MaterialTheme.colorScheme.onSurface
+                )
+            }
+        },
+        colors = TopAppBarDefaults.topAppBarColors(
+            containerColor = cardColor.copy(alpha = cardAlpha),
+            scrolledContainerColor = cardColor.copy(alpha = cardAlpha)
+        ),
+        actions = {
+            IconButton(onClick = onSave) {
+                Icon(
+                    imageVector = Icons.Filled.Save,
+                    contentDescription = stringResource(id = R.string.save_log),
+                    tint = MaterialTheme.colorScheme.onSurfaceVariant
+                )
+            }
+        },
+        windowInsets = WindowInsets.safeDrawing.only(WindowInsetsSides.Top + WindowInsetsSides.Horizontal),
+        scrollBehavior = scrollBehavior
+    )
+}

manager/app/src/main/java/com/sukisu/ultra/ui/screen/Kpm.kt

@@ -0,0 +1,783 @@
+package com.sukisu.ultra.ui.screen
+
+import android.content.Context
+import android.content.Intent
+import android.util.Log
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.*
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.draw.shadow
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.viewmodel.compose.viewModel
+import com.ramcosta.composedestinations.annotation.Destination
+import com.ramcosta.composedestinations.annotation.RootGraph
+import com.ramcosta.composedestinations.navigation.DestinationsNavigator
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import com.sukisu.ultra.ui.component.*
+import com.sukisu.ultra.ui.theme.*
+import com.sukisu.ultra.ui.viewmodel.KpmViewModel
+import com.sukisu.ultra.ui.util.*
+import java.io.File
+import androidx.core.content.edit
+import com.sukisu.ultra.R
+import java.io.BufferedReader
+import java.io.FileInputStream
+import java.io.InputStreamReader
+import java.net.*
+import android.app.Activity
+import com.sukisu.ultra.ui.theme.CardConfig.cardElevation
+
+/**
+ * KPM 管理界面
+ * 以下内核模块功能由KernelPatch开发，经过修改后加入SukiSU Ultra的内核模块功能
+ * 开发者：ShirkNeko, Liaokong
+ */
+@OptIn(ExperimentalMaterial3Api::class)
+@Destination<RootGraph>
+@Composable
+fun KpmScreen(
+    navigator: DestinationsNavigator,
+    viewModel: KpmViewModel = viewModel()
+) {
+    val context = LocalContext.current
+    val scope = rememberCoroutineScope()
+    val snackBarHost = remember { SnackbarHostState() }
+    val confirmDialog = rememberConfirmDialog()
+
+    val moduleConfirmContentMap = viewModel.moduleList.associate { module ->
+        val moduleFileName = module.id
+        module.id to stringResource(R.string.confirm_uninstall_content, moduleFileName)
+    }
+
+    val scrollBehavior = TopAppBarDefaults.pinnedScrollBehavior(rememberTopAppBarState())
+
+    val kpmInstallSuccess = stringResource(R.string.kpm_install_success)
+    val kpmInstallFailed = stringResource(R.string.kpm_install_failed)
+    val cancel = stringResource(R.string.cancel)
+    val uninstall = stringResource(R.string.uninstall)
+    val failedToCheckModuleFile = stringResource(R.string.snackbar_failed_to_check_module_file)
+    val kpmUninstallSuccess = stringResource(R.string.kpm_uninstall_success)
+    val kpmUninstallFailed = stringResource(R.string.kpm_uninstall_failed)
+    val kpmInstallMode = stringResource(R.string.kpm_install_mode)
+    val kpmInstallModeLoad = stringResource(R.string.kpm_install_mode_load)
+    val kpmInstallModeEmbed = stringResource(R.string.kpm_install_mode_embed)
+    val invalidFileTypeMessage = stringResource(R.string.invalid_file_type)
+    val confirmTitle = stringResource(R.string.confirm_uninstall_title_with_filename)
+
+    var tempFileForInstall by remember { mutableStateOf<File?>(null) }
+    val installModeDialog = rememberCustomDialog { dismiss ->
+        var moduleName by remember { mutableStateOf<String?>(null) }
+
+        LaunchedEffect(tempFileForInstall) {
+            tempFileForInstall?.let { tempFile ->
+                try {
+                    val command = arrayOf("su", "-c", "strings ${tempFile.absolutePath} | grep 'name='")
+                    val process = Runtime.getRuntime().exec(command)
+                    val inputStream = process.inputStream
+                    val reader = BufferedReader(InputStreamReader(inputStream))
+                    var line: String?
+                    while (reader.readLine().also { line = it } != null) {
+                        if (line!!.startsWith("name=")) {
+                            moduleName = line.substringAfter("name=").trim()
+                            break
+                        }
+                    }
+                    process.waitFor()
+                } catch (e: Exception) {
+                    Log.e("KsuCli", "Failed to get module name: ${e.message}", e)
+                }
+            }
+        }
+
+        AlertDialog(
+            onDismissRequest = {
+                dismiss()
+                tempFileForInstall?.delete()
+                tempFileForInstall = null
+            },
+            title = {
+                Text(
+                    text = kpmInstallMode,
+                    style = MaterialTheme.typography.headlineSmall,
+                    color = MaterialTheme.colorScheme.onSurface
+                )
+            },
+            text = {
+                Column {
+                    moduleName?.let {
+                        Text(
+                            text = stringResource(R.string.kpm_install_mode_description, it),
+                            style = MaterialTheme.typography.bodyMedium,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant
+                        )
+                    }
+                    Spacer(modifier = Modifier.height(16.dp))
+                    Column(
+                        verticalArrangement = Arrangement.spacedBy(8.dp)
+                    ) {
+                        Button(
+                            onClick = {
+                                scope.launch {
+                                    dismiss()
+                                    tempFileForInstall?.let { tempFile ->
+                                        handleModuleInstall(
+                                            tempFile = tempFile,
+                                            isEmbed = false,
+                                            viewModel = viewModel,
+                                            snackBarHost = snackBarHost,
+                                            kpmInstallSuccess = kpmInstallSuccess,
+                                            kpmInstallFailed = kpmInstallFailed
+                                        )
+                                    }
+                                    tempFileForInstall = null
+                                }
+                            },
+                            modifier = Modifier.fillMaxWidth(),
+                            colors = ButtonDefaults.buttonColors(
+                                containerColor = MaterialTheme.colorScheme.primary
+                            )
+                        ) {
+                            Icon(
+                                imageVector = Icons.Filled.Download,
+                                contentDescription = null,
+                                modifier = Modifier.size(18.dp).padding(end = 4.dp)
+                            )
+                            Text(kpmInstallModeLoad)
+                        }
+
+                        Button(
+                            onClick = {
+                                scope.launch {
+                                    dismiss()
+                                    tempFileForInstall?.let { tempFile ->
+                                        handleModuleInstall(
+                                            tempFile = tempFile,
+                                            isEmbed = true,
+                                            viewModel = viewModel,
+                                            snackBarHost = snackBarHost,
+                                            kpmInstallSuccess = kpmInstallSuccess,
+                                            kpmInstallFailed = kpmInstallFailed
+                                        )
+                                    }
+                                    tempFileForInstall = null
+                                }
+                            },
+                            modifier = Modifier.fillMaxWidth(),
+                            colors = ButtonDefaults.buttonColors(
+                                containerColor = MaterialTheme.colorScheme.secondary
+                            )
+                        ) {
+                            Icon(
+                                imageVector = Icons.Filled.Inventory,
+                                contentDescription = null,
+                                modifier = Modifier.size(18.dp).padding(end = 4.dp)
+                            )
+                            Text(kpmInstallModeEmbed)
+                        }
+                    }
+                }
+            },
+            confirmButton = {
+            },
+            dismissButton = {
+                Column(
+                    modifier = Modifier.fillMaxWidth(),
+                    horizontalAlignment = Alignment.CenterHorizontally
+                ) {
+                    Spacer(modifier = Modifier.height(16.dp))
+                    TextButton(
+                        onClick = {
+                            dismiss()
+                            tempFileForInstall?.delete()
+                            tempFileForInstall = null
+                        }
+                    ) {
+                        Text(cancel)
+                    }
+                }
+            },
+            containerColor = MaterialTheme.colorScheme.surfaceContainerHigh,
+            shape = MaterialTheme.shapes.extraLarge
+        )
+    }
+
+    val selectPatchLauncher = rememberLauncherForActivityResult(
+        contract = ActivityResultContracts.StartActivityForResult()
+    ) { result ->
+        if (result.resultCode != Activity.RESULT_OK) return@rememberLauncherForActivityResult
+
+        val uri = result.data?.data ?: return@rememberLauncherForActivityResult
+
+        scope.launch {
+            val fileName = uri.lastPathSegment ?: "unknown.kpm"
+            val encodedFileName = URLEncoder.encode(fileName, "UTF-8")
+            val tempFile = File(context.cacheDir, encodedFileName)
+
+            context.contentResolver.openInputStream(uri)?.use { input ->
+                tempFile.outputStream().use { output ->
+                    input.copyTo(output)
+                }
+            }
+
+            val mimeType = context.contentResolver.getType(uri)
+            val isCorrectMimeType = mimeType == null || mimeType.contains("application/octet-stream")
+
+            if (!isCorrectMimeType) {
+                var shouldShowSnackbar = true
+                try {
+                    val matchCount = checkStringsCommand(tempFile)
+                    val isElf = isElfFile(tempFile)
+
+                    if (matchCount >= 1 || isElf) {
+                        shouldShowSnackbar = false
+                    }
+                } catch (e: Exception) {
+                    Log.e("KsuCli", "Failed to execute checks: ${e.message}", e)
+                }
+                if (shouldShowSnackbar) {
+                    snackBarHost.showSnackbar(
+                        message = invalidFileTypeMessage,
+                        duration = SnackbarDuration.Short
+                    )
+                }
+                tempFile.delete()
+                return@launch
+            }
+            tempFileForInstall = tempFile
+            installModeDialog.show()
+        }
+    }
+
+    LaunchedEffect(Unit) {
+        while(true) {
+            viewModel.fetchModuleList()
+            delay(5000)
+        }
+    }
+
+    val sharedPreferences = context.getSharedPreferences("app_preferences", Context.MODE_PRIVATE)
+    var isNoticeClosed by remember { mutableStateOf(sharedPreferences.getBoolean("is_notice_closed", false)) }
+
+    Scaffold(
+        topBar = {
+            SearchAppBar(
+                title = { Text(stringResource(R.string.kpm_title)) },
+                searchText = viewModel.search,
+                onSearchTextChange = { viewModel.search = it },
+                onClearClick = { viewModel.search = "" },
+                scrollBehavior = scrollBehavior,
+                dropdownContent = {
+                    IconButton(
+                        onClick = { viewModel.fetchModuleList() }
+                    ) {
+                        Icon(
+                            imageVector = Icons.Filled.Refresh,
+                            contentDescription = stringResource(R.string.refresh),
+                        )
+                    }
+                }
+            )
+        },
+        floatingActionButton = {
+            ExtendedFloatingActionButton(
+                onClick = {
+                    selectPatchLauncher.launch(
+                        Intent(Intent.ACTION_GET_CONTENT).apply {
+                            type = "application/octet-stream"
+                        }
+                    )
+                },
+                icon = {
+                    Icon(
+                        imageVector = Icons.Filled.Add,
+                        contentDescription = stringResource(R.string.kpm_install),
+                    )
+                },
+                text = {
+                    Text(
+                        text = stringResource(R.string.kpm_install),
+                        color = MaterialTheme.colorScheme.onPrimaryContainer
+                    )
+                },
+                contentColor = MaterialTheme.colorScheme.onPrimaryContainer,
+                expanded = true,
+            )
+        },
+        snackbarHost = { SnackbarHost(snackBarHost) }
+    ) { padding ->
+        Column(modifier = Modifier.padding(padding)) {
+            if (!isNoticeClosed) {
+                Card(
+                    colors = CardDefaults.cardColors(
+                        containerColor = MaterialTheme.colorScheme.secondaryContainer
+                    ),
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(16.dp)
+                        .clip(MaterialTheme.shapes.medium)
+                ) {
+                    Row(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .padding(16.dp),
+                        horizontalArrangement = Arrangement.SpaceBetween,
+                        verticalAlignment = Alignment.CenterVertically
+                    ) {
+                        Icon(
+                            imageVector = Icons.Filled.Info,
+                            contentDescription = null,
+                            modifier = Modifier
+                                .padding(end = 16.dp)
+                                .size(24.dp)
+                        )
+
+                        Text(
+                            text = stringResource(R.string.kernel_module_notice),
+                            modifier = Modifier.weight(1f),
+                            style = MaterialTheme.typography.bodyMedium,
+                            color = MaterialTheme.colorScheme.onSecondaryContainer
+                        )
+
+                        IconButton(
+                            onClick = {
+                                isNoticeClosed = true
+                                sharedPreferences.edit { putBoolean("is_notice_closed", true) }
+                            },
+                            modifier = Modifier.size(24.dp),
+                            colors = IconButtonDefaults.iconButtonColors(
+                                contentColor = MaterialTheme.colorScheme.onSecondaryContainer
+                            )
+                        ) {
+                            Icon(
+                                imageVector = Icons.Filled.Close,
+                                contentDescription = stringResource(R.string.close_notice)
+                            )
+                        }
+                    }
+                }
+            }
+
+            if (viewModel.moduleList.isEmpty()) {
+                Box(
+                    modifier = Modifier.fillMaxSize(),
+                    contentAlignment = Alignment.Center
+                ) {
+                    Column(
+                        horizontalAlignment = Alignment.CenterHorizontally,
+                        verticalArrangement = Arrangement.Center
+                    ) {
+                        Icon(
+                            imageVector = Icons.Filled.Code,
+                            contentDescription = null,
+                            tint = MaterialTheme.colorScheme.primary.copy(alpha = 0.6f),
+                            modifier = Modifier
+                                .size(96.dp)
+                                .padding(bottom = 16.dp)
+                        )
+                        Text(
+                            stringResource(R.string.kpm_empty),
+                            textAlign = TextAlign.Center,
+                            style = MaterialTheme.typography.bodyLarge,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant
+                        )
+                    }
+                }
+            } else {
+                LazyColumn(
+                    modifier = Modifier.fillMaxSize(),
+                    contentPadding = PaddingValues(horizontal = 16.dp, vertical = 16.dp),
+                    verticalArrangement = Arrangement.spacedBy(16.dp)
+                ) {
+                    items(viewModel.moduleList) { module ->
+                        KpmModuleItem(
+                            module = module,
+                            onUninstall = {
+                                scope.launch {
+                                    val confirmContent = moduleConfirmContentMap[module.id] ?: ""
+                                    handleModuleUninstall(
+                                        module = module,
+                                        viewModel = viewModel,
+                                        snackBarHost = snackBarHost,
+                                        kpmUninstallSuccess = kpmUninstallSuccess,
+                                        kpmUninstallFailed = kpmUninstallFailed,
+                                        failedToCheckModuleFile = failedToCheckModuleFile,
+                                        uninstall = uninstall,
+                                        cancel = cancel,
+                                        confirmDialog = confirmDialog,
+                                        confirmTitle = confirmTitle,
+                                        confirmContent = confirmContent
+                                    )
+                                }
+                            },
+                            onControl = {
+                                viewModel.loadModuleDetail(module.id)
+                            }
+                        )
+                    }
+                }
+            }
+        }
+    }
+}
+
+private suspend fun handleModuleInstall(
+    tempFile: File,
+    isEmbed: Boolean,
+    viewModel: KpmViewModel,
+    snackBarHost: SnackbarHostState,
+    kpmInstallSuccess: String,
+    kpmInstallFailed: String
+) {
+    var moduleId: String? = null
+    try {
+        val command = arrayOf("su", "-c", "strings ${tempFile.absolutePath} | grep 'name='")
+        val process = Runtime.getRuntime().exec(command)
+        val inputStream = process.inputStream
+        val reader = BufferedReader(InputStreamReader(inputStream))
+        var line: String?
+        while (reader.readLine().also { line = it } != null) {
+            if (line!!.startsWith("name=")) {
+                moduleId = line.substringAfter("name=").trim()
+                break
+            }
+        }
+        process.waitFor()
+    } catch (e: Exception) {
+        Log.e("KsuCli", "Failed to get module ID from strings command: ${e.message}", e)
+    }
+
+    if (moduleId == null || moduleId.isEmpty()) {
+        Log.e("KsuCli", "Failed to extract module ID from file: ${tempFile.name}")
+        snackBarHost.showSnackbar(
+            message = kpmInstallFailed,
+            duration = SnackbarDuration.Short
+        )
+        tempFile.delete()
+        return
+    }
+
+    val targetPath = "/data/adb/kpm/$moduleId.kpm"
+
+    try {
+        if (isEmbed) {
+            Runtime.getRuntime().exec(arrayOf("su", "-c", "mkdir -p /data/adb/kpm")).waitFor()
+            Runtime.getRuntime().exec(arrayOf("su", "-c", "cp ${tempFile.absolutePath} $targetPath")).waitFor()
+        }
+
+        val loadResult = loadKpmModule(tempFile.absolutePath)
+        if (loadResult.startsWith("Error")) {
+            Log.e("KsuCli", "Failed to load KPM module: $loadResult")
+            snackBarHost.showSnackbar(
+                message = kpmInstallFailed,
+                duration = SnackbarDuration.Short
+            )
+        } else {
+            viewModel.fetchModuleList()
+            snackBarHost.showSnackbar(
+                message = kpmInstallSuccess,
+                duration = SnackbarDuration.Short
+            )
+        }
+    } catch (e: Exception) {
+        Log.e("KsuCli", "Failed to load KPM module: ${e.message}", e)
+        snackBarHost.showSnackbar(
+            message = kpmInstallFailed,
+            duration = SnackbarDuration.Short
+        )
+    }
+    tempFile.delete()
+}
+
+private suspend fun handleModuleUninstall(
+    module: KpmViewModel.ModuleInfo,
+    viewModel: KpmViewModel,
+    snackBarHost: SnackbarHostState,
+    kpmUninstallSuccess: String,
+    kpmUninstallFailed: String,
+    failedToCheckModuleFile: String,
+    uninstall: String,
+    cancel: String,
+    confirmTitle : String,
+    confirmContent : String,
+    confirmDialog: ConfirmDialogHandle
+) {
+    val moduleFileName = "${module.id}.kpm"
+    val moduleFilePath = "/data/adb/kpm/$moduleFileName"
+
+    val fileExists = try {
+        val result = Runtime.getRuntime().exec(arrayOf("su", "-c", "ls /data/adb/kpm/$moduleFileName")).waitFor() == 0
+        result
+    } catch (e: Exception) {
+        Log.e("KsuCli", "Failed to check module file existence: ${e.message}", e)
+        snackBarHost.showSnackbar(
+            message = failedToCheckModuleFile,
+            duration = SnackbarDuration.Short
+        )
+        false
+    }
+    val confirmResult = confirmDialog.awaitConfirm(
+        title = confirmTitle,
+        content = confirmContent,
+        confirm = uninstall,
+        dismiss = cancel
+    )
+
+    if (confirmResult == ConfirmResult.Confirmed) {
+        try {
+            val unloadResult = unloadKpmModule(module.id)
+            if (unloadResult.startsWith("Error")) {
+                Log.e("KsuCli", "Failed to unload KPM module: $unloadResult")
+                snackBarHost.showSnackbar(
+                    message = kpmUninstallFailed,
+                    duration = SnackbarDuration.Short
+                )
+                return
+            }
+
+            if (fileExists) {
+                Runtime.getRuntime().exec(arrayOf("su", "-c", "rm $moduleFilePath")).waitFor()
+            }
+
+            viewModel.fetchModuleList()
+            snackBarHost.showSnackbar(
+                message = kpmUninstallSuccess,
+                duration = SnackbarDuration.Short
+            )
+        } catch (e: Exception) {
+            Log.e("KsuCli", "Failed to unload KPM module: ${e.message}", e)
+            snackBarHost.showSnackbar(
+                message = kpmUninstallFailed,
+                duration = SnackbarDuration.Short
+            )
+        }
+    }
+}
+
+@Composable
+private fun KpmModuleItem(
+    module: KpmViewModel.ModuleInfo,
+    onUninstall: () -> Unit,
+    onControl: () -> Unit
+) {
+    val viewModel: KpmViewModel = viewModel()
+    val scope = rememberCoroutineScope()
+    val snackBarHost = remember { SnackbarHostState() }
+    val successMessage = stringResource(R.string.kpm_control_success)
+    val failureMessage = stringResource(R.string.kpm_control_failed)
+
+    if (viewModel.showInputDialog && viewModel.selectedModuleId == module.id) {
+        AlertDialog(
+            onDismissRequest = { viewModel.hideInputDialog() },
+            title = {
+                Text(
+                    text = stringResource(R.string.kpm_control),
+                    style = MaterialTheme.typography.headlineSmall,
+                    color = MaterialTheme.colorScheme.onSurface
+                )
+            },
+            text = {
+                OutlinedTextField(
+                    value = viewModel.inputArgs,
+                    onValueChange = { viewModel.updateInputArgs(it) },
+                    label = {
+                        Text(
+                            text = stringResource(R.string.kpm_args),
+                            color = MaterialTheme.colorScheme.primary
+                        )
+                    },
+                    placeholder = {
+                        Text(
+                            text = module.args,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.6f)
+                        )
+                    },
+                    modifier = Modifier.fillMaxWidth(),
+                    colors = OutlinedTextFieldDefaults.colors(
+                        focusedBorderColor = MaterialTheme.colorScheme.primary,
+                        unfocusedBorderColor = MaterialTheme.colorScheme.outline
+                    )
+                )
+            },
+            confirmButton = {
+                TextButton(
+                    onClick = {
+                        scope.launch {
+                            val result = viewModel.executeControl()
+                            val message = when (result) {
+                                0 -> successMessage
+                                else -> failureMessage
+                            }
+                            snackBarHost.showSnackbar(message)
+                            onControl()
+                        }
+                    }
+                ) {
+                    Text(
+                        text = stringResource(R.string.confirm),
+                        color = MaterialTheme.colorScheme.primary
+                    )
+                }
+            },
+            dismissButton = {
+                TextButton(onClick = { viewModel.hideInputDialog() }) {
+                    Text(
+                        text = stringResource(R.string.cancel),
+                        color = MaterialTheme.colorScheme.primary
+                    )
+                }
+            },
+            containerColor = MaterialTheme.colorScheme.surfaceContainerHigh,
+            shape = MaterialTheme.shapes.extraLarge
+        )
+    }
+
+    Card(
+        colors = getCardColors(MaterialTheme.colorScheme.surfaceContainerHigh),
+        elevation = CardDefaults.cardElevation(defaultElevation = cardElevation),
+        modifier = Modifier
+            .fillMaxWidth()
+            .clip(MaterialTheme.shapes.large)
+            .shadow(
+                elevation = cardElevation,
+                shape = MaterialTheme.shapes.large,
+                spotColor = MaterialTheme.colorScheme.primary.copy(alpha = 0.1f)
+            )
+    ) {
+        Column(
+            modifier = Modifier.padding(20.dp)
+        ) {
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.SpaceBetween,
+                verticalAlignment = Alignment.CenterVertically
+            ) {
+                Column(modifier = Modifier.weight(1f)) {
+                    Text(
+                        text = module.name,
+                        style = MaterialTheme.typography.titleLarge,
+                        color = MaterialTheme.colorScheme.onSurface
+                    )
+
+                    Spacer(modifier = Modifier.height(4.dp))
+
+                    Text(
+                        text = "${stringResource(R.string.kpm_version)}: ${module.version}",
+                        style = MaterialTheme.typography.bodyMedium,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant
+                    )
+
+                    Text(
+                        text = "${stringResource(R.string.kpm_author)}: ${module.author}",
+                        style = MaterialTheme.typography.bodyMedium,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant
+                    )
+
+                    Text(
+                        text = "${stringResource(R.string.kpm_args)}: ${module.args}",
+                        style = MaterialTheme.typography.bodyMedium,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant
+                    )
+                }
+            }
+
+            Spacer(modifier = Modifier.height(12.dp))
+
+            Text(
+                text = module.description,
+                style = MaterialTheme.typography.bodyLarge,
+                color = MaterialTheme.colorScheme.onSurfaceVariant
+            )
+
+            Spacer(modifier = Modifier.height(20.dp))
+
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.spacedBy(8.dp)
+            ) {
+                Button(
+                    onClick = { viewModel.showInputDialog(module.id) },
+                    enabled = module.hasAction,
+                    modifier = Modifier.weight(1f),
+                    colors = ButtonDefaults.buttonColors(
+                        containerColor = MaterialTheme.colorScheme.primary,
+                        disabledContainerColor = MaterialTheme.colorScheme.surfaceVariant
+                    )
+                ) {
+                    Icon(
+                        imageVector = Icons.Filled.Settings,
+                        contentDescription = null,
+                        modifier = Modifier.size(20.dp)
+                    )
+                    Spacer(modifier = Modifier.width(8.dp))
+                    Text(stringResource(R.string.kpm_control))
+                }
+
+                Button(
+                    onClick = onUninstall,
+                    modifier = Modifier.weight(1f),
+                    colors = ButtonDefaults.buttonColors(
+                        containerColor = MaterialTheme.colorScheme.error
+                    )
+                ) {
+                    Icon(
+                        imageVector = Icons.Filled.Delete,
+                        contentDescription = null,
+                        modifier = Modifier.size(20.dp)
+                    )
+                    Spacer(modifier = Modifier.width(8.dp))
+                    Text(stringResource(R.string.kpm_uninstall))
+                }
+            }
+        }
+    }
+}
+
+private fun checkStringsCommand(tempFile: File): Int {
+    val command = arrayOf("su", "-c", "strings ${tempFile.absolutePath} | grep -E 'name=|version=|license=|author='")
+    val process = Runtime.getRuntime().exec(command)
+    val inputStream = process.inputStream
+    val reader = BufferedReader(InputStreamReader(inputStream))
+    var line: String?
+    var matchCount = 0
+    val keywords = listOf("name=", "version=", "license=", "author=")
+    var nameExists = false
+
+    while (reader.readLine().also { line = it } != null) {
+        if (!nameExists && line!!.startsWith("name=")) {
+            nameExists = true
+            matchCount++
+        } else if (nameExists) {
+            for (keyword in keywords) {
+                if (line!!.startsWith(keyword)) {
+                    matchCount++
+                    break
+                }
+            }
+        }
+    }
+    process.waitFor()
+
+    return if (nameExists) matchCount else 0
+}
+
+private fun isElfFile(tempFile: File): Boolean {
+    val elfMagic = byteArrayOf(0x7F, 'E'.code.toByte(), 'L'.code.toByte(), 'F'.code.toByte())
+    val fileBytes = ByteArray(4)
+    FileInputStream(tempFile).use { input ->
+        input.read(fileBytes)
+    }
+    return fileBytes.contentEquals(elfMagic)
+}

manager/app/src/main/java/com/sukisu/ultra/ui/screen/Module.kt

@@ -1,30 +1,16 @@
-package shirkneko.zako.sukisu.ui.screen
+package com.sukisu.ultra.ui.screen
 
 import android.app.Activity.*
 import android.content.Context
 import android.content.Intent
 import android.net.Uri
+import android.util.Log
 import android.widget.Toast
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
 import androidx.compose.foundation.*
 import androidx.compose.foundation.interaction.MutableInteractionSource
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.PaddingValues
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.WindowInsets
-import androidx.compose.foundation.layout.WindowInsetsSides
-import androidx.compose.foundation.layout.defaultMinSize
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.only
-import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.*
-import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.items
 import androidx.compose.foundation.selection.toggleable
@@ -32,41 +18,14 @@ import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.automirrored.outlined.*
 import androidx.compose.material.icons.filled.*
 import androidx.compose.material.icons.outlined.*
-import androidx.compose.material3.Button
-import androidx.compose.material3.ButtonDefaults
-import androidx.compose.material3.CardDefaults
-import androidx.compose.material3.Checkbox
-import androidx.compose.material3.DropdownMenu
-import androidx.compose.material3.DropdownMenuItem
-import androidx.compose.material3.ElevatedCard
-import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.material3.ExtendedFloatingActionButton
-import androidx.compose.material3.FilledTonalButton
-import androidx.compose.material3.HorizontalDivider
-import androidx.compose.material3.Icon
-import androidx.compose.material3.IconButton
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Scaffold
-import androidx.compose.material3.SnackbarDuration
-import androidx.compose.material3.SnackbarHost
-import androidx.compose.material3.SnackbarHostState
-import androidx.compose.material3.SnackbarResult
-import androidx.compose.material3.Switch
-import androidx.compose.material3.Text
-import androidx.compose.material3.TopAppBarDefaults
+import androidx.compose.material3.*
 import androidx.compose.material3.pulltorefresh.PullToRefreshBox
-import androidx.compose.material3.rememberTopAppBarState
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.produceState
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.runtime.setValue
+import androidx.compose.runtime.*
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
 import androidx.compose.ui.draw.rotate
+import androidx.compose.ui.draw.shadow
 import androidx.compose.ui.input.nestedscroll.nestedScroll
 import androidx.compose.ui.platform.*
 import androidx.compose.ui.res.stringResource
@@ -88,34 +47,38 @@ import com.ramcosta.composedestinations.navigation.EmptyDestinationsNavigator
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
-import shirkneko.zako.sukisu.Natives
-import shirkneko.zako.sukisu.R
-import shirkneko.zako.sukisu.ui.component.ConfirmResult
-import shirkneko.zako.sukisu.ui.component.SearchAppBar
-import shirkneko.zako.sukisu.ui.component.rememberConfirmDialog
-import shirkneko.zako.sukisu.ui.component.rememberLoadingDialog
-import shirkneko.zako.sukisu.ui.util.DownloadListener
-import shirkneko.zako.sukisu.ui.util.*
-import shirkneko.zako.sukisu.ui.util.download
-import shirkneko.zako.sukisu.ui.util.hasMagisk
-import shirkneko.zako.sukisu.ui.util.reboot
-import shirkneko.zako.sukisu.ui.util.restoreModule
-import shirkneko.zako.sukisu.ui.util.toggleModule
-import shirkneko.zako.sukisu.ui.util.uninstallModule
-import shirkneko.zako.sukisu.ui.webui.WebUIActivity
+import com.sukisu.ultra.Natives
+import com.sukisu.ultra.ui.component.ConfirmResult
+import com.sukisu.ultra.ui.component.SearchAppBar
+import com.sukisu.ultra.ui.component.rememberConfirmDialog
+import com.sukisu.ultra.ui.component.rememberLoadingDialog
+import com.sukisu.ultra.ui.util.DownloadListener
+import com.sukisu.ultra.ui.util.*
+import com.sukisu.ultra.ui.util.download
+import com.sukisu.ultra.ui.util.hasMagisk
+import com.sukisu.ultra.ui.util.reboot
+import com.sukisu.ultra.ui.util.restoreModule
+import com.sukisu.ultra.ui.util.toggleModule
+import com.sukisu.ultra.ui.util.uninstallModule
+import com.sukisu.ultra.ui.webui.WebUIActivity
 import okhttp3.OkHttpClient
-import shirkneko.zako.sukisu.ui.util.ModuleModify
-import shirkneko.zako.sukisu.ui.theme.getCardColors
-import shirkneko.zako.sukisu.ui.theme.getCardElevation
-import shirkneko.zako.sukisu.ui.viewmodel.ModuleViewModel
-import java.io.BufferedReader
-import java.io.InputStreamReader
-import java.util.zip.ZipInputStream
+import com.sukisu.ultra.ui.util.ModuleModify
+import com.sukisu.ultra.ui.theme.getCardColors
+import com.sukisu.ultra.ui.viewmodel.ModuleViewModel
+import java.util.concurrent.TimeUnit
 import androidx.core.content.edit
+import com.sukisu.ultra.R
+import com.sukisu.ultra.ui.theme.CardConfig.cardElevation
+import com.sukisu.ultra.ui.webui.WebUIXActivity
+import com.dergoogler.mmrl.platform.Platform
 import androidx.core.net.toUri
-import shirkneko.zako.sukisu.ui.theme.ThemeConfig
-
+import com.dergoogler.mmrl.platform.model.ModuleConfig
+import com.dergoogler.mmrl.platform.model.ModuleConfig.Companion.asModuleConfig
 
+/**
+ * @author ShirkNeko
+ * @date 2025/5/31.
+ */
 @OptIn(ExperimentalMaterial3Api::class)
 @Destination<RootGraph>
 @Composable
@@ -125,6 +88,7 @@ fun ModuleScreen(navigator: DestinationsNavigator) {
     val snackBarHost = LocalSnackbarHost.current
     val scope = rememberCoroutineScope()
     val confirmDialog = rememberConfirmDialog()
+    var lastClickTime by remember { mutableStateOf(0L) }
 
     val selectZipLauncher = rememberLauncherForActivityResult(
         contract = ActivityResultContracts.StartActivityForResult()
@@ -137,38 +101,21 @@ fun ModuleScreen(navigator: DestinationsNavigator) {
         scope.launch {
             val clipData = data.clipData
             if (clipData != null) {
-                // 处理多选结果
-                val selectedModules = mutableSetOf<Uri>()
+                val selectedModules = mutableListOf<Uri>()
                 val selectedModuleNames = mutableMapOf<Uri, String>()
 
-                suspend fun processUri(uri: Uri) {
-                    val moduleName = withContext(Dispatchers.IO) {
-                        try {
-                            val zipInputStream = ZipInputStream(context.contentResolver.openInputStream(uri))
-                            var entry = zipInputStream.nextEntry
-                            var name = context.getString(R.string.unknown_module)
-
-                            while (entry != null) {
-                                if (entry.name == "module.prop") {
-                                    val reader = BufferedReader(InputStreamReader(zipInputStream))
-                                    var line: String?
-                                    while (reader.readLine().also { line = it } != null) {
-                                        if (line?.startsWith("name=") == true) {
-                                            name = line.substringAfter("=")
-                                            break
-                                        }
-                                    }
-                                    break
-                                }
-                                entry = zipInputStream.nextEntry
-                            }
-                            name
-                        } catch (e: Exception) {
-                            context.getString(R.string.unknown_module)
+                fun processUri(uri: Uri) {
+                    try {
+                        if (!ModuleUtils.isUriAccessible(context, uri)) {
+                            return
                         }
+                        ModuleUtils.takePersistableUriPermission(context, uri)
+                        val moduleName = ModuleUtils.extractModuleName(context, uri)
+                        selectedModules.add(uri)
+                        selectedModuleNames[uri] = moduleName
+                    } catch (e: Exception) {
+                        Log.e("ModuleScreen", "Error while processing URI: $uri, Error: ${e.message}")
                     }
-                    selectedModules.add(uri)
-                    selectedModuleNames[uri] = moduleName
                 }
 
                 for (i in 0 until clipData.itemCount) {
@@ -176,7 +123,11 @@ fun ModuleScreen(navigator: DestinationsNavigator) {
                     processUri(uri)
                 }
 
-                // 显示确认对话框
+                if (selectedModules.isEmpty()) {
+                    snackBarHost.showSnackbar("Unable to access selected module files")
+                    return@launch
+                }
+
                 val modulesList = selectedModuleNames.values.joinToString("\n• ", "• ")
                 val confirmResult = confirmDialog.awaitConfirm(
                     title = context.getString(R.string.module_install),
@@ -186,51 +137,42 @@ fun ModuleScreen(navigator: DestinationsNavigator) {
                 )
 
                 if (confirmResult == ConfirmResult.Confirmed) {
-                    // 批量安装模块
-                    selectedModules.forEach { uri ->
-                        navigator.navigate(FlashScreenDestination(FlashIt.FlashModule(uri)))
+                    try {
+                        // 批量安装模块
+                        navigator.navigate(FlashScreenDestination(FlashIt.FlashModules(selectedModules)))
+                        viewModel.markNeedRefresh()
+                    } catch (e: Exception) {
+                        Log.e("ModuleScreen", "Error navigating to FlashScreen: ${e.message}")
+                        snackBarHost.showSnackbar("Error while installing module: ${e.message}")
                     }
-                    viewModel.markNeedRefresh()
                 }
             } else {
-                // 单个文件安装逻辑
                 val uri = data.data ?: return@launch
-                val moduleName = withContext(Dispatchers.IO) {
-                    try {
-                        val zipInputStream = ZipInputStream(context.contentResolver.openInputStream(uri))
-                        var entry = zipInputStream.nextEntry
-                        var name = context.getString(R.string.unknown_module)
-
-                        while (entry != null) {
-                            if (entry.name == "module.prop") {
-                                val reader = BufferedReader(InputStreamReader(zipInputStream))
-                                var line: String?
-                                while (reader.readLine().also { line = it } != null) {
-                                    if (line?.startsWith("name=") == true) {
-                                        name = line.substringAfter("=")
-                                        break
-                                    }
-                                }
-                                break
-                            }
-                            entry = zipInputStream.nextEntry
-                        }
-                        name
-                    } catch (e: Exception) {
-                        context.getString(R.string.unknown_module)
+                // 单个安装模块
+                try {
+                    if (!ModuleUtils.isUriAccessible(context, uri)) {
+                        snackBarHost.showSnackbar("Unable to access selected module files")
+                        return@launch
                     }
-                }
 
-                val confirmResult = confirmDialog.awaitConfirm(
-                    title = context.getString(R.string.module_install),
-                    content = context.getString(R.string.module_install_confirm, moduleName),
-                    confirm = context.getString(R.string.install),
-                    dismiss = context.getString(R.string.cancel)
-                )
+                    ModuleUtils.takePersistableUriPermission(context, uri)
 
-                if (confirmResult == ConfirmResult.Confirmed) {
-                    navigator.navigate(FlashScreenDestination(FlashIt.FlashModule(uri)))
-                    viewModel.markNeedRefresh()
+                    val moduleName = ModuleUtils.extractModuleName(context, uri)
+
+                    val confirmResult = confirmDialog.awaitConfirm(
+                        title = context.getString(R.string.module_install),
+                        content = context.getString(R.string.module_install_confirm, moduleName),
+                        confirm = context.getString(R.string.install),
+                        dismiss = context.getString(R.string.cancel)
+                    )
+
+                    if (confirmResult == ConfirmResult.Confirmed) {
+                        navigator.navigate(FlashScreenDestination(FlashIt.FlashModule(uri)))
+                        viewModel.markNeedRefresh()
+                    }
+                } catch (e: Exception) {
+                    Log.e("ModuleScreen", "Error processing a single URI: $uri, Error: ${e.message}")
+                    snackBarHost.showSnackbar("Error processing module file: ${e.message}")
                 }
             }
         }
@@ -239,7 +181,7 @@ fun ModuleScreen(navigator: DestinationsNavigator) {
     val backupLauncher = ModuleModify.rememberModuleBackupLauncher(context, snackBarHost)
     val restoreLauncher = ModuleModify.rememberModuleRestoreLauncher(context, snackBarHost)
 
-    val prefs = context.getSharedPreferences("settings", Context.MODE_PRIVATE)
+    val prefs = context.getSharedPreferences("settings", MODE_PRIVATE)
 
     LaunchedEffect(Unit) {
         if (viewModel.moduleList.isEmpty() || viewModel.isNeedRefresh) {
@@ -275,7 +217,7 @@ fun ModuleScreen(navigator: DestinationsNavigator) {
                     ) {
                         Icon(
                             imageVector = Icons.Filled.MoreVert,
-                            contentDescription = stringResource(id = R.string.settings)
+                            contentDescription = stringResource(id = R.string.settings),
                         )
 
                         DropdownMenu(
@@ -284,7 +226,16 @@ fun ModuleScreen(navigator: DestinationsNavigator) {
                         ) {
                             DropdownMenuItem(
                                 text = { Text(stringResource(R.string.module_sort_action_first)) },
-                                trailingIcon = { Checkbox(viewModel.sortActionFirst, null) },
+                                trailingIcon = {
+                                    Checkbox(
+                                        checked = viewModel.sortActionFirst,
+                                        onCheckedChange = null,
+                                        colors = CheckboxDefaults.colors(
+                                            checkedColor = MaterialTheme.colorScheme.primary,
+                                            uncheckedColor = MaterialTheme.colorScheme.outline
+                                        )
+                                    )
+                                },
                                 onClick = {
                                     viewModel.sortActionFirst = !viewModel.sortActionFirst
                                     prefs.edit {
@@ -300,23 +251,33 @@ fun ModuleScreen(navigator: DestinationsNavigator) {
                             )
                             DropdownMenuItem(
                                 text = { Text(stringResource(R.string.module_sort_enabled_first)) },
-                                trailingIcon = { Checkbox(viewModel.sortEnabledFirst, null) },
+                                trailingIcon = {
+                                    Checkbox(
+                                        checked = viewModel.sortEnabledFirst,
+                                        onCheckedChange = null,
+                                        colors = CheckboxDefaults.colors(
+                                            checkedColor = MaterialTheme.colorScheme.primary,
+                                            uncheckedColor = MaterialTheme.colorScheme.outline
+                                        )
+                                    )
+                                },
                                 onClick = {
                                     viewModel.sortEnabledFirst = !viewModel.sortEnabledFirst
                                     prefs.edit {
-                                            putBoolean("module_sort_enabled_first", viewModel.sortEnabledFirst)
-                                        }
+                                        putBoolean("module_sort_enabled_first", viewModel.sortEnabledFirst)
+                                    }
                                     scope.launch {
                                         viewModel.fetchModuleList()
                                     }
                                 }
                             )
+                            HorizontalDivider(thickness = Dp.Hairline, modifier = Modifier.padding(vertical = 4.dp))
                             DropdownMenuItem(
                                 text = { Text(stringResource(R.string.backup_modules)) },
                                 leadingIcon = {
                                     Icon(
                                         imageVector = Icons.Outlined.Download,
-                                        contentDescription = stringResource(R.string.backup)
+                                        contentDescription = stringResource(R.string.backup),
                                     )
                                 },
                                 onClick = {
@@ -329,7 +290,7 @@ fun ModuleScreen(navigator: DestinationsNavigator) {
                                 leadingIcon = {
                                     Icon(
                                         imageVector = Icons.Outlined.Refresh,
-                                        contentDescription = stringResource(R.string.restore)
+                                        contentDescription = stringResource(R.string.restore),
                                     )
                                 },
                                 onClick = {
@@ -346,7 +307,6 @@ fun ModuleScreen(navigator: DestinationsNavigator) {
         floatingActionButton = {
             if (!hideInstallButton) {
                 val moduleInstall = stringResource(id = R.string.module_install)
-                val cardColor = MaterialTheme.colorScheme.secondaryContainer
                 ExtendedFloatingActionButton(
                     onClick = {
                         selectZipLauncher.launch(
@@ -359,16 +319,17 @@ fun ModuleScreen(navigator: DestinationsNavigator) {
                     icon = {
                         Icon(
                             imageVector = Icons.Filled.Add,
-                            contentDescription = moduleInstall
+                            contentDescription = moduleInstall,
                         )
                     },
                     text = {
                         Text(
-                            text = moduleInstall
+                            text = moduleInstall,
+                            color = MaterialTheme.colorScheme.onPrimaryContainer
                         )
                     },
-                    containerColor = cardColor.copy(alpha = 1f),
-                    contentColor = MaterialTheme.colorScheme.onSecondaryContainer
+                    contentColor = MaterialTheme.colorScheme.onPrimaryContainer,
+                    expanded = true,
                 )
             }
         },
@@ -385,10 +346,25 @@ fun ModuleScreen(navigator: DestinationsNavigator) {
                         .padding(24.dp),
                     contentAlignment = Alignment.Center
                 ) {
-                    Text(
-                        stringResource(R.string.module_magisk_conflict),
-                        textAlign = TextAlign.Center,
-                    )
+                    Column(
+                        horizontalAlignment = Alignment.CenterHorizontally,
+                        verticalArrangement = Arrangement.Center
+                    ) {
+                        Icon(
+                            imageVector = Icons.Outlined.Warning,
+                            contentDescription = null,
+                            tint = MaterialTheme.colorScheme.error,
+                            modifier = Modifier
+                                .size(64.dp)
+                                .padding(bottom = 16.dp)
+                        )
+                        Text(
+                            stringResource(R.string.module_magisk_conflict),
+                            textAlign = TextAlign.Center,
+                            style = MaterialTheme.typography.bodyLarge,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant
+                        )
+                    }
                 }
             }
             else -> {
@@ -401,13 +377,60 @@ fun ModuleScreen(navigator: DestinationsNavigator) {
                         navigator.navigate(FlashScreenDestination(FlashIt.FlashModule(it)))
                     },
                     onClickModule = { id, name, hasWebUi ->
+                        val currentTime = System.currentTimeMillis()
+                        if (currentTime - lastClickTime < 600) {
+                            Log.d("ModuleScreen", "Click too fast, ignoring")
+                            return@ModuleList
+                        }
+                        lastClickTime = currentTime
+
                         if (hasWebUi) {
-                            webUILauncher.launch(
-                                Intent(context, WebUIActivity::class.java)
+                            try {
+                                val wxEngine = Intent(context, WebUIXActivity::class.java)
+                                    .setData("kernelsu://webuix/$id".toUri())
+                                    .putExtra("id", id)
+                                    .putExtra("name", name)
+
+                                val ksuEngine = Intent(context, WebUIActivity::class.java)
                                     .setData("kernelsu://webui/$id".toUri())
                                     .putExtra("id", id)
                                     .putExtra("name", name)
-                            )
+
+                                val config = try {
+                                    id.asModuleConfig
+                                } catch (e: Exception) {
+                                    Log.e("ModuleScreen", "Failed to get config from id: $id", e)
+                                    null
+                                }
+
+                                val globalEngine = prefs.getString("webui_engine", "default") ?: "default"
+                                val moduleEngine = config?.getWebuiEngine(context)
+                                val selectedEngine = when (globalEngine) {
+                                    "wx" -> wxEngine
+                                    "ksu" -> ksuEngine
+                                    "default" -> {
+                                        when (moduleEngine) {
+                                            "wx" -> wxEngine
+                                            "ksu" -> ksuEngine
+                                            else -> {
+                                                if (Platform.isAlive) {
+                                                    wxEngine
+                                                } else {
+                                                    ksuEngine
+                                                }
+                                            }
+                                        }
+                                    }
+                                    else -> ksuEngine
+                                }
+                                webUILauncher.launch(selectedEngine)
+                            } catch (e: Exception) {
+                                Log.e("ModuleScreen", "Error launching WebUI: ${e.message}", e)
+                                scope.launch {
+                                    snackBarHost.showSnackbar("Error launching WebUI: ${e.message}")
+                                }
+                            }
+                            return@ModuleList
                         }
                     },
                     context = context,
@@ -445,6 +468,7 @@ private fun ModuleList(
     val downloadingText = stringResource(R.string.module_downloading)
     val startDownloadingText = stringResource(R.string.module_start_downloading)
     val fetchChangeLogFailed = stringResource(R.string.module_changelog_failed)
+    val downloadErrorText = stringResource(R.string.module_download_error)
 
     val loadingDialog = rememberLoadingDialog()
     val confirmDialog = rememberConfirmDialog()
@@ -455,12 +479,20 @@ private fun ModuleList(
         downloadUrl: String,
         fileName: String
     ) {
+        val client = OkHttpClient.Builder()
+            .connectTimeout(15, TimeUnit.SECONDS)
+            .readTimeout(30, TimeUnit.SECONDS)
+            .build()
+
+        val request = okhttp3.Request.Builder()
+            .url(changelogUrl)
+            .header("User-Agent", "SukiSU-Ultra/2.0")
+            .build()
+
         val changelogResult = loadingDialog.withLoading {
             withContext(Dispatchers.IO) {
                 runCatching {
-                    OkHttpClient().newCall(
-                        okhttp3.Request.Builder().url(changelogUrl).build()
-                    ).execute().body!!.string()
+                    client.newCall(request).execute().body!!.string()
                 }
             }
         }
@@ -509,6 +541,11 @@ private fun ModuleList(
                     launch(Dispatchers.Main) {
                         Toast.makeText(context, downloading, Toast.LENGTH_SHORT).show()
                     }
+                },
+                onError = { errorMsg ->
+                    launch(Dispatchers.Main) {
+                        Toast.makeText(context, "$downloadErrorText: $errorMsg", Toast.LENGTH_LONG).show()
+                    }
                 }
             )
         }
@@ -587,10 +624,25 @@ private fun ModuleList(
                             modifier = Modifier.fillParentMaxSize(),
                             contentAlignment = Alignment.Center
                         ) {
-                            Text(
-                                stringResource(R.string.module_empty),
-                                textAlign = TextAlign.Center
-                            )
+                            Column(
+                                horizontalAlignment = Alignment.CenterHorizontally,
+                                verticalArrangement = Arrangement.Center
+                            ) {
+                                Icon(
+                                    imageVector = Icons.Outlined.Extension,
+                                    contentDescription = null,
+                                    tint = MaterialTheme.colorScheme.primary.copy(alpha = 0.6f),
+                                    modifier = Modifier
+                                        .size(96.dp)
+                                        .padding(bottom = 16.dp)
+                                )
+                                Text(
+                                    text = stringResource(R.string.module_empty),
+                                    textAlign = TextAlign.Center,
+                                    style = MaterialTheme.typography.bodyLarge,
+                                    color = MaterialTheme.colorScheme.onSurfaceVariant
+                                )
+                            }
                         }
                     }
                 }
@@ -673,8 +725,16 @@ fun ModuleItem(
     onClick: (ModuleViewModel.ModuleInfo) -> Unit
 ) {
     ElevatedCard(
-        colors = getCardColors(MaterialTheme.colorScheme.secondaryContainer),
-        elevation = CardDefaults.cardElevation(defaultElevation = getCardElevation())
+        colors = getCardColors(MaterialTheme.colorScheme.surfaceContainerHigh),
+        elevation = CardDefaults.cardElevation(defaultElevation = cardElevation),
+        modifier = Modifier
+            .fillMaxWidth()
+            .clip(MaterialTheme.shapes.large)
+            .shadow(
+                elevation = cardElevation,
+                shape = MaterialTheme.shapes.large,
+                spotColor = MaterialTheme.colorScheme.primary.copy(alpha = 0.1f)
+            )
     ) {
         val textDecoration = if (!module.remove) null else TextDecoration.LineThrough
         val interactionSource = remember { MutableInteractionSource() }
@@ -702,6 +762,7 @@ fun ModuleItem(
             Row(
                 modifier = Modifier.fillMaxWidth(),
                 horizontalArrangement = Arrangement.SpaceBetween,
+                verticalAlignment = Alignment.CenterVertically
             ) {
                 val moduleVersion = stringResource(id = R.string.module_version)
                 val moduleAuthor = stringResource(id = R.string.module_author)
@@ -716,6 +777,7 @@ fun ModuleItem(
                         lineHeight = MaterialTheme.typography.bodySmall.lineHeight,
                         fontFamily = MaterialTheme.typography.titleMedium.fontFamily,
                         textDecoration = textDecoration,
+                        color = MaterialTheme.colorScheme.onSurface
                     )
 
                     Text(
@@ -723,7 +785,8 @@ fun ModuleItem(
                         fontSize = MaterialTheme.typography.bodySmall.fontSize,
                         lineHeight = MaterialTheme.typography.bodySmall.lineHeight,
                         fontFamily = MaterialTheme.typography.bodySmall.fontFamily,
-                        textDecoration = textDecoration
+                        textDecoration = textDecoration,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant
                     )
 
                     Text(
@@ -731,7 +794,8 @@ fun ModuleItem(
                         fontSize = MaterialTheme.typography.bodySmall.fontSize,
                         lineHeight = MaterialTheme.typography.bodySmall.lineHeight,
                         fontFamily = MaterialTheme.typography.bodySmall.fontFamily,
-                    textDecoration = textDecoration
+                        textDecoration = textDecoration,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant
                     )
                 }
 
@@ -745,7 +809,15 @@ fun ModuleItem(
                         enabled = !module.update,
                         checked = module.enabled,
                         onCheckedChange = onCheckChanged,
-                        interactionSource = if (!module.hasWebUi) interactionSource else null
+                        interactionSource = if (!module.hasWebUi) interactionSource else null,
+                        colors = SwitchDefaults.colors(
+                            checkedThumbColor = MaterialTheme.colorScheme.onPrimary,
+                            checkedTrackColor = MaterialTheme.colorScheme.primary,
+                            checkedIconColor = MaterialTheme.colorScheme.primary,
+                            uncheckedThumbColor = MaterialTheme.colorScheme.outline,
+                            uncheckedTrackColor = MaterialTheme.colorScheme.surfaceVariant,
+                            uncheckedIconColor = MaterialTheme.colorScheme.surfaceVariant
+                        )
                     )
                 }
             }
@@ -760,83 +832,54 @@ fun ModuleItem(
                 fontWeight = MaterialTheme.typography.bodySmall.fontWeight,
                 overflow = TextOverflow.Ellipsis,
                 maxLines = 4,
-                textDecoration = textDecoration
+                textDecoration = textDecoration,
+                color = MaterialTheme.colorScheme.onSurfaceVariant
             )
 
             Spacer(modifier = Modifier.height(16.dp))
 
             HorizontalDivider(thickness = Dp.Hairline)
 
-            Spacer(modifier = Modifier.height(4.dp))
+            Spacer(modifier = Modifier.height(8.dp))
 
             Row(
-                horizontalArrangement = Arrangement.SpaceBetween,
+                horizontalArrangement = Arrangement.spacedBy(8.dp),
                 verticalAlignment = Alignment.CenterVertically
             ) {
-
                 if (module.hasActionScript) {
                     FilledTonalButton(
-                        modifier = Modifier.defaultMinSize(52.dp, 32.dp),
+                        modifier = Modifier.defaultMinSize(minWidth = 52.dp, minHeight = 32.dp),
                         enabled = !module.remove && module.enabled,
                         onClick = {
                             navigator.navigate(ExecuteModuleActionScreenDestination(module.dirId))
                             viewModel.markNeedRefresh()
                         },
                         contentPadding = ButtonDefaults.TextButtonContentPadding,
-                        colors = if (!ThemeConfig.useDynamicColor) {
-                            ButtonDefaults.filledTonalButtonColors(
-                                containerColor = ThemeConfig.currentTheme.ButtonContrast
-                            )
-                        } else {
-                            ButtonDefaults.filledTonalButtonColors()
-                        }
+                        colors = ButtonDefaults.filledTonalButtonColors()
                     ) {
                         Icon(
                             modifier = Modifier.size(20.dp),
                             imageVector = Icons.Outlined.PlayArrow,
                             contentDescription = null
                         )
-                        if (!module.hasWebUi && updateUrl.isEmpty()) {
-                            Text(
-                                modifier = Modifier.padding(start = 7.dp),
-                                text = stringResource(R.string.action),
-                                fontFamily = MaterialTheme.typography.labelMedium.fontFamily,
-                                fontSize = MaterialTheme.typography.labelMedium.fontSize
-                            )
-                        }
                     }
-
-                    Spacer(modifier = Modifier.weight(0.1f, true))
                 }
 
                 if (module.hasWebUi) {
                     FilledTonalButton(
-                        modifier = Modifier.defaultMinSize(52.dp, 32.dp),
+                        modifier = Modifier.defaultMinSize(minWidth = 52.dp, minHeight = 32.dp),
                         enabled = !module.remove && module.enabled,
                         onClick = { onClick(module) },
                         interactionSource = interactionSource,
                         contentPadding = ButtonDefaults.TextButtonContentPadding,
-                        colors = if (!ThemeConfig.useDynamicColor) {
-                            ButtonDefaults.filledTonalButtonColors(
-                                containerColor = ThemeConfig.currentTheme.ButtonContrast
-                            )
-                        } else {
-                            ButtonDefaults.filledTonalButtonColors()
-                        }
+                        colors = ButtonDefaults.filledTonalButtonColors()
+
                     ) {
                         Icon(
                             modifier = Modifier.size(20.dp),
                             imageVector = Icons.AutoMirrored.Outlined.Wysiwyg,
                             contentDescription = null
                         )
-                        if (!module.hasActionScript && updateUrl.isEmpty()) {
-                            Text(
-                                modifier = Modifier.padding(start = 7.dp),
-                                fontFamily = MaterialTheme.typography.labelMedium.fontFamily,
-                                fontSize = MaterialTheme.typography.labelMedium.fontSize,
-                                text = stringResource(R.string.open)
-                            )
-                        }
                     }
                 }
 
@@ -844,41 +887,27 @@ fun ModuleItem(
 
                 if (updateUrl.isNotEmpty()) {
                     Button(
-                        modifier = Modifier.defaultMinSize(52.dp, 32.dp),
+                        modifier = Modifier.defaultMinSize(minWidth = 52.dp, minHeight = 32.dp),
                         enabled = !module.remove,
                         onClick = { onUpdate(module) },
                         shape = ButtonDefaults.textShape,
                         contentPadding = ButtonDefaults.TextButtonContentPadding,
+                        colors = ButtonDefaults.filledTonalButtonColors()
                     ) {
                         Icon(
                             modifier = Modifier.size(20.dp),
                             imageVector = Icons.Outlined.Download,
                             contentDescription = null
                         )
-                        if (!module.hasActionScript || !module.hasWebUi) {
-                            Text(
-                                modifier = Modifier.padding(start = 7.dp),
-                                fontFamily = MaterialTheme.typography.labelMedium.fontFamily,
-                                fontSize = MaterialTheme.typography.labelMedium.fontSize,
-                                text = stringResource(R.string.module_update)
-                            )
-                        }
                     }
-
-                    Spacer(modifier = Modifier.weight(0.1f, true))
                 }
 
                 FilledTonalButton(
-                    modifier = Modifier.defaultMinSize(52.dp, 32.dp),
+                    modifier = Modifier.defaultMinSize(minWidth = 52.dp, minHeight = 32.dp),
                     onClick = { onUninstallClicked(module) },
                     contentPadding = ButtonDefaults.TextButtonContentPadding,
-                    colors = if (!ThemeConfig.useDynamicColor) {
-                        ButtonDefaults.filledTonalButtonColors(
-                            containerColor = ThemeConfig.currentTheme.ButtonContrast
-                        )
-                    } else {
-                        ButtonDefaults.filledTonalButtonColors()
-                    }
+                    colors = ButtonDefaults.filledTonalButtonColors(
+                        containerColor = if (!module.remove) MaterialTheme.colorScheme.secondaryContainer else MaterialTheme.colorScheme.errorContainer)
                 ) {
                     if (!module.remove) {
                         Icon(
@@ -890,16 +919,7 @@ fun ModuleItem(
                         Icon(
                             modifier = Modifier.size(20.dp).rotate(180f),
                             imageVector = Icons.Outlined.Refresh,
-                            contentDescription = null,
-
-                        )
-                    }
-                    if (!module.hasActionScript && !module.hasWebUi && updateUrl.isEmpty()) {
-                        Text(
-                            modifier = Modifier.padding(start = 7.dp),
-                            fontFamily = MaterialTheme.typography.labelMedium.fontFamily,
-                            fontSize = MaterialTheme.typography.labelMedium.fontSize,
-                            text = stringResource(if (!module.remove) R.string.uninstall else R.string.restore)
+                            contentDescription = null
                         )
                     }
                 }
@@ -924,8 +944,8 @@ fun ModuleItemPreview() {
         updateJson = "",
         hasWebUi = false,
         hasActionScript = false,
-        dirId = "dirId"
+        dirId = "dirId",
+        config = ModuleConfig(),
     )
     ModuleItem(EmptyDestinationsNavigator, module, "", {}, {}, {}, {})
 }
-

manager/app/src/main/java/com/sukisu/ultra/ui/screen/Settings.kt

@@ -0,0 +1,798 @@
+package com.sukisu.ultra.ui.screen
+
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import android.widget.Toast
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.expandVertically
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.shrinkVertically
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.Undo
+import androidx.compose.material.icons.filled.*
+import androidx.compose.material3.*
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.input.nestedscroll.nestedScroll
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import androidx.core.content.FileProvider
+import androidx.core.content.edit
+import com.maxkeppeker.sheets.core.models.base.IconSource
+import com.maxkeppeler.sheets.list.models.ListOption
+import com.ramcosta.composedestinations.annotation.Destination
+import com.ramcosta.composedestinations.annotation.RootGraph
+import com.ramcosta.composedestinations.generated.destinations.AppProfileTemplateScreenDestination
+import com.ramcosta.composedestinations.generated.destinations.FlashScreenDestination
+import com.ramcosta.composedestinations.generated.destinations.MoreSettingsScreenDestination
+import com.ramcosta.composedestinations.navigation.DestinationsNavigator
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import com.sukisu.ultra.BuildConfig
+import com.sukisu.ultra.Natives
+import com.sukisu.ultra.R
+import com.sukisu.ultra.*
+import com.sukisu.ultra.ui.component.*
+import com.sukisu.ultra.ui.theme.*
+import com.sukisu.ultra.ui.theme.CardConfig.cardAlpha
+import com.sukisu.ultra.ui.util.LocalSnackbarHost
+import com.sukisu.ultra.ui.util.getBugreportFile
+import java.time.LocalDateTime
+import java.time.format.DateTimeFormatter
+import com.sukisu.ultra.ui.component.KsuIsValid
+
+/**
+ * @author ShirkNeko
+ * @date 2025/5/31.
+ */
+@OptIn(ExperimentalMaterial3Api::class)
+@Destination<RootGraph>
+@Composable
+fun SettingScreen(navigator: DestinationsNavigator) {
+    val scrollBehavior = TopAppBarDefaults.pinnedScrollBehavior(rememberTopAppBarState())
+    val snackBarHost = LocalSnackbarHost.current
+    val context = LocalContext.current
+    val prefs = context.getSharedPreferences("settings", Context.MODE_PRIVATE)
+    var selectedEngine by rememberSaveable {
+        mutableStateOf(
+            prefs.getString("webui_engine", "default") ?: "default"
+        )
+    }
+
+    Scaffold(
+        topBar = {
+            TopBar(
+                scrollBehavior = scrollBehavior
+            )
+        },
+        snackbarHost = { SnackbarHost(snackBarHost) },
+        contentWindowInsets = WindowInsets.safeDrawing.only(WindowInsetsSides.Top + WindowInsetsSides.Horizontal)
+    ) { paddingValues ->
+        val aboutDialog = rememberCustomDialog {
+            AboutDialog(it)
+        }
+        val loadingDialog = rememberLoadingDialog()
+
+        Column(
+            modifier = Modifier
+                .padding(paddingValues)
+                .nestedScroll(scrollBehavior.nestedScrollConnection)
+                .verticalScroll(rememberScrollState())
+        ) {
+            val context = LocalContext.current
+            val scope = rememberCoroutineScope()
+            val exportBugreportLauncher = rememberLauncherForActivityResult(
+                ActivityResultContracts.CreateDocument("application/gzip")
+            ) { uri: Uri? ->
+                if (uri == null) return@rememberLauncherForActivityResult
+                scope.launch(Dispatchers.IO) {
+                    loadingDialog.show()
+                    context.contentResolver.openOutputStream(uri)?.use { output ->
+                        getBugreportFile(context).inputStream().use {
+                            it.copyTo(output)
+                        }
+                    }
+                    loadingDialog.hide()
+                    snackBarHost.showSnackbar(context.getString(R.string.log_saved))
+                }
+            }
+
+            // 配置
+            Card(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(horizontal = 16.dp, vertical = 8.dp),
+                colors = CardDefaults.cardColors(
+                    containerColor = MaterialTheme.colorScheme.surfaceContainerHigh.copy(alpha = cardAlpha)
+                ),
+                elevation = CardDefaults.cardElevation(defaultElevation = 0.dp)
+            ) {
+                Column(modifier = Modifier.padding(vertical = 8.dp)) {
+                    Text(
+                        text = stringResource(R.string.configuration),
+                        style = MaterialTheme.typography.titleMedium,
+                        color = MaterialTheme.colorScheme.primary,
+                        modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp)
+                    )
+
+                    // 配置文件模板入口
+                    val profileTemplate = stringResource(id = R.string.settings_profile_template)
+                    KsuIsValid {
+                        SettingItem(
+                            icon = Icons.Filled.Fence,
+                            title = profileTemplate,
+                            summary = stringResource(id = R.string.settings_profile_template_summary),
+                            onClick = {
+                                navigator.navigate(AppProfileTemplateScreenDestination)
+                            }
+                        )
+                    }
+
+                    // 卸载模块开关
+                    var umountChecked by rememberSaveable {
+                        mutableStateOf(Natives.isDefaultUmountModules())
+                    }
+
+                    KsuIsValid {
+                        SwitchItem(
+                            icon = Icons.Filled.FolderDelete,
+                            title = stringResource(id = R.string.settings_umount_modules_default),
+                            summary = stringResource(id = R.string.settings_umount_modules_default_summary),
+                            checked = umountChecked
+                        ) { enabled ->
+                            if (Natives.setDefaultUmountModules(enabled)) {
+                                umountChecked = enabled
+                            }
+                        }
+                    }
+
+                    // SU 禁用开关（仅在兼容版本显示）
+                    KsuIsValid {
+                        if (Natives.version >= Natives.MINIMAL_SUPPORTED_SU_COMPAT) {
+                            var isSuDisabled by rememberSaveable {
+                                mutableStateOf(!Natives.isSuEnabled())
+                            }
+                            SwitchItem(
+                                icon = Icons.Filled.RemoveModerator,
+                                title = stringResource(id = R.string.settings_disable_su),
+                                summary = stringResource(id = R.string.settings_disable_su_summary),
+                                checked = isSuDisabled
+                            ) { enabled ->
+                                val shouldEnable = !enabled
+                                if (Natives.setSuEnabled(shouldEnable)) {
+                                    isSuDisabled = enabled
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            // 应用设置
+            Card(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(horizontal = 16.dp, vertical = 8.dp),
+                colors = CardDefaults.cardColors(
+                    containerColor = MaterialTheme.colorScheme.surfaceContainerHigh.copy(alpha = cardAlpha)
+                ),
+                elevation = CardDefaults.cardElevation(defaultElevation = 0.dp)
+            ) {
+                Column(modifier = Modifier.padding(vertical = 8.dp)) {
+                    Text(
+                        text = stringResource(R.string.app_settings),
+                        style = MaterialTheme.typography.titleMedium,
+                        color = MaterialTheme.colorScheme.primary,
+                        modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp)
+                    )
+
+                    val prefs = context.getSharedPreferences("settings", Context.MODE_PRIVATE)
+
+                    // 更新检查开关
+                    var checkUpdate by rememberSaveable {
+                        mutableStateOf(
+                            prefs.getBoolean("check_update", true)
+                        )
+                    }
+                    SwitchItem(
+                        icon = Icons.Filled.Update,
+                        title = stringResource(id = R.string.settings_check_update),
+                        summary = stringResource(id = R.string.settings_check_update_summary),
+                        checked = checkUpdate
+                    ) { enabled ->
+                        prefs.edit { putBoolean("check_update", enabled) }
+                        checkUpdate = enabled
+                    }
+
+                    // WebUI引擎选择
+                    KsuIsValid {
+                        val engineOptions = listOf(
+                            "default" to stringResource(id = R.string.engine_auto_select),
+                            "wx" to stringResource(id = R.string.engine_force_webuix),
+                            "ksu" to stringResource(id = R.string.engine_force_ksu)
+                        )
+
+                        var showEngineDialog by remember { mutableStateOf(false) }
+
+                        SettingItem(
+                            icon = Icons.Filled.WebAsset,
+                            title = stringResource(id = R.string.use_webuix),
+                            summary = engineOptions.find { it.first == selectedEngine }?.second
+                                ?: stringResource(id = R.string.engine_auto_select),
+                            onClick = {
+                                showEngineDialog = true
+                            }
+                        )
+
+                        if (showEngineDialog) {
+                            AlertDialog(
+                                onDismissRequest = { showEngineDialog = false },
+                                title = { Text(stringResource(id = R.string.use_webuix)) },
+                                text = {
+                                    Column {
+                                        engineOptions.forEach { (value, label) ->
+                                            Row(
+                                                modifier = Modifier
+                                                    .fillMaxWidth()
+                                                    .clickable {
+                                                        selectedEngine = value
+                                                        prefs.edit {
+                                                            putString("webui_engine", value)
+                                                        }
+                                                        showEngineDialog = false
+                                                    }
+                                                    .padding(vertical = 12.dp),
+                                                verticalAlignment = Alignment.CenterVertically
+                                            ) {
+                                                RadioButton(
+                                                    selected = selectedEngine == value,
+                                                    onClick = null
+                                                )
+                                                Spacer(modifier = Modifier.width(8.dp))
+                                                Text(text = label)
+                                            }
+                                        }
+                                    }
+                                },
+                                confirmButton = {
+                                    TextButton(
+                                        onClick = { showEngineDialog = false }
+                                    ) {
+                                        Text(stringResource(id = R.string.cancel))
+                                    }
+                                }
+                            )
+                        }
+                    }
+
+                    // Web调试和Web X Eruda 开关
+                    var enableWebDebugging by rememberSaveable {
+                        mutableStateOf(
+                            prefs.getBoolean("enable_web_debugging", false)
+                        )
+                    }
+                    var useWebUIXEruda by rememberSaveable {
+                        mutableStateOf(
+                            prefs.getBoolean("use_webuix_eruda", false)
+                        )
+                    }
+                    KsuIsValid {
+                        SwitchItem(
+                            icon = Icons.Filled.DeveloperMode,
+                            title = stringResource(id = R.string.enable_web_debugging),
+                            summary = stringResource(id = R.string.enable_web_debugging_summary),
+                            checked = enableWebDebugging
+                        ) { enabled ->
+                            prefs.edit { putBoolean("enable_web_debugging", enabled) }
+                            enableWebDebugging = enabled
+                        }
+
+                        AnimatedVisibility(
+                            visible = enableWebDebugging && selectedEngine == "wx",
+                            enter = fadeIn() + expandVertically(),
+                            exit = fadeOut() + shrinkVertically()
+                        ) {
+                            SwitchItem(
+                                icon = Icons.Filled.FormatListNumbered,
+                                title = stringResource(id = R.string.use_webuix_eruda),
+                                summary = stringResource(id = R.string.use_webuix_eruda_summary),
+                                checked = useWebUIXEruda
+                            ) { enabled ->
+                                prefs.edit { putBoolean("use_webuix_eruda", enabled) }
+                                useWebUIXEruda = enabled
+                            }
+                        }
+                    }
+
+                    // 更多设置
+                    SettingItem(
+                        icon = Icons.Filled.Settings,
+                        title = stringResource(id = R.string.more_settings),
+                        summary = stringResource(id = R.string.more_settings),
+                        onClick = {
+                            navigator.navigate(MoreSettingsScreenDestination)
+                        }
+                    )
+                }
+            }
+
+            // 工具
+            Card(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(horizontal = 16.dp, vertical = 8.dp),
+                colors = CardDefaults.cardColors(
+                    containerColor = MaterialTheme.colorScheme.surfaceContainerHigh.copy(alpha = cardAlpha)
+                ),
+                elevation = CardDefaults.cardElevation(defaultElevation = 0.dp)
+            ) {
+                Column(modifier = Modifier.padding(vertical = 8.dp)) {
+                    Text(
+                        text = stringResource(R.string.tools),
+                        style = MaterialTheme.typography.titleMedium,
+                        color = MaterialTheme.colorScheme.primary,
+                        modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp)
+                    )
+
+                    var showBottomsheet by remember { mutableStateOf(false) }
+
+                    SettingItem(
+                        icon = Icons.Filled.BugReport,
+                        title = stringResource(id = R.string.send_log),
+                        onClick = {
+                            showBottomsheet = true
+                        }
+                    )
+
+                    if (showBottomsheet) {
+                        ModalBottomSheet(
+                            onDismissRequest = { showBottomsheet = false },
+                            containerColor = MaterialTheme.colorScheme.surfaceContainerHigh,
+                        ) {
+                            Row(
+                                modifier = Modifier
+                                    .fillMaxWidth()
+                                    .padding(16.dp),
+                                horizontalArrangement = Arrangement.SpaceEvenly
+                            ) {
+                                LogActionButton(
+                                    icon = Icons.Filled.Save,
+                                    text = stringResource(R.string.save_log),
+                                    onClick = {
+                                        val formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd_HH_mm")
+                                        val current = LocalDateTime.now().format(formatter)
+                                        exportBugreportLauncher.launch("KernelSU_bugreport_${current}.tar.gz")
+                                        showBottomsheet = false
+                                    }
+                                )
+
+                                LogActionButton(
+                                    icon = Icons.Filled.Share,
+                                    text = stringResource(R.string.send_log),
+                                    onClick = {
+                                        scope.launch {
+                                            val bugreport = loadingDialog.withLoading {
+                                                withContext(Dispatchers.IO) {
+                                                    getBugreportFile(context)
+                                                }
+                                            }
+
+                                            val uri: Uri =
+                                                FileProvider.getUriForFile(
+                                                    context,
+                                                    "${BuildConfig.APPLICATION_ID}.fileprovider",
+                                                    bugreport
+                                                )
+
+                                            val shareIntent = Intent(Intent.ACTION_SEND).apply {
+                                                putExtra(Intent.EXTRA_STREAM, uri)
+                                                setDataAndType(uri, "application/gzip")
+                                                addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
+                                            }
+
+                                            context.startActivity(
+                                                Intent.createChooser(
+                                                    shareIntent,
+                                                    context.getString(R.string.send_log)
+                                                )
+                                            )
+
+                                            showBottomsheet = false
+                                        }
+                                    }
+                                )
+                            }
+                            Spacer(modifier = Modifier.height(16.dp))
+                        }
+                    }
+
+                    val lkmMode = Natives.version >= Natives.MINIMAL_SUPPORTED_KERNEL_LKM && Natives.isLkmMode
+                    if (lkmMode) {
+                        UninstallItem(navigator) {
+                            loadingDialog.withLoading(it)
+                        }
+                    }
+                }
+            }
+
+            // 关于
+            Card(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(horizontal = 16.dp, vertical = 8.dp),
+                colors = CardDefaults.cardColors(
+                    containerColor = MaterialTheme.colorScheme.surfaceContainerHigh.copy(alpha = cardAlpha)
+                ),
+                elevation = CardDefaults.cardElevation(defaultElevation = 0.dp)
+            ) {
+                Column(modifier = Modifier.padding(vertical = 8.dp)) {
+                    Text(
+                        text = stringResource(R.string.about),
+                        style = MaterialTheme.typography.titleMedium,
+                        color = MaterialTheme.colorScheme.primary,
+                        modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp)
+                    )
+
+                    SettingItem(
+                        icon = Icons.Filled.Info,
+                        title = stringResource(R.string.about),
+                        onClick = {
+                            aboutDialog.show()
+                        }
+                    )
+                }
+            }
+
+            Spacer(modifier = Modifier.height(16.dp))
+        }
+    }
+}
+
+@Composable
+fun LogActionButton(
+    icon: ImageVector,
+    text: String,
+    onClick: () -> Unit
+) {
+    Column(
+        horizontalAlignment = Alignment.CenterHorizontally,
+        modifier = Modifier
+            .clickable(onClick = onClick)
+            .padding(8.dp)
+    ) {
+        Box(
+            contentAlignment = Alignment.Center,
+            modifier = Modifier
+                .size(56.dp)
+                .clip(CircleShape)
+                .background(MaterialTheme.colorScheme.primaryContainer)
+        ) {
+            Icon(
+                imageVector = icon,
+                contentDescription = text,
+                tint = MaterialTheme.colorScheme.onPrimaryContainer,
+                modifier = Modifier.size(24.dp)
+            )
+        }
+        Spacer(modifier = Modifier.height(8.dp))
+        Text(
+            text = text,
+            style = MaterialTheme.typography.bodyMedium,
+            color = MaterialTheme.colorScheme.onSurface
+        )
+    }
+}
+
+@Composable
+fun SettingItem(
+    icon: ImageVector,
+    title: String,
+    summary: String? = null,
+    onClick: () -> Unit
+) {
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .clickable(onClick = onClick)
+            .padding(horizontal = 16.dp, vertical = 12.dp),
+        verticalAlignment = Alignment.CenterVertically
+    ) {
+        Icon(
+            imageVector = icon,
+            contentDescription = null,
+            tint = MaterialTheme.colorScheme.primary,
+            modifier = Modifier
+                .padding(end = 16.dp)
+                .size(24.dp)
+        )
+
+        Column(modifier = Modifier.weight(1f)) {
+            Text(
+                text = title,
+                style = MaterialTheme.typography.titleMedium,
+                color = MaterialTheme.colorScheme.onSurface
+            )
+            if (summary != null) {
+                Text(
+                    text = summary,
+                    style = MaterialTheme.typography.bodyMedium,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant
+                )
+            }
+        }
+        Icon(
+            imageVector = Icons.Filled.ChevronRight,
+            contentDescription = null,
+            tint = MaterialTheme.colorScheme.onSurfaceVariant,
+            modifier = Modifier.size(24.dp)
+        )
+    }
+}
+
+@Composable
+fun UninstallItem(
+    navigator: DestinationsNavigator,
+    withLoading: suspend (suspend () -> Unit) -> Unit
+) {
+    val context = LocalContext.current
+    val scope = rememberCoroutineScope()
+    val uninstallConfirmDialog = rememberConfirmDialog()
+    val showTodo = {
+        Toast.makeText(context, "TODO", Toast.LENGTH_SHORT).show()
+    }
+    val uninstallDialog = rememberUninstallDialog { uninstallType ->
+        scope.launch {
+            val result = uninstallConfirmDialog.awaitConfirm(
+                title = context.getString(uninstallType.title),
+                content = context.getString(uninstallType.message)
+            )
+            if (result == ConfirmResult.Confirmed) {
+                withLoading {
+                    when (uninstallType) {
+                        UninstallType.TEMPORARY -> showTodo()
+                        UninstallType.PERMANENT -> navigator.navigate(
+                            FlashScreenDestination(FlashIt.FlashUninstall)
+                        )
+                        UninstallType.RESTORE_STOCK_IMAGE -> navigator.navigate(
+                            FlashScreenDestination(FlashIt.FlashRestore)
+                        )
+                        UninstallType.NONE -> Unit
+                    }
+                }
+            }
+        }
+    }
+
+    SettingItem(
+        icon = Icons.Filled.Delete,
+        title = stringResource(id = R.string.settings_uninstall),
+        onClick = {
+            uninstallDialog.show()
+        }
+    )
+}
+
+enum class UninstallType(val title: Int, val message: Int, val icon: ImageVector) {
+    TEMPORARY(
+        R.string.settings_uninstall_temporary,
+        R.string.settings_uninstall_temporary_message,
+        Icons.Filled.Delete
+    ),
+    PERMANENT(
+        R.string.settings_uninstall_permanent,
+        R.string.settings_uninstall_permanent_message,
+        Icons.Filled.DeleteForever
+    ),
+    RESTORE_STOCK_IMAGE(
+        R.string.settings_restore_stock_image,
+        R.string.settings_restore_stock_image_message,
+        Icons.AutoMirrored.Filled.Undo
+    ),
+    NONE(0, 0, Icons.Filled.Delete)
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun rememberUninstallDialog(onSelected: (UninstallType) -> Unit): DialogHandle {
+    return rememberCustomDialog { dismiss ->
+        val options = listOf(
+            // UninstallType.TEMPORARY,
+            UninstallType.PERMANENT,
+            UninstallType.RESTORE_STOCK_IMAGE
+        )
+        val listOptions = options.map {
+            ListOption(
+                titleText = stringResource(it.title),
+                subtitleText = if (it.message != 0) stringResource(it.message) else null,
+                icon = IconSource(it.icon)
+            )
+        }
+
+        var selectedOption by remember { mutableStateOf<UninstallType?>(null) }
+
+        AlertDialog(
+            onDismissRequest = {
+                dismiss()
+            },
+            title = {
+                Text(
+                    text = stringResource(R.string.settings_uninstall),
+                    style = MaterialTheme.typography.headlineSmall,
+                    color = MaterialTheme.colorScheme.onSurface
+                )
+            },
+            text = {
+                Column(
+                    modifier = Modifier.padding(vertical = 8.dp),
+                    verticalArrangement = Arrangement.spacedBy(16.dp)
+                ) {
+                    options.forEachIndexed { index, option ->
+                        val isSelected = selectedOption == option
+                        val backgroundColor = if (isSelected)
+                            MaterialTheme.colorScheme.primaryContainer
+                        else
+                            Color.Transparent
+                        val borderColor = if (isSelected)
+                            MaterialTheme.colorScheme.primary
+                        else
+                            Color.Transparent
+                        val contentColor = if (isSelected)
+                            MaterialTheme.colorScheme.onPrimaryContainer
+                        else
+                            MaterialTheme.colorScheme.onSurface
+
+                        Row(
+                            modifier = Modifier
+                                .fillMaxWidth()
+                                .clip(MaterialTheme.shapes.medium)
+                                .background(backgroundColor)
+                                .border(
+                                    width = 1.dp,
+                                    color = borderColor,
+                                    shape = MaterialTheme.shapes.medium
+                                )
+                                .clickable {
+                                    selectedOption = option
+                                }
+                                .padding(vertical = 12.dp, horizontal = 8.dp),
+                            verticalAlignment = Alignment.CenterVertically
+                        ) {
+                            Icon(
+                                imageVector = option.icon,
+                                contentDescription = null,
+                                tint = if (isSelected)
+                                    MaterialTheme.colorScheme.primary
+                                else
+                                    MaterialTheme.colorScheme.primary,
+                                modifier = Modifier
+                                    .padding(end = 16.dp)
+                                    .size(24.dp)
+                            )
+                            Column(
+                                modifier = Modifier.weight(1f)
+                            ) {
+                                Text(
+                                    text = listOptions[index].titleText,
+                                    style = MaterialTheme.typography.titleMedium,
+                                    color = contentColor
+                                )
+                                listOptions[index].subtitleText?.let {
+                                    Text(
+                                        text = it,
+                                        style = MaterialTheme.typography.bodyMedium,
+                                        color = if (isSelected)
+                                            contentColor.copy(alpha = 0.8f)
+                                        else
+                                            MaterialTheme.colorScheme.onSurfaceVariant
+                                    )
+                                }
+                            }
+                            if (isSelected) {
+                                Icon(
+                                    imageVector = Icons.Default.RadioButtonChecked,
+                                    contentDescription = null,
+                                    tint = MaterialTheme.colorScheme.primary,
+                                    modifier = Modifier.size(24.dp)
+                                )
+                            } else {
+                                Icon(
+                                    imageVector = Icons.Default.RadioButtonUnchecked,
+                                    contentDescription = null,
+                                    tint = MaterialTheme.colorScheme.onSurfaceVariant,
+                                    modifier = Modifier.size(24.dp)
+                                )
+                            }
+                        }
+                    }
+                }
+            },
+            confirmButton = {
+                Button(
+                    onClick = {
+                        selectedOption?.let { onSelected(it) }
+                        dismiss()
+                    },
+                    enabled = selectedOption != null,
+                    colors = ButtonDefaults.buttonColors(
+                        containerColor = MaterialTheme.colorScheme.primary,
+                        contentColor = MaterialTheme.colorScheme.onPrimary,
+                        disabledContainerColor = MaterialTheme.colorScheme.surfaceVariant,
+                        disabledContentColor = MaterialTheme.colorScheme.onSurfaceVariant
+                    )
+                ) {
+                    Text(
+                        text = stringResource(android.R.string.ok)
+                    )
+                }
+            },
+            dismissButton = {
+                TextButton(
+                    onClick = {
+                        dismiss()
+                    }
+                ) {
+                    Text(
+                        text = stringResource(android.R.string.cancel),
+                        color = MaterialTheme.colorScheme.primary
+                    )
+                }
+            },
+            containerColor = MaterialTheme.colorScheme.secondaryContainer,
+            shape = MaterialTheme.shapes.extraLarge,
+            tonalElevation = 4.dp
+        )
+    }
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun TopBar(
+    scrollBehavior: TopAppBarScrollBehavior? = null
+) {
+    val systemIsDark = isSystemInDarkTheme()
+    val cardColor = MaterialTheme.colorScheme.surfaceContainerLow
+    val cardAlpha = if (ThemeConfig.customBackgroundUri != null) {
+        cardAlpha
+    } else {
+        if (systemIsDark) 0.8f else 1f
+    }
+
+    TopAppBar(
+        title = {
+            Text(
+                text = stringResource(R.string.settings),
+                style = MaterialTheme.typography.titleLarge
+            )
+        },
+        colors = TopAppBarDefaults.topAppBarColors(
+            containerColor = cardColor.copy(alpha = cardAlpha),
+            scrolledContainerColor = cardColor.copy(alpha = cardAlpha)
+        ),
+        windowInsets = WindowInsets.safeDrawing.only(WindowInsetsSides.Top + WindowInsetsSides.Horizontal),
+        scrollBehavior = scrollBehavior
+    )
+}

manager/app/src/main/java/com/sukisu/ultra/ui/screen/SuperUser.kt

@@ -0,0 +1,888 @@
+package com.sukisu.ultra.ui.screen
+
+import androidx.compose.animation.*
+import androidx.compose.animation.core.*
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+import androidx.compose.foundation.gestures.detectTapGestures
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.interaction.collectIsPressedAsState
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.lazy.rememberLazyListState
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.ExperimentalMaterialApi
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.*
+import androidx.compose.material3.*
+import androidx.compose.material3.pulltorefresh.PullToRefreshBox
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.draw.shadow
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.input.nestedscroll.nestedScroll
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import androidx.lifecycle.viewmodel.compose.viewModel
+import com.sukisu.ultra.R
+import coil.compose.AsyncImage
+import coil.request.ImageRequest
+import com.ramcosta.composedestinations.annotation.Destination
+import com.ramcosta.composedestinations.annotation.RootGraph
+import com.ramcosta.composedestinations.generated.destinations.AppProfileScreenDestination
+import com.ramcosta.composedestinations.navigation.DestinationsNavigator
+import kotlinx.coroutines.launch
+import com.sukisu.ultra.Natives
+import com.sukisu.ultra.ui.component.SearchAppBar
+import com.sukisu.ultra.ui.theme.CardConfig
+import com.sukisu.ultra.ui.util.ModuleModify
+import com.sukisu.ultra.ui.viewmodel.SuperUserViewModel
+import com.dergoogler.mmrl.ui.component.LabelItem
+import com.dergoogler.mmrl.ui.component.LabelItemDefaults
+
+/**
+ * @author ShirkNeko
+ * @date 2025/5/31.
+ */
+@OptIn(ExperimentalMaterialApi::class, ExperimentalMaterial3Api::class)
+@Destination<RootGraph>
+@Composable
+fun SuperUserScreen(navigator: DestinationsNavigator) {
+    val viewModel = viewModel<SuperUserViewModel>()
+    val scope = rememberCoroutineScope()
+    val scrollBehavior = TopAppBarDefaults.pinnedScrollBehavior(rememberTopAppBarState())
+    val listState = rememberLazyListState()
+    val context = LocalContext.current
+    val snackBarHostState = remember { SnackbarHostState() }
+
+    // 添加备份和还原启动器
+    val backupLauncher = ModuleModify.rememberAllowlistBackupLauncher(context, snackBarHostState)
+    val restoreLauncher = ModuleModify.rememberAllowlistRestoreLauncher(context, snackBarHostState)
+
+    LaunchedEffect(key1 = navigator) {
+        viewModel.search = ""
+        if (viewModel.appList.isEmpty()) {
+            // viewModel.fetchAppList()
+        }
+    }
+
+    LaunchedEffect(viewModel.search) {
+        if (viewModel.search.isEmpty()) {
+            // 取消自动滚动到顶部的行为
+            // listState.scrollToItem(0)
+        }
+    }
+
+    Scaffold(
+        topBar = {
+            SearchAppBar(
+                title = { Text(stringResource(R.string.superuser)) },
+                searchText = viewModel.search,
+                onSearchTextChange = { viewModel.search = it },
+                onClearClick = { viewModel.search = "" },
+                dropdownContent = {
+                    var showDropdown by remember { mutableStateOf(false) }
+
+                    IconButton(
+                        onClick = { showDropdown = true },
+                    ) {
+                        Icon(
+                            imageVector = Icons.Filled.MoreVert,
+                            contentDescription = stringResource(id = R.string.settings),
+                        )
+
+                        DropdownMenu(expanded = showDropdown, onDismissRequest = {
+                            showDropdown = false
+                        }) {
+                            DropdownMenuItem(
+                                text = { Text(stringResource(R.string.refresh)) },
+                                leadingIcon = {
+                                    Icon(
+                                        imageVector = Icons.Filled.Refresh,
+                                        contentDescription = null,
+                                    )
+                                },
+                                onClick = {
+                                    scope.launch {
+                                        viewModel.fetchAppList()
+                                    }
+                                    showDropdown = false
+                                }
+                            )
+                            DropdownMenuItem(
+                                text = {
+                                    Text(
+                                        if (viewModel.showSystemApps) {
+                                            stringResource(R.string.hide_system_apps)
+                                        } else {
+                                            stringResource(R.string.show_system_apps)
+                                        }
+                                    )
+                                },
+                                leadingIcon = {
+                                    Icon(
+                                        imageVector = if (viewModel.showSystemApps)
+                                            Icons.Filled.VisibilityOff else Icons.Filled.Visibility,
+                                        contentDescription = null,
+                                    )
+                                },
+                                onClick = {
+                                    viewModel.showSystemApps = !viewModel.showSystemApps
+                                    showDropdown = false
+                                }
+                            )
+                            HorizontalDivider(thickness = 0.5.dp, modifier = Modifier.padding(vertical = 4.dp))
+                            DropdownMenuItem(
+                                text = { Text(stringResource(R.string.backup_allowlist)) },
+                                leadingIcon = {
+                                    Icon(
+                                        imageVector = Icons.Filled.Save,
+                                        contentDescription = null,
+                                    )
+                                },
+                                onClick = {
+                                    backupLauncher.launch(ModuleModify.createAllowlistBackupIntent())
+                                    showDropdown = false
+                                }
+                            )
+                            DropdownMenuItem(
+                                text = { Text(stringResource(R.string.restore_allowlist)) },
+                                leadingIcon = {
+                                    Icon(
+                                        imageVector = Icons.Filled.RestoreFromTrash,
+                                        contentDescription = null,
+                                    )
+                                },
+                                onClick = {
+                                    restoreLauncher.launch(ModuleModify.createAllowlistRestoreIntent())
+                                    showDropdown = false
+                                }
+                            )
+                        }
+                    }
+                },
+                scrollBehavior = scrollBehavior
+            )
+        },
+        snackbarHost = { SnackbarHost(snackBarHostState) },
+        contentWindowInsets = WindowInsets.safeDrawing.only(WindowInsetsSides.Top + WindowInsetsSides.Horizontal),
+        floatingActionButton = {
+            // 侧边悬浮按钮集合
+            Column(
+                verticalArrangement = Arrangement.spacedBy(8.dp),
+                horizontalAlignment = Alignment.End
+            ) {
+                // 批量操作相关按钮
+                // 只有在批量模式且有选中应用时才显示批量操作按钮
+                if (viewModel.showBatchActions && viewModel.selectedApps.isNotEmpty()) {
+                    // 取消按钮
+                    val cancelInteractionSource = remember { MutableInteractionSource() }
+                    val isCancelPressed by cancelInteractionSource.collectIsPressedAsState()
+
+                    FloatingActionButton(
+                        onClick = {
+                            viewModel.selectedApps = emptySet()
+                            viewModel.showBatchActions = false
+                        },
+                        modifier = Modifier.size(if (isCancelPressed) 56.dp else 40.dp),
+                        containerColor = MaterialTheme.colorScheme.surfaceContainerHigh,
+                        contentColor = MaterialTheme.colorScheme.onSurfaceVariant,
+                        shape = CircleShape,
+                        interactionSource = cancelInteractionSource,
+                        elevation = FloatingActionButtonDefaults.elevation(4.dp, 6.dp)
+                    ) {
+                        Row(
+                            verticalAlignment = Alignment.CenterVertically,
+                            horizontalArrangement = Arrangement.Center
+                        ) {
+                            Icon(
+                                imageVector = Icons.Filled.Close,
+                                contentDescription = stringResource(android.R.string.cancel),
+                                modifier = Modifier.size(24.dp)
+                            )
+                            AnimatedVisibility(
+                                visible = isCancelPressed,
+                                enter = expandHorizontally() + fadeIn(),
+                                exit = shrinkHorizontally() + fadeOut()
+                            ) {
+                                Text(
+                                    stringResource(android.R.string.cancel),
+                                    modifier = Modifier.padding(end = 4.dp),
+                                    style = MaterialTheme.typography.labelMedium
+                                )
+                            }
+                        }
+                    }
+
+                    // 取消授权按钮
+                    val unauthorizeInteractionSource = remember { MutableInteractionSource() }
+                    val isUnauthorizePressed by unauthorizeInteractionSource.collectIsPressedAsState()
+
+                    FloatingActionButton(
+                        onClick = {
+                            scope.launch {
+                                viewModel.updateBatchPermissions(false)
+                            }
+                        },
+                        modifier = Modifier.size(if (isUnauthorizePressed) 56.dp else 40.dp),
+                        containerColor = MaterialTheme.colorScheme.errorContainer,
+                        contentColor = MaterialTheme.colorScheme.onErrorContainer,
+                        shape = CircleShape,
+                        interactionSource = unauthorizeInteractionSource,
+                        elevation = FloatingActionButtonDefaults.elevation(4.dp, 6.dp)
+                    ) {
+                        Row(
+                            verticalAlignment = Alignment.CenterVertically,
+                            horizontalArrangement = Arrangement.Center
+                        ) {
+                            Icon(
+                                imageVector = Icons.Filled.Block,
+                                contentDescription = stringResource(R.string.batch_cancel_authorization),
+                                modifier = Modifier.size(24.dp)
+                            )
+                            AnimatedVisibility(
+                                visible = isUnauthorizePressed,
+                                enter = expandHorizontally() + fadeIn(),
+                                exit = shrinkHorizontally() + fadeOut()
+                            ) {
+                                Text(
+                                    stringResource(R.string.batch_cancel_authorization),
+                                    modifier = Modifier.padding(end = 4.dp),
+                                    style = MaterialTheme.typography.labelMedium
+                                )
+                            }
+                        }
+                    }
+
+                    // 授权按钮
+                    val authorizeInteractionSource = remember { MutableInteractionSource() }
+                    val isAuthorizePressed by authorizeInteractionSource.collectIsPressedAsState()
+
+                    FloatingActionButton(
+                        onClick = {
+                            scope.launch {
+                                viewModel.updateBatchPermissions(true)
+                            }
+                        },
+                        modifier = Modifier.size(if (isAuthorizePressed) 56.dp else 40.dp),
+                        containerColor = MaterialTheme.colorScheme.primaryContainer,
+                        contentColor = MaterialTheme.colorScheme.onPrimaryContainer,
+                        shape = CircleShape,
+                        interactionSource = authorizeInteractionSource,
+                        elevation = FloatingActionButtonDefaults.elevation(4.dp, 6.dp)
+                    ) {
+                        Row(
+                            verticalAlignment = Alignment.CenterVertically,
+                            horizontalArrangement = Arrangement.Center
+                        ) {
+                            Icon(
+                                imageVector = Icons.Filled.Check,
+                                contentDescription = stringResource(R.string.batch_authorization),
+                                modifier = Modifier.size(24.dp)
+                            )
+                            AnimatedVisibility(
+                                visible = isAuthorizePressed,
+                                enter = expandHorizontally() + fadeIn(),
+                                exit = shrinkHorizontally() + fadeOut()
+                            ) {
+                                Text(
+                                    stringResource(R.string.batch_authorization),
+                                    modifier = Modifier.padding(end = 4.dp),
+                                    style = MaterialTheme.typography.labelMedium
+                                )
+                            }
+                        }
+                    }
+
+                    // 添加分隔
+                    Spacer(modifier = Modifier.height(8.dp))
+                }
+
+                if (viewModel.showBatchActions && viewModel.selectedApps.isNotEmpty()) {
+
+                // 在批量操作按钮组中添加卸载模块的按钮
+                // 卸载模块启用按钮
+                val umountEnableInteractionSource = remember { MutableInteractionSource() }
+                val isUmountEnablePressed by umountEnableInteractionSource.collectIsPressedAsState()
+
+                FloatingActionButton(
+                    onClick = {
+                        scope.launch {
+                            viewModel.updateBatchPermissions(
+                                allowSu = false, // 不改变ROOT权限状态
+                                umountModules = true // 启用卸载模块
+                            )
+                        }
+                    },
+                    modifier = Modifier.size(if (isUmountEnablePressed) 56.dp else 40.dp),
+                    containerColor = MaterialTheme.colorScheme.tertiaryContainer,
+                    contentColor = MaterialTheme.colorScheme.onTertiaryContainer,
+                    shape = CircleShape,
+                    interactionSource = umountEnableInteractionSource,
+                    elevation = FloatingActionButtonDefaults.elevation(4.dp, 6.dp)
+                ) {
+                    Row(
+                        verticalAlignment = Alignment.CenterVertically,
+                        horizontalArrangement = Arrangement.Center
+                    ) {
+                        Icon(
+                            imageVector = Icons.Filled.FolderOff,
+                            contentDescription = stringResource(R.string.profile_umount_modules),
+                            modifier = Modifier.size(24.dp)
+                        )
+                        AnimatedVisibility(
+                            visible = isUmountEnablePressed,
+                            enter = expandHorizontally() + fadeIn(),
+                            exit = shrinkHorizontally() + fadeOut()
+                        ) {
+                            Text(
+                                stringResource(R.string.profile_umount_modules),
+                                modifier = Modifier.padding(end = 4.dp),
+                                style = MaterialTheme.typography.labelMedium
+                            )
+                        }
+                    }
+                }
+
+                // 卸载模块禁用按钮
+                val umountDisableInteractionSource = remember { MutableInteractionSource() }
+                val isUmountDisablePressed by umountDisableInteractionSource.collectIsPressedAsState()
+
+                FloatingActionButton(
+                    onClick = {
+                        scope.launch {
+                            viewModel.updateBatchPermissions(
+                                allowSu = false, // 不改变ROOT权限状态
+                                umountModules = false // 禁用卸载模块
+                            )
+                        }
+                    },
+                    modifier = Modifier.size(if (isUmountDisablePressed) 56.dp else 40.dp),
+                    containerColor = MaterialTheme.colorScheme.tertiaryContainer,
+                    contentColor = MaterialTheme.colorScheme.onTertiaryContainer,
+                    shape = CircleShape,
+                    interactionSource = umountDisableInteractionSource,
+                    elevation = FloatingActionButtonDefaults.elevation(4.dp, 6.dp)
+                ) {
+                    Row(
+                        verticalAlignment = Alignment.CenterVertically,
+                        horizontalArrangement = Arrangement.Center
+                    ) {
+                        Icon(
+                            imageVector = Icons.Filled.Folder,
+                            contentDescription = stringResource(R.string.profile_umount_modules_disable),
+                            modifier = Modifier.size(24.dp)
+                        )
+                        AnimatedVisibility(
+                            visible = isUmountDisablePressed,
+                            enter = expandHorizontally() + fadeIn(),
+                            exit = shrinkHorizontally() + fadeOut()
+                        ) {
+                            Text(
+                                stringResource(R.string.profile_umount_modules_disable),
+                                modifier = Modifier.padding(end = 4.dp),
+                                style = MaterialTheme.typography.labelMedium
+                            )
+                        }
+                    }
+                    // 添加分隔
+                    Spacer(modifier = Modifier.height(8.dp))
+                }
+                    }
+
+                // 向上导航按钮
+                val topBtnInteractionSource = remember { MutableInteractionSource() }
+                val isTopBtnPressed by topBtnInteractionSource.collectIsPressedAsState()
+
+                FloatingActionButton(
+                    onClick = {
+                        scope.launch {
+                            listState.animateScrollToItem(0)
+                        }
+                    },
+                    modifier = Modifier.size(if (isTopBtnPressed) 56.dp else 40.dp),
+                    containerColor = MaterialTheme.colorScheme.primaryContainer.copy(alpha = 1f),
+                    contentColor = MaterialTheme.colorScheme.onPrimaryContainer,
+                    shape = CircleShape,
+                    interactionSource = topBtnInteractionSource,
+                    elevation = FloatingActionButtonDefaults.elevation(4.dp, 6.dp)
+                ) {
+                    Row(
+                        verticalAlignment = Alignment.CenterVertically,
+                        horizontalArrangement = Arrangement.Center
+                    ) {
+                        Icon(
+                            imageVector = Icons.Filled.KeyboardArrowUp,
+                            contentDescription = stringResource(R.string.scroll_to_top_description),
+                            modifier = Modifier.size(24.dp)
+                        )
+                        AnimatedVisibility(
+                            visible = isTopBtnPressed,
+                            enter = expandHorizontally() + fadeIn(),
+                            exit = shrinkHorizontally() + fadeOut()
+                        ) {
+                            Text(
+                                stringResource(R.string.scroll_to_top),
+                                modifier = Modifier.padding(end = 4.dp),
+                                style = MaterialTheme.typography.labelMedium
+                            )
+                        }
+                    }
+                }
+
+                // 向下导航按钮
+                val bottomBtnInteractionSource = remember { MutableInteractionSource() }
+                val isBottomBtnPressed by bottomBtnInteractionSource.collectIsPressedAsState()
+
+                FloatingActionButton(
+                    onClick = {
+                        scope.launch {
+                            val lastIndex = viewModel.appList.size - 1
+                            if (lastIndex >= 0) {
+                                listState.animateScrollToItem(lastIndex)
+                            }
+                        }
+                    },
+                    modifier = Modifier.size(if (isBottomBtnPressed) 56.dp else 40.dp),
+                    containerColor = MaterialTheme.colorScheme.primaryContainer.copy(alpha = 1f),
+                    contentColor = MaterialTheme.colorScheme.onPrimaryContainer,
+                    shape = CircleShape,
+                    interactionSource = bottomBtnInteractionSource,
+                    elevation = FloatingActionButtonDefaults.elevation(4.dp, 6.dp)
+                ) {
+                    Row(
+                        verticalAlignment = Alignment.CenterVertically,
+                        horizontalArrangement = Arrangement.Center
+                    ) {
+                        Icon(
+                            imageVector = Icons.Filled.KeyboardArrowDown,
+                            contentDescription = stringResource(R.string.scroll_to_bottom_description),
+                            modifier = Modifier.size(24.dp)
+                        )
+                        AnimatedVisibility(
+                            visible = isBottomBtnPressed,
+                            enter = expandHorizontally() + fadeIn(),
+                            exit = shrinkHorizontally() + fadeOut()
+                        ) {
+                            Text(
+                                stringResource(R.string.scroll_to_bottom),
+                                modifier = Modifier.padding(end = 4.dp),
+                                style = MaterialTheme.typography.labelMedium
+                            )
+                        }
+                    }
+                }
+            }
+        }
+    ) { innerPadding ->
+        PullToRefreshBox(
+            modifier = Modifier.padding(innerPadding),
+            onRefresh = {
+                scope.launch { viewModel.fetchAppList() }
+            },
+            isRefreshing = viewModel.isRefreshing
+        ) {
+            LazyColumn(
+                state = listState,
+                modifier = Modifier
+                    .fillMaxSize()
+                    .nestedScroll(scrollBehavior.nestedScrollConnection),
+                contentPadding = PaddingValues(
+                    top = 8.dp,
+                    bottom = 16.dp
+                )
+            ) {
+                // 获取分组后的应用列表
+                val rootApps = viewModel.appList.filter { it.allowSu }
+                val customApps = viewModel.appList.filter { !it.allowSu && it.hasCustomProfile }
+                val otherApps = viewModel.appList.filter { !it.allowSu && !it.hasCustomProfile }
+
+                // 显示ROOT权限应用组
+                if (rootApps.isNotEmpty()) {
+                    item {
+                        GroupHeader(title = stringResource(R.string.apps_with_root))
+                    }
+
+                    items(rootApps, key = { "root_" + it.packageName + it.uid }) { app ->
+                        AppItem(
+                            app = app,
+                            isSelected = viewModel.selectedApps.contains(app.packageName),
+                            onToggleSelection = { viewModel.toggleAppSelection(app.packageName) },
+                            onSwitchChange = { allowSu ->
+                                scope.launch {
+                                    val profile = Natives.getAppProfile(app.packageName, app.uid)
+                                    val updatedProfile = profile.copy(allowSu = allowSu)
+                                    if (Natives.setAppProfile(updatedProfile)) {
+                                        viewModel.updateAppProfileLocally(app.packageName, updatedProfile)
+                                    }
+                                }
+                            },
+                            onClick = {
+                                if (viewModel.showBatchActions) {
+                                    viewModel.toggleAppSelection(app.packageName)
+                                } else {
+                                    navigator.navigate(AppProfileScreenDestination(app))
+                                }
+                            },
+                            onLongClick = {
+                                // 长按进入多选模式
+                                if (!viewModel.showBatchActions) {
+                                    viewModel.toggleBatchMode()
+                                    viewModel.toggleAppSelection(app.packageName)
+                                }
+                            },
+                            viewModel = viewModel
+                        )
+                    }
+                }
+
+                // 显示自定义配置应用组
+                if (customApps.isNotEmpty()) {
+                    item {
+                        GroupHeader(title = stringResource(R.string.apps_with_custom_profile))
+                    }
+
+                    items(customApps, key = { "custom_" + it.packageName + it.uid }) { app ->
+                        AppItem(
+                            app = app,
+                            isSelected = viewModel.selectedApps.contains(app.packageName),
+                            onToggleSelection = { viewModel.toggleAppSelection(app.packageName) },
+                            onSwitchChange = { allowSu ->
+                                scope.launch {
+                                    val profile = Natives.getAppProfile(app.packageName, app.uid)
+                                    val updatedProfile = profile.copy(allowSu = allowSu)
+                                    if (Natives.setAppProfile(updatedProfile)) {
+                                        viewModel.updateAppProfileLocally(app.packageName, updatedProfile)
+                                    }
+                                }
+                            },
+                            onClick = {
+                                if (viewModel.showBatchActions) {
+                                    viewModel.toggleAppSelection(app.packageName)
+                                } else {
+                                    navigator.navigate(AppProfileScreenDestination(app))
+                                }
+                            },
+                            onLongClick = {
+                                // 长按进入多选模式
+                                if (!viewModel.showBatchActions) {
+                                    viewModel.toggleBatchMode()
+                                    viewModel.toggleAppSelection(app.packageName)
+                                }
+                            },
+                            viewModel = viewModel
+                        )
+                    }
+                }
+
+                // 显示其他应用组
+                if (otherApps.isNotEmpty()) {
+                    item {
+                        GroupHeader(title = stringResource(R.string.other_apps))
+                    }
+
+                    items(otherApps, key = { "other_" + it.packageName + it.uid }) { app ->
+                        AppItem(
+                            app = app,
+                            isSelected = viewModel.selectedApps.contains(app.packageName),
+                            onToggleSelection = { viewModel.toggleAppSelection(app.packageName) },
+                            onSwitchChange = { allowSu ->
+                                scope.launch {
+                                    val profile = Natives.getAppProfile(app.packageName, app.uid)
+                                    val updatedProfile = profile.copy(allowSu = allowSu)
+                                    if (Natives.setAppProfile(updatedProfile)) {
+                                        viewModel.updateAppProfileLocally(app.packageName, updatedProfile)
+                                    }
+                                }
+                            },
+                            onClick = {
+                                if (viewModel.showBatchActions) {
+                                    viewModel.toggleAppSelection(app.packageName)
+                                } else {
+                                    navigator.navigate(AppProfileScreenDestination(app))
+                                }
+                            },
+                            onLongClick = {
+                                // 长按进入多选模式
+                                if (!viewModel.showBatchActions) {
+                                    viewModel.toggleBatchMode()
+                                    viewModel.toggleAppSelection(app.packageName)
+                                }
+                            },
+                            viewModel = viewModel
+                        )
+                    }
+                }
+
+                // 当没有应用显示时显示空状态
+                if (viewModel.appList.isEmpty()) {
+                    item {
+                        Box(
+                            modifier = Modifier
+                                .fillMaxWidth()
+                                .height(400.dp),
+                            contentAlignment = Alignment.Center
+                        ) {
+                            Column(
+                                horizontalAlignment = Alignment.CenterHorizontally,
+                                verticalArrangement = Arrangement.Center
+                            ) {
+                                Icon(
+                                    imageVector = Icons.Filled.Apps,
+                                    contentDescription = null,
+                                    tint = MaterialTheme.colorScheme.primary.copy(alpha = 0.6f),
+                                    modifier = Modifier
+                                        .size(96.dp)
+                                        .padding(bottom = 16.dp)
+                                )
+                                Text(
+                                    text = stringResource(R.string.no_apps_found),
+                                    textAlign = TextAlign.Center,
+                                    style = MaterialTheme.typography.bodyLarge,
+                                    color = MaterialTheme.colorScheme.onSurfaceVariant
+                                )
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+@Composable
+fun GroupHeader(title: String) {
+    Box(
+        modifier = Modifier
+            .fillMaxWidth()
+            .background(MaterialTheme.colorScheme.surfaceContainerHighest.copy(alpha = 0.7f))
+            .padding(horizontal = 16.dp, vertical = 8.dp)
+    ) {
+        Text(
+            text = title,
+            style = TextStyle(
+                fontSize = 14.sp,
+                fontWeight = FontWeight.Bold,
+                color = MaterialTheme.colorScheme.primary
+            )
+        )
+    }
+}
+
+@OptIn(ExperimentalLayoutApi::class)
+@Composable
+private fun AppItem(
+    app: SuperUserViewModel.AppInfo,
+    isSelected: Boolean,
+    onToggleSelection: () -> Unit,
+    onSwitchChange: (Boolean) -> Unit,
+    onClick: () -> Unit,
+    onLongClick: () -> Unit,
+    viewModel: SuperUserViewModel
+) {
+    val cardAlpha = CardConfig.cardAlpha
+
+    val cardColor = if (app.allowSu)
+        MaterialTheme.colorScheme.surfaceVariant.copy(alpha = cardAlpha)
+    else if (app.hasCustomProfile)
+        MaterialTheme.colorScheme.secondaryContainer.copy(alpha = cardAlpha)
+    else
+        MaterialTheme.colorScheme.tertiaryContainer.copy(alpha = cardAlpha)
+
+    Card(
+        colors = CardDefaults.cardColors(containerColor = cardColor),
+        elevation = CardDefaults.cardElevation(defaultElevation = 0.dp),
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(horizontal = 8.dp, vertical = 4.dp)
+            .clip(MaterialTheme.shapes.medium)
+            .shadow(
+                elevation = 0.dp,
+                shape = MaterialTheme.shapes.medium,
+                spotColor = MaterialTheme.colorScheme.primary.copy(alpha = 0.1f)
+            )
+            .then(
+                if (isSelected)
+                    Modifier.border(
+                        width = 2.dp,
+                        color = MaterialTheme.colorScheme.primary,
+                        shape = MaterialTheme.shapes.medium
+                    )
+                else
+                    Modifier
+            )
+            .pointerInput(Unit) {
+                detectTapGestures(
+                    onLongPress = { onLongClick() },
+                    onTap = { onClick() }
+                )
+            }
+    ) {
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(16.dp),
+            verticalAlignment = Alignment.CenterVertically
+        ) {
+            AsyncImage(
+                model = ImageRequest.Builder(LocalContext.current)
+                    .data(app.packageInfo)
+                    .crossfade(true)
+                    .build(),
+                contentDescription = app.label,
+                modifier = Modifier
+                    .padding(end = 16.dp)
+                    .size(48.dp)
+                    .clip(MaterialTheme.shapes.small)
+            )
+
+            Column(
+                modifier = Modifier
+                    .weight(1f)
+                    .padding(end = 8.dp)
+            ) {
+                Text(
+                    text = app.label,
+                    style = MaterialTheme.typography.titleMedium,
+                    color = MaterialTheme.colorScheme.onSurface,
+                    maxLines = 1,
+                    overflow = androidx.compose.ui.text.style.TextOverflow.Ellipsis
+                )
+
+                Text(
+                    text = app.packageName,
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    maxLines = 1,
+                    overflow = androidx.compose.ui.text.style.TextOverflow.Ellipsis
+                )
+
+                FlowRow(
+                    modifier = Modifier.padding(top = 4.dp),
+                    horizontalArrangement = Arrangement.spacedBy(4.dp)
+                ) {
+                    if (app.allowSu) {
+                        LabelItem(text = "ROOT",)
+                    }
+                    if (Natives.uidShouldUmount(app.uid)) {
+                        LabelItem(text = "UNMOUNT", style = LabelItemDefaults.style.copy(
+                            containerColor = MaterialTheme.colorScheme.secondaryContainer,
+                            contentColor = MaterialTheme.colorScheme.onSecondaryContainer
+                            )
+                        )
+                    }
+                    if (app.hasCustomProfile) {
+                        LabelItem(text = "CUSTOM", style = LabelItemDefaults.style.copy(
+                            containerColor = MaterialTheme.colorScheme.onTertiary,
+                            contentColor = MaterialTheme.colorScheme.onTertiaryContainer,
+                            )
+                        )
+                    }
+                }
+            }
+
+            if (!viewModel.showBatchActions) {
+                // 开关交互源
+                val switchInteractionSource = remember { MutableInteractionSource() }
+                val isSwitchPressed by switchInteractionSource.collectIsPressedAsState()
+
+                Row(
+                    verticalAlignment = Alignment.CenterVertically,
+                    horizontalArrangement = Arrangement.End
+                ) {
+                    AnimatedVisibility(
+                        visible = isSwitchPressed,
+                        enter = expandHorizontally() + fadeIn(),
+                        exit = shrinkHorizontally() + fadeOut()
+                    ) {
+                        Text(
+                            text = if (app.allowSu) stringResource(R.string.authorized) else stringResource(R.string.unauthorized),
+                            style = MaterialTheme.typography.labelMedium,
+                            color = if (app.allowSu) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.outline,
+                            modifier = Modifier.padding(end = 4.dp)
+                        )
+                    }
+
+                    Switch(
+                        checked = app.allowSu,
+                        onCheckedChange = onSwitchChange,
+                        interactionSource = switchInteractionSource,
+                        colors = SwitchDefaults.colors(
+                            checkedThumbColor = MaterialTheme.colorScheme.onPrimary,
+                            checkedTrackColor = MaterialTheme.colorScheme.primary,
+                            checkedIconColor = MaterialTheme.colorScheme.primary,
+                            uncheckedThumbColor = MaterialTheme.colorScheme.outline,
+                            uncheckedTrackColor = MaterialTheme.colorScheme.surfaceVariant,
+                            uncheckedIconColor = MaterialTheme.colorScheme.surfaceVariant
+                        )
+                    )
+                }
+            } else {
+                // 复选框交互源
+                val checkboxInteractionSource = remember { MutableInteractionSource() }
+                val isCheckboxPressed by checkboxInteractionSource.collectIsPressedAsState()
+
+                Row(
+                    verticalAlignment = Alignment.CenterVertically,
+                    horizontalArrangement = Arrangement.End
+                ) {
+                    AnimatedVisibility(
+                        visible = isCheckboxPressed,
+                        enter = expandHorizontally() + fadeIn(),
+                        exit = shrinkHorizontally() + fadeOut()
+                    ) {
+                        Text(
+                            text = if (isSelected) stringResource(R.string.selected) else stringResource(R.string.select),
+                            style = MaterialTheme.typography.labelMedium,
+                            color = if (isSelected) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.outline,
+                            modifier = Modifier.padding(end = 4.dp)
+                        )
+                    }
+
+                    Checkbox(
+                        checked = isSelected,
+                        onCheckedChange = { onToggleSelection() },
+                        interactionSource = checkboxInteractionSource,
+                        colors = CheckboxDefaults.colors(
+                            checkedColor = MaterialTheme.colorScheme.primary,
+                            uncheckedColor = MaterialTheme.colorScheme.outline
+                        )
+                    )
+                }
+            }
+        }
+    }
+}
+
+@Composable
+fun LabelText(label: String, backgroundColor: Color) {
+    Box(
+        modifier = Modifier
+            .padding(top = 2.dp, end = 2.dp)
+            .background(
+                backgroundColor,
+                shape = RoundedCornerShape(4.dp)
+            )
+            .clip(RoundedCornerShape(4.dp))
+    ) {
+        Text(
+            text = label,
+            modifier = Modifier.padding(vertical = 2.dp, horizontal = 6.dp),
+            style = TextStyle(
+                fontSize = 10.sp,
+                color = Color.White,
+                fontWeight = FontWeight.Medium
+            )
+        )
+    }
+}

manager/app/src/main/java/com/sukisu/ultra/ui/screen/Template.kt

@@ -1,5 +1,7 @@
-package shirkneko.zako.sukisu.ui.screen
+package com.sukisu.ultra.ui.screen
 
+import android.content.ClipData
+import android.content.ClipboardManager
 import android.widget.Toast
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Column
@@ -31,6 +33,7 @@ import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Scaffold
 import androidx.compose.material3.Text
 import androidx.compose.material3.TopAppBar
+import androidx.compose.material3.TopAppBarColors
 import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.material3.TopAppBarScrollBehavior
 import androidx.compose.material3.pulltorefresh.PullToRefreshBox
@@ -44,11 +47,10 @@ import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.input.nestedscroll.nestedScroll
-import androidx.compose.ui.platform.LocalClipboardManager
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.AnnotatedString
 import androidx.compose.ui.unit.dp
+import androidx.core.content.getSystemService
 import androidx.lifecycle.compose.dropUnlessResumed
 import androidx.lifecycle.viewmodel.compose.viewModel
 import com.ramcosta.composedestinations.annotation.Destination
@@ -59,8 +61,9 @@ import com.ramcosta.composedestinations.result.ResultRecipient
 import com.ramcosta.composedestinations.result.getOr
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
-import shirkneko.zako.sukisu.R
-import shirkneko.zako.sukisu.ui.viewmodel.TemplateViewModel
+import com.sukisu.ultra.R
+import com.sukisu.ultra.ui.theme.CardConfig
+import com.sukisu.ultra.ui.viewmodel.TemplateViewModel
 
 /**
  * @author weishu
@@ -77,7 +80,6 @@ fun AppProfileTemplateScreen(
     val viewModel = viewModel<TemplateViewModel>()
     val scope = rememberCoroutineScope()
     val scrollBehavior = TopAppBarDefaults.pinnedScrollBehavior(rememberTopAppBarState())
-    val cardColor = MaterialTheme.colorScheme.secondaryContainer
 
     LaunchedEffect(Unit) {
         if (viewModel.templateList.isEmpty()) {
@@ -92,10 +94,13 @@ fun AppProfileTemplateScreen(
         }
     }
 
+    val cardColorUse = MaterialTheme.colorScheme.surfaceVariant
+    val cardAlpha = CardConfig.cardAlpha
+
     Scaffold(
         topBar = {
-            val clipboardManager = LocalClipboardManager.current
             val context = LocalContext.current
+            val clipboardManager = context.getSystemService<ClipboardManager>()
             val showToast = fun(msg: String) {
                 scope.launch(Dispatchers.Main) {
                     Toast.makeText(context, msg, Toast.LENGTH_SHORT).show()
@@ -103,24 +108,28 @@ fun AppProfileTemplateScreen(
             }
             TopBar(
                 onBack = dropUnlessResumed { navigator.popBackStack() },
+                colors = TopAppBarDefaults.topAppBarColors(
+                    containerColor = cardColorUse.copy(alpha = cardAlpha),
+                    scrolledContainerColor = cardColorUse.copy(alpha = cardAlpha)
+                ),
                 onSync = {
                     scope.launch { viewModel.fetchTemplates(true) }
                 },
                 onImport = {
-                    clipboardManager.getText()?.text?.let {
-                        if (it.isEmpty()) {
+                    scope.launch {
+                        val clipboardText = clipboardManager?.primaryClip?.getItemAt(0)?.text?.toString()
+                        if (clipboardText.isNullOrEmpty()) {
                             showToast(context.getString(R.string.app_profile_template_import_empty))
-                            return@let
-                        }
-                        scope.launch {
-                            viewModel.importTemplates(
-                                it, {
-                                    showToast(context.getString(R.string.app_profile_template_import_success))
-                                    viewModel.fetchTemplates(false)
-                                },
-                                showToast
-                            )
+                            return@launch
                         }
+                        viewModel.importTemplates(
+                            clipboardText,
+                            {
+                                showToast(context.getString(R.string.app_profile_template_import_success))
+                                viewModel.fetchTemplates(false)
+                            },
+                            showToast
+                        )
                     }
                 },
                 onExport = {
@@ -129,8 +138,8 @@ fun AppProfileTemplateScreen(
                             {
                                 showToast(context.getString(R.string.app_profile_template_export_empty))
                             }
-                        ) {
-                            clipboardManager.setText(AnnotatedString(it))
+                        ) { text ->
+                            clipboardManager?.setPrimaryClip(ClipData.newPlainText("", text))
                         }
                     }
                 },
@@ -149,7 +158,6 @@ fun AppProfileTemplateScreen(
                 },
                 icon = { Icon(Icons.Filled.Add, null) },
                 text = { Text(stringResource(id = R.string.app_profile_template_create)) },
-                containerColor = cardColor.copy(alpha = 1f),
                 contentColor = MaterialTheme.colorScheme.onSecondaryContainer
             )
         },
@@ -199,17 +207,17 @@ private fun TemplateItem(
                 )
                 Text(template.description)
                 FlowRow {
-                    LabelText(label = "UID: ${template.uid}")
-                    LabelText(label = "GID: ${template.gid}")
-                    LabelText(label = template.context)
+                    LabelText(label = "UID: ${template.uid}", backgroundColor = MaterialTheme.colorScheme.surface)
+                    LabelText(label = "GID: ${template.gid}", backgroundColor = MaterialTheme.colorScheme.surface)
+                    LabelText(label = template.context, backgroundColor = MaterialTheme.colorScheme.surface)
                     if (template.local) {
-                        LabelText(label = "local")
+                        LabelText(label = "local", backgroundColor = MaterialTheme.colorScheme.surface)
                     } else {
-                        LabelText(label = "remote")
+                        LabelText(label = "remote", backgroundColor = MaterialTheme.colorScheme.surface)
                     }
                 }
             }
-        },
+        }
     )
 }
 
@@ -220,12 +228,20 @@ private fun TopBar(
     onSync: () -> Unit = {},
     onImport: () -> Unit = {},
     onExport: () -> Unit = {},
+    colors: TopAppBarColors,
     scrollBehavior: TopAppBarScrollBehavior? = null
 ) {
+    val cardColor = MaterialTheme.colorScheme.surfaceContainerLow
+    val cardAlpha = CardConfig.cardAlpha
+
     TopAppBar(
         title = {
             Text(stringResource(R.string.settings_profile_template))
         },
+        colors = TopAppBarDefaults.topAppBarColors(
+            containerColor = cardColor.copy(alpha = cardAlpha),
+            scrolledContainerColor = cardColor.copy(alpha = cardAlpha)
+        ),
         navigationIcon = {
             IconButton(
                 onClick = onBack

manager/app/src/main/java/com/sukisu/ultra/ui/screen/TemplateEditor.kt

@@ -1,4 +1,4 @@
-package shirkneko.zako.sukisu.ui.screen
+package com.sukisu.ultra.ui.screen
 
 import android.widget.Toast
 import androidx.activity.compose.BackHandler
@@ -47,14 +47,14 @@ import androidx.compose.ui.text.input.KeyboardType
 import com.ramcosta.composedestinations.annotation.Destination
 import com.ramcosta.composedestinations.annotation.RootGraph
 import com.ramcosta.composedestinations.result.ResultBackNavigator
-import shirkneko.zako.sukisu.Natives
-import shirkneko.zako.sukisu.R
-import shirkneko.zako.sukisu.ui.component.profile.RootProfileConfig
-import shirkneko.zako.sukisu.ui.util.deleteAppProfileTemplate
-import shirkneko.zako.sukisu.ui.util.getAppProfileTemplate
-import shirkneko.zako.sukisu.ui.util.setAppProfileTemplate
-import shirkneko.zako.sukisu.ui.viewmodel.TemplateViewModel
-import shirkneko.zako.sukisu.ui.viewmodel.toJSON
+import com.sukisu.ultra.Natives
+import com.sukisu.ultra.R
+import com.sukisu.ultra.ui.component.profile.RootProfileConfig
+import com.sukisu.ultra.ui.util.deleteAppProfileTemplate
+import com.sukisu.ultra.ui.util.getAppProfileTemplate
+import com.sukisu.ultra.ui.util.setAppProfileTemplate
+import com.sukisu.ultra.ui.viewmodel.TemplateViewModel
+import com.sukisu.ultra.ui.viewmodel.toJSON
 import androidx.lifecycle.compose.dropUnlessResumed
 
 /**

manager/app/src/main/java/com/sukisu/ultra/ui/theme/CardManage.kt

@@ -0,0 +1,133 @@
+package com.sukisu.ultra.ui.theme
+
+import android.content.Context
+import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.material3.CardDefaults
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.luminance
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+
+object CardConfig {
+    val settingElevation: Dp = 4.dp
+    val customBackgroundElevation: Dp = 0.dp
+
+    // 卡片透明度
+    var cardAlpha by mutableFloatStateOf(1f)
+    // 卡片亮度
+    var cardDim by mutableFloatStateOf(0f)
+    // 卡片阴影
+    var cardElevation by mutableStateOf(settingElevation)
+    var isShadowEnabled by mutableStateOf(true)
+    var isCustomAlphaSet by mutableStateOf(false)
+    var isCustomDimSet by mutableStateOf(false)
+    var isUserDarkModeEnabled by mutableStateOf(false)
+    var isUserLightModeEnabled by mutableStateOf(false)
+    var isCustomBackgroundEnabled by mutableStateOf(false)
+
+    /**
+     * 保存卡片配置到SharedPreferences
+     */
+    fun save(context: Context) {
+        val prefs = context.getSharedPreferences("settings", Context.MODE_PRIVATE)
+        prefs.edit().apply {
+            putFloat("card_alpha", cardAlpha)
+            putFloat("card_dim", cardDim)
+            putBoolean("custom_background_enabled", isCustomBackgroundEnabled)
+            putBoolean("is_shadow_enabled", isShadowEnabled)
+            putBoolean("is_custom_alpha_set", isCustomAlphaSet)
+            putBoolean("is_custom_dim_set", isCustomDimSet)
+            putBoolean("is_user_dark_mode_enabled", isUserDarkModeEnabled)
+            putBoolean("is_user_light_mode_enabled", isUserLightModeEnabled)
+            apply()
+        }
+    }
+
+    /**
+     * 从SharedPreferences加载卡片配置
+     */
+    fun load(context: Context) {
+        val prefs = context.getSharedPreferences("settings", Context.MODE_PRIVATE)
+        cardAlpha = prefs.getFloat("card_alpha", 1f)
+        cardDim = prefs.getFloat("card_dim", 0f)
+        isCustomBackgroundEnabled = prefs.getBoolean("custom_background_enabled", false)
+        isShadowEnabled = prefs.getBoolean("is_shadow_enabled", true)
+        isCustomAlphaSet = prefs.getBoolean("is_custom_alpha_set", false)
+        isCustomDimSet = prefs.getBoolean("is_custom_dim_set", false)
+        isUserDarkModeEnabled = prefs.getBoolean("is_user_dark_mode_enabled", false)
+        isUserLightModeEnabled = prefs.getBoolean("is_user_light_mode_enabled", false)
+        updateShadowEnabled(isShadowEnabled)
+    }
+
+    /**
+     * 更新阴影启用状态
+     */
+    fun updateShadowEnabled(enabled: Boolean) {
+        isShadowEnabled = enabled
+        cardElevation = if (isCustomBackgroundEnabled && cardAlpha != 1f) {
+            customBackgroundElevation
+        } else if (enabled) {
+            settingElevation
+        } else {
+            customBackgroundElevation
+        }
+    }
+
+    /**
+     * 设置深色模式默认值
+     */
+    fun setDarkModeDefaults() {
+        if (!isCustomAlphaSet) {
+            cardAlpha = 1f
+        }
+        if (!isCustomDimSet) {
+            cardDim = 0.5f
+        }
+        updateShadowEnabled(isShadowEnabled)
+    }
+
+    /**
+     * 设置浅色模式默认值
+     */
+    fun setLightModeDefaults() {
+        if (!isCustomAlphaSet) {
+            cardAlpha = 1f
+        }
+        if (!isCustomDimSet) {
+            cardDim = 0f
+        }
+        updateShadowEnabled(isShadowEnabled)
+    }
+}
+
+/**
+ * 获取卡片颜色配置
+ */
+@Composable
+fun getCardColors(originalColor: Color) = CardDefaults.cardColors(
+    containerColor = originalColor.copy(alpha = CardConfig.cardAlpha),
+    contentColor = determineContentColor(originalColor)
+)
+
+/**
+ * 根据背景颜色、主题模式和用户设置确定内容颜色
+ */
+@Composable
+private fun determineContentColor(originalColor: Color): Color {
+    val isDarkTheme = isSystemInDarkTheme()
+    if (ThemeConfig.isThemeChanging) {
+        return if (isDarkTheme) Color.White else Color.Black
+    }
+
+    return when {
+        CardConfig.isUserLightModeEnabled -> Color.Black
+        !isDarkTheme && originalColor.luminance() > 0.5f -> Color.Black
+        isDarkTheme -> Color.White
+        else -> if (originalColor.luminance() > 0.5f) Color.Black else Color.White
+    }
+}

manager/app/src/main/java/com/sukisu/ultra/ui/theme/Color.kt

@@ -0,0 +1,615 @@
+package com.sukisu.ultra.ui.theme
+
+import androidx.compose.ui.graphics.Color
+
+sealed class ThemeColors {
+    // 浅色
+    abstract val primaryLight: Color
+    abstract val onPrimaryLight: Color
+    abstract val primaryContainerLight: Color
+    abstract val onPrimaryContainerLight: Color
+    abstract val secondaryLight: Color
+    abstract val onSecondaryLight: Color
+    abstract val secondaryContainerLight: Color
+    abstract val onSecondaryContainerLight: Color
+    abstract val tertiaryLight: Color
+    abstract val onTertiaryLight: Color
+    abstract val tertiaryContainerLight: Color
+    abstract val onTertiaryContainerLight: Color
+    abstract val errorLight: Color
+    abstract val onErrorLight: Color
+    abstract val errorContainerLight: Color
+    abstract val onErrorContainerLight: Color
+    abstract val backgroundLight: Color
+    abstract val onBackgroundLight: Color
+    abstract val surfaceLight: Color
+    abstract val onSurfaceLight: Color
+    abstract val surfaceVariantLight: Color
+    abstract val onSurfaceVariantLight: Color
+    abstract val outlineLight: Color
+    abstract val outlineVariantLight: Color
+    abstract val scrimLight: Color
+    abstract val inverseSurfaceLight: Color
+    abstract val inverseOnSurfaceLight: Color
+    abstract val inversePrimaryLight: Color
+    abstract val surfaceDimLight: Color
+    abstract val surfaceBrightLight: Color
+    abstract val surfaceContainerLowestLight: Color
+    abstract val surfaceContainerLowLight: Color
+    abstract val surfaceContainerLight: Color
+    abstract val surfaceContainerHighLight: Color
+    abstract val surfaceContainerHighestLight: Color
+    // 深色
+    abstract val primaryDark: Color
+    abstract val onPrimaryDark: Color
+    abstract val primaryContainerDark: Color
+    abstract val onPrimaryContainerDark: Color
+    abstract val secondaryDark: Color
+    abstract val onSecondaryDark: Color
+    abstract val secondaryContainerDark: Color
+    abstract val onSecondaryContainerDark: Color
+    abstract val tertiaryDark: Color
+    abstract val onTertiaryDark: Color
+    abstract val tertiaryContainerDark: Color
+    abstract val onTertiaryContainerDark: Color
+    abstract val errorDark: Color
+    abstract val onErrorDark: Color
+    abstract val errorContainerDark: Color
+    abstract val onErrorContainerDark: Color
+    abstract val backgroundDark: Color
+    abstract val onBackgroundDark: Color
+    abstract val surfaceDark: Color
+    abstract val onSurfaceDark: Color
+    abstract val surfaceVariantDark: Color
+    abstract val onSurfaceVariantDark: Color
+    abstract val outlineDark: Color
+    abstract val outlineVariantDark: Color
+    abstract val scrimDark: Color
+    abstract val inverseSurfaceDark: Color
+    abstract val inverseOnSurfaceDark: Color
+    abstract val inversePrimaryDark: Color
+    abstract val surfaceDimDark: Color
+    abstract val surfaceBrightDark: Color
+    abstract val surfaceContainerLowestDark: Color
+    abstract val surfaceContainerLowDark: Color
+    abstract val surfaceContainerDark: Color
+    abstract val surfaceContainerHighDark: Color
+    abstract val surfaceContainerHighestDark: Color
+
+    // 默认主题 (蓝色)
+    object Default : ThemeColors() {
+        override val primaryLight = Color(0xFF415F91)
+        override val onPrimaryLight = Color(0xFFFFFFFF)
+        override val primaryContainerLight = Color(0xFFD6E3FF)
+        override val onPrimaryContainerLight = Color(0xFF284777)
+        override val secondaryLight = Color(0xFF565F71)
+        override val onSecondaryLight = Color(0xFFFFFFFF)
+        override val secondaryContainerLight = Color(0xFFDAE2F9)
+        override val onSecondaryContainerLight = Color(0xFF3E4759)
+        override val tertiaryLight = Color(0xFF705575)
+        override val onTertiaryLight = Color(0xFFFFFFFF)
+        override val tertiaryContainerLight = Color(0xFFFAD8FD)
+        override val onTertiaryContainerLight = Color(0xFF573E5C)
+        override val errorLight = Color(0xFFBA1A1A)
+        override val onErrorLight = Color(0xFFFFFFFF)
+        override val errorContainerLight = Color(0xFFFFDAD6)
+        override val onErrorContainerLight = Color(0xFF93000A)
+        override val backgroundLight = Color(0xFFF9F9FF)
+        override val onBackgroundLight = Color(0xFF191C20)
+        override val surfaceLight = Color(0xFFF9F9FF)
+        override val onSurfaceLight = Color(0xFF191C20)
+        override val surfaceVariantLight = Color(0xFFE0E2EC)
+        override val onSurfaceVariantLight = Color(0xFF44474E)
+        override val outlineLight = Color(0xFF74777F)
+        override val outlineVariantLight = Color(0xFFC4C6D0)
+        override val scrimLight = Color(0xFF000000)
+        override val inverseSurfaceLight = Color(0xFF2E3036)
+        override val inverseOnSurfaceLight = Color(0xFFF0F0F7)
+        override val inversePrimaryLight = Color(0xFFAAC7FF)
+        override val surfaceDimLight = Color(0xFFD9D9E0)
+        override val surfaceBrightLight = Color(0xFFF9F9FF)
+        override val surfaceContainerLowestLight = Color(0xFFFFFFFF)
+        override val surfaceContainerLowLight = Color(0xFFF3F3FA)
+        override val surfaceContainerLight = Color(0xFFEDEDF4)
+        override val surfaceContainerHighLight = Color(0xFFE7E8EE)
+        override val surfaceContainerHighestLight = Color(0xFFE2E2E9)
+
+        override val primaryDark = Color(0xFFAAC7FF)
+        override val onPrimaryDark = Color(0xFF0A305F)
+        override val primaryContainerDark = Color(0xFF284777)
+        override val onPrimaryContainerDark = Color(0xFFD6E3FF)
+        override val secondaryDark = Color(0xFFBEC6DC)
+        override val onSecondaryDark = Color(0xFF283141)
+        override val secondaryContainerDark = Color(0xFF3E4759)
+        override val onSecondaryContainerDark = Color(0xFFDAE2F9)
+        override val tertiaryDark = Color(0xFFDDBCE0)
+        override val onTertiaryDark = Color(0xFF3F2844)
+        override val tertiaryContainerDark = Color(0xFF573E5C)
+        override val onTertiaryContainerDark = Color(0xFFFAD8FD)
+        override val errorDark = Color(0xFFFFB4AB)
+        override val onErrorDark = Color(0xFF690005)
+        override val errorContainerDark = Color(0xFF93000A)
+        override val onErrorContainerDark = Color(0xFFFFDAD6)
+        override val backgroundDark = Color(0xFF111318)
+        override val onBackgroundDark = Color(0xFFE2E2E9)
+        override val surfaceDark = Color(0xFF111318)
+        override val onSurfaceDark = Color(0xFFE2E2E9)
+        override val surfaceVariantDark = Color(0xFF44474E)
+        override val onSurfaceVariantDark = Color(0xFFC4C6D0)
+        override val outlineDark = Color(0xFF8E9099)
+        override val outlineVariantDark = Color(0xFF44474E)
+        override val scrimDark = Color(0xFF000000)
+        override val inverseSurfaceDark = Color(0xFFE2E2E9)
+        override val inverseOnSurfaceDark = Color(0xFF2E3036)
+        override val inversePrimaryDark = Color(0xFF415F91)
+        override val surfaceDimDark = Color(0xFF111318)
+        override val surfaceBrightDark = Color(0xFF37393E)
+        override val surfaceContainerLowestDark = Color(0xFF0C0E13)
+        override val surfaceContainerLowDark = Color(0xFF191C20)
+        override val surfaceContainerDark = Color(0xFF1D2024)
+        override val surfaceContainerHighDark = Color(0xFF282A2F)
+        override val surfaceContainerHighestDark = Color(0xFF33353A)
+    }
+
+    // 绿色主题
+    object Green : ThemeColors() {
+        override val primaryLight = Color(0xFF4C662B)
+        override val onPrimaryLight = Color(0xFFFFFFFF)
+        override val primaryContainerLight = Color(0xFFCDEDA3)
+        override val onPrimaryContainerLight = Color(0xFF354E16)
+        override val secondaryLight = Color(0xFF586249)
+        override val onSecondaryLight = Color(0xFFFFFFFF)
+        override val secondaryContainerLight = Color(0xFFDCE7C8)
+        override val onSecondaryContainerLight = Color(0xFF404A33)
+        override val tertiaryLight = Color(0xFF386663)
+        override val onTertiaryLight = Color(0xFFFFFFFF)
+        override val tertiaryContainerLight = Color(0xFFBCECE7)
+        override val onTertiaryContainerLight = Color(0xFF1F4E4B)
+        override val errorLight = Color(0xFFBA1A1A)
+        override val onErrorLight = Color(0xFFFFFFFF)
+        override val errorContainerLight = Color(0xFFFFDAD6)
+        override val onErrorContainerLight = Color(0xFF93000A)
+        override val backgroundLight = Color(0xFFF9FAEF)
+        override val onBackgroundLight = Color(0xFF1A1C16)
+        override val surfaceLight = Color(0xFFF9FAEF)
+        override val onSurfaceLight = Color(0xFF1A1C16)
+        override val surfaceVariantLight = Color(0xFFE1E4D5)
+        override val onSurfaceVariantLight = Color(0xFF44483D)
+        override val outlineLight = Color(0xFF75796C)
+        override val outlineVariantLight = Color(0xFFC5C8BA)
+        override val scrimLight = Color(0xFF000000)
+        override val inverseSurfaceLight = Color(0xFF2F312A)
+        override val inverseOnSurfaceLight = Color(0xFFF1F2E6)
+        override val inversePrimaryLight = Color(0xFFB1D18A)
+        override val surfaceDimLight = Color(0xFFDADBD0)
+        override val surfaceBrightLight = Color(0xFFF9FAEF)
+        override val surfaceContainerLowestLight = Color(0xFFFFFFFF)
+        override val surfaceContainerLowLight = Color(0xFFF3F4E9)
+        override val surfaceContainerLight = Color(0xFFEEEFE3)
+        override val surfaceContainerHighLight = Color(0xFFE8E9DE)
+        override val surfaceContainerHighestLight = Color(0xFFE2E3D8)
+
+        override val primaryDark = Color(0xFFB1D18A)
+        override val onPrimaryDark = Color(0xFF1F3701)
+        override val primaryContainerDark = Color(0xFF354E16)
+        override val onPrimaryContainerDark = Color(0xFFCDEDA3)
+        override val secondaryDark = Color(0xFFBFCBAD)
+        override val onSecondaryDark = Color(0xFF2A331E)
+        override val secondaryContainerDark = Color(0xFF404A33)
+        override val onSecondaryContainerDark = Color(0xFFDCE7C8)
+        override val tertiaryDark = Color(0xFFA0D0CB)
+        override val onTertiaryDark = Color(0xFF003735)
+        override val tertiaryContainerDark = Color(0xFF1F4E4B)
+        override val onTertiaryContainerDark = Color(0xFFBCECE7)
+        override val errorDark = Color(0xFFFFB4AB)
+        override val onErrorDark = Color(0xFF690005)
+        override val errorContainerDark = Color(0xFF93000A)
+        override val onErrorContainerDark = Color(0xFFFFDAD6)
+        override val backgroundDark = Color(0xFF12140E)
+        override val onBackgroundDark = Color(0xFFE2E3D8)
+        override val surfaceDark = Color(0xFF12140E)
+        override val onSurfaceDark = Color(0xFFE2E3D8)
+        override val surfaceVariantDark = Color(0xFF44483D)
+        override val onSurfaceVariantDark = Color(0xFFC5C8BA)
+        override val outlineDark = Color(0xFF8F9285)
+        override val outlineVariantDark = Color(0xFF44483D)
+        override val scrimDark = Color(0xFF000000)
+        override val inverseSurfaceDark = Color(0xFFE2E3D8)
+        override val inverseOnSurfaceDark = Color(0xFF2F312A)
+        override val inversePrimaryDark = Color(0xFF4C662B)
+        override val surfaceDimDark = Color(0xFF12140E)
+        override val surfaceBrightDark = Color(0xFF383A32)
+        override val surfaceContainerLowestDark = Color(0xFF0C0F09)
+        override val surfaceContainerLowDark = Color(0xFF1A1C16)
+        override val surfaceContainerDark = Color(0xFF1E201A)
+        override val surfaceContainerHighDark = Color(0xFF282B24)
+        override val surfaceContainerHighestDark = Color(0xFF33362E)
+    }
+
+    // 紫色主题
+    object Purple : ThemeColors() {
+        override val primaryLight = Color(0xFF7C4E7E)
+        override val onPrimaryLight = Color(0xFFFFFFFF)
+        override val primaryContainerLight = Color(0xFFFFD6FC)
+        override val onPrimaryContainerLight = Color(0xFF623765)
+        override val secondaryLight = Color(0xFF6C586B)
+        override val onSecondaryLight = Color(0xFFFFFFFF)
+        override val secondaryContainerLight = Color(0xFFF5DBF1)
+        override val onSecondaryContainerLight = Color(0xFF534152)
+        override val tertiaryLight = Color(0xFF825249)
+        override val onTertiaryLight = Color(0xFFFFFFFF)
+        override val tertiaryContainerLight = Color(0xFFFFDAD4)
+        override val onTertiaryContainerLight = Color(0xFF673B33)
+        override val errorLight = Color(0xFFBA1A1A)
+        override val onErrorLight = Color(0xFFFFFFFF)
+        override val errorContainerLight = Color(0xFFFFDAD6)
+        override val onErrorContainerLight = Color(0xFF93000A)
+        override val backgroundLight = Color(0xFFFFF7FA)
+        override val onBackgroundLight = Color(0xFF1F1A1F)
+        override val surfaceLight = Color(0xFFFFF7FA)
+        override val onSurfaceLight = Color(0xFF1F1A1F)
+        override val surfaceVariantLight = Color(0xFFEDDFE8)
+        override val onSurfaceVariantLight = Color(0xFF4D444C)
+        override val outlineLight = Color(0xFF7F747C)
+        override val outlineVariantLight = Color(0xFFD0C3CC)
+        override val scrimLight = Color(0xFF000000)
+        override val inverseSurfaceLight = Color(0xFF352F34)
+        override val inverseOnSurfaceLight = Color(0xFFF9EEF4)
+        override val inversePrimaryLight = Color(0xFFECB4EC)
+        override val surfaceDimLight = Color(0xFFE2D7DE)
+        override val surfaceBrightLight = Color(0xFFFFF7FA)
+        override val surfaceContainerLowestLight = Color(0xFFFFFFFF)
+        override val surfaceContainerLowLight = Color(0xFFFCF0F7)
+        override val surfaceContainerLight = Color(0xFFF6EBF2)
+        override val surfaceContainerHighLight = Color(0xFFF0E5EC)
+        override val surfaceContainerHighestLight = Color(0xFFEBDFE6)
+
+        override val primaryDark = Color(0xFFECB4EC)
+        override val onPrimaryDark = Color(0xFF49204D)
+        override val primaryContainerDark = Color(0xFF623765)
+        override val onPrimaryContainerDark = Color(0xFFFFD6FC)
+        override val secondaryDark = Color(0xFFD8BFD5)
+        override val onSecondaryDark = Color(0xFF3B2B3B)
+        override val secondaryContainerDark = Color(0xFF534152)
+        override val onSecondaryContainerDark = Color(0xFFF5DBF1)
+        override val tertiaryDark = Color(0xFFF6B8AD)
+        override val onTertiaryDark = Color(0xFF4C251F)
+        override val tertiaryContainerDark = Color(0xFF673B33)
+        override val onTertiaryContainerDark = Color(0xFFFFDAD4)
+        override val errorDark = Color(0xFFFFB4AB)
+        override val onErrorDark = Color(0xFF690005)
+        override val errorContainerDark = Color(0xFF93000A)
+        override val onErrorContainerDark = Color(0xFFFFDAD6)
+        override val backgroundDark = Color(0xFF171216)
+        override val onBackgroundDark = Color(0xFFEBDFE6)
+        override val surfaceDark = Color(0xFF171216)
+        override val onSurfaceDark = Color(0xFFEBDFE6)
+        override val surfaceVariantDark = Color(0xFF4D444C)
+        override val onSurfaceVariantDark = Color(0xFFD0C3CC)
+        override val outlineDark = Color(0xFF998D96)
+        override val outlineVariantDark = Color(0xFF4D444C)
+        override val scrimDark = Color(0xFF000000)
+        override val inverseSurfaceDark = Color(0xFFEBDFE6)
+        override val inverseOnSurfaceDark = Color(0xFF352F34)
+        override val inversePrimaryDark = Color(0xFF7C4E7E)
+        override val surfaceDimDark = Color(0xFF171216)
+        override val surfaceBrightDark = Color(0xFF3E373D)
+        override val surfaceContainerLowestDark = Color(0xFF110D11)
+        override val surfaceContainerLowDark = Color(0xFF1F1A1F)
+        override val surfaceContainerDark = Color(0xFF231E23)
+        override val surfaceContainerHighDark = Color(0xFF2E282D)
+        override val surfaceContainerHighestDark = Color(0xFF393338)
+    }
+
+    // 橙色主题
+    object Orange : ThemeColors() {
+        override val primaryLight = Color(0xFF8B4F24)
+        override val onPrimaryLight = Color(0xFFFFFFFF)
+        override val primaryContainerLight = Color(0xFFFFDCC7)
+        override val onPrimaryContainerLight = Color(0xFF6E390E)
+        override val secondaryLight = Color(0xFF755846)
+        override val onSecondaryLight = Color(0xFFFFFFFF)
+        override val secondaryContainerLight = Color(0xFFFFDCC7)
+        override val onSecondaryContainerLight = Color(0xFF5B4130)
+        override val tertiaryLight = Color(0xFF865219)
+        override val onTertiaryLight = Color(0xFFFFFFFF)
+        override val tertiaryContainerLight = Color(0xFFFFDCBF)
+        override val onTertiaryContainerLight = Color(0xFF6A3B01)
+        override val errorLight = Color(0xFFBA1A1A)
+        override val onErrorLight = Color(0xFFFFFFFF)
+        override val errorContainerLight = Color(0xFFFFDAD6)
+        override val onErrorContainerLight = Color(0xFF93000A)
+        override val backgroundLight = Color(0xFFFFF8F5)
+        override val onBackgroundLight = Color(0xFF221A15)
+        override val surfaceLight = Color(0xFFFFF8F5)
+        override val onSurfaceLight = Color(0xFF221A15)
+        override val surfaceVariantLight = Color(0xFFF4DED3)
+        override val onSurfaceVariantLight = Color(0xFF52443C)
+        override val outlineLight = Color(0xFF84746A)
+        override val outlineVariantLight = Color(0xFFD7C3B8)
+        override val scrimLight = Color(0xFF000000)
+        override val inverseSurfaceLight = Color(0xFF382E29)
+        override val inverseOnSurfaceLight = Color(0xFFFFEDE5)
+        override val inversePrimaryLight = Color(0xFFFFB787)
+        override val surfaceDimLight = Color(0xFFE7D7CE)
+        override val surfaceBrightLight = Color(0xFFFFF8F5)
+        override val surfaceContainerLowestLight = Color(0xFFFFFFFF)
+        override val surfaceContainerLowLight = Color(0xFFFFF1EA)
+        override val surfaceContainerLight = Color(0xFFFCEBE2)
+        override val surfaceContainerHighLight = Color(0xFFF6E5DC)
+        override val surfaceContainerHighestLight = Color(0xFFF0DFD7)
+
+        override val primaryDark = Color(0xFFFFB787)
+        override val onPrimaryDark = Color(0xFF502400)
+        override val primaryContainerDark = Color(0xFF6E390E)
+        override val onPrimaryContainerDark = Color(0xFFFFDCC7)
+        override val secondaryDark = Color(0xFFE5BFA8)
+        override val onSecondaryDark = Color(0xFF422B1B)
+        override val secondaryContainerDark = Color(0xFF5B4130)
+        override val onSecondaryContainerDark = Color(0xFFFFDCC7)
+        override val tertiaryDark = Color(0xFFFDB876)
+        override val onTertiaryDark = Color(0xFF4B2800)
+        override val tertiaryContainerDark = Color(0xFF6A3B01)
+        override val onTertiaryContainerDark = Color(0xFFFFDCBF)
+        override val errorDark = Color(0xFFFFB4AB)
+        override val onErrorDark = Color(0xFF690005)
+        override val errorContainerDark = Color(0xFF93000A)
+        override val onErrorContainerDark = Color(0xFFFFDAD6)
+        override val backgroundDark = Color(0xFF19120D)
+        override val onBackgroundDark = Color(0xFFF0DFD7)
+        override val surfaceDark = Color(0xFF19120D)
+        override val onSurfaceDark = Color(0xFFF0DFD7)
+        override val surfaceVariantDark = Color(0xFF52443C)
+        override val onSurfaceVariantDark = Color(0xFFD7C3B8)
+        override val outlineDark = Color(0xFF9F8D83)
+        override val outlineVariantDark = Color(0xFF52443C)
+        override val scrimDark = Color(0xFF000000)
+        override val inverseSurfaceDark = Color(0xFFF0DFD7)
+        override val inverseOnSurfaceDark = Color(0xFF382E29)
+        override val inversePrimaryDark = Color(0xFF8B4F24)
+        override val surfaceDimDark = Color(0xFF19120D)
+        override val surfaceBrightDark = Color(0xFF413731)
+        override val surfaceContainerLowestDark = Color(0xFF140D08)
+        override val surfaceContainerLowDark = Color(0xFF221A15)
+        override val surfaceContainerDark = Color(0xFF261E19)
+        override val surfaceContainerHighDark = Color(0xFF312823)
+        override val surfaceContainerHighestDark = Color(0xFF3D332D)
+    }
+
+    // 粉色主题
+    object Pink : ThemeColors() {
+        override val primaryLight = Color(0xFF8C4A60)
+        override val onPrimaryLight = Color(0xFFFFFFFF)
+        override val primaryContainerLight = Color(0xFFFFD9E2)
+        override val onPrimaryContainerLight = Color(0xFF703348)
+        override val secondaryLight = Color(0xFF8B4A62)
+        override val onSecondaryLight = Color(0xFFFFFFFF)
+        override val secondaryContainerLight = Color(0xFFFFD9E3)
+        override val onSecondaryContainerLight = Color(0xFF6F334B)
+        override val tertiaryLight = Color(0xFF8B4A62)
+        override val onTertiaryLight = Color(0xFFFFFFFF)
+        override val tertiaryContainerLight = Color(0xFFFFD9E3)
+        override val onTertiaryContainerLight = Color(0xFF6F334B)
+        override val errorLight = Color(0xFFBA1A1A)
+        override val onErrorLight = Color(0xFFFFFFFF)
+        override val errorContainerLight = Color(0xFFFFDAD6)
+        override val onErrorContainerLight = Color(0xFF93000A)
+        override val backgroundLight = Color(0xFFFFF8F8)
+        override val onBackgroundLight = Color(0xFF22191B)
+        override val surfaceLight = Color(0xFFFFF8F8)
+        override val onSurfaceLight = Color(0xFF22191B)
+        override val surfaceVariantLight = Color(0xFFF2DDE1)
+        override val onSurfaceVariantLight = Color(0xFF514346)
+        override val outlineLight = Color(0xFF837377)
+        override val outlineVariantLight = Color(0xFFD5C2C5)
+        override val scrimLight = Color(0xFF000000)
+        override val inverseSurfaceLight = Color(0xFF372E30)
+        override val inverseOnSurfaceLight = Color(0xFFFDEDEF)
+        override val inversePrimaryLight = Color(0xFFFFB1C7)
+        override val surfaceDimLight = Color(0xFFE6D6D9)
+        override val surfaceBrightLight = Color(0xFFFFF8F8)
+        override val surfaceContainerLowestLight = Color(0xFFFFFFFF)
+        override val surfaceContainerLowLight = Color(0xFFFFF0F2)
+        override val surfaceContainerLight = Color(0xFFFBEAED)
+        override val surfaceContainerHighLight = Color(0xFFF5E4E7)
+        override val surfaceContainerHighestLight = Color(0xFFEFDFE1)
+
+        override val primaryDark = Color(0xFFFFB1C7)
+        override val onPrimaryDark = Color(0xFF541D32)
+        override val primaryContainerDark = Color(0xFF703348)
+        override val onPrimaryContainerDark = Color(0xFFFFD9E2)
+        override val secondaryDark = Color(0xFFFFB0CB)
+        override val onSecondaryDark = Color(0xFF541D34)
+        override val secondaryContainerDark = Color(0xFF6F334B)
+        override val onSecondaryContainerDark = Color(0xFFFFD9E3)
+        override val tertiaryDark = Color(0xFFFFB0CB)
+        override val onTertiaryDark = Color(0xFF541D34)
+        override val tertiaryContainerDark = Color(0xFF6F334B)
+        override val onTertiaryContainerDark = Color(0xFFFFD9E3)
+        override val errorDark = Color(0xFFFFB4AB)
+        override val onErrorDark = Color(0xFF690005)
+        override val errorContainerDark = Color(0xFF93000A)
+        override val onErrorContainerDark = Color(0xFFFFDAD6)
+        override val backgroundDark = Color(0xFF191113)
+        override val onBackgroundDark = Color(0xFFEFDFE1)
+        override val surfaceDark = Color(0xFF191113)
+        override val onSurfaceDark = Color(0xFFEFDFE1)
+        override val surfaceVariantDark = Color(0xFF514346)
+        override val onSurfaceVariantDark = Color(0xFFD5C2C5)
+        override val outlineDark = Color(0xFF9E8C90)
+        override val outlineVariantDark = Color(0xFF514346)
+        override val scrimDark = Color(0xFF000000)
+        override val inverseSurfaceDark = Color(0xFFEFDFE1)
+        override val inverseOnSurfaceDark = Color(0xFF372E30)
+        override val inversePrimaryDark = Color(0xFF8C4A60)
+        override val surfaceDimDark = Color(0xFF191113)
+        override val surfaceBrightDark = Color(0xFF413739)
+        override val surfaceContainerLowestDark = Color(0xFF140C0E)
+        override val surfaceContainerLowDark = Color(0xFF22191B)
+        override val surfaceContainerDark = Color(0xFF261D1F)
+        override val surfaceContainerHighDark = Color(0xFF31282A)
+        override val surfaceContainerHighestDark = Color(0xFF3C3234)
+    }
+
+    // 灰色主题
+    object Gray : ThemeColors() {
+        override val primaryLight = Color(0xFF5B5C5C)
+        override val onPrimaryLight = Color(0xFFFFFFFF)
+        override val primaryContainerLight = Color(0xFF747474)
+        override val onPrimaryContainerLight = Color(0xFFFEFCFC)
+        override val secondaryLight = Color(0xFF5F5E5E)
+        override val onSecondaryLight = Color(0xFFFFFFFF)
+        override val secondaryContainerLight = Color(0xFFE4E2E1)
+        override val onSecondaryContainerLight = Color(0xFF656464)
+        override val tertiaryLight = Color(0xFF5E5B5D)
+        override val onTertiaryLight = Color(0xFFFFFFFF)
+        override val tertiaryContainerLight = Color(0xFF777375)
+        override val onTertiaryContainerLight = Color(0xFFFFFBFF)
+        override val errorLight = Color(0xFFBA1A1A)
+        override val onErrorLight = Color(0xFFFFFFFF)
+        override val errorContainerLight = Color(0xFFFFDAD6)
+        override val onErrorContainerLight = Color(0xFF93000A)
+        override val backgroundLight = Color(0xFFFCF8F8)
+        override val onBackgroundLight = Color(0xFF1C1B1B)
+        override val surfaceLight = Color(0xFFFCF8F8)
+        override val onSurfaceLight = Color(0xFF1C1B1B)
+        override val surfaceVariantLight = Color(0xFFE0E3E3)
+        override val onSurfaceVariantLight = Color(0xFF444748)
+        override val outlineLight = Color(0xFF747878)
+        override val outlineVariantLight = Color(0xFFC4C7C7)
+        override val scrimLight = Color(0xFF000000)
+        override val inverseSurfaceLight = Color(0xFF313030)
+        override val inverseOnSurfaceLight = Color(0xFFF4F0EF)
+        override val inversePrimaryLight = Color(0xFFC7C6C6)
+        override val surfaceDimLight = Color(0xFFDDD9D8)
+        override val surfaceBrightLight = Color(0xFFFCF8F8)
+        override val surfaceContainerLowestLight = Color(0xFFFFFFFF)
+        override val surfaceContainerLowLight = Color(0xFFF7F3F2)
+        override val surfaceContainerLight = Color(0xFFF1EDEC)
+        override val surfaceContainerHighLight = Color(0xFFEBE7E7)
+        override val surfaceContainerHighestLight = Color(0xFFE5E2E1)
+
+        override val primaryDark = Color(0xFFC7C6C6)
+        override val onPrimaryDark = Color(0xFF303031)
+        override val primaryContainerDark = Color(0xFF919190)
+        override val onPrimaryContainerDark = Color(0xFF161718)
+        override val secondaryDark = Color(0xFFC8C6C5)
+        override val onSecondaryDark = Color(0xFF303030)
+        override val secondaryContainerDark = Color(0xFF474746)
+        override val onSecondaryContainerDark = Color(0xFFB7B5B4)
+        override val tertiaryDark = Color(0xFFCAC5C7)
+        override val onTertiaryDark = Color(0xFF323031)
+        override val tertiaryContainerDark = Color(0xFF948F91)
+        override val onTertiaryContainerDark = Color(0xFF181718)
+        override val errorDark = Color(0xFFFFB4AB)
+        override val onErrorDark = Color(0xFF690005)
+        override val errorContainerDark = Color(0xFF93000A)
+        override val onErrorContainerDark = Color(0xFFFFDAD6)
+        override val backgroundDark = Color(0xFF141313)
+        override val onBackgroundDark = Color(0xFFE5E2E1)
+        override val surfaceDark = Color(0xFF141313)
+        override val onSurfaceDark = Color(0xFFE5E2E1)
+        override val surfaceVariantDark = Color(0xFF444748)
+        override val onSurfaceVariantDark = Color(0xFFC4C7C7)
+        override val outlineDark = Color(0xFF8E9192)
+        override val outlineVariantDark = Color(0xFF444748)
+        override val scrimDark = Color(0xFF000000)
+        override val inverseSurfaceDark = Color(0xFFE5E2E1)
+        override val inverseOnSurfaceDark = Color(0xFF313030)
+        override val inversePrimaryDark = Color(0xFF5E5E5E)
+        override val surfaceDimDark = Color(0xFF141313)
+        override val surfaceBrightDark = Color(0xFF3A3939)
+        override val surfaceContainerLowestDark = Color(0xFF0E0E0E)
+        override val surfaceContainerLowDark = Color(0xFF1C1B1B)
+        override val surfaceContainerDark = Color(0xFF201F1F)
+        override val surfaceContainerHighDark = Color(0xFF2A2A2A)
+        override val surfaceContainerHighestDark = Color(0xFF353434)
+    }
+
+    // 黄色主题
+    object Yellow : ThemeColors() {
+        override val primaryLight = Color(0xFF6D5E0F)
+        override val onPrimaryLight = Color(0xFFFFFFFF)
+        override val primaryContainerLight = Color(0xFFF8E288)
+        override val onPrimaryContainerLight = Color(0xFF534600)
+        override val secondaryLight = Color(0xFF6D5E0F)
+        override val onSecondaryLight = Color(0xFFFFFFFF)
+        override val secondaryContainerLight = Color(0xFFF7E388)
+        override val onSecondaryContainerLight = Color(0xFF534600)
+        override val tertiaryLight = Color(0xFF685F13)
+        override val onTertiaryLight = Color(0xFFFFFFFF)
+        override val tertiaryContainerLight = Color(0xFFF1E58A)
+        override val onTertiaryContainerLight = Color(0xFF4F4800)
+        override val errorLight = Color(0xFFBA1A1A)
+        override val onErrorLight = Color(0xFFFFFFFF)
+        override val errorContainerLight = Color(0xFFFFDAD6)
+        override val onErrorContainerLight = Color(0xFF93000A)
+        override val backgroundLight = Color(0xFFFFF9ED)
+        override val onBackgroundLight = Color(0xFF1E1C13)
+        override val surfaceLight = Color(0xFFFFF9ED)
+        override val onSurfaceLight = Color(0xFF1E1C13)
+        override val surfaceVariantLight = Color(0xFFE9E2D0)
+        override val onSurfaceVariantLight = Color(0xFF4B4739)
+        override val outlineLight = Color(0xFF7C7768)
+        override val outlineVariantLight = Color(0xFFCDC6B4)
+        override val scrimLight = Color(0xFF000000)
+        override val inverseSurfaceLight = Color(0xFF333027)
+        override val inverseOnSurfaceLight = Color(0xFFF7F0E2)
+        override val inversePrimaryLight = Color(0xFFDAC66F)
+        override val surfaceDimLight = Color(0xFFE0D9CC)
+        override val surfaceBrightLight = Color(0xFFFFF9ED)
+        override val surfaceContainerLowestLight = Color(0xFFFFFFFF)
+        override val surfaceContainerLowLight = Color(0xFFFAF3E5)
+        override val surfaceContainerLight = Color(0xFFF4EDDF)
+        override val surfaceContainerHighLight = Color(0xFFEEE8DA)
+        override val surfaceContainerHighestLight = Color(0xFFE8E2D4)
+
+        override val primaryDark = Color(0xFFDAC66F)
+        override val onPrimaryDark = Color(0xFF393000)
+        override val primaryContainerDark = Color(0xFF534600)
+        override val onPrimaryContainerDark = Color(0xFFF8E288)
+        override val secondaryDark = Color(0xFFDAC76F)
+        override val onSecondaryDark = Color(0xFF393000)
+        override val secondaryContainerDark = Color(0xFF534600)
+        override val onSecondaryContainerDark = Color(0xFFF7E388)
+        override val tertiaryDark = Color(0xFFD4C871)
+        override val onTertiaryDark = Color(0xFF363100)
+        override val tertiaryContainerDark = Color(0xFF4F4800)
+        override val onTertiaryContainerDark = Color(0xFFF1E58A)
+        override val errorDark = Color(0xFFFFB4AB)
+        override val onErrorDark = Color(0xFF690005)
+        override val errorContainerDark = Color(0xFF93000A)
+        override val onErrorContainerDark = Color(0xFFFFDAD6)
+        override val backgroundDark = Color(0xFF15130B)
+        override val onBackgroundDark = Color(0xFFE8E2D4)
+        override val surfaceDark = Color(0xFF15130B)
+        override val onSurfaceDark = Color(0xFFE8E2D4)
+        override val surfaceVariantDark = Color(0xFF4B4739)
+        override val onSurfaceVariantDark = Color(0xFFCDC6B4)
+        override val outlineDark = Color(0xFF969080)
+        override val outlineVariantDark = Color(0xFF4B4739)
+        override val scrimDark = Color(0xFF000000)
+        override val inverseSurfaceDark = Color(0xFFE8E2D4)
+        override val inverseOnSurfaceDark = Color(0xFF333027)
+        override val inversePrimaryDark = Color(0xFF6D5E0F)
+        override val surfaceDimDark = Color(0xFF15130B)
+        override val surfaceBrightDark = Color(0xFF3C3930)
+        override val surfaceContainerLowestDark = Color(0xFF100E07)
+        override val surfaceContainerLowDark = Color(0xFF1E1C13)
+        override val surfaceContainerDark = Color(0xFF222017)
+        override val surfaceContainerHighDark = Color(0xFF2C2A21)
+        override val surfaceContainerHighestDark = Color(0xFF37352B)
+    }
+
+    companion object {
+        fun fromName(name: String): ThemeColors = when (name.lowercase()) {
+            "green" -> Green
+            "purple" -> Purple
+            "orange" -> Orange
+            "pink" -> Pink
+            "gray" -> Gray
+            "yellow" -> Yellow
+            else -> Default
+        }
+    }
+}

manager/app/src/main/java/com/sukisu/ultra/ui/theme/Theme.kt

@@ -0,0 +1,606 @@
+package com.sukisu.ultra.ui.theme
+
+import android.content.ContentResolver
+import android.content.Context
+import android.net.Uri
+import android.os.Build
+import android.util.Log
+import androidx.annotation.RequiresApi
+import androidx.compose.animation.core.animateFloat
+import androidx.compose.animation.core.spring
+import androidx.compose.animation.core.updateTransition
+import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.darkColorScheme
+import androidx.compose.material3.dynamicDarkColorScheme
+import androidx.compose.material3.dynamicLightColorScheme
+import androidx.compose.material3.lightColorScheme
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.alpha
+import androidx.compose.ui.draw.paint
+import androidx.compose.ui.graphics.Brush
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.zIndex
+import coil.compose.AsyncImagePainter
+import coil.compose.rememberAsyncImagePainter
+import androidx.compose.foundation.background
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.unit.dp
+import java.io.File
+import java.io.FileOutputStream
+import java.io.InputStream
+import androidx.core.content.edit
+import androidx.core.net.toUri
+import com.sukisu.ultra.ui.util.BackgroundTransformation
+import com.sukisu.ultra.ui.util.saveTransformedBackground
+import androidx.activity.SystemBarStyle
+import androidx.activity.ComponentActivity
+import androidx.activity.enableEdgeToEdge
+import androidx.compose.runtime.SideEffect
+import androidx.compose.ui.graphics.toArgb
+
+/**
+ * 主题配置对象，管理应用的主题相关状态
+ */
+object ThemeConfig {
+    var customBackgroundUri by mutableStateOf<Uri?>(null)
+    var forceDarkMode by mutableStateOf<Boolean?>(null)
+    var currentTheme by mutableStateOf<ThemeColors>(ThemeColors.Default)
+    var useDynamicColor by mutableStateOf(false)
+    var backgroundImageLoaded by mutableStateOf(false)
+    var needsResetOnThemeChange by mutableStateOf(false)
+    var isThemeChanging by mutableStateOf(false)
+    var preventBackgroundRefresh by mutableStateOf(false)
+
+    private var lastDarkModeState: Boolean? = null
+    fun detectThemeChange(currentDarkMode: Boolean): Boolean {
+        val isChanged = lastDarkModeState != null && lastDarkModeState != currentDarkMode
+        lastDarkModeState = currentDarkMode
+        return isChanged
+    }
+
+    fun resetBackgroundState() {
+        if (!preventBackgroundRefresh) {
+            backgroundImageLoaded = false
+        }
+        isThemeChanging = true
+    }
+}
+
+/**
+ * 应用主题
+ */
+@Composable
+fun KernelSUTheme(
+    darkTheme: Boolean = when(ThemeConfig.forceDarkMode) {
+        true -> true
+        false -> false
+        null -> isSystemInDarkTheme()
+    },
+    dynamicColor: Boolean = ThemeConfig.useDynamicColor,
+    content: @Composable () -> Unit
+) {
+    val context = LocalContext.current
+    val systemIsDark = isSystemInDarkTheme()
+
+    // 检测系统主题变化并保存状态
+    val themeChanged = ThemeConfig.detectThemeChange(systemIsDark)
+    LaunchedEffect(systemIsDark, themeChanged) {
+        if (ThemeConfig.forceDarkMode == null && themeChanged) {
+            Log.d("ThemeSystem", "系统主题变化检测: 从 ${!systemIsDark} 变为 $systemIsDark")
+            ThemeConfig.resetBackgroundState()
+
+            if (!ThemeConfig.preventBackgroundRefresh) {
+                context.loadCustomBackground()
+            }
+
+            CardConfig.apply {
+                load(context)
+                if (!isCustomAlphaSet) {
+                    cardAlpha = if (systemIsDark) 0.50f else 1f
+                }
+                if (!isCustomDimSet) {
+                    cardDim = if (systemIsDark) 0.5f else 0f
+                }
+                save(context)
+            }
+        }
+    }
+
+    SystemBarStyle(
+        darkMode = darkTheme
+    )
+
+    // 初始加载配置
+    LaunchedEffect(Unit) {
+        context.loadThemeMode()
+        context.loadThemeColors()
+        context.loadDynamicColorState()
+        CardConfig.load(context)
+
+        if (!ThemeConfig.backgroundImageLoaded && !ThemeConfig.preventBackgroundRefresh) {
+            context.loadCustomBackground()
+            ThemeConfig.backgroundImageLoaded = false
+        }
+
+        ThemeConfig.preventBackgroundRefresh = context.getSharedPreferences("theme_prefs", Context.MODE_PRIVATE)
+            .getBoolean("prevent_background_refresh", true)
+    }
+
+    // 创建颜色方案
+    val colorScheme = when {
+        dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
+            if (darkTheme) createDynamicDarkColorScheme(context) else createDynamicLightColorScheme(context)
+        }
+        darkTheme -> createDarkColorScheme()
+        else -> createLightColorScheme()
+    }
+
+    // 根据暗色模式和自定义背景调整卡片配置
+    val isDarkModeWithCustomBackground = darkTheme && ThemeConfig.customBackgroundUri != null
+    if (darkTheme && !dynamicColor) {
+        CardConfig.setDarkModeDefaults()
+    } else if (!darkTheme && !dynamicColor) {
+        CardConfig.setLightModeDefaults()
+    }
+    CardConfig.updateShadowEnabled(!isDarkModeWithCustomBackground)
+
+    val backgroundUri = rememberSaveable { mutableStateOf(ThemeConfig.customBackgroundUri) }
+
+    LaunchedEffect(ThemeConfig.customBackgroundUri) {
+        backgroundUri.value = ThemeConfig.customBackgroundUri
+    }
+
+    val bgImagePainter = backgroundUri.value?.let {
+        rememberAsyncImagePainter(
+            model = it,
+            onError = {
+                Log.e("ThemeSystem", "背景图加载失败: ${it.result.throwable.message}")
+                ThemeConfig.customBackgroundUri = null
+                context.saveCustomBackground(null)
+            },
+            onSuccess = {
+                Log.d("ThemeSystem", "背景图加载成功")
+                ThemeConfig.backgroundImageLoaded = true
+                ThemeConfig.isThemeChanging = false
+
+                ThemeConfig.preventBackgroundRefresh = true
+                context.getSharedPreferences("theme_prefs", Context.MODE_PRIVATE)
+                    .edit { putBoolean("prevent_background_refresh", true) }
+            }
+        )
+    }
+
+    val transition = updateTransition(
+        targetState = ThemeConfig.backgroundImageLoaded,
+        label = "bgTransition"
+    )
+    val bgAlpha by transition.animateFloat(
+        label = "bgAlpha",
+        transitionSpec = {
+            spring(
+                dampingRatio = 0.8f,
+                stiffness = 300f
+            )
+        }
+    ) { loaded -> if (loaded) 1f else 0f }
+
+    DisposableEffect(systemIsDark) {
+        onDispose {
+            if (ThemeConfig.isThemeChanging) {
+                ThemeConfig.isThemeChanging = false
+            }
+        }
+    }
+
+    // 计算适用的暗化值
+    val dimFactor = CardConfig.cardDim
+
+    MaterialTheme(
+        colorScheme = colorScheme,
+        typography = Typography
+    ) {
+        Box(modifier = Modifier.fillMaxSize()) {
+            Box(
+                modifier = Modifier
+                    .fillMaxSize()
+                    .zIndex(-2f)
+                    .background(if (darkTheme) MaterialTheme.colorScheme.surfaceContainerLow else MaterialTheme.colorScheme.surfaceContainerLow)
+            )
+
+            // 自定义背景层
+            backgroundUri.value?.let { uri ->
+                Box(
+                    modifier = Modifier
+                        .fillMaxSize()
+                        .zIndex(-1f)
+                        .alpha(bgAlpha)
+                ) {
+                    // 背景图片
+                    bgImagePainter?.let { painter ->
+                        Box(
+                            modifier = Modifier
+                                .fillMaxSize()
+                                .paint(
+                                    painter = painter,
+                                    contentScale = ContentScale.Crop
+                                )
+                                .graphicsLayer {
+                                    alpha = (painter.state as? AsyncImagePainter.State.Success)?.let { 1f } ?: 0f
+                                }
+                        )
+                    }
+
+                    // 亮度调节层 (根据cardDim调整)
+                    Box(
+                        modifier = Modifier
+                            .fillMaxSize()
+                            .background(
+                                if (darkTheme) Color.Black.copy(alpha = 0.6f + dimFactor * 0.3f)
+                                else Color.White.copy(alpha = 0.1f + dimFactor * 0.2f)
+                            )
+                    )
+
+                    // 边缘渐变遮罩
+                    Box(
+                        modifier = Modifier
+                            .fillMaxSize()
+                            .background(
+                                Brush.radialGradient(
+                                    colors = listOf(
+                                        Color.Transparent,
+                                        if (darkTheme) Color.Black.copy(alpha = 0.5f + dimFactor * 0.2f)
+                                        else Color.Black.copy(alpha = 0.2f + dimFactor * 0.1f)
+                                    ),
+                                    radius = 1200f
+                                )
+                            )
+                    )
+                }
+            }
+
+            // 内容层
+            Box(
+                modifier = Modifier
+                    .fillMaxSize()
+                    .zIndex(1f)
+            ) {
+                content()
+            }
+        }
+    }
+}
+
+/**
+ * 创建动态深色颜色方案
+ */
+@RequiresApi(Build.VERSION_CODES.S)
+@Composable
+private fun createDynamicDarkColorScheme(context: Context) =
+    dynamicDarkColorScheme(context).copy(
+        background = Color.Transparent,
+        surface = Color.Transparent,
+        onBackground = Color.White,
+        onSurface = Color.White
+    )
+
+/**
+ * 创建动态浅色颜色方案
+ */
+@RequiresApi(Build.VERSION_CODES.S)
+@Composable
+private fun createDynamicLightColorScheme(context: Context) =
+    dynamicLightColorScheme(context).copy(
+        background = Color.Transparent,
+        surface = Color.Transparent
+    )
+
+/**
+ * 创建深色颜色方案
+ */
+@Composable
+private fun createDarkColorScheme() = darkColorScheme(
+    primary = ThemeConfig.currentTheme.primaryDark,
+    onPrimary = ThemeConfig.currentTheme.onPrimaryDark,
+    primaryContainer = ThemeConfig.currentTheme.primaryContainerDark,
+    onPrimaryContainer = ThemeConfig.currentTheme.onPrimaryContainerDark,
+    secondary = ThemeConfig.currentTheme.secondaryDark,
+    onSecondary = ThemeConfig.currentTheme.onSecondaryDark,
+    secondaryContainer = ThemeConfig.currentTheme.secondaryContainerDark,
+    onSecondaryContainer = ThemeConfig.currentTheme.onSecondaryContainerDark,
+    tertiary = ThemeConfig.currentTheme.tertiaryDark,
+    onTertiary = ThemeConfig.currentTheme.onTertiaryDark,
+    tertiaryContainer = ThemeConfig.currentTheme.tertiaryContainerDark,
+    onTertiaryContainer = ThemeConfig.currentTheme.onTertiaryContainerDark,
+    error = ThemeConfig.currentTheme.errorDark,
+    onError = ThemeConfig.currentTheme.onErrorDark,
+    errorContainer = ThemeConfig.currentTheme.errorContainerDark,
+    onErrorContainer = ThemeConfig.currentTheme.onErrorContainerDark,
+    background = Color.Transparent,
+    onBackground = ThemeConfig.currentTheme.onBackgroundDark,
+    surface = Color.Transparent,
+    onSurface = ThemeConfig.currentTheme.onSurfaceDark,
+    surfaceVariant = ThemeConfig.currentTheme.surfaceVariantDark,
+    onSurfaceVariant = ThemeConfig.currentTheme.onSurfaceVariantDark,
+    outline = ThemeConfig.currentTheme.outlineDark,
+    outlineVariant = ThemeConfig.currentTheme.outlineVariantDark,
+    scrim = ThemeConfig.currentTheme.scrimDark,
+    inverseSurface = ThemeConfig.currentTheme.inverseSurfaceDark,
+    inverseOnSurface = ThemeConfig.currentTheme.inverseOnSurfaceDark,
+    inversePrimary = ThemeConfig.currentTheme.inversePrimaryDark,
+    surfaceDim = ThemeConfig.currentTheme.surfaceDimDark,
+    surfaceBright = ThemeConfig.currentTheme.surfaceBrightDark,
+    surfaceContainerLowest = ThemeConfig.currentTheme.surfaceContainerLowestDark,
+    surfaceContainerLow = ThemeConfig.currentTheme.surfaceContainerLowDark,
+    surfaceContainer = ThemeConfig.currentTheme.surfaceContainerDark,
+    surfaceContainerHigh = ThemeConfig.currentTheme.surfaceContainerHighDark,
+    surfaceContainerHighest = ThemeConfig.currentTheme.surfaceContainerHighestDark,
+)
+
+/**
+ * 创建浅色颜色方案
+ */
+@Composable
+private fun createLightColorScheme() = lightColorScheme(
+    primary = ThemeConfig.currentTheme.primaryLight,
+    onPrimary = ThemeConfig.currentTheme.onPrimaryLight,
+    primaryContainer = ThemeConfig.currentTheme.primaryContainerLight,
+    onPrimaryContainer = ThemeConfig.currentTheme.onPrimaryContainerLight,
+    secondary = ThemeConfig.currentTheme.secondaryLight,
+    onSecondary = ThemeConfig.currentTheme.onSecondaryLight,
+    secondaryContainer = ThemeConfig.currentTheme.secondaryContainerLight,
+    onSecondaryContainer = ThemeConfig.currentTheme.onSecondaryContainerLight,
+    tertiary = ThemeConfig.currentTheme.tertiaryLight,
+    onTertiary = ThemeConfig.currentTheme.onTertiaryLight,
+    tertiaryContainer = ThemeConfig.currentTheme.tertiaryContainerLight,
+    onTertiaryContainer = ThemeConfig.currentTheme.onTertiaryContainerLight,
+    error = ThemeConfig.currentTheme.errorLight,
+    onError = ThemeConfig.currentTheme.onErrorLight,
+    errorContainer = ThemeConfig.currentTheme.errorContainerLight,
+    onErrorContainer = ThemeConfig.currentTheme.onErrorContainerLight,
+    background = Color.Transparent,
+    onBackground = ThemeConfig.currentTheme.onBackgroundLight,
+    surface = Color.Transparent,
+    onSurface = ThemeConfig.currentTheme.onSurfaceLight,
+    surfaceVariant = ThemeConfig.currentTheme.surfaceVariantLight,
+    onSurfaceVariant = ThemeConfig.currentTheme.onSurfaceVariantLight,
+    outline = ThemeConfig.currentTheme.outlineLight,
+    outlineVariant = ThemeConfig.currentTheme.outlineVariantLight,
+    scrim = ThemeConfig.currentTheme.scrimLight,
+    inverseSurface = ThemeConfig.currentTheme.inverseSurfaceLight,
+    inverseOnSurface = ThemeConfig.currentTheme.inverseOnSurfaceLight,
+    inversePrimary = ThemeConfig.currentTheme.inversePrimaryLight,
+    surfaceDim = ThemeConfig.currentTheme.surfaceDimLight,
+    surfaceBright = ThemeConfig.currentTheme.surfaceBrightLight,
+    surfaceContainerLowest = ThemeConfig.currentTheme.surfaceContainerLowestLight,
+    surfaceContainerLow = ThemeConfig.currentTheme.surfaceContainerLowLight,
+    surfaceContainer = ThemeConfig.currentTheme.surfaceContainerLight,
+    surfaceContainerHigh = ThemeConfig.currentTheme.surfaceContainerHighLight,
+    surfaceContainerHighest = ThemeConfig.currentTheme.surfaceContainerHighestLight,
+)
+
+/**
+ * 复制图片到应用内部存储并提升持久性
+ */
+private fun Context.copyImageToInternalStorage(uri: Uri): Uri? {
+    return try {
+        val contentResolver: ContentResolver = contentResolver
+        val inputStream: InputStream = contentResolver.openInputStream(uri) ?: return null
+
+        val fileName = "custom_background.jpg"
+        val file = File(filesDir, fileName)
+
+        val backupFile = File(filesDir, "${fileName}.backup")
+        val outputStream = FileOutputStream(backupFile)
+        val buffer = ByteArray(4 * 1024)
+        var read: Int
+
+        while (inputStream.read(buffer).also { read = it } != -1) {
+            outputStream.write(buffer, 0, read)
+        }
+
+        outputStream.flush()
+        outputStream.close()
+        inputStream.close()
+
+        if (file.exists()) {
+            file.delete()
+        }
+        backupFile.renameTo(file)
+
+        Uri.fromFile(file)
+    } catch (e: Exception) {
+        Log.e("ImageCopy", "复制图片失败: ${e.message}")
+        null
+    }
+}
+
+/**
+ * 保存并应用自定义背景
+ */
+fun Context.saveAndApplyCustomBackground(uri: Uri, transformation: BackgroundTransformation? = null) {
+    val finalUri = if (transformation != null) {
+        saveTransformedBackground(uri, transformation)
+    } else {
+        copyImageToInternalStorage(uri)
+    }
+
+    // 保存到配置文件
+    getSharedPreferences("theme_prefs", Context.MODE_PRIVATE)
+        .edit {
+            putString("custom_background", finalUri?.toString())
+            // 设置阻止刷新标志为false，允许新设置的背景加载一次
+            putBoolean("prevent_background_refresh", false)
+        }
+
+    ThemeConfig.customBackgroundUri = finalUri
+    ThemeConfig.backgroundImageLoaded = false
+    ThemeConfig.preventBackgroundRefresh = false
+    CardConfig.cardElevation = 0.dp
+    CardConfig.isCustomBackgroundEnabled = true
+}
+
+/**
+ * 保存自定义背景
+ */
+fun Context.saveCustomBackground(uri: Uri?) {
+    val newUri = uri?.let { copyImageToInternalStorage(it) }
+
+    // 保存到配置文件
+    getSharedPreferences("theme_prefs", Context.MODE_PRIVATE)
+        .edit {
+            putString("custom_background", newUri?.toString())
+            if (uri == null) {
+                // 如果清除背景，也重置阻止刷新标志
+                putBoolean("prevent_background_refresh", false)
+            } else {
+                // 设置阻止刷新标志为false，允许新设置的背景加载一次
+                putBoolean("prevent_background_refresh", false)
+            }
+        }
+
+    ThemeConfig.customBackgroundUri = newUri
+    ThemeConfig.backgroundImageLoaded = false
+    ThemeConfig.preventBackgroundRefresh = false
+
+    if (uri != null) {
+        CardConfig.cardElevation = 0.dp
+        CardConfig.isCustomBackgroundEnabled = true
+    }
+}
+
+/**
+ * 加载自定义背景
+ */
+fun Context.loadCustomBackground() {
+    val uriString = getSharedPreferences("theme_prefs", Context.MODE_PRIVATE)
+        .getString("custom_background", null)
+
+    val newUri = uriString?.toUri()
+    val preventRefresh = getSharedPreferences("theme_prefs", Context.MODE_PRIVATE)
+        .getBoolean("prevent_background_refresh", false)
+
+    ThemeConfig.preventBackgroundRefresh = preventRefresh
+
+    if (!preventRefresh || ThemeConfig.customBackgroundUri?.toString() != newUri?.toString()) {
+        Log.d("ThemeSystem", "加载自定义背景: $uriString, 阻止刷新: $preventRefresh")
+        ThemeConfig.customBackgroundUri = newUri
+        ThemeConfig.backgroundImageLoaded = false
+    }
+}
+
+/**
+ * 保存主题模式
+ */
+fun Context.saveThemeMode(forceDark: Boolean?) {
+    getSharedPreferences("theme_prefs", Context.MODE_PRIVATE)
+        .edit {
+            putString(
+                "theme_mode", when (forceDark) {
+                    true -> "dark"
+                    false -> "light"
+                    null -> "system"
+                }
+            )
+        }
+    ThemeConfig.forceDarkMode = forceDark
+    ThemeConfig.needsResetOnThemeChange = forceDark == null
+}
+
+/**
+ * 加载主题模式
+ */
+fun Context.loadThemeMode() {
+    val mode = getSharedPreferences("theme_prefs", Context.MODE_PRIVATE)
+        .getString("theme_mode", "system")
+
+    ThemeConfig.forceDarkMode = when(mode) {
+        "dark" -> true
+        "light" -> false
+        else -> null
+    }
+    ThemeConfig.needsResetOnThemeChange = ThemeConfig.forceDarkMode == null
+}
+
+/**
+ * 保存主题颜色
+ */
+fun Context.saveThemeColors(themeName: String) {
+    getSharedPreferences("theme_prefs", Context.MODE_PRIVATE)
+        .edit {
+            putString("theme_colors", themeName)
+        }
+
+    ThemeConfig.currentTheme = ThemeColors.fromName(themeName)
+}
+
+/**
+ * 加载主题颜色
+ */
+fun Context.loadThemeColors() {
+    val themeName = getSharedPreferences("theme_prefs", Context.MODE_PRIVATE)
+        .getString("theme_colors", "default")
+
+    ThemeConfig.currentTheme = ThemeColors.fromName(themeName ?: "default")
+}
+
+/**
+ * 保存动态颜色状态
+ */
+fun Context.saveDynamicColorState(enabled: Boolean) {
+    getSharedPreferences("theme_prefs", Context.MODE_PRIVATE)
+        .edit {
+            putBoolean("use_dynamic_color", enabled)
+        }
+    ThemeConfig.useDynamicColor = enabled
+}
+
+/**
+ * 加载动态颜色状态
+ */
+fun Context.loadDynamicColorState() {
+    val enabled = getSharedPreferences("theme_prefs", Context.MODE_PRIVATE)
+        .getBoolean("use_dynamic_color", true)
+
+    ThemeConfig.useDynamicColor = enabled
+}
+
+@Composable
+private fun SystemBarStyle(
+    darkMode: Boolean,
+    statusBarScrim: Color = Color.Transparent,
+    navigationBarScrim: Color = Color.Transparent,
+) {
+    val context = LocalContext.current
+    val activity = context as ComponentActivity
+
+    SideEffect {
+        activity.enableEdgeToEdge(
+            statusBarStyle = SystemBarStyle.auto(
+                statusBarScrim.toArgb(),
+                statusBarScrim.toArgb(),
+            ) { darkMode },
+            navigationBarStyle = when {
+                darkMode -> SystemBarStyle.dark(
+                    navigationBarScrim.toArgb()
+                )
+
+                else -> SystemBarStyle.light(
+                    navigationBarScrim.toArgb(),
+                    navigationBarScrim.toArgb(),
+                )
+            }
+        )
+    }
+}

manager/app/src/main/java/com/sukisu/ultra/ui/theme/Type.kt

@@ -0,0 +1,108 @@
+package com.sukisu.ultra.ui.theme
+
+import androidx.compose.material3.Typography
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.sp
+
+val Typography = Typography(
+    // 大标题
+    displayLarge = TextStyle(
+        fontWeight = FontWeight.Normal,
+        fontSize = 57.sp,
+        lineHeight = 64.sp,
+        letterSpacing = (-0.25).sp
+    ),
+    displayMedium = TextStyle(
+        fontWeight = FontWeight.Normal,
+        fontSize = 45.sp,
+        lineHeight = 52.sp,
+        letterSpacing = 0.sp
+    ),
+    displaySmall = TextStyle(
+        fontWeight = FontWeight.Normal,
+        fontSize = 36.sp,
+        lineHeight = 44.sp,
+        letterSpacing = 0.sp
+    ),
+
+    // 标题
+    headlineLarge = TextStyle(
+        fontWeight = FontWeight.SemiBold,
+        fontSize = 32.sp,
+        lineHeight = 40.sp,
+        letterSpacing = 0.sp
+    ),
+    headlineMedium = TextStyle(
+        fontWeight = FontWeight.SemiBold,
+        fontSize = 28.sp,
+        lineHeight = 36.sp,
+        letterSpacing = 0.sp
+    ),
+    headlineSmall = TextStyle(
+        fontWeight = FontWeight.SemiBold,
+        fontSize = 24.sp,
+        lineHeight = 32.sp,
+        letterSpacing = 0.sp
+    ),
+
+    // 标题栏
+    titleLarge = TextStyle(
+        fontWeight = FontWeight.SemiBold,
+        fontSize = 22.sp,
+        lineHeight = 28.sp,
+        letterSpacing = 0.sp
+    ),
+    titleMedium = TextStyle(
+        fontWeight = FontWeight.SemiBold,
+        fontSize = 16.sp,
+        lineHeight = 24.sp,
+        letterSpacing = 0.15.sp
+    ),
+    titleSmall = TextStyle(
+        fontWeight = FontWeight.Medium,
+        fontSize = 14.sp,
+        lineHeight = 20.sp,
+        letterSpacing = 0.1.sp
+    ),
+
+    // 主体文字
+    bodyLarge = TextStyle(
+        fontWeight = FontWeight.Normal,
+        fontSize = 16.sp,
+        lineHeight = 24.sp,
+        letterSpacing = 0.5.sp
+    ),
+    bodyMedium = TextStyle(
+        fontWeight = FontWeight.Normal,
+        fontSize = 14.sp,
+        lineHeight = 20.sp,
+        letterSpacing = 0.25.sp
+    ),
+    bodySmall = TextStyle(
+        fontWeight = FontWeight.Normal,
+        fontSize = 12.sp,
+        lineHeight = 16.sp,
+        letterSpacing = 0.4.sp
+    ),
+
+    // 标签
+    labelLarge = TextStyle(
+        fontWeight = FontWeight.Medium,
+        fontSize = 14.sp,
+        lineHeight = 20.sp,
+        letterSpacing = 0.1.sp
+    ),
+    labelMedium = TextStyle(
+        fontWeight = FontWeight.Medium,
+        fontSize = 12.sp,
+        lineHeight = 16.sp,
+        letterSpacing = 0.5.sp
+    ),
+    labelSmall = TextStyle(
+        fontWeight = FontWeight.Medium,
+        fontSize = 11.sp,
+        lineHeight = 16.sp,
+        letterSpacing = 0.5.sp
+    )
+)

manager/app/src/main/java/com/sukisu/ultra/ui/util/BackgroundUtils.kt

@@ -0,0 +1,110 @@
+package com.sukisu.ultra.ui.util
+
+import android.content.ContentResolver
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.Canvas
+import android.graphics.Matrix
+import android.net.Uri
+import android.util.Log
+import java.io.File
+import java.io.FileOutputStream
+import java.io.InputStream
+import androidx.core.graphics.createBitmap
+
+data class BackgroundTransformation(
+    val scale: Float = 1f,
+    val offsetX: Float = 0f,
+    val offsetY: Float = 0f
+)
+
+fun Context.getImageBitmap(uri: Uri): Bitmap? {
+    return try {
+        val contentResolver: ContentResolver = contentResolver
+        val inputStream: InputStream = contentResolver.openInputStream(uri) ?: return null
+        val bitmap = BitmapFactory.decodeStream(inputStream)
+        inputStream.close()
+        bitmap
+    } catch (e: Exception) {
+        Log.e("BackgroundUtils", "Failed to get image bitmap: ${e.message}")
+        null
+    }
+}
+
+fun Context.applyTransformationToBitmap(bitmap: Bitmap, transformation: BackgroundTransformation): Bitmap {
+    val width = bitmap.width
+    val height = bitmap.height
+
+    // 创建与屏幕比例相同的目标位图
+    val displayMetrics = resources.displayMetrics
+    val screenWidth = displayMetrics.widthPixels
+    val screenHeight = displayMetrics.heightPixels
+    val screenRatio = screenHeight.toFloat() / screenWidth.toFloat()
+
+    // 计算目标宽高
+    val targetWidth: Int
+    val targetHeight: Int
+    if (width.toFloat() / height.toFloat() > screenRatio) {
+        targetHeight = height
+        targetWidth = (height / screenRatio).toInt()
+    } else {
+        targetWidth = width
+        targetHeight = (width * screenRatio).toInt()
+    }
+
+    // 创建与目标相同大小的位图
+    val scaledBitmap = createBitmap(targetWidth, targetHeight)
+    val canvas = Canvas(scaledBitmap)
+
+    val matrix = Matrix()
+
+    // 确保缩放值有效
+    val safeScale = maxOf(0.1f, transformation.scale)
+    matrix.postScale(safeScale, safeScale)
+
+    // 计算偏移量，确保不会出现负最大值的问题
+    val widthDiff = (bitmap.width * safeScale - targetWidth)
+    val heightDiff = (bitmap.height * safeScale - targetHeight)
+
+    // 安全计算偏移量边界
+    val maxOffsetX = maxOf(0f, widthDiff / 2)
+    val maxOffsetY = maxOf(0f, heightDiff / 2)
+
+    // 限制偏移范围
+    val safeOffsetX = if (maxOffsetX > 0)
+        transformation.offsetX.coerceIn(-maxOffsetX, maxOffsetX) else 0f
+    val safeOffsetY = if (maxOffsetY > 0)
+        transformation.offsetY.coerceIn(-maxOffsetY, maxOffsetY) else 0f
+
+    // 应用偏移量到矩阵
+    val translationX = -widthDiff / 2 + safeOffsetX
+    val translationY = -heightDiff / 2 + safeOffsetY
+
+    matrix.postTranslate(translationX, translationY)
+
+    // 将原始位图绘制到新位图上
+    canvas.drawBitmap(bitmap, matrix, null)
+
+    return scaledBitmap
+}
+
+fun Context.saveTransformedBackground(uri: Uri, transformation: BackgroundTransformation): Uri? {
+    try {
+        val bitmap = getImageBitmap(uri) ?: return null
+        val transformedBitmap = applyTransformationToBitmap(bitmap, transformation)
+
+        val fileName = "custom_background_transformed.jpg"
+        val file = File(filesDir, fileName)
+        val outputStream = FileOutputStream(file)
+
+        transformedBitmap.compress(Bitmap.CompressFormat.JPEG, 90, outputStream)
+        outputStream.flush()
+        outputStream.close()
+
+        return Uri.fromFile(file)
+    } catch (e: Exception) {
+        Log.e("BackgroundUtils", "Failed to save transformed image: ${e.message}", e)
+        return null
+    }
+}

manager/app/src/main/java/com/sukisu/ultra/ui/util/CompositionProvider.kt

@@ -1,4 +1,4 @@
-package shirkneko.zako.sukisu.ui.util
+package com.sukisu.ultra.ui.util
 
 import androidx.compose.material3.SnackbarHostState
 import androidx.compose.runtime.compositionLocalOf

manager/app/src/main/java/com/sukisu/ultra/ui/util/Downloader.kt

@@ -0,0 +1,319 @@
+package com.sukisu.ultra.ui.util
+
+import android.annotation.SuppressLint
+import android.app.DownloadManager
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.net.Uri
+import android.os.Build
+import android.os.Environment
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.core.content.ContextCompat
+import com.sukisu.ultra.ui.util.module.LatestVersionInfo
+import androidx.core.net.toUri
+import java.io.File
+import java.util.concurrent.TimeUnit
+
+private const val TAG = "DownloadUtil"
+private val CUSTOM_USER_AGENT = "SukiSU-Ultra/2.0 (Linux; Android ${Build.VERSION.RELEASE}; ${Build.MODEL})"
+private const val MAX_RETRY_COUNT = 3
+private const val RETRY_DELAY_MS = 3000L
+
+/**
+ * @author weishu
+ * @date 2023/6/22.
+ */
+@SuppressLint("Range")
+fun download(
+    context: Context,
+    url: String,
+    fileName: String,
+    description: String,
+    onDownloaded: (Uri) -> Unit = {},
+    onDownloading: () -> Unit = {},
+    onError: (String) -> Unit = {}
+) {
+    Log.d(TAG, "Start Download: $url")
+    val downloadManager = context.getSystemService(Context.DOWNLOAD_SERVICE) as DownloadManager
+
+    val query = DownloadManager.Query()
+    query.setFilterByStatus(DownloadManager.STATUS_RUNNING or DownloadManager.STATUS_PAUSED or DownloadManager.STATUS_PENDING)
+    downloadManager.query(query).use { cursor ->
+        while (cursor.moveToNext()) {
+            val uri = cursor.getString(cursor.getColumnIndex(DownloadManager.COLUMN_URI))
+            val localUri = cursor.getString(cursor.getColumnIndex(DownloadManager.COLUMN_LOCAL_URI))
+            val status = cursor.getInt(cursor.getColumnIndex(DownloadManager.COLUMN_STATUS))
+            val columnTitle = cursor.getString(cursor.getColumnIndex(DownloadManager.COLUMN_TITLE))
+            if (url == uri || fileName == columnTitle) {
+                if (status == DownloadManager.STATUS_RUNNING || status == DownloadManager.STATUS_PENDING) {
+                    onDownloading()
+                    return
+                } else if (status == DownloadManager.STATUS_SUCCESSFUL) {
+                    onDownloaded(localUri.toUri())
+                    return
+                }
+            }
+        }
+    }
+    val downloadFile = File(
+        Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS),
+        fileName
+    )
+    if (downloadFile.exists()) {
+        downloadFile.delete()
+    }
+
+    val request = DownloadManager.Request(url.toUri())
+        .setDestinationInExternalPublicDir(
+            Environment.DIRECTORY_DOWNLOADS,
+            fileName
+        )
+        .setNotificationVisibility(DownloadManager.Request.VISIBILITY_VISIBLE_NOTIFY_COMPLETED)
+        .setMimeType("application/zip")
+        .setTitle(fileName)
+        .setDescription(description)
+        .addRequestHeader("User-Agent", CUSTOM_USER_AGENT)
+        .setAllowedOverMetered(true)
+        .setAllowedOverRoaming(true)
+        .setAllowedNetworkTypes(DownloadManager.Request.NETWORK_WIFI or DownloadManager.Request.NETWORK_MOBILE)
+
+    try {
+        val downloadId = downloadManager.enqueue(request)
+        Log.d(TAG, "Successful launch of the download，ID: $downloadId")
+        monitorDownload(context, downloadManager, downloadId, url, fileName, description, onDownloaded, onDownloading, onError)
+    } catch (e: Exception) {
+        Log.e(TAG, "Download startup failure", e)
+        onError("Download startup failure: ${e.message}")
+    }
+}
+
+private fun monitorDownload(
+    context: Context,
+    downloadManager: DownloadManager,
+    downloadId: Long,
+    url: String,
+    fileName: String,
+    description: String,
+    onDownloaded: (Uri) -> Unit,
+    onDownloading: () -> Unit,
+    onError: (String) -> Unit,
+    retryCount: Int = 0
+) {
+    val handler = Handler(Looper.getMainLooper())
+    val query = DownloadManager.Query().setFilterById(downloadId)
+
+    var lastProgress = -1
+    var stuckCounter = 0
+
+    val runnable = object : Runnable {
+        override fun run() {
+            downloadManager.query(query).use { cursor ->
+                if (cursor != null && cursor.moveToFirst()) {
+                    @SuppressLint("Range")
+                    val status = cursor.getInt(cursor.getColumnIndex(DownloadManager.COLUMN_STATUS))
+
+                    when (status) {
+                        DownloadManager.STATUS_SUCCESSFUL -> {
+                            @SuppressLint("Range")
+                            val localUri = cursor.getString(cursor.getColumnIndex(DownloadManager.COLUMN_LOCAL_URI))
+                            Log.d(TAG, "Download Successfully: $localUri")
+                            onDownloaded(localUri.toUri())
+                            return
+                        }
+                        DownloadManager.STATUS_FAILED -> {
+                            @SuppressLint("Range")
+                            val reason = cursor.getInt(cursor.getColumnIndex(DownloadManager.COLUMN_REASON))
+                            Log.d(TAG, "Download failed with reason code: $reason")
+
+                            if (retryCount < MAX_RETRY_COUNT) {
+                                Log.d(TAG, "Attempts to re download, number of retries: ${retryCount + 1}")
+                                handler.postDelayed({
+                                    downloadManager.remove(downloadId)
+                                    download(context, url, fileName, description, onDownloaded, onDownloading, onError)
+                                }, RETRY_DELAY_MS)
+                            } else {
+                                onError("Download failed, please check network connection or storage space")
+                            }
+                            return
+                        }
+                        DownloadManager.STATUS_RUNNING, DownloadManager.STATUS_PENDING, DownloadManager.STATUS_PAUSED -> {
+                            @SuppressLint("Range")
+                            val totalBytes = cursor.getLong(cursor.getColumnIndex(DownloadManager.COLUMN_TOTAL_SIZE_BYTES))
+                            @SuppressLint("Range")
+                            val downloadedBytes = cursor.getLong(cursor.getColumnIndex(DownloadManager.COLUMN_BYTES_DOWNLOADED_SO_FAR))
+
+                            if (totalBytes > 0) {
+                                val progress = (downloadedBytes * 100 / totalBytes).toInt()
+                                if (progress == lastProgress) {
+                                    stuckCounter++
+                                    if (stuckCounter > 30) {
+                                        if (retryCount < MAX_RETRY_COUNT) {
+                                            Log.d(TAG, "Download stalled and restarted")
+                                            downloadManager.remove(downloadId)
+                                            download(context, url, fileName, description, onDownloaded, onDownloading, onError)
+                                            return
+                                        }
+                                    }
+                                } else {
+                                    lastProgress = progress
+                                    stuckCounter = 0
+                                    Log.d(TAG, "Download progress: $progress% ($downloadedBytes/$totalBytes)")
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            handler.postDelayed(this, 1000)
+        }
+    }
+    handler.post(runnable)
+
+    val receiver = object : BroadcastReceiver() {
+        override fun onReceive(context: Context?, intent: Intent?) {
+            val id = intent?.getLongExtra(DownloadManager.EXTRA_DOWNLOAD_ID, -1) ?: -1
+            if (id == downloadId) {
+                handler.removeCallbacks(runnable)
+
+                val query = DownloadManager.Query().setFilterById(downloadId)
+                downloadManager.query(query).use { cursor ->
+                    if (cursor != null && cursor.moveToFirst()) {
+                        @SuppressLint("Range")
+                        val status = cursor.getInt(cursor.getColumnIndex(DownloadManager.COLUMN_STATUS))
+
+                        if (status == DownloadManager.STATUS_SUCCESSFUL) {
+                            @SuppressLint("Range")
+                            val localUri = cursor.getString(cursor.getColumnIndex(DownloadManager.COLUMN_LOCAL_URI))
+                            onDownloaded(localUri.toUri())
+                        } else {
+                            if (retryCount < MAX_RETRY_COUNT) {
+                                download(context!!, url, fileName, description, onDownloaded, onDownloading, onError)
+                            } else {
+                                onError("Download failed, please try again later")
+                            }
+                        }
+                    }
+                }
+
+                context?.unregisterReceiver(this)
+            }
+        }
+    }
+
+    ContextCompat.registerReceiver(
+        context,
+        receiver,
+        IntentFilter(DownloadManager.ACTION_DOWNLOAD_COMPLETE),
+        ContextCompat.RECEIVER_EXPORTED
+    )
+}
+
+fun checkNewVersion(): LatestVersionInfo {
+    val url = "https://api.github.com/repos/ShirkNeko/SukiSU-Ultra/releases/latest"
+    val defaultValue = LatestVersionInfo()
+    return runCatching {
+        val client = okhttp3.OkHttpClient.Builder()
+            .connectTimeout(15, TimeUnit.SECONDS)
+            .readTimeout(30, TimeUnit.SECONDS)
+            .writeTimeout(15, TimeUnit.SECONDS)
+            .build()
+
+        val request = okhttp3.Request.Builder()
+            .url(url)
+            .header("User-Agent", CUSTOM_USER_AGENT)
+            .build()
+
+        client.newCall(request).execute().use { response ->
+            if (!response.isSuccessful) {
+                Log.d("CheckUpdate", "Network request failed: ${response.message}")
+                return defaultValue
+            }
+            val body = response.body?.string()
+            if (body == null) {
+                Log.d("CheckUpdate", "Return data is null")
+                return defaultValue
+            }
+            Log.d("CheckUpdate", "Return data: $body")
+            val json = org.json.JSONObject(body)
+
+            // 直接从 tag_name 提取版本号（如 v1.1）
+            val tagName = json.optString("tag_name", "")
+            val versionName = tagName.removePrefix("v") // 移除前缀 "v"
+
+            // 从 body 字段获取更新日志（保留换行符）
+            val changelog = json.optString("body")
+                .replace("\\r\\n", "\n") // 转换换行符
+
+            val assets = json.getJSONArray("assets")
+            for (i in 0 until assets.length()) {
+                val asset = assets.getJSONObject(i)
+                val name = asset.getString("name")
+                if (!name.endsWith(".apk")) continue
+
+                val regex = Regex("SukiSU.*_(\\d+)-release")
+                val matchResult = regex.find(name)
+                if (matchResult == null) {
+                    Log.d("CheckUpdate", "No matches found: $name, skip over")
+                    continue
+                }
+                val versionCode = matchResult.groupValues[1].toInt()
+
+                val downloadUrl = asset.getString("browser_download_url")
+                return LatestVersionInfo(
+                    versionCode,
+                    downloadUrl,
+                    changelog,
+                    versionName
+                )
+            }
+            Log.d("CheckUpdate", "No valid APK resource found, return default value")
+            defaultValue
+        }
+    }.getOrDefault(defaultValue)
+}
+
+@Composable
+fun DownloadListener(context: Context, onDownloaded: (Uri) -> Unit) {
+    DisposableEffect(context) {
+        val receiver = object : BroadcastReceiver() {
+            @SuppressLint("Range")
+            override fun onReceive(context: Context?, intent: Intent?) {
+                if (intent?.action == DownloadManager.ACTION_DOWNLOAD_COMPLETE) {
+                    val id = intent.getLongExtra(
+                        DownloadManager.EXTRA_DOWNLOAD_ID, -1
+                    )
+                    val query = DownloadManager.Query().setFilterById(id)
+                    val downloadManager =
+                        context?.getSystemService(Context.DOWNLOAD_SERVICE) as DownloadManager
+                    val cursor = downloadManager.query(query)
+                    if (cursor.moveToFirst()) {
+                        val status = cursor.getInt(
+                            cursor.getColumnIndex(DownloadManager.COLUMN_STATUS)
+                        )
+                        if (status == DownloadManager.STATUS_SUCCESSFUL) {
+                            val uri = cursor.getString(
+                                cursor.getColumnIndex(DownloadManager.COLUMN_LOCAL_URI)
+                            )
+                            onDownloaded(uri.toUri())
+                        }
+                    }
+                }
+            }
+        }
+        ContextCompat.registerReceiver(
+            context,
+            receiver,
+            IntentFilter(DownloadManager.ACTION_DOWNLOAD_COMPLETE),
+            ContextCompat.RECEIVER_EXPORTED
+        )
+        onDispose {
+            context.unregisterReceiver(receiver)
+        }
+    }
+}

manager/app/src/main/java/com/sukisu/ultra/ui/util/HanziToPinyin.java

@@ -1,4 +1,4 @@
-package shirkneko.zako.sukisu.ui.util;
+package com.sukisu.ultra.ui.util;
 /*
  * Copyright (C) 2009 The Android Open Source Project
  *

manager/app/src/main/java/com/sukisu/ultra/ui/util/HyperlinkText.kt

@@ -1,4 +1,4 @@
-package shirkneko.zako.sukisu.ui.util
+package com.sukisu.ultra.ui.util
 
 import androidx.compose.foundation.gestures.detectTapGestures
 import androidx.compose.material3.MaterialTheme

manager/app/src/main/java/com/sukisu/ultra/ui/util/KsuCli.kt

@@ -1,4 +1,4 @@
-package shirkneko.zako.sukisu.ui.util
+package com.sukisu.ultra.ui.util
 
 import android.content.ContentResolver
 import android.content.Context
@@ -16,9 +16,9 @@ import com.topjohnwu.superuser.ShellUtils
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import kotlinx.parcelize.Parcelize
-import shirkneko.zako.sukisu.BuildConfig
-import shirkneko.zako.sukisu.Natives
-import shirkneko.zako.sukisu.ksuApp
+import com.sukisu.ultra.BuildConfig
+import com.sukisu.ultra.Natives
+import com.sukisu.ultra.ksuApp
 import org.json.JSONArray
 import java.io.File
 
@@ -30,7 +30,7 @@ import java.io.File
 private const val TAG = "KsuCli"
 
 private fun getKsuDaemonPath(): String {
-    return ksuApp.applicationInfo.nativeLibraryDir + File.separator + "libzakomk.so"
+    return ksuApp.applicationInfo.nativeLibraryDir + File.separator + "libzakozako.so"
 }
 
 object KsuCli {
@@ -76,9 +76,9 @@ fun createRootShell(globalMnt: Boolean = false): Shell {
         Log.w(TAG, "ksu failed: ", e)
         try {
             if (globalMnt) {
-                builder.build("su")
-            } else {
                 builder.build("su", "-mm")
+            } else {
+                builder.build("su")
             }
         } catch (e: Throwable) {
             Log.e(TAG, "su failed: ", e)
@@ -436,8 +436,8 @@ fun restartApp(packageName: String) {
     launchApp(packageName)
 }
 
-private fun getSuSFSDaemonPath(): String {
-    return ksuApp.applicationInfo.nativeLibraryDir + File.separator + "libzakomksd.so"
+fun getSuSFSDaemonPath(): String {
+    return ksuApp.applicationInfo.nativeLibraryDir + File.separator + "libzakozakozako.so"
 }
 
 fun getSuSFS(): String {
@@ -481,7 +481,7 @@ fun susfsSUS_SU_Mode(): String {
     return result
 }
 
-private fun getKpmmgrPath(): String {
+fun getKpmmgrPath(): String {
     return ksuApp.applicationInfo.nativeLibraryDir + File.separator + "libkpmmgr.so"
 }
 
@@ -489,48 +489,62 @@ private fun getKpmmgrPath(): String {
 fun loadKpmModule(path: String, args: String? = null): String {
     val shell = getRootShell()
     val cmd = "${getKpmmgrPath()} load $path ${args ?: ""}"
-    val result = ShellUtils.fastCmd(shell, cmd)
-    return result
+    return ShellUtils.fastCmd(shell, cmd)
 }
 
 fun unloadKpmModule(name: String): String {
     val shell = getRootShell()
     val cmd = "${getKpmmgrPath()} unload $name"
-    val result = ShellUtils.fastCmd(shell, cmd)
-    return result
+    return ShellUtils.fastCmd(shell, cmd)
 }
 
-fun getKpmModuleCount(): String {
+fun getKpmModuleCount(): Int {
     val shell = getRootShell()
     val cmd = "${getKpmmgrPath()} num"
     val result = ShellUtils.fastCmd(shell, cmd)
-    return result
+    return result.trim().toIntOrNull() ?: 0
+}
+
+fun runCmd(shell : Shell, cmd : String) : String {
+    return shell.newJob()
+        .add(cmd)
+        .to(mutableListOf<String>(), null)
+        .exec().out
+        .joinToString("\n")
 }
 
 fun listKpmModules(): String {
     val shell = getRootShell()
     val cmd = "${getKpmmgrPath()} list"
-    val result = ShellUtils.fastCmd(shell, cmd)
-    return result
+    return try {
+        runCmd(shell, cmd).trim()
+    } catch (e: Exception) {
+        Log.e(TAG, "Failed to list KPM modules", e)
+        ""
+    }
 }
 
 fun getKpmModuleInfo(name: String): String {
     val shell = getRootShell()
     val cmd = "${getKpmmgrPath()} info $name"
-    val result = ShellUtils.fastCmd(shell, cmd)
-    return result
+    return try {
+        runCmd(shell, cmd).trim()
+    } catch (e: Exception) {
+        Log.e(TAG, "Failed to get KPM module info: $name", e)
+        ""
+    }
 }
 
-fun controlKpmModule(name: String, args: String? = null): String {
+fun controlKpmModule(name: String, args: String? = null): Int {
     val shell = getRootShell()
-    val cmd = "${getKpmmgrPath()} control $name ${args ?: ""}"
-    val result = ShellUtils.fastCmd(shell, cmd)
-    return result
+    val cmd = """${getKpmmgrPath()} control $name "${args ?: ""}""""
+    val result = runCmd(shell, cmd)
+    return result.trim().toIntOrNull() ?: -1
 }
 
-fun printKpmModules(): String {
+fun getKpmVersion(): String {
     val shell = getRootShell()
-    val cmd = "${getKpmmgrPath()} print"
+    val cmd = "${getKpmmgrPath()} version"
     val result = ShellUtils.fastCmd(shell, cmd)
-    return result
+    return result.trim()
 }

manager/app/src/main/java/com/sukisu/ultra/ui/util/LogEvent.kt

@@ -1,11 +1,11 @@
-package shirkneko.zako.sukisu.ui.util
+package com.sukisu.ultra.ui.util
 
 import android.content.Context
 import android.os.Build
 import android.system.Os
 import com.topjohnwu.superuser.ShellUtils
-import shirkneko.zako.sukisu.Natives
-import shirkneko.zako.sukisu.ui.screen.getManagerVersion
+import com.sukisu.ultra.Natives
+import com.sukisu.ultra.ui.screen.getManagerVersion
 import java.io.File
 import java.io.FileWriter
 import java.io.PrintWriter
@@ -24,7 +24,7 @@ fun getBugreportFile(context: Context): File {
     val pstoreFile = File(bugreportDir, "pstore.tar.gz")
     // Xiaomi/Readmi devices have diag in /data/vendor/diag
     val diagFile = File(bugreportDir, "diag.tar.gz")
-    val opulsFile = File(bugreportDir, "opuls.tar.gz")
+    val oplusFile = File(bugreportDir, "oplus.tar.gz")
     val bootlogFile = File(bugreportDir, "bootlog.tar.gz")
     val mountsFile = File(bugreportDir, "mounts.txt")
     val fileSystemsFile = File(bugreportDir, "filesystems.txt")
@@ -46,7 +46,7 @@ fun getBugreportFile(context: Context): File {
     shell.newJob().add("tar -czf ${dropboxFile.absolutePath} -C /data/system/dropbox .").exec()
     shell.newJob().add("tar -czf ${pstoreFile.absolutePath} -C /sys/fs/pstore .").exec()
     shell.newJob().add("tar -czf ${diagFile.absolutePath} -C /data/vendor/diag . --exclude=./minidump.gz").exec()
-    shell.newJob().add("tar -czf ${opulsFile.absolutePath} -C /mnt/oplus/op2/media/log/boot_log/ .").exec()
+    shell.newJob().add("tar -czf ${oplusFile.absolutePath} -C /mnt/oplus/op2/media/log/boot_log/ .").exec()
     shell.newJob().add("tar -czf ${bootlogFile.absolutePath} -C /data/adb/ksu/log .").exec()
 
     shell.newJob().add("cat /proc/1/mountinfo > ${mountsFile.absolutePath}").exec()

manager/app/src/main/java/com/sukisu/ultra/ui/util/ModuleModify.kt

@@ -1,4 +1,4 @@
-package shirkneko.zako.sukisu.ui.util
+package com.sukisu.ultra.ui.util
 
 import android.app.AlertDialog
 import android.content.Context
@@ -16,7 +16,7 @@ import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
-import shirkneko.zako.sukisu.R
+import com.sukisu.ultra.R
 import java.io.BufferedReader
 import java.io.IOException
 import java.io.InputStreamReader

manager/app/src/main/java/com/sukisu/ultra/ui/util/ModuleUtils.kt

@@ -0,0 +1,105 @@
+package com.sukisu.ultra.ui.util
+
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import java.io.BufferedReader
+import java.io.InputStreamReader
+import java.nio.charset.StandardCharsets
+import java.util.zip.ZipInputStream
+import com.sukisu.ultra.R
+import android.util.Log
+import java.io.IOException
+
+object ModuleUtils {
+    private const val TAG = "ModuleUtils"
+
+    fun extractModuleName(context: Context, uri: Uri): String {
+        if (uri == Uri.EMPTY) {
+            Log.e(TAG, "The supplied URI is empty")
+            return context.getString(R.string.unknown_module)
+        }
+
+        return try {
+            Log.d(TAG, "Start extracting module names from URIs: $uri")
+
+            // 从URI路径中提取文件名
+            val fileName = uri.lastPathSegment?.let { path ->
+                val lastSlash = path.lastIndexOf('/')
+                if (lastSlash != -1 && lastSlash < path.length - 1) {
+                    path.substring(lastSlash + 1)
+                } else {
+                    path
+                }
+            }?.removeSuffix(".zip") ?: context.getString(R.string.unknown_module)
+
+            var formattedFileName = fileName.replace(Regex("[^a-zA-Z0-9\\s\\-_.@()\\u4e00-\\u9fa5]"), "").trim()
+            var moduleName = formattedFileName
+
+            try {
+                // 打开ZIP文件输入流
+                val inputStream = context.contentResolver.openInputStream(uri)
+                if (inputStream == null) {
+                    Log.e(TAG, "Unable to get input stream from URI: $uri")
+                    return formattedFileName
+                }
+
+                val zipInputStream = ZipInputStream(inputStream)
+                var entry = zipInputStream.nextEntry
+
+                // 遍历ZIP文件中的条目，查找module.prop文件
+                while (entry != null) {
+                    if (entry.name == "module.prop") {
+                        val reader = BufferedReader(InputStreamReader(zipInputStream, StandardCharsets.UTF_8))
+                        var line: String?
+                        var nameFound = false
+                        while (reader.readLine().also { line = it } != null) {
+                            if (line?.startsWith("name=") == true) {
+                                moduleName = line.substringAfter("=")
+                                moduleName = moduleName.replace(Regex("[^a-zA-Z0-9\\s\\-_.@()\\u4e00-\\u9fa5]"), "").trim()
+                                nameFound = true
+                                break
+                            }
+                        }
+                        break
+                    }
+                    entry = zipInputStream.nextEntry
+                }
+                zipInputStream.close()
+                Log.d(TAG, "Successfully extracted module name: $moduleName")
+                moduleName
+            } catch (e: IOException) {
+                Log.e(TAG, "Error reading ZIP file: ${e.message}")
+                formattedFileName
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Exception when extracting module name: ${e.message}")
+            context.getString(R.string.unknown_module)
+        }
+    }
+
+    // 验证URI是否有效并可访问
+    fun isUriAccessible(context: Context, uri: Uri): Boolean {
+        if (uri == Uri.EMPTY) return false
+
+        return try {
+            val inputStream = context.contentResolver.openInputStream(uri)
+            inputStream?.close()
+            inputStream != null
+        } catch (e: Exception) {
+            Log.e(TAG, "The URI is inaccessible: $uri, Error: ${e.message}")
+            false
+        }
+    }
+
+    // 获取URI的持久权限
+    fun takePersistableUriPermission(context: Context, uri: Uri) {
+        try {
+            val flags = Intent.FLAG_GRANT_READ_URI_PERMISSION
+            context.contentResolver.takePersistableUriPermission(uri, flags)
+            Log.d(TAG, "Persistent permissions for URIs have been obtained: $uri")
+        } catch (e: Exception) {
+            Log.e(TAG, "Unable to get persistent permissions on URIs: $uri, Error: ${e.message}")
+        }
+    }
+}

manager/app/src/main/java/com/sukisu/ultra/ui/util/SELinuxChecker.kt

@@ -0,0 +1,31 @@
+package com.sukisu.ultra.ui.util
+
+import android.content.Context
+import com.topjohnwu.superuser.Shell
+import com.sukisu.ultra.R
+
+fun getSELinuxStatus(context: Context): String {
+    val shell = Shell.Builder.create().build("sh")
+    val list = ArrayList<String>()
+
+    val result = shell.use {
+        it.newJob().add("getenforce").to(list, list).exec()
+    }
+
+    val output = list.joinToString("\n").trim()
+
+    return if (result.isSuccess) {
+        when (output) {
+            "Enforcing" -> context.getString(R.string.selinux_status_enforcing)
+            "Permissive" -> context.getString(R.string.selinux_status_permissive)
+            "Disabled" -> context.getString(R.string.selinux_status_disabled)
+            else -> context.getString(R.string.selinux_status_unknown)
+        }
+    } else {
+        if (output.contains("Permission denied")) {
+            context.getString(R.string.selinux_status_enforcing)
+        } else {
+            context.getString(R.string.selinux_status_unknown)
+        }
+    }
+}

manager/app/src/main/java/com/sukisu/ultra/ui/util/module/LatestVersionInfo.kt

@@ -1,4 +1,4 @@
-package shirkneko.zako.sukisu.ui.util.module
+package com.sukisu.ultra.ui.util.module
 
 data class LatestVersionInfo(
     val versionCode : Int = 0,

manager/app/src/main/java/com/sukisu/ultra/ui/viewmodel/HomeViewModel.kt

@@ -0,0 +1,290 @@
+package com.sukisu.ultra.ui.viewmodel
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.os.Build
+import android.os.SystemClock
+import android.system.Os
+import android.util.Log
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import com.dergoogler.mmrl.platform.Platform.Companion.context
+import com.google.gson.Gson
+import com.sukisu.ultra.KernelVersion
+import com.sukisu.ultra.Natives
+import com.sukisu.ultra.getKernelVersion
+import com.sukisu.ultra.ksuApp
+import com.sukisu.ultra.ui.util.*
+import com.sukisu.ultra.ui.util.module.LatestVersionInfo
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import androidx.core.content.edit
+
+class HomeViewModel : ViewModel() {
+    companion object {
+        private const val TAG = "HomeViewModel"
+        private const val CACHE_DURATION = 5 * 60 * 1000L
+        private const val PREFS_NAME = "home_cache"
+        private const val KEY_SYSTEM_STATUS = "system_status"
+        private const val KEY_SYSTEM_INFO = "system_info"
+        private const val KEY_VERSION_INFO = "version_info"
+        private const val KEY_LAST_UPDATE = "last_update_time"
+    }
+
+    // 系统状态
+    data class SystemStatus(
+        val isManager: Boolean = false,
+        val ksuVersion: Int? = null,
+        val lkmMode: Boolean? = null,
+        val kernelVersion: KernelVersion = getKernelVersion(),
+        val isRootAvailable: Boolean = false,
+        val isKpmConfigured: Boolean = false,
+        val requireNewKernel: Boolean = false
+    )
+
+    // 系统信息
+    data class SystemInfo(
+        val kernelRelease: String = "",
+        val androidVersion: String = "",
+        val deviceModel: String = "",
+        val managerVersion: Pair<String, Long> = Pair("", 0L),
+        val seLinuxStatus: String = "",
+        val kpmVersion: String = "",
+        val suSFSStatus: String = "",
+        val suSFSVersion: String = "",
+        val suSFSVariant: String = "",
+        val suSFSFeatures: String = "",
+        val susSUMode: String = "",
+        val superuserCount: Int = 0,
+        val moduleCount: Int = 0,
+        val kpmModuleCount: Int = 0
+    )
+
+    private val gson = Gson()
+    private val prefs by lazy { ksuApp.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE) }
+
+    var systemStatus by mutableStateOf(SystemStatus())
+        private set
+
+    var systemInfo by mutableStateOf(SystemInfo())
+        private set
+
+    var latestVersionInfo by mutableStateOf(LatestVersionInfo())
+        private set
+
+    var isSimpleMode by mutableStateOf(false)
+        private set
+    var isHideVersion by mutableStateOf(false)
+        private set
+    var isHideOtherInfo by mutableStateOf(false)
+        private set
+    var isHideSusfsStatus by mutableStateOf(false)
+        private set
+    var isHideLinkCard by mutableStateOf(false)
+        private set
+    var showKpmInfo by mutableStateOf(true)
+        private set
+
+    fun loadUserSettings(context: Context) {
+        viewModelScope.launch(Dispatchers.IO) {
+            val prefs = context.getSharedPreferences("settings", Context.MODE_PRIVATE)
+            isSimpleMode = prefs.getBoolean("is_simple_mode", false)
+            isHideVersion = prefs.getBoolean("is_hide_version", false)
+            isHideOtherInfo = prefs.getBoolean("is_hide_other_info", false)
+            isHideSusfsStatus = prefs.getBoolean("is_hide_susfs_status", false)
+            isHideLinkCard = prefs.getBoolean("is_hide_link_card", false)
+            showKpmInfo = prefs.getBoolean("show_kpm_info", true)
+        }
+    }
+
+    fun initializeData() {
+        viewModelScope.launch {
+            val currentTime = System.currentTimeMillis()
+            val lastUpdateTime = prefs.getLong(KEY_LAST_UPDATE, 0)
+            val shouldRefresh = currentTime - lastUpdateTime > CACHE_DURATION
+
+            if (!shouldRefresh) {
+                loadCachedData()
+            } else {
+                fetchAndSaveData()
+            }
+        }
+    }
+
+    private fun loadCachedData() {
+        prefs.getString(KEY_SYSTEM_STATUS, null)?.let {
+            systemStatus = gson.fromJson(it, SystemStatus::class.java)
+        }
+        prefs.getString(KEY_SYSTEM_INFO, null)?.let {
+            systemInfo = gson.fromJson(it, SystemInfo::class.java)
+        }
+        prefs.getString(KEY_VERSION_INFO, null)?.let {
+            latestVersionInfo = gson.fromJson(it, LatestVersionInfo::class.java)
+        }
+    }
+
+    private suspend fun fetchAndSaveData() {
+        fetchSystemStatus()
+        fetchSystemInfo()
+        withContext(Dispatchers.IO) {
+            prefs.edit {
+                putString(KEY_SYSTEM_STATUS, gson.toJson(systemStatus))
+                putString(KEY_SYSTEM_INFO, gson.toJson(systemInfo))
+                putString(KEY_VERSION_INFO, gson.toJson(latestVersionInfo))
+                putLong(KEY_LAST_UPDATE, System.currentTimeMillis())
+            }
+        }
+    }
+
+    fun checkForUpdates(context: Context) {
+        viewModelScope.launch(Dispatchers.IO) {
+            try {
+                val checkUpdate = context.getSharedPreferences("settings", Context.MODE_PRIVATE)
+                    .getBoolean("check_update", true)
+
+                if (checkUpdate) {
+                    val currentTime = System.currentTimeMillis()
+                    val lastUpdateTime = prefs.getLong(KEY_LAST_UPDATE, 0)
+                    val shouldRefresh = currentTime - lastUpdateTime > CACHE_DURATION
+
+                    if (shouldRefresh) {
+                        val start = SystemClock.elapsedRealtime()
+                        val newVersionInfo = checkNewVersion()
+                        latestVersionInfo = newVersionInfo
+                        prefs.edit { putString(KEY_VERSION_INFO, gson.toJson(newVersionInfo)) }
+                        Log.i(TAG, "Update check completed in ${SystemClock.elapsedRealtime() - start}ms")
+                    }
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "Error checking for updates", e)
+            }
+        }
+    }
+
+    fun refreshAllData(context: Context) {
+        viewModelScope.launch {
+            try {
+                fetchAndSaveData()
+                checkForUpdates(context)
+            } catch (e: Exception) {
+                Log.e(TAG, "Error refreshing data", e)
+            }
+        }
+    }
+
+    private suspend fun fetchSystemStatus() {
+        withContext(Dispatchers.IO) {
+            try {
+                val kernelVersion = getKernelVersion()
+                val isManager = Natives.becomeManager(ksuApp.packageName)
+                val ksuVersion = if (isManager) Natives.version else null
+                val lkmMode = ksuVersion?.let {
+                    if (it >= Natives.MINIMAL_SUPPORTED_KERNEL_LKM && kernelVersion.isGKI()) Natives.isLkmMode else null
+                }
+
+                systemStatus = SystemStatus(
+                    isManager = isManager,
+                    ksuVersion = ksuVersion,
+                    lkmMode = lkmMode,
+                    kernelVersion = kernelVersion,
+                    isRootAvailable = rootAvailable(),
+                    isKpmConfigured = Natives.isKPMEnabled(),
+                    requireNewKernel = isManager && Natives.requireNewKernel()
+                )
+            } catch (e: Exception) {
+                Log.e(TAG, "Error fetching system status", e)
+            }
+        }
+    }
+
+    @SuppressLint("RestrictedApi")
+    private suspend fun fetchSystemInfo() {
+        withContext(Dispatchers.IO) {
+            try {
+                val uname = Os.uname()
+                val kpmVersion = getKpmVersion()
+                val suSFS = getSuSFS()
+                var suSFSVersion = ""
+                var suSFSVariant = ""
+                var suSFSFeatures = ""
+                var susSUMode = ""
+
+                if (suSFS == "Supported") {
+                    suSFSVersion = getSuSFSVersion()
+                    if (suSFSVersion.isNotEmpty()) {
+                        suSFSVariant = getSuSFSVariant()
+                        suSFSFeatures = getSuSFSFeatures()
+                        val isSUS_SU = suSFSFeatures == "CONFIG_KSU_SUSFS_SUS_SU"
+                        if (isSUS_SU) {
+                            susSUMode = try {
+                                susfsSUS_SU_Mode().toString()
+                            } catch (_: Exception) {
+                                ""
+                            }
+                        }
+                    }
+                }
+
+                systemInfo = SystemInfo(
+                    kernelRelease = uname.release,
+                    androidVersion = Build.VERSION.RELEASE,
+                    deviceModel = getDeviceModel(),
+                    managerVersion = getManagerVersion(ksuApp.applicationContext),
+                    seLinuxStatus = getSELinuxStatus(context),
+                    kpmVersion = kpmVersion,
+                    suSFSStatus = suSFS,
+                    suSFSVersion = suSFSVersion,
+                    suSFSVariant = suSFSVariant,
+                    suSFSFeatures = suSFSFeatures,
+                    susSUMode = susSUMode,
+                    superuserCount = getSuperuserCount(),
+                    moduleCount = getModuleCount(),
+                    kpmModuleCount = getKpmModuleCount()
+                )
+            } catch (e: Exception) {
+                Log.e(TAG, "Error fetching system info", e)
+            }
+        }
+    }
+
+    @SuppressLint("PrivateApi")
+    private fun getDeviceModel(): String {
+        return try {
+            val systemProperties = Class.forName("android.os.SystemProperties")
+            val getMethod = systemProperties.getMethod("get", String::class.java, String::class.java)
+            val marketNameKeys = listOf(
+                "ro.product.marketname",          // Xiaomi
+                "ro.vendor.oplus.market.name",    // Oppo, OnePlus, Realme
+                "ro.vivo.market.name",            // Vivo
+                "ro.config.marketing_name"        // Huawei
+            )
+            var result = Build.DEVICE
+            for (key in marketNameKeys) {
+                val marketName = getMethod.invoke(null, key, "") as String
+                if (marketName.isNotEmpty()) {
+                    result = marketName
+                    break
+                }
+            }
+            result
+        } catch (e: Exception) {
+            Log.e(TAG, "Error getting device model", e)
+            Build.DEVICE
+        }
+    }
+
+    private fun getManagerVersion(context: Context): Pair<String, Long> {
+        return try {
+            val packageInfo = context.packageManager.getPackageInfo(context.packageName, 0)!!
+            val versionCode = androidx.core.content.pm.PackageInfoCompat.getLongVersionCode(packageInfo)
+            Pair(packageInfo.versionName!!, versionCode)
+        } catch (e: Exception) {
+            Log.e(TAG, "Error getting manager version", e)
+            Pair("", 0L)
+        }
+    }
+}

manager/app/src/main/java/com/sukisu/ultra/ui/viewmodel/KpmViewModel.kt

@@ -0,0 +1,160 @@
+package com.sukisu.ultra.ui.viewmodel
+
+import android.util.Log
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import com.sukisu.ultra.ui.util.*
+
+/**
+ * @author ShirkNeko
+ * @date 2025/5/31.
+ */
+class KpmViewModel : ViewModel() {
+    var moduleList by mutableStateOf(emptyList<ModuleInfo>())
+        private set
+
+    var search by mutableStateOf("")
+        internal set
+
+    var isRefreshing by mutableStateOf(false)
+        private set
+
+    var currentModuleDetail by mutableStateOf("")
+        private set
+
+    fun fetchModuleList() {
+        viewModelScope.launch {
+            isRefreshing = true
+            try {
+                val moduleCount = getKpmModuleCount()
+                Log.d("KsuCli", "Module count: $moduleCount")
+
+                moduleList = getAllKpmModuleInfo()
+
+                // 获取 KPM 版本信息
+                val kpmVersion = getKpmVersion()
+                Log.d("KsuCli", "KPM Version: $kpmVersion")
+            } catch (e: Exception) {
+                Log.e("KsuCli", "获取模块列表失败", e)
+            } finally {
+                isRefreshing = false
+            }
+        }
+    }
+
+    private fun getAllKpmModuleInfo(): List<ModuleInfo> {
+        val result = mutableListOf<ModuleInfo>()
+        try {
+            val str = listKpmModules()
+            val moduleNames = str
+                .split("\n")
+                .filter { it.isNotBlank() }
+
+            for (name in moduleNames) {
+                try {
+                    val moduleInfo = parseModuleInfo(name)
+                    moduleInfo?.let { result.add(it) }
+                } catch (e: Exception) {
+                    Log.e("KsuCli", "Error processing module $name", e)
+                }
+            }
+        } catch (e: Exception) {
+            Log.e("KsuCli", "Failed to get module list", e)
+        }
+        return result
+    }
+
+    private fun parseModuleInfo(name: String): ModuleInfo? {
+        val info = getKpmModuleInfo(name)
+        if (info.isBlank()) return null
+
+        val properties = info.lineSequence()
+            .filter { line ->
+                val trimmed = line.trim()
+                trimmed.isNotEmpty() && !trimmed.startsWith("#")
+            }
+            .mapNotNull { line ->
+                line.split("=", limit = 2).let { parts ->
+                    when (parts.size) {
+                        2 -> parts[0].trim() to parts[1].trim()
+                        1 -> parts[0].trim() to ""
+                        else -> null
+                    }
+                }
+            }
+            .toMap()
+
+        return ModuleInfo(
+            id = name,
+            name = properties["name"] ?: name,
+            version = properties["version"] ?: "",
+            author = properties["author"] ?: "",
+            description = properties["description"] ?: "",
+            args = properties["args"] ?: "",
+            enabled = true,
+            hasAction = true
+        )
+    }
+
+    fun loadModuleDetail(moduleId: String) {
+        viewModelScope.launch {
+            try {
+                currentModuleDetail = withContext(Dispatchers.IO) {
+                    getKpmModuleInfo(moduleId)
+                }
+                Log.d("KsuCli", "Module detail loaded: $currentModuleDetail")
+            } catch (e: Exception) {
+                Log.e("KsuCli", "Failed to load module detail", e)
+                currentModuleDetail = "Error: ${e.message}"
+            }
+        }
+    }
+
+    var showInputDialog by mutableStateOf(false)
+        private set
+
+    var selectedModuleId by mutableStateOf<String?>(null)
+        private set
+
+    var inputArgs by mutableStateOf("")
+        private set
+
+    fun showInputDialog(moduleId: String) {
+        selectedModuleId = moduleId
+        showInputDialog = true
+    }
+
+    fun hideInputDialog() {
+        showInputDialog = false
+        selectedModuleId = null
+        inputArgs = ""
+    }
+
+    fun updateInputArgs(args: String) {
+        inputArgs = args
+    }
+
+    fun executeControl(): Int {
+        val moduleId = selectedModuleId ?: return -1
+        val result = controlKpmModule(moduleId, inputArgs)
+        hideInputDialog()
+        return result
+    }
+
+    data class ModuleInfo(
+        val id: String,
+        val name: String,
+        val version: String,
+        val author: String,
+        val description: String,
+        val args: String,
+        val enabled: Boolean,
+        val hasAction: Boolean
+    )
+}

manager/app/src/main/java/com/sukisu/ultra/ui/viewmodel/ModuleViewModel.kt

@@ -1,4 +1,4 @@
-package shirkneko.zako.sukisu.ui.viewmodel
+package com.sukisu.ultra.ui.viewmodel
 
 import android.os.SystemClock
 import android.util.Log
@@ -8,20 +8,29 @@ import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.setValue
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
+import com.dergoogler.mmrl.platform.model.ModuleConfig
+import com.dergoogler.mmrl.platform.model.ModuleConfig.Companion.asModuleConfig
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
-import shirkneko.zako.sukisu.ui.util.HanziToPinyin
-import shirkneko.zako.sukisu.ui.util.listModules
+import com.sukisu.ultra.ui.util.HanziToPinyin
+import com.sukisu.ultra.ui.util.listModules
+import kotlinx.coroutines.withContext
 import org.json.JSONArray
 import org.json.JSONObject
 import java.text.Collator
 import java.util.Locale
+import java.util.concurrent.TimeUnit
 
+/**
+ * @author ShirkNeko
+ * @date 2025/5/31.
+ */
 class ModuleViewModel : ViewModel() {
 
     companion object {
         private const val TAG = "ModuleViewModel"
         private var modules by mutableStateOf<List<ModuleInfo>>(emptyList())
+        private const val CUSTOM_USER_AGENT = "SukiSU-Ultra/2.0"
     }
 
     class ModuleInfo(
@@ -38,13 +47,7 @@ class ModuleViewModel : ViewModel() {
         val hasWebUi: Boolean,
         val hasActionScript: Boolean,
         val dirId: String, // real module id (dir name)
-    )
-
-    data class ModuleUpdateInfo(
-        val version: String,
-        val versionCode: Int,
-        val zipUrl: String,
-        val changelog: String,
+        var config: ModuleConfig? = null,
     )
 
     var isRefreshing by mutableStateOf(false)
@@ -105,9 +108,42 @@ class ModuleViewModel : ViewModel() {
                             obj.optString("updateJson"),
                             obj.optBoolean("web"),
                             obj.optBoolean("action"),
-                            obj.getString("dir_id"),
+                            obj.getString("dir_id")
                         )
                     }.toList()
+                launch {
+                    modules.forEach { module ->
+                        withContext(Dispatchers.IO) {
+                            try {
+                                runCatching {
+                                    module.config = module.id.asModuleConfig
+                                }.onFailure { e ->
+                                    Log.e(TAG, "Failed to load config from id for module ${module.id}", e)
+                                }
+                                if (module.config == null) {
+                                    runCatching {
+                                        module.config = module.name.asModuleConfig
+                                    }.onFailure { e ->
+                                        Log.e(TAG, "Failed to load config from name for module ${module.id}", e)
+                                    }
+                                }
+                                if (module.config == null) {
+                                    runCatching {
+                                        module.config = module.description.asModuleConfig
+                                    }.onFailure { e ->
+                                        Log.e(TAG, "Failed to load config from description for module ${module.id}", e)
+                                    }
+                                }
+                                if (module.config == null) {
+                                    module.config = ModuleConfig()
+                                }
+                            } catch (e: Exception) {
+                                Log.e(TAG, "Failed to load any config for module ${module.id}", e)
+                                module.config = ModuleConfig()
+                            }
+                        }
+                    }
+                }
                 isNeedRefresh = false
             }.onFailure { e ->
                 Log.e(TAG, "fetchModuleList: ", e)
@@ -124,6 +160,10 @@ class ModuleViewModel : ViewModel() {
         }
     }
 
+    private fun sanitizeVersionString(version: String): String {
+        return version.replace(Regex("[^a-zA-Z0-9.\\-_]"), "_")
+    }
+
     fun checkUpdate(m: ModuleInfo): Triple<String, String, String> {
         val empty = Triple("", "", "")
         if (m.updateJson.isEmpty() || m.remove || m.update || !m.enabled) {
@@ -133,19 +173,32 @@ class ModuleViewModel : ViewModel() {
         val result = kotlin.runCatching {
             val url = m.updateJson
             Log.i(TAG, "checkUpdate url: $url")
-            val response = okhttp3.OkHttpClient()
-                .newCall(
-                    okhttp3.Request.Builder()
-                        .url(url)
-                        .build()
-                ).execute()
+
+            val client = okhttp3.OkHttpClient.Builder()
+                .connectTimeout(15, TimeUnit.SECONDS)
+                .readTimeout(30, TimeUnit.SECONDS)
+                .writeTimeout(15, TimeUnit.SECONDS)
+                .build()
+
+            val request = okhttp3.Request.Builder()
+                .url(url)
+                .header("User-Agent", CUSTOM_USER_AGENT)
+                .build()
+
+            val response = client.newCall(request).execute()
+
             Log.d(TAG, "checkUpdate code: ${response.code}")
             if (response.isSuccessful) {
                 response.body?.string() ?: ""
             } else {
+                Log.d(TAG, "checkUpdate failed: ${response.message}")
                 ""
             }
-        }.getOrDefault("")
+        }.getOrElse { e ->
+            Log.e(TAG, "checkUpdate exception", e)
+            ""
+        }
+
         Log.i(TAG, "checkUpdate result: $result")
 
         if (result.isEmpty()) {
@@ -156,7 +209,8 @@ class ModuleViewModel : ViewModel() {
             JSONObject(result)
         }.getOrNull() ?: return empty
 
-        val version = updateJson.optString("version", "")
+        var version = updateJson.optString("version", "")
+        version = sanitizeVersionString(version)
         val versionCode = updateJson.optInt("versionCode", 0)
         val zipUrl = updateJson.optString("zipUrl", "")
         val changelog = updateJson.optString("changelog", "")

manager/app/src/main/java/com/sukisu/ultra/ui/viewmodel/SuperUserViewModel.kt

@@ -1,38 +1,40 @@
-package shirkneko.zako.sukisu.ui.viewmodel
+package com.sukisu.ultra.ui.viewmodel
 
-import android.content.ComponentName
-import android.content.Intent
-import android.content.ServiceConnection
 import android.content.pm.ApplicationInfo
 import android.content.pm.PackageInfo
-import android.os.IBinder
 import android.os.Parcelable
 import android.os.SystemClock
 import android.util.Log
+import android.widget.Toast
 import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.setValue
 import androidx.lifecycle.ViewModel
-import com.topjohnwu.superuser.Shell
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import kotlinx.parcelize.Parcelize
-import shirkneko.zako.sukisu.IKsuInterface
-import shirkneko.zako.sukisu.Natives
-import shirkneko.zako.sukisu.ksuApp
-import shirkneko.zako.sukisu.ui.KsuService
-import shirkneko.zako.sukisu.ui.util.HanziToPinyin
-import shirkneko.zako.sukisu.ui.util.KsuCli
+import com.sukisu.ultra.Natives
+import com.sukisu.ultra.ksuApp
+import com.sukisu.ultra.ui.util.HanziToPinyin
 import java.text.Collator
 import java.util.*
-import kotlin.coroutines.resume
-import kotlin.coroutines.suspendCoroutine
+import com.dergoogler.mmrl.platform.Platform
+import com.dergoogler.mmrl.platform.TIMEOUT_MILLIS
+import com.sukisu.ultra.ui.webui.getInstalledPackagesAll
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.withTimeoutOrNull
 
+
+/**
+ * @author ShirkNeko
+ * @date 2025/5/31.
+ */
 class SuperUserViewModel : ViewModel() {
+    val isPlatformAlive get() = Platform.isAlive
     companion object {
         private const val TAG = "SuperUserViewModel"
-        private var apps by mutableStateOf<List<AppInfo>>(emptyList())
+        var apps by mutableStateOf<List<AppInfo>>(emptyList())
     }
 
     @Parcelize
@@ -68,9 +70,9 @@ class SuperUserViewModel : ViewModel() {
 
     // 批量操作相关状态
     var showBatchActions by mutableStateOf(false)
-        private set
+        internal set
     var selectedApps by mutableStateOf<Set<String>>(emptySet())
-        private set
+        internal set
 
     private val sortedList by derivedStateOf {
         val comparator = compareBy<AppInfo> {
@@ -142,55 +144,60 @@ class SuperUserViewModel : ViewModel() {
         fetchAppList() // 刷新列表以显示最新状态
     }
 
-    private suspend fun connectKsuService(
-        onDisconnect: () -> Unit = {}
-    ): Pair<IBinder, ServiceConnection> = suspendCoroutine { continuation ->
-        val connection = object : ServiceConnection {
-            override fun onServiceDisconnected(name: ComponentName?) {
-                onDisconnect()
-            }
-
-            override fun onServiceConnected(name: ComponentName?, binder: IBinder?) {
-                continuation.resume(binder as IBinder to this)
+    // 批量更新权限和umount模块设置
+    suspend fun updateBatchPermissions(allowSu: Boolean, umountModules: Boolean? = null) {
+        selectedApps.forEach { packageName ->
+            val app = apps.find { it.packageName == packageName }
+            app?.let {
+                val profile = Natives.getAppProfile(packageName, it.uid)
+                val updatedProfile = profile.copy(
+                    allowSu = allowSu,
+                    umountModules = umountModules ?: profile.umountModules,
+                    nonRootUseDefault = false
+                )
+                if (Natives.setAppProfile(updatedProfile)) {
+                    apps = apps.map { app ->
+                        if (app.packageName == packageName) {
+                            app.copy(profile = updatedProfile)
+                        } else {
+                            app
+                        }
+                    }
+                }
             }
         }
-
-        val intent = Intent(ksuApp, KsuService::class.java)
-
-        val task = KsuService.bindOrTask(
-            intent,
-            Shell.EXECUTOR,
-            connection,
-        )
-        val shell = KsuCli.SHELL
-        task?.let { it1 -> shell.execTask(it1) }
+        clearSelection()
+        showBatchActions = false // 批量操作完成后退出批量模式
+        fetchAppList() // 刷新列表以显示最新状态
     }
 
-    private fun stopKsuService() {
-        val intent = Intent(ksuApp, KsuService::class.java)
-        KsuService.stop(intent)
+    // 更新本地应用配置
+    fun updateAppProfileLocally(packageName: String, updatedProfile: Natives.Profile) {
+        apps = apps.map { app ->
+            if (app.packageName == packageName) {
+                app.copy(profile = updatedProfile)
+            } else {
+                app
+            }
+        }
     }
 
     suspend fun fetchAppList() {
         isRefreshing = true
 
-        val result = connectKsuService {
-            Log.w(TAG, "KsuService disconnected")
-        }
-
         withContext(Dispatchers.IO) {
+            withTimeoutOrNull(TIMEOUT_MILLIS) {
+                while (!isPlatformAlive) {
+                    delay(500)
+                }
+            } ?: return@withContext // Exit early if timeout
             val pm = ksuApp.packageManager
             val start = SystemClock.elapsedRealtime()
 
-            val binder = result.first
-            val allPackages = IKsuInterface.Stub.asInterface(binder).getPackages(0)
-
-            withContext(Dispatchers.Main) {
-                stopKsuService()
+            val packages = Platform.getInstalledPackagesAll {
+                Log.e(TAG, "getInstalledPackagesAll:", it)
+                Toast.makeText(ksuApp, "Something went wrong, check logs", Toast.LENGTH_SHORT).show()
             }
-
-            val packages = allPackages.list
-
             apps = packages.map {
                 val appInfo = it.applicationInfo
                 val uid = appInfo!!.uid

manager/app/src/main/java/com/sukisu/ultra/ui/viewmodel/TemplateViewModel.kt

@@ -1,4 +1,4 @@
-package shirkneko.zako.sukisu.ui.viewmodel
+package com.sukisu.ultra.ui.viewmodel
 
 import android.os.Parcelable
 import android.util.Log
@@ -10,12 +10,12 @@ import androidx.lifecycle.ViewModel
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import kotlinx.parcelize.Parcelize
-import shirkneko.zako.sukisu.Natives
-import shirkneko.zako.sukisu.profile.Capabilities
-import shirkneko.zako.sukisu.profile.Groups
-import shirkneko.zako.sukisu.ui.util.getAppProfileTemplate
-import shirkneko.zako.sukisu.ui.util.listAppProfileTemplates
-import shirkneko.zako.sukisu.ui.util.setAppProfileTemplate
+import com.sukisu.ultra.Natives
+import com.sukisu.ultra.profile.Capabilities
+import com.sukisu.ultra.profile.Groups
+import com.sukisu.ultra.ui.util.getAppProfileTemplate
+import com.sukisu.ultra.ui.util.listAppProfileTemplates
+import com.sukisu.ultra.ui.util.setAppProfileTemplate
 import okhttp3.OkHttpClient
 import okhttp3.Request
 import org.json.JSONArray

manager/app/src/main/java/com/sukisu/ultra/ui/webui/KsuLibSuProvider.kt

@@ -0,0 +1,72 @@
+package com.sukisu.ultra.ui.webui
+
+import android.content.ServiceConnection
+import android.util.Log
+import android.content.pm.PackageInfo
+import com.dergoogler.mmrl.platform.Platform
+import com.dergoogler.mmrl.platform.model.IProvider
+import com.dergoogler.mmrl.platform.model.PlatformIntent
+import com.sukisu.ultra.ksuApp
+import com.sukisu.ultra.Natives
+import com.topjohnwu.superuser.ipc.RootService
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.withContext
+
+class KsuLibSuProvider : IProvider {
+    override val name = "KsuLibSu"
+
+    override fun isAvailable() = true
+
+    override suspend fun isAuthorized() = Natives.becomeManager(ksuApp.packageName)
+
+    private val serviceIntent
+        get() = PlatformIntent(
+            ksuApp,
+            Platform.KsuNext,
+            SuService::class.java
+        )
+
+    override fun bind(connection: ServiceConnection) {
+        RootService.bind(serviceIntent.intent, connection)
+    }
+
+    override fun unbind(connection: ServiceConnection) {
+        RootService.stop(serviceIntent.intent)
+    }
+}
+
+// webui x
+suspend fun initPlatform() = withContext(Dispatchers.IO) {
+    try {
+        val active = Platform.init {
+            this.context = ksuApp
+            this.platform = Platform.KsuNext
+            this.provider = from(KsuLibSuProvider())
+        }
+
+        while (!active) {
+            delay(1000)
+        }
+
+        return@withContext active
+    } catch (e: Exception) {
+        Log.e("KsuLibSu", "Failed to initialize platform", e)
+        return@withContext false
+    }
+}
+
+fun Platform.Companion.getInstalledPackagesAll(catch: (Exception) -> Unit = {}): List<PackageInfo> =
+    try {
+        val packages = mutableListOf<PackageInfo>()
+        val userInfos = userManager.getUsers()
+
+        for (userInfo in userInfos) {
+            packages.addAll(packageManager.getInstalledPackages(0, userInfo.id))
+        }
+
+        packages
+    } catch (e: Exception) {
+        catch(e)
+        packageManager.getInstalledPackages(0, userManager.myUserId)
+    }

manager/app/src/main/java/com/sukisu/ultra/ui/webui/MimeUtil.java

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package shirkneko.zako.sukisu.ui.webui;
+package com.sukisu.ultra.ui.webui;
 
 import java.net.URLConnection;
 

manager/app/src/main/java/com/sukisu/ultra/ui/webui/SuFilePathHandler.java

@@ -1,4 +1,4 @@
-package shirkneko.zako.sukisu.ui.webui;
+package com.sukisu.ultra.ui.webui;
 
 import android.content.Context;
 import android.util.Log;

manager/app/src/main/java/com/sukisu/ultra/ui/webui/SuService.kt

@@ -0,0 +1,14 @@
+package com.sukisu.ultra.ui.webui
+
+import android.content.Intent
+import android.os.IBinder
+import com.dergoogler.mmrl.platform.model.PlatformIntent.Companion.getPlatform
+import com.dergoogler.mmrl.platform.service.ServiceManager
+import com.topjohnwu.superuser.ipc.RootService
+
+class SuService : RootService() {
+    override fun onBind(intent: Intent): IBinder {
+        val mode = intent.getPlatform()
+        return ServiceManager(mode)
+    }
+}

manager/app/src/main/java/com/sukisu/ultra/ui/webui/WebUIActivity.kt

@@ -1,4 +1,4 @@
-package shirkneko.zako.sukisu.ui.webui
+package com.sukisu.ultra.ui.webui
 
 import android.annotation.SuppressLint
 import android.app.ActivityManager
@@ -15,9 +15,11 @@ import androidx.core.view.ViewCompat
 import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.updateLayoutParams
 import androidx.webkit.WebViewAssetLoader
+import com.dergoogler.mmrl.platform.model.ModId
 import com.topjohnwu.superuser.Shell
-import shirkneko.zako.sukisu.ui.util.createRootShell
+import com.sukisu.ultra.ui.util.createRootShell
 import java.io.File
+import com.dergoogler.mmrl.webui.interfaces.WXOptions
 
 @SuppressLint("SetJavaScriptEnabled")
 class WebUIActivity : ComponentActivity() {
@@ -41,7 +43,8 @@ class WebUIActivity : ComponentActivity() {
             @Suppress("DEPRECATION")
             setTaskDescription(ActivityManager.TaskDescription("KernelSU - $name"))
         } else {
-            val taskDescription = ActivityManager.TaskDescription.Builder().setLabel("KernelSU - $name").build()
+            val taskDescription =
+                ActivityManager.TaskDescription.Builder().setLabel("KernelSU - $name").build()
             setTaskDescription(taskDescription)
         }
 
@@ -82,7 +85,7 @@ class WebUIActivity : ComponentActivity() {
             settings.javaScriptEnabled = true
             settings.domStorageEnabled = true
             settings.allowFileAccess = false
-            webviewInterface = WebViewInterface(this@WebUIActivity, this, moduleDir)
+            webviewInterface = WebViewInterface(WXOptions(this@WebUIActivity, this, ModId(moduleId)))
             addJavascriptInterface(webviewInterface, "ksu")
             setWebViewClient(webViewClient)
             loadUrl("https://mui.kernelsu.org/index.html")

manager/app/src/main/java/com/sukisu/ultra/ui/webui/WebUIXActivity.kt

@@ -0,0 +1,112 @@
+package com.sukisu.ultra.ui.webui
+
+import android.app.ActivityManager
+import android.os.Build
+import android.os.Bundle
+import android.webkit.WebView
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.activity.enableEdgeToEdge
+import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.lifecycle.lifecycleScope
+import com.dergoogler.mmrl.platform.Platform
+import com.dergoogler.mmrl.platform.model.ModId
+import com.dergoogler.mmrl.ui.component.Loading
+import com.dergoogler.mmrl.webui.screen.WebUIScreen
+import com.dergoogler.mmrl.webui.util.rememberWebUIOptions
+import com.sukisu.ultra.BuildConfig
+import com.sukisu.ultra.ui.theme.KernelSUTheme
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+
+class WebUIXActivity : ComponentActivity() {
+    private lateinit var webView: WebView
+
+    private val userAgent
+        get(): String {
+            val ksuVersion = BuildConfig.VERSION_CODE
+
+            val platform = Platform.get("Unknown") {
+                platform.name
+            }
+
+            val platformVersion = Platform.get(-1) {
+                moduleManager.versionCode
+            }
+
+            val osVersion = Build.VERSION.RELEASE
+            val deviceModel = Build.MODEL
+
+            return "SukiSU /$ksuVersion (Linux; Android $osVersion; $deviceModel; $platform/$platformVersion)"
+        }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        enableEdgeToEdge()
+
+        webView = WebView(this)
+
+        lifecycleScope.launch {
+            initPlatform()
+        }
+
+        val moduleId = intent.getStringExtra("id")!!
+        val name = intent.getStringExtra("name")!!
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+            @Suppress("DEPRECATION")
+            setTaskDescription(ActivityManager.TaskDescription("KernelSU - $name"))
+        } else {
+            val taskDescription =
+                ActivityManager.TaskDescription.Builder().setLabel("KernelSU - $name").build()
+            setTaskDescription(taskDescription)
+        }
+
+        val prefs = getSharedPreferences("settings", MODE_PRIVATE)
+
+        setContent {
+            KernelSUTheme {
+                var isLoading by remember { mutableStateOf(true) }
+
+                LaunchedEffect(Platform.isAlive) {
+                    while (!Platform.isAlive) {
+                        delay(1000)
+                    }
+
+                    isLoading = false
+                }
+
+                if (isLoading) {
+                    Loading()
+                    return@KernelSUTheme
+                }
+
+                val webDebugging = prefs.getBoolean("enable_web_debugging", false)
+                val erudaInject = prefs.getBoolean("use_webuix_eruda", false)
+                val dark = isSystemInDarkTheme()
+
+                val options = rememberWebUIOptions(
+                    modId = ModId(moduleId),
+                    debug = webDebugging,
+                    appVersionCode = BuildConfig.VERSION_CODE,
+                    isDarkMode = dark,
+                    enableEruda = erudaInject,
+                    cls = WebUIXActivity::class.java,
+                    userAgentString = userAgent
+                )
+
+                WebUIScreen(
+                    webView = webView,
+                    options = options,
+                    interfaces = listOf(
+                        WebViewInterface.factory()
+                    )
+                )
+            }
+        }
+    }
+}

manager/app/src/main/java/com/sukisu/ultra/ui/webui/WebViewInterface.kt

@@ -1,32 +1,39 @@
-package shirkneko.zako.sukisu.ui.webui
+package com.sukisu.ultra.ui.webui
 
 import android.app.Activity
-import android.content.Context
 import android.os.Handler
 import android.os.Looper
 import android.text.TextUtils
 import android.view.Window
 import android.webkit.JavascriptInterface
-import android.webkit.WebView
 import android.widget.Toast
 import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.WindowInsetsControllerCompat
+import com.dergoogler.mmrl.webui.interfaces.WXInterface
+import com.dergoogler.mmrl.webui.interfaces.WXOptions
+import com.dergoogler.mmrl.webui.model.JavaScriptInterface
 import com.topjohnwu.superuser.CallbackList
 import com.topjohnwu.superuser.ShellUtils
 import com.topjohnwu.superuser.internal.UiThreadHandler
-import shirkneko.zako.sukisu.ui.util.createRootShell
-import shirkneko.zako.sukisu.ui.util.listModules
-import shirkneko.zako.sukisu.ui.util.withNewRootShell
+import com.sukisu.ultra.ui.util.createRootShell
+import com.sukisu.ultra.ui.util.listModules
+import com.sukisu.ultra.ui.util.withNewRootShell
 import org.json.JSONArray
 import org.json.JSONObject
+import com.sukisu.ultra.ui.util.*
 import java.io.File
 import java.util.concurrent.CompletableFuture
 
 class WebViewInterface(
-    val context: Context,
-    private val webView: WebView,
-    private val modDir: String
-) {
+    wxOptions: WXOptions,
+) : WXInterface(wxOptions) {
+    override var name: String = "ksu"
+
+    companion object {
+        fun factory() = JavaScriptInterface(WebViewInterface::class.java)
+    }
+
+    private val modDir get() = "/data/adb/modules/${modId.id}"
 
     @JavascriptInterface
     fun exec(cmd: String): String {
@@ -168,9 +175,9 @@ class WebViewInterface(
         if (context is Activity) {
             Handler(Looper.getMainLooper()).post {
                 if (enable) {
-                    hideSystemUI(context.window)
+                    hideSystemUI(activity.window)
                 } else {
-                    showSystemUI(context.window)
+                    showSystemUI(activity.window)
                 }
             }
         }
@@ -179,7 +186,7 @@ class WebViewInterface(
     @JavascriptInterface
     fun moduleInfo(): String {
         val moduleInfos = JSONArray(listModules())
-        var currentModuleInfo = JSONObject()
+        val currentModuleInfo = JSONObject()
         currentModuleInfo.put("moduleDir", modDir)
         val moduleId = File(modDir).getName()
         for (i in 0 until moduleInfos.length()) {
@@ -189,7 +196,7 @@ class WebViewInterface(
                 continue
             }
 
-            var keys = currentInfo.keys()
+            val keys = currentInfo.keys()
             for (key in keys) {
                 currentModuleInfo.put(key, currentInfo.get(key))
             }
@@ -197,6 +204,18 @@ class WebViewInterface(
         }
         return currentModuleInfo.toString()
     }
+
+    // =================== KPM支持 =============================
+
+    @JavascriptInterface
+    fun listAllKpm() : String {
+        return listKpmModules()
+    }
+
+    @JavascriptInterface
+    fun controlKpm(name: String, args: String) : Int {
+        return controlKpmModule(name, args)
+    }
 }
 
 fun hideSystemUI(window: Window) =