Bump version to 2.110

- Use SettingsManager instead StatusBarNotificationPresenter on A14 and HyperOS

.editorconfig

@@ -0,0 +1,17 @@
+# noinspection EditorConfigKeyCorrectness
+[{*.kt,*.kts}]
+ktlint_standard_annotation = disabled
+ktlint_standard_filename = disabled
+ktlint_standard_wrapping = disabled
+ktlint_standard_import-ordering = enabled
+ktlint_standard_max-line-length = disabled
+ktlint_standard_multiline-if-else = disabled
+ktlint_standard_argument-list-wrapping = disabled
+ktlint_standard_parameter-list-wrapping = disabled
+ktlint_standard_trailing-comma-on-declaration-site = disabled
+ktlint_function_signature_body_expression_wrapping = multiline
+ij_continuation_indent_size = 2
+indent_size = 4
+indent_style = space
+insert_final_newline = false
+max_line_length = 150

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,96 @@
+name: 问题与 BUG 反馈
+description: 问题反馈必须使用此模板进行提交
+labels: [ bug ]
+title: "[问题与 BUG 反馈] (在这里简要描述问题原因)"
+body:
+  - type: markdown
+    attributes:
+      value: |
+        ### 请在下方填写问题发生的具体原因和复现步骤。
+        
+        我们只接受 MIUI 或 HyperOS 正规官方版本系统，如果你正在使用官改 (第三方修改版) 请不要提交任何 BUG 与问题，我们无义务去解决，请自求多福。
+        
+        发生异常、崩溃、闪退或功能性问题，必须提交问题 Log (日志)，没有 Log 的 issues 将直接被关闭。
+  - type: input
+    attributes:
+      label: 模块版本
+      description: 请填写当前使用的模块完整版本号，例如：**2.0**
+    validations:
+      required: true
+  - type: input
+    attributes:
+      label: 系统版本
+      description: |
+        这里填写当前的系统，例如：**MIUI 13.0.1** 或 **HyperOS 1.0**
+        开发版需要标注具体的版本号，例如：**MIUI 13 22.9.27** 或 **HyperOS 1.0 22.9.27**
+    validations:
+      required: true
+  - type: dropdown
+    attributes:
+      label: 系统版本类型
+      description: 请选择你使用的系统版本类型。
+      options:
+        - 稳定版
+        - 稳定内测版
+        - 开发版
+        - 开发内测版
+        - 开发公测版 DEV
+    validations:
+      required: true
+  - type: dropdown
+    attributes:
+      label: Android 版本
+      options:
+        - 14
+        - 13
+        - 12L/12.1
+        - 12
+        - 11
+        - 10
+        - 9
+        - 8.1
+        - 8.0.0
+    validations:
+      required: true
+  - type: input
+    attributes:
+      label: Xposed 框架名称与版本号
+      description: 请填写当前使用的 Xposed 框架，例如：**LSPosed 1.8.4(次版本号)**
+    validations:
+      required: true
+  - type: input
+    attributes:
+      label: 与系统界面(系统 UI)同作用域的 Xposed 模块
+      description: |
+        此模块的作用域为系统界面(系统 UI)，为确保非其它模块冲突造成的问题，请一定要填写当前你同时激活的相关模块。
+        若没有，请直接在下方填写“无”。
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: 详细描述问题发生的具体原因
+      description: 请在下方详细描述问题发生的具体场景、复现步骤和经过，以便我们能够按照你所描述的步骤复现这个问题。
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: 提供模块问题 Log 或必要 Log
+      description: LSPosed 可在日志管理中查看并筛选包含 `MIUINativeNotifyIcon` 的日志。
+      value: |
+        <details><summary>展开查看</summary><pre><code>
+
+        (此处粘贴问题 Log)
+
+        </code></pre></details>
+        <!-- 提交时请将括号内容包括括号全部删除，粘贴你复制的日志，不要破坏代码格式 -->
+    validations:
+      required: true
+  - type: checkboxes
+    attributes:
+      label: 确认一下你提交的信息
+      description: |
+        为了确保 issues 的质量和避免浪费不必要的时间，未勾选下方选项的 issues 将直接被关闭。
+        请一定确保你已经**勾选下方的选项**后再提交。
+      options:
+        - label: 我确保上述信息准确无误
+          required: false

.github/ISSUE_TEMPLATE/request_notify_icon_adaption.yml

@@ -0,0 +1,71 @@
+name: 通知图标优化适配反馈
+description: 提交通知图标优化适配必须使用此模板提交
+labels: [To be adapted]
+title: "[通知图标优化适配反馈]"
+body:
+  - type: markdown
+    attributes:
+      value: |
+        ### 请在下方填写你需要适配的 APP 通知图标的必要信息。
+        
+        **China and Chinese only.**
+        **仅限中国和中文。**
+
+        以下类型的 APP 不予适配：
+
+        - VPN、翻墙软件
+        - 涉嫌色情、赌博类软件
+        - 申请超限权限、涉嫌泄露国家机密行为的软件
+
+        以下类型的 APP 通知图标暂不适配：
+
+        - 多态彩色图标，状态不唯一，例如 360 极速浏览器
+        - 规范的原生图标，但未被通知图标规则适配的 (将稍后加入白名单)
+  - type: input
+    attributes:
+      label: APP 名称
+      description: 这里填写 APP 的名称，例如：**微信**
+    validations:
+      required: true
+  - type: input
+    attributes:
+      label: APP 包名
+      description: 这里填写 APP 的包名，例如：**com.tencent.mm**
+    validations:
+      required: true
+  - type: input
+    attributes:
+      label: 通知图标颜色 (HEX)
+      description: |
+        这里填写通知图标在下拉通知栏中的图标颜色，要求为 16 进制，例如：**#ff232323**
+        如果不知道什么是 16 进制颜色，可以参考 [这里](https://www.qtccolor.com/tool/hex.aspx) 的取色。
+        留空代表使用系统默认主题色。
+    validations:
+      required: false
+  - type: input
+    attributes:
+      label: 下载渠道、来源地址链接
+      description: 请填写我们应该从何处得到你需要适配的这个 APP 的下载链接。
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: 简单描述适配的通知图标使用场景
+      description: 简单描述一下当前 APP 的通知图标在何时会变成彩色的、不规范的以及可触发推送通知的操作，例如小米推送或 HMS 推送。
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: 通知单色图标适配素材 (大小 50x50~72x72)
+      description: 请在这里填写我们能够获得这个图标的网址或在下方的文本框粘贴你需要上传的图标。
+    validations:
+      required: false
+  - type: checkboxes
+    attributes:
+      label: 确认一下你提交的信息
+      description: |
+        为了确保 issues 的质量和避免浪费不必要的时间，未勾选下方选项的 issues 将直接被关闭。
+        请一定确保你已经**勾选下方的选项**后再提交。
+      options:
+        - label: 我确保上述信息准确无误
+          required: false

.github/workflows/commit_ci.yml

@@ -0,0 +1,88 @@
+name: Automatic Build on Commit
+
+on:
+  workflow_dispatch:
+  push:
+    branches: [ master ]
+    paths-ignore:
+      - '**.md'
+      - '**.txt'
+      - '.github/**'
+      - '!.github/workflows/**'
+
+jobs:
+  build:
+    name: Build CI
+    if: ${{ success() }}
+    runs-on: ubuntu-latest
+    env:
+      APK_OUTPUT_PATH: 'app/build/outputs/apk'
+      TG_BOT_TOKEN: ${{ secrets.TELEGRAM_BOT_TOKEN }}
+      TG_CHAT_ID: ${{ secrets.TELEGRAM_CHAT_ID }}
+      COMMIT_MESSAGE: |+
+        New push to GitHub\!
+        ```
+        ${{ github.event.head_commit.message }}
+        ```by `${{ github.event.head_commit.author.name }}`
+        See commit detail [here](${{ github.event.head_commit.url }})
+      COMMIT_URL: ${{ github.event.head_commit.url }}
+    steps:
+      - uses: actions/checkout@v3
+      - name: Prepare GitHub Env
+        run: |
+          GITHUB_SHA=${{ github.sha }}
+          GITHUB_CI_COMMIT_ID=${GITHUB_SHA:0:7}
+          echo "GITHUB_CI_COMMIT_ID=$GITHUB_CI_COMMIT_ID" >> $GITHUB_ENV
+      - name: Setup cmake
+        uses: jwlawson/actions-setup-cmake@v1
+        with:
+          cmake-version: '3.22.1'
+      - name: Prepare Java 17
+        uses: actions/setup-java@v3
+        with:
+          java-version: 17
+          java-package: jdk
+          distribution: 'temurin'
+          cache: 'gradle'
+      - name: Cache Gradle Dependencies
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~/.gradle/caches
+            ~/.gradle/wrapper
+            !~/.gradle/caches/build-cache-*
+          key: gradle-deps-core-${{ hashFiles('**/build.gradle.kts') }}
+          restore-keys: |
+            gradle-deps
+      - name: Cache Gradle Build
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~/.gradle/caches/build-cache-*
+          key: gradle-builds-core-${{ github.sha }}
+          restore-keys: |
+            gradle-builds
+      - name: Build with Gradle
+        run: |
+          ./gradlew :app:assembleDebug
+          ./gradlew :app:assembleRelease
+          echo "DEBUG_APK_PATH=$(find ${{ env.APK_OUTPUT_PATH }}/debug -name '*.apk')" >> $GITHUB_ENV
+          echo "RELEASE_APK_PATH=$(find ${{ env.APK_OUTPUT_PATH }}/release -name '*.apk')" >> $GITHUB_ENV
+      - name: Upload Artifacts (Debug)
+        uses: actions/upload-artifact@v3
+        with:
+          path: ${{ env.DEBUG_APK_PATH }}
+          name: MIUINativeNotifyIcon-debug-${{ github.event.head_commit.id }}
+      - name: Upload Artifacts (Release)
+        uses: actions/upload-artifact@v3
+        with:
+          path: ${{ env.RELEASE_APK_PATH }}
+          name: MIUINativeNotifyIcon-release-${{ github.event.head_commit.id }}
+      - name: Post Artifacts to Telegram
+        run: |
+          export debug=$(find ${{ env.APK_OUTPUT_PATH }}/debug -name "*.apk")
+          export release=$(find ${{ env.APK_OUTPUT_PATH }}/release -name "*.apk")
+          ESCAPED=`python3 -c 'import json,os,urllib.parse; msg = json.dumps(os.environ["COMMIT_MESSAGE"]); print(urllib.parse.quote(msg if len(msg) <= 1024 else json.dumps(os.environ["COMMIT_URL"])))'`
+          curl -v "https://api.telegram.org/bot${TG_BOT_TOKEN}/sendMediaGroup?chat_id=${TG_CHAT_ID}&media=%5B%7B%22type%22%3A%22document%22%2C%20%22media%22%3A%22attach%3A%2F%2Fdebug%22%7D%2C%7B%22type%22%3A%22document%22%2C%20%22media%22%3A%22attach%3A%2F%2Frelease%22%2C%22parse_mode%22%3A%22MarkdownV2%22%2C%22caption%22:${ESCAPED}%7D%5D" \
+           -F debug="@$debug" \
+           -F release="@$release"

.github/workflows/pull_request_ci.yml

@@ -0,0 +1,70 @@
+name: Pull Request Checker
+
+on:
+  pull_request:
+    branches: [ master ]
+    paths-ignore:
+      - '**.md'
+      - '**.txt'
+      - '.github/**'
+      - '!.github/workflows/**'
+
+jobs:
+  build:
+    name: Pull Request Check
+    if: ${{ success() }}
+    runs-on: ubuntu-latest
+    env:
+      APK_OUTPUT_PATH: 'app/build/outputs/apk'
+    steps:
+      - uses: actions/checkout@v3
+      - name: Prepare GitHub Env
+        run: |
+          GITHUB_SHA=${{ github.sha }}
+          GITHUB_CI_COMMIT_ID=${GITHUB_SHA:0:7}
+          echo "GITHUB_CI_COMMIT_ID=$GITHUB_CI_COMMIT_ID" >> $GITHUB_ENV
+      - name: Setup cmake
+        uses: jwlawson/actions-setup-cmake@v1
+        with:
+          cmake-version: '3.22.1'
+      - name: Prepare Java 17
+        uses: actions/setup-java@v3
+        with:
+          java-version: 17
+          java-package: jdk
+          distribution: 'temurin'
+          cache: 'gradle'
+      - name: Cache Gradle Dependencies
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~/.gradle/caches
+            ~/.gradle/wrapper
+            !~/.gradle/caches/build-cache-*
+          key: gradle-deps-core-${{ hashFiles('**/build.gradle.kts') }}
+          restore-keys: |
+            gradle-deps
+      - name: Cache Gradle Build
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~/.gradle/caches/build-cache-*
+          key: gradle-builds-core-${{ github.sha }}
+          restore-keys: |
+            gradle-builds
+      - name: Build with Gradle
+        run: |
+          ./gradlew :app:assembleDebug
+          ./gradlew :app:assembleRelease
+          echo "DEBUG_APK_PATH=$(find ${{ env.APK_OUTPUT_PATH }}/debug -name '*.apk')" >> $GITHUB_ENV
+          echo "RELEASE_APK_PATH=$(find ${{ env.APK_OUTPUT_PATH }}/release -name '*.apk')" >> $GITHUB_ENV
+      - name: Upload Artifacts (Debug)
+        uses: actions/upload-artifact@v3
+        with:
+          path: ${{ env.DEBUG_APK_PATH }}
+          name: MIUINativeNotifyIcon-debug-${{ github.event.head_commit.id }}
+      - name: Upload Artifacts (Release)
+        uses: actions/upload-artifact@v3
+        with:
+          path: ${{ env.RELEASE_APK_PATH }}
+          name: MIUINativeNotifyIcon-release-${{ github.event.head_commit.id }}

.idea/.gitignore

@@ -1,3 +1,5 @@
 # Default ignored files
 /shelf/
 /workspace.xml
+/gradle.xml
+/misc.xml

.idea/.name

@@ -1 +0,0 @@
-MIUINativeNotifyIcon

.idea/appInsightsSettings.xml

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="AppInsightsSettings">
+    <option name="tabSettings">
+      <map>
+        <entry key="Firebase Crashlytics">
+          <value>
+            <InsightsFilterSettings>
+              <option name="connection">
+                <ConnectionSetting>
+                  <option name="appId" value="PLACEHOLDER" />
+                  <option name="mobileSdkAppId" value="" />
+                  <option name="projectId" value="" />
+                  <option name="projectNumber" value="" />
+                </ConnectionSetting>
+              </option>
+              <option name="signal" value="SIGNAL_UNSPECIFIED" />
+              <option name="timeIntervalDays" value="THIRTY_DAYS" />
+              <option name="visibilityType" value="ALL" />
+            </InsightsFilterSettings>
+          </value>
+        </entry>
+      </map>
+    </option>
+  </component>
+</project>

.idea/compiler.xml

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="CompilerConfiguration">
-    <bytecodeTargetLevel target="11" />
+    <bytecodeTargetLevel target="17" />
   </component>
 </project>

.idea/deploymentTargetDropDown.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="deploymentTargetDropDown">
+    <value>
+      <entry key="app">
+        <State />
+      </entry>
+    </value>
+  </component>
+</project>

.idea/gradle.xml

@@ -1,20 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="GradleMigrationSettings" migrationVersion="1" />
-  <component name="GradleSettings">
-    <option name="linkedExternalProjectsSettings">
-      <GradleProjectSettings>
-        <option name="testRunner" value="GRADLE" />
-        <option name="distributionType" value="DEFAULT_WRAPPED" />
-        <option name="externalProjectPath" value="$PROJECT_DIR$" />
-        <option name="modules">
-          <set>
-            <option value="$PROJECT_DIR$" />
-            <option value="$PROJECT_DIR$/app" />
-          </set>
-        </option>
-        <option name="resolveModulePerSourceSet" value="false" />
-      </GradleProjectSettings>
-    </option>
-  </component>
-</project>

.idea/inspectionProfiles/Project_Default.xml

@@ -6,5 +6,6 @@
       <option name="processLiterals" value="true" />
       <option name="processComments" value="true" />
     </inspection_tool>
+    <inspection_tool class="YAMLSchemaValidation" enabled="false" level="WARNING" enabled_by_default="false" />
   </profile>
 </component>

.idea/kotlinc.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="KotlinJpsPluginSettings">
+    <option name="version" value="1.9.10" />
+  </component>
+</project>

.idea/ktlint.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="KtlintProjectConfiguration">
+    <treatAsErrors>false</treatAsErrors>
+  </component>
+</project>

.idea/migrations.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectMigrations">
+    <option name="MigrateToGradleLocalJavaHome">
+      <set>
+        <option value="$PROJECT_DIR$" />
+      </set>
+    </option>
+  </component>
+</project>

.idea/misc.xml

@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="DesignSurface">
-    <option name="filePathToZoomLevelMap">
-      <map>
-        <entry key="app/src/main/res/drawable-night/dark_round.xml" value="0.256" />
-        <entry key="app/src/main/res/drawable-night/permotion_round.xml" value="0.256" />
-        <entry key="app/src/main/res/drawable-v24/ic_launcher_foreground.xml" value="0.44871794871794873" />
-        <entry key="app/src/main/res/drawable/permotion_round.xml" value="0.256" />
-        <entry key="app/src/main/res/drawable/white_round.xml" value="0.256" />
-        <entry key="app/src/main/res/layout/activity_config.xml" value="0.42168674698795183" />
-        <entry key="app/src/main/res/layout/activity_main.xml" value="0.4036346245815399" />
-        <entry key="app/src/main/res/layout/adapter_config.xml" value="0.4375" />
-        <entry key="app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml" value="0.44871794871794873" />
-      </map>
-    </option>
-  </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_11" default="true" project-jdk-name="Android Studio default JDK" project-jdk-type="JavaSDK">
-    <output url="file://$PROJECT_DIR$/build/classes" />
-  </component>
-  <component name="ProjectType">
-    <option name="id" value="Android" />
-  </component>
-</project>

CONTRIBUTING.md

@@ -1,42 +0,0 @@
-# 开始贡献
-
-欢迎为通知图标优化名单贡献宝贵资源！<br/>
-
-## 分支规定
-
-不管是直接 Push 代码还是提交 Pull Request，都必须使 commit 指向 master 分支。
-
-## 代码格式规范
-
-- 1.全部提交代码必须使用 IDE(Android Studio 或 IDEA) 进行格式化，未经格式化的代码将拒绝合并提交请求
-- 2.代码必须使用 4 spaces 缩进格式化
-
-## 贡献方法
-
-- 在下方的类中添加新的 APP 通知图标适配条目
-- [IconPackParams.kt](https://github.com/fankes/MIUINativeNotifyIcon/blob/master/app/src/main/java/com/fankes/miui/notify/params/IconPackParams.kt)
-- 使用灰度位图转 Base64 来得到 Base64 的位图数据字符串
-- [BitmapToBase64](https://github.com/fankes/BitmapToBase64)
-- 新增条目的模板如下所示
-
-```kotlin
-IconDataBean(
-    isEnabled = true, // 是否默认启用替换
-    isEnabledAll = false, // 是否默认启用完全替换
-    appName = "", // APP 名称
-    packageName = "", // APP 包名
-    iconBitmap = ("").bitmap, // 位图数据 Base64
-    contributorName = "" // 贡献者昵称
-)
-```
-
-- 提交时请将后方的注释删除，否则不予合并代码
-
-## 其它要求
-
-- 1.调试性质或大批量注释代码，禁止提交
-- 2.类名和方法名仅能由开发者进行修改和提交，禁止随意修改项目名称、方法名称以及类名
-- 3.禁止随意更新项目依赖以及增加新的依赖，有问题请提前提交到 issues 进行说明
-- 4.禁止更新项目版本号，版本号交由开发者合并代码并发布 release 版本
-- 5.代码语言要求，请统一使用 Kotlin，除特殊情况外，不接受其他语言的提交
-- 6.以上

EXPLORE_HISTORY.md

@@ -0,0 +1,74 @@
+# 历史背景
+
+这个模块诞生来源于 MIUI 的乱改和不规范，本来 MIUI 9 之后，官方给出了原生通知图标样式，后面由于用户反应通知栏经常出现黑白块。
+
+这当然不是系统的错，而是国内 APP 和 `MIPUSH` 的通知极其不规范的通知图标设计。
+
+但是呢，接到反馈后 MIUI 开发组选择直接忽略这个问题，在 `2021-5-18` 的开发版开始，把全部通知图标都改成了 APP 的彩色图标，使得之前拥有自有样式的原生图标也被破坏。
+
+对于 Android 开发者来说，官方文档中的 `setSmallIcon` 不再适用于魔改后的 MIUI，这将会严重破坏非常多的状态图标。
+
+当然，国内的手机生态除了 `MIPUSH` 的营销通知就是社交软件的通知，可能大部分人都不会在意这件事情。
+
+但是，这个模块就是为了修复被 MIUI 开发组忽略的图标问题才诞生的，并完美地给 MIUI 修复了黑白块图标的问题。
+
+补充：现在这个 [开发文档](https://dev.mi.com/distribute/doc/details?pId=1582) 竟然还在，那就放在这里鞭个尸吧。
+
+## 效果展示
+
+<img src="https://github.com/fankes/MIUINativeNotifyIcon/blob/master/img-src/style.png?raw=true" alt="Screenshot"/>
+
+## 探索历程
+
+原生 Android 的小图标和通知图标具有状态性。
+
+<img src="https://github.com/fankes/MIUINativeNotifyIcon/blob/master/img-src/native.jpg?raw=true" height = "35" alt="Screenshot"/>
+
+而 MIUI 最近的版本直接破坏了这一状态性，全部设置为 APP 的图标，不仅难看而且你无法下拉通知栏区别这些图标代表什么。
+
+<img src="https://github.com/fankes/MIUINativeNotifyIcon/blob/master/img-src/miui.jpg?raw=true" height = "40" alt="Screenshot"/>
+
+同样地，通知面板的图标同样遵守这一状态性。
+
+<img src="https://github.com/fankes/MIUINativeNotifyIcon/blob/master/img-src/native_n_1.jpg?raw=true" height = "100" alt="Screenshot"/>
+
+<img src="https://github.com/fankes/MIUINativeNotifyIcon/blob/master/img-src/native_n_2.jpg?raw=true" height = "100" alt="Screenshot"/>
+
+而 MIUI 做了什么呢？
+
+<img src="https://github.com/fankes/MIUINativeNotifyIcon/blob/master/img-src/miui_n_1.jpg?raw=true" height = "100" alt="Screenshot"/>
+
+<img src="https://github.com/fankes/MIUINativeNotifyIcon/blob/master/img-src/miui_n_2.jpg?raw=true" height = "100" alt="Screenshot"/>
+
+不曾记得是什么版本开始，MIUI 把通知图标改成了这个鬼样子，寻找开发组提案也是无人问津，最后转念一想，自己干吧。
+
+由于目前大量通知图标都来自 `MIPUSH` 发出的营销通知，而 `MIPUSH` 的图标都是统一的彩色应用图标，很多应用也没有适配这一特性， 在通知栏广告满天飞的情况下，MIUI
+选择放弃原生通知功能，而做出这种违反原生通知规则的做法，而这些彩色图标被设置为单色调图标，也确实会发生黑白块的问题，但是同时又会破坏遵守规范的图标。
+
+真的没有办法了吗？在不断探索下，我找到了原生支持色彩判断的类。
+
+```kotlin
+com.android.internal.util.ContrastColorUtil
+```
+
+这个类中有一个方法可以拿出来判断图标的灰度效果。
+
+```kotlin
+ContrastColorUtil.getInstance().isGrayscaleIcon(drawable)
+```
+
+问题就被解决了，顺便修了一下被 MIUI 破坏的通知图标以及优化了一下应用本身方块图标的圆角......
+
+最后，我想大声问一句 MIUI 开发组：“就这？” 就这么简单的问题为什么拖了这么长时间也没有结论，还要交给用户去修复，这真的是一种负责任的表现吗？
+
+后来一想，也是啊，被国内生态毒害的用户，怎么可能会去想到这些问题呢，最后只能是我自作多情，还对 MIUI 留有一点情怀吧。
+
+——来自一个无可奈何的 MIUI 老用户
+
+## 后记
+
+近期重新适配了 MIUI 11、12、12.5、13、14 版本，每个版本的图标设置方法都不一样，而且改的乱七八糟的，我都要无语了，只能用了很多折中方案，毕竟我也没有那么大精力每个版本去修复，实在是累了。
+
+特地的把自己能有的小米手机刷成各种 MIUI 版本去为酷友做专项适配，我也是很累了，也希望你们能够多多支持，也能让 MIUI 做得更好。
+
+MIUI 再不重写，怕是永远会变成安卓之光。雷军，金凡！！

PRIVACY.md

@@ -0,0 +1,359 @@
+### MIUI 原生通知图标 隐私政策
+
+> 简体中文
+
+版本：1.0
+
+修订与生效日期：2022年4月25日
+
+#### 前言
+
+为帮助您使用 MIUI 原生通知图标产品(以下简称“本产品”)或服务，我们可能收集与提供服务相关的设备信息或申请设备权限，您有权拒绝或撤回授权；
+
+我们采取了互联网业内标准的技术措施和数据安全措施来保护您的设备信息安全；
+
+除非再次征得您的同意，我们不会将您的设备信息用于本政策未载明的其他目的；
+
+在阅读本协议前，请确认您已年满 18 岁，否则请在父母的陪同下阅读本协议。
+
+#### 目录
+
+```
+1.  引言
+2. 本产品处理设备信息的法律依据
+3. 我们如何收集和使用您的设备信息
+3.1 向您提供本产品和/或服务的核心业务功能
+3.2 征得授权同意的例外
+4. 我们如何转让、公开披露您的设备信息
+4.1 转让您的设备信息
+4.2 公开披露
+4.3 共享、转让、公开披露设备信息授权同意的例外
+5. 您管理设备信息的权利
+5.1 设备权限调用
+6. 如何更新与修改本政策
+7. 争议解决
+8. 名词解释
+```
+
+1. 引言
+
+【特别提示】
+
+请您在使用我们的各项产品和/或服务前，仔细阅读并充分理解本政策。一旦您使用或继续使用本产品/服务，即表示您同意我们按照本政策处理您的相关信息。
+
+2. 本产品处理设备信息的法律依据
+
+如果您是中华人民共和国大陆地区的用户，我们将依据《中华人民共和国网络安全法》、《信息安全技术 个人信息安全规范》（GB/T 35273-2017）以及其他相关法律法规收集和使用您的设备信息或申请设备权限，为您提供本产品或服务。 我们通常只会在征得您同意的情况下收集您的设备信息。
+
+3. 我们如何收集和使用您的设备信息
+
+我们会遵循正当、合法、必要的原则，出于本政策所述的以下目的，收集和使用您在使用服务过程中主动提供或因使用本产品和/或服务而产生的设备信息。如果我们要将您的设备信息用于本政策未载明的其它用途，或基于特定目的将收集而来的信息用于其他目的，我们将以合理的方式向您告知，并在使用前再次征得您的同意。
+
+3.1 向您提供本产品和/或服务的核心业务功能
+
+为实现 本产品的核心业务功能，我们可能需要向您收集设备信息。以下将详细列出 本产品的核心业务功能及为实现该功能所需收集的设备信息，若您拒绝收集，则无法使用该服务。
+
+查看设备中的所有应用信息。 本产品会读取您的设备应用列表；
+
+搜索功能。 当您使用 本产品提供的搜索功能时，我们可能会使用应用数据缓存，收集您设备上的信息并进行本地存储。 该信息通常无法单独识别您的个人身份。
+
+3.2 征得授权同意的例外
+
+根据相关法律法规的规定，在以下情形中，我们可以在不征得您的授权同意的情况下收集、使用一些必要的设备信息：
+
+```
+a. 与国家安全、国防安全直接相关的；
+b. 与公共安全、公共卫生、重大公共利益直接相关的；
+c. 与犯罪侦查、起诉、审判和判决执行等直接相关的；
+d. 出于维护您或其他个人的生命、财产等重大合法权益但又很难得到本人同意的；
+e. 所收集的设备信息是您自行向社会公众公开的；
+f. 从合法公开披露的信息中收集到您的设备信息，如从合法的新闻报道、政府信息公开等渠道；
+g. 根据您的要求签订和履行合同所必需的；
+h. 用于维护 本产品的产品和/或服务的安全稳定运行所必需的，例如发现、处置产品或服务的故障；
+i. 法律法规规定的其他情形。
+```
+
+4. 我们如何共享、转让、公开披露您的设备信息
+
+4.1 转让您的设备信息
+
+除非获取您的明确同意，我们不会将您的设备信息转让给任何公司、组织或个人。
+
+4.2 公开披露
+
+除非获取您的明确同意，我们不会公开披露您的设备信息。
+
+4.3 共享、转让、公开披露设备信息授权同意的例外
+
+根据相关法律法规的规定，在以下情形中，我们可以在不征得您的授权同意的情况下共享、转让、公开披露您的设备信息：
+
+```
+A. 与国家安全、国防安全有关的；
+B. 与公共安全、公共卫生、重大公共利益有关的；
+C. 与犯罪侦查、起诉、审判和判决执行等有关的；
+D. 出于维护您或其他个人的生命、财产等重大合法权益但又很难得到本人同意的；
+E. 您自行向社会公众公开的设备信息；
+F. 从合法公开披露的信息中收集到的设备信息的，如合法的新闻报道、政府信息公开等渠道。
+G. 法律法规规定的其他情形。
+```
+
+根据法律规定，共享、转让经去标识化处理的设备信息，且确保数据接收方无法复原并重新识别设备信息主体的，不属于设备信息的对外共享、转让及公开披露行为，对此类数据的保存及处理将无需另行向您通知并征得您的同意。
+
+5. 您管理设备信息的权利
+
+5.1 设备权限调用
+
+我们在提供服务的过程中，可能需要您开通一些设备权限，例如网络连接、查看设备应用列表等访问权限。 您也可以在设备的【设置】功能中随时选择关闭部分或者全部权限，从而拒绝我们收集您相应的设备信息。在不同设备中，权限显示方式及关闭方式可能有所不同，具体请参考设备及系统开发方说明或指引。
+
+6. 如何更新与修改本政策
+
+6.1 本政策为本产品的重要组成部分。 本产品保留不时更新或修改本政策的权利。
+
+6.2 未经您明确同意，我们不会削减您按照本政策所应享有的权利。我们会通过 App 客户端推送通知、弹窗形式等合理方式通知您，以便您能及时了解本政策所做的任何变更。
+
+6.3 对于重大变更，视具体情况我们 可能还会提供更为显著的通知 说明本政策的具体变更内容。 重大变更包括但不限于：
+
+```
+A. 我们的服务模式发生重大变化。如处理设备信息的目的、处理的设备信息类型、设备信息的使用方式等；
+B. 我们在所有权结构、组织架构等方面发生重大变化。如业务调整、破产并购等引起的所有者变更等；
+C. 设备信息共享、转让或公开披露的主要对象发生变化；
+D. 您参与设备信息处理方面的权利及其行使方式发生重大变化；
+E. 我们负责处理设备信息安全的责任部门、联络方式及投诉渠道发生变化；
+F. 设备信息安全影响评估报告表明存在高风险时。
+```
+
+6.4 若您不同意修改后的隐私政策，您有权并应立即停止使用 本产品的服务。如果您继续使用 本产品的服务，则视为您接受 本产品对本政策相关条款所做的修改。
+
+7. 争议解决
+
+7.1 如果您认为我们的设备信息处理行为损害了您的合法权益，您也可向有关政府部门进行反映。
+
+8. 名词解释
+
+本隐私政策中使用到的名词，在通常意义中有如下定义：
+
+设备信息： 设备信息是指以电子或者其他方式记录的能够单独或者与其他信息结合识别设备身份的各种信息，包括但不限于设备的品牌、型号、系统版本、 唯一设备标识符、 网络 IP 地址、Cookie等；
+
+设备： 设备是指可用于访问本产品和/或服务的装置，例如台式计算机、笔记本电脑、平板电脑或智能手机。 唯一设备标识符： 唯一设备标识符（专属 ID 或 UUID）是指由设备制造商编入到设备中的一串字符，可用于以独有方式标识相应设备（例如手机的 IMEI
+号）。唯一设备标识符有多种用途，其中可在不能使用 Cookie（例如在移动应用程序中）时用以提供广告。
+
+IP 地址： 每台上网的设备都会指定一个编号，称为互联网协议 ( IP ) 地址。这些编号通常都是根据地理区域指定的。IP 地址通常可用于识别设备连接至互联网时所在的位置。
+
+信息收集技术： 我们在《MIUI 原生通知图标 隐私政策》中所述的“自动收集”包括以下方式： A. Cookie（曲奇档案） Cookie 是您浏览网页时，网站服务器放在客户端（您的计算机、移动电话或其他智能终端内）里面的一个小小的文本文件，当您再次访问相应网站时，网站就可通过
+Cookie 识别您的浏览器。Cookie 可能会存储用户偏好及其他信息。您可以将浏览器配置为拒绝所有 Cookie 或在网站发送 Cookie 时显示提示。不过，如果没有 Cookie，某些网站功能或服务可能无法正常工作。 B. Web beacon（网络信标） Web beacon
+是装嵌在网站或电邮内的电子图像文件案或其他技术，可用于计算访客数目、记录您是否及何时阅览电邮或网站，或用以使用某些 Cookie。 C. Log files（日志文件） Log files 储存自动收集的若干数据。该等数据包括互联网协议（ IP ）地址、浏览器类型、互联网服务提供商（
+ISP ）、引用/退出页面、操作系统、日期/时间戳和点击流数据等。 D. ET Tag（实体标签） ET Tag 是在互联网浏览器与互联网服务器之间背后传送的 HTTP 协议标头，可代替 Cookie，用以追踪个别使用者，使我们可更深入地了解和改善我们的服务。 E. JavaScript
+JavaScript 是一种编程语言，用于制作更具互动性和动态的网页。JavaScript 可以设定 Cookie、阅读 Cookie 及删除 Cookie。
+
+算法： 计算机在执行解题运算时遵循的流程或一系列规则。
+
+应用数据缓存： 应用数据缓存是指设备上的一种数据存储机制。使用它有很多好处，例如，可让网络应用在未连接互联网的情况下运行，以及可通过提高内容加载速度来改善相关应用的性能。
+
+非个人身份信息： 记录的与用户相关的信息，但实际上不可直接或间接识别您身份的信息，包括经过去标识化、匿名化处理或化名方式提供的设备信息。
+
+去标识化： 指通过对设备信息的技术处理，使其在不借助额外信息的情况下，无法识别设备信息主体的过程。
+
+匿名化： 指通过对设备信息的技术处理，使得设备信息主体无法被识别，且处理后的信息不能被复原的过程。
+
+服务器日志： 与大多数网站一样，我们的服务器会自动记录您在访问网站时所发出的网页请求。这些“服务器日志”通常包括您的网络请求、互联网协议地址、浏览器类型、浏览器语言、请求的日期和时间及可以唯一识别您的浏览器的一个或多个 Cookie。
+
+### MIUINativeNotifyIcon Privacy Policy
+
+> English
+
+Version: 1.0
+
+Amendment and effective date: April 25, 2022
+
+#### Preface
+
+In order to help you use MIUINativeNotifyIcon products (hereinafter referred to as "this product") or services, we may collect device information
+related to the provision of services or apply for device permissions, and you have the right to refuse or withdraw authorization;
+
+We have adopted technical measures and data security measures that are standard in the Internet industry to protect the security of your device
+information;
+
+Unless we obtain your consent again, we will not use your device information for other purposes not specified in this policy;
+
+Before reading this agreement, please confirm that you are at least 18 years old, otherwise please read this agreement with your parents.
+
+#### content
+
+````
+1 Introduction
+2. Legal basis for this product to process device information
+3. How we collect and use your device information
+3.1 Provide you with the core business functions of this product and/or service
+3.2 Exceptions to Authorized Consent
+4. How we transfer and publicly disclose your device information
+4.1 Transfer your device information
+4.2 Public disclosure
+4.3 Exceptions to Authorization and Consent for Sharing, Transfer, and Public Disclosure of Device Information
+5. Your Right to Manage Device Information
+5.1 Device permission call
+6. How to update and modify this policy
+7. Dispute Resolution
+8. Glossary
+````
+
+1 Introduction
+
+【Special Note】
+
+Please read and fully understand this policy before using our products and/or services. Once you use or continue to use this product/service, you
+agree that we will process your relevant information in accordance with this policy.
+
+2. Legal basis for this product to process device information
+
+If you are a user in the mainland of the People's Republic of China, we will collect and use your Device information or apply for device
+permissions to provide you with this product or service. We generally only collect your device information with your consent.
+
+3. How we collect and use your device information
+
+We will follow the principles of legitimacy, lawfulness, and necessity, and for the following purposes described in this policy, to collect and
+use the device information that you actively provide during the use of the service or that arises from the use of this product and/or service. If
+we want to use your device information for other purposes not specified in this policy, or use the collected information for other purposes based
+on a specific purpose, we will inform you in a reasonable manner and ask again before use with your consent.
+
+3.1 Provide you with the core business functions of this product and/or service
+
+In order to implement the core business functions of this product, we may need to collect device information from you. The following will list in
+detail the core business functions of this product and the device information that needs to be collected to achieve this function. If you refuse
+to collect, you cannot use the service.
+
+View all app information on the device. This product will read your device application list;
+
+searching feature. When you use the search function provided by this product, we may use application data cache, collect information on your
+device and store it locally. This information generally does not individually identify you as an individual.
+
+3.2 Exceptions to Authorized Consent
+
+According to relevant laws and regulations, we may collect and use some necessary device information without your authorization and consent under
+the following circumstances:
+
+````
+a. Directly related to national security and national defense security;
+b. Directly related to public safety, public health, and major public interests;
+c. Directly related to criminal investigation, prosecution, trial and execution of judgments;
+d. In order to protect your or other personal life, property and other major legitimate rights and interests, but it is difficult to obtain my consent;
+e. The collected device information is disclosed to the public by you;
+f. Your device information is collected from legally publicly disclosed information, such as legal news reports, government information disclosure and other channels;
+g. Necessary to enter into and perform a contract at your request;
+h. Necessary to maintain the safe and stable operation of the products and/or services of this product, such as finding and disposing of faults in the products or services;
+i. Other situations stipulated by laws and regulations.
+````
+
+4. How we share, transfer, and publicly disclose your device information
+
+4.1 Transfer your device information
+
+We will not transfer your device information to any company, organization or individual without your express consent.
+
+4.2 Public disclosure
+
+We will not publicly disclose your device information without your express consent.
+
+4.3 Exceptions to Authorization and Consent for Sharing, Transfer, and Public Disclosure of Device Information
+
+According to relevant laws and regulations, we may share, transfer and publicly disclose your device information without your authorization and
+consent in the following circumstances:
+
+````
+A. Related to national security and national defense security;
+B. Related to public safety, public health, and major public interests;
+C. Related to criminal investigation, prosecution, trial and execution of judgments;
+D. In order to protect your or other personal life, property and other major legitimate rights and interests, but it is difficult to obtain my consent;
+E. The device information that you disclose to the public by yourself;
+F. Device information collected from legally publicly disclosed information, such as legal news reports, government information disclosure and other channels.
+G. Other situations stipulated by laws and regulations.
+````
+
+According to the law, sharing and transferring de-identified device information and ensuring that the data recipient cannot restore and
+re-identify the subject of the device information is not an act of external sharing, transfer and public disclosure of device information.
+Storage and processing will not be required to notify you and obtain your consent.
+
+5. Your Right to Manage Device Information
+
+5.1 Device permission call
+
+In the process of providing services, we may require you to activate some device permissions, such as network connection, viewing device
+application list and other access permissions. You can also choose to turn off some or all permissions at any time in the [Settings] function of
+the device, thereby refusing us to collect your corresponding device information. In different devices, the display method and closing method of
+permissions may be different. For details, please refer to the instructions or guidelines of the device and system developers.
+
+6. How to update and modify this policy
+
+6.1 This policy is an important part of this product. This product reserves the right to update or modify this policy from time to time.
+
+6.2 We will not reduce your rights under this Policy without your express consent. We will notify you through reasonable means such as app client
+push notifications and pop-up windows, so that you can keep abreast of any changes to this policy.
+
+6.3 For major changes, we may also provide a more prominent notice to explain the specific changes to this policy as the case may be. Significant
+changes include, but are not limited to:
+
+````
+A. Significant changes to our service model. Such as the purpose of processing device information, the type of device information processed, the way of using device information, etc.;
+B. We have made significant changes in our ownership structure, organizational structure, etc. Such as changes in owners caused by business adjustments, bankruptcy mergers and acquisitions, etc.;
+C. The main object of equipment information sharing, transfer or public disclosure has changed;
+D. Significant changes in your rights to participate in the processing of device information and the way you exercise it;
+E. The responsible department, contact information and complaint channel that we are responsible for handling equipment information security have changed;
+F. When the equipment information security impact assessment report indicates that there is a high risk.
+````
+
+6.4 If you do not agree with the revised Privacy Policy, you have the right and should immediately stop using the services of this product. If
+you continue to use the services of this product, it is deemed that you accept the modifications made by this product to the relevant terms of
+this policy.
+
+7. Dispute Resolution
+
+7.1 If you believe that our device information processing has damaged your legitimate rights and interests, you can also report to the relevant
+government departments.
+
+8. Glossary
+
+Terms used in this Privacy Policy have the following definitions in their usual meanings:
+
+Device information: Device information refers to various information recorded electronically or in other ways that can identify the identity of
+the device alone or in combination with other information, including but not limited to the brand, model, system version, unique device
+identifier, network IP address of the device , Cookies, etc.;
+
+Device: A device is a device that can be used to access the Product and/or Service, such as a desktop computer, laptop, tablet or smartphone.
+Unique Device Identifier: A Unique Device Identifier (Unique ID or UUID) is a string of characters programmed into a device by the device
+manufacturer that can be used to uniquely identify the device (such as the IMEI of a mobile phone)
+No). Unique device identifiers are used for a variety of purposes, including serving advertisements when cookies cannot be used, such as in
+mobile applications.
+
+IP Address: Every device that goes online is assigned a number called an Internet Protocol (IP) address. These numbers are usually assigned by
+geographic area. An IP address can often be used to identify where a device is connected to the Internet.
+
+Information collection technology: The "automatic collection" described in the "MIUINativeNotifyIcon Privacy Policy" includes the following
+methods: A. Cookie (cookie file) Cookie is when you browse the web, the website server places it on the client (your A small text file in a
+computer, mobile phone or other intelligent terminal), when you visit the corresponding website again, the website can pass Cookies identify your
+browser. Cookies may store user preferences and other information. You can configure your browser to refuse all cookies or to display a prompt
+when a website sends a cookie. However, some website features or services may not function properly without cookies. B. Web beacon (web beacon)
+Web beacon An electronic image file or other technology embedded in a website or email that can be used to count visitors, record whether and
+when you view an email or website, or to use certain cookies. C. Log files Log files store certain data collected automatically. This data
+includes Internet Protocol (IP) address, browser type, Internet Service Provider (
+ISP), referring/exit pages, operating system, date/time stamp and clickstream data, etc. D. ET Tag (Entity Tag) ET Tag is an HTTP protocol header
+transmitted behind the Internet browser and Internet server, which can replace cookies to track individual users, so that we can better
+understand and improve our Serve. E. JavaScript JavaScript is a programming language used to make more interactive and dynamic web pages.
+JavaScript can set cookies, read cookies and delete cookies.
+
+Algorithm: A process or set of rules that a computer follows when performing a problem-solving operation.
+
+App data cache: App data cache refers to a data storage mechanism on the device. There are many benefits to using it, such as allowing web
+applications to run without an internet connection, and improving the performance of related applications by increasing the speed of content
+loading.
+
+Non-Personally Identifiable Information: Information that is recorded about a user but does not actually identify you directly or indirectly,
+including device information that has been de-identified, anonymized, or provided under a pseudonym.
+
+De-identification: refers to the process of technical processing of device information to make it impossible to identify the subject of device
+information without the aid of additional information.
+
+Anonymization: refers to the process in which the subject of the device information cannot be identified and the processed information cannot be
+recovered through the technical processing of the device information.
+
+Server Logs: Like most websites, our servers automatically log the web page requests you make while visiting the website. These "server logs"
+typically include your web request, internet protocol address, browser type, browser language, date and time of the request, and one or more
+cookies that uniquely identify your browser.

README.md

@@ -1,87 +1,125 @@
 # MIUI 原生通知图标
 
-![Eclipse Marketplace](https://img.shields.io/badge/build-passing-brightgreen)
-![Eclipse Marketplace](https://img.shields.io/badge/license-GPL3.0-blue)
-![Eclipse Marketplace](https://img.shields.io/badge/version-v1.1-green)
-<br/><br/>
-<img src="https://github.com/fankes/MIUINativeNotifyIcon/blob/master/app/src/main/ic_launcher-playstore.png" width = "100" height = "100"/>
-<br/>
-Fix the native notification bar icon function abandoned by the MIUI development team.<br/>
-修复被 MIUI 开发组丢弃的原生通知图标，支持 MIUI 12、12.5、13 以及最新版本。
+[![GitHub license](https://img.shields.io/github/license/fankes/MIUINativeNotifyIcon?color=blue)](https://github.com/fankes/MIUINativeNotifyIcon/blob/master/LICENSE)
+[![GitHub CI](https://img.shields.io/github/actions/workflow/status/fankes/MIUINativeNotifyIcon/commit_ci.yml?label=CI%20builds)](https://github.com/fankes/MIUINativeNotifyIcon/actions/workflows/commit_ci.yml)
+[![GitHub release](https://img.shields.io/github/v/release/fankes/MIUINativeNotifyIcon?display_name=release&logo=github&color=green)](https://github.com/fankes/MIUINativeNotifyIcon/releases)
+![GitHub all releases](https://img.shields.io/github/downloads/fankes/MIUINativeNotifyIcon/total?label=downloads)
+![GitHub all releases](https://img.shields.io/github/downloads/Xposed-Modules-Repo/com.fankes.miui.notify/total?label=LSPosed%20downloads&labelColor=F48FB1)
 
-# 开始使用
+[![Telegram CI](https://img.shields.io/badge/CI%20builds-Telegram-blue.svg?logo=telegram)](https://t.me/MIUINativeNotifyIcon_CI)
+[![Telegram](https://img.shields.io/badge/discussion-Telegram-blue.svg?logo=telegram)](https://t.me/XiaofangInternet)
+[![QQ](https://img.shields.io/badge/discussion-QQ-blue.svg?logo=tencent-qq&logoColor=red)](https://qm.qq.com/cgi-bin/qm/qr?k=dp2h5YhWiga9WWb_Oh7kSHmx01X8I8ii&jump_from=webapi&authKey=Za5CaFP0lk7+Zgsk2KpoBD7sSaYbeXbsDgFjiWelOeH4VSionpxFJ7V0qQBSqvFM)
+[![QQ 频道](https://img.shields.io/badge/discussion-QQ%20频道-blue.svg?logo=tencent-qq&logoColor=red)](https://pd.qq.com/s/44gcy28h)
 
-点击下载最新版本
-<a href='https://github.com/fankes/MIUINativeNotifyIcon/releases'>![Eclipse Marketplace](https://img.shields.io/badge/download-v1.1-green)</a>
-<br/><br/>
-⚠️适配说明<br/>
+<img src="https://github.com/fankes/MIUINativeNotifyIcon/blob/master/img-src/icon.png?raw=true" width = "100" height = "100" alt="LOGO"/>
 
-- 此模块仅支持 Lsposed(作用域“系统界面”)、EdXposed(不推荐)、不支持太极无极(阴)
-- 目前最低支持基于 Android 9 版本的 MIUI12 或 MIUI12.5(建议)
+Fix the native notification bar icon function abandoned by the MIUI development team.
 
-# 禁止任何商业用途
+修复被 MIUI 开发组丢弃的原生通知图标，支持 MIUI 11~14 以及 HyperOS 1.0。
 
-本模块完全开源免费，如果好用你可以打赏支持开发，严禁未经许可进行二改贩卖，违者必惩必究。
+## For Non-Chinese Users
 
-# 开始贡献
+This project will not be adapted i18n, please stay tuned for my new projects in the future.
 
-由于国内厂商 APP 的不规范彩色图标影响整体图标的美观，现在开放第三方 APP 的通知图标适配。<br/>
-欢迎为通知图标优化名单贡献宝贵资源！<br/>
+## 项目迁移公告
 
-- [CONTRIBUTING](https://github.com/fankes/MIUINativeNotifyIcon/blob/master/CONTRIBUTING.md)
+由于本人同时维护 **MIUI** 与 **ColorOS** 两个系统需要同时维护两个模块，十分不方便，所以我决定在后期逐渐合并两个项目并解耦合为一个新项目并计划适配更多系统与设备，例如原生与类原生系统。
 
-# 历史背景
+在新的项目确定后，会在这里添加新项目的链接，届时我会终止维护这个项目并建议大家转移到新项目。
 
-这个模块诞生来源于 MIUI 的乱改和不规范，本来 MIUI 9 之后，官方给出了原生通知图标样式，后面由于用户反应通知栏经常出现黑白块。 这当然不是系统的错，而是国内 APP 极其不规范的通知图标设计，于是 MIUI
-选择直接忽略这个问题把全部图标都改成了 APP 的彩色图标， 使得之前拥有自有样式的原生图标也被破坏，通知中“setSmallIcon”不再有效，这个模块就是为了修复被 MIUI 开发组忽略的图标问题， 并完美地给 MIUI 修复了黑白块图标的问题。
-<br/>
+## 适配说明
 
-# 探索历程
+- 此模块仅支持 **LSPosed** (作用域“系统界面”)、**~~EdXposed(随时停止支持)~~**、不支持**太极、无极**
 
-- 原生 Android 的小图标和通知图标具有状态性<br/>
-  <img src="https://github.com/fankes/MIUINativeNotifyIcon/blob/master/images/native.jpg" height = "35"/><br/>
-- 而 MIUI 最近的版本直接破坏了这一状态性，全部设置为 APP 的图标，不仅难看而且你无法下拉通知栏区别这些图标代表什么<br/>
-  <img src="https://github.com/fankes/MIUINativeNotifyIcon/blob/master/images/miui.jpg" height = "40"/><br/>
-- 同样地，通知面板的图标同样遵守这一状态性<br/>
-  <img src="https://github.com/fankes/MIUINativeNotifyIcon/blob/master/images/native_n_1.jpg" height = "100"/><br/>
-  <img src="https://github.com/fankes/MIUINativeNotifyIcon/blob/master/images/native_n_2.jpg" height = "100"/><br/>
-- 而 MIUI 做了什么呢<br/>
-  <img src="https://github.com/fankes/MIUINativeNotifyIcon/blob/master/images/miui_n_1.jpg" height = "100"/><br/>
-  <img src="https://github.com/fankes/MIUINativeNotifyIcon/blob/master/images/miui_n_2.jpg" height = "100"/><br/>
-- 不曾记得是什么版本开始，MIUI 把通知图标改成了这个鬼样子，寻找开发组提案也是无人问津，最后转念一想，自己干吧。
-- 由于目前大量通知图标都来自 MIPUSH 发出的营销通知，而 MIPUSH 的图标都是统一的彩色应用图标，很多应用也没有适配这一特性， 在通知栏广告满天飞的情况下，MIUI
-  选择放弃原生通知功能，而做出这种违反原生通知规则的做法，而这些彩色图标被设置为单色调图标，也确实会发生黑白块的问题，但是同时又会破坏遵守规范的图标。
-- 真的没有办法了吗？在不断探索下，我找到了原生支持色彩判断的类
+- 请确保你使用的是 MIUI 官方版本，任何第三方官改包发生的问题，开发者没有义务去解决和修复，请自求多福
+
+- 目前最低支持基于 Android 9 版本的 MIUI 11 或 MIUI 12、12.5 (最低建议)
+
+- 建议最低从 MIUI 12.5 `2021-5-18` 开发版以后开始使用模块，之前的版本可能或多或少存在 MIUI 自身 BUG 不生效、图标黑白块的问题
+
+- 请始终保持最新版本的 **LSPosed**，旧版本可能会出现 Hook 不生效的问题，若最新版本依然不生效请在作用域中长按“系统界面” (“系统 UI”) 选择重新优化
+
+## 历史背景
+
+点击下方的链接查看此模块的历史背景与探索历程。
+
+- [EXPLORE_HISTORY](https://github.com/fankes/MIUINativeNotifyIcon/blob/master/EXPLORE_HISTORY.md)
+
+## 贡献通知图标优化名单
+
+此项目是 `AndroidNotifyIconAdapt` 项目的一部分，详情请参考下方。
+
+- [Android 通知图标规范适配计划](https://github.com/fankes/AndroidNotifyIconAdapt)
+
+## 发行渠道
+
+| <img src="https://avatars.githubusercontent.com/in/15368?s=64&v=4" width = "30" height = "30" alt="LOGO"/> | [GitHub CI](https://github.com/fankes/MIUINativeNotifyIcon/actions/workflows/commit_ci.yml) | CI 自动构建 (测试版) |
+|------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------|
+
+| <img src="https://github.com/peter-iakovlev/Telegram/blob/public/Icon.png?raw=true" width = "30" height = "30" alt="LOGO"/> | [Telegram CI 频道](https://t.me/MIUINativeNotifyIcon_CI) | CI 自动构建 (测试版) |
+|-----------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------|---------------|
+
+| <img src="https://avatars.githubusercontent.com/in/15368?s=64&v=4" width = "30" height = "30" alt="LOGO"/> | [GitHub Releases](https://github.com/fankes/MIUINativeNotifyIcon/releases) | 正式版 (稳定版) |
+|------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------|-----------|
+
+| <img src="https://avatars.githubusercontent.com/u/78217009?s=200&v=4?raw=true" width = "30" height = "30" alt="LOGO"/> | [Xposed-Modules-Repo](https://github.com/Xposed-Modules-Repo/com.fankes.miui.notify/releases) | 正式版 (稳定版) |
+|------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------|-----------|
+
+| <img src="https://github.com/fankes/fankes/assets/37344460/82113d3c-aa7b-4dd1-95c7-cda650065c12" width = "30" height = "30" alt="LOGO"/> | [123 云盘 **(密码：62ll)**](https://www.123pan.com/s/5SlUVv-W8DBh.html) | 正式版 (稳定版) |
+|------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------|-----------|
+
+| <img src="https://github.com/fankes/fankes/assets/37344460/3cd43efd-785e-411d-a5c3-a8c9dc02308a" width = "30" height = "30" alt="LOGO"/> | [酷安应用市场](https://www.coolapk.com/apk/com.fankes.miui.notify) | 正式版 (稳定版) |
+|------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------|-----------|
+
+本模块发布地址仅限于上述所列出的地址，从其他非正规渠道下载到的版本或对您造成任何影响均与我们无关。
+
+## 请勿用于非法用途
+
+- 本模块完全开源免费，如果好用你可以打赏支持开发，但是请不要用于非法用途。
+
+## 项目推广
+
+如果你正在寻找一个可以自动管理 Gradle 项目依赖的 Gradle 插件，你可以了解一下 [SweetDependency](https://github.com/HighCapable/SweetDependency) 项目。
+
+如果你正在寻找一个可以自动生成属性键值的 Gradle 插件，你可以了解一下 [SweetProperty](https://github.com/HighCapable/SweetProperty) 项目。
+
+本项目同样使用了 **SweetDependency** 和 **SweetProperty**。
+
+## 捐赠支持
+
+工作不易，无意外情况此项目将继续维护下去，提供更多可能，欢迎打赏。
+
+<img src="https://github.com/fankes/fankes/blob/main/img-src/payment_code.jpg?raw=true" width = "500" alt="Payment Code"/>
+
+## Star History
+
+![Star History Chart](https://api.star-history.com/svg?repos=fankes/MIUINativeNotifyIcon&type=Date)
+
+## 隐私政策
+
+- [PRIVACY](https://github.com/fankes/MIUINativeNotifyIcon/blob/master/PRIVACY.md)
+
+## 许可证
+
+- [AGPL-3.0](https://www.gnu.org/licenses/agpl-3.0.html)
 
 ```
-com.android.internal.util.ContrastColorUtil
-```
-
-- 这个类中有一个方法可以拿出来判断图标的灰度效果
-
-```java
-ContrastColorUtil.getInstance().isGrayscaleIcon(drawable);
-```
-
-- 问题就被解决了，顺便修了一下被 MIUI 破坏的通知图标以及优化了一下应用本身方块图标的圆角...
-- 最后，我想大声问一句 MIUI 开发组：“就这？” 就这么简单的问题为什么拖了这么长时间也没有结论，还要交给用户去修复，这真的是一种负责任的表现吗？
-- 后来一想，也是啊，被国内生态毒害的用户，怎么可能会去想到这些问题呢，最后只能是我自作多情，还对 MIUI 留有一点情怀吧。
-- ——来自一个无可奈何的 MIUI 老用户
-
-# 许可证
-
-- [GPL-3.0](https://www.gnu.org/licenses/gpl-3.0.html)
-
-```
-Copyright (C) 2020-2022  Fankes Studio(qzmmcn@163.com)
+Copyright (C) 2017-2023 Fankes Studio(qzmmcn@163.com)
 
 This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-```
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+```
+
+Powered by [YukiHookAPI](https://github.com/HighCapable/YukiHookAPI)
+
+版权所有 © 2017-2023 Fankes Studio(qzmmcn@163.com)

app/.gitignore

@@ -1 +1,3 @@
-/build
+/build
+/src/main/assets/xposed_init
+/src/main/resources/META-INF/yukihookapi_init

app/build.gradle

@@ -1,62 +0,0 @@
-plugins {
-    id 'com.android.application'
-    id 'kotlin-android'
-}
-
-android {
-    compileSdk 31
-
-    signingConfigs {
-        debug {
-            storeFile file('../keystore/public')
-            storePassword '123456'
-            keyAlias 'public'
-            keyPassword '123456'
-            v1SigningEnabled true
-            v2SigningEnabled true
-        }
-    }
-
-    defaultConfig {
-        applicationId "com.fankes.miui.notify"
-        minSdk 26
-        targetSdk 26
-        versionCode 2
-        versionName "1.1"
-
-        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
-    }
-
-    buildTypes {
-        release {
-            minifyEnabled true
-            signingConfig signingConfigs.debug
-            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
-        }
-    }
-    compileOptions {
-        sourceCompatibility JavaVersion.VERSION_1_8
-        targetCompatibility JavaVersion.VERSION_1_8
-    }
-    kotlinOptions {
-        jvmTarget = '1.8'
-    }
-}
-
-dependencies {
-    compileOnly 'de.robv.android.xposed:api:82'
-    // 基础依赖包
-    implementation 'com.gyf.immersionbar:immersionbar:3.0.0'
-    // Fragment 快速实现
-    implementation 'com.gyf.immersionbar:immersionbar-components:3.0.0'
-    // Kotlin 扩展
-    implementation 'com.gyf.immersionbar:immersionbar-ktx:3.0.0'
-    implementation 'androidx.core:core-ktx:1.7.0'
-    implementation 'androidx.appcompat:appcompat:1.4.1'
-    implementation 'com.google.android.material:material:1.5.0'
-    implementation 'androidx.constraintlayout:constraintlayout:2.1.3'
-    //noinspection GradleDynamicVersion
-    testImplementation 'junit:junit:4.+'
-    androidTestImplementation 'androidx.test.ext:junit:1.1.3'
-    androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0'
-}

app/build.gradle.kts

@@ -0,0 +1,84 @@
+plugins {
+    autowire(libs.plugins.android.application)
+    autowire(libs.plugins.kotlin.android)
+    autowire(libs.plugins.kotlin.ksp)
+}
+
+android {
+    namespace = property.project.app.packageName
+    compileSdk = property.project.android.compileSdk
+
+    signingConfigs {
+        create("universal") {
+            keyAlias = property.project.app.signing.keyAlias
+            keyPassword = property.project.app.signing.keyPassword
+            storeFile = rootProject.file(property.project.app.signing.storeFilePath)
+            storePassword = property.project.app.signing.storePassword
+            enableV1Signing = true
+            enableV2Signing = true
+        }
+    }
+    defaultConfig {
+        applicationId = property.project.app.packageName
+        minSdk = property.project.android.minSdk
+        targetSdk = property.project.android.targetSdk
+        versionName = property.project.app.versionName
+        versionCode = property.project.app.versionCode
+        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+    }
+    buildTypes {
+        all { signingConfig = signingConfigs.getByName("universal") }
+        release {
+            isMinifyEnabled = true
+            isShrinkResources = true
+            proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
+        }
+    }
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+    kotlinOptions {
+        jvmTarget = "17"
+        freeCompilerArgs = listOf(
+            "-Xno-param-assertions",
+            "-Xno-call-assertions",
+            "-Xno-receiver-assertions"
+        )
+    }
+    buildFeatures {
+        buildConfig = true
+        viewBinding = true
+    }
+    lint { checkReleaseBuilds = false }
+    androidResources.additionalParameters += listOf("--allow-reserved-package-id", "--package-id", "0x37")
+}
+
+androidComponents {
+    onVariants(selector().all()) {
+        it.outputs.forEach { output ->
+            val currentType = it.buildType
+            val currentSuffix = property.github.ci.commit.id.let { suffix -> if (suffix.isNotBlank()) "-$suffix" else "" }
+            val currentVersion = "${output.versionName.get()}$currentSuffix(${output.versionCode.get()})"
+            if (output is com.android.build.api.variant.impl.VariantOutputImpl)
+                output.outputFileName.set("${property.project.name}-v$currentVersion-$currentType.apk")
+        }
+    }
+}
+
+dependencies {
+    compileOnly(de.robv.android.xposed.api)
+    implementation(com.highcapable.yukihookapi.api)
+    ksp(com.highcapable.yukihookapi.ksp.xposed)
+    implementation(com.fankes.projectpromote.project.promote)
+    implementation(com.github.topjohnwu.libsu.core)
+    implementation(com.github.duanhong169.drawabletoolbox)
+    implementation(com.squareup.okhttp3.okhttp)
+    implementation(androidx.core.core.ktx)
+    implementation(androidx.appcompat.appcompat)
+    implementation(com.google.android.material.material)
+    implementation(androidx.constraintlayout.constraintlayout)
+    testImplementation(junit.junit)
+    androidTestImplementation(androidx.test.ext.junit)
+    androidTestImplementation(androidx.test.espresso.espresso.core)
+}

app/proguard-rules.pro

@@ -20,29 +20,27 @@
 # hide the original source file name.
 #-renamesourcefileattribute SourceFile
 
--dontwarn
 -ignorewarnings
 -optimizationpasses 10
 -dontusemixedcaseclassnames
 -dontoptimize
 -verbose
 -overloadaggressively
--repackageclasses o
 -allowaccessmodification
 -adaptclassstrings
 -adaptresourcefilenames
 -adaptresourcefilecontents
 
-#-optimizations !code/simplification/arithmetic,!code/simplification/cast,!field/*,!class/merging/*
--renamesourcefileattribute H
--keepattributes SourceFile,LineNumberTable
+-renamesourcefileattribute P
+-keepattributes SourceFile,Signature,LineNumberTable
 
--keep class android.support**
--keep class androidx**
+-assumenosideeffects class kotlin.jvm.internal.Intrinsics {
+    public static *** throwUninitializedProperty(...);
+    public static *** throwUninitializedPropertyAccessException(...);
+}
 
--keep public class * extends android.app.Activity
--keep public class * extends android.app.Application
--keep public class * extends android.app.Service
--keep public class * extends android.content.ContentProvider
--keep public class * extends android.app.backup.BackupAgentHelper
--keep public class * extends android.preference.Preference
+-keep class * extends android.app.Activity
+-keep class * implements androidx.viewbinding.ViewBinding {
+    <init>();
+    *** inflate(android.view.LayoutInflater);
+}

app/src/main/AndroidManifest.xml

@@ -1,7 +1,17 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:tools="http://schemas.android.com/tools"
-    package="com.fankes.miui.notify">
+    xmlns:tools="http://schemas.android.com/tools">
+
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+
+    <uses-permission
+        android:name="${applicationId}.DYNAMIC_RECEIVER_NOT_EXPORTED_PERMISSION"
+        tools:node="remove" />
+    <permission
+        android:name="${applicationId}.DYNAMIC_RECEIVER_NOT_EXPORTED_PERMISSION"
+        tools:node="remove" />
 
     <application
         android:name=".application.MNNApplication"
@@ -11,51 +21,70 @@
         android:roundIcon="@mipmap/ic_launcher_round"
         android:supportsRtl="true"
         android:theme="@style/Theme.MIUINativeNotifyIcon"
-        tools:ignore="AllowBackup">
+        android:usesCleartextTraffic="true"
+        tools:ignore="AllowBackup,ExportedService">
 
-        <!-- 是否是xposed模块 -->
         <meta-data
             android:name="xposedmodule"
             android:value="true" />
-
-        <!-- 模块描述 -->
         <meta-data
             android:name="xposeddescription"
-            android:value="MIUI 状态栏原生图标，修复 12.5、13 后期被破坏的彩色图标。\n开发者：酷安 @星夜不荟" />
-
-        <!-- 最低xposed版本号 -->
+            android:value="为金凡教我做事的 MIUI 修复自 12.5 开始后期被破坏的单色图标。\n开发者：酷安 @星夜不荟" />
         <meta-data
             android:name="xposedminversion"
-            android:value="82" />
+            android:value="93" />
+        <meta-data
+            android:name="xposedscope"
+            android:resource="@array/module_scope" />
 
         <activity
-            android:name="com.fankes.miui.notify.ui.MainActivity"
+            android:name=".ui.activity.MainActivity"
             android:exported="true"
             android:screenOrientation="behind">
 
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
+
                 <category android:name="de.robv.android.xposed.category.MODULE_SETTINGS" />
             </intent-filter>
         </activity>
 
         <activity-alias
-            android:name="com.fankes.miui.notify.Home"
+            android:name=".Home"
             android:enabled="true"
             android:exported="true"
             android:label="@string/app_name"
             android:screenOrientation="behind"
-            android:targetActivity="com.fankes.miui.notify.ui.MainActivity">
+            android:targetActivity=".ui.activity.MainActivity">
 
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
+
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
         </activity-alias>
 
         <activity
-            android:name="com.fankes.miui.notify.ui.ConfigureActivity"
-            android:exported="false"
+            android:name=".ui.activity.ConfigureActivity"
+            android:exported="true"
             android:screenOrientation="behind" />
+
+        <activity
+            android:name=".ui.activity.auto.NotifyIconRuleUpdateActivity"
+            android:excludeFromRecents="true"
+            android:exported="true"
+            android:theme="@android:style/Theme.Translucent.NoTitleBar" />
+
+        <service
+            android:name=".service.QuickStartTileService"
+            android:exported="true"
+            android:icon="@drawable/ic_notify_icon"
+            android:label="@string/tile_name"
+            android:permission="android.permission.BIND_QUICK_SETTINGS_TILE">
+
+            <intent-filter>
+                <action android:name="android.service.quicksettings.action.QS_TILE" />
+            </intent-filter>
+        </service>
     </application>
 </manifest>

app/src/main/assets/xposed_init

@@ -1 +0,0 @@
-com.fankes.miui.notify.hook.HookMain

app/src/main/java/com/fankes/miui/notify/application/MNNApplication.kt

@@ -1,51 +1,40 @@
-/**
- * Copyright (C) 2022. Fankes Studio(qzmmcn@163.com)
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2017-2023 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
  *
- * This file is part of MIUINativeNotifyIcon.
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
  *
- * MIUINativeNotifyIcon is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * MIUINativeNotifyIcon is distributed in the hope that it will be useful,
+ * This software is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
  *
- * This file is Created by fankes on 2022/01/24.
+ * This file is created by fankes on 2022/1/24.
  */
 @file:Suppress("unused")
 
 package com.fankes.miui.notify.application
 
-import android.app.Application
 import androidx.appcompat.app.AppCompatDelegate
+import com.fankes.miui.notify.data.ConfigData
+import com.highcapable.yukihookapi.hook.xposed.application.ModuleApplication
 
-class MNNApplication : Application() {
-
-    companion object {
-
-        /** 全局静态实例 */
-        private var context: MNNApplication? = null
-
-        /** 调用全局静态实例 */
-        val appContext get() = context ?: error("App is death")
-
-        /** 自身 APP 是否已启动 */
-        var isMineStarted = false
-    }
+class MNNApplication : ModuleApplication() {
 
     override fun onCreate() {
         super.onCreate()
-        /** 设置状态 */
-        isMineStarted = true
-        /** 设置静态实例 */
-        context = this
         /** 跟随系统夜间模式 */
         AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM)
+        /** 装载存储控制类 */
+        ConfigData.init(instance = this)
     }
 }

app/src/main/java/com/fankes/miui/notify/bean/IconDataBean.kt

@@ -1,46 +1,61 @@
-/**
- * Copyright (C) 2022. Fankes Studio(qzmmcn@163.com)
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2017-2023 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
  *
- * This file is part of MIUINativeNotifyIcon.
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
  *
- * MIUINativeNotifyIcon is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * MIUINativeNotifyIcon is distributed in the hope that it will be useful,
+ * This software is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
  *
- * This file is Created by fankes on 2022/1/30.
+ * This file is created by fankes on 2022/1/30.
  */
 package com.fankes.miui.notify.bean
 
 import android.graphics.Bitmap
-import com.fankes.miui.notify.utils.base64
+import com.fankes.miui.notify.utils.factory.base64
 import java.io.Serializable
 
 /**
  * 通知栏小图标 bean
- * @param appName APP 名称 - 仅限默认语言区域
+ * @param appName APP 名称
  * @param packageName 包名
  * @param iconBitmap 图标位图
+ * @param iconColor 通知栏中显示的图标颜色 - 设置为 0 使用系统默认颜色
  * @param contributorName 贡献者昵称
- * @param isEnabled 是否默认启用替换
- * @param isEnabledAll 是否默认启用完全替换
+ * @param isEnabled 是否默认启用替换彩色图标 - 关闭后将全部停止替换
+ * @param isEnabledAll 是否默认启用替换全部图标
  */
 data class IconDataBean(
     var appName: String,
     var packageName: String,
     var iconBitmap: Bitmap,
+    var iconColor: Int = 0,
     var contributorName: String,
     var isEnabled: Boolean,
     var isEnabledAll: Boolean,
 ) : Serializable {
     fun toEnabledName() = ("$appName$packageName").base64 + "_enable"
     fun toEnabledAllName() = ("$appName$packageName").base64 + "_enable_all"
+    override fun toString() = """
+      {
+        "appName": "$appName",
+        "packageName": "$packageName",
+        "iconBitmap": "${iconBitmap.base64}",
+        "iconColor": "#${Integer.toHexString(iconColor)}",
+        "contributorName": "$contributorName",
+        "isEnabled": $isEnabled,
+        "isEnabledAll": $isEnabledAll
+      }
+    """.trimIndent()
 }

app/src/main/java/com/fankes/miui/notify/const/ConstFactory.kt

@@ -0,0 +1,78 @@
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2017-2023 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
+ *
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
+ *
+ * This file is created by fankes on 2023/2/2.
+ */
+@file:Suppress("MemberVisibilityCanBePrivate")
+
+package com.fankes.miui.notify.const
+
+import com.fankes.miui.notify.generated.AppProperties
+import com.fankes.miui.notify.wrapper.BuildConfigWrapper
+
+/**
+ * 包名常量定义类
+ */
+object PackageName {
+
+    /** 系统界面 (系统 UI) */
+    const val SYSTEMUI = "com.android.systemui"
+}
+
+/**
+ * 通知图标优化名单同步方式定义类
+ */
+object IconRuleSourceSyncType {
+
+    /** GitHub Raw (代理 - GitHub Proxy) */
+    const val GITHUB_RAW_PROXY_1 = 500
+
+    /** GitHub Raw (代理 - 7ED Services) */
+    const val GITHUB_RAW_PROXY_2 = 1000
+
+    /** GitHub Raw (直连) */
+    const val GITHUB_RAW_DIRECT = 2000
+
+    /** 自定义地址 */
+    const val CUSTOM_URL = 3000
+}
+
+/**
+ * 模块版本常量定义类
+ */
+object ModuleVersion {
+
+    /** 当前 GitHub 提交的 ID (CI 自动构建) */
+    const val GITHUB_COMMIT_ID = AppProperties.GITHUB_CI_COMMIT_ID
+
+    /** 版本名称 */
+    const val NAME = BuildConfigWrapper.VERSION_NAME
+
+    /** 版本号 */
+    const val CODE = BuildConfigWrapper.VERSION_CODE
+
+    /** 是否为 CI 自动构建版本 */
+    val isCiMode = GITHUB_COMMIT_ID.isNotBlank()
+
+    /** 当前版本名称后缀 */
+    val suffix = GITHUB_COMMIT_ID.let { if (it.isNotBlank()) "-$it" else "" }
+
+    override fun toString() = "$NAME$suffix($CODE)"
+}

app/src/main/java/com/fankes/miui/notify/data/ConfigData.kt

@@ -0,0 +1,375 @@
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2017-2023 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
+ *
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
+ *
+ * This file is created by fankes on 2023/2/2.
+ */
+@file:Suppress("MemberVisibilityCanBePrivate")
+
+package com.fankes.miui.notify.data
+
+import android.content.Context
+import com.fankes.miui.notify.const.IconRuleSourceSyncType
+import com.highcapable.yukihookapi.hook.factory.prefs
+import com.highcapable.yukihookapi.hook.log.YLog
+import com.highcapable.yukihookapi.hook.param.PackageParam
+import com.highcapable.yukihookapi.hook.xposed.prefs.data.PrefsData
+
+/**
+ * 全局配置存储控制类
+ */
+object ConfigData {
+
+    /** 启用模块 */
+    val ENABLE_MODULE = PrefsData("_enable_module", true)
+
+    /** 启用模块日志 */
+    val ENABLE_MODULE_LOG = PrefsData("_enable_module_log", false)
+
+    /** 解除状态栏通知图标个数限制 */
+    val ENABLE_LIFTED_STATUS_ICON_COUNT = PrefsData("_enable_hook_status_icon_count", true)
+
+    /** 解除后的状态栏通知图标最大个数 */
+    val LIFTED_STATUS_ICON_COUNT = PrefsData("_hook_status_icon_count", 5)
+
+    /** 启用通知图标兼容模式 */
+    val ENABLE_COLOR_ICON_COMPAT = PrefsData("_color_icon_compat", false)
+
+    /** 状态栏中的通知图标暗色透明度 */
+    val STATUS_ICON_DARK_ALPHA_LEVEL = PrefsData("_status_icon_dark_alpha", 75)
+
+    /** 状态栏中的通知图标亮色透明度 */
+    val STATUS_ICON_LIGHT_ALPHA_LEVEL = PrefsData("_status_icon_light_alpha", 95)
+
+    /** 通知栏中的通知图标圆角程度 */
+    val NOTIFY_ICON_CORNER_SIZE = PrefsData("_notify_icon_corner", 15)
+
+    /** 替换 MIUI 样式通知栏的通知图标 */
+    val ENABLE_REPLACE_MIUI_STYLE_NOTIFY_ICON = PrefsData("_replace_miui_style_notify_icon", true)
+
+    /** 强制通知栏中的通知图标使用系统着色 */
+    val ENABLE_NOTIFY_ICON_FORCE_SYSTEM_COLOR = PrefsData("_notify_icon_force_system_color", false)
+
+    /** 强制通知栏中的通知图标为 APP 图标 */
+    val ENABLE_NOTIFY_ICON_FORCE_APP_ICON = PrefsData("_notify_icon_force_app_icon", false)
+
+    /** 启用通知图标优化 */
+    val ENABLE_NOTIFY_ICON_FIX = PrefsData("_notify_icon_fix", true)
+
+    /** 使用占位符修补未适配的通知图标 */
+    val ENABLE_NOTIFY_ICON_FIX_PLACEHOLDER = PrefsData("_notify_icon_fix_placeholder", false)
+
+    /** 提醒未适配通知图标的新安装应用 */
+    val ENABLE_NOTIFY_ICON_FIX_NOTIFY = PrefsData("_notify_icon_fix_notify", true)
+
+    /** 启用通知图标优化名单自动更新 */
+    val ENABLE_NOTIFY_ICON_FIX_AUTO = PrefsData("_enable_notify_icon_fix_auto", true)
+
+    /** 通知图标优化名单自动更新时间 */
+    val NOTIFY_ICON_FIX_AUTO_TIME = PrefsData("_notify_icon_fix_auto_time", "07:00")
+
+    /** 通知图标优化适配数据 */
+    val NOTIFY_ICONS_DATA = PrefsData("_notify_icon_datas", "")
+
+    /** 通知图标优化名单同步方式 */
+    val ICON_RULE_SOURCE_SYNC_TYPE = PrefsData("_rule_source_sync_way", IconRuleSourceSyncType.GITHUB_RAW_PROXY_1)
+
+    /** 通知图标优化名单同步地址 */
+    val ICON_RULE_SOURCE_SYNC_CUSTOM_URL = PrefsData("_rule_source_sync_way_custom_url", "")
+
+    /** 忽略 Android 版本过低提示 */
+    val IGNORED_ANDROID_VERSION_TO_LOW = PrefsData("_ignored_android_version_to_low", false)
+
+    /** 当前实例 - [Context] or [PackageParam] */
+    private var instance: Any? = null
+
+    /**
+     * 初始化存储控制类
+     * @param instance 实例 - 只能是 [Context] or [PackageParam]
+     * @throws IllegalStateException 如果类型错误
+     */
+    fun init(instance: Any) {
+        when (instance) {
+            is Context, is PackageParam -> this.instance = instance
+            else -> error("Unknown type for init ConfigData")
+        }
+    }
+
+    /**
+     * 读取 [String] 数据
+     * @param data 键值数据模板
+     * @return [String]
+     */
+    private fun getString(data: PrefsData<String>) = when (instance) {
+        is Context -> (instance as Context).prefs().get(data)
+        is PackageParam -> (instance as PackageParam).prefs.get(data)
+        else -> error("Unknown type for get prefs data")
+    }
+
+    /**
+     * 存入 [String] 数据
+     * @param data 键值数据模板
+     * @param value 键值内容
+     */
+    private fun putString(data: PrefsData<String>, value: String) {
+        when (instance) {
+            is Context -> (instance as Context).prefs().edit { put(data, value) }
+            is PackageParam -> YLog.warn("Not support for this method")
+            else -> error("Unknown type for put prefs data")
+        }
+    }
+
+    /**
+     * 读取 [Int] 数据
+     * @param data 键值数据模板
+     * @return [Int]
+     */
+    internal fun getInt(data: PrefsData<Int>) = when (instance) {
+        is Context -> (instance as Context).prefs().get(data)
+        is PackageParam -> (instance as PackageParam).prefs.get(data)
+        else -> error("Unknown type for get prefs data")
+    }
+
+    /**
+     * 存入 [Int] 数据
+     * @param data 键值数据模板
+     * @param value 键值内容
+     */
+    internal fun putInt(data: PrefsData<Int>, value: Int) {
+        when (instance) {
+            is Context -> (instance as Context).prefs().edit { put(data, value) }
+            is PackageParam -> YLog.warn("Not support for this method")
+            else -> error("Unknown type for put prefs data")
+        }
+    }
+
+    /**
+     * 读取 [Boolean] 数据
+     * @param data 键值数据模板
+     * @return [Boolean]
+     */
+    internal fun getBoolean(data: PrefsData<Boolean>) = when (instance) {
+        is Context -> (instance as Context).prefs().get(data)
+        is PackageParam -> (instance as PackageParam).prefs.get(data)
+        else -> error("Unknown type for get prefs data")
+    }
+
+    /**
+     * 存入 [Boolean] 数据
+     * @param data 键值数据模板
+     * @param value 键值内容
+     */
+    internal fun putBoolean(data: PrefsData<Boolean>, value: Boolean) {
+        when (instance) {
+            is Context -> (instance as Context).prefs().edit { put(data, value) }
+            is PackageParam -> YLog.warn("Not support for this method")
+            else -> error("Unknown type for put prefs data")
+        }
+    }
+
+    /**
+     * 是否启用模块
+     * @return [Boolean]
+     */
+    var isEnableModule
+        get() = getBoolean(ENABLE_MODULE)
+        set(value) {
+            putBoolean(ENABLE_MODULE, value)
+        }
+
+    /**
+     * 是否启用模块日志
+     * @return [Boolean]
+     */
+    var isEnableModuleLog
+        get() = getBoolean(ENABLE_MODULE_LOG)
+        set(value) {
+            putBoolean(ENABLE_MODULE_LOG, value)
+        }
+
+    /**
+     * 是否解除状态栏通知图标个数限制
+     * @return [Boolean]
+     */
+    var isEnableLiftedStatusIconCount
+        get() = getBoolean(ENABLE_LIFTED_STATUS_ICON_COUNT)
+        set(value) {
+            putBoolean(ENABLE_LIFTED_STATUS_ICON_COUNT, value)
+        }
+
+    /**
+     * 解除后的状态栏通知图标最大个数
+     * @return [Int]
+     */
+    var liftedStatusIconCount
+        get() = getInt(LIFTED_STATUS_ICON_COUNT)
+        set(value) {
+            putInt(LIFTED_STATUS_ICON_COUNT, value)
+        }
+
+    /**
+     * 是否启用通知图标兼容模式
+     * @return [Boolean]
+     */
+    var isEnableColorIconCompat
+        get() = getBoolean(ENABLE_COLOR_ICON_COMPAT)
+        set(value) {
+            putBoolean(ENABLE_COLOR_ICON_COMPAT, value)
+        }
+
+    /**
+     * 状态栏中的通知图标暗色透明度
+     * @return [Int]
+     */
+    var statusIconDarkAlphaLevel
+        get() = getInt(STATUS_ICON_DARK_ALPHA_LEVEL)
+        set(value) {
+            putInt(STATUS_ICON_DARK_ALPHA_LEVEL, value)
+        }
+
+    /**
+     * 状态栏中的通知图标亮色透明度
+     * @return [Int]
+     */
+    var statusIconLightAlphaLevel
+        get() = getInt(STATUS_ICON_LIGHT_ALPHA_LEVEL)
+        set(value) {
+            putInt(STATUS_ICON_LIGHT_ALPHA_LEVEL, value)
+        }
+
+    /**
+     * 通知栏中的通知图标圆角程度
+     * @return [Int]
+     */
+    var notifyIconCornerSize
+        get() = getInt(NOTIFY_ICON_CORNER_SIZE)
+        set(value) {
+            putInt(NOTIFY_ICON_CORNER_SIZE, value)
+        }
+
+    /**
+     * 是否替换 MIUI 样式通知栏的通知图标
+     * @return [Boolean]
+     */
+    var isEnableReplaceMiuiStyleNotifyIcon
+        get() = getBoolean(ENABLE_REPLACE_MIUI_STYLE_NOTIFY_ICON)
+        set(value) {
+            putBoolean(ENABLE_REPLACE_MIUI_STYLE_NOTIFY_ICON, value)
+        }
+
+    /**
+     * 是否强制通知栏中的通知图标使用系统着色
+     * @return [Boolean]
+     */
+    var isEnableNotifyIconForceSystemColor
+        get() = getBoolean(ENABLE_NOTIFY_ICON_FORCE_SYSTEM_COLOR)
+        set(value) {
+            putBoolean(ENABLE_NOTIFY_ICON_FORCE_SYSTEM_COLOR, value)
+        }
+
+    /**
+     * 是否强制通知栏中的通知图标为 APP 图标
+     * @return [Boolean]
+     */
+    var isEnableNotifyIconForceAppIcon
+        get() = getBoolean(ENABLE_NOTIFY_ICON_FORCE_APP_ICON)
+        set(value) {
+            putBoolean(ENABLE_NOTIFY_ICON_FORCE_APP_ICON, value)
+        }
+
+    /**
+     * 是否启用通知图标优化
+     * @return [Boolean]
+     */
+    var isEnableNotifyIconFix
+        get() = getBoolean(ENABLE_NOTIFY_ICON_FIX)
+        set(value) {
+            putBoolean(ENABLE_NOTIFY_ICON_FIX, value)
+        }
+
+    /**
+     * 是否使用占位符修补未适配的通知图标
+     * @return [Boolean]
+     */
+    var isEnableNotifyIconFixPlaceholder
+        get() = getBoolean(ENABLE_NOTIFY_ICON_FIX_PLACEHOLDER)
+        set(value) {
+            putBoolean(ENABLE_NOTIFY_ICON_FIX_PLACEHOLDER, value)
+        }
+
+    /**
+     * 是否提醒未适配通知图标的新安装应用
+     * @return [Boolean]
+     */
+    var isEnableNotifyIconFixNotify
+        get() = getBoolean(ENABLE_NOTIFY_ICON_FIX_NOTIFY)
+        set(value) {
+            putBoolean(ENABLE_NOTIFY_ICON_FIX_NOTIFY, value)
+        }
+
+    /**
+     * 是否启用通知图标优化名单自动更新
+     * @return [Boolean]
+     */
+    var isEnableNotifyIconFixAuto
+        get() = getBoolean(ENABLE_NOTIFY_ICON_FIX_AUTO)
+        set(value) {
+            putBoolean(ENABLE_NOTIFY_ICON_FIX_AUTO, value)
+        }
+
+    /**
+     * 通知图标优化名单自动更新时间
+     * @return [String]
+     */
+    var notifyIconFixAutoTime
+        get() = getString(NOTIFY_ICON_FIX_AUTO_TIME)
+        set(value) {
+            putString(NOTIFY_ICON_FIX_AUTO_TIME, value)
+        }
+
+    /**
+     * 通知图标优化名单同步方式
+     * @return [Int]
+     */
+    var iconRuleSourceSyncType
+        get() = getInt(ICON_RULE_SOURCE_SYNC_TYPE)
+        set(value) {
+            putInt(ICON_RULE_SOURCE_SYNC_TYPE, value)
+        }
+
+    /**
+     * 通知图标优化名单同步地址
+     * @return [String]
+     */
+    var iconRuleSourceSyncCustomUrl
+        get() = getString(ICON_RULE_SOURCE_SYNC_CUSTOM_URL)
+        set(value) {
+            putString(ICON_RULE_SOURCE_SYNC_CUSTOM_URL, value)
+        }
+
+    /**
+     * 是否忽略 Android 版本过低提示
+     * @return [Boolean]
+     */
+    var isIgnoredAndroidVersionToLow
+        get() = getBoolean(IGNORED_ANDROID_VERSION_TO_LOW)
+        set(value) {
+            putBoolean(IGNORED_ANDROID_VERSION_TO_LOW, value)
+        }
+}

app/src/main/java/com/fankes/miui/notify/data/factory/CompoundButtonFactory.kt

@@ -0,0 +1,102 @@
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2017-2023 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
+ *
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
+ *
+ * This file is created by fankes on 2023/2/3.
+ */
+@file:Suppress("unused", "MemberVisibilityCanBePrivate")
+
+package com.fankes.miui.notify.data.factory
+
+import android.widget.CompoundButton
+import com.fankes.miui.notify.data.ConfigData
+import com.highcapable.yukihookapi.hook.xposed.prefs.data.PrefsData
+
+/**
+ * 绑定到 [CompoundButton] 自动设置选中状态
+ * @param data 键值数据模板
+ * @param initiate 方法体
+ */
+fun CompoundButton.bind(data: PrefsData<Boolean>, initiate: CompoundButtonDataBinder.(CompoundButton) -> Unit = {}) {
+    val binder = CompoundButtonDataBinder(button = this).also { initiate(it, this) }
+    isChecked = ConfigData.getBoolean(data).also { binder.initializeCallback?.invoke(it) }
+    binder.applyChangesCallback = { ConfigData.putBoolean(data, it) }
+    setOnCheckedChangeListener { button, isChecked ->
+        if (button.isPressed) {
+            if (binder.isAutoApplyChanges) binder.applyChangesCallback?.invoke(isChecked)
+            binder.changedCallback?.invoke(isChecked)
+        }
+    }
+}
+
+/**
+ * [CompoundButton] 数据绑定管理器实例
+ * @param button 当前实例
+ */
+class CompoundButtonDataBinder(private val button: CompoundButton) {
+
+    /** 状态初始化回调事件 */
+    internal var initializeCallback: ((Boolean) -> Unit)? = null
+
+    /** 状态改变回调事件 */
+    internal var changedCallback: ((Boolean) -> Unit)? = null
+
+    /** 应用更改回调事件 */
+    internal var applyChangesCallback: ((Boolean) -> Unit)? = null
+
+    /** 是否启用自动应用更改 */
+    var isAutoApplyChanges = true
+
+    /**
+     * 监听状态初始化
+     * @param result 回调结果
+     */
+    fun onInitialize(result: (Boolean) -> Unit) {
+        initializeCallback = result
+    }
+
+    /**
+     * 监听状态改变
+     * @param result 回调结果
+     */
+    fun onChanged(result: (Boolean) -> Unit) {
+        changedCallback = result
+    }
+
+    /** 重新初始化 */
+    fun reinitialize() {
+        initializeCallback?.invoke(button.isChecked)
+    }
+
+    /** 应用更改并重新初始化 */
+    fun applyChangesAndReinitialize() {
+        applyChanges()
+        reinitialize()
+    }
+
+    /** 应用更改 */
+    fun applyChanges() {
+        applyChangesCallback?.invoke(button.isChecked)
+    }
+
+    /** 取消更改 */
+    fun cancelChanges() {
+        button.isChecked = button.isChecked.not()
+    }
+}

app/src/main/java/com/fankes/miui/notify/data/factory/SeekBarFactory.kt

@@ -0,0 +1,57 @@
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2017-2023 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
+ *
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
+ *
+ * This file is created by fankes on 2023/2/4.
+ */
+@file:Suppress("SetTextI18n")
+
+package com.fankes.miui.notify.data.factory
+
+import android.widget.SeekBar
+import android.widget.TextView
+import com.fankes.miui.notify.data.ConfigData
+import com.highcapable.yukihookapi.hook.xposed.prefs.data.PrefsData
+
+/**
+ * 绑定到 [SeekBar] 自动设置进度与 [TextView]
+ * @param data 键值数据模板
+ * @param textView 文本框
+ * @param suffix 文本显示的后缀 - 默认空
+ * @param onChange 当改变停止时回调
+ */
+fun SeekBar.bind(data: PrefsData<Int>, textView: TextView, suffix: String = "", onChange: (Int) -> Unit = {}) {
+    ConfigData.getInt(data).also { value ->
+        textView.text = "$value$suffix"
+        progress = value
+    }
+    setOnSeekBarChangeListener(object : SeekBar.OnSeekBarChangeListener {
+
+        override fun onProgressChanged(seekBar: SeekBar?, progress: Int, fromUser: Boolean) {
+            textView.text = "$progress$suffix"
+        }
+
+        override fun onStopTrackingTouch(seekBar: SeekBar) {
+            ConfigData.putInt(data, seekBar.progress)
+            onChange(seekBar.progress)
+        }
+
+        override fun onStartTrackingTouch(seekBar: SeekBar?) {}
+    })
+}

app/src/main/java/com/fankes/miui/notify/hook/HookEntry.kt

@@ -0,0 +1,62 @@
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2017-2023 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
+ *
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
+ *
+ * This file is created by fankes on 2022/2/15.
+ */
+package com.fankes.miui.notify.hook
+
+import com.fankes.miui.notify.const.PackageName
+import com.fankes.miui.notify.data.ConfigData
+import com.fankes.miui.notify.hook.entity.SystemUIHooker
+import com.fankes.miui.notify.utils.factory.isLowerAndroidP
+import com.fankes.miui.notify.utils.factory.isNotMiSystem
+import com.fankes.miui.notify.utils.factory.isNotSupportMiSystemVersion
+import com.fankes.miui.notify.utils.factory.miSystemVersion
+import com.highcapable.yukihookapi.annotation.xposed.InjectYukiHookWithXposed
+import com.highcapable.yukihookapi.hook.factory.configs
+import com.highcapable.yukihookapi.hook.factory.encase
+import com.highcapable.yukihookapi.hook.log.YLog
+import com.highcapable.yukihookapi.hook.xposed.proxy.IYukiHookXposedInit
+
+@InjectYukiHookWithXposed
+object HookEntry : IYukiHookXposedInit {
+
+    override fun onInit() = configs {
+        debugLog {
+            tag = "MIUINativeNotifyIcon"
+            isRecord = true
+            elements(PRIORITY)
+        }
+        isDebug = false
+    }
+
+    override fun onHook() = encase {
+        loadApp(PackageName.SYSTEMUI) {
+            ConfigData.init(instance = this)
+            when {
+                isNotMiSystem -> YLog.warn("Aborted Hook -> This System is not MIUI or HyperOS")
+                isLowerAndroidP -> YLog.warn("Aborted Hook -> This System is lower than Android P")
+                isNotSupportMiSystemVersion -> YLog.warn("Aborted Hook -> This System Version ${miSystemVersion.ifBlank { "unknown" }} not supported")
+                ConfigData.isEnableModule.not() -> YLog.warn("Aborted Hook -> Hook Closed")
+                else -> loadHooker(SystemUIHooker)
+            }
+        }
+    }
+}

app/src/main/java/com/fankes/miui/notify/hook/HookMain.kt

@@ -1,454 +0,0 @@
-/**
- * Copyright (C) 2022. Fankes Studio(qzmmcn@163.com)
- *
- * This file is part of MIUINativeNotifyIcon.
- *
- * MIUINativeNotifyIcon is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * MIUINativeNotifyIcon is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * This file is Created by fankes on 2022/01/24.
- */
-@file:Suppress("SameParameterValue")
-
-package com.fankes.miui.notify.hook
-
-import android.content.Context
-import android.graphics.Bitmap
-import android.graphics.Color
-import android.graphics.Outline
-import android.graphics.drawable.Drawable
-import android.graphics.drawable.Icon
-import android.service.notification.StatusBarNotification
-import android.util.Log
-import android.view.View
-import android.view.ViewOutlineProvider
-import android.widget.ImageView
-import androidx.annotation.Keep
-import androidx.core.graphics.drawable.toBitmap
-import com.fankes.miui.notify.hook.HookMedium.SELF_PACKAGE_NAME
-import com.fankes.miui.notify.hook.HookMedium.SYSTEMUI_PACKAGE_NAME
-import com.fankes.miui.notify.params.IconPackParams
-import com.fankes.miui.notify.utils.*
-import de.robv.android.xposed.*
-import de.robv.android.xposed.callbacks.XC_LoadPackage
-
-@Keep
-class HookMain : IXposedHookLoadPackage {
-
-    companion object {
-
-        private const val NotificationUtilClass =
-            "$SYSTEMUI_PACKAGE_NAME.statusbar.notification.NotificationUtil"
-
-        private const val NotificationHeaderViewWrapperInjectorClass =
-            "$SYSTEMUI_PACKAGE_NAME.statusbar.notification.row.wrapper.NotificationHeaderViewWrapperInjector"
-
-        private const val ExpandedNotificationClass =
-            "$SYSTEMUI_PACKAGE_NAME.statusbar.notification.ExpandedNotification"
-
-        private const val SystemUIApplicationClass = "$SYSTEMUI_PACKAGE_NAME.SystemUIApplication"
-
-        private const val ContrastColorUtilClass = "com.android.internal.util.ContrastColorUtil"
-    }
-
-    /** 仅作用于替换的 Hook 方法体 */
-    private val replaceToNull = object : XC_MethodReplacement() {
-        override fun replaceHookedMethod(param: MethodHookParam?): Any? {
-            return null
-        }
-    }
-
-    /** 仅作用于替换的 Hook 方法体 */
-    private val replaceToTrue = object : XC_MethodReplacement() {
-        override fun replaceHookedMethod(param: MethodHookParam?): Any {
-            return true
-        }
-    }
-
-    /** 仅作用于替换的 Hook 方法体 */
-    private val replaceToFalse = object : XC_MethodReplacement() {
-        override fun replaceHookedMethod(param: MethodHookParam?): Any {
-            return false
-        }
-    }
-
-    /**
-     * 忽略异常运行
-     * @param error 错误信息
-     * @param ignored 忽略后出错将不输出到控制台
-     * @param it 正常回调
-     */
-    private fun runWithoutError(error: String = "", ignored: Boolean = false, it: () -> Unit) {
-        try {
-            it()
-        } catch (e: Error) {
-            if (!ignored) logE("hookFailed: $error", e)
-        } catch (e: Exception) {
-            if (!ignored) logE("hookFailed: $error", e)
-        } catch (e: Throwable) {
-            if (!ignored) logE("hookFailed: $error", e)
-        }
-    }
-
-    /**
-     * Print the log
-     * @param content
-     */
-    private fun logD(content: String) {
-        XposedBridge.log("[MIUINativeNotifyIcon][D]>$content")
-        Log.d("MIUINativeNotifyIcon", content)
-    }
-
-    /**
-     * Print the log
-     * @param content
-     */
-    private fun logE(content: String, e: Throwable? = null) {
-        XposedBridge.log("[MIUINativeNotifyIcon][E]>$content")
-        XposedBridge.log(e)
-        Log.e("MIUINativeNotifyIcon", content, e)
-    }
-
-    /**
-     * 查找目标类
-     * @param name 类名
-     * @return [Class]
-     */
-    private fun XC_LoadPackage.LoadPackageParam.findClass(name: String) =
-        classLoader.loadClass(name)
-
-    /**
-     * ⚠️ 这个是修复彩色图标的关键核心代码判断
-     * 判断是否为灰度图标 - 反射执行系统方法
-     * @param context 实例
-     * @param icon 要判断的图标
-     * @return [Boolean]
-     */
-    private fun XC_LoadPackage.LoadPackageParam.isGrayscaleIcon(context: Context, icon: Drawable) =
-        findClass(ContrastColorUtilClass).let {
-            val instance = it.getDeclaredMethod("getInstance", Context::class.java)
-                .apply { isAccessible = true }.invoke(null, context)
-            it.getDeclaredMethod("isGrayscaleIcon", Drawable::class.java)
-                .apply { isAccessible = true }.invoke(instance, icon) as Boolean
-        }
-
-    /**
-     * 获取 [ExpandedNotificationClass] 的应用名称
-     * @param instance 通知实例
-     * @return [String]
-     */
-    private fun XC_LoadPackage.LoadPackageParam.findAppName(instance: Any?) =
-        findClass(ExpandedNotificationClass).getDeclaredMethod("getAppName").let {
-            it.isAccessible = true
-            it.invoke(instance) as? String ?: ""
-        }
-
-    /**
-     * 获取全局上下文
-     * @return [Context]
-     */
-    private val XC_LoadPackage.LoadPackageParam.globalContext
-        get() = findClass(SystemUIApplicationClass)
-            .getDeclaredMethod("getContext").apply { isAccessible = true }
-            .invoke(null) as Context
-
-    /**
-     * Hook 状态栏小图标
-     * 区分系统版本 - 由于每个系统版本的方法不一样这里单独拿出来进行 Hook
-     * @param param Hook Param
-     */
-    private fun XC_LoadPackage.LoadPackageParam.hookSmallIconOnSet(param: XC_MethodHook.MethodHookParam) =
-        runWithoutError(error = "GetSmallIconOnSet") {
-            /** 获取通知小图标 */
-            val iconDrawable = (param.result as Icon).loadDrawable(globalContext)
-
-            /** 判断是否不是灰度图标 */
-            val isNotGrayscaleIcon = !isGrayscaleIcon(globalContext, iconDrawable)
-            /** 获取通知对象 - 由于 MIUI 的版本迭代不规范性可能是空的 */
-            (param.args?.get(0) as? StatusBarNotification?)?.also { notifyInstance ->
-                /** 目标彩色通知 APP 图标 */
-                var customIcon: Icon? = null
-                if (HookMedium.getBoolean(HookMedium.ENABLE_COLOR_ICON_HOOK, default = true))
-                    run {
-                        IconPackParams.iconDatas.forEach {
-                            if ((notifyInstance.opPkgName == it.packageName ||
-                                        findAppName(notifyInstance) == it.appName) &&
-                                HookMedium.isAppNotifyHookOf(it)
-                            ) {
-                                if (isNotGrayscaleIcon || HookMedium.isAppNotifyHookAllOf(it))
-                                    customIcon = Icon.createWithBitmap(it.iconBitmap)
-                                return@run
-                            }
-                        }
-                    }
-                when {
-                    /** 如果开启了修复 APP 的彩色图标 */
-                    customIcon != null && HookMedium.getBoolean(HookMedium.ENABLE_NOTIFY_ICON_HOOK, default = true) ->
-                        param.result = customIcon
-                    /** 若不是灰度图标自动处理为圆角 */
-                    isNotGrayscaleIcon ->
-                        param.result = Icon.createWithBitmap(
-                            iconDrawable.toBitmap().round(15.dp(globalContext))
-                        )
-                }
-            }
-        }
-
-    /**
-     * Hook 通知栏小图标
-     * 区分系统版本 - 由于每个系统版本的方法不一样这里单独拿出来进行 Hook
-     * @param param Hook Param
-     * @param isNew 是否为新版方式
-     */
-    private fun XC_LoadPackage.LoadPackageParam.hookNotifyIconOnSet(param: XC_MethodHook.MethodHookParam, isNew: Boolean) =
-        runWithoutError(error = "AutoSetAppIconOnSet") {
-            /** 获取通知对象 - 由于 MIUI 的版本迭代不规范性可能是空的 */
-            (param.args?.get(if (isNew) 2 else 1) as? StatusBarNotification?)?.let { notifyInstance ->
-                /** 是否 Hook 彩色通知图标 */
-                val isHookColorIcon = HookMedium.getBoolean(HookMedium.ENABLE_COLOR_ICON_HOOK, default = true)
-
-                /** 获取 [Context] */
-                val context = if (isNew) param.args[0] as Context else globalContext
-
-                /** 新版风格反色 */
-                val newStyle = if (context.isSystemInDarkMode) 0xFF2D2D2D.toInt() else Color.WHITE
-
-                /** 旧版风格反色 */
-                val oldStyle = if (context.isNotSystemInDarkMode) 0xFF515151.toInt() else Color.WHITE
-
-                /** 获取图标框 */
-                val iconImageView = param.args[if (isNew) 1 else 0] as ImageView
-
-                /** 获取通知小图标 */
-                val iconDrawable = notifyInstance.notification.smallIcon.loadDrawable(context)
-
-                /** 判断图标风格 */
-                val isGrayscaleIcon = isGrayscaleIcon(context, iconDrawable)
-
-                /** 自定义默认小图标 */
-                var customIcon: Bitmap? = null
-                if (isHookColorIcon)
-                    run {
-                        IconPackParams.iconDatas.forEach {
-                            if ((notifyInstance.opPkgName == it.packageName ||
-                                        findAppName(notifyInstance) == it.appName) &&
-                                HookMedium.isAppNotifyHookOf(it)
-                            ) {
-                                if (!isGrayscaleIcon || HookMedium.isAppNotifyHookAllOf(it))
-                                    customIcon = it.iconBitmap
-                                return@run
-                            }
-                        }
-                    }
-                /** 如果开启了修复 APP 的彩色图标 */
-                if (customIcon != null && HookMedium.getBoolean(HookMedium.ENABLE_NOTIFY_ICON_HOOK, default = true))
-                    iconImageView.apply {
-                        /** 设置自定义小图标 */
-                        setImageBitmap(customIcon)
-                        /** 上色 */
-                        setColorFilter(if (isUpperOfAndroidS) newStyle else oldStyle)
-                    }
-                else {
-                    /** 重新设置图标 - 防止系统更改它 */
-                    iconImageView.setImageDrawable(iconDrawable)
-                    /*判断是否开启 Hook 彩色图标*/
-                    if (isHookColorIcon) {
-                        /** 判断如果是灰度图标就给他设置一个白色颜色遮罩 */
-                        if (isGrayscaleIcon)
-                            iconImageView.setColorFilter(if (isUpperOfAndroidS) newStyle else oldStyle)
-                        else
-                            iconImageView.apply {
-                                clipToOutline = true
-                                /** 设置一个圆角轮廓裁切 */
-                                outlineProvider = object : ViewOutlineProvider() {
-                                    override fun getOutline(view: View, out: Outline) {
-                                        out.setRoundRect(
-                                            0,
-                                            0,
-                                            view.width,
-                                            view.height,
-                                            5.dp(context)
-                                        )
-                                    }
-                                }
-                                /** 清除原生的背景边距设置 */
-                                if (isUpperOfAndroidS) setPadding(0, 0, 0, 0)
-                                /** 清除原生的主题色背景圆圈颜色 */
-                                if (isUpperOfAndroidS) background = null
-                            }
-                        /** 否则一律设置灰度图标 */
-                    } else iconImageView.setColorFilter(if (isUpperOfAndroidS) newStyle else oldStyle)
-                }
-            }
-        }
-
-    override fun handleLoadPackage(lpparam: XC_LoadPackage.LoadPackageParam?) {
-        if (lpparam == null) return
-        when (lpparam.packageName) {
-            /** Hook 自身 */
-            SELF_PACKAGE_NAME ->
-                XposedHelpers.findAndHookMethod(
-                    "$SELF_PACKAGE_NAME.hook.HookMedium",
-                    lpparam.classLoader,
-                    "isHooked",
-                    replaceToTrue
-                )
-            /** Hook 系统 UI */
-            SYSTEMUI_PACKAGE_NAME -> {
-                /** 若不是 MIUI 系统直接停止 Hook */
-                if (isNotMIUI) return
-                /** 系统版本过低直接停止 Hook */
-                if (isLowerAndroidP) return
-                /** 若没开启模块直接停止 Hook */
-                if (!HookMedium.getBoolean(HookMedium.ENABLE_MODULE, default = true)) return
-                /** 强制回写系统的状态栏图标样式为原生 */
-                runWithoutError(error = "SubstituteSmallIcon") {
-                    XposedHelpers.findAndHookMethod(
-                        NotificationUtilClass,
-                        lpparam.classLoader,
-                        "shouldSubstituteSmallIcon",
-                        lpparam.findClass(ExpandedNotificationClass),
-                        replaceToFalse
-                    )
-                }
-                /** 修复通知图标为彩色 */
-                runWithoutError(error = "IgnoreStatusBarIconColor") {
-                    XposedHelpers.findAndHookMethod(
-                        NotificationUtilClass,
-                        lpparam.classLoader,
-                        "ignoreStatusBarIconColor",
-                        lpparam.findClass(ExpandedNotificationClass),
-                        object : XC_MethodReplacement() {
-                            override fun replaceHookedMethod(param: MethodHookParam) =
-                                if (HookMedium.getBoolean(HookMedium.ENABLE_COLOR_ICON_HOOK, default = true))
-                                    try {
-                                        /** 获取通知对象 - 由于 MIUI 的版本迭代不规范性可能是空的 */
-                                        (param.args?.get(0) as? StatusBarNotification?)?.let { notifyInstance ->
-                                            /** 获取通知小图标 */
-                                            val iconDrawable =
-                                                notifyInstance.notification.smallIcon.loadDrawable(lpparam.globalContext)
-
-                                            /** 判断是否不是灰度图标 */
-                                            val isNotGrayscaleIcon =
-                                                !lpparam.isGrayscaleIcon(lpparam.globalContext, iconDrawable)
-
-                                            /** 获取目标修复彩色图标的 APP */
-                                            var isTargetApp = false
-                                            run {
-                                                IconPackParams.iconDatas.forEach {
-                                                    if ((notifyInstance.opPkgName == it.packageName ||
-                                                                lpparam.findAppName(notifyInstance) == it.appName) &&
-                                                        HookMedium.isAppNotifyHookOf(it)
-                                                    ) {
-                                                        if (isNotGrayscaleIcon || HookMedium.isAppNotifyHookAllOf(it))
-                                                            isTargetApp = true
-                                                        return@run
-                                                    }
-                                                }
-                                            }
-                                            /** 如果开启了修复 APP 的彩色图标 */
-                                            if (isTargetApp &&
-                                                HookMedium.getBoolean(HookMedium.ENABLE_NOTIFY_ICON_HOOK, default = true)
-                                            ) false
-                                            /** 只要不是灰度就返回彩色图标 */
-                                            else isNotGrayscaleIcon
-                                        } ?: true // 否则不对颜色进行反色处理防止一些系统图标出现异常
-                                    } catch (e: Exception) {
-                                        logE("Failed to hook ignoreStatusBarIconColor", e)
-                                        false
-                                    }
-                                else false
-                        }
-                    )
-                }
-                /** 强制回写系统的状态栏图标样式为原生 - 新版 */
-                runWithoutError(ignored = true) {
-                    XposedHelpers.findAndHookMethod(
-                        NotificationUtilClass,
-                        lpparam.classLoader,
-                        "getSmallIcon",
-                        lpparam.findClass(ExpandedNotificationClass),
-                        Int::class.java,
-                        object : XC_MethodHook() {
-
-                            override fun afterHookedMethod(param: MethodHookParam) {
-                                lpparam.hookSmallIconOnSet(param)
-                            }
-                        }
-                    )
-                }
-                /** 强制回写系统的状态栏图标样式为原生 - 旧版 */
-                runWithoutError(ignored = true) {
-                    XposedHelpers.findAndHookMethod(
-                        NotificationUtilClass,
-                        lpparam.classLoader,
-                        "getSmallIcon",
-                        lpparam.findClass(ExpandedNotificationClass),
-                        object : XC_MethodHook() {
-
-                            override fun afterHookedMethod(param: MethodHookParam) {
-                                lpparam.hookSmallIconOnSet(param)
-                            }
-                        }
-                    )
-                }
-                /** 修复下拉通知图标自动设置回 APP 图标的方法 - 新版本 */
-                runWithoutError(ignored = true) {
-                    XposedHelpers.findAndHookMethod(
-                        NotificationHeaderViewWrapperInjectorClass,
-                        lpparam.classLoader,
-                        "setAppIcon",
-                        Context::class.java,
-                        ImageView::class.java,
-                        lpparam.findClass(ExpandedNotificationClass),
-                        object : XC_MethodReplacement() {
-                            override fun replaceHookedMethod(param: MethodHookParam): Any? {
-                                lpparam.hookNotifyIconOnSet(param, isNew = true)
-                                return null
-                            }
-                        }
-                    )
-                }
-                /** 修复下拉通知图标自动设置回 APP 图标的方法 - 旧版本 */
-                runWithoutError(ignored = true) {
-                    XposedHelpers.findAndHookMethod(
-                        NotificationHeaderViewWrapperInjectorClass,
-                        lpparam.classLoader,
-                        "setAppIcon",
-                        ImageView::class.java,
-                        lpparam.findClass(ExpandedNotificationClass),
-                        object : XC_MethodReplacement() {
-                            override fun replaceHookedMethod(param: MethodHookParam): Any? {
-                                lpparam.hookNotifyIconOnSet(param, isNew = false)
-                                return null
-                            }
-                        }
-                    )
-                }
-                /** 干掉下拉通知图标自动设置回 APP 图标的方法 - Android 12 */
-                if (isUpperOfAndroidS)
-                    runWithoutError(error = "ResetIconBgAndPaddings") {
-                        XposedHelpers.findAndHookMethod(
-                            NotificationHeaderViewWrapperInjectorClass,
-                            lpparam.classLoader,
-                            "resetIconBgAndPaddings",
-                            ImageView::class.java,
-                            lpparam.findClass(ExpandedNotificationClass),
-                            replaceToNull
-                        )
-                    }
-                logD("hook Completed!")
-            }
-        }
-    }
-}

app/src/main/java/com/fankes/miui/notify/hook/HookMedium.kt

@@ -1,136 +0,0 @@
-/**
- * Copyright (C) 2022. Fankes Studio(qzmmcn@163.com)
- *
- * This file is part of MIUINativeNotifyIcon.
- *
- * MIUINativeNotifyIcon is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * MIUINativeNotifyIcon is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * This file is Created by fankes on 2022/1/24.
- */
-@file:Suppress("DEPRECATION", "SetWorldReadable")
-
-package com.fankes.miui.notify.hook
-
-import android.content.Context
-import android.os.Handler
-import android.util.Log
-import android.widget.Toast
-import androidx.annotation.Keep
-import com.fankes.miui.notify.application.MNNApplication.Companion.appContext
-import com.fankes.miui.notify.application.MNNApplication.Companion.isMineStarted
-import com.fankes.miui.notify.bean.IconDataBean
-import com.fankes.miui.notify.utils.FileUtils
-import com.fankes.miui.notify.utils.XPrefUtils
-import java.io.File
-
-@Keep
-object HookMedium {
-
-    const val ENABLE_MODULE = "_enable_module"
-    const val ENABLE_HIDE_ICON = "_hide_icon"
-    const val ENABLE_COLOR_ICON_HOOK = "_color_icon_hook"
-    const val ENABLE_NOTIFY_ICON_HOOK = "_notify_icon_hook"
-
-    const val SELF_PACKAGE_NAME = "com.fankes.miui.notify"
-    const val SYSTEMUI_PACKAGE_NAME = "com.android.systemui"
-
-    /**
-     * 判断模块是否激活
-     * 在 [HookMain] 中 Hook 掉此方法
-     * @return [Boolean] 激活状态
-     */
-    fun isHooked(): Boolean {
-        Log.d("MIUINativeNotifyIcon", "isHooked: true")
-        return false
-    }
-
-    /**
-     * 获取此 APP 的通知图标是否被 Hook
-     * @param bean 图标 bean
-     */
-    fun isAppNotifyHookOf(bean: IconDataBean) = getBoolean(key = bean.toEnabledName(), default = bean.isEnabled)
-
-    /**
-     * 设置 Hook 此 APP 的通知图标
-     * @param bean 图标 bean
-     * @param isHook 是否 Hook
-     */
-    fun putAppNotifyHookOf(bean: IconDataBean, isHook: Boolean) = putBoolean(key = bean.toEnabledName(), bool = isHook)
-
-    /**
-     * 获取此 APP 的通知图标是否被全部 Hook
-     * @param bean 图标 bean
-     */
-    fun isAppNotifyHookAllOf(bean: IconDataBean) = getBoolean(key = bean.toEnabledAllName(), default = bean.isEnabledAll)
-
-    /**
-     * 设置全部 Hook 此 APP 的通知图标
-     * @param bean 图标 bean
-     * @param isHook 是否 Hook
-     */
-    fun putAppNotifyHookAllOf(bean: IconDataBean, isHook: Boolean) = putBoolean(key = bean.toEnabledAllName(), bool = isHook)
-
-    /**
-     * 获取保存的值
-     * @param key 名称
-     * @param default 默认值
-     * @return [Boolean] 保存的值
-     */
-    fun getBoolean(key: String, default: Boolean = false) =
-        if (isMineStarted)
-            appContext.getSharedPreferences(
-                appContext.packageName + "_preferences",
-                Context.MODE_PRIVATE
-            ).getBoolean(key, default)
-        else XPrefUtils.getBoolean(key, default)
-
-    /**
-     * 保存值
-     * @param key 名称
-     * @param bool 值
-     */
-    fun putBoolean(key: String, bool: Boolean) {
-        appContext.getSharedPreferences(
-            appContext.packageName + "_preferences",
-            Context.MODE_PRIVATE
-        ).edit().putBoolean(key, bool).apply()
-        setWorldReadable(appContext)
-        /** 延迟继续设置强制允许 SP 可读可写 */
-        Handler().postDelayed({ setWorldReadable(appContext) }, 500)
-        Handler().postDelayed({ setWorldReadable(appContext) }, 1000)
-        Handler().postDelayed({ setWorldReadable(appContext) }, 1500)
-    }
-
-    /**
-     * 强制设置 Sp 存储为全局可读可写
-     * 以供模块使用
-     * @param context 实例
-     */
-    fun setWorldReadable(context: Context) {
-        try {
-            if (FileUtils.getDefaultPrefFile(context).exists()) {
-                for (file in arrayOf<File>(
-                    FileUtils.getDataDir(context),
-                    FileUtils.getPrefDir(context),
-                    FileUtils.getDefaultPrefFile(context)
-                )) {
-                    file.setReadable(true, false)
-                    file.setExecutable(true, false)
-                }
-            }
-        } catch (_: Exception) {
-            Toast.makeText(context, "无法写入模块设置，请检查权限\n如果此提示一直显示，请不要双开模块", Toast.LENGTH_SHORT).show()
-        }
-    }
-}

app/src/main/java/com/fankes/miui/notify/params/IconPackParams.kt

@@ -1,378 +1,142 @@
-/**
- * Copyright (C) 2022. Fankes Studio(qzmmcn@163.com)
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2017-2023 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
  *
- * This file is part of MIUINativeNotifyIcon.
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
  *
- * MIUINativeNotifyIcon is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * MIUINativeNotifyIcon is distributed in the hope that it will be useful,
+ * This software is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
  *
- * This file is Created by fankes on 2022/1/24.
+ * This file is created by fankes on 2022/1/24.
  */
+@file:Suppress("MemberVisibilityCanBePrivate")
+
 package com.fankes.miui.notify.params
 
+import android.content.Context
+import android.graphics.Color
 import com.fankes.miui.notify.bean.IconDataBean
-import com.fankes.miui.notify.utils.bitmap
+import com.fankes.miui.notify.data.ConfigData
+import com.fankes.miui.notify.utils.factory.bitmap
+import com.fankes.miui.notify.utils.factory.safeOf
+import com.fankes.miui.notify.utils.factory.safeOfNan
+import com.fankes.miui.notify.utils.factory.safeOfNull
+import com.fankes.miui.notify.utils.factory.snake
+import com.highcapable.yukihookapi.hook.factory.prefs
+import com.highcapable.yukihookapi.hook.param.PackageParam
+import org.json.JSONArray
+import org.json.JSONObject
 
 /**
  * 通知栏小图标适配类
- * 国内 APP 不规范的图标将由这里完成其自定义黑白小图标绘制
+ *
+ * 国内 APP 不规范的图标将由这里完成其自定义单色小图标绘制
+ * @param context 实例 - 二选一
+ * @param param 实例 - 二选一
  */
-object IconPackParams {
+class IconPackParams(private val context: Context? = null, private val param: PackageParam? = null) {
 
     /**
-     * 通知栏小图标数组
-     * 默认使用包名进行匹配 - 若失败则使用 APP 名称进行匹配
-     * @return [Array]
+     * 已存储的 JSON 数据
+     * @return [String]
      */
-    val iconDatas by lazy {
-        arrayOf(
+    internal val storageDataJson get() = (context?.prefs() ?: param?.prefs)?.get(ConfigData.NOTIFY_ICONS_DATA)
+
+    /**
+     * 获取图标数据
+     * @return [Array] 通知栏小图标数组
+     */
+    val iconDatas
+        get() = ArrayList<IconDataBean>().apply {
+            storageDataJson?.also {
+                if (it.isNotBlank()) runCatching {
+                    JSONArray(it).also { array ->
+                        for (i in 0 until array.length()) runCatching {
+                            add(convertToBean(array.get(i) as JSONObject)!!)
+                        }.onFailure { context?.snake(msg = "部分规则加载失败") }
+                    }
+                }.onFailure { context?.snake(msg = "规则加载发生错误") }
+            }
+        }
+
+    /**
+     * 转换为 [IconDataBean]
+     * @param jsonObject Json 实例
+     * @return [IconDataBean] or null
+     */
+    private fun convertToBean(jsonObject: JSONObject) = safeOfNull {
+        jsonObject.let {
             IconDataBean(
-                isEnabled = true,
-                isEnabledAll = false,
-                appName = "Android 系统",
-                packageName = "android",
-                iconBitmap = ("iVBORw0KGgoAAAANSUhEUgAAAD4AAAA+CAYAAABzwahEAAAAAXNSR0IArs4c6QAAAARzQklUCAgI\n" +
-                        "CHwIZIgAAAMCSURBVGiB7ZlLixRXGIafMzqC6MyoUfCCEFwoBpzZGK9hQGzQlW4SENGN4FZI9Ed4\n" +
-                        "+Q8iuBdNQEVHhZCoW10oLt0JipfRqIwyj4vuoduxu27d1V2R80Bvur/z1vueS5061RCJRCKRSCQS\n" +
-                        "iUQiFSKkFaiTwEHgHXA+hPC0dFcFUH8EjgFLgCshhL+7ETuuztpkWq31ymyvUGsNb3PMqseLig2p\n" +
-                        "r/2W91UK3wj9vo3PV+pQEcGVbcQqFT4h9Bw/FBV+UtXwGUI/TmqfeHNTdwFTwOIOJR+AAyGEqQ7t\n" +
-                        "lwC/ABPAT8BmYCUwBow0yt4Cb4AXwKPG5yHwTwjhvw66NeDPFF+1EMLdpHyJZOjZr0ZeXaOeUm+p\n" +
-                        "HxPapfFRnVJPqquL+umKjBc7oV5SP3URthMzDe0TGXxkCp26j7eEnwSuUt8nq0jisusKdVJ9V8KI\n" +
-                        "dkv5N1rr035mwEFbmbFA6FwbvLoAqAHDeS9UIsPAb2o5ntTl6s2Bjm0yN9RlWfNkurlZfwK6A2wp\n" +
-                        "2nF94gGwJ4TwKq0wdaqro8A1qh8a6g9K19WRtMLE4Ooi4C/g5x4Z6wfbgCumrPm0ET8HTPbMUv/Y\n" +
-                        "A5xOKui4xtUDwOWkmooj8GsI4VK7H9uGUtdSPyyMZbzII+B6Q28/9cNILymq/xrYHEJ4lqlavZhj\n" +
-                        "GzmjLmxpO6ye7eE21a3+hayhd/v166YkbqnfzBo1qLfzpCtRf1bdmSX4vRzGDiXoHM6XsVT9f+e3\n" +
-                        "H5onthvYkdo7TZIeFF7m0Clbf5fzRn3+dvZHDjGo75md2J5Tq2z939t+q65XP+ecitPqhjZaG9S3\n" +
-                        "ObXK1v+krpvTaB3xg8CCnL04AtxTj6ij6ph6FLgPLM2pVbb+QuoZgZZ9XJ0C9vbAbJW5EULYB43g\n" +
-                        "6hjwnGqds8tgBlgVQpiem+rb+P5DAywCtkJzjY8PzkvfGYdm8IkBGuk3E9AMvnGARvrNJmgGL/bn\n" +
-                        "2v+TFdAMnvX4+T2wDJrBRwdopN9kfhMbiUQikUgkEolEIpGy+QJozXWVnxEugwAAAABJRU5ErkJg\n" +
-                        "gg==").bitmap,
-                contributorName = "fankes"
-            ),
-            IconDataBean(
-                isEnabled = true,
-                isEnabledAll = true,
-                appName = "手机管家",
-                packageName = "com.miui.securitycenter",
-                iconBitmap = ("iVBORw0KGgoAAAANSUhEUgAAADIAAAA7CAYAAAA5MNl5AAAAAXNSR0IArs4c6QAAAARzQklUCAgI\n" +
-                        "CHwIZIgAAAXzSURBVGiB1ZrLi1xFFMa/ut13bnfTw4gOBMMkQUJcCAqiZBEQsxFchBAiItGNOzHg\n" +
-                        "H+Aqg+jKTVausoi4kCS6EBQF0SGQLCITgviAyJhkHDKLzNvu+zxV9bmY7s7tnkf6UTeJPyhmum51\n" +
-                        "1fnqnLr3dNUFHEPyFMnLJJdIRiSlVSKSSyJymeQp1+M6geTpJElukkxImn7K2tpa0mg0bi4vL3/w\n" +
-                        "SI1fXl4+HMfxtTiOoyRJDEnT/jtIkUxMlmURyVmShx+aAJKfkrxHUpM0YRh2GdW3AOlua4wxSZJo\n" +
-                        "EblH8mwhxs/Ozj4dx/GPaZpGg874oCVHLCI/z83N7RtZAMnDxpjfRURImizLtsxk0UVERBK5SfLV\n" +
-                        "YQScIvlPO3wehxJFkSZ5t9lsvtuPgNPt+O+d+fX19YHWQIFFi8gSya67nWoJeDVN00u+7z/led6O\n" +
-                        "QrVolP3ywB4ukBUAbyqlLiuSx621lzzPe6ws7JeNjQ09MTHxphKRpXK5/KS1FtZalMv/Sz1riqQA\n" +
-                        "8LTWhYqw1mK3sB2Wlt3W01p7AAoZBACiKAKwKUREnPffmvz71nueh3Z4OYTlcvlDAIYkfN932XcX\n" +
-                        "iqQBsEWAIw/dVUrtN8Yknuf5URShVqu56HcLHrBVxCho0e3+COB94P6kFCUCaAlpD5YvwyJa4Hke\n" +
-                        "jDELSqnv8tcch20Xzhd6EAQAwLW1tQenEg7prBFXtNbBLaXUoXYdyQSAX9QtGMiFlitqtZoF8E6+\n" +
-                        "rn03LDy0XJKm6S2l1C/5OqstrLEg2SXKpTDXj3K7urr6dm+lV96cryI94nqN/KmUer63Mr9GenG1\n" +
-                        "ZkbuRYtu/2sBvLVDs2WguDQIcBBaogVlv4wwDP+o1+t/btdGKTU1Nze37+DBg7h9+/aW677vj+/f\n" +
-                        "v/8KgIlh7XAVWhbAs0qprVb2Ccl5EZkaNh9z4mud6RujiFhcXHwJwN5RkkoXQsz8wvwbo3RQr9e/\n" +
-                        "iKJoJFtchNY1pdSRYb88Pz//3NTU1K8YMV0a1SP6+vXrI3lj7969XzqwY2SPdOVUg3Lnzp1nDhw4\n" +
-                        "8BcetRBrraRp+p0xJq3X69u2aTabV8bHxz/b7lqWZLN+4L847Ph5FEmN1v7WoOSf1LvENldWVo5M\n" +
-                        "Tk525V8k9xlj/i6VSqVhxu4dw8PmM2Ao+lyYamxs7IVt6i+QdCECAKwHQD+wmWNmZmYm0zR9yeH2\n" +
-                        "k/YArLvqrV+OHj16KQgCl5n3ugfgt1F6eNBvfK01xsfHO58vXrw4obU+4vL3SBRFv3kAPsLmjkch\n" +
-                        "GGPQaDQ6n0+cOPEVcsmqA0FsNpsfeUqpq6urqxvA5uy5JgiCjkemp6drpVLplbwHR921McZs7Nmz\n" +
-                        "56oHAL7vnwdQyN6vtbbjkTNnzlwE4HS7sVQqnQdyz484jtcrlcr4zl8ZifcAfA6gYa3tEjKoN0QE\n" +
-                        "pVIJnuchSZJGtVp9AsilBpVK5WMRKWytAPgSDrzh+z6s2dzJNMZ83K7veqInSTIbBIGTlKGHCwBO\n" +
-                        "AAhG7SiOY1SrVQC4oZR6uV3fm5r4JJcBbJ84PT40AUwqpTrnFL0BKgBOZllmgftnG48D7fOVOI7t\n" +
-                        "ysrKybwIYJv0WSn1U5Zl5wCwVqsVtqE2KCIC3/dpjDk3OTn5U+/1HbPeKIoulMvlN0qlUlebIrd0\n" +
-                        "tkNrDRFBtVqliHw9Nja27ZbTruk7yW9Jvk6y0+5hC2l7IsuyH4IgOLZTu12tUkodU0rNpGnadTRX\n" +
-                        "ZKjFcdxZm1EUtY/rZnYTAfTxE1Mp9RrJ77F5HujC1l0h2TnZqlQqBPC9Uuo1ZwPEcfxJkiSZ6aHA\n" +
-                        "VzWyOI4/cSYgD8njxpioSCFhGBpjTBSG4fFCRLRZWFg4RPKeyxdskiTJT8y9hYWFoXdmBobkNzrT\n" +
-                        "4kLExsaG4eYLnN88NAF5wjA8TrIxipCWFxokiw2lBzE9PV0jOdOa0UGFiIjMkCzuAH5QSB4muUjS\n" +
-                        "RFHUj4hFPsy3SgeF5HSapv/u9O5jo9H4NwzD6UdtZ98kSXI2juMlkmmrLLGo12AB/AciDjB9K6Gy\n" +
-                        "5wAAAABJRU5ErkJggg==").bitmap,
-                contributorName = "fankes"
-            ),
-            IconDataBean(
-                isEnabled = true,
-                isEnabledAll = false,
-                appName = "QQ",
-                packageName = "com.tencent.mobileqq",
-                iconBitmap = ("iVBORw0KGgoAAAANSUhEUgAAAEwAAABMCAYAAADHl1ErAAAAAXNSR0IArs4c6QAAAARzQklUCAgI\n" +
-                        "CHwIZIgAAATZSURBVHic7ZxNjF5TGMd/T6uliBk1pSgtxQwlqo2gKghiU4ZaCOIjRGwIiY8QCRs7\n" +
-                        "S4suRJBYkUgXMiIipBYTiZmuKtRHW0biK8xrNE2l9be4d5LpeN/33nue877n3tHf5p259zzPfc4/\n" +
-                        "z7kf5wuOUglLeXFJw8BmYD0wApwBrACW5UUOANPAPuAb4HNg0sx29j/aREgakvSUpHGFMyHpBUln\n" +
-                        "p65Pz5C0VNJLkmYcQs3nkKRtkoZS1y8qkkYl/RBRqPlMS3oodT2jIOnlHgo1nzdT19eFpHf6KNYs\n" +
-                        "O1LXO4hEYs0ynrr+lZD0SkKxZtmeWodSSLoztVJzeC52/aK+uEoaBP6I6TMC55nZt7GcLYrlKOeN\n" +
-                        "yP5i8HZMZ9EEk7QRGI3lLyIbJG2N5Sxak1T2ZLoylr/ITJnZWTEcRckwSeuor1gAqyTdHMNRrCb5\n" +
-                        "TCQ/veT5GE7cTVLSUuBP4Fh/OD1npZn97HEQI8O20AyxAO71OoghWB2fjJ1w38diNMk9wBqvnz5x\n" +
-                        "EDjFzPaHOnBlmLIu5qaIBdmtY7PHgbdJXu60T8ElHmOvYCNO+xQkFWzYaZ+CCzzGXsHOddqnYK2k\n" +
-                        "4HoHG+YXPTXUPiHLycY+g/Bk2EnAoMM+FYtxxO0V7ESHfUqODzX0CLbEYZua40INY/e4LniOClYR\n" +
-                        "j2CtaFH0n99DDT2CneawTU3w969HsEcdtql5PNQwqHunYb2snQjqfQ3NsNtptlgAD4YYhWZYnYfU\n" +
-                        "yhI09FY5wyStpfliQTb0dm1Vo5Am+USATV15sqpBpSaZ91C0aO43ZDtWmNlvZQtXzbC7WVhiATxc\n" +
-                        "pXDVDNsBXFMpnPqz18zOKVu4tGDK5sTvCwqp/mwys1LTPKs0yXsCg2kC95UtWCXDdgPnB4VTf/4C\n" +
-                        "Bszsn6KCpTIsn860UMWC7EF2U5mCZZvkXeGxNIb7yxQq1SQXeHOcpWVmhYMjhRmWPx0XulgAA2U+\n" +
-                        "lco0ySZNZ/JyS1GBMoLdECGQpnB9UYGu97D82/EnHCPFDaTrt2VRhl3G/0ssgKu7nSwSbH3EQJrC\n" +
-                        "pd1OFgl2YYfjh4GpoHDqwRTZ9M12dJ0/ViTYRR2OPwK8WmBbZ94j66pqR6ckAYoFW93m2F4ze61M\n" +
-                        "VDVmwMzeBT5tc25VN8Miwdrd8Lfkvz+WCKyufJf/tlu0tbibYZFgy+b9/7SZ7cr//qREYHXlQ4D8\n" +
-                        "9eGOaF515B4T/1kSLGl3j1fU9oIZZQPRc+sxd8n1TDdNijLsQP47aWa3tTn/eoF9HXnLzP6ee8DM\n" +
-                        "HgPez//tOmZR9Ka/DVgH3Dj/Ivn5IeDXSuGmZ8TMvmp3QtIYcMjMbu3Z1VWPHQTKMuatb4y1RieQ\n" +
-                        "jVV2fbrUhNVm9r3HgXsGYr7Q6QGvnz7wolcsiLvmezv17TubNLONMRzFFGwR8CX1651tAWvMbDqG\n" +
-                        "s2iTgvMhqk3U66P8IHBFLLGgR1v6SZoANvTCdwW+Bi5u9zrk4ZiYziRdBVxHPWYnLgGelfSZmX2Q\n" +
-                        "OpgjkLRV0sfpXq8KmVAddrCTNChpLLEYVRhXNoMymOB7mLIX1p3U76lYRAsYDt2/wvOUXEnzxAIY\n" +
-                        "wLH02nPT30O2ccYoWVf2mYR/Hh0m23dsP9myltlXk9PJlhkuB052+v8F+AL4CGjWln9N5l/CCEZS\n" +
-                        "HWRiiAAAAABJRU5ErkJggg==").bitmap,
-                contributorName = "fankes"
-            ),
-            IconDataBean(
-                isEnabled = false,
-                isEnabledAll = false,
-                appName = "微信",
-                packageName = "com.tencent.mm",
-                iconBitmap = ("iVBORw0KGgoAAAANSUhEUgAAAEgAAABICAYAAABV7bNHAAAAAXNSR0IArs4c6QAAAARzQklUCAgI\n" +
-                        "CHwIZIgAAAZvSURBVHic7ZtbrF1VFYa/UbDWSktRELl4ioa2iAUURKXyACgXxQsoqKmaqAkqicqL\n" +
-                        "JvpgohIjRnwQbdQHYkLRaOKtjQ1VMdVGShu1GppKQ5FWbKlwqOcUaUNty+fDXFs2i7171tyXtbbJ\n" +
-                        "/pKTczL3nGOM9e+51ppzzHFgzJgxY8aM+X8lBmVInQ28DDgPWAKcBhwPPL/ochCYBvYA24AtwMMR\n" +
-                        "cXBQMQyDvgVSrwbeCFwNnAnMrTj0APA34C5gfUSs6TeWkUGdUL+ibnVw/FW9WX1p09fXM+rL1dvU\n" +
-                        "JwcoTJnJQqgXNX29Wag3qVNDFKbMTvWdTV/3jKgL1XU1ClPmO01r0BX1PHV7g+K0WKO+uAkNur7F\n" +
-                        "1EuAtTzzmm6arcBlEfFYnU47CqSeBWwkrWNGiS3Asoh4si6Hs8oN6jxgNaMnDsA5wMo6HT5HIOB2\n" +
-                        "YFGdQWRyjfrlupw96xZTLwN+U5fzPlkaEVuH7aQ8g74xbIcD5Ft1OPmfQOq7gKV1OB0Ql6iXD9tJ\n" +
-                        "+wz6aObYA8AK4BPAj/qMYyPwGeBm4B8Z4z7ep99qqIvVpzMWblPqa0o2buhxEXhHyc4CdXPFsYfU\n" +
-                        "hXUI9KnMi/p2Fzv3ZNqZUk/qYOd9GTY+MkxtWrfYlZnjtndpfyjTzlRETHZoz7nN3pTpM4uWQEsy\n" +
-                        "x11VblBfAFyaaedU9eIO7TkP39dn+sxH3Z95a6h+ySJnY8oT/bwHG6r3qxcWdo5RP6gezBx/3LC0\n" +
-                        "iSIwexy/m5Q2fS3VU63d2ADMI20nOrEP+HPRbzvwCLAXeBzYFRFH+vTfkX4FGjYHSDnr1cDaunfy\n" +
-                        "AMfW7bAie4FvAndExI72D9TTSYcDS4FTSJvqY4FDwBRpVm8DdkTEw/0GMooCrQBuiYhdrQb1IuDt\n" +
-                        "wDLgImB2BTsH1E3A74E1EbGp54jUp3p8wA6SHaYjpPa4rlV/qR7p0/Zhdb1pO9WTQA/1GUC/rFIX\n" +
-                        "tMVzscPLg28ydw+n3jWkYKpwZymWz5u+8WHzNbXawan6yRoC6sTKthhmqz+s2f9vTRnUGQWasP7n\n" +
-                        "0Po2//PVe2v23+JP6mndtJkFULwOV1WaboNhD3A9gGma/xR4Q43+2zkf+Jl6TKcP2/NBX60nHgA+\n" +
-                        "HBGPFn/fzpA3nBW4EPjBjL3UlTVM6TVt/q6rwV8Oy8ualJP2JwAPAsMsHHhlRGxT5xe+npMPamMa\n" +
-                        "mKS3U5Yp0or8zIwxjwOLImK61fCspH1ETAE39BBMVVZFxLbi7xs5uji/Ai6IiMWk59XeDD9rgfMj\n" +
-                        "YhHwIWB/xXEnAjfN2Ev97JCm8HsK+3PVXUfp92gxw9pj+lxFH5Pq8aWxt2bE+E91Tmtsp4NDIuIW\n" +
-                        "4OsVVa/KJOmbBbiGVKLXjd0R8USp7b6KfvZExL5S218qjgU4mVQtB3QRCCAiPg3cmmF4Jja3XfRM\n" +
-                        "Kd6z1fJr/70V/SxRl5Xa3l1xbIs3m7HKzk3od+MLhb1Q76vQf9q0wr9CvTPT17Sp4Ott6k8yx2oq\n" +
-                        "LZyoLKd6qfpAD47a+UBh6xR1X5+2hs1+U/lP91usnYhYB1wB9JPR21P8PgmYf7SOI8AcUklzNYEA\n" +
-                        "ImIn8Mc+nLZetXOO2ms0mEXxJVYWyLRX6ecUs5X3PtyHjToR8lKurwZe1aH9MGlRt410KnEqMAEs\n" +
-                        "AE4AWkcyrYTYPlLV/aiU9nXiCGlVnSXQBR3a1gBfjIg/lD9QX0i6jydIB5Ot09jdxc8rMnzXzRPA\n" +
-                        "37NGqCvanvK71Pf36t1UtTrK3GNRVVvpGWRaNLUWW7cB50TE93sVCLi7j7F1cHdEVN/7qWebMm/v\n" +
-                        "GIR39Qzzjpfr5nW5F3SiXTJufYj0vYZF6MaG9jgH9v9iPQi0GLifjKVGTbwlIlqb6uaCi4gHSM+z\n" +
-                        "UWJ1uzjQ4AwCUJ9HWp2f22QcBY+QSoun2hsbnd4RcQhYTvWM37B4Gri+LA6MwP1fFIO/tcEQBK6N\n" +
-                        "iA0z9mwS9XL1sZrfWPvV3LLB5lDPVR+sUaDrmr7mbNR56ndrEOfHVeJp/BlUJiL+HREfIxVM3TtE\n" +
-                        "VxurdBo5gVpExC8iYhmp5HgVRfohk53AOuDXpEPKdirlthpdB+VgqsC4klQFexZwBinfNJf0JnoK\n" +
-                        "+BcpL7UZ+B2wMSL+U4yfRTpuWs4zG++Fg6hjHEnU49SXqKcXPydbsV5avUrdot447DjHjBkzZsyY\n" +
-                        "5vgviFEUXbpK+wsAAAAASUVORK5CYII=").bitmap,
-                contributorName = "fankes"
-            ),
-            IconDataBean(
-                isEnabled = true,
-                isEnabledAll = false,
-                appName = "酷安",
-                packageName = "com.coolapk.market",
-                iconBitmap = ("iVBORw0KGgoAAAANSUhEUgAAAEgAAABICAYAAABV7bNHAAAAAXNSR0IArs4c6QAAAARzQklUCAgI\n" +
-                        "CHwIZIgAAATESURBVHic7ZpviFVFGMafWcvC/YMa2x/TLFs2My1pIZGiLAUtKohVRIoiKiOEIiIU\n" +
-                        "qQ8VgVSyQrEmlF8K+mJYWWIQtaSWmxtYURttBJa1FGurpLabbb8+3LPs9e6dOXPmnGsE8/u0e2fm\n" +
-                        "eZ/3veeeOTNzpEgkEolEIpFIJBKJRCKRSCQS8cXkGQzMltQmaZGkuZIuktQgaUjSz5L6JX0pab+k\n" +
-                        "XmNMby631T2slrReUpOkjcaYZ4uOkRngDuATsvMdsAZoLsjHyioxHilCO9TQYuCLgMJUchxYD0zJ\n" +
-                        "4aXJov0XUFdk3r6GNhZQmEqOAPcG+nnDobul6PxdRhqArhoUp5wuoC2Dp6s8NGfWsi6jRiYCX9W0\n" +
-                        "NKdyn6evAx5aO4uogXMWA/ZJWuChc1TSXkm/SjqR6NZLOlfSPEnTM3jqNMascXi6U9LrnlpzajFz\n" +
-                        "jhrZ4PEt7QIeBCY7dOqAW4CXgV88r6Qu4IIqWhOAAU8NgI9rVZyWlMC/E3BzBSYBTwMnPJLrB66s\n" +
-                        "GP9UhuKMsqy4yowZ2e8I+DUwLaf+dGCrR3IjwO3JGNu0DtAD9FraDhZTlTHzNzmM/Ijj5xQQ6x7g\n" +
-                        "H49CtQHPOdrrgZsd7XcX5VnADkegOYUFGos3F+hzxNwE3OZo7yjTOmrpc7gos1McRnxnjpC4jZYv\n" +
-                        "5tGk/UOLp2HgjDKdakuPUdYVYXSpRfxv4MLcAdLjb07i/QAsTj572JH0yioatnsRQENeg7blRHcu\n" +
-                        "4WweFgGNyd/NjmR3W8Zf5xjzUl5zeyzCT+YSDvfzniPZWY5xtjyc43wM/WQRvSFYNNzLMkeSL1b0\n" +
-                        "nVrxf6tj7I48po5ZRFuCRcN81AODFi/9nHpjfh74A9gJzCj7/G1HkeaHGjtuEQy/LMN8vONIbknS\n" +
-                        "p5Xxe1NDQHvSPs2hsTfUmG2tdE2B+ad5uMuR2PakzwOUnrJtdCT9nnH0WRhizrbEsK6uiwS41JEQ\n" +
-                        "wJmUFqx/pvQD2AbMAr6xtPf5eKrcmjxg6bc0X+revO9oW2uMOWmMGVFp+6TqNF9Gu6QuSSOW9hZg\n" +
-                        "eSZ3wHJLtQczCQWAe4nzqWWMz5aMi9+ymnTd2B4vpBLV476Wksj5jrErsM94PqzNanafRWgIaMpd\n" +
-                        "jfHxOlMSaPfQmAl0BxZoBDg7i+FVDrG0330mgFdTzHdm1NsSWKQNWYJMBA45xN7KXInxMS4h/aRk\n" +
-                        "T6D2avz2mMrJ9usAlqQIdgPzAhN4LDHk4jNgQoh+EmM28HnGImW6WtMWiqN0AK0eWmdR2raw3d/K\n" +
-                        "6QUmhRanLGYdftu65VxcqWM99klMHpLkczy8U9K3kr6X1CcJSedJulxSi6TrJfnsY/dIutEYc8yj\n" +
-                        "rxeUztpe8ey+zRizIov4ZZR27U4HH1C2CC0S4FrgoKePccdNaeJXA4drVZWETbUoTEUejcCbHl62\n" +
-                        "hog3A7trUJhBkmOd0wXwUIqnk3nE11F6vaQINgPnFJh7ljwWUNpXqkpe8RnAC/idjlYyTOlh7oqC\n" +
-                        "cs2TRxOwvYrHj8r7Bb+CR+ktsYWSbpU0X1KzpMmSRp9fhiUdkTSg0mt470rqMcb0h8asBcD9kp6Q\n" +
-                        "NFVSt6RVxpiB/9ZVJBKJRCKRSCQSiUQikUgkEvl/8i8jWVdXsYky1AAAAABJRU5ErkJggg==").bitmap,
-                contributorName = "fankes"
-            ),
-            IconDataBean(
-                isEnabled = true,
-                isEnabledAll = false,
-                appName = "支付宝",
-                packageName = "com.eg.android.AlipayGphone",
-                iconBitmap = ("iVBORw0KGgoAAAANSUhEUgAAAEgAAABICAYAAABV7bNHAAAAAXNSR0IArs4c6QAAAARzQklUCAgI\n" +
-                        "CHwIZIgAAAK8SURBVHic7ZpBitVAEIb/9hpxIcgIeg15C0HceAxlQLzHu4mLDAMD48JbKGQQXOg5\n" +
-                        "fhdJIC8vnepOV3fnPepbTvKqqv+urq7uDGAYhmEYhmEYhnFdkDyQ7LhC7RirIomzB4FcTechAjjn\n" +
-                        "qsb4rKbzS8AEEjCBBEwggaQCuIddJoSUQm8ZJGACCVgfJGAZJGACCZhAAiaQgAkkoLJDkGwA/NWw\n" +
-                        "pcSTc+6VhqFrzaB7LUPXKtBD7QCqQbIpeQt5iRn0Rnh+VySKvUKyFRLoUDvGagQsr07b56UtsY/C\n" +
-                        "c7XdayT1wqxBXxNeA3gx/Pnl5JXfAP4A+AXgp3PuX6K/DsDNyivPU30kM6T5kQHftDy0w++jagX7\n" +
-                        "j4yrdnONOTTAhnKB3EIXIhjlCalXnEneZhDGRzv4ayb+pexRL865xNm67HyMYlXLntUiPTh+XHj0\n" +
-                        "hH7HeICn+PK0gL8F8CE52mXUDqbRLMxclzJb7JdKSoEvmj3SYOZLS3WXmIiVSsdZzSoCT2c52xbK\n" +
-                        "fncMqTMhtCyRUTxv6YvMjqJQecXi6bZ6zOLE77tRFIkM7LNig5zWn6JFkHl7Lh2xaglEuSEsLtZu\n" +
-                        "TvP091xT7tD3YBrcAPgC4DE6s0pnUGDmdLP3c5wLR86OO2sBZz0lM1CcpWCZXyj//fbsvSzbPBPE\n" +
-                        "mdkZr2DUWXM6dah+Wg4ckCjOzGbqXVWUQPNmsY0JdsWu+N/1W8RZ8KPSdEpO5rPckbzdGHBMvVCZ\n" +
-                        "jA1+4wQaHCzNQugt4IHxM5mlc98qlHhpz34mf2D9snypN1l732fjk3Pue+TvohjG8xXAe8TH6Dca\n" +
-                        "mQWxFD3vTcYlZnesQe2t9MjS9zjL4/Iuvy3GUnuOzYU+N0tjS/1weADwDv16Bs7X9Fib7tF/QPxW\n" +
-                        "/cNeIMMkfs5huNnDsjEMwzAMwzAMoyb/AfL3c7cVoO+XAAAAAElFTkSuQmCC").bitmap,
-                contributorName = "fankes"
-            ),
-            IconDataBean(
-                isEnabled = true,
-                isEnabledAll = false,
-                appName = "淘宝",
-                packageName = "com.taobao.taobao",
-                iconBitmap = ("iVBORw0KGgoAAAANSUhEUgAAAE8AAAA8CAYAAAAngufpAAAAAXNSR0IArs4c6QAAAARzQklUCAgI\n" +
-                        "CHwIZIgAAAzFSURBVHicxVxfjF5FFf/Nbj92W8oqbCihGlbKH7MmlodiVVwNNCISk5o0MX3goaiN\n" +
-                        "qaKxPOADCUpEYgIxfSAhmmKKphj+VKUQMfDQvhCIFrUQKxSlBc02YSsWdxu76+7Hz4dzzt7zzTcz\n" +
-                        "997tH09yM9+dOzPnz5yZOXPmzBdwDoDkHgBXAngBwFEAhwG8CWAyhPDOuaDhbECoK0ByUH8OaPpe\n" +
-                        "CKHbpF4IoUtyBMDfAFycKPYugGP6/QiA+0MIx6xuDT0Gi3Ql8uJ8NKH9tIHkYIJQ/71TV1/TCQos\n" +
-                        "kJzVdIH9MKOCTtHRqcPXBqzN021nWa5x6yGSGwB8HsBqAKcA/A7A4yGE6ZKGQHq/C+AzLm8oUW5O\n" +
-                        "83+kbXYg2jIQQpjX9hdxkFwNYA2AKwBcBuBSABcBGHH8TAOYgWj2cQCTAN4AcCSEcMy3afjOiEY6\n" +
-                        "jRkhuTehISQ5SfImX77QzvNO83IwS3Is1QbJtSS3kdxN8qBq6FJhRtvYSXITnaZTtDs70toIsEPy\n" +
-                        "gGPaD7dZR4wJsBPVN8GNNxAaST4QCWwDyQdIHirUXWj5pGBKBbnW875koWl6b8RcjulJksOFdu50\n" +
-                        "jKaYJ8lJLTumeA9n8JWE0Aa8MnjYRXKV7/ylCHCYIhQmEMQMkeTmHEJWmlNq506SDyYYzAnrTGic\n" +
-                        "b8sryAmSG1sLkNVQW1uD0MCQ7oi0zdKbHIE5mGHvHBZrhDGX0pQ20ESQXoh3NBFgarXtG4Y1sFLT\n" +
-                        "96L0Gy3q2opr9HQBDLoHrtw0ZAWdQrWqngIwq2WX63MJgDHIiuzb6EbvBkOoVvX7SCKEcD8LFkVK\n" +
-                        "eG87ZprAUU0HFGGX5DoAGzW/Tv27SkfM1ByA1wD8CcBLAF4F8A8Ab4cQppsQRhkFHwJwHYBNAL6g\n" +
-                        "OEwYMW32rQsR4BshhF+VBOiR2dDdn1Dl1FAgdaWiM6pJPhqVaTqUDrMyI/pMlxS9rIzoRWM6N9xI\n" +
-                        "XkUxeWIecrzNUOzK+jnQMb/eNRQL0E+yDzombK5bVxBYiuBJilkywYSZEAmn9SroBDzo8jY5HnIC\n" +
-                        "tO97GglPC5kQttQIYW9G8Ka1MVHx+37qyhYxOqzP6Rus/bz5Tl7fQICWP+FlU4tE03WUXcYJVhp3\n" +
-                        "kOS2qHws8HjF9O97HDFjlNV99AzLqY6/YU03NhTeXi+XJgg67vcoZbeQ3EJpukqF7JH6If8MyfWu\n" +
-                        "np8aJik7mt0k79JOWHWaMkrx5IeudfiuBK0pGI/bqEWWKhznUYaZH66+Jw9Rt3GecJYN6CnK3rpn\n" +
-                        "voueTvT0zW1NBEnR/pLg7NvdrYRXJ0hHQG6BuSuqb8Ml7m2/ZTrBBittC5o7lM4doYyOHmeApiXr\n" +
-                        "wPIOxO3XOkMNSQhhPkeg2nYTAH4LMXxfAvDVEMIrVgbqYiK5HcAO9Nt19v4UgJ9BXE0A0HHPee73\n" +
-                        "cohBv0zfL9A8+z4EYIV+N2N8NYDvhhDuiWjaDODRBE0eugDGQwh/NZ7rhDbsfmeHBHvNlHsT+ZZu\n" +
-                        "KgyPcwVbjSY2H7qmfVtMFiWheWP3EHV19ILICTDRhgluIkFMidg2z2yD7yacvomfohjmzUnR1uM6\n" +
-                        "ywrPMbs5amAPyatKQmS/Meo1MrapmgijCbTxpOxOCU7TZyL6YhwkuT8ptKihUVZmh2dkgbrq5ASY\n" +
-                        "EFzKGK0zC84kzFJMoR1M+x6N550F2ozuI76N5BkGgJ8AeD96HQT2+3skvwTgyyGE3xtyP4FSJtR5\n" +
-                        "kpsA/FKzuy4dgpyavQ6Z3G0xmgewAPGWXATgxgx9NrH/BcB9mjcL8a7MaTsnNe/fEGfCbKYtg79r\n" +
-                        "mpKJaepqiLfmLfqh63pgW6EH4vw74vpRW5sy9XazZldBMcpz0GP5NwHm52qjdWvUdg7Wx/wuNsTK\n" +
-                        "2LWGSnMAqfNIQoA2bDe6sj0GsyO8x/jVPG875vA/o2WHmTGY+5jMCJVVR9dt1czT3OlRUR16N2iB\n" +
-                        "2wFcr59i/5elcwBuIXlBCOGLfujqsO2EEJ4ieSuAy0II93ihWfloyNvPNkeBXcVXOskbiLLj48Z3\n" +
-                        "G+K60OoXS1FOseo0MXbHJ3ch9lu1JLXdssd2IY0173SAlfZPFPB5nNutXu7Q2w6C9wHYRxlqPwBw\n" +
-                        "rRbxlri5r7eTfDqEsI9uRxJpY88Bdgbs+4kWArAtl99xnKe/V0B2Hucrrcsh2vOC7oDscP5UQ3Qr\n" +
-                        "NB1ICs8Yd0J8FsCzFFfUDyErsRfggv7+NoB9cCpN2af6VXOZlvXbrkFUZydG3JoCA4b30yQPQ7Zf\n" +
-                        "1tYyl5bmu9sBvKJl5lGt+DkwHs/3jGTBCXEwhNANIfyY5BMA9kDmQxOgtfNR0zqnfdcD2FlD2FJh\n" +
-                        "JYCrG5Tz2r4A0cBXEt9aQVF4Bi5upaMhYTeQPATgIxFyGxa+F/0JWSN8Dpq4f9owb4I7DnFeAHUT\n" +
-                        "fz8smjzxClQE1SgbXk86ggxOon/ueF/0vpB5lgqDLR4z+L/lgooMmh65LipGW00Aqp42n5tv462E\n" +
-                        "yfBBTY3wM3k20YUIft6l86h2Gafc+38gQZUPhxD+wGoXZPScV4PL+JyNMxqBQzgKOQMFRBhzmh50\n" +
-                        "xW04/BHAYwD+pe9zmhqjs/rYexey0l4BYNG9FYHNtc8BuBUyVZzS/HkA/y1tx2wO11dbbW0hKPn0\n" +
-                        "gEp47YY7K2t8R2TjmQ2UjJpaClDOWOtsrkdbtJfccTg7b3PUdg7nNqvXWPPcKroOwHbNNhtvELLR\n" +
-                        "fxGoVmmrh/6eLE3yg6o1FxbK9NEG1YQaD+9AziOOynNdB2Z/pu28FDikP9U0Vu/9qWhRrVd04Ud5\n" +
-                        "bYaDLTTFyE5nNqXK2LC1mGmz53Jw3HA2Ep7TursBXIN0LMvjUR0729gMYBxiV01BYmHeDiFMn83g\n" +
-                        "arozCrcwfB/A0RDCQ4mOqzt0MoH+sy0Rub3fYoAiE8HYWi+O7jTn5EGK93ZVhCd1IpfDu8vXsd/R\n" +
-                        "+zDJ2yiOTJK8L66j76Xw32TsSlHznPYMA/i5Zqe2ZXv9kHXpaogDEai0dUjzVkN6exZIzlVmOpRW\n" +
-                        "Pxu2A1RvjDPoRwF8BcDXAVzu6iy3OqiCuoejMjk4DrUaQgjdumFrCB7SxuPhavV/kam3BtU+2Nez\n" +
-                        "dl5MzJOLTDWFaIEaB/A1ALegmsfMHhyCW4gc3sshHmKgPN8d8yZQVnis5rmtSkgsANOIl0MIzysT\n" +
-                        "xrRN+h8oEAJIiD+QFljJaDWNP6m0jgL4LIAtAG525WxL6AViYRx+YRpHFZtXEt6riq8TQpgv3cOY\n" +
-                        "p8Te5Tb1xsAjvsGoTN3yf7LwrWQrGt1rdA67Fb03jKwjUgGaKwBYEGZHy36ihk7j1W8C+jUvmuds\n" +
-                        "/5rqkSFIzz6i7ykTY0Uiz+P9sNVl5e01F1EJjBYfohZrbk6DVrrfRvN1NfisEyzk4j2g7Bh4DNU8\n" +
-                        "lzNyn6y5K5YTgrV3M8kt6u7qqllhc0qTsN6u0me4TUMGIW71uUSdEdU4uEXtmoiuGAcgm4DXrB4Q\n" +
-                        "aZ6b5+6C9GpdbPIuTXOT/FShrsHDJL8J4M+Q/ekIZK40P11pDhqMfpvQ7gfwa8gty5j+dyJ/440Q\n" +
-                        "bayb71KLmwD7T7vq9niHclhY2Wrrojql9tpAKqpgknKnY1Rx+/skPtziNvuu6XM1dJTjVFgxO87m\n" +
-                        "sbp2V6Hu9uOBqF6OwFTMSa6chwOUYMg4KMnHABqYUW2KUjob9nCCVackD7tHWFnhddpQGyXuCNzg\n" +
-                        "6rUNs8gJ8gQlxm8ixsne3cVBLf88VXMi2iwyvk5RdpZ4BZtdH7Bvuz0RBa3LBYfnIptKt31mKUNs\n" +
-                        "K6OQ2xxTlHjnq6I8G67WqU2mjXxILctBLjHTpNzBzfdEgjHK/PdctuU0riOUMLetjKJF2fKKp5Y3\n" +
-                        "wa1i/f26WOv6FCVQjMw7kLbGPdhq9FII4WNNiTbE7iRuHMCnIObBpahswWnIvtH+g+BVAG9GW69F\n" +
-                        "2uLAIoduAJX9tmg3uj3vGMQDfTXyK6zlvwvgyhDCO8yssltYTerWEyXPgnlSW3mL2SLYOlVvKXWj\n" +
-                        "dkZIbmd1UbC0usZxKUncwTUex6cA/T1zHNITje5+ZZiwnUTO6Vn7RxCsdkFjkDPktyDaehRiW9q2\n" +
-                        "byXEOXEtgM+h11FQMogHAXyn7uJeyq+1gVWUZDz+k/Eo5xqYXsmbQGlUtb4y2kMQe5f59axC7A0W\n" +
-                        "L+mdBZk0BlaL0Hala4a9K3XuSQnSC22KEpC5NB4TQhynxCM3v8B2lsEJ74EGWtYkZnmGciLYbwgX\n" +
-                        "IHsPg+4MQN+zdzH+X0Bx/a8F8EkAH4f45S5Dr+ckB8cAvAzgNwCeCCFMaZv1dywUGv+jz9k8rDlT\n" +
-                        "oLReAjGBxiAH5xdDXO8LEFPodVRm0HRUtxWf/wMVHEsUTW3uUgAAAABJRU5ErkJggg==").bitmap,
-                contributorName = "fankes"
-            ),
-            IconDataBean(
-                isEnabled = true,
-                isEnabledAll = false,
-                appName = "小米穿戴",
-                packageName = "com.xiaomi.wearable",
-                iconBitmap = ("iVBORw0KGgoAAAANSUhEUgAAAC4AAAAuCAYAAABXuSs3AAAAAXNSR0IArs4c6QAAAARzQklUCAgI\n" +
-                        "CHwIZIgAAAI4SURBVGiB7Zq9ahtBFEa/WVKmNshBpZ/AgUDAMcTunSpu3Cov4E5voFcQ+AECLpw+\n" +
-                        "NiKG4EBcGgKp4zIuJFBlnRQ7Eip2du7+WOuBHFgQo733nh1mZ3ZHkjyAAwbADTDl+TAldxoATusA\n" +
-                        "PeCyUz0bl0BPkhz5VXyV9F5pcCXp0AEDSeOubSryyQE3kt50bVKRHw6YSnrZtUlFZg6ga4s6ZF0L\n" +
-                        "1OVFS3kWkr5LupB0K+neH5K07Y9dSR8kvVUbHdZwXp0DI2CrQr0tHzNvUriJ+DnQb9BhfZ9jY+IL\n" +
-                        "YFhXuOAChj7nk4ovgOO2pNfkj6vKVxVvracL5IdPJX5uKH4AjIFf5E91U/95DBwY4s1j3io+p+RG\n" +
-                        "BHaAiSHPBNgpydPHONtYxUclxfaAv8Y8+HP3SvKN2hJ/JDBPk/d0Fel1+cKeJ5/nH9sQvy7pHcvw\n" +
-                        "CDEpyXsdC7YsvReB5IeS9g3xIfYJ37BfYsEW8dtA+0dDbIzQmvAzFmgRvw+0vzPExgjlCNVc0UT8\n" +
-                        "lSE2RihHK+IufkrrRGtaxHuB9j/VXCrlCNVcYRHfDrR/M8TGCOUI1VxhEd8NtH82xMYI5XgdjUx1\n" +
-                        "AUp2ybcMlUzSadEXzrnfko4kPRjyLHmQdORjiziVZQgbeyjZx1pI9EViSZKvbpDwy/JSPrntiXWS\n" +
-                        "2xBap7MtuLa2mTe+6fl/f3zTZJJmXUvUYJZJuuvaogZ3maSzri1qcJbsD7SZcw5JJ77huXMl6cQ7\n" +
-                        "55DYnxD+AevUWpo12Yg8AAAAAElFTkSuQmCC").bitmap,
-                contributorName = "fankes"
-            ),
-            IconDataBean(
-                isEnabled = true,
-                isEnabledAll = false,
-                appName = "微博",
-                packageName = "com.sina.weibo",
-                iconBitmap = ("iVBORw0KGgoAAAANSUhEUgAAADgAAAAyCAYAAAAJHRh4AAAAAXNSR0IArs4c6QAAAARzQklUCAgI\n" +
-                        "CHwIZIgAAARUSURBVGiB7VrtcRMxEH3K8IdfBBrgmIGfzFwHmApwB7gD3EHcAe4gTgUJFdipIE4F\n" +
-                        "MRXkqODxY3WxLGulvQ8wMLwZz/jGJ2mfdm/3ac8OfxBIngP4DKAGUAHYBD9vnHO3JzFsDJA8J3nH\n" +
-                        "Mu5IfvGb8feA5MxALsYlyerUtptActqDIEk+kvxyavtNILnoSZKU0D0KW3cKIiX4sGtDb+I/HwxD\n" +
-                        "twA+OueaX2XbLwMlCc1J7gqeXJ/a1sEwhPKsvXfUECVZQ0KpgtSyHaSWfbOGjQ/PC3+5g4RdE9dA\n" +
-                        "v9YGwIvENA2AN6OEqg+dzyQfxggbkjfKHA8kJ9G9Ncmm5MUh5C4oadqC+UCCLa4ZZEuSE+W+uyHE\n" +
-                        "Jsx7LIVNeeaniFh4olpCWURjlsp9r/qQu+hIrBNBhXDKq1VwT6Ws+bbrQhatqGHVh2Cw/jyabx39\n" +
-                        "vkkRfGacvAawBjBE4CY96D3x2l9WkMx5H2dA59yS5BT7gn+QcCCZM8a7olWU582aSHKYBHNWlFDP\n" +
-                        "PceXjKQXJWuGCMM0VRvfl8j1Ufg5g7+yW5gfZcLo93DT4mzakHz+u8gNwTSyaxv8Nk/YvKM8jzUA\n" +
-                        "nCnkJgAus+79faij60b5DufcyjlXOecmzrktkCDomV+PbmZ/3ETXYTYulp6DLEp5qIdmyzFx33qi\n" +
-                        "hXNuRRIQfborTRCXiWv8OeSAY+8BEJLWCZ4IUuRPXFss+A5R/FtIyOxSO+ujow4+U6RPAiHG2Wzq\n" +
-                        "UkdDQ9F/cQLouu6UaQUS4prRKaILnF9oBelHlvADwBLAMnXW4v48GO58sZ/p0/0CeY9u/bpXBjsP\n" +
-                        "Jrd6b8NEi46iUUuq5NHfo4Yc82e7EMnmUo6gdtQIkXyo2V3GPTIT1jyWYirJLgRL0kkj11fplEha\n" +
-                        "W4e2E3thkq0ypm+TtoXawqCEvCVUbefLwiTJnWb303wKasudtseGFn5JLerxLVYRfvEZ9k3ZIcil\n" +
-                        "/mTk9EGOoKYWptH1FaRF5wC89NcW5DapKMEgJauIHEEtxsMUfeucm7XKxdfGOUTdDIGlDJi8fAbF\n" +
-                        "GGPTdKmMsySAnJcsCimpU2OcacZQL6bqeSyAxQM5Az8NHP8ElSD0JBDef0TEb0zpTdCVFiE+c5c8\n" +
-                        "eGU5KoWTphqsWoGvuK9TB7KJUsPWhezeZKIDxvHdsjj1wp2cKLr/0Ru1pk22xVk4nNeijvq9c2C6\n" +
-                        "e5xTHDPaFEeLJmccbTp0oY23EDznYceqhdp8ooRr6WUJqZxEgnkson1QZzwkmXoej5qw0bia0lq/\n" +
-                        "8WQ2/vs8R8yPtbzrGP4qLCKZ8uQDM89Pj3VK7xTpN7v3ab5kgCZ4Hygd6s56lOQHP9aSjFYc4c8+\n" +
-                        "2VfYlJq0hF7XGuybTcBhjayij9UTtwBmnercUFCSgCWZ9EXjPTb6v5Y6/QnBGzCFeMMip3K4h3h8\n" +
-                        "45wzya4+GPQvC0oCqCGSLReCbSjvIH3TXm97/+M//kH8BEhmToz+KexyAAAAAElFTkSuQmCC").bitmap,
-                contributorName = "fankes"
-            ),
-            IconDataBean(
-                isEnabled = true,
-                isEnabledAll = false,
-                appName = "抖音",
-                packageName = "com.ss.android.ugc.aweme",
-                iconBitmap = ("iVBORw0KGgoAAAANSUhEUgAAADIAAAAyCAYAAAAeP4ixAAAAAXNSR0IArs4c6QAAAARzQklUCAgI\n" +
-                        "CHwIZIgAAALtSURBVGiB7Znfa41xHMdfHynkxwVN0UhYbGkNhRpFcaFYbtzaDSK2/AGKC5e4oEZZ\n" +
-                        "SSkuXLASU2q1C7VWcrNxoQwrbNiYm928XZyz9Th7znm+3+fHOc/K6/Kc7+fzfb/O0/f7PN/zQJVQ\n" +
-                        "NNeT9F+QVtAUqE9SnCeRuiTFllaKKCTJYVi9mY3G6Z+nKwJwrNYBInFY7JI0WOuckTiKSNLpOP3z\n" +
-                        "tkYAfgMNZvbVp3/e1gjAcuCFb1EeRQCaJY1Iaqt1kDl4rJFSbktaH9U/j2skjB/AM6AbGAXGzGwi\n" +
-                        "OGC+iJTSZ2YHgh/kdY14818kb+RJ5H2S4jyJ3Ae64hYvTDKzpN1AG4WzRB2wGBgBxs3som8/Mzsn\n" +
-                        "qQc4g+eTsLeIpJVAB3AU2FlmWJ9v3xnMrBfolbQPaAcOA2uj6rxEJHUAncDmOCF9MLN+oL847y6g\n" +
-                        "FdgIrAFWlY53Eik+ItwD9qeW1AMzGwAGKo2JFJG0l+Ivk2cq7lqSljAPJCB6+71RlRQpUFZE0lng\n" +
-                        "ZBWzJCJURNIKClvsvKHcYu8AGh17vAEeUzgvDFG4t5S7v1QXSUOOp7dbxavn0jOKy0kyz7kikrbg\n" +
-                        "djVOmVl3ksnTJGyNtDrUvcyTBISLbHWoy922HCYS9a/4L+B5BlkSESayOqLmlZlNZxEmCXEOVsO+\n" +
-                        "BZKWOQwbj5FlljCR7xE1cZ6Amx3GvIvRd5YwkahfpqW4RfvgIvLWs+c/hIl8cKg74TlPe8T3P83s\n" +
-                        "k2fPykhqcbgLT0na5tjvjkO/h6lKBCb/6DD5U0kVj7ySjjj0kaTOrES6HANMSeqQtKmkfrukq449\n" +
-                        "piXtyEqkUdKkY5AZPksalPTHs+5aJhIBmSuegeLwRdKGrEUWSXqdsciFTCUCMg0ZSjyqikRAZk8G\n" +
-                        "Eg+qKhGQaZI0nJLEpZpIlMjcTSAwIul8TSWCSDooqcdDYELSTUnrsswV+2WopCbgOHCIwhmmDlgK\n" +
-                        "fAPGKLy4eQL0mNlk8qiV+Qt8xU94PoUr+AAAAABJRU5ErkJggg==").bitmap,
-                contributorName = "fankes"
-            ),
-            IconDataBean(
-                isEnabled = true,
-                isEnabledAll = false,
-                appName = "哔哩哔哩",
-                packageName = "tv.danmaku.bili",
-                iconBitmap = ("iVBORw0KGgoAAAANSUhEUgAAADIAAAAyCAYAAAAeP4ixAAAAAXNSR0IArs4c6QAAAARzQklUCAgI\n" +
-                        "CHwIZIgAAALMSURBVGiB7Zm9axRBGMafV4KIUZCgBFTEkKgg+FUFtMk/YNDCRhEVg5ViIdgoJBZq\n" +
-                        "kc5SBAuNgqXa+FFYiEUawRQSOY0SQhBF8IO0P4vbwN3ezN7czu4lxf7gipt9n3eed3dndmdWqqio\n" +
-                        "qHABjAMLwCxwu8C8t4EaMAeMF5XX19kErUwBvRE5e5McaSaK9J7udM7RIcBrYCBHvoFE62KhjBqW\n" +
-                        "O571dAowAwx3kGs40fh4VWYhkxkdA3wHRgPyjCaxWZwrrZDExJU2BgDGMvRjAfrrnfqyQPO7JW1t\n" +
-                        "aNoi6Ukb2TVJ71JthyXdbKObknSv4f+8mX0O8ekFuAXMB5zBspkD7mR59V4RoCZpMOpMFE/NzHa5\n" +
-                        "DqxxNQLvtfqKkKQh4K3rQEshwCVJB0u3lJ8jQMs4c12RU10wE8vJdEPTGAE2SPrrEf+TdEHSYvG+\n" +
-                        "WuiTtE9S1mvKDjObdx4BBn3TRhluQ8iYyUYa49K3Vr8n341ybAYR9PKYLmStJ246zksUn0KCnNOv\n" +
-                        "g6UII7EEjcnQQloANlFfDC0m9+zTDvUjwP2Ge7649UeSvO3ASmKPOeKCzeBepJ3I6yn3FZF02dF2\n" +
-                        "vgO9azl7OqeXqEJcbI/Ub8wrLLqQFaMqRFLN0fY1Ip8k/cgrjCnEtcvxpgN9evUoSV9yemmmk+k3\n" +
-                        "iX/cEPMC2NlBX3uB6UT7B5gswlNuEbAN2BNagEO/H1gX66knr4FlzCxqI83MPsR6kKpZa/URWshK\n" +
-                        "ruGHQoJCCzkTYSQW32vPL68COOCZIaC+ax50dooA6KP+LcZH02o2vfmwWdlP1yVJs5J+F2+9Bf9z\n" +
-                        "QpKZNXnvSR38CTyTdNSjXy/pUJS9YniQbnCNkbtdMBLLw3RDSyFm9lzSxa7YycdVM3sZHE19KVrL\n" +
-                        "GGzd5htw1ue37fcR4Ljq3zX6k59vy6gsPkqakfTIzLoxyVRUVFR0gf/L83vOF7040QAAAABJRU5E\n" +
-                        "rkJggg==").bitmap,
-                contributorName = "fankes"
-            ),
-            // TODO 可继续在这里添加更多 APP
-        )
+                appName = it.getString("appName"),
+                packageName = it.getString("packageName"),
+                isEnabled = it.getBoolean("isEnabled"),
+                isEnabledAll = it.getBoolean("isEnabledAll"),
+                iconBitmap = it.getString("iconBitmap").bitmap,
+                iconColor = safeOfNan { Color.parseColor(it.getString("iconColor")) },
+                contributorName = it.getString("contributorName")
+            )
+        }
     }
+
+    /**
+     * 拼接图标数组数据
+     * @param dataJson1 图标数据 JSON
+     * @param dataJson2 图标数据 JSON
+     * @return [String] 拼接后的数据
+     */
+    fun splicingJsonArray(dataJson1: String, dataJson2: String) = safeOf(default = "[]") {
+        dataJson1.replace("]", "") + "," + dataJson2.replace("[", "")
+    }
+
+    /**
+     * 是否不为合法 JSON
+     * @param json 数据
+     * @return [Boolean]
+     */
+    fun isNotVaildJson(json: String) = !isJsonArray(json) && !isJsonObject(json)
+
+    /**
+     * 是否为 JSON 数组
+     * @param json 数据
+     * @return [Boolean]
+     */
+    fun isJsonArray(json: String) = json.trim().let { it.startsWith("[") && it.endsWith("]") }
+
+    /**
+     * 是否为 JSON 实例
+     * @param json 数据
+     * @return [Boolean]
+     */
+    fun isJsonObject(json: String) = json.trim().let { it.startsWith("{") && it.endsWith("}") }
+
+    /**
+     * 是否为异常地址
+     * @param json 数据
+     * @return [Boolean]
+     */
+    fun isHackString(json: String) = json.contains("Checking your browser before accessing")
+
+    /**
+     * 比较图标数据不相等
+     * @param dataJson 图标数据 JSON
+     * @return [Boolean] 是否不相等
+     */
+    fun isCompareDifferent(dataJson: String) = storageDataJson?.trim() != dataJson.trim()
+
+    /**
+     * 保存图标数据
+     * @param dataJson 图标数据 JSON
+     */
+    fun save(dataJson: String) = context?.prefs()?.edit { put(ConfigData.NOTIFY_ICONS_DATA, dataJson) }
 }

app/src/main/java/com/fankes/miui/notify/params/factory/DataFactory.kt

@@ -0,0 +1,67 @@
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2017-2023 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
+ *
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
+ *
+ * This file is created by fankes on 2022/2/15.
+ * This file is Modified by fankes on 2023/2/3.
+ */
+package com.fankes.miui.notify.params.factory
+
+import android.content.Context
+import com.fankes.miui.notify.bean.IconDataBean
+import com.highcapable.yukihookapi.hook.factory.prefs
+import com.highcapable.yukihookapi.hook.param.PackageParam
+
+/**
+ * 获取此 APP 的通知图标是否被 Hook
+ * @param bean 图标 bean
+ */
+fun PackageParam.isAppNotifyHookOf(bean: IconDataBean) = prefs.getBoolean(bean.toEnabledName(), bean.isEnabled)
+
+/**
+ * 获取此 APP 的通知图标是否被 Hook
+ * @param bean 图标 bean
+ */
+fun Context.isAppNotifyHookOf(bean: IconDataBean) = prefs().getBoolean(bean.toEnabledName(), bean.isEnabled)
+
+/**
+ * 设置 Hook 此 APP 的通知图标
+ * @param bean 图标 bean
+ * @param isHook 是否 Hook
+ */
+fun Context.putAppNotifyHookOf(bean: IconDataBean, isHook: Boolean) = prefs().edit { putBoolean(bean.toEnabledName(), isHook) }
+
+/**
+ * 获取此 APP 的通知图标是否被全部 Hook
+ * @param bean 图标 bean
+ */
+fun PackageParam.isAppNotifyHookAllOf(bean: IconDataBean) = prefs.getBoolean(bean.toEnabledAllName(), bean.isEnabledAll)
+
+/**
+ * 获取此 APP 的通知图标是否被全部 Hook
+ * @param bean 图标 bean
+ */
+fun Context.isAppNotifyHookAllOf(bean: IconDataBean) = prefs().getBoolean(bean.toEnabledAllName(), bean.isEnabledAll)
+
+/**
+ * 设置全部 Hook 此 APP 的通知图标
+ * @param bean 图标 bean
+ * @param isHook 是否 Hook
+ */
+fun Context.putAppNotifyHookAllOf(bean: IconDataBean, isHook: Boolean) = prefs().edit { putBoolean(bean.toEnabledAllName(), isHook) }

app/src/main/java/com/fankes/miui/notify/service/QuickStartTileService.kt

@@ -0,0 +1,36 @@
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2017-2023 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
+ *
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
+ *
+ * This file is created by fankes on 2022/3/26.
+ */
+package com.fankes.miui.notify.service
+
+import android.service.quicksettings.TileService
+import com.fankes.miui.notify.ui.activity.ConfigureActivity
+import com.fankes.miui.notify.utils.factory.navigate
+
+class QuickStartTileService : TileService() {
+
+    override fun onClick() {
+        super.onClick()
+        /** 启动通知图标优化列表窗口 */
+        navigate<ConfigureActivity>()
+    }
+}

app/src/main/java/com/fankes/miui/notify/ui/ConfigureActivity.kt

@@ -1,123 +0,0 @@
-/**
- * Copyright (C) 2022. Fankes Studio(qzmmcn@163.com)
- *
- * This file is part of MIUINativeNotifyIcon.
- *
- * MIUINativeNotifyIcon is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * MIUINativeNotifyIcon is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * This file is Created by fankes on 2022/01/30.
- */
-@file:Suppress("SetTextI18n", "InflateParams")
-
-package com.fankes.miui.notify.ui
-
-import android.content.Intent
-import android.net.Uri
-import android.os.Bundle
-import android.view.LayoutInflater
-import android.view.View
-import android.view.ViewGroup
-import android.widget.BaseAdapter
-import android.widget.ListView
-import android.widget.TextView
-import android.widget.Toast
-import androidx.constraintlayout.utils.widget.ImageFilterView
-import com.fankes.miui.notify.R
-import com.fankes.miui.notify.hook.HookMedium
-import com.fankes.miui.notify.params.IconPackParams
-import com.fankes.miui.notify.ui.base.BaseActivity
-import com.fankes.miui.notify.view.MaterialSwitch
-
-class ConfigureActivity : BaseActivity() {
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        setContentView(R.layout.activity_config)
-        /** 返回按钮点击事件 */
-        findViewById<View>(R.id.title_back_icon).setOnClickListener { onBackPressed() }
-        /** 设置列表元素和 Adapter */
-        findViewById<ListView>(R.id.config_list_view).apply {
-            adapter = object : BaseAdapter() {
-
-                private val inflater = LayoutInflater.from(context)
-
-                override fun getCount() = IconPackParams.iconDatas.size
-
-                override fun getItem(position: Int) = IconPackParams.iconDatas[position]
-
-                override fun getItemId(position: Int) = position.toLong()
-
-                override fun getView(position: Int, convertView: View?, parent: ViewGroup?): View {
-                    var cView = convertView
-                    val holder: ViewHolder
-                    if (convertView == null) {
-                        holder = ViewHolder()
-                        cView = inflater.inflate(R.layout.adapter_config, null).also {
-                            holder.appIcon = it.findViewById(R.id.adp_app_icon)
-                            holder.appName = it.findViewById(R.id.adp_app_name)
-                            holder.pkgName = it.findViewById(R.id.adp_app_pkg_name)
-                            holder.cbrName = it.findViewById(R.id.adp_cbr_name)
-                            holder.switchOpen = it.findViewById(R.id.adp_app_open_switch)
-                            holder.switchAll = it.findViewById(R.id.adp_app_all_switch)
-                        }
-                        cView.tag = holder
-                    } else holder = convertView.tag as ViewHolder
-                    getItem(position).also {
-                        holder.appIcon.setImageBitmap(it.iconBitmap)
-                        holder.appName.text = it.appName
-                        holder.pkgName.text = it.packageName
-                        holder.cbrName.text = "贡献者：" + it.contributorName
-                        HookMedium.isAppNotifyHookOf(it).also { e ->
-                            holder.switchOpen.isChecked = e
-                            holder.switchAll.isEnabled = e
-                        }
-                        holder.switchOpen.setOnCheckedChangeListener { btn, b ->
-                            if (!btn.isPressed) return@setOnCheckedChangeListener
-                            HookMedium.putAppNotifyHookOf(it, b)
-                            holder.switchAll.isEnabled = b
-                        }
-                        holder.switchAll.isChecked = HookMedium.isAppNotifyHookAllOf(it)
-                        holder.switchAll.setOnCheckedChangeListener { btn, b ->
-                            if (!btn.isPressed) return@setOnCheckedChangeListener
-                            HookMedium.putAppNotifyHookAllOf(it, b)
-                        }
-                    }
-                    return cView!!
-                }
-
-                inner class ViewHolder {
-                    lateinit var appIcon: ImageFilterView
-                    lateinit var appName: TextView
-                    lateinit var pkgName: TextView
-                    lateinit var cbrName: TextView
-                    lateinit var switchOpen: MaterialSwitch
-                    lateinit var switchAll: MaterialSwitch
-                }
-            }
-        }
-        /** 设置点击事件 */
-        findViewById<View>(R.id.config_cbr_button).setOnClickListener {
-            try {
-                startActivity(Intent().apply {
-                    action = "android.intent.action.VIEW"
-                    data = Uri.parse("https://github.com/fankes/MIUINativeNotifyIcon")
-                    /** 防止顶栈一样重叠在自己的 APP 中 */
-                    flags = Intent.FLAG_ACTIVITY_NEW_TASK
-                })
-            } catch (e: Exception) {
-                Toast.makeText(this, "无法启动系统默认浏览器", Toast.LENGTH_SHORT).show()
-            }
-        }
-    }
-}

app/src/main/java/com/fankes/miui/notify/ui/MainActivity.kt

@@ -1,198 +0,0 @@
-/**
- * Copyright (C) 2022. Fankes Studio(qzmmcn@163.com)
- *
- * This file is part of MIUINativeNotifyIcon.
- *
- * MIUINativeNotifyIcon is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * MIUINativeNotifyIcon is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * This file is Created by fankes on 2022/01/24.
- */
-@file:Suppress("SetTextI18n")
-
-package com.fankes.miui.notify.ui
-
-import android.content.ComponentName
-import android.content.Intent
-import android.content.pm.PackageManager
-import android.net.Uri
-import android.os.Bundle
-import android.view.View
-import android.widget.LinearLayout
-import android.widget.TextView
-import android.widget.Toast
-import androidx.appcompat.widget.SwitchCompat
-import androidx.constraintlayout.utils.widget.ImageFilterView
-import androidx.core.view.isVisible
-import com.fankes.miui.notify.BuildConfig
-import com.fankes.miui.notify.R
-import com.fankes.miui.notify.hook.HookMedium
-import com.fankes.miui.notify.ui.base.BaseActivity
-import com.fankes.miui.notify.utils.*
-
-class MainActivity : BaseActivity() {
-
-    companion object {
-
-        /** 模块版本 */
-        private const val moduleVersion = BuildConfig.VERSION_NAME
-    }
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        setContentView(R.layout.activity_main)
-        /** 设置文本 */
-        findViewById<TextView>(R.id.main_text_version).text = "当前版本：$moduleVersion"
-        findViewById<TextView>(R.id.main_text_miui_version).text = "MIUI 版本：$miuiVersion"
-        when {
-            /** 判断是否为 MIUI 系统 */
-            isNotMIUI ->
-                showDialog {
-                    title = "不是 MIUI 系统"
-                    msg = "此模块专为 MIUI 系统打造，当前无法识别你的系统为 MIUI，所以模块无法工作。\n" +
-                            "如有问题请联系 酷安 @星夜不荟"
-                    confirmButton(text = "退出") { finish() }
-                    noCancelable()
-                }
-            /** 判断最低系统版本 */
-            isLowerAndroidP ->
-                showDialog {
-                    title = "系统版本过低"
-                    msg = "此模块最低支持基于 Android 9 的 MIUI 系统，你的系统版本过低不再进行适配。\n" +
-                            "如有问题请联系 酷安 @星夜不荟"
-                    confirmButton(text = "退出") { finish() }
-                    noCancelable()
-                }
-            /** 判断是否 Hook */
-            isHooked() -> {
-                findViewById<LinearLayout>(R.id.main_lin_status).setBackgroundResource(R.drawable.green_round)
-                findViewById<ImageFilterView>(R.id.main_img_status).setImageResource(R.mipmap.succcess)
-                findViewById<TextView>(R.id.main_text_status).text = "模块已激活"
-            }
-            else ->
-                showDialog {
-                    title = "模块没有激活"
-                    msg = "检测到模块没有激活，模块需要 Xposed 环境依赖，" +
-                            "同时需要系统拥有 Root 权限，" +
-                            "请自行查看本页面使用帮助与说明第二条。\n" +
-                            "由于需要修改系统应用达到效果，模块不支持太极阴、应用转生。"
-                    confirmButton(text = "我知道了")
-                    noCancelable()
-                }
-        }
-        /** 初始化 View */
-        val notifyIconConfigItem = findViewById<View>(R.id.config_item_notify)
-        val moduleEnableSwitch = findViewById<SwitchCompat>(R.id.module_enable_switch)
-        val hideIconInLauncherSwitch = findViewById<SwitchCompat>(R.id.hide_icon_in_launcher_switch)
-        val colorIconHookSwitch = findViewById<SwitchCompat>(R.id.color_icon_fix_switch)
-        val notifyIconHookSwitch = findViewById<SwitchCompat>(R.id.notify_icon_fix_switch)
-        /** 获取 Sp 存储的信息 */
-        notifyIconConfigItem.isVisible = getBoolean(HookMedium.ENABLE_COLOR_ICON_HOOK, default = true)
-        moduleEnableSwitch.isChecked = getBoolean(HookMedium.ENABLE_MODULE, default = true)
-        hideIconInLauncherSwitch.isChecked = getBoolean(HookMedium.ENABLE_HIDE_ICON)
-        colorIconHookSwitch.isChecked = getBoolean(HookMedium.ENABLE_COLOR_ICON_HOOK, default = true)
-        notifyIconHookSwitch.isChecked = getBoolean(HookMedium.ENABLE_NOTIFY_ICON_HOOK, default = true)
-        moduleEnableSwitch.setOnCheckedChangeListener { btn, b ->
-            if (!btn.isPressed) return@setOnCheckedChangeListener
-            putBoolean(HookMedium.ENABLE_MODULE, b)
-        }
-        hideIconInLauncherSwitch.setOnCheckedChangeListener { btn, b ->
-            if (!btn.isPressed) return@setOnCheckedChangeListener
-            putBoolean(HookMedium.ENABLE_HIDE_ICON, b)
-            packageManager.setComponentEnabledSetting(
-                ComponentName(this@MainActivity, "com.fankes.miui.notify.Home"),
-                if (b) PackageManager.COMPONENT_ENABLED_STATE_DISABLED else PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
-                PackageManager.DONT_KILL_APP
-            )
-        }
-        colorIconHookSwitch.setOnCheckedChangeListener { btn, b ->
-            if (!btn.isPressed) return@setOnCheckedChangeListener
-            putBoolean(HookMedium.ENABLE_COLOR_ICON_HOOK, b)
-            notifyIconConfigItem.isVisible = b
-        }
-        notifyIconHookSwitch.setOnCheckedChangeListener { btn, b ->
-            if (!btn.isPressed) return@setOnCheckedChangeListener
-            putBoolean(HookMedium.ENABLE_NOTIFY_ICON_HOOK, b)
-        }
-        /** 重启按钮点击事件 */
-        findViewById<View>(R.id.title_restart_icon).setOnClickListener {
-            showDialog {
-                title = "重启系统界面"
-                msg = "你确定要立即重启系统界面吗？\n\n" +
-                        "部分 MIUI 系统使用了状态栏主题可能会发生主题失效的情况，这种情况请再重启一次即可。"
-                confirmButton { restartSystemUI() }
-                cancelButton()
-            }
-        }
-        /** 通知图标优化名单按钮点击事件 */
-        findViewById<View>(R.id.config_notify_app_button).setOnClickListener {
-            startActivity(Intent(this, ConfigureActivity::class.java))
-        }
-        /** 恰饭！ */
-        findViewById<View>(R.id.link_with_follow_me).setOnClickListener {
-            try {
-                startActivity(Intent().apply {
-                    setPackage("com.coolapk.market")
-                    action = "android.intent.action.VIEW"
-                    data = Uri.parse("https://www.coolapk.com/u/876977")
-                    /** 防止顶栈一样重叠在自己的 APP 中 */
-                    flags = Intent.FLAG_ACTIVITY_NEW_TASK
-                })
-            } catch (e: Exception) {
-                Toast.makeText(this, "你可能没有安装酷安", Toast.LENGTH_SHORT).show()
-            }
-        }
-        /** 项目地址点击事件 */
-        findViewById<View>(R.id.link_with_project_address).setOnClickListener {
-            try {
-                startActivity(Intent().apply {
-                    action = "android.intent.action.VIEW"
-                    data = Uri.parse("https://github.com/fankes/MIUINativeNotifyIcon")
-                    /** 防止顶栈一样重叠在自己的 APP 中 */
-                    flags = Intent.FLAG_ACTIVITY_NEW_TASK
-                })
-            } catch (e: Exception) {
-                Toast.makeText(this, "无法启动系统默认浏览器", Toast.LENGTH_SHORT).show()
-            }
-        }
-    }
-
-    /**
-     * 判断模块是否激活
-     * @return [Boolean] 激活状态
-     */
-    private fun isHooked() = HookMedium.isHooked()
-
-    /** 重启系统界面 */
-    private fun restartSystemUI() =
-        execShellCmd(cmd = "pgrep systemui").also { pid ->
-            if (pid.isNotBlank())
-                execShellCmd(cmd = "kill -9 $pid")
-            else Toast.makeText(this, "ROOT 权限获取失败", Toast.LENGTH_SHORT).show()
-        }
-
-    /**
-     * 获取保存的值
-     * @param key 名称
-     * @param default 默认值
-     * @return [Boolean] 保存的值
-     */
-    private fun getBoolean(key: String, default: Boolean = false) = HookMedium.getBoolean(key, default)
-
-    /**
-     * 保存值
-     * @param key 名称
-     * @param bool 值
-     */
-    private fun putBoolean(key: String, bool: Boolean) = HookMedium.putBoolean(key, bool)
-}

app/src/main/java/com/fankes/miui/notify/ui/activity/ConfigureActivity.kt

@@ -0,0 +1,278 @@
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2017-2023 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
+ *
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
+ *
+ * This file is created by fankes on 2022/1/30.
+ */
+@file:Suppress("SetTextI18n", "InflateParams")
+
+package com.fankes.miui.notify.ui.activity
+
+import androidx.core.view.isVisible
+import com.fankes.miui.notify.R
+import com.fankes.miui.notify.bean.IconDataBean
+import com.fankes.miui.notify.data.ConfigData
+import com.fankes.miui.notify.databinding.ActivityConfigBinding
+import com.fankes.miui.notify.databinding.AdapterConfigBinding
+import com.fankes.miui.notify.databinding.DiaIconFilterBinding
+import com.fankes.miui.notify.params.IconPackParams
+import com.fankes.miui.notify.params.factory.isAppNotifyHookAllOf
+import com.fankes.miui.notify.params.factory.isAppNotifyHookOf
+import com.fankes.miui.notify.params.factory.putAppNotifyHookAllOf
+import com.fankes.miui.notify.params.factory.putAppNotifyHookOf
+import com.fankes.miui.notify.ui.activity.base.BaseActivity
+import com.fankes.miui.notify.utils.factory.addOnBackPressedEvent
+import com.fankes.miui.notify.utils.factory.bindAdapter
+import com.fankes.miui.notify.utils.factory.callOnBackPressed
+import com.fankes.miui.notify.utils.factory.colorOf
+import com.fankes.miui.notify.utils.factory.copyToClipboard
+import com.fankes.miui.notify.utils.factory.navigate
+import com.fankes.miui.notify.utils.factory.openBrowser
+import com.fankes.miui.notify.utils.factory.showDialog
+import com.fankes.miui.notify.utils.factory.snake
+import com.fankes.miui.notify.utils.factory.toast
+import com.fankes.miui.notify.utils.tool.IconRuleManagerTool
+import com.fankes.miui.notify.utils.tool.SystemUITool
+import com.highcapable.yukihookapi.YukiHookAPI
+
+class ConfigureActivity : BaseActivity<ActivityConfigBinding>() {
+
+    /** 当前筛选条件 */
+    private var filterText = ""
+
+    /** 回调适配器改变 */
+    private var onChanged: (() -> Unit)? = null
+
+    /** 回调滚动事件改变 */
+    private var onScrollEvent: ((Boolean) -> Unit)? = null
+
+    /** 全部的通知图标优化数据 */
+    private var iconAllDatas = ArrayList<IconDataBean>()
+
+    override fun onCreate() {
+        /** 检查激活和启用状态 */
+        if (YukiHookAPI.Status.isXposedModuleActive.not() || ConfigData.isEnableModule.not()) {
+            showDialog {
+                title = "模块不可用"
+                msg = "模块没有激活或已被停用，你无法使用这里的功能，请先激活或启用模块。"
+                confirmButton(text = "我知道了") { finish() }
+                noCancelable()
+            }
+            return
+        }
+        /** 返回按钮点击事件 */
+        binding.titleBackIcon.setOnClickListener { callOnBackPressed() }
+        /** 刷新适配器结果相关 */
+        refreshAdapterResult()
+        /** 设置上下按钮点击事件 */
+        binding.configTitleUp.setOnClickListener {
+            snake(msg = "滚动到顶部")
+            onScrollEvent?.invoke(false)
+        }
+        binding.configTitleDown.setOnClickListener {
+            snake(msg = "滚动到底部")
+            onScrollEvent?.invoke(true)
+        }
+        /** 设置过滤按钮点击事件 */
+        binding.configTitleFilter.setOnClickListener {
+            showDialog<DiaIconFilterBinding> {
+                title = "按条件过滤"
+                binding.iconFiltersEdit.apply {
+                    requestFocus()
+                    invalidate()
+                    if (filterText.isNotBlank()) {
+                        setText(filterText)
+                        setSelection(filterText.length)
+                    }
+                }
+                confirmButton {
+                    if (binding.iconFiltersEdit.text.toString().isNotBlank()) {
+                        filterText = binding.iconFiltersEdit.text.toString().trim()
+                        refreshAdapterResult()
+                    } else {
+                        toast(msg = "条件不能为空")
+                        it.performClick()
+                    }
+                }
+                cancelButton()
+                if (filterText.isNotBlank())
+                    neutralButton(text = "清除条件") {
+                        filterText = ""
+                        refreshAdapterResult()
+                    }
+            }
+        }
+        /** 设置同步列表按钮点击事件 */
+        binding.configTitleSync.setOnClickListener { onStartRefresh() }
+        /** 设置列表元素和 Adapter */
+        binding.configListView.apply {
+            bindAdapter {
+                onBindDatas { iconDatas }
+                onBindViews<AdapterConfigBinding> { binding, position ->
+                    iconDatas[position].also { bean ->
+                        binding.adpAppIcon.setImageBitmap(bean.iconBitmap)
+                        (if (bean.iconColor != 0) bean.iconColor else resources.colorOf(R.color.colorTextGray)).also { color ->
+                            binding.adpAppIcon.setColorFilter(color)
+                            binding.adpAppName.setTextColor(color)
+                        }
+                        binding.adpAppName.text = bean.appName
+                        binding.adpAppPkgName.text = bean.packageName
+                        binding.adpCbrName.text = "贡献者：" + bean.contributorName
+                        isAppNotifyHookOf(bean).also { e ->
+                            binding.adpAppOpenSwitch.isChecked = e
+                            binding.adpAppAllSwitch.isEnabled = e
+                        }
+                        binding.adpAppOpenSwitch.setOnCheckedChangeListener { btn, b ->
+                            if (btn.isPressed.not()) return@setOnCheckedChangeListener
+                            putAppNotifyHookOf(bean, b)
+                            binding.adpAppAllSwitch.isEnabled = b
+                            SystemUITool.refreshSystemUI(context = this@ConfigureActivity)
+                        }
+                        binding.adpAppAllSwitch.isChecked = isAppNotifyHookAllOf(bean)
+                        binding.adpAppAllSwitch.setOnCheckedChangeListener { btn, b ->
+                            if (btn.isPressed.not()) return@setOnCheckedChangeListener
+                            fun saveState() {
+                                putAppNotifyHookAllOf(bean, b)
+                                SystemUITool.refreshSystemUI(context = this@ConfigureActivity)
+                            }
+                            if (b) showDialog {
+                                title = "全部替换"
+                                msg = "此功能仅针对严重不遵守规范的 APP 通知图标才需要开启，例如：APP 推送通知后无法识别出现的黑白块图标。\n\n" +
+                                    "此功能在一般情况下请保持关闭并跟随在线规则的配置，并不要随意改变此配置，" +
+                                    "开启后 APP 的通知图标可能会被规则破坏，你确定还要开启吗？"
+                                confirmButton { saveState() }
+                                cancelButton { btn.isChecked = btn.isChecked.not() }
+                                noCancelable()
+                            } else saveState()
+                        }
+                    }
+                }
+            }.apply {
+                setOnItemLongClickListener { _, _, p, _ ->
+                    showDialog {
+                        title = "复制“${iconDatas[p].appName}”的规则"
+                        msg = "是否复制单条规则到剪贴板？"
+                        confirmButton { copyToClipboard(iconDatas[p].toString()) }
+                        cancelButton()
+                    }
+                    true
+                }
+                onChanged = { notifyDataSetChanged() }
+            }
+            onScrollEvent = { post { setSelection(if (it) iconDatas.lastIndex else 0) } }
+        }
+        /** 设置点击事件 */
+        binding.configCbrButton.setOnClickListener {
+            showDialog {
+                title = "感谢你的贡献"
+                msg = "通知图标优化名单需要大家的共同维护才能得以完善，请选择你的贡献方式。"
+                confirmButton(text = "贡献规则") { openBrowser(IconRuleManagerTool.RULES_CONTRIBUTING_URL) }
+                cancelButton(text = "请求适配") { openBrowser(IconRuleManagerTool.RULES_FEEDBACK_URL) }
+                neutralButton(text = "暂时不用")
+            }
+        }
+        /** 装载数据 */
+        mockLocalData()
+        /** 更新数据 */
+        when {
+            intent?.getBooleanExtra("isNewAppSupport", false) == true ->
+                showDialog {
+                    val appName = intent?.getStringExtra("appName") ?: ""
+                    val pkgName = intent?.getStringExtra("pkgName") ?: ""
+                    title = "新安装应用通知图标适配"
+                    msg = "你已安装 $appName($pkgName)\n\n" +
+                        "此应用未在通知优化名单中发现适配数据，若此应用发送的通知为彩色图标，" +
+                        "可随时点击本页面下方的“贡献通知图标优化名单”按钮提交贡献或请求适配。\n\n" +
+                        "若你已知晓此应用会遵守原生通知图标规范，可忽略此提示。\n\n" +
+                        "你可以现在立即同步适配列表，以获取最新的适配数据。"
+                    confirmButton(text = "同步列表") { onStartRefresh() }
+                    cancelButton(text = "复制名称+包名") { copyToClipboard(content = "$appName($pkgName)") }
+                    neutralButton(text = "取消")
+                    noCancelable()
+                }
+            intent?.getBooleanExtra("isDirectUpdate", false) == true -> onStartRefresh(isByHand = false)
+            intent?.getBooleanExtra("isShowUpdDialog", true) == true -> onStartRefresh()
+        }
+        /** 清除数据 */
+        intent?.apply {
+            removeExtra("isNewAppSupport")
+            removeExtra("isDirectUpdate")
+            removeExtra("isShowUpdDialog")
+        }
+        /** 设置返回监听事件 */
+        addOnBackPressedEvent {
+            if (MainActivity.isActivityLive.not())
+                showDialog {
+                    title = "提示"
+                    msg = "要返回模块主页吗？"
+                    confirmButton {
+                        releaseEventAndBack()
+                        navigate<MainActivity>()
+                    }
+                    cancelButton { releaseEventAndBack() }
+                }
+            else releaseEventAndBack()
+        }
+    }
+
+    /**
+     * 开始同步
+     * @param isByHand 是否手动同步 - 默认是
+     */
+    private fun onStartRefresh(isByHand: Boolean = true) {
+        if (isByHand)
+            IconRuleManagerTool.syncByHand(context = this) {
+                filterText = ""
+                mockLocalData()
+            }
+        else
+            IconRuleManagerTool.sync(context = this) {
+                filterText = ""
+                mockLocalData()
+            }
+    }
+
+    /** 装载或刷新本地数据 */
+    private fun mockLocalData() {
+        iconAllDatas = IconPackParams(context = this).iconDatas
+        refreshAdapterResult()
+    }
+
+    /** 刷新适配器结果相关 */
+    private fun refreshAdapterResult() {
+        onChanged?.invoke()
+        binding.configTitleCountText.text =
+            if (filterText.isBlank()) "已适配 ${iconDatas.size} 个 APP 的通知图标"
+            else "“$filterText” 匹配到 ${iconDatas.size} 个结果"
+        binding.configListNoDataView.apply {
+            text = if (iconAllDatas.isEmpty()) "噫，竟然什么都没有~\n请点击右上角同步按钮获取云端数据" else "噫，竟然什么都没找到~"
+            isVisible = iconDatas.isEmpty()
+        }
+    }
+
+    /**
+     * 当前结果下的图标数组
+     * @return [Array]
+     */
+    private val iconDatas
+        get() = if (filterText.isBlank()) iconAllDatas
+        else iconAllDatas.filter {
+            it.appName.lowercase().contains(filterText.lowercase()) || it.packageName.lowercase().contains(filterText.lowercase())
+        }
+}

app/src/main/java/com/fankes/miui/notify/ui/activity/MainActivity.kt

@@ -0,0 +1,452 @@
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2017-2023 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
+ *
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
+ *
+ * This file is created by fankes on 2022/1/24.
+ */
+@file:Suppress("SetTextI18n")
+
+package com.fankes.miui.notify.ui.activity
+
+import androidx.core.view.isGone
+import androidx.core.view.isVisible
+import com.fankes.miui.notify.R
+import com.fankes.miui.notify.const.ModuleVersion
+import com.fankes.miui.notify.data.ConfigData
+import com.fankes.miui.notify.data.factory.bind
+import com.fankes.miui.notify.databinding.ActivityMainBinding
+import com.fankes.miui.notify.databinding.DiaStatusIconCountBinding
+import com.fankes.miui.notify.params.IconPackParams
+import com.fankes.miui.notify.ui.activity.base.BaseActivity
+import com.fankes.miui.notify.utils.factory.androidVersionCodeName
+import com.fankes.miui.notify.utils.factory.hideOrShowLauncherIcon
+import com.fankes.miui.notify.utils.factory.isLauncherIconShowing
+import com.fankes.miui.notify.utils.factory.isLowerAndroidP
+import com.fankes.miui.notify.utils.factory.isLowerAndroidR
+import com.fankes.miui.notify.utils.factory.isMIOS
+import com.fankes.miui.notify.utils.factory.isNotMiSystem
+import com.fankes.miui.notify.utils.factory.isNotNoificationEnabled
+import com.fankes.miui.notify.utils.factory.isNotSupportMiSystemVersion
+import com.fankes.miui.notify.utils.factory.miSystemVersion
+import com.fankes.miui.notify.utils.factory.miuiVersionCode
+import com.fankes.miui.notify.utils.factory.navigate
+import com.fankes.miui.notify.utils.factory.openBrowser
+import com.fankes.miui.notify.utils.factory.openNotifySetting
+import com.fankes.miui.notify.utils.factory.showDialog
+import com.fankes.miui.notify.utils.factory.showTimePicker
+import com.fankes.miui.notify.utils.factory.snake
+import com.fankes.miui.notify.utils.factory.systemFullVersion
+import com.fankes.miui.notify.utils.tool.GithubReleaseTool
+import com.fankes.miui.notify.utils.tool.I18nWarnTool
+import com.fankes.miui.notify.utils.tool.SystemUITool
+import com.fankes.projectpromote.ProjectPromote
+import com.highcapable.yukihookapi.YukiHookAPI
+
+class MainActivity : BaseActivity<ActivityMainBinding>() {
+
+    companion object {
+
+        /** 窗口是否启动 */
+        internal var isActivityLive = false
+
+        /** 模块是否可用 */
+        internal var isModuleRegular = false
+
+        /** 模块是否有效 */
+        internal var isModuleValied = false
+    }
+
+    override fun onCreate() {
+        /** 设置可用性 */
+        isActivityLive = true
+        /** 检查更新 */
+        GithubReleaseTool.checkingForUpdate(context = this, ModuleVersion.NAME) { version, function ->
+            binding.mainTextReleaseVersion.apply {
+                text = "点击更新 $version"
+                isVisible = true
+                setOnClickListener { function() }
+            }
+        }
+        when {
+            /** 判断是否为小米系统 */
+            isNotMiSystem ->
+                showDialog {
+                    title = "不是 MIUI 或 HyperOS 系统"
+                    msg = "此模块专为 MIUI、HyperOS 系统打造，当前无法识别你的系统为其中任意之一，所以模块无法工作。"
+                    confirmButton(text = "查看支持的模块") {
+                        openBrowser(url = "https://github.com/fankes/AndroidNotifyIconAdapt")
+                        finish()
+                    }
+                    cancelButton(text = "退出") { finish() }
+                    noCancelable()
+                }
+            /** 判断最低 Android 系统版本 */
+            isLowerAndroidP ->
+                showDialog {
+                    title = "Android 系统版本过低"
+                    msg = "此模块最低支持基于 Android 9 的 MIUI 系统，你的系统版本过低不再进行适配。\n\n" +
+                        "若有其它疑问，你可以点击下方按钮前往项目地址进行反馈。"
+                    confirmButton(text = "前往项目地址") {
+                        openProjectUrl()
+                        finish()
+                    }
+                    cancelButton(text = "退出") { finish() }
+                    noCancelable()
+                }
+            /** 判断支持的系统版本 */
+            isNotSupportMiSystemVersion ->
+                showDialog {
+                    title = "不支持的系统版本"
+                    msg = (if (miSystemVersion.isNotBlank())
+                        "此模块目前支持 MIUI 11~14 和 HyperOS 1.0 系统，你的系统版本为 $miSystemVersion，暂不支持。\n\n" +
+                            "如果你的系统版本识别有误，请检查是否有相关插件修改了系统版本。\n\n"
+                    else "无法获取系统版本，请检查你是否修改了系统参数或使用非官方系统。\n\n") + "若有其它疑问，你可以点击下方按钮前往项目地址进行反馈。"
+                    confirmButton(text = "前往项目地址") {
+                        openProjectUrl()
+                        finish()
+                    }
+                    cancelButton(text = "退出") { finish() }
+                    noCancelable()
+                }
+            /** 判断是否 Hook */
+            YukiHookAPI.Status.isXposedModuleActive -> {
+                if (IconPackParams(context = this).iconDatas.isEmpty() && ConfigData.isEnableNotifyIconFix)
+                    showDialog {
+                        title = "配置通知图标优化名单"
+                        msg = "模块需要获取在线规则以更新“通知图标优化名单”，它现在是空的，这看起来是你第一次使用模块，请首先进行配置才可以使用相关功能。\n" +
+                            "你可以随时在本页面下方找到“配置通知图标优化名单”手动前往。"
+                        confirmButton(text = "前往") { navigate<ConfigureActivity>() }
+                        cancelButton()
+                        noCancelable()
+                    }
+                if (isNotNoificationEnabled && ConfigData.isEnableNotifyIconFix)
+                    showDialog {
+                        title = "模块的通知权限已关闭"
+                        msg = "请开启通知权限，以确保你能收到通知图标优化在线规则的更新。"
+                        confirmButton { openNotifySetting() }
+                        cancelButton()
+                        noCancelable()
+                    }
+                if (isLowerAndroidR && ConfigData.isIgnoredAndroidVersionToLow.not())
+                    showDialog {
+                        title = "Android 版本过低"
+                        msg = "你当前使用的 Android 版本过低，模块的部分功能可能会发生问题，" +
+                            "由于设备有限，无法逐一调试，若有好的建议可向我们贡献代码提交适配请求，建议在 Android 11 及以上版本中使用效果最佳。"
+                        confirmButton(text = "我知道了") { ConfigData.isIgnoredAndroidVersionToLow = true }
+                        noCancelable()
+                    }
+                /** 推广、恰饭 */
+                ProjectPromote.show(activity = this, ModuleVersion.toString())
+            }
+            else ->
+                showDialog {
+                    title = "模块没有激活"
+                    msg = "检测到模块没有激活，模块需要 Xposed 环境依赖，" +
+                        "同时需要系统拥有 Root 权限，" +
+                        "请自行查看本页面使用帮助与说明第二条。\n" +
+                        "由于需要修改系统应用达到效果，模块不支持太极阴、应用转生。"
+                    confirmButton(text = "我知道了")
+                    noCancelable()
+                }
+        }
+        I18nWarnTool.checkingOrShowing(context = this)
+        if (isMIOS) binding.mainTitle.text = binding.mainTitle.text.toString().replace("MIUI", "HyperOS")
+        binding.mainTextVersion.text = "模块版本：${ModuleVersion.NAME}"
+        /** 设置 CI 自动构建标识 */
+        if (ModuleVersion.isCiMode)
+            binding.mainTextReleaseVersion.apply {
+                text = "CI ${ModuleVersion.GITHUB_COMMIT_ID}"
+                isVisible = true
+                setOnClickListener {
+                    showDialog {
+                        title = "CI 自动构建说明"
+                        msg = """
+                          你正在使用的是 CI 自动构建版本，Commit ID 为 ${ModuleVersion.GITHUB_COMMIT_ID}。
+                          
+                          它是由代码提交后自动触发并构建、自动编译发布的，并未经任何稳定性测试，使用风险自负。
+                        """.trimIndent()
+                        confirmButton(text = "我知道了")
+                        noCancelable()
+                    }
+                }
+            }
+        binding.mainTextMiuiVersion.text = "系统版本：[$androidVersionCodeName] $systemFullVersion"
+        binding.warnSCountDisTip.isGone = miuiVersionCode > 12.5
+        binding.warnMiuiNotifyStyleTip.isGone = miuiVersionCode > 11
+        binding.statusIconCountText.text = ConfigData.liftedStatusIconCount.toString()
+        binding.notifyIconAutoSyncText.text = ConfigData.notifyIconFixAutoTime
+        binding.moduleEnableSwitch.bind(ConfigData.ENABLE_MODULE) {
+            onInitialize {
+                binding.moduleEnableLogItem.isVisible = it
+                binding.colorIconHookItem.isVisible = it
+                binding.statusIconCountItem.isVisible = isLowerAndroidR.not() && it
+                binding.notifyStyleConfigItem.isVisible = it
+                binding.notifyIconConfigItem.isVisible = it
+            }
+            onChanged {
+                reinitialize()
+                refreshModuleStatus()
+                SystemUITool.showNeedRestartSnake(context = this@MainActivity)
+            }
+        }
+        binding.moduleEnableLogSwitch.bind(ConfigData.ENABLE_MODULE_LOG) {
+            onInitialize { binding.expAllDebugLogButton.isVisible = it }
+            onChanged {
+                reinitialize()
+                SystemUITool.refreshSystemUI(context = this@MainActivity, isRefreshCacheOnly = true)
+            }
+        }
+        binding.statusIconCountSwitch.bind(ConfigData.ENABLE_LIFTED_STATUS_ICON_COUNT) {
+            onInitialize { binding.statusIconCountChildItem.isVisible = it }
+            onChanged {
+                reinitialize()
+                SystemUITool.refreshSystemUI(context = this@MainActivity) { snake(msg = "设置将在新通知推送或状态栏刷新后自动生效") }
+            }
+        }
+        binding.colorIconCompatSwitch.bind(ConfigData.ENABLE_COLOR_ICON_COMPAT) {
+            isAutoApplyChanges = false
+            onChanged {
+                /** 应用更改并刷新系统界面 */
+                fun applyChangesAndRefresh() {
+                    applyChanges()
+                    SystemUITool.refreshSystemUI(context = this@MainActivity)
+                }
+                if (it) showDialog {
+                    title = "启用兼容模式"
+                    msg = "启用兼容模式可修复部分系统版本可能出现无法判定通知图标反色的问题，" +
+                        "但是这也可能会导致新的问题，一般情况下不建议开启，确定要继续吗？\n\n" +
+                        "如果系统界面刷新后通知图标颜色发生错误，请尝试重启一次系统界面。"
+                    confirmButton { applyChangesAndRefresh() }
+                    cancelButton { cancelChanges() }
+                    noCancelable()
+                } else applyChangesAndRefresh()
+            }
+        }
+        binding.miuiNotifyIconReplacementSwitch.bind(ConfigData.ENABLE_REPLACE_MIUI_STYLE_NOTIFY_ICON) {
+            onChanged { SystemUITool.refreshSystemUI(context = this@MainActivity) }
+        }
+        binding.notifyIconForceSystemColorSwitch.bind(ConfigData.ENABLE_NOTIFY_ICON_FORCE_SYSTEM_COLOR) {
+            isAutoApplyChanges = false
+            onChanged {
+                /** 应用更改并刷新系统界面 */
+                fun applyChangesAndRefresh() {
+                    applyChangesAndReinitialize()
+                    SystemUITool.refreshSystemUI(context = this@MainActivity)
+                }
+                if (it) showDialog {
+                    title = "破坏性功能警告"
+                    msg = "开启这个功能后，任何通知栏中的通知图标都会忽略图标自身的着色属性，全部使用系统默认颜色 (系统提供的统一色调) 着色。\n\n" +
+                        "此功能仅面向一些追求图标美观度的用户，我们不推荐开启这个功能，且发生任何 BUG 都不会去修复，仍然继续开启吗？"
+                    confirmButton { applyChangesAndRefresh() }
+                    cancelButton { cancelChanges() }
+                    noCancelable()
+                } else applyChangesAndRefresh()
+            }
+        }
+        binding.notifyIconForceAppIconSwitch.bind(ConfigData.ENABLE_NOTIFY_ICON_FORCE_APP_ICON) {
+            isAutoApplyChanges = false
+            onInitialize {
+                arrayOf(
+                    binding.notifyIconCustomCornerItem,
+                    binding.notifyIconForceSystemColorItem
+                ).forEach { e -> e.isVisible = isLowerAndroidR.not() && it.not() }
+                binding.miuiNotifyIconReplacementItem.isVisible = it.not()
+            }
+            onChanged {
+                /** 应用更改并刷新系统界面 */
+                fun applyChangesAndRefresh() {
+                    applyChangesAndReinitialize()
+                    SystemUITool.refreshSystemUI(context = this@MainActivity)
+                }
+                if (it) showDialog {
+                    title = "破坏性功能警告"
+                    msg = "开启这个功能后，任何通知栏中的通知图标都会被强制替换为当前推送通知的 APP 的图标，" +
+                        "某些系统级别的 APP 通知图标可能会显示异常或发生图标丢失。\n\n" +
+                        "此功能仅面向一些追求图标美观度的用户，我们不推荐开启这个功能，且发生任何 BUG 都不会去修复，仍然继续开启吗？"
+                    confirmButton { applyChangesAndRefresh() }
+                    cancelButton { cancelChanges() }
+                    noCancelable()
+                } else applyChangesAndRefresh()
+            }
+        }
+        binding.notifyIconFixSwitch.bind(ConfigData.ENABLE_NOTIFY_ICON_FIX) {
+            onInitialize {
+                binding.notifyIconFixButton.isVisible = it
+                binding.notifyIconFixPlaceholderItem.isVisible = it
+                binding.notifyIconFixNotifyItem.isVisible = it
+                binding.notifyIconAutoSyncItem.isVisible = it
+            }
+            onChanged {
+                reinitialize()
+                SystemUITool.refreshSystemUI(context = this@MainActivity)
+            }
+        }
+        binding.notifyIconFixPlaceholderSwitch.bind(ConfigData.ENABLE_NOTIFY_ICON_FIX_PLACEHOLDER) {
+            isAutoApplyChanges = false
+            onChanged {
+                /** 应用更改并刷新系统界面 */
+                fun applyChangesAndRefresh() {
+                    applyChanges()
+                    SystemUITool.refreshSystemUI(context = this@MainActivity)
+                }
+                if (it) showDialog {
+                    title = "注意"
+                    msg = "开启这个功能后，当发现未适配的彩色通知图标时，" +
+                        "状态栏中显示的通知图标将会使用预置的占位符图标进行修补，" +
+                        "通知栏中显示的通知图标保持原始图标不变。\n\n" +
+                        "此功能的作用仅为临时修复破坏规范的通知图标，仍然继续开启吗？"
+                    confirmButton { applyChangesAndRefresh() }
+                    cancelButton { cancelChanges() }
+                    noCancelable()
+                } else applyChangesAndRefresh()
+            }
+        }
+        binding.notifyIconFixNotifySwitch.bind(ConfigData.ENABLE_NOTIFY_ICON_FIX_NOTIFY) {
+            onChanged { SystemUITool.refreshSystemUI(context = this@MainActivity, isRefreshCacheOnly = true) }
+        }
+        binding.notifyIconAutoSyncSwitch.bind(ConfigData.ENABLE_NOTIFY_ICON_FIX_AUTO) {
+            onInitialize { binding.notifyIconAutoSyncChildItem.isVisible = it }
+            onChanged {
+                reinitialize()
+                SystemUITool.refreshSystemUI(context = this@MainActivity, isRefreshCacheOnly = true)
+            }
+        }
+        binding.statusDarkIconCustomAlphaSeekbar.bind(
+            ConfigData.STATUS_ICON_DARK_ALPHA_LEVEL, binding.statusDarkIconCustomAlphaText, suffix = "%"
+        ) { SystemUITool.refreshSystemUI(context = this) }
+        binding.statusLightIconCustomAlphaSeekbar.bind(
+            ConfigData.STATUS_ICON_LIGHT_ALPHA_LEVEL, binding.statusLightIconCustomAlphaText, suffix = "%"
+        ) { SystemUITool.refreshSystemUI(context = this) }
+        binding.notifyIconCustomCornerSeekbar.bind(ConfigData.NOTIFY_ICON_CORNER_SIZE, binding.notifyIconCustomCornerText, suffix = " dp") {
+            SystemUITool.refreshSystemUI(context = this)
+        }
+        /** 导出全部日志按钮点击事件 */
+        binding.expAllDebugLogButton.setOnClickListener { SystemUITool.obtainAndExportDebugLogs(context = this) }
+        /** MIUI 通知显示设置按钮点击事件 */
+        binding.miuiNotifyStyleButton.setOnClickListener { SystemUITool.openMiuiNotificationDisplaySettings(context = this) }
+        /** 通知图标优化名单按钮点击事件 */
+        binding.notifyIconFixButton.setOnClickListener { navigate<ConfigureActivity>() }
+        /** 修改状态栏通知图标个数按钮点击事件 */
+        binding.statusIconCountButton.setOnClickListener {
+            showDialog<DiaStatusIconCountBinding> {
+                title = "设置最多显示的图标个数"
+                binding.iconCountEdit.apply {
+                    requestFocus()
+                    invalidate()
+                    setText(ConfigData.liftedStatusIconCount.toString())
+                    setSelection(ConfigData.liftedStatusIconCount.toString().length)
+                }
+                confirmButton {
+                    when {
+                        (runCatching { binding.iconCountEdit.text.toString().toInt() }.getOrNull() ?: -1)
+                            !in 0..100 -> snake(msg = "请输入有效数值")
+                        binding.iconCountEdit.text.toString().isNotBlank() -> runCatching {
+                            ConfigData.liftedStatusIconCount = binding.iconCountEdit.text.toString().trim().toInt()
+                            this@MainActivity.binding.statusIconCountText.text = ConfigData.liftedStatusIconCount.toString()
+                            SystemUITool.refreshSystemUI(context) { context.snake(msg = "设置将在新通知推送或状态栏刷新后自动生效") }
+                        }.onFailure { snake(msg = "数值格式无效") }
+                        else -> snake(msg = "请输入有效数值")
+                    }
+                }
+                cancelButton()
+            }
+        }
+        /** 自动更新在线规则修改时间按钮点击事件 */
+        binding.notifyIconAutoSyncButton.setOnClickListener {
+            showTimePicker(ConfigData.notifyIconFixAutoTime) {
+                showDialog {
+                    title = "每天 $it 自动更新"
+                    msg = "设置保存后将在每天 $it 自动同步名单到最新云端数据，若数据已是最新则不会显示任何提示，否则会发送一条通知。\n\n" +
+                        "请确保：\n\n" +
+                        "1.模块没有被禁止前台以及后台联网权限\n" +
+                        "2.模块没有被禁止被其它 APP 关联唤醒\n" +
+                        "3.模块的系统通知权限已开启\n\n" +
+                        "模块无需保持在后台运行，到达同步时间后会自动启动，如果到达时间后模块正在运行则会自动取消本次计划任务。"
+                    confirmButton(text = "保存设置") {
+                        ConfigData.notifyIconFixAutoTime = it
+                        this@MainActivity.binding.notifyIconAutoSyncText.text = it
+                        SystemUITool.refreshSystemUI(context, isRefreshCacheOnly = true)
+                    }
+                    cancelButton()
+                    noCancelable()
+                }
+            }
+        }
+        /** 重启按钮点击事件 */
+        binding.titleRestartIcon.setOnClickListener { SystemUITool.restartSystemUI(context = this) }
+        /** 项目地址按钮点击事件 */
+        binding.titleGithubIcon.setOnClickListener { openProjectUrl() }
+        /** 恰饭！ */
+        binding.linkWithFollowMe.setOnClickListener {
+            openBrowser(url = "https://www.coolapk.com/u/876977", packageName = "com.coolapk.market")
+        }
+        /** 设置桌面图标显示隐藏 */
+        binding.hideIconInLauncherSwitch.isChecked = isLauncherIconShowing.not()
+        binding.hideIconInLauncherSwitch.setOnCheckedChangeListener { btn, b ->
+            if (btn.isPressed.not()) return@setOnCheckedChangeListener
+            hideOrShowLauncherIcon(b)
+        }
+        /** 注册导出调试日志启动器 */
+        SystemUITool.registerExportDebugLogsLauncher(activity = this)
+    }
+
+    /** 前往项目地址 */
+    private fun openProjectUrl() {
+        openBrowser(url = "https://github.com/fankes/MIUINativeNotifyIcon")
+    }
+
+    /** 刷新模块状态 */
+    private fun refreshModuleStatus() {
+        binding.mainLinStatus.setBackgroundResource(
+            when {
+                YukiHookAPI.Status.isXposedModuleActive &&
+                    (isModuleRegular.not() || isModuleValied.not() || ConfigData.isEnableModule.not()) -> R.drawable.bg_yellow_round
+                YukiHookAPI.Status.isXposedModuleActive -> R.drawable.bg_green_round
+                else -> R.drawable.bg_dark_round
+            }
+        )
+        binding.mainImgStatus.setImageResource(
+            when {
+                YukiHookAPI.Status.isXposedModuleActive && ConfigData.isEnableModule -> R.drawable.ic_success
+                else -> R.drawable.ic_warn
+            }
+        )
+        binding.mainTextStatus.text = when {
+            YukiHookAPI.Status.isXposedModuleActive && ConfigData.isEnableModule.not() -> "模块已停用"
+            YukiHookAPI.Status.isXposedModuleActive && isModuleRegular.not() -> "模块已激活，请重启系统界面"
+            YukiHookAPI.Status.isXposedModuleActive && isModuleValied.not() -> "模块已更新，请重启系统界面"
+            YukiHookAPI.Status.isXposedModuleActive -> "模块已激活"
+            else -> "模块未激活"
+        }
+        binding.mainTextApiWay.isVisible = YukiHookAPI.Status.isXposedModuleActive
+        binding.mainTextApiWay.text = "Activated by ${YukiHookAPI.Status.Executor.name} API ${YukiHookAPI.Status.Executor.apiLevel}"
+    }
+
+    override fun onResume() {
+        super.onResume()
+        /** 刷新模块状态 */
+        refreshModuleStatus()
+        /** 检查模块激活状态 */
+        SystemUITool.checkingActivated(context = this) { isValied ->
+            isModuleRegular = true
+            isModuleValied = isValied
+            refreshModuleStatus()
+        }
+    }
+}

app/src/main/java/com/fankes/miui/notify/ui/activity/auto/NotifyIconRuleUpdateActivity.kt

@@ -0,0 +1,60 @@
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2017-2023 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
+ *
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
+ *
+ * This file is created by fankes on 2022/3/26.
+ */
+@file:Suppress("DEPRECATION")
+
+package com.fankes.miui.notify.ui.activity.auto
+
+import android.app.Activity
+import android.os.Bundle
+import android.view.View
+import android.view.WindowManager
+import com.fankes.miui.notify.ui.activity.base.BaseActivity
+import com.fankes.miui.notify.utils.factory.delayedRun
+import com.fankes.miui.notify.utils.tool.IconRuleManagerTool
+import com.fankes.miui.notify.utils.tool.SystemUITool
+
+class NotifyIconRuleUpdateActivity : Activity() {
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        /** 设置透明窗口 */
+        window?.decorView?.systemUiVisibility =
+            View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN or View.SYSTEM_UI_FLAG_LAYOUT_STABLE
+        window?.addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS)
+        window?.addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION)
+        /** 检测运行状态 */
+        if (BaseActivity.isMainThreadRunning) {
+            finish()
+            return
+        }
+        /** 拉取云端数据 */
+        IconRuleManagerTool.sync(context = this) {
+            /** 刷新系统界面 */
+            SystemUITool.refreshSystemUI()
+            /** 结束当前窗口 */
+            runOnUiThread { delayedRun(ms = 1000) { finish() } }
+        }
+        /** 切换到后台 */
+        moveTaskToBack(true)
+    }
+}

app/src/main/java/com/fankes/miui/notify/ui/activity/base/BaseActivity.kt

@@ -0,0 +1,75 @@
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2017-2023 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
+ *
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
+ *
+ * This file is created by fankes on 2022/1/30.
+ */
+@file:Suppress("UNCHECKED_CAST")
+
+package com.fankes.miui.notify.ui.activity.base
+
+import android.os.Bundle
+import androidx.appcompat.app.AppCompatActivity
+import androidx.core.content.res.ResourcesCompat
+import androidx.core.view.WindowCompat
+import androidx.viewbinding.ViewBinding
+import com.fankes.miui.notify.R
+import com.fankes.miui.notify.utils.factory.isNotSystemInDarkMode
+import com.highcapable.yukihookapi.hook.factory.current
+import com.highcapable.yukihookapi.hook.factory.method
+import com.highcapable.yukihookapi.hook.type.android.LayoutInflaterClass
+
+abstract class BaseActivity<VB : ViewBinding> : AppCompatActivity() {
+
+    companion object {
+
+        /** 应用是否正在运行 */
+        var isMainThreadRunning = false
+    }
+
+    /** 获取绑定布局对象 */
+    lateinit var binding: VB
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        isMainThreadRunning = true
+        binding = current().generic()?.argument()?.method {
+            name = "inflate"
+            param(LayoutInflaterClass)
+        }?.get()?.invoke<VB>(layoutInflater) ?: error("binding failed")
+        setContentView(binding.root)
+        /** 隐藏系统的标题栏 */
+        supportActionBar?.hide()
+        /** 初始化沉浸状态栏 */
+        WindowCompat.getInsetsController(window, window.decorView).apply {
+            isAppearanceLightStatusBars = isNotSystemInDarkMode
+            isAppearanceLightNavigationBars = isNotSystemInDarkMode
+        }
+        ResourcesCompat.getColor(resources, R.color.colorThemeBackground, null).also {
+            window?.statusBarColor = it
+            window?.navigationBarColor = it
+            window?.navigationBarDividerColor = it
+        }
+        /** 装载子类 */
+        onCreate()
+    }
+
+    /** 回调 [onCreate] 方法 */
+    abstract fun onCreate()
+}

app/src/main/java/com/fankes/miui/notify/ui/base/BaseActivity.kt

@@ -1,66 +0,0 @@
-/**
- * Copyright (C) 2022. Fankes Studio(qzmmcn@163.com)
- *
- * This file is part of MIUINativeNotifyIcon.
- *
- * MIUINativeNotifyIcon is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * MIUINativeNotifyIcon is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * This file is Created by fankes on 2022/01/30.
- */
-package com.fankes.miui.notify.ui.base
-
-import android.os.Bundle
-import androidx.appcompat.app.AppCompatActivity
-import com.fankes.miui.notify.R
-import com.fankes.miui.notify.hook.HookMedium
-import com.fankes.miui.notify.utils.isNotSystemInDarkMode
-import com.gyf.immersionbar.ktx.immersionBar
-
-abstract class BaseActivity : AppCompatActivity() {
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        /** 隐藏系统的标题栏 */
-        supportActionBar?.hide()
-        /** 初始化沉浸状态栏 */
-        immersionBar {
-            statusBarColor(R.color.colorThemeBackground)
-            autoDarkModeEnable(true)
-            statusBarDarkFont(isNotSystemInDarkMode)
-            navigationBarColor(R.color.colorThemeBackground)
-            navigationBarDarkIcon(isNotSystemInDarkMode)
-            fitsSystemWindows(true)
-        }
-    }
-
-    override fun onResume() {
-        super.onResume()
-        HookMedium.setWorldReadable(this)
-    }
-
-    override fun onRestart() {
-        super.onRestart()
-        HookMedium.setWorldReadable(this)
-    }
-
-    override fun onPause() {
-        super.onPause()
-        HookMedium.setWorldReadable(this)
-    }
-
-    override fun onBackPressed() {
-        HookMedium.setWorldReadable(this)
-        super.onBackPressed()
-    }
-}

app/src/main/java/com/fankes/miui/notify/ui/widget/MaterialSwitch.kt

@@ -0,0 +1,75 @@
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2017-2023 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
+ *
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
+ *
+ * This file is created by fankes on 2022/1/8.
+ */
+@file:Suppress("SameParameterValue")
+
+package com.fankes.miui.notify.ui.widget
+
+import android.content.Context
+import android.content.res.ColorStateList
+import android.graphics.Color
+import android.text.TextUtils
+import android.util.AttributeSet
+import androidx.appcompat.widget.SwitchCompat
+import com.fankes.miui.notify.utils.factory.dp
+import com.fankes.miui.notify.utils.factory.isSystemInDarkMode
+import top.defaults.drawabletoolbox.DrawableBuilder
+
+class MaterialSwitch(context: Context, attrs: AttributeSet?) : SwitchCompat(context, attrs) {
+
+    private fun toColors(selected: Int, pressed: Int, normal: Int): ColorStateList {
+        val colors = intArrayOf(selected, pressed, normal)
+        val states = arrayOfNulls<IntArray>(3)
+        states[0] = intArrayOf(android.R.attr.state_checked)
+        states[1] = intArrayOf(android.R.attr.state_pressed)
+        states[2] = intArrayOf()
+        return ColorStateList(states, colors)
+    }
+
+    private val thumbColor get() = if (context.isSystemInDarkMode) 0xFF7C7C7C else 0xFFCCCCCC
+
+    init {
+        trackDrawable = DrawableBuilder()
+            .rectangle()
+            .rounded()
+            .solidColor(0xFF656565.toInt())
+            .height(20.dp(context))
+            .cornerRadius(15.dp(context))
+            .build()
+        thumbDrawable = DrawableBuilder()
+            .rectangle()
+            .rounded()
+            .solidColor(Color.WHITE)
+            .size(20.dp(context), 20.dp(context))
+            .cornerRadius(20.dp(context))
+            .strokeWidth(8.dp(context))
+            .strokeColor(Color.TRANSPARENT)
+            .build()
+        trackTintList = toColors(
+            0xFF656565.toInt(),
+            thumbColor.toInt(),
+            thumbColor.toInt()
+        )
+        isSingleLine = true
+        ellipsize = TextUtils.TruncateAt.END
+    }
+}

app/src/main/java/com/fankes/miui/notify/utils/DialogBuilder.kt

@@ -1,101 +0,0 @@
-/**
- * Copyright (C) 2022. Fankes Studio(qzmmcn@163.com)
- *
- * This file is part of MIUINativeNotifyIcon.
- *
- * MIUINativeNotifyIcon is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * MIUINativeNotifyIcon is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * This file is Created by fankes on 2022/1/7.
- */
-@file:Suppress("unused")
-
-package com.fankes.miui.notify.utils
-
-import android.app.AlertDialog
-import android.content.Context
-import android.graphics.Color
-import android.graphics.drawable.GradientDrawable
-
-
-/**
- * 构造对话框
- * @param it 对话框方法体
- */
-fun Context.showDialog(it: DialogBuilder.() -> Unit) = DialogBuilder(this).apply(it).show()
-
-/**
- * 对话框构造器
- * @param context 实例
- */
-class DialogBuilder(private val context: Context) {
-
-    private var instance: AlertDialog.Builder? = null // 实例对象
-
-    init {
-        instance = AlertDialog.Builder(context, android.R.style.Theme_Material_Light_Dialog)
-    }
-
-    /** 设置对话框不可关闭 */
-    fun noCancelable() = instance?.setCancelable(false)
-
-    /** 设置对话框标题 */
-    var title
-        get() = ""
-        set(value) {
-            instance?.setTitle(value)
-        }
-
-    /** 设置对话框消息内容 */
-    var msg
-        get() = ""
-        set(value) {
-            instance?.setMessage(value)
-        }
-
-    /**
-     * 设置对话框确定按钮
-     * @param text 按钮文本内容
-     * @param it 点击事件
-     */
-    fun confirmButton(text: String = "确定", it: () -> Unit = {}) =
-        instance?.setPositiveButton(text) { _, _ -> it() }
-
-    /**
-     * 设置对话框取消按钮
-     * @param text 按钮文本内容
-     * @param it 点击事件
-     */
-    fun cancelButton(text: String = "取消", it: () -> Unit = {}) =
-        instance?.setNegativeButton(text) { _, _ -> it() }
-
-    /**
-     * 设置对话框第三个按钮
-     * @param text 按钮文本内容
-     * @param it 点击事件
-     */
-    fun neutralButton(text: String = "更多", it: () -> Unit = {}) =
-        instance?.setNeutralButton(text) { _, _ -> it() }
-
-    /** 显示对话框 */
-    internal fun show() = instance?.create()?.apply {
-        window?.setBackgroundDrawable(GradientDrawable(
-            GradientDrawable.Orientation.TOP_BOTTOM,
-            intArrayOf(Color.WHITE, Color.WHITE)
-        ).apply {
-            shape = GradientDrawable.RECTANGLE
-            gradientType = GradientDrawable.LINEAR_GRADIENT
-            cornerRadius = 15.dp(this@DialogBuilder.context)
-        })
-    }?.show()
-}

app/src/main/java/com/fankes/miui/notify/utils/FileUtils.java

@@ -1,85 +0,0 @@
-/*
- * Copyright (C) 2022. Fankes Studio(qzmmcn@163.com)
- *
- * This file is part of MIUINativeNotifyIcon.
- *
- * MIUINativeNotifyIcon is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * MIUINativeNotifyIcon is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * This file is Created by zpp0196 on 2019/2/9.
- */
-package com.fankes.miui.notify.utils;
-
-import android.content.Context;
-
-import com.fankes.miui.notify.BuildConfig;
-
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileOutputStream;
-import java.io.IOException;
-
-@SuppressWarnings("ALL")
-public class FileUtils {
-
-    private static final String FILE_PREF_NAME = BuildConfig.APPLICATION_ID + "_preferences.xml";
-
-    public static boolean copyFile(File srcFile, File targetFile) {
-        FileInputStream ins = null;
-        FileOutputStream out = null;
-        try {
-            if (targetFile.exists()) {
-                targetFile.delete();
-            }
-            File targetParent = targetFile.getParentFile();
-            if (!targetParent.exists()) {
-                targetParent.mkdirs();
-            }
-            targetFile.createNewFile();
-            ins = new FileInputStream(srcFile);
-            out = new FileOutputStream(targetFile);
-            byte[] b = new byte[1024];
-            int n;
-            while ((n = ins.read(b)) != -1) {
-                out.write(b, 0, n);
-            }
-        } catch (IOException e) {
-            e.printStackTrace();
-            return false;
-        } finally {
-            try {
-                if (ins != null) {
-                    ins.close();
-                }
-                if (out != null) {
-                    out.close();
-                }
-            } catch (IOException e) {
-                e.printStackTrace();
-            }
-        }
-        return true;
-    }
-
-    public static File getDataDir(Context context) {
-        return new File(context.getApplicationInfo().dataDir);
-    }
-
-    public static File getPrefDir(Context context) {
-        return new File(getDataDir(context), "shared_prefs");
-    }
-
-    public static File getDefaultPrefFile(Context context) {
-        return new File(getPrefDir(context), FILE_PREF_NAME);
-    }
-}

app/src/main/java/com/fankes/miui/notify/utils/Utils.kt

@@ -1,257 +0,0 @@
-/**
- * Copyright (C) 2022. Fankes Studio(qzmmcn@163.com)
- *
- * This file is part of MIUINativeNotifyIcon.
- *
- * MIUINativeNotifyIcon is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * MIUINativeNotifyIcon is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * This file is Created by fankes on 2022/1/7.
- */
-@file:Suppress("DEPRECATION", "PrivateApi", "unused")
-
-package com.fankes.miui.notify.utils
-
-import android.content.Context
-import android.content.pm.PackageInfo
-import android.content.pm.PackageManager
-import android.content.res.Configuration
-import android.graphics.*
-import android.graphics.Bitmap.createBitmap
-import android.os.Build
-import android.service.notification.StatusBarNotification
-import android.util.Base64
-import com.fankes.miui.notify.application.MNNApplication.Companion.appContext
-import java.io.DataInputStream
-import java.io.DataOutputStream
-
-/**
- * 系统深色模式是否开启
- * @return [Boolean] 是否开启
- */
-val isSystemInDarkMode
-    get() = (appContext.resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK) == Configuration.UI_MODE_NIGHT_YES
-
-/**
- * 系统深色模式是否没开启
- * @return [Boolean] 是否开启
- */
-inline val isNotSystemInDarkMode get() = !isSystemInDarkMode
-
-/**
- * 系统深色模式是否开启
- * @return [Boolean] 是否开启
- */
-val Context.isSystemInDarkMode get() = (resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK) == Configuration.UI_MODE_NIGHT_YES
-
-/**
- * 系统深色模式是否没开启
- * @return [Boolean] 是否开启
- */
-inline val Context.isNotSystemInDarkMode get() = !isSystemInDarkMode
-
-/**
- * 系统版本是否高于或等于 Android 12
- * @return [Boolean] 是否符合条件
- */
-inline val isUpperOfAndroidS get() = Build.VERSION.SDK_INT > Build.VERSION_CODES.R
-
-/**
- * 系统版本是否低于 Android 9
- * @return [Boolean] 是否符合条件
- */
-inline val isLowerAndroidP get() = Build.VERSION.SDK_INT < Build.VERSION_CODES.P
-
-/**
- * 当前设备是否是 MIUI 定制 Android 系统
- * @return [Boolean] 是否符合条件
- */
-val isMIUI by lazy {
-    try {
-        Class.forName("android.miui.R")
-        true
-    } catch (_: Exception) {
-        false
-    }
-}
-
-/**
- * 当前设备是否不是 MIUI 定制 Android 系统
- * @return [Boolean] 是否符合条件
- */
-inline val isNotMIUI get() = !isMIUI
-
-/**
- * 获取 MIUI 版本
- * @return [String]
- */
-val miuiVersion
-    get() =
-        if (isMIUI)
-            findPropString(key = "ro.miui.ui.version.name", default = "V无法获取").let {
-                when (it) {
-                    "V110" -> "11"
-                    "V11" -> "11"
-                    "V120" -> "12"
-                    "V12" -> "12"
-                    "V125" -> "12.5"
-                    "V130" -> "13"
-                    "V13" -> "13"
-                    else -> it.replace(oldValue = "V", newValue = "")
-                }
-            } + " " + findPropString(key = "ro.system.build.version.incremental")
-        else "不是 MIUI 系统"
-
-/**
- * 获取推送通知的包名
- * @return [String]
- */
-val StatusBarNotification.opPkgName get() = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) opPkg else packageName ?: ""
-
-/**
- * 得到安装包信息
- * @return [PackageInfo]
- */
-val Context.packageInfo get() = packageManager?.getPackageInfo(packageName, 0) ?: PackageInfo()
-
-/**
- * 判断应用是否安装
- * @return [Boolean]
- */
-val String.isInstall
-    get() =
-        try {
-            appContext.packageManager.getPackageInfo(
-                this,
-                PackageManager.GET_UNINSTALLED_PACKAGES
-            )
-            true
-        } catch (e: Exception) {
-            false
-        }
-
-/**
- * 得到版本信息
- * @return [String]
- */
-val Context.versionName get() = packageInfo.versionName ?: ""
-
-/**
- * 得到版本号
- * @return [Int]
- */
-val Context.versionCode get() = packageInfo.versionCode
-
-/**
- * dp 转换为 px
- * @return [Int]
- */
-val Number.dp get() = (toFloat() * appContext.resources.displayMetrics.density).toInt()
-
-/**
- * dp 转换为 px
- * @param context 使用的实例
- * @return [Float]
- */
-fun Number.dp(context: Context) = toFloat() * context.resources.displayMetrics.density
-
-/**
- * Base64 加密
- * @return [String]
- */
-val String.base64: String get() = Base64.encodeToString(toByteArray(), Base64.DEFAULT)
-
-/**
- * Base64 解密为字节流
- * @return [ByteArray]
- */
-val String.unbase64 get() = Base64.decode(this, Base64.DEFAULT) ?: ByteArray(0)
-
-/**
- * 字节流解析为位图
- * @return [Bitmap]
- */
-val ByteArray.bitmap: Bitmap get() = BitmapFactory.decodeByteArray(this, 0, size)
-
-/**
- * 字符串解析为位图
- * @return [Bitmap]
- */
-val String.bitmap: Bitmap get() = unbase64.bitmap
-
-/**
- * 圆角图片
- * @param radius 圆角度
- * @return [Bitmap] 圆角后的位图 - 失败会返回处理之前的位图
- */
-fun Bitmap.round(radius: Float): Bitmap =
-    createBitmap(width, height, Bitmap.Config.ARGB_8888).also { out ->
-        Canvas(out).also { canvas ->
-            Paint().also { paint ->
-                paint.isAntiAlias = true
-                canvas.drawARGB(0, 0, 0, 0)
-                paint.color = Color.WHITE
-                canvas.drawRoundRect(RectF(Rect(0, 0, width, height)), radius, radius, paint)
-                paint.xfermode = PorterDuffXfermode(PorterDuff.Mode.SRC_IN)
-                canvas.drawBitmap(this, Rect(0, 0, width, height), Rect(0, 0, width, height), paint)
-            }
-        }
-    }
-
-/**
- * 获取系统 Prop 值
- * @param key Key
- * @param default 默认值
- * @return [String]
- */
-fun findPropString(key: String, default: String = "") =
-    try {
-        (Class.forName("android.os.SystemProperties").getDeclaredMethod(
-            "get",
-            String::class.java,
-            String::class.java
-        ).apply { isAccessible = true }.invoke(null, key, default)) as? String? ?: default
-    } catch (_: Exception) {
-        default
-    }
-
-/**
- * 执行命令 - su
- * @param cmd 命令
- * @return [String] 执行结果
- */
-fun execShellCmd(cmd: String): String {
-    var result = ""
-    var dos: DataOutputStream? = null
-    var dis: DataInputStream? = null
-    try {
-        val p = Runtime.getRuntime().exec("su")
-        dos = DataOutputStream(p.outputStream)
-        dis = DataInputStream(p.inputStream)
-        dos.writeBytes("$cmd\n")
-        dos.flush()
-        dos.writeBytes("exit\n")
-        dos.flush()
-        var line: String
-        while (dis.readLine().also { line = it } != null) result += line
-        p.waitFor()
-    } catch (_: Exception) {
-    } finally {
-        try {
-            dos?.close()
-            dis?.close()
-        } catch (_: Exception) {
-        }
-    }
-    return result.trim()
-}

app/src/main/java/com/fankes/miui/notify/utils/XPrefUtils.kt

@@ -1,37 +0,0 @@
-/*
- * Copyright (C) 2022. Fankes Studio(qzmmcn@163.com)
- *
- * This file is part of MIUINativeNotifyIcon.
- *
- * MIUINativeNotifyIcon is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * MIUINativeNotifyIcon is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * This file is Created by zpp0196 on 2018/4/11.
- */
-package com.fankes.miui.notify.utils
-
-import com.fankes.miui.notify.BuildConfig
-import de.robv.android.xposed.XSharedPreferences
-
-object XPrefUtils {
-
-    fun getBoolean(key: String, default: Boolean = false) = pref.getBoolean(key, default)
-
-    private val pref: XSharedPreferences
-        get() {
-            val preferences = XSharedPreferences(BuildConfig.APPLICATION_ID)
-            preferences.makeWorldReadable()
-            preferences.reload()
-            return preferences
-        }
-}

app/src/main/java/com/fankes/miui/notify/utils/drawable/drawabletoolbox/Compatible.kt

@@ -1,291 +0,0 @@
-/*
- * Copyright (C) 2022. Fankes Studio(qzmmcn@163.com)
- *
- * This file is part of MIUINativeNotifyIcon.
- *
- * MIUINativeNotifyIcon is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * MIUINativeNotifyIcon is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * This file is Created by fankes on 2022/1/8.
- */
-@file:Suppress("SameParameterValue")
-
-package com.fankes.miui.notify.utils.drawable.drawabletoolbox
-
-import android.annotation.SuppressLint
-import android.graphics.drawable.Drawable
-import android.graphics.drawable.GradientDrawable
-import android.graphics.drawable.RippleDrawable
-import android.graphics.drawable.RotateDrawable
-import android.os.Build
-import java.lang.reflect.Field
-import java.lang.reflect.Method
-
-private val gradientState = resolveGradientState()
-
-private fun resolveGradientState(): Class<*> {
-    val classes = GradientDrawable::class.java.declaredClasses
-    for (singleClass in classes) {
-        if (singleClass.simpleName == "GradientState") return singleClass
-    }
-    throw RuntimeException("GradientState could not be found in thisAny GradientDrawable implementation")
-}
-
-private val rotateState = resolveRotateState()
-
-private fun resolveRotateState(): Class<*> {
-    val classes = RotateDrawable::class.java.declaredClasses
-    for (singleClass in classes) {
-        if (singleClass.simpleName == "RotateState") return singleClass
-    }
-    throw RuntimeException("RotateState could not be found in thisAny RotateDrawable implementation")
-}
-
-@Throws(SecurityException::class, NoSuchFieldException::class)
-private fun resolveField(source: Class<*>, fieldName: String): Field {
-    val field = source.getDeclaredField(fieldName)
-    field.isAccessible = true
-    return field
-}
-
-@Throws(SecurityException::class, NoSuchMethodException::class)
-private fun resolveMethod(
-    source: Class<*>,
-    methodName: String,
-    vararg parameterTypes: Class<*>
-): Method {
-    val method = source.getDeclaredMethod(methodName, *parameterTypes)
-    method.isAccessible = true
-    return method
-}
-
-fun setInnerRadius(drawable: GradientDrawable, value: Int) {
-    try {
-        val innerRadius = resolveField(gradientState, "mInnerRadius")
-        innerRadius.setInt(drawable.constantState, value)
-    } catch (e: NoSuchFieldException) {
-        e.printStackTrace()
-    } catch (e: IllegalAccessException) {
-        e.printStackTrace()
-    }
-}
-
-fun setInnerRadiusRatio(drawable: GradientDrawable, value: Float) {
-    try {
-        val innerRadius = resolveField(gradientState, "mInnerRadiusRatio")
-        innerRadius.setFloat(drawable.constantState, value)
-    } catch (e: NoSuchFieldException) {
-        e.printStackTrace()
-    } catch (e: IllegalAccessException) {
-        e.printStackTrace()
-    }
-}
-
-fun setThickness(drawable: GradientDrawable, value: Int) {
-    try {
-        val innerRadius = resolveField(gradientState, "mThickness")
-        innerRadius.setInt(drawable.constantState, value)
-    } catch (e: NoSuchFieldException) {
-        e.printStackTrace()
-    } catch (e: IllegalAccessException) {
-        e.printStackTrace()
-    }
-}
-
-fun setThicknessRatio(drawable: GradientDrawable, value: Float) {
-    try {
-        val innerRadius = resolveField(gradientState, "mThicknessRatio")
-        innerRadius.setFloat(drawable.constantState, value)
-    } catch (e: NoSuchFieldException) {
-        e.printStackTrace()
-    } catch (e: IllegalAccessException) {
-        e.printStackTrace()
-    }
-}
-
-fun setUseLevelForShape(drawable: GradientDrawable, value: Boolean) {
-    try {
-        val useLevelForShape = resolveField(gradientState, "mUseLevelForShape")
-        useLevelForShape.setBoolean(drawable.constantState, value)
-    } catch (e: NoSuchFieldException) {
-        e.printStackTrace()
-    } catch (e: IllegalAccessException) {
-        e.printStackTrace()
-    }
-}
-
-@SuppressLint("ObsoleteSdkInt")
-fun setOrientation(drawable: GradientDrawable, value: GradientDrawable.Orientation) {
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
-        drawable.orientation = value
-    } else {
-        try {
-            val orientation = resolveField(gradientState, "mOrientation")
-            orientation.set(drawable.constantState, value)
-            val rectIdDirty = resolveField(GradientDrawable::class.java, "mRectIsDirty")
-            rectIdDirty.setBoolean(drawable, true)
-            drawable.invalidateSelf()
-        } catch (e: NoSuchFieldException) {
-            e.printStackTrace()
-        } catch (e: IllegalAccessException) {
-            e.printStackTrace()
-        }
-    }
-}
-
-@SuppressLint("ObsoleteSdkInt")
-fun setColors(drawable: GradientDrawable, value: IntArray) {
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
-        drawable.colors = value
-    } else {
-        try {
-            val colors = resolveField(gradientState, "mColors")
-            colors.set(drawable.constantState, value)
-            drawable.invalidateSelf()
-        } catch (e: NoSuchFieldException) {
-            e.printStackTrace()
-        } catch (e: IllegalAccessException) {
-            e.printStackTrace()
-        }
-    }
-}
-
-fun setGradientRadiusType(drawable: GradientDrawable, value: Int) {
-    try {
-        val type = resolveField(gradientState, "mGradientRadiusType")
-        type.setInt(drawable.constantState, value)
-    } catch (e: NoSuchFieldException) {
-        e.printStackTrace()
-    } catch (e: IllegalAccessException) {
-        e.printStackTrace()
-    }
-}
-
-fun setGradientRadius(drawable: GradientDrawable, value: Float) {
-    try {
-        val gradientRadius = resolveField(gradientState, "mGradientRadius")
-        gradientRadius.setFloat(drawable.constantState, value)
-    } catch (e: NoSuchFieldException) {
-        e.printStackTrace()
-    } catch (e: IllegalAccessException) {
-        e.printStackTrace()
-    }
-}
-
-fun setStrokeColor(drawable: GradientDrawable, value: Int) {
-    try {
-        val type = resolveField(gradientState, "mStrokeColor")
-        type.setInt(drawable.constantState, value)
-    } catch (e: NoSuchFieldException) {
-        e.printStackTrace()
-    } catch (e: IllegalAccessException) {
-        e.printStackTrace()
-    }
-}
-
-fun setDrawable(rotateDrawable: RotateDrawable, drawable: Drawable) {
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
-        rotateDrawable.drawable = drawable
-    } else {
-        try {
-            val drawableField = resolveField(rotateState, "mDrawable")
-            val stateField = resolveField(RotateDrawable::class.java, "mState")
-            drawableField.set(stateField.get(rotateDrawable), drawable)
-            drawable.callback = rotateDrawable
-        } catch (e: NoSuchFieldException) {
-            e.printStackTrace()
-        } catch (e: IllegalAccessException) {
-            e.printStackTrace()
-        }
-    }
-}
-
-fun setPivotX(rotateDrawable: RotateDrawable, value: Float) {
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
-        rotateDrawable.pivotX = value
-    } else {
-        try {
-            val pivotXField = resolveField(rotateState, "mPivotX")
-            pivotXField.setFloat(rotateDrawable.constantState, value)
-            val pivotXRelField = resolveField(rotateState, "mPivotXRel")
-            pivotXRelField.setBoolean(rotateDrawable.constantState, true)
-        } catch (e: NoSuchFieldException) {
-            e.printStackTrace()
-        } catch (e: IllegalAccessException) {
-            e.printStackTrace()
-        }
-    }
-}
-
-fun setPivotY(rotateDrawable: RotateDrawable, value: Float) {
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
-        rotateDrawable.pivotY = value
-    } else {
-        try {
-            val pivotYField = resolveField(rotateState, "mPivotY")
-            pivotYField.setFloat(rotateDrawable.constantState, value)
-            val pivotYRelField = resolveField(rotateState, "mPivotYRel")
-            pivotYRelField.setBoolean(rotateDrawable.constantState, true)
-        } catch (e: NoSuchFieldException) {
-            e.printStackTrace()
-        } catch (e: IllegalAccessException) {
-            e.printStackTrace()
-        }
-    }
-}
-
-fun setFromDegrees(rotateDrawable: RotateDrawable, value: Float) {
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
-        rotateDrawable.fromDegrees = value
-    } else {
-        try {
-            val fromDegreesField = resolveField(rotateState, "mFromDegrees")
-            fromDegreesField.setFloat(rotateDrawable.constantState, value)
-        } catch (e: NoSuchFieldException) {
-            e.printStackTrace()
-        } catch (e: IllegalAccessException) {
-            e.printStackTrace()
-        }
-    }
-}
-
-fun setToDegrees(rotateDrawable: RotateDrawable, value: Float) {
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
-        rotateDrawable.toDegrees = value
-    } else {
-        try {
-            val toDegreesField = resolveField(rotateState, "mToDegrees")
-            toDegreesField.setFloat(rotateDrawable.constantState, value)
-        } catch (e: NoSuchFieldException) {
-            e.printStackTrace()
-        } catch (e: IllegalAccessException) {
-            e.printStackTrace()
-        }
-    }
-}
-
-fun setRadius(rippleDrawable: RippleDrawable, value: Int) {
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-        rippleDrawable.radius = value
-    } else {
-        try {
-            val setRadiusMethod =
-                resolveMethod(RippleDrawable::class.java, "setMaxRadius", Int::class.java)
-            setRadiusMethod.invoke(rippleDrawable, value)
-        } catch (e: NoSuchFieldException) {
-            e.printStackTrace()
-        } catch (e: IllegalAccessException) {
-            e.printStackTrace()
-        }
-    }
-}

app/src/main/java/com/fankes/miui/notify/utils/drawable/drawabletoolbox/Constants.kt

@@ -1,29 +0,0 @@
-/*
- * Copyright (C) 2022. Fankes Studio(qzmmcn@163.com)
- *
- * This file is part of MIUINativeNotifyIcon.
- *
- * MIUINativeNotifyIcon is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * MIUINativeNotifyIcon is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * This file is Created by fankes on 2022/1/8.
- */
-
-package com.fankes.miui.notify.utils.drawable.drawabletoolbox
-
-class Constants {
-
-    companion object {
-        const val DEFAULT_COLOR = 0xFFBA68C8.toInt()
-    }
-}

app/src/main/java/com/fankes/miui/notify/utils/drawable/drawabletoolbox/DrawableBuilder.kt

@@ -1,488 +0,0 @@
-/*
- * Copyright (C) 2022. Fankes Studio(qzmmcn@163.com)
- *
- * This file is part of MIUINativeNotifyIcon.
- *
- * MIUINativeNotifyIcon is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * MIUINativeNotifyIcon is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * This file is Created by fankes on 2022/1/8.
- */
-@file:Suppress("unused", "MemberVisibilityCanBePrivate")
-
-package com.fankes.miui.notify.utils.drawable.drawabletoolbox
-
-import android.content.res.ColorStateList
-import android.graphics.drawable.Drawable
-import android.graphics.drawable.GradientDrawable
-import android.util.StateSet
-import java.util.*
-import java.util.concurrent.atomic.AtomicInteger
-
-class DrawableBuilder {
-
-    private var properties = DrawableProperties()
-    private var order: AtomicInteger = AtomicInteger(1)
-    private var transformsMap = TreeMap<Int, (Drawable) -> Drawable>()
-    private var baseDrawable: Drawable? = null
-
-    fun batch(properties: DrawableProperties) = apply { this.properties = properties.copy() }
-    fun baseDrawable(drawable: Drawable) = apply { baseDrawable = drawable }
-
-    // <shape>
-    fun shape(shape: Int) = apply { properties.shape = shape }
-
-    fun rectangle() = apply { shape(GradientDrawable.RECTANGLE) }
-    fun oval() = apply { shape(GradientDrawable.OVAL) }
-    fun line() = apply { shape(GradientDrawable.LINE) }
-    fun ring() = apply { shape(GradientDrawable.RING) }
-    fun innerRadius(innerRadius: Int) = apply { properties.innerRadius = innerRadius }
-    fun innerRadiusRatio(innerRadiusRatio: Float) =
-        apply { properties.innerRadiusRatio = innerRadiusRatio }
-
-    fun thickness(thickness: Int) = apply { properties.thickness = thickness }
-    fun thicknessRatio(thicknessRatio: Float) = apply { properties.thicknessRatio = thicknessRatio }
-
-    fun useLevelForRing(use: Boolean = true) = apply { properties.useLevelForRing = use }
-
-    // <corner>
-    fun cornerRadius(cornerRadius: Int) = apply { properties.cornerRadius = cornerRadius }
-
-    fun topLeftRadius(topLeftRadius: Int) = apply { properties.topLeftRadius = topLeftRadius }
-    fun topRightRadius(topRightRadius: Int) = apply { properties.topRightRadius = topRightRadius }
-    fun bottomRightRadius(bottomRightRadius: Int) =
-        apply { properties.bottomRightRadius = bottomRightRadius }
-
-    fun bottomLeftRadius(bottomLeftRadius: Int) =
-        apply { properties.bottomLeftRadius = bottomLeftRadius }
-
-    fun rounded() = apply { cornerRadius(Int.MAX_VALUE) }
-    fun cornerRadii(
-        topLeftRadius: Int,
-        topRightRadius: Int,
-        bottomRightRadius: Int,
-        bottomLeftRadius: Int
-    ) = apply {
-        topLeftRadius(topLeftRadius); topRightRadius(topRightRadius); bottomRightRadius(
-        bottomRightRadius
-    ); bottomLeftRadius(bottomLeftRadius)
-    }
-
-    // <gradient>
-
-    fun gradient(useGradient: Boolean = true) = apply { properties.useGradient = useGradient }
-
-    fun gradientType(type: Int) = apply { properties.type = type }
-    fun linearGradient() = apply { gradientType(GradientDrawable.LINEAR_GRADIENT) }
-    fun radialGradient() = apply { gradientType(GradientDrawable.RADIAL_GRADIENT) }
-    fun sweepGradient() = apply { gradientType(GradientDrawable.SWEEP_GRADIENT) }
-    fun angle(angle: Int) = apply { properties.angle = angle }
-    fun centerX(centerX: Float) = apply { properties.centerX = centerX }
-    fun centerY(centerY: Float) = apply { properties.centerY = centerY }
-    fun center(centerX: Float, centerY: Float) = apply { centerX(centerX); centerY(centerY) }
-
-    fun useCenterColor(useCenterColor: Boolean = true) =
-        apply { properties.useCenterColor = useCenterColor }
-
-    fun startColor(startColor: Int) = apply { properties.startColor = startColor }
-    fun centerColor(centerColor: Int) = apply {
-        properties.centerColor = centerColor
-        useCenterColor(true)
-    }
-
-    fun endColor(endColor: Int) = apply { properties.endColor = endColor }
-    fun gradientColors(startColor: Int, endColor: Int, centerColor: Int?) = apply {
-        startColor(startColor); endColor(endColor)
-        useCenterColor(centerColor != null)
-        centerColor?.let {
-            centerColor(it)
-        }
-    }
-
-    fun gradientRadiusType(gradientRadiusType: Int) =
-        apply { properties.gradientRadiusType = gradientRadiusType }
-
-    fun gradientRadius(gradientRadius: Float) = apply { properties.gradientRadius = gradientRadius }
-    fun gradientRadius(radius: Float, type: Int) =
-        apply { gradientRadius(radius); gradientRadiusType(type) }
-
-    fun gradientRadiusInPixel(radius: Float) =
-        apply { gradientRadius(radius); gradientRadiusType(DrawableProperties.RADIUS_TYPE_PIXELS) }
-
-    fun gradientRadiusInFraction(radius: Float) =
-        apply { gradientRadius(radius); gradientRadiusType(DrawableProperties.RADIUS_TYPE_FRACTION) }
-
-    fun useLevelForGradient(use: Boolean) = apply { properties.useLevelForGradient = use }
-    fun useLevelForGradient() = apply { useLevelForGradient(true) }
-
-    // <size>
-    fun width(width: Int) = apply { properties.width = width }
-
-    fun height(height: Int) = apply { properties.height = height }
-    fun size(width: Int, height: Int) = apply { width(width); height(height) }
-    fun size(size: Int) = apply { width(size).height(size) }
-
-    // <solid>
-    fun solidColor(solidColor: Int) = apply { properties.solidColor = solidColor }
-
-    private var solidColorPressed: Int? = null
-    fun solidColorPressed(color: Int?) = apply { solidColorPressed = color }
-    private var solidColorPressedWhenRippleUnsupported: Int? = null
-    fun solidColorPressedWhenRippleUnsupported(color: Int?) =
-        apply { solidColorPressedWhenRippleUnsupported = color }
-
-    private var solidColorDisabled: Int? = null
-    fun solidColorDisabled(color: Int?) = apply { solidColorDisabled = color }
-    private var solidColorSelected: Int? = null
-    fun solidColorSelected(color: Int?) = apply { solidColorSelected = color }
-    fun solidColorStateList(colorStateList: ColorStateList) =
-        apply { properties.solidColorStateList = colorStateList }
-
-    // <stroke>
-    fun strokeWidth(strokeWidth: Int) = apply { properties.strokeWidth = strokeWidth }
-
-    fun strokeColor(strokeColor: Int) = apply { properties.strokeColor = strokeColor }
-    private var strokeColorPressed: Int? = null
-    fun strokeColorPressed(color: Int?) = apply { strokeColorPressed = color }
-    private var strokeColorDisabled: Int? = null
-    fun strokeColorDisabled(color: Int?) = apply { strokeColorDisabled = color }
-    private var strokeColorSelected: Int? = null
-    fun strokeColorSelected(color: Int?) = apply { strokeColorSelected = color }
-    fun strokeColorStateList(colorStateList: ColorStateList) =
-        apply { properties.strokeColorStateList = colorStateList }
-
-    fun dashWidth(dashWidth: Int) = apply { properties.dashWidth = dashWidth }
-    fun dashGap(dashGap: Int) = apply { properties.dashGap = dashGap }
-    fun hairlineBordered() = apply { strokeWidth(1) }
-    fun shortDashed() = apply { dashWidth(12).dashGap(12) }
-    fun mediumDashed() = apply { dashWidth(24).dashGap(24) }
-    fun longDashed() = apply { dashWidth(36).dashGap(36) }
-    fun dashed() = apply { mediumDashed() }
-
-    // <rotate>
-    private var rotateOrder = 0
-
-
-    fun rotate(boolean: Boolean = true) = apply {
-        properties.useRotate = boolean
-        rotateOrder = if (boolean) {
-            order.getAndIncrement()
-        } else {
-            0
-        }
-    }
-
-    fun pivotX(pivotX: Float) = apply { properties.pivotX = pivotX }
-    fun pivotY(pivotY: Float) = apply { properties.pivotY = pivotY }
-    fun pivot(pivotX: Float, pivotY: Float) = apply { pivotX(pivotX).pivotY(pivotY) }
-    fun fromDegrees(degrees: Float) = apply { properties.fromDegrees = degrees }
-    fun toDegrees(degrees: Float) = apply { properties.toDegrees = degrees }
-    fun degrees(fromDegrees: Float, toDegrees: Float) =
-        apply { fromDegrees(fromDegrees).toDegrees(toDegrees) }
-
-    fun degrees(degrees: Float) = apply { fromDegrees(degrees).toDegrees(degrees) }
-    fun rotate(fromDegrees: Float, toDegrees: Float) =
-        apply { rotate().fromDegrees(fromDegrees).toDegrees(toDegrees) }
-
-    fun rotate(degrees: Float) = apply { rotate().degrees(degrees) }
-
-    // <scale>
-    private var scaleOrder = 0
-
-
-    fun scale(boolean: Boolean = true) = apply {
-        properties.useScale = boolean
-        scaleOrder = if (boolean) {
-            order.getAndIncrement()
-        } else {
-            0
-        }
-    }
-
-    fun scaleLevel(level: Int) = apply { properties.scaleLevel = level }
-    fun scaleGravity(gravity: Int) = apply { properties.scaleGravity = gravity }
-    fun scaleWidth(scale: Float) = apply { properties.scaleWidth = scale }
-    fun scaleHeight(scale: Float) = apply { properties.scaleHeight = scale }
-    fun scale(scale: Float) = apply { scale().scaleWidth(scale).scaleHeight(scale) }
-    fun scale(scaleWidth: Float, scaleHeight: Float) =
-        apply { scale().scaleWidth(scaleWidth).scaleHeight(scaleHeight) }
-
-    // flip
-
-    fun flip(boolean: Boolean = true) = apply { properties.useFlip = boolean }
-
-    fun orientation(orientation: Int) = apply { properties.orientation = orientation }
-    fun flipVertical() = apply { flip().orientation(FlipDrawable.ORIENTATION_VERTICAL) }
-
-    // <ripple>
-
-    fun ripple(boolean: Boolean = true) = apply { properties.useRipple = boolean }
-
-    fun rippleColor(color: Int) = apply { properties.rippleColor = color }
-    fun rippleColorStateList(colorStateList: ColorStateList) =
-        apply { properties.rippleColorStateList = colorStateList }
-
-    fun rippleRadius(radius: Int) = apply { properties.rippleRadius = radius }
-
-    fun build(): Drawable {
-        if (baseDrawable != null) {
-            return wrap(baseDrawable!!)
-        }
-
-        var drawable: Drawable
-
-        // fall back when ripple is unavailable on devices with API < 21
-        if (shouldFallbackRipple()) {
-            if (solidColorPressedWhenRippleUnsupported != null) {
-                solidColorPressed(solidColorPressedWhenRippleUnsupported)
-            } else {
-                solidColorPressed(properties.rippleColor)
-            }
-        }
-
-        if (needStateListDrawable()) {
-            drawable = StateListDrawableBuilder()
-                .pressed(buildPressedDrawable())
-                .disabled(buildDisabledDrawable())
-                .selected(buildSelectedDrawable())
-                .normal(buildNormalDrawable())
-                .build()
-        } else {
-            drawable = GradientDrawable()
-            setupGradientDrawable(drawable)
-        }
-        drawable = wrap(drawable)
-        return drawable
-    }
-
-    private fun getSolidColorStateList(): ColorStateList {
-        if (properties.solidColorStateList != null) {
-            return properties.solidColorStateList!!
-        }
-
-        val states = mutableListOf<IntArray>()
-        val colors = mutableListOf<Int>()
-
-        solidColorPressed?.let {
-            states.add(intArrayOf(android.R.attr.state_pressed))
-            colors.add(it)
-        }
-        solidColorDisabled?.let {
-            states.add(intArrayOf(-android.R.attr.state_enabled))
-            colors.add(it)
-        }
-        solidColorSelected?.let {
-            states.add(intArrayOf(android.R.attr.state_selected))
-            colors.add(it)
-        }
-        states.add(StateSet.WILD_CARD)
-        colors.add(properties.solidColor)
-
-        return ColorStateList(states.toTypedArray(), colors.toIntArray())
-    }
-
-    private fun getStrokeColorStateList(): ColorStateList {
-        if (properties.strokeColorStateList != null) {
-            return properties.strokeColorStateList!!
-        }
-
-        val states = mutableListOf<IntArray>()
-        val colors = mutableListOf<Int>()
-
-        strokeColorPressed?.let {
-            states.add(intArrayOf(android.R.attr.state_pressed))
-            colors.add(it)
-        }
-        strokeColorDisabled?.let {
-            states.add(intArrayOf(-android.R.attr.state_enabled))
-            colors.add(it)
-        }
-        strokeColorSelected?.let {
-            states.add(intArrayOf(android.R.attr.state_selected))
-            colors.add(it)
-        }
-        states.add(StateSet.WILD_CARD)
-        colors.add(properties.strokeColor)
-
-        return ColorStateList(states.toTypedArray(), colors.toIntArray())
-    }
-
-    private fun buildPressedDrawable(): Drawable? {
-        if (solidColorPressed == null && strokeColorPressed == null) return null
-
-        val pressedDrawable = GradientDrawable()
-        setupGradientDrawable(pressedDrawable)
-        solidColorPressed?.let {
-            pressedDrawable.setColor(it)
-        }
-        strokeColorPressed?.let {
-            setStrokeColor(pressedDrawable, it)
-        }
-        return pressedDrawable
-    }
-
-    private fun buildDisabledDrawable(): Drawable? {
-        if (solidColorDisabled == null && strokeColorDisabled == null) return null
-
-        val disabledDrawable = GradientDrawable()
-        setupGradientDrawable(disabledDrawable)
-        solidColorDisabled?.let {
-            disabledDrawable.setColor(it)
-        }
-        strokeColorDisabled?.let {
-            setStrokeColor(disabledDrawable, it)
-        }
-        return disabledDrawable
-    }
-
-    private fun buildSelectedDrawable(): Drawable? {
-        if (solidColorSelected == null && strokeColorSelected == null) return null
-
-        val selectedDrawable = GradientDrawable()
-        setupGradientDrawable(selectedDrawable)
-        solidColorSelected?.let {
-            selectedDrawable.setColor(it)
-        }
-        strokeColorSelected?.let {
-            setStrokeColor(selectedDrawable, it)
-        }
-        return selectedDrawable
-    }
-
-    private fun buildNormalDrawable(): Drawable {
-        val pressedDrawable = GradientDrawable()
-        setupGradientDrawable(pressedDrawable)
-        return pressedDrawable
-    }
-
-    private fun setupGradientDrawable(drawable: GradientDrawable) {
-        properties.apply {
-            drawable.shape = shape
-            if (shape == GradientDrawable.RING) {
-                setInnerRadius(drawable, innerRadius)
-                setInnerRadiusRatio(drawable, innerRadiusRatio)
-                setThickness(drawable, thickness)
-                setThicknessRatio(drawable, thicknessRatio)
-                setUseLevelForShape(drawable, useLevelForRing)
-            }
-            drawable.cornerRadii = getCornerRadii()
-            if (useGradient) {
-                drawable.gradientType = type
-                setGradientRadiusType(drawable, gradientRadiusType)
-                setGradientRadius(drawable, gradientRadius)
-                drawable.setGradientCenter(centerX, centerY)
-                setOrientation(drawable, getOrientation())
-                setColors(drawable, getColors())
-                drawable.useLevel = useLevelForGradient
-            } else {
-                drawable.color = getSolidColorStateList()
-            }
-            drawable.setSize(width, height)
-            drawable.setStroke(
-                strokeWidth,
-                getStrokeColorStateList(),
-                dashWidth.toFloat(),
-                dashGap.toFloat()
-            )
-        }
-    }
-
-    private fun needStateListDrawable(): Boolean {
-        return (hasStrokeColorStateList() || (!properties.useGradient && hasSolidColorStateList()))
-    }
-
-    private fun needRotateDrawable(): Boolean {
-        return properties.useRotate &&
-                !(properties.pivotX == 0.5f && properties.pivotY == 0.5f
-                        && properties.fromDegrees == 0f && properties.toDegrees == 0f)
-    }
-
-    private fun needScaleDrawable(): Boolean {
-        return properties.useScale
-    }
-
-    private fun wrap(drawable: Drawable): Drawable {
-        var wrappedDrawable = drawable
-
-        if (rotateOrder > 0) {
-            transformsMap[rotateOrder] = ::wrapRotateIfNeeded
-        }
-        if (scaleOrder > 0) {
-            transformsMap[scaleOrder] = ::wrapScaleIfNeeded
-        }
-
-        for (action in transformsMap.values) {
-            wrappedDrawable = action.invoke(wrappedDrawable)
-        }
-
-        if (properties.useFlip) {
-            wrappedDrawable = FlipDrawableBuilder()
-                .drawable(wrappedDrawable)
-                .orientation(properties.orientation)
-                .build()
-        }
-
-        if (isRippleSupported() && properties.useRipple) {
-            wrappedDrawable = RippleDrawableBuilder()
-                .drawable(wrappedDrawable)
-                .color(properties.rippleColor)
-                .colorStateList(properties.rippleColorStateList)
-                .radius(properties.rippleRadius)
-                .build()
-        }
-
-        return wrappedDrawable
-    }
-
-    private fun shouldFallbackRipple(): Boolean {
-        return properties.useRipple && !isRippleSupported()
-    }
-
-    private fun isRippleSupported() = true
-
-    private fun wrapRotateIfNeeded(drawable: Drawable): Drawable {
-        if (!needRotateDrawable()) return drawable
-
-        with(properties) {
-            return RotateDrawableBuilder()
-                .drawable(drawable)
-                .pivotX(pivotX)
-                .pivotY(pivotY)
-                .fromDegrees(fromDegrees)
-                .toDegrees(toDegrees)
-                .build()
-        }
-    }
-
-    private fun wrapScaleIfNeeded(drawable: Drawable): Drawable {
-        if (!needScaleDrawable()) return drawable
-
-        with(properties) {
-            return ScaleDrawableBuilder()
-                .drawable(drawable)
-                .level(scaleLevel)
-                .scaleGravity(scaleGravity)
-                .scaleWidth(scaleWidth)
-                .scaleHeight(scaleHeight)
-                .build()
-        }
-    }
-
-    private fun hasSolidColorStateList(): Boolean {
-        return solidColorPressed != null || solidColorDisabled != null || solidColorSelected != null
-    }
-
-    private fun hasStrokeColorStateList(): Boolean {
-        return strokeColorPressed != null || strokeColorDisabled != null || strokeColorSelected != null
-    }
-}

app/src/main/java/com/fankes/miui/notify/utils/drawable/drawabletoolbox/DrawableProperties.kt

@@ -1,220 +0,0 @@
-/*
- * Copyright (C) 2022. Fankes Studio(qzmmcn@163.com)
- *
- * This file is part of MIUINativeNotifyIcon.
- *
- * MIUINativeNotifyIcon is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * MIUINativeNotifyIcon is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * This file is Created by fankes on 2022/1/8.
- */
-@file:Suppress("SetterBackingFieldAssignment", "unused")
-
-package com.fankes.miui.notify.utils.drawable.drawabletoolbox
-
-import android.content.res.ColorStateList
-import android.graphics.Color
-import android.graphics.drawable.Drawable
-import android.graphics.drawable.GradientDrawable
-import android.os.Parcel
-import android.os.Parcelable
-import android.view.Gravity
-import java.io.Serializable
-
-data class DrawableProperties(
-
-    // <shape>
-    @JvmField var shape: Int = GradientDrawable.RECTANGLE,
-    @JvmField var innerRadius: Int = -1,
-    @JvmField var innerRadiusRatio: Float = 9f,
-    @JvmField var thickness: Int = -1,
-    @JvmField var thicknessRatio: Float = 3f,
-    @JvmField var useLevelForRing: Boolean = false,
-
-    // <corner>
-    private var _cornerRadius: Int = 0,
-    @JvmField var topLeftRadius: Int = 0,
-    @JvmField var topRightRadius: Int = 0,
-    @JvmField var bottomRightRadius: Int = 0,
-    @JvmField var bottomLeftRadius: Int = 0,
-
-    // <gradient>
-    @JvmField var useGradient: Boolean = false,
-    @JvmField var type: Int = GradientDrawable.RADIAL_GRADIENT,
-    @JvmField var angle: Int = 0,
-    @JvmField var centerX: Float = 0.5f,
-    @JvmField var centerY: Float = 0.5f,
-    @JvmField var useCenterColor: Boolean = false,
-    @JvmField var startColor: Int = Constants.DEFAULT_COLOR,
-    @JvmField var centerColor: Int? = null,
-    @JvmField var endColor: Int = 0x7FFFFFFF,
-    @JvmField var gradientRadiusType: Int = RADIUS_TYPE_FRACTION,
-    @JvmField var gradientRadius: Float = 0.5f,
-    @JvmField var useLevelForGradient: Boolean = false,
-
-    // <size>
-    @JvmField var width: Int = -1,
-    @JvmField var height: Int = -1,
-
-    // <solid>
-    @JvmField var solidColor: Int = Color.TRANSPARENT,
-    @JvmField var solidColorStateList: ColorStateList? = null,
-
-    // <stroke>
-    @JvmField var strokeWidth: Int = 0,
-    @JvmField var strokeColor: Int = Color.DKGRAY,
-    @JvmField var strokeColorStateList: ColorStateList? = null,
-    @JvmField var dashWidth: Int = 0,
-    @JvmField var dashGap: Int = 0,
-
-    // <rotate>
-    @JvmField var useRotate: Boolean = false,
-    @JvmField var pivotX: Float = 0.5f,
-    @JvmField var pivotY: Float = 0.5f,
-    @JvmField var fromDegrees: Float = 0f,
-    @JvmField var toDegrees: Float = 0f,
-
-    // <scale>
-    @JvmField var useScale: Boolean = false,
-    @JvmField var scaleLevel: Int = 10000,
-    @JvmField var scaleGravity: Int = Gravity.CENTER,
-    @JvmField var scaleWidth: Float = 0f,
-    @JvmField var scaleHeight: Float = 0f,
-
-    // flip
-    @JvmField var useFlip: Boolean = false,
-    @JvmField var orientation: Int = FlipDrawable.ORIENTATION_HORIZONTAL,
-
-    // ripple
-    @JvmField var useRipple: Boolean = false,
-    @JvmField var rippleColor: Int = Constants.DEFAULT_COLOR,
-    @JvmField var rippleColorStateList: ColorStateList? = null,
-    @JvmField var rippleRadius: Int = -1
-) : Serializable {
-
-    companion object {
-        const val RADIUS_TYPE_PIXELS = 0
-        const val RADIUS_TYPE_FRACTION = 1
-
-        @JvmField
-        val CREATOR = object : Parcelable.Creator<DrawableProperties> {
-            override fun createFromParcel(parcel: Parcel): DrawableProperties {
-                return DrawableProperties(parcel)
-            }
-
-            override fun newArray(size: Int): Array<DrawableProperties?> {
-                return arrayOfNulls(size)
-            }
-        }
-    }
-
-    var cornerRadius: Int = _cornerRadius
-        set(value) {
-            _cornerRadius = value
-            topLeftRadius = value
-            topRightRadius = value
-            bottomRightRadius = value
-            bottomLeftRadius = value
-        }
-
-    constructor(parcel: Parcel) : this(
-        parcel.readInt(),
-        parcel.readInt(),
-        parcel.readFloat(),
-        parcel.readInt(),
-        parcel.readFloat(),
-        parcel.readByte() != 0.toByte(),
-        parcel.readInt(),
-        parcel.readInt(),
-        parcel.readInt(),
-        parcel.readInt(),
-        parcel.readInt(),
-        parcel.readByte() != 0.toByte(),
-        parcel.readInt(),
-        parcel.readInt(),
-        parcel.readFloat(),
-        parcel.readFloat(),
-        parcel.readByte() != 0.toByte(),
-        parcel.readInt(),
-        parcel.readValue(Int::class.java.classLoader) as? Int,
-        parcel.readInt(),
-        parcel.readInt(),
-        parcel.readFloat(),
-        parcel.readByte() != 0.toByte(),
-        parcel.readInt(),
-        parcel.readInt(),
-        parcel.readInt(),
-        parcel.readParcelable(ColorStateList::class.java.classLoader),
-        parcel.readInt(),
-        parcel.readInt(),
-        parcel.readParcelable(ColorStateList::class.java.classLoader),
-        parcel.readInt(),
-        parcel.readInt(),
-        parcel.readByte() != 0.toByte(),
-        parcel.readFloat(),
-        parcel.readFloat(),
-        parcel.readFloat(),
-        parcel.readFloat(),
-        parcel.readByte() != 0.toByte(),
-        parcel.readInt(),
-        parcel.readInt(),
-        parcel.readFloat(),
-        parcel.readFloat(),
-        parcel.readByte() != 0.toByte(),
-        parcel.readInt(),
-        parcel.readByte() != 0.toByte(),
-        parcel.readInt(),
-        parcel.readParcelable(ColorStateList::class.java.classLoader),
-        parcel.readInt()
-    )
-
-    fun copy(): DrawableProperties {
-        val parcel = Parcel.obtain()
-        parcel.setDataPosition(0)
-        val properties = CREATOR.createFromParcel(parcel)
-        parcel.recycle()
-        return properties
-    }
-
-    fun getCornerRadii(): FloatArray {
-        return floatArrayOf(
-            topLeftRadius.toFloat(), topLeftRadius.toFloat(),
-            topRightRadius.toFloat(), topRightRadius.toFloat(),
-            bottomRightRadius.toFloat(), bottomRightRadius.toFloat(),
-            bottomLeftRadius.toFloat(), bottomLeftRadius.toFloat()
-        )
-    }
-
-    fun getOrientation(): GradientDrawable.Orientation {
-        val orientation: GradientDrawable.Orientation = when (val angle = this.angle % 360) {
-            0 -> GradientDrawable.Orientation.LEFT_RIGHT
-            45 -> GradientDrawable.Orientation.BL_TR
-            90 -> GradientDrawable.Orientation.BOTTOM_TOP
-            135 -> GradientDrawable.Orientation.BR_TL
-            180 -> GradientDrawable.Orientation.RIGHT_LEFT
-            225 -> GradientDrawable.Orientation.TR_BL
-            270 -> GradientDrawable.Orientation.TOP_BOTTOM
-            315 -> GradientDrawable.Orientation.TL_BR
-            else -> throw IllegalArgumentException("Unsupported angle: $angle")
-        }
-        return orientation
-    }
-
-    fun getColors(): IntArray {
-        return if (useCenterColor && centerColor != null) {
-            intArrayOf(startColor, centerColor!!, endColor)
-        } else intArrayOf(startColor, endColor)
-    }
-
-    fun materialization(): Drawable = DrawableBuilder().batch(this).build()
-}

app/src/main/java/com/fankes/miui/notify/utils/drawable/drawabletoolbox/DrawableWrapperBuilder.kt

@@ -1,33 +0,0 @@
-/*
- * Copyright (C) 2022. Fankes Studio(qzmmcn@163.com)
- *
- * This file is part of MIUINativeNotifyIcon.
- *
- * MIUINativeNotifyIcon is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * MIUINativeNotifyIcon is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * This file is Created by fankes on 2022/1/8.
- */
-package com.fankes.miui.notify.utils.drawable.drawabletoolbox
-
-import android.graphics.drawable.Drawable
-
-abstract class DrawableWrapperBuilder<T: DrawableWrapperBuilder<T>> {
-
-    protected var drawable: Drawable? = null
-
-    @Suppress("UNCHECKED_CAST")
-    fun drawable(drawable: Drawable): T = apply { this.drawable = drawable } as T
-
-    abstract fun build(): Drawable
-}

app/src/main/java/com/fankes/miui/notify/utils/drawable/drawabletoolbox/FlipDrawable.kt

@@ -1,77 +0,0 @@
-/*
- * Copyright (C) 2022. Fankes Studio(qzmmcn@163.com)
- *
- * This file is part of MIUINativeNotifyIcon.
- *
- * MIUINativeNotifyIcon is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * MIUINativeNotifyIcon is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * This file is Created by fankes on 2022/1/8.
- */
-@file:Suppress("DEPRECATION", "CanvasSize")
-
-package com.fankes.miui.notify.utils.drawable.drawabletoolbox
-
-import android.graphics.Canvas
-import android.graphics.ColorFilter
-import android.graphics.Rect
-import android.graphics.drawable.Drawable
-
-class FlipDrawable(
-    private var drawable: Drawable,
-    private var orientation: Int = ORIENTATION_HORIZONTAL
-) : Drawable() {
-
-    companion object {
-        const val ORIENTATION_HORIZONTAL = 0
-        const val ORIENTATION_VERTICAL = 1
-    }
-
-    override fun draw(canvas: Canvas) {
-        val saveCount = canvas.save()
-        if (orientation == ORIENTATION_VERTICAL) {
-            canvas.scale(1f, -1f, (canvas.width / 2).toFloat(), (canvas.height / 2).toFloat())
-        } else {
-            canvas.scale(-1f, 1f, (canvas.width / 2).toFloat(), (canvas.height / 2).toFloat())
-        }
-        drawable.bounds = Rect(0, 0, canvas.width, canvas.height)
-        drawable.draw(canvas)
-        canvas.restoreToCount(saveCount)
-    }
-
-    override fun onLevelChange(level: Int): Boolean {
-        drawable.level = level
-        invalidateSelf()
-        return true
-    }
-
-    override fun getIntrinsicWidth(): Int {
-        return drawable.intrinsicWidth
-    }
-
-    override fun getIntrinsicHeight(): Int {
-        return drawable.intrinsicHeight
-    }
-
-    override fun setAlpha(alpha: Int) {
-        drawable.alpha = alpha
-    }
-
-    override fun getOpacity(): Int {
-        return drawable.opacity
-    }
-
-    override fun setColorFilter(colorFilter: ColorFilter?) {
-        drawable.colorFilter = colorFilter
-    }
-}

app/src/main/java/com/fankes/miui/notify/utils/drawable/drawabletoolbox/FlipDrawableBuilder.kt

@@ -1,34 +0,0 @@
-/*
- * Copyright (C) 2022. Fankes Studio(qzmmcn@163.com)
- *
- * This file is part of MIUINativeNotifyIcon.
- *
- * MIUINativeNotifyIcon is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * MIUINativeNotifyIcon is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * This file is Created by fankes on 2022/1/8.
- */
-package com.fankes.miui.notify.utils.drawable.drawabletoolbox
-
-import android.graphics.drawable.Drawable
-
-class FlipDrawableBuilder : DrawableWrapperBuilder<FlipDrawableBuilder>() {
-
-    private var orientation: Int = FlipDrawable.ORIENTATION_HORIZONTAL
-
-    fun orientation(orientation: Int) = apply { this.orientation = orientation }
-
-    override fun build(): Drawable {
-        return FlipDrawable(drawable!!, orientation)
-    }
-}

app/src/main/java/com/fankes/miui/notify/utils/drawable/drawabletoolbox/LayerDrawableBuilder.kt

@@ -1,181 +0,0 @@
-/*
- * Copyright (C) 2022. Fankes Studio(qzmmcn@163.com)
- *
- * This file is part of MIUINativeNotifyIcon.
- *
- * MIUINativeNotifyIcon is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * MIUINativeNotifyIcon is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * This file is Created by fankes on 2022/1/8.
- */
-package com.fankes.miui.notify.utils.drawable.drawabletoolbox
-
-import android.graphics.drawable.Drawable
-import android.graphics.drawable.LayerDrawable
-import android.os.Build
-import android.view.Gravity
-import androidx.annotation.RequiresApi
-import java.util.*
-
-class LayerDrawableBuilder {
-
-    companion object {
-        const val DIMEN_UNDEFINED = Int.MIN_VALUE
-    }
-
-    @RequiresApi(Build.VERSION_CODES.LOLLIPOP)
-    private var paddingMode = LayerDrawable.PADDING_MODE_NEST
-    private var paddingLeft = 0
-    private var paddingTop = 0
-    private var paddingRight = 0
-    private var paddingBottom = 0
-    private var paddingStart = 0
-    private var paddingEnd = 0
-    private val layers = ArrayList<Layer>()
-
-    @RequiresApi(Build.VERSION_CODES.LOLLIPOP)
-    fun paddingMode(mode: Int) = apply { paddingMode = mode }
-    fun paddingLeft(padding: Int) = apply { paddingLeft = padding }
-    fun paddingTop(padding: Int) = apply { paddingTop = padding }
-    fun paddingRight(padding: Int) = apply { paddingRight = padding }
-    fun paddingBottom(padding: Int) = apply { paddingBottom = padding }
-
-    @RequiresApi(Build.VERSION_CODES.M)
-    fun paddingStart(padding: Int) = apply { paddingStart = padding }
-
-    @RequiresApi(Build.VERSION_CODES.M)
-    fun paddingEnd(padding: Int) = apply { paddingEnd = padding }
-    fun padding(padding: Int) = apply {
-        paddingLeft(padding).paddingTop(padding).paddingRight(padding).paddingBottom(padding)
-    }
-
-    @RequiresApi(Build.VERSION_CODES.M)
-    fun paddingRelative(padding: Int) = apply {
-        paddingStart(padding).paddingTop(padding).paddingEnd(padding).paddingBottom(padding)
-    }
-
-    fun add(drawable: Drawable) = apply { layers.add(Layer(drawable)) }
-
-    fun width(width: Int) = apply { layers.last().width = width }
-    fun height(height: Int) = apply { layers.last().height = height }
-
-    fun insetLeft(inset: Int) = apply { layers.last().insetLeft = inset }
-    fun insetTop(inset: Int) = apply { layers.last().insetTop = inset }
-    fun insetRight(inset: Int) = apply { layers.last().insetRight = inset }
-    fun insetBottom(inset: Int) = apply { layers.last().insetBottom = inset }
-
-    @RequiresApi(Build.VERSION_CODES.M)
-    fun insetStart(inset: Int) = apply { layers.last().insetStart = inset }
-
-    @RequiresApi(Build.VERSION_CODES.M)
-    fun insetEnd(inset: Int) = apply { layers.last().insetEnd = inset }
-    fun inset(inset: Int) =
-        apply { insetLeft(inset).insetTop(inset).insetRight(inset).insetBottom(inset) }
-
-    fun inset(insetLeft: Int, insetTop: Int, insetRight: Int, insetBottom: Int) = apply {
-        insetLeft(insetLeft).insetTop(insetTop).insetRight(insetRight).insetBottom(insetBottom)
-    }
-
-    @RequiresApi(Build.VERSION_CODES.M)
-    fun insetRelative(inset: Int) =
-        apply { insetStart(inset).insetTop(inset).insetEnd(inset).insetBottom(inset) }
-
-    @RequiresApi(Build.VERSION_CODES.M)
-    fun insetRelative(insetStart: Int, insetTop: Int, insetEnd: Int, insetBottom: Int) = apply {
-        insetStart(insetStart).insetTop(insetTop).insetEnd(insetEnd).insetBottom(insetBottom)
-    }
-
-    @RequiresApi(Build.VERSION_CODES.M)
-    fun gravity(gravity: Int) = apply { layers.last().gravity = gravity }
-
-    fun modify(
-        index: Int, drawable: Drawable,
-        width: Int = DIMEN_UNDEFINED,
-        height: Int = DIMEN_UNDEFINED,
-        insetLeft: Int = DIMEN_UNDEFINED,
-        insetTop: Int = DIMEN_UNDEFINED,
-        insetRight: Int = DIMEN_UNDEFINED,
-        insetBottom: Int = DIMEN_UNDEFINED,
-        insetStart: Int = DIMEN_UNDEFINED,
-        insetEnd: Int = DIMEN_UNDEFINED
-    ) =
-        apply {
-            val layer = layers[index]
-            layer.drawable = drawable
-            if (width != DIMEN_UNDEFINED) layer.width = width
-            if (height != DIMEN_UNDEFINED) layer.height = height
-            if (insetLeft != DIMEN_UNDEFINED) layer.insetLeft = insetLeft
-            if (insetTop != DIMEN_UNDEFINED) layer.insetTop = insetTop
-            if (insetRight != DIMEN_UNDEFINED) layer.insetRight = insetRight
-            if (insetBottom != DIMEN_UNDEFINED) layer.insetBottom = insetBottom
-            if (insetStart != DIMEN_UNDEFINED) layer.insetStart = insetStart
-            if (insetEnd != DIMEN_UNDEFINED) layer.insetEnd = insetEnd
-        }
-
-    fun build(): LayerDrawable {
-        val layerDrawable = LayerDrawable(layers.map { it -> it.drawable }.toTypedArray())
-        for (i in 0 until layers.size) {
-            val layer = layers[i]
-            layerDrawable.setLayerInset(
-                i,
-                layer.insetLeft,
-                layer.insetTop,
-                layer.insetRight,
-                layer.insetBottom
-            )
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-                if (layer.insetStart != DIMEN_UNDEFINED || layer.insetEnd != DIMEN_UNDEFINED) {
-                    layerDrawable.setLayerInsetRelative(
-                        i,
-                        layer.insetStart,
-                        layer.insetTop,
-                        layer.insetEnd,
-                        layer.insetBottom
-                    )
-                }
-            }
-            layerDrawable.setId(i, i)
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-                layerDrawable.setLayerGravity(i, layer.gravity)
-                layerDrawable.setLayerInsetStart(i, layer.insetStart)
-                layerDrawable.setLayerInsetEnd(i, layer.insetEnd)
-            }
-        }
-        layerDrawable.paddingMode = paddingMode
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-            layerDrawable.setPadding(paddingLeft, paddingTop, paddingRight, paddingBottom)
-            if (paddingStart != DIMEN_UNDEFINED || paddingEnd != DIMEN_UNDEFINED) {
-                layerDrawable.setPaddingRelative(
-                    paddingStart,
-                    paddingTop,
-                    paddingEnd,
-                    paddingBottom
-                )
-            }
-        }
-
-        return layerDrawable
-    }
-
-    internal class Layer(var drawable: Drawable) {
-        var gravity: Int = Gravity.NO_GRAVITY
-        var width: Int = -1
-        var height: Int = -1
-        var insetLeft: Int = 0
-        var insetTop: Int = 0
-        var insetRight: Int = 0
-        var insetBottom: Int = 0
-        var insetStart: Int = DIMEN_UNDEFINED
-        var insetEnd: Int = DIMEN_UNDEFINED
-    }
-}

app/src/main/java/com/fankes/miui/notify/utils/drawable/drawabletoolbox/PathShapeDrawableBuilder.kt

@@ -1,60 +0,0 @@
-/*
- * Copyright (C) 2022. Fankes Studio(qzmmcn@163.com)
- *
- * This file is part of MIUINativeNotifyIcon.
- *
- * MIUINativeNotifyIcon is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * MIUINativeNotifyIcon is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * This file is Created by fankes on 2022/1/8.
- */
-package com.fankes.miui.notify.utils.drawable.drawabletoolbox
-
-import android.graphics.Path
-import android.graphics.drawable.ShapeDrawable
-import android.graphics.drawable.shapes.PathShape
-
-class PathShapeDrawableBuilder {
-
-    private var path: Path? = null
-    private var pathStandardWidth: Float = 100f
-    private var pathStandardHeight: Float = 100f
-    private var width: Int = -1
-    private var height: Int = -1
-
-    fun path(path: Path, pathStandardWidth: Float, pathStandardHeight: Float) = apply {
-        this.path = path
-        this.pathStandardWidth = pathStandardWidth
-        this.pathStandardHeight = pathStandardHeight
-    }
-
-    fun width(width: Int) = apply { this.width = width }
-    fun height(height: Int) = apply { this.height = height }
-    fun size(size: Int) = apply { width(size).height(size) }
-
-    fun build(custom: ((shapeDrawable: ShapeDrawable) -> Unit)? = null): ShapeDrawable {
-        val shapeDrawable = ShapeDrawable()
-        if (path == null || width <= 0 || height <= 0) {
-            return shapeDrawable
-        }
-        val pathShape = PathShape(path!!, pathStandardWidth, pathStandardHeight)
-
-        shapeDrawable.shape = pathShape
-        shapeDrawable.intrinsicWidth = width
-        shapeDrawable.intrinsicHeight = height
-        if (custom != null) {
-            custom(shapeDrawable)
-        }
-        return shapeDrawable
-    }
-}

app/src/main/java/com/fankes/miui/notify/utils/drawable/drawabletoolbox/RippleDrawableBuilder.kt

@@ -1,72 +0,0 @@
-/*
- * Copyright (C) 2022. Fankes Studio(qzmmcn@163.com)
- *
- * This file is part of MIUINativeNotifyIcon.
- *
- * MIUINativeNotifyIcon is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * MIUINativeNotifyIcon is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * This file is Created by fankes on 2022/1/8.
- */
-package com.fankes.miui.notify.utils.drawable.drawabletoolbox
-
-import android.content.res.ColorStateList
-import android.graphics.Color
-import android.graphics.drawable.*
-import android.util.StateSet
-
-class RippleDrawableBuilder : DrawableWrapperBuilder<RippleDrawableBuilder>() {
-
-    private var color: Int = Constants.DEFAULT_COLOR
-    private var colorStateList: ColorStateList? = null
-    private var radius: Int = -1
-
-    fun color(color: Int) = apply { this.color = color }
-    fun colorStateList(colorStateList: ColorStateList?) =
-        apply { this.colorStateList = colorStateList }
-
-    fun radius(radius: Int) = apply { this.radius = radius }
-
-    override fun build(): Drawable {
-        var drawable = this.drawable!!
-        val colorStateList = this.colorStateList ?: ColorStateList(
-            arrayOf(StateSet.WILD_CARD),
-            intArrayOf(color)
-        )
-
-        var mask = if (drawable is DrawableContainer) drawable.getCurrent() else drawable
-        if (mask is ShapeDrawable) {
-            val state = mask.getConstantState()
-            if (state != null) {
-                val temp = state.newDrawable().mutate() as ShapeDrawable
-                temp.paint.color = Color.BLACK
-                mask = temp
-            }
-        } else if (mask is GradientDrawable) {
-            val state = mask.getConstantState()
-            if (state != null) {
-                val temp = state.newDrawable().mutate() as GradientDrawable
-                temp.setColor(Color.BLACK)
-                mask = temp
-            }
-        } else {
-            mask = ColorDrawable(Color.BLACK)
-        }
-
-        val rippleDrawable = RippleDrawable(colorStateList, drawable, mask)
-        setRadius(rippleDrawable, radius)
-        rippleDrawable.invalidateSelf()
-        drawable = rippleDrawable
-        return drawable
-    }
-}

app/src/main/java/com/fankes/miui/notify/utils/drawable/drawabletoolbox/RotateDrawableBuilder.kt

@@ -1,51 +0,0 @@
-/*
- * Copyright (C) 2022. Fankes Studio(qzmmcn@163.com)
- *
- * This file is part of MIUINativeNotifyIcon.
- *
- * MIUINativeNotifyIcon is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * MIUINativeNotifyIcon is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * This file is Created by fankes on 2022/1/8.
- */
-package com.fankes.miui.notify.utils.drawable.drawabletoolbox
-
-import android.graphics.drawable.Drawable
-import android.graphics.drawable.RotateDrawable
-
-class RotateDrawableBuilder : DrawableWrapperBuilder<RotateDrawableBuilder>() {
-
-    private var pivotX: Float = 0.5f
-    private var pivotY: Float = 0.5f
-    private var fromDegrees: Float = 0f
-    private var toDegrees: Float = 360f
-
-    fun pivotX(x: Float) = apply { pivotX = x }
-    fun pivotY(y: Float) = apply { pivotY = y }
-    fun fromDegrees(degree: Float) = apply { fromDegrees = degree }
-    fun toDegrees(degree: Float) = apply { toDegrees = degree }
-
-    override fun build(): Drawable {
-        val rotateDrawable = RotateDrawable()
-        drawable?.let {
-            setDrawable(rotateDrawable, it)
-            apply {
-                setPivotX(rotateDrawable, pivotX)
-                setPivotY(rotateDrawable, pivotY)
-                setFromDegrees(rotateDrawable, fromDegrees)
-                setToDegrees(rotateDrawable, toDegrees)
-            }
-        }
-        return rotateDrawable
-    }
-}

app/src/main/java/com/fankes/miui/notify/utils/drawable/drawabletoolbox/ScaleDrawableBuilder.kt

@@ -1,44 +0,0 @@
-/*
- * Copyright (C) 2022. Fankes Studio(qzmmcn@163.com)
- *
- * This file is part of MIUINativeNotifyIcon.
- *
- * MIUINativeNotifyIcon is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * MIUINativeNotifyIcon is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * This file is Created by fankes on 2022/1/8.
- */
-package com.fankes.miui.notify.utils.drawable.drawabletoolbox
-
-import android.graphics.drawable.Drawable
-import android.graphics.drawable.ScaleDrawable
-import android.view.Gravity
-
-class ScaleDrawableBuilder : DrawableWrapperBuilder<ScaleDrawableBuilder>() {
-
-    private var level: Int = 10000
-    private var scaleGravity = Gravity.CENTER
-    private var scaleWidth: Float = 0f
-    private var scaleHeight: Float = 0f
-
-    fun level(level: Int) = apply { this.level = level }
-    fun scaleGravity(gravity: Int) = apply { this.scaleGravity = gravity }
-    fun scaleWidth(scale: Float) = apply { this.scaleWidth = scale }
-    fun scaleHeight(scale: Float) = apply { this.scaleHeight = scale }
-
-    override fun build(): Drawable {
-        val scaleDrawable = ScaleDrawable(drawable, scaleGravity, scaleWidth, scaleHeight)
-        scaleDrawable.level = level
-        return scaleDrawable
-    }
-}

app/src/main/java/com/fankes/miui/notify/utils/drawable/drawabletoolbox/StateListDrawableBuilder.kt

@@ -1,59 +0,0 @@
-/*
- * Copyright (C) 2022. Fankes Studio(qzmmcn@163.com)
- *
- * This file is part of MIUINativeNotifyIcon.
- *
- * MIUINativeNotifyIcon is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * MIUINativeNotifyIcon is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * This file is Created by fankes on 2022/1/8.
- */
-package com.fankes.miui.notify.utils.drawable.drawabletoolbox
-
-import android.graphics.Color
-import android.graphics.drawable.ColorDrawable
-import android.graphics.drawable.Drawable
-import android.graphics.drawable.StateListDrawable
-import android.util.StateSet
-
-class StateListDrawableBuilder {
-
-    private var pressed: Drawable? = null
-    private var disabled: Drawable? = null
-    private var selected: Drawable? = null
-    private var normal: Drawable = ColorDrawable(Color.TRANSPARENT)
-
-    fun pressed(pressed: Drawable?) = apply { this.pressed = pressed }
-    fun disabled(disabled: Drawable?) = apply { this.disabled = disabled }
-    fun selected(selected: Drawable?) = apply { this.selected = selected }
-    fun normal(normal: Drawable) = apply { this.normal = normal }
-
-    fun build(): StateListDrawable {
-        val stateListDrawable = StateListDrawable()
-        setupStateListDrawable(stateListDrawable)
-        return stateListDrawable
-    }
-
-    private fun setupStateListDrawable(stateListDrawable: StateListDrawable) {
-        pressed?.let {
-            stateListDrawable.addState(intArrayOf(android.R.attr.state_pressed), it)
-        }
-        disabled?.let {
-            stateListDrawable.addState(intArrayOf(-android.R.attr.state_enabled), it)
-        }
-        selected?.let {
-            stateListDrawable.addState(intArrayOf(android.R.attr.state_selected), it)
-        }
-        stateListDrawable.addState(StateSet.WILD_CARD, normal)
-    }
-}

app/src/main/java/com/fankes/miui/notify/utils/factory/BackPressedEventFactory.kt

@@ -0,0 +1,66 @@
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2017-2023 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
+ *
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
+ *
+ * This file is created by fankes on 2022/10/6.
+ */
+package com.fankes.miui.notify.utils.factory
+
+import androidx.activity.OnBackPressedCallback
+import androidx.appcompat.app.AppCompatActivity
+
+/** 已添加的返回监听事件 */
+private val onBackPressedCallbacks = HashMap<AppCompatActivity, OnBackPressedCallback>()
+
+/**
+ * 手动调用返回事件
+ * @param ignored 是否忽略现有返回监听事件立即返回 - 否则将执行返回事件 - 默认否
+ */
+fun AppCompatActivity.callOnBackPressed(ignored: Boolean = false) {
+    if (isDestroyed) return
+    onBackPressedCallbacks[this]?.isEnabled = ignored.not()
+    onBackPressedDispatcher.onBackPressed()
+}
+
+/**
+ * 添加返回监听事件
+ * @param callback 回调事件
+ */
+fun AppCompatActivity.addOnBackPressedEvent(callback: OnBackPressedEvent.() -> Unit) {
+    object : OnBackPressedCallback(true) {
+        override fun handleOnBackPressed() {
+            OnBackPressedEvent(this@addOnBackPressedEvent).apply(callback)
+        }
+    }.also { result ->
+        onBackPressedCallbacks.computeIfAbsent(this) {
+            onBackPressedDispatcher.addCallback(result)
+            result
+        }
+    }
+}
+
+/**
+ * 返回监听事件实现类
+ * @param instance 当前实例
+ */
+class OnBackPressedEvent(private val instance: AppCompatActivity) {
+
+    /** 立即释放返回事件并调用返回功能 */
+    fun releaseEventAndBack() = instance.callOnBackPressed(ignored = true)
+}

app/src/main/java/com/fankes/miui/notify/utils/factory/BaseAdapterFactory.kt

@@ -0,0 +1,87 @@
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2017-2023 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
+ *
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
+ *
+ * This file is created by fankes on 2022/6/3.
+ */
+package com.fankes.miui.notify.utils.factory
+
+import android.content.Context
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.widget.BaseAdapter
+import android.widget.ListView
+import androidx.viewbinding.ViewBinding
+import com.highcapable.yukihookapi.hook.factory.method
+import com.highcapable.yukihookapi.hook.type.android.LayoutInflaterClass
+
+/**
+ * 绑定 [BaseAdapter] 到 [ListView]
+ * @param initiate 方法体
+ * @return [BaseAdapter]
+ */
+inline fun ListView.bindAdapter(initiate: BaseAdapterCreater.() -> Unit) =
+    BaseAdapterCreater(context).apply(initiate).baseAdapter?.apply { adapter = this } ?: error("BaseAdapter not binded")
+
+/**
+ * [BaseAdapter] 创建类
+ * @param context 实例
+ */
+class BaseAdapterCreater(val context: Context) {
+
+    /** 当前 [List] 回调 */
+    var listDataCallback: (() -> List<*>)? = null
+
+    /** 当前 [BaseAdapter] */
+    var baseAdapter: BaseAdapter? = null
+
+    /**
+     * 绑定 [List] 到 [ListView]
+     * @param result 回调数据
+     */
+    fun onBindDatas(result: (() -> List<*>)) {
+        listDataCallback = result
+    }
+
+    /**
+     * 绑定 [BaseAdapter] 到 [ListView]
+     * @param bindViews 回调 - ([VB] 每项,[Int] 下标)
+     */
+    inline fun <reified VB : ViewBinding> onBindViews(crossinline bindViews: (binding: VB, position: Int) -> Unit) {
+        baseAdapter = object : BaseAdapter() {
+            override fun getCount() = listDataCallback?.let { it() }?.size ?: 0
+            override fun getItem(position: Int) = listDataCallback?.let { it() }?.get(position)
+            override fun getItemId(position: Int) = position.toLong()
+            override fun getView(position: Int, convertView: View?, parent: ViewGroup?): View {
+                var holderView = convertView
+                val holder: VB
+                if (convertView == null) {
+                    holder = VB::class.java.method {
+                        name = "inflate"
+                        param(LayoutInflaterClass)
+                    }.get().invoke<VB>(LayoutInflater.from(context)) ?: error("ViewHolder binding failed")
+                    holderView = holder.root.apply { tag = holder }
+                } else holder = convertView.tag as VB
+                bindViews(holder, position)
+                return holderView ?: error("ViewHolder binding failed")
+            }
+        }
+    }
+}

app/src/main/java/com/fankes/miui/notify/utils/factory/DialogBuilderFactory.kt

@@ -0,0 +1,192 @@
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2017-2023 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
+ *
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
+ *
+ * This file is created by fankes on 2022/1/7.
+ */
+@file:Suppress("unused")
+
+package com.fankes.miui.notify.utils.factory
+
+import android.app.Dialog
+import android.app.TimePickerDialog
+import android.content.Context
+import android.view.Gravity
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.widget.LinearLayout
+import android.widget.TextView
+import androidx.appcompat.app.AlertDialog
+import androidx.viewbinding.ViewBinding
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import com.google.android.material.progressindicator.CircularProgressIndicator
+import com.highcapable.yukihookapi.YukiHookAPI
+import com.highcapable.yukihookapi.hook.factory.method
+import com.highcapable.yukihookapi.hook.type.android.LayoutInflaterClass
+
+/**
+ * 显示时间选择对话框
+ * @param timeSet 当前时间 - 不写将使用当前时间格式：HH:mm
+ * @param result 回调 - 小时与分钟 HH:mm
+ */
+fun Context.showTimePicker(timeSet: String = "", result: (String) -> Unit) =
+    TimePickerDialog(this, { _, h, m -> result("${h.autoZero}:${m.autoZero}") }, timeSet.hour, timeSet.minute, true).show()
+
+/**
+ * 构造 [VB] 自定义 View 对话框
+ * @param initiate 对话框方法体
+ */
+@JvmName(name = "showDialog_Generics")
+inline fun <reified VB : ViewBinding> Context.showDialog(initiate: DialogBuilder<VB>.() -> Unit) =
+    DialogBuilder<VB>(context = this, VB::class.java).apply(initiate).show()
+
+/**
+ * 构造对话框
+ * @param initiate 对话框方法体
+ */
+inline fun Context.showDialog(initiate: DialogBuilder<*>.() -> Unit) = DialogBuilder<ViewBinding>(context = this).apply(initiate).show()
+
+/**
+ * 对话框构造器
+ * @param context 实例
+ * @param bindingClass [ViewBinding] 的 [Class] 实例 or null
+ */
+class DialogBuilder<VB : ViewBinding>(val context: Context, private val bindingClass: Class<*>? = null) {
+
+    /** 实例对象 */
+    private var instance: AlertDialog.Builder? = null
+
+    /** 对话框取消监听 */
+    private var onCancel: (() -> Unit)? = null
+
+    /** 对话框实例 */
+    private var dialogInstance: Dialog? = null
+
+    /** 自定义布局 */
+    private var customLayoutView: View? = null
+
+    /**
+     * 获取 [DialogBuilder] 绑定布局对象
+     * @return [VB]
+     */
+    val binding by lazy {
+        bindingClass?.method {
+            name = "inflate"
+            param(LayoutInflaterClass)
+        }?.get()?.invoke<VB>(LayoutInflater.from(context))?.apply {
+            customLayoutView = root
+        } ?: error("This dialog maybe not a custom view dialog")
+    }
+
+    init {
+        if (YukiHookAPI.Status.isXposedEnvironment) error("This dialog is not allowed to created in Xposed environment")
+        instance = MaterialAlertDialogBuilder(context)
+    }
+
+    /** 设置对话框不可关闭 */
+    fun noCancelable() {
+        instance?.setCancelable(false)
+    }
+
+    /** 设置对话框标题 */
+    var title
+        get() = ""
+        set(value) {
+            instance?.setTitle(value)
+        }
+
+    /** 设置对话框消息内容 */
+    var msg
+        get() = ""
+        set(value) {
+            instance?.setMessage(value)
+        }
+
+    /** 设置进度条对话框消息内容 */
+    var progressContent
+        get() = ""
+        set(value) {
+            if (customLayoutView == null)
+                customLayoutView = LinearLayout(context).apply {
+                    orientation = LinearLayout.HORIZONTAL
+                    gravity = Gravity.CENTER or Gravity.START
+                    addView(CircularProgressIndicator(context).apply {
+                        isIndeterminate = true
+                        trackCornerRadius = 10.dp(context)
+                    })
+                    addView(View(context).apply { layoutParams = ViewGroup.LayoutParams(20.dp(context), 5) })
+                    addView(TextView(context).apply {
+                        tag = "progressContent"
+                        text = value
+                    })
+                    setPadding(20.dp(context), 20.dp(context), 20.dp(context), 20.dp(context))
+                }
+            else customLayoutView?.findViewWithTag<TextView>("progressContent")?.text = value
+        }
+
+    /**
+     * 设置对话框确定按钮
+     * @param text 按钮文本内容
+     * @param callback 点击事件
+     */
+    fun confirmButton(text: String = "确定", callback: () -> Unit = {}) {
+        instance?.setPositiveButton(text) { _, _ -> callback() }
+    }
+
+    /**
+     * 设置对话框取消按钮
+     * @param text 按钮文本内容
+     * @param callback 点击事件
+     */
+    fun cancelButton(text: String = "取消", callback: () -> Unit = {}) {
+        instance?.setNegativeButton(text) { _, _ -> callback() }
+    }
+
+    /**
+     * 设置对话框第三个按钮
+     * @param text 按钮文本内容
+     * @param callback 点击事件
+     */
+    fun neutralButton(text: String = "更多", callback: () -> Unit = {}) {
+        instance?.setNeutralButton(text) { _, _ -> callback() }
+    }
+
+    /**
+     * 当对话框关闭时
+     * @param callback 回调
+     */
+    fun onCancel(callback: () -> Unit) {
+        onCancel = callback
+    }
+
+    /** 取消对话框 */
+    fun cancel() = dialogInstance?.cancel()
+
+    /** 显示对话框 */
+    fun show() = runInSafe {
+        /** 若当前自定义 View 的对话框没有调用 [binding] 将会对其手动调用一次以确保显示布局 */
+        if (bindingClass != null) binding
+        instance?.create()?.apply {
+            customLayoutView?.let { setView(it) }
+            dialogInstance = this
+            setOnCancelListener { onCancel?.invoke() }
+        }?.show()
+    }
+}

app/src/main/java/com/fankes/miui/notify/utils/factory/ExceptionFactory.kt

@@ -0,0 +1,83 @@
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2017-2023 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
+ *
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
+ *
+ * This file is created by fankes on 2022/3/13.
+ */
+@file:Suppress("unused")
+
+package com.fankes.miui.notify.utils.factory
+
+import com.highcapable.yukihookapi.hook.log.YLog
+
+/**
+ * 忽略异常返回值
+ * @param result 回调 - 如果异常为空
+ * @return [T] 发生异常时返回设定值否则返回正常值
+ */
+inline fun <T> safeOfNull(result: () -> T): T? = safeOf(default = null, result)
+
+/**
+ * 忽略异常返回值
+ * @param result 回调 - 如果异常为 false
+ * @return [Boolean] 发生异常时返回设定值否则返回正常值
+ */
+inline fun safeOfFalse(result: () -> Boolean) = safeOf(default = false, result)
+
+/**
+ * 忽略异常返回值
+ * @param result 回调 - 如果异常为 true
+ * @return [Boolean] 发生异常时返回设定值否则返回正常值
+ */
+inline fun safeOfTrue(result: () -> Boolean) = safeOf(default = true, result)
+
+/**
+ * 忽略异常返回值
+ * @param result 回调 - 如果异常为 false
+ * @return [String] 发生异常时返回设定值否则返回正常值
+ */
+inline fun safeOfNothing(result: () -> String) = safeOf(default = "", result)
+
+/**
+ * 忽略异常返回值
+ * @param result 回调 - 如果异常为 false
+ * @return [Int] 发生异常时返回设定值否则返回正常值
+ */
+inline fun safeOfNan(result: () -> Int) = safeOf(default = 0, result)
+
+/**
+ * 忽略异常返回值
+ * @param default 异常返回值
+ * @param result 正常回调值
+ * @return [T] 发生异常时返回设定值否则返回正常值
+ */
+inline fun <T> safeOf(default: T, result: () -> T) = try {
+    result()
+} catch (_: Throwable) {
+    default
+}
+
+/**
+ * 忽略异常运行
+ * @param msg 出错输出的消息 - 默认为空
+ * @param block 正常回调
+ */
+inline fun <T> T.runInSafe(msg: String = "", block: () -> Unit) {
+    runCatching(block).onFailure { if (msg.isNotBlank()) YLog.error(msg, it) }
+}

app/src/main/java/com/fankes/miui/notify/utils/factory/FunctionFactory.kt

@@ -0,0 +1,722 @@
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2017-2023 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
+ *
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
+ *
+ * This file is created by fankes on 2022/1/7.
+ */
+@file:Suppress("unused", "ObsoleteSdkInt")
+
+package com.fankes.miui.notify.utils.factory
+
+import android.annotation.SuppressLint
+import android.app.Activity
+import android.app.Notification
+import android.app.Service
+import android.app.WallpaperManager
+import android.content.ClipData
+import android.content.ClipboardManager
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.content.pm.ApplicationInfo
+import android.content.pm.PackageInfo
+import android.content.pm.PackageManager
+import android.content.pm.PackageManager.PackageInfoFlags
+import android.content.res.Configuration
+import android.content.res.Resources
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Paint
+import android.graphics.PorterDuff
+import android.graphics.PorterDuffXfermode
+import android.graphics.Rect
+import android.graphics.RectF
+import android.graphics.drawable.Drawable
+import android.net.ConnectivityManager
+import android.net.Uri
+import android.os.Build
+import android.os.Handler
+import android.provider.Settings
+import android.util.Base64
+import android.widget.Toast
+import androidx.annotation.ColorRes
+import androidx.annotation.DrawableRes
+import androidx.core.app.NotificationManagerCompat
+import androidx.core.content.getSystemService
+import androidx.core.content.pm.PackageInfoCompat
+import androidx.core.content.res.ResourcesCompat
+import com.fankes.miui.notify.wrapper.BuildConfigWrapper
+import com.google.android.material.snackbar.Snackbar
+import com.highcapable.yukihookapi.hook.factory.hasClass
+import com.highcapable.yukihookapi.hook.factory.method
+import com.highcapable.yukihookapi.hook.factory.toClassOrNull
+import com.highcapable.yukihookapi.hook.log.YLog
+import com.highcapable.yukihookapi.hook.type.java.StringClass
+import com.highcapable.yukihookapi.hook.xposed.application.ModuleApplication.Companion.appContext
+import com.topjohnwu.superuser.Shell
+import java.io.ByteArrayOutputStream
+import java.text.SimpleDateFormat
+import java.util.Calendar
+import java.util.Date
+import java.util.Locale
+
+/**
+ * 系统深色模式是否开启
+ * @return [Boolean] 是否开启
+ */
+val isSystemInDarkMode get() = appContext.isSystemInDarkMode
+
+/**
+ * 系统深色模式是否没开启
+ * @return [Boolean] 是否开启
+ */
+inline val isNotSystemInDarkMode get() = !isSystemInDarkMode
+
+/**
+ * 系统深色模式是否开启
+ * @return [Boolean] 是否开启
+ */
+val Context.isSystemInDarkMode get() = (resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK) == Configuration.UI_MODE_NIGHT_YES
+
+/**
+ * 系统深色模式是否没开启
+ * @return [Boolean] 是否开启
+ */
+inline val Context.isNotSystemInDarkMode get() = !isSystemInDarkMode
+
+/**
+ * 系统版本是否高于或等于 Android 14
+ * @return [Boolean] 是否符合条件
+ */
+inline val isUpperOfAndroidU get() = Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE
+
+/**
+ * 系统版本是否高于或等于 Android 13
+ * @return [Boolean] 是否符合条件
+ */
+inline val isUpperOfAndroidT get() = Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU
+
+/**
+ * 系统版本是否高于或等于 Android 12
+ * @return [Boolean] 是否符合条件
+ */
+inline val isUpperOfAndroidS get() = Build.VERSION.SDK_INT >= Build.VERSION_CODES.S
+
+/**
+ * 系统版本是否低于 Android 9
+ * @return [Boolean] 是否符合条件
+ */
+inline val isLowerAndroidP get() = Build.VERSION.SDK_INT < Build.VERSION_CODES.P
+
+/**
+ * 系统版本是否低于 Android 11
+ * @return [Boolean] 是否符合条件
+ */
+inline val isLowerAndroidR get() = Build.VERSION.SDK_INT < Build.VERSION_CODES.R
+
+/**
+ * 当前设备是否是 MIUI、HyperOS 定制 Android 系统
+ * @return [Boolean] 是否符合条件
+ */
+val isMiSystem get() = isMIUI || isMIOS
+
+/**
+ * 当前设备是否不是 MIUI、HyperOS 定制 Android 系统
+ * @return [Boolean] 是否符合条件
+ */
+val isNotMiSystem get() = !isMiSystem
+
+/**
+ * 当前设备是否是 MIUI 定制 Android 系统
+ * @return [Boolean] 是否符合条件
+ */
+val isMIUI by lazy { "android.miui.R".hasClass() }
+
+/**
+ * 当前设备是否是 HyperOS 定制 Android 系统
+ * @return [Boolean] 是否符合条件
+ */
+val isMIOS get() = isMIUI && miuiVersion == "816"
+
+/**
+ * 当前设备是否不是 MIUI 定制 Android 系统
+ * @return [Boolean] 是否符合条件
+ */
+inline val isNotMIUI get() = !isMIUI
+
+/**
+ * 当前设备是否不是 HyperOS 定制 Android 系统
+ * @return [Boolean] 是否符合条件
+ */
+inline val isNotMIOS get() = !isMIOS
+
+/**
+ * 是否为支持的 MIUI、HyperOS 版本
+ * @return [Boolean]
+ */
+val isSupportMiSystemVersion
+    get() = when {
+        isMIOS -> when (miosVersion) {
+            "1.0" -> true
+            else -> false
+        }
+        isMIUI -> when (miuiVersion) {
+            "11", "12", "12.5", "13", "14" -> true
+            else -> false
+        }
+        else -> false
+    }
+
+/**
+ * 是否不为支持的 MIUI、HyperOS 版本
+ * @return [Boolean]
+ */
+inline val isNotSupportMiSystemVersion get() = !isSupportMiSystemVersion
+
+/**
+ * 获取 Android 版本代号
+ * @return [String]
+ */
+val androidVersionCodeName
+    get() = when (Build.VERSION.SDK_INT) {
+        34 -> "U"
+        33 -> "T"
+        32 -> "S_V2"
+        31 -> "S"
+        30 -> "R"
+        29 -> "Q"
+        28 -> "P"
+        27 -> "O_MR1"
+        26 -> "O"
+        25 -> "N_MR1"
+        24 -> "N"
+        23 -> "M"
+        22 -> "L_MR1"
+        21 -> "L"
+        else -> "?"
+    }
+
+/**
+ * 获取 MIUI、HyperOS 版本
+ * @return [String]
+ */
+val miSystemVersion
+    get() = when {
+        isMIOS -> miosVersion
+        isMIUI -> miuiVersion
+        else -> ""
+    }
+
+/**
+ * 获取 MIUI、HyperOS 版本号
+ * @return [Float]
+ */
+val miSystemVersionCode
+    get() = when {
+        isMIOS -> miosVersionCode
+        isMIUI -> miuiVersionCode
+        else -> 0f
+    }
+
+/**
+ * 获取 MIUI 版本
+ * @return [String]
+ */
+val miuiVersion
+    get() = if (isMIUI)
+        findPropString("ro.miui.ui.version.name").let {
+            when (it) {
+                "V11", "V110" -> "11"
+                "V12", "V120" -> "12"
+                "V125" -> "12.5"
+                "V13", "V130" -> "13"
+                "V14", "V140" -> "14"
+                else -> it.replace("V", "")
+            }
+        }.trim()
+    else ""
+
+/**
+ * 获取 HyperOS 版本
+ * @return [String]
+ */
+val miosVersion
+    get() = if (isMIOS)
+        findPropString("ro.mi.os.version.name").let {
+            if (it.startsWith("OS")) it.replaceFirst("OS", "") else it
+        }.trim()
+    else ""
+
+/**
+ * 获取 MIUI 版本号
+ * @return [Float]
+ */
+val miuiVersionCode get() = miuiVersion.toFloatOrNull() ?: 0f
+
+/**
+ * 获取 HyperOS 版本号
+ * @return [Float]
+ */
+val miosVersionCode get() = findPropString("ro.mi.os.version.code").toFloatOrNull() ?: 0f
+
+/**
+ * 获取 MIUI 次版本号
+ * @return [String]
+ */
+val miuiIncrementalVersion get() = findPropString("ro.system.build.version.incremental").trim()
+
+/**
+ * 获取 HyperOS 次版本号
+ * @return [String]
+ */
+val miosIncrementalVersion get() = findPropString("ro.mi.os.version.incremental").trim()
+
+/**
+ * 获取 MIUI、HyperOS 完全版本
+ * @return [String]
+ */
+val systemFullVersion
+    get() = when {
+        isMIOS -> "HyperOS " + miosIncrementalVersion.let {
+            if (it.lowercase().endsWith(".dev").not() && it.lowercase().any { e -> e.code in 97..122 })
+                "${it.replaceFirst("OS", "")} 稳定版"
+            else when {
+                it.lowercase().endsWith(".dev") -> "${it.replaceFirst("OS", "")} 开发版"
+                else -> "$miosVersion $it 开发版"
+            }
+        }
+        isMIUI -> miuiIncrementalVersion.let {
+            if (it.lowercase().endsWith(".dev").not() && it.lowercase().any { e -> e.code in 97..122 })
+                "$it 稳定版"
+            else when {
+                it.lowercase().endsWith(".dev") -> "$it 开发版"
+                else -> "V$miuiVersion $it 开发版"
+            }
+        }
+        else -> "不是 MIUI 或 HyperOS 系统"
+    }
+
+/**
+ * 获取 [Drawable]
+ * @param resId 属性资源 ID
+ * @return [Drawable]
+ */
+fun Resources.drawableOf(@DrawableRes resId: Int) = ResourcesCompat.getDrawable(this, resId, null) ?: error("Invalid resources")
+
+/**
+ * 获取颜色
+ * @param resId 属性资源 ID
+ * @return [Int]
+ */
+fun Resources.colorOf(@ColorRes resId: Int) = ResourcesCompat.getColor(this, resId, null)
+
+/**
+ * 得到 APP 安装包信息 (兼容)
+ * @param packageName APP 包名
+ * @param flag [PackageInfoFlags]
+ * @return [PackageInfo] or null
+ */
+private fun Context.getPackageInfoCompat(packageName: String, flag: Number = 0) = runCatching {
+    @Suppress("DEPRECATION", "KotlinRedundantDiagnosticSuppress")
+    if (Build.VERSION.SDK_INT >= 33)
+        packageManager?.getPackageInfo(packageName, PackageInfoFlags.of(flag.toLong()))
+    else packageManager?.getPackageInfo(packageName, flag.toInt())
+}.getOrNull()
+
+/**
+ * 得到 APP 版本号 (兼容 [PackageInfo.getLongVersionCode])
+ * @return [Int]
+ */
+private val PackageInfo.versionCodeCompat get() = PackageInfoCompat.getLongVersionCode(this)
+
+/**
+ * 判断 APP 是否安装
+ * @param packageName APP 包名
+ * @return [Boolean]
+ */
+fun Context.isInstall(packageName: String) = getPackageInfoCompat(packageName)?.let { true } ?: false
+
+/**
+ * 得到 APP 版本信息
+ * @return [String]
+ */
+val Context.appVersionName get() = getPackageInfoCompat(packageName)?.versionName ?: ""
+
+/**
+ * 得到 APP 版本号
+ * @return [Int]
+ */
+val Context.appVersionCode get() = getPackageInfoCompat(packageName)?.versionCodeCompat
+
+/**
+ * 得到 APP 名称
+ * @param packageName APP 包名 - 默认为当前 APP
+ * @return [String]
+ */
+fun Context.appNameOf(packageName: String = getPackageName()) =
+    getPackageInfoCompat(packageName)?.applicationInfo?.loadLabel(packageManager)?.toString() ?: ""
+
+/**
+ * 得到 APP 图标
+ * @param packageName APP 包名 - 默认为当前 APP
+ * @return [Drawable] or null
+ */
+fun Context.appIconOf(packageName: String = getPackageName()) = getPackageInfoCompat(packageName)?.applicationInfo?.loadIcon(packageManager)
+
+/**
+ * 获取 APP 是否为 DEBUG 版本
+ * @param packageName APP 包名
+ * @return [Boolean]
+ */
+fun Context.isDebugApp(packageName: String) =
+    safeOfFalse { (getPackageInfoCompat(packageName)?.applicationInfo?.flags?.and(ApplicationInfo.FLAG_DEBUGGABLE) ?: 0) != 0 }
+
+/**
+ * 获取 APP 是否为系统 APP
+ * @param packageName APP 包名
+ * @return [Boolean]
+ */
+fun Context.isSystemApp(packageName: String) =
+    safeOfFalse { (getPackageInfoCompat(packageName)?.applicationInfo?.flags?.and(ApplicationInfo.FLAG_SYSTEM) ?: 0) != 0 }
+
+/**
+ * 对数值自动补零
+ * @return [String]
+ */
+val Int.autoZero: String get() = if (this < 10) "0$this" else toString()
+
+/**
+ * 从字符串获取小时
+ * @return [Int]
+ */
+val String.hour
+    get() = safeOfNan {
+        Calendar.getInstance().also {
+            it.time = SimpleDateFormat("HH:mm", Locale.CHINA).parse(this) as Date
+        }.get(Calendar.HOUR_OF_DAY)
+    }
+
+/**
+ * 从字符串获取分钟
+ * @return [Int]
+ */
+val String.minute
+    get() = safeOfNan {
+        Calendar.getInstance().also {
+            it.time = SimpleDateFormat("HH:mm", Locale.CHINA).parse(this) as Date
+        }.get(Calendar.MINUTE)
+    }
+
+/**
+ * 是否关闭了通知权限
+ * @return [Boolean]
+ */
+val isNotNoificationEnabled get() = !NotificationManagerCompat.from(appContext).areNotificationsEnabled()
+
+/**
+ * 网络连接是否正常
+ * @return [Boolean] 网络是否连接
+ */
+val Context.isNetWorkSuccess
+    get() = safeOfFalse {
+        @Suppress("DEPRECATION")
+        getSystemService<ConnectivityManager>()?.activeNetworkInfo != null
+    }
+
+/**
+ * dp 转换为 pxInt
+ * @param context 使用的实例
+ * @return [Int]
+ */
+fun Number.dp(context: Context) = dpFloat(context).toInt()
+
+/**
+ * dp 转换为 pxFloat
+ * @param context 使用的实例
+ * @return [Float]
+ */
+fun Number.dpFloat(context: Context) = toFloat() * context.resources.displayMetrics.density
+
+/**
+ * 获取系统主题色
+ * @return [Int] Android < 12 返回 [wallpaperColor]
+ */
+val Context.systemAccentColor
+    @SuppressLint("InlinedApi")
+    get() = safeOf(wallpaperColor) {
+        if (isUpperOfAndroidS) resources.colorOf(android.R.color.system_accent1_600) else wallpaperColor
+    }
+
+/**
+ * 获取系统壁纸颜色
+ * @return [Int] 无法获取时返回默认颜色
+ */
+val Context.wallpaperColor
+    get() = runCatching {
+        WallpaperManager.getInstance(this).getWallpaperColors(WallpaperManager.FLAG_SYSTEM)?.primaryColor?.toArgb()
+    }.getOrNull() ?: (if (isSystemInDarkMode) 0xFFD8D8D8.toInt() else 0xFF707173.toInt())
+
+/**
+ * 获取较浅的颜色
+ * @return [Int]
+ */
+val Int.brighterColor: Int
+    get() {
+        val hsv = FloatArray(3)
+        Color.colorToHSV(this, hsv)
+        hsv[1] = hsv[1] - 0.3f
+        hsv[2] = hsv[2] + 0.3f
+        return Color.HSVToColor(hsv)
+    }
+
+/**
+ * 是否为白色
+ * @return [Boolean]
+ */
+val Int.isWhiteColor
+    get() = safeOfTrue {
+        val r = this and 0xff0000 shr 16
+        val g = this and 0x00ff00 shr 8
+        val b = this and 0x0000ff
+        (0.2126 * r + 0.7152 * g + 0.0722 * b) >= 128
+    }
+
+/**
+ * Base64 加密
+ * @return [String]
+ */
+val Bitmap.base64
+    get() = safeOfNothing {
+        val baos = ByteArrayOutputStream()
+        compress(Bitmap.CompressFormat.PNG, 100, baos)
+        Base64.encodeToString(baos.toByteArray(), Base64.DEFAULT)
+    }
+
+/**
+ * Base64 加密
+ * @return [String]
+ */
+val String.base64: String get() = Base64.encodeToString(toByteArray(), Base64.DEFAULT)
+
+/**
+ * Base64 解密为字节流
+ * @return [ByteArray]
+ */
+val String.unbase64 get() = Base64.decode(this, Base64.DEFAULT) ?: ByteArray(0)
+
+/**
+ * 字节流解析为位图
+ * @return [Bitmap]
+ */
+val ByteArray.bitmap: Bitmap get() = BitmapFactory.decodeByteArray(this, 0, size)
+
+/**
+ * 字符串解析为位图
+ * @return [Bitmap]
+ */
+val String.bitmap: Bitmap get() = unbase64.bitmap
+
+/**
+ * 圆角图片
+ * @param radius 圆角度
+ * @return [Bitmap] 圆角后的位图 - 失败会返回处理之前的位图
+ */
+fun Bitmap.round(radius: Float): Bitmap = safeOf(default = this) {
+    Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888).also { out ->
+        Canvas(out).also { canvas ->
+            Paint().also { paint ->
+                paint.isAntiAlias = true
+                canvas.drawARGB(0, 0, 0, 0)
+                paint.color = Color.WHITE
+                canvas.drawRoundRect(RectF(Rect(0, 0, width, height)), radius, radius, paint)
+                paint.xfermode = PorterDuffXfermode(PorterDuff.Mode.SRC_IN)
+                canvas.drawBitmap(this, Rect(0, 0, width, height), Rect(0, 0, width, height), paint)
+            }
+        }
+    }
+}
+
+/**
+ * 获取系统 Prop 值
+ * @param key Key
+ * @param default 默认值
+ * @return [String]
+ */
+fun findPropString(key: String, default: String = "") = safeOf(default) {
+    "android.os.SystemProperties".toClassOrNull()?.method {
+        name = "get"
+        param(StringClass, StringClass)
+    }?.get()?.invoke(key, default) ?: default
+}
+
+/**
+ * 是否有 Root 权限
+ * @return [Boolean]
+ */
+val isRootAccess get() = safeOfFalse {
+    @Suppress("DEPRECATION")
+    Shell.rootAccess()
+}
+
+/**
+ * 执行命令
+ * @param cmd 命令
+ * @param isSu 是否使用 Root 权限执行 - 默认：是
+ * @return [String] 执行结果
+ */
+fun execShell(cmd: String, isSu: Boolean = true) = safeOfNothing {
+    @Suppress("DEPRECATION")
+    (if (isSu) Shell.su(cmd) else Shell.sh(cmd)).exec().out.let {
+        if (it.isNotEmpty()) it[0].trim() else ""
+    }
+}
+
+/**
+ * 弹出 [Toast]
+ * @param msg 提示内容
+ */
+fun toast(msg: String) {
+    runCatching {
+        Toast.makeText(appContext, msg, Toast.LENGTH_SHORT).show()
+    }.onFailure { YLog.warn(msg) }
+}
+
+/**
+ * 跳转到指定页面
+ *
+ * [T] 为指定的 [Activity]
+ */
+inline fun <reified T : Activity> Context.navigate() = runInSafe {
+    startActivity(Intent(if (this is Service) applicationContext else this, T::class.java).apply {
+        if (this@navigate !is Activity) flags = Intent.FLAG_ACTIVITY_NEW_TASK
+    })
+}
+
+/**
+ * 弹出 [Snackbar]
+ * @param msg 提示内容
+ * @param actionText 按钮文本 - 不写默认取消按钮
+ * @param callback 按钮事件回调
+ */
+fun Context.snake(msg: String, actionText: String = "", callback: () -> Unit = {}) =
+    Snackbar.make((this as Activity).findViewById(android.R.id.content), msg, Snackbar.LENGTH_LONG)
+        .apply {
+            if (actionText.isBlank()) return@apply
+            setActionTextColor(if (isSystemInDarkMode) Color.BLACK else Color.WHITE)
+            setAction(actionText) { callback() }
+        }.show()
+
+/**
+ * 启动系统浏览器
+ * @param url 网址
+ * @param packageName 指定包名 - 可不填
+ */
+fun Context.openBrowser(url: String, packageName: String = "") = runCatching {
+    startActivity(Intent().apply {
+        if (packageName.isNotBlank()) setPackage(packageName)
+        action = Intent.ACTION_VIEW
+        data = Uri.parse(url)
+        /** 防止顶栈一样重叠在自己的 APP 中 */
+        flags = Intent.FLAG_ACTIVITY_NEW_TASK
+    })
+}.onFailure {
+    if (packageName.isNotBlank())
+        snake(msg = "启动 $packageName 失败")
+    else snake(msg = "启动系统浏览器失败")
+}
+
+/**
+ * 跳转 APP 自身设置界面
+ * @param packageName 包名
+ */
+fun Context.openSelfSetting(packageName: String = appContext.packageName) = runCatching {
+    if (isInstall(packageName))
+        startActivity(Intent().apply {
+            flags = Intent.FLAG_ACTIVITY_NEW_TASK
+            action = Settings.ACTION_APPLICATION_DETAILS_SETTINGS
+            data = Uri.fromParts("package", packageName, null)
+        })
+    else toast(msg = "你没有安装此应用")
+}.onFailure { toast(msg = "启动 $packageName 应用信息失败") }
+
+/** 跳转通知设置界面 */
+fun Context.openNotifySetting() = runCatching {
+    Intent().also { intent ->
+        intent.action = Settings.ACTION_APP_NOTIFICATION_SETTINGS
+        intent.putExtra(Settings.EXTRA_APP_PACKAGE, packageName)
+        intent.putExtra(Notification.EXTRA_CHANNEL_ID, applicationInfo.uid)
+        startActivity(intent)
+    }
+}.onFailure { snake(msg = "跳转通知设置失败") }
+
+/**
+ * 复制到剪贴板
+ * @param content 要复制的文本
+ */
+fun Context.copyToClipboard(content: String) = runInSafe {
+    (getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager).apply {
+        setPrimaryClip(ClipData.newPlainText(null, content))
+        (primaryClip?.getItemAt(0)?.text ?: "").also {
+            if (it != content) snake(msg = "复制失败") else snake(msg = "已复制")
+        }
+    }
+}
+
+/**
+ * 时间戳 -> 时间
+ * @param format 格式化方法 - 默认：yyyy-MM-dd HH:mm:ss
+ * @return [String] 目标字符串时间
+ */
+fun Long.stampToDate(format: String = "yyyy-MM-dd HH:mm:ss") =
+    safeOfNothing { SimpleDateFormat(format, Locale.CHINA).format(Date(this)) ?: "" }
+
+/**
+ * 延迟执行
+ * @param ms 毫秒 - 默认：150
+ * @param it 方法体
+ */
+fun Any?.delayedRun(ms: Long = 150, it: () -> Unit) = runInSafe {
+    @Suppress("DEPRECATION")
+    Handler().postDelayed({ it() }, ms)
+}
+
+/**
+ * 隐藏或显示启动器图标
+ *
+ * - 你可能需要 LSPosed 的最新版本以开启高版本系统中隐藏 APP 桌面图标功能
+ * @param isShow 是否显示
+ */
+fun Context.hideOrShowLauncherIcon(isShow: Boolean) {
+    packageManager?.setComponentEnabledSetting(
+        ComponentName(packageName, "${BuildConfigWrapper.APPLICATION_ID}.Home"),
+        if (isShow) PackageManager.COMPONENT_ENABLED_STATE_DISABLED else PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
+        PackageManager.DONT_KILL_APP
+    )
+}
+
+/**
+ * 获取启动器图标状态
+ * @return [Boolean] 是否显示
+ */
+val Context.isLauncherIconShowing
+    get() = packageManager?.getComponentEnabledSetting(
+        ComponentName(packageName, "${BuildConfigWrapper.APPLICATION_ID}.Home")
+    ) != PackageManager.COMPONENT_ENABLED_STATE_DISABLED

app/src/main/java/com/fankes/miui/notify/utils/tool/ActivationPromptTool.kt

@@ -0,0 +1,84 @@
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2017-2023 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
+ *
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
+ *
+ * This file is created by fankes on 2023/4/17.
+ */
+package com.fankes.miui.notify.utils.tool
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.graphics.drawable.Icon
+import android.os.Build
+import androidx.core.graphics.drawable.toBitmap
+import com.fankes.miui.notify.R
+import com.fankes.miui.notify.utils.factory.appIconOf
+import com.fankes.miui.notify.wrapper.BuildConfigWrapper
+
+/**
+ * 模块更新激活提醒通知工具类
+ */
+object ActivationPromptTool {
+
+    /** 当前模块的包名 */
+    private const val MODULE_PACKAGE_NAME = BuildConfigWrapper.APPLICATION_ID
+
+    /** 推送通知的渠道名称 */
+    private const val NOTIFY_CHANNEL = "activationPromptId"
+
+    /**
+     * 推送提醒通知
+     * @param context 当前实例
+     * @param packageName 当前 APP 包名
+     */
+    fun prompt(context: Context, packageName: String) {
+        if (packageName != BuildConfigWrapper.APPLICATION_ID) return
+        context.getSystemService(NotificationManager::class.java)?.apply {
+            createNotificationChannel(
+                NotificationChannel(
+                    NOTIFY_CHANNEL, "MIUI 原生通知图标 - 版本更新",
+                    NotificationManager.IMPORTANCE_DEFAULT
+                ).apply { enableLights(false) }
+            )
+            notify(packageName.hashCode(), Notification.Builder(context, NOTIFY_CHANNEL).apply {
+                setShowWhen(true)
+                setContentTitle("模块已更新")
+                setContentText("点按通知打开模块以完成新版本激活。")
+                setColor(0xFFE06818.toInt())
+                setAutoCancel(true)
+                setSmallIcon(Icon.createWithResource(MODULE_PACKAGE_NAME, R.drawable.ic_notify_update))
+                setLargeIcon(context.appIconOf(packageName)?.toBitmap())
+                setContentIntent(
+                    PendingIntent.getActivity(
+                        context, packageName.hashCode(),
+                        Intent().apply {
+                            component = ComponentName(MODULE_PACKAGE_NAME, "$MODULE_PACKAGE_NAME.ui.activity.MainActivity")
+                            flags = Intent.FLAG_ACTIVITY_NEW_TASK
+                        }, if (Build.VERSION.SDK_INT < 31) PendingIntent.FLAG_UPDATE_CURRENT else PendingIntent.FLAG_IMMUTABLE
+                    )
+                )
+            }.build())
+        }
+    }
+}

app/src/main/java/com/fankes/miui/notify/utils/tool/BitmapCompatTool.kt

@@ -0,0 +1,123 @@
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2017-2023 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
+ *
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
+ *
+ * This file is created by fankes on 2022/2/19.
+ */
+package com.fankes.miui.notify.utils.tool
+
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Matrix
+import android.graphics.Paint
+import android.graphics.PorterDuff
+import android.graphics.drawable.AnimationDrawable
+import android.graphics.drawable.BitmapDrawable
+import android.graphics.drawable.Drawable
+import android.graphics.drawable.VectorDrawable
+import android.util.ArrayMap
+import androidx.core.graphics.drawable.toBitmap
+import com.fankes.miui.notify.utils.factory.safeOfFalse
+import kotlin.math.abs
+
+/**
+ * 这是一个从 AOSP 源码中分离出来的功能
+ *
+ * 主要作用于兼容部分 MIUI 魔改颜色判断代码造成判断位图灰度功能失效
+ */
+object BitmapCompatTool {
+
+    /** 缓存已判断的结果防止卡顿 */
+    private var cachedBitmapGrayscales = ArrayMap<Int, Boolean>()
+
+    private var tempBuffer = intArrayOf(0)
+    private var tempCompactBitmap: Bitmap? = null
+    private var tempCompactBitmapCanvas: Canvas? = null
+    private var tempCompactBitmapPaint: Paint? = null
+    private val tempMatrix = Matrix()
+
+    /**
+     * 判断 [Drawable] 是否为灰度位图
+     * @param drawable 要判断的 [Drawable]
+     * @return [Boolean] 是否灰度
+     */
+    fun isGrayscaleDrawable(drawable: Drawable) = safeOfFalse {
+        when (drawable) {
+            is BitmapDrawable -> isGrayscaleBitmap(drawable.bitmap)
+            is AnimationDrawable -> !(drawable.numberOfFrames <= 0 || !isGrayscaleBitmap(drawable.getFrame(0).toBitmap()))
+            is VectorDrawable -> true
+            else -> isGrayscaleBitmap(drawable.toBitmap())
+        }
+    }
+
+    /**
+     * 判断 [Bitmap] 是否为灰度位图
+     * @param bitmap 要判断的位图
+     * @return [Boolean] 是否灰度
+     */
+    private fun isGrayscaleBitmap(bitmap: Bitmap) =
+        cachedBitmapGrayscales[bitmap.generationId] ?: let {
+            var height = bitmap.height
+            var width = bitmap.width
+            if (height > 64 || width > 64) {
+                if (tempCompactBitmap == null) {
+                    tempCompactBitmap = Bitmap.createBitmap(64, 64, Bitmap.Config.ARGB_8888)
+                        .also { tempCompactBitmapCanvas = Canvas(it) }
+                    tempCompactBitmapPaint = Paint(Paint.FILTER_BITMAP_FLAG).apply { isFilterBitmap = true }
+                }
+                tempMatrix.reset()
+                tempMatrix.setScale(64f / width, 64f / height, 0f, 0f)
+                tempCompactBitmapCanvas?.drawColor(0, PorterDuff.Mode.SRC)
+                tempCompactBitmapCanvas?.drawBitmap(bitmap, tempMatrix, tempCompactBitmapPaint)
+                height = 64
+                width = 64
+            }
+            val size = height * width
+            ensureBufferSize(size)
+            tempCompactBitmap?.getPixels(tempBuffer, 0, width, 0, 0, width, height)
+            for (i in 0 until size)
+                if (isGrayscaleColor(tempBuffer[i]).not()) {
+                    cachedBitmapGrayscales[bitmap.generationId] = false
+                    return@let false
+                }
+            cachedBitmapGrayscales[bitmap.generationId] = true
+            true
+        }
+
+    /**
+     * 提纯 [Bitmap] 颜色判断灰度
+     * @param color 颜色
+     * @return [Boolean] 是否灰度
+     */
+    private fun isGrayscaleColor(color: Int): Boolean {
+        if (color shr 24 and 255 < 50) return true
+        val r = color shr 16 and 255
+        val g = color shr 8 and 255
+        val b = color and 255
+        return !(abs(r - g) >= 20 || abs(r - b) >= 20 || abs(g - b) >= 20)
+    }
+
+    /**
+     * 计算字节数组
+     * @param size 大小
+     */
+    private fun ensureBufferSize(size: Int) {
+        if (tempBuffer.size < size) tempBuffer = IntArray(size)
+    }
+}

app/src/main/java/com/fankes/miui/notify/utils/tool/GithubReleaseTool.kt

@@ -0,0 +1,152 @@
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2017-2023 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
+ *
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
+ *
+ * This file is created by fankes on 2022/3/20.
+ */
+package com.fankes.miui.notify.utils.tool
+
+import android.app.Activity
+import android.content.Context
+import android.icu.text.SimpleDateFormat
+import android.icu.util.Calendar
+import android.icu.util.TimeZone
+import com.fankes.miui.notify.utils.factory.isNetWorkSuccess
+import com.fankes.miui.notify.utils.factory.openBrowser
+import com.fankes.miui.notify.utils.factory.openSelfSetting
+import com.fankes.miui.notify.utils.factory.runInSafe
+import com.fankes.miui.notify.utils.factory.showDialog
+import okhttp3.Call
+import okhttp3.Callback
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Response
+import org.json.JSONObject
+import java.io.IOException
+import java.io.Serializable
+import java.util.Locale
+
+/**
+ * 获取 GitHub Release 最新版本工具类
+ */
+object GithubReleaseTool {
+
+    /** 仓库作者 */
+    private const val REPO_AUTHOR = "fankes"
+
+    /** 仓库名称 */
+    private const val REPO_NAME = "MIUINativeNotifyIcon"
+
+    /**
+     * 获取最新版本信息
+     * @param context 实例
+     * @param version 当前版本
+     * @param result 成功后回调 - ([String] 最新版本,[Function] 更新对话框方法体)
+     */
+    fun checkingForUpdate(context: Context, version: String, result: (String, () -> Unit) -> Unit) = checkingInternetConnect(context) {
+        OkHttpClient().newBuilder().build().newCall(
+            Request.Builder()
+                .url("https://api.github.com/repos/$REPO_AUTHOR/$REPO_NAME/releases/latest")
+                .get()
+                .build()
+        ).enqueue(object : Callback {
+            override fun onFailure(call: Call, e: IOException) {}
+
+            override fun onResponse(call: Call, response: Response) = runInSafe {
+                JSONObject(response.body.string()).apply {
+                    GithubReleaseBean(
+                        name = getString("name"),
+                        htmlUrl = getString("html_url"),
+                        content = getString("body"),
+                        date = getString("published_at").localTime()
+                    ).apply {
+                        fun showUpdate() = context.showDialog {
+                            title = "最新版本 $name"
+                            msg = "发布于 $date\n\n" +
+                                "更新日志\n\n" + content
+                            confirmButton(text = "更新") { context.openBrowser(htmlUrl) }
+                            cancelButton()
+                        }
+                        if (name != version) (context as? Activity?)?.runOnUiThread {
+                            showUpdate()
+                            result(name) { showUpdate() }
+                        }
+                    }
+                }
+            }
+        })
+    }
+
+    /**
+     * 检查网络连接情况
+     * @param context 实例
+     * @param callback 已连接回调
+     */
+    private fun checkingInternetConnect(context: Context, callback: () -> Unit) = runInSafe {
+        if (context.isNetWorkSuccess)
+            OkHttpClient().newBuilder().build().newCall(
+                Request.Builder()
+                    .url("https://www.baidu.com")
+                    .get()
+                    .build()
+            ).enqueue(object : Callback {
+                override fun onFailure(call: Call, e: IOException) {
+                    (context as? Activity?)?.runOnUiThread {
+                        context.showDialog {
+                            title = "网络不可用"
+                            msg = "应用的联网权限可能已被禁用，请开启联网权限以定期检查更新。"
+                            confirmButton(text = "去开启") { context.openSelfSetting() }
+                            cancelButton()
+                            noCancelable()
+                        }
+                    }
+                }
+
+                override fun onResponse(call: Call, response: Response) = runInSafe {
+                    (context as? Activity?)?.runOnUiThread { runInSafe { callback() } }
+                }
+            })
+    }
+
+    /**
+     * 格式化时间为本地时区
+     * @return [String] 本地时区时间
+     */
+    private fun String.localTime() = replace("T", " ").replace("Z", "").let {
+        runCatching {
+            val local = SimpleDateFormat("yyyy-MM-dd HH:mm", Locale.ROOT).apply { timeZone = Calendar.getInstance().timeZone }
+            val current = SimpleDateFormat("yyyy-MM-dd HH:mm", Locale.ROOT).apply { timeZone = TimeZone.getTimeZone("GMT") }
+            local.format(current.parse(it))
+        }.getOrNull() ?: it
+    }
+
+    /**
+     * GitHub Release bean
+     * @param name 版本名称
+     * @param htmlUrl 网页地址
+     * @param content 更新日志
+     * @param date 发布时间
+     */
+    private data class GithubReleaseBean(
+        var name: String,
+        var htmlUrl: String,
+        var content: String,
+        var date: String
+    ) : Serializable
+}

app/src/main/java/com/fankes/miui/notify/utils/tool/I18nWarnTool.kt

@@ -0,0 +1,55 @@
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2017-2023 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
+ *
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
+ *
+ * This file is created by fankes on 2023/2/3.
+ */
+package com.fankes.miui.notify.utils.tool
+
+import android.content.Context
+import com.fankes.miui.notify.utils.factory.showDialog
+import com.highcapable.yukihookapi.hook.factory.prefs
+import com.highcapable.yukihookapi.hook.xposed.prefs.data.PrefsData
+import java.util.Locale
+
+/**
+ * I18n 适配警告提示工具类
+ */
+object I18nWarnTool {
+
+    /** 推广已读存储键值 */
+    private val LOCALE_WARN_READED = PrefsData("locale_warn_readed", false)
+
+    /**
+     * 检查并显示 I18n 适配警告对话框
+     * @param context 实例
+     */
+    fun checkingOrShowing(context: Context) {
+        fun saveReaded() = context.prefs().edit { put(LOCALE_WARN_READED, value = true) }
+        if (Locale.getDefault().language.startsWith("zh").not() && context.prefs().get(LOCALE_WARN_READED).not())
+            context.showDialog {
+                title = "Notice of I18n Support"
+                msg = "This Xposed Module is only for Chinese and the Chinese region.\n\n" +
+                    "Currently, there will be no internationalization adaptation.\n\n" +
+                    "There may be plans for internationalization adaptation in the future, so stay tuned."
+                confirmButton(text = "Got It") { saveReaded() }
+                noCancelable()
+            }
+    }
+}

app/src/main/java/com/fankes/miui/notify/utils/tool/IconAdaptationTool.kt

@@ -0,0 +1,131 @@
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2017-2023 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
+ *
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
+ *
+ * This file is created by fankes on 2022/3/21.
+ */
+package com.fankes.miui.notify.utils.tool
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.graphics.drawable.Icon
+import android.os.Build
+import androidx.core.graphics.drawable.toBitmap
+import com.fankes.miui.notify.R
+import com.fankes.miui.notify.hook.HookEntry
+import com.fankes.miui.notify.utils.factory.appIconOf
+import com.fankes.miui.notify.utils.factory.appNameOf
+import com.fankes.miui.notify.utils.factory.isDebugApp
+import com.fankes.miui.notify.utils.factory.isSystemApp
+import com.fankes.miui.notify.utils.factory.runInSafe
+import com.fankes.miui.notify.utils.factory.stampToDate
+import com.fankes.miui.notify.wrapper.BuildConfigWrapper
+
+/**
+ * 通知图标适配推送通知类
+ *
+ * 这个类需要在 [HookEntry] 中调用
+ */
+object IconAdaptationTool {
+
+    /** 当前模块的包名 */
+    private const val MODULE_PACKAGE_NAME = BuildConfigWrapper.APPLICATION_ID
+
+    /** 推送通知的渠道名称 */
+    private const val NOTIFY_CHANNEL = "notifyRuleSupportId"
+
+    /** 已过期的时间 */
+    private val outTimeLimits = HashSet<String>()
+
+    /**
+     * 推送新 APP 安装适配通知
+     * @param context 实例
+     * @param packageName 安装的 APP 包名
+     */
+    fun pushNewAppSupportNotify(context: Context, packageName: String) {
+        if (packageName.startsWith("com.google.android.trichromelibrary")) return
+        if (context.isSystemApp(packageName) || context.isDebugApp(packageName)) return
+        context.getSystemService(NotificationManager::class.java)?.apply {
+            createNotificationChannel(
+                NotificationChannel(
+                    NOTIFY_CHANNEL, "通知图标优化适配",
+                    NotificationManager.IMPORTANCE_DEFAULT
+                ).apply { enableLights(false) }
+            )
+            notify(packageName.hashCode(), Notification.Builder(context, NOTIFY_CHANNEL).apply {
+                setShowWhen(true)
+                setContentTitle("您已安装 ${context.appNameOf(packageName)}")
+                setContentText("尚未适配此应用，点按打开在线规则。")
+                setColor(0xFF2993F0.toInt())
+                setAutoCancel(true)
+                setSmallIcon(Icon.createWithResource(MODULE_PACKAGE_NAME, R.drawable.ic_unsupported))
+                setLargeIcon(context.appIconOf(packageName)?.toBitmap())
+                setContentIntent(
+                    PendingIntent.getActivity(
+                        context, packageName.hashCode(),
+                        Intent().apply {
+                            component = ComponentName(
+                                MODULE_PACKAGE_NAME,
+                                "$MODULE_PACKAGE_NAME.ui.activity.ConfigureActivity"
+                            )
+                            flags = Intent.FLAG_ACTIVITY_NEW_TASK
+                        }.apply {
+                            putExtra("isNewAppSupport", true)
+                            putExtra("appName", context.appNameOf(packageName))
+                            putExtra("pkgName", packageName)
+                        }, if (Build.VERSION.SDK_INT < 31) PendingIntent.FLAG_UPDATE_CURRENT else PendingIntent.FLAG_IMMUTABLE
+                    )
+                )
+            }.build())
+        }
+    }
+
+    /**
+     * 检测 APP 卸载后移除相关通知
+     * @param context 实例
+     * @param packageName 卸载的 APP 包名
+     */
+    fun removeNewAppSupportNotify(context: Context, packageName: String) = runInSafe {
+        context.getSystemService(NotificationManager::class.java)?.cancel(packageName.hashCode())
+    }
+
+    /**
+     * 自动更新通知图标优化在线规则
+     * @param context 实例
+     * @param timeSet 设定的时间
+     */
+    fun prepareAutoUpdateIconRule(context: Context, timeSet: String) = runInSafe {
+        System.currentTimeMillis().also {
+            val nowTime = it.stampToDate(format = "HH:mm")
+            if (timeSet != nowTime || outTimeLimits.any { e -> e == nowTime }) return
+            outTimeLimits.add(nowTime)
+            context.startActivity(
+                Intent().apply {
+                    component = ComponentName(MODULE_PACKAGE_NAME, "$MODULE_PACKAGE_NAME.ui.activity.auto.NotifyIconRuleUpdateActivity")
+                    flags = Intent.FLAG_ACTIVITY_NEW_TASK
+                }
+            )
+        }
+    }
+}

app/src/main/java/com/fankes/miui/notify/utils/tool/IconRuleManagerTool.kt

@@ -0,0 +1,490 @@
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2017-2023 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
+ *
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
+ *
+ * This file is created by fankes on 2022/2/25.
+ */
+@file:Suppress("TrustAllX509TrustManager", "CustomX509TrustManager", "IMPLICIT_CAST_TO_ANY")
+
+package com.fankes.miui.notify.utils.tool
+
+import android.app.Activity
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import android.os.Build
+import android.provider.Settings
+import androidx.appcompat.app.AppCompatActivity
+import androidx.core.app.NotificationCompat
+import androidx.core.content.getSystemService
+import androidx.core.view.isVisible
+import androidx.core.widget.doOnTextChanged
+import com.fankes.miui.notify.R
+import com.fankes.miui.notify.const.IconRuleSourceSyncType
+import com.fankes.miui.notify.data.ConfigData
+import com.fankes.miui.notify.databinding.DiaSourceFromBinding
+import com.fankes.miui.notify.databinding.DiaSourceFromStringBinding
+import com.fankes.miui.notify.params.IconPackParams
+import com.fankes.miui.notify.ui.activity.ConfigureActivity
+import com.fankes.miui.notify.utils.factory.delayedRun
+import com.fankes.miui.notify.utils.factory.openBrowser
+import com.fankes.miui.notify.utils.factory.safeOfNull
+import com.fankes.miui.notify.utils.factory.showDialog
+import com.fankes.miui.notify.utils.factory.snake
+import com.highcapable.yukihookapi.hook.log.YLog
+import okhttp3.Call
+import okhttp3.Callback
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Response
+import java.io.IOException
+import java.security.SecureRandom
+import java.security.cert.X509Certificate
+import javax.net.ssl.HostnameVerifier
+import javax.net.ssl.SSLContext
+import javax.net.ssl.SSLSocketFactory
+import javax.net.ssl.TrustManager
+import javax.net.ssl.X509TrustManager
+
+/**
+ * 通知图标在线规则管理类
+ */
+object IconRuleManagerTool {
+
+    /** 推送通知的渠道名称 */
+    private const val NOTIFY_CHANNEL = "notifyRuleUpdateId"
+
+    /** 当前规则的系统名称 */
+    private const val OS_TAG = "MIUI"
+
+    /** 当前规则的通知图标颜色 */
+    private const val OS_COLOR = 0xFFE06818.toInt()
+
+    /** 同步地址 - GitHub Raw (直连) */
+    private const val SYNC_DIRECT_URL = "https://raw.githubusercontent.com/fankes/AndroidNotifyIconAdapt/main"
+
+    /** 同步地址 - GitHub Raw (代理 - GitHub Proxy) */
+    private const val SYNC_PROXY_1_URL = "https://ghproxy.com/$SYNC_DIRECT_URL"
+
+    /** 同步地址 - GitHub Raw (代理 - 7ED Services) */
+    private const val SYNC_PROXY_2_URL = "https://raw.githubusercontentS.com/fankes/AndroidNotifyIconAdapt/main"
+
+    /** 云端规则展示地址 (OS) */
+    private const val RULES_TRAVELER_OS_URL = "https://fankes.github.io/AndroidNotifyIconAdapt/?notify-rules-miui"
+
+    /** 云端规则展示地址 (APP) */
+    private const val RULES_TRAVELER_APP_URL = "https://fankes.github.io/AndroidNotifyIconAdapt/?notify-rules-app"
+
+    /** 请求适配通知图标优化名单地址 */
+    internal const val RULES_FEEDBACK_URL = "https://fankes.github.io/AndroidNotifyIconAdapt/?feedback"
+
+    /** 贡献通知图标优化名单地址 */
+    internal const val RULES_CONTRIBUTING_URL = "https://fankes.github.io/AndroidNotifyIconAdapt/?contribute"
+
+    /**
+     * 从在线地址手动同步规则
+     * @param context 实例
+     * @param callback 成功后回调
+     */
+    fun syncByHand(context: Context, callback: () -> Unit) =
+        context.showDialog<DiaSourceFromBinding> {
+            title = "同步列表"
+            var sourceType = ConfigData.iconRuleSourceSyncType
+            var customUrl = ConfigData.iconRuleSourceSyncCustomUrl
+            binding.sourceUrlEdit.apply {
+                if (customUrl.isNotBlank()) {
+                    setText(customUrl)
+                    setSelection(customUrl.length)
+                }
+                doOnTextChanged { text, _, _, _ -> customUrl = text.toString() }
+            }
+            binding.sourceFromTextLin.isVisible = sourceType == IconRuleSourceSyncType.CUSTOM_URL
+            binding.sourceTravelerLin.isVisible = sourceType != IconRuleSourceSyncType.CUSTOM_URL
+            binding.sourceRadio0.isChecked = sourceType == IconRuleSourceSyncType.GITHUB_RAW_PROXY_1
+            binding.sourceRadio1.isChecked = sourceType == IconRuleSourceSyncType.GITHUB_RAW_PROXY_2
+            binding.sourceRadio2.isChecked = sourceType == IconRuleSourceSyncType.GITHUB_RAW_DIRECT
+            binding.sourceRadio3.isChecked = sourceType == IconRuleSourceSyncType.CUSTOM_URL
+            binding.sourceRadio0.setOnClickListener {
+                binding.sourceFromTextLin.isVisible = false
+                binding.sourceTravelerLin.isVisible = true
+                sourceType = IconRuleSourceSyncType.GITHUB_RAW_PROXY_1
+            }
+            binding.sourceRadio1.setOnClickListener {
+                binding.sourceFromTextLin.isVisible = false
+                binding.sourceTravelerLin.isVisible = true
+                sourceType = IconRuleSourceSyncType.GITHUB_RAW_PROXY_2
+            }
+            binding.sourceRadio2.setOnClickListener {
+                binding.sourceFromTextLin.isVisible = false
+                binding.sourceTravelerLin.isVisible = true
+                sourceType = IconRuleSourceSyncType.GITHUB_RAW_DIRECT
+            }
+            binding.sourceRadio3.setOnClickListener {
+                binding.sourceFromTextLin.isVisible = true
+                binding.sourceTravelerLin.isVisible = false
+                sourceType = IconRuleSourceSyncType.CUSTOM_URL
+            }
+            binding.sourceTravelerOsButton.setOnClickListener { context.openBrowser(RULES_TRAVELER_OS_URL) }
+            binding.sourceTravelerAppButton.setOnClickListener { context.openBrowser(RULES_TRAVELER_APP_URL) }
+            confirmButton {
+                ConfigData.iconRuleSourceSyncType = sourceType
+                ConfigData.iconRuleSourceSyncCustomUrl = customUrl
+                sync(context, sourceType, customUrl, callback)
+            }
+            cancelButton()
+            neutralButton(text = "自定义规则") {
+                context.showDialog<DiaSourceFromStringBinding> {
+                    title = "自定义规则 (调试)"
+                    binding.jsonRuleEdit.apply {
+                        requestFocus()
+                        invalidate()
+                    }
+                    IconPackParams(context).also { params ->
+                        confirmButton(text = "合并") {
+                            binding.jsonRuleEdit.text.toString().also { jsonString ->
+                                when {
+                                    jsonString.isNotBlank() && params.isNotVaildJson(jsonString) -> context.snake(msg = "不是有效的 JSON 数据")
+                                    jsonString.isNotBlank() -> {
+                                        params.save(
+                                            params.splicingJsonArray(
+                                                dataJson1 = params.storageDataJson ?: "[]",
+                                                dataJson2 = jsonString.takeIf { params.isJsonArray(it) } ?: "[$jsonString]"
+                                            )
+                                        )
+                                        notifyRefresh(context)
+                                        callback()
+                                    }
+                                    else -> context.snake(msg = "请输入有效内容")
+                                }
+                            }
+                        }
+                        cancelButton(text = "覆盖") {
+                            binding.jsonRuleEdit.text.toString().also { jsonString ->
+                                when {
+                                    jsonString.isNotBlank() && params.isNotVaildJson(jsonString) -> context.snake(msg = "不是有效的 JSON 数据")
+                                    jsonString.isNotBlank() -> {
+                                        params.save(dataJson = jsonString.takeIf { params.isJsonArray(it) } ?: "[$jsonString]")
+                                        notifyRefresh(context)
+                                        callback()
+                                    }
+                                    else -> context.snake(msg = "请输入有效内容")
+                                }
+                            }
+                        }
+                    }
+                    neutralButton(text = "取消")
+                }
+            }
+        }
+
+    /**
+     * 从在线地址同步规则
+     * @param context 实例
+     * @param sourceType 同步地址类型 - 默认自动获取已存储的键值
+     * @param customUrl 自定义同步地址 - 默认自动获取已存储的键值
+     * @param callback 成功后回调
+     */
+    fun sync(
+        context: Context,
+        sourceType: Int = ConfigData.iconRuleSourceSyncType,
+        customUrl: String = ConfigData.iconRuleSourceSyncCustomUrl,
+        callback: () -> Unit
+    ) {
+        when (sourceType) {
+            IconRuleSourceSyncType.GITHUB_RAW_PROXY_1 -> onRefreshing(context, SYNC_PROXY_1_URL, callback)
+            IconRuleSourceSyncType.GITHUB_RAW_PROXY_2 -> onRefreshing(context, SYNC_PROXY_2_URL, callback)
+            IconRuleSourceSyncType.GITHUB_RAW_DIRECT -> onRefreshing(context, SYNC_DIRECT_URL, callback)
+            IconRuleSourceSyncType.CUSTOM_URL ->
+                if (customUrl.isNotBlank())
+                    if (customUrl.startsWith("http://") || customUrl.startsWith("https://"))
+                        onRefreshingCustom(context, customUrl, callback)
+                    else context.snakeOrNotify(title = "同步失败", msg = "同步地址不是一个合法的 URL")
+                else context.snakeOrNotify(title = "同步失败", msg = "同步地址不能为空")
+            else -> context.snakeOrNotify(title = "同步异常", msg = "同步类型错误")
+        }
+    }
+
+    /**
+     * 开始更新数据
+     * @param context 实例
+     * @param url
+     * @param callback 成功后回调
+     */
+    private fun onRefreshing(context: Context, url: String, callback: () -> Unit) = checkingInternetConnect(context) {
+        fun doParse(result: (Boolean) -> Unit = {}) {
+            wait(context, url = "$url/OS/$OS_TAG/NotifyIconsSupportConfig.json") { isDone1, ctOS ->
+                result(true)
+                wait(context, url = "$url/APP/NotifyIconsSupportConfig.json") { isDone2, ctAPP ->
+                    result(false)
+                    IconPackParams(context).also { params ->
+                        when {
+                            isDone1 && isDone2 -> params.splicingJsonArray(ctOS, ctAPP).also {
+                                when {
+                                    params.isHackString(it) ->
+                                        context.snakeOrNotify(title = "同步错误", msg = "请求需要验证，请尝试魔法上网或关闭魔法")
+                                    params.isNotVaildJson(it) ->
+                                        context.snakeOrNotify(title = "同步错误", msg = "目标地址不是有效的 JSON 数据")
+                                    params.isCompareDifferent(it) -> {
+                                        params.save(it)
+                                        notifyRefresh(context)
+                                        callback()
+                                    }
+                                    else -> (if (context is AppCompatActivity) context.snake(msg = "列表数据已是最新"))
+                                }
+                            }
+                            context is AppCompatActivity ->
+                                context.showDialog {
+                                    title = "连接失败"
+                                    msg = "连接失败，错误如下：\n${if (isDone1.not()) ctOS else ctAPP}"
+                                    confirmButton(text = "再试一次") { syncByHand(context, callback) }
+                                    cancelButton()
+                                }
+                            else -> pushNotify(context, title = "同步地址不可用", msg = if (isDone1.not()) ctOS else ctAPP)
+                        }
+                    }
+                }
+            }
+        }
+        if (context is AppCompatActivity)
+            context.showDialog {
+                title = "同步中"
+                progressContent = "正在同步 OS 数据"
+                noCancelable()
+                doParse { if (it) progressContent = "正在同步 APP 数据" else cancel() }
+            }
+        else doParse()
+    }
+
+    /**
+     * 开始更新数据
+     * @param context 实例
+     * @param url
+     * @param callback 成功后回调
+     */
+    private fun onRefreshingCustom(context: Context, url: String, callback: () -> Unit) = checkingInternetConnect(context) {
+        fun doParse(result: () -> Unit = {}) {
+            wait(context, url) { isDone, content ->
+                result()
+                /** 延迟重新回调防止对话框无法取消 */
+                delayedRun { result() }
+                IconPackParams(context).also { params ->
+                    when {
+                        isDone -> when {
+                            params.isHackString(content) ->
+                                context.snakeOrNotify(title = "同步错误", msg = "请求需要验证，请尝试魔法上网或关闭魔法")
+                            params.isNotVaildJson(content) ->
+                                context.snakeOrNotify(title = "同步错误", msg = "目标地址不是有效的 JSON 数据")
+                            params.isCompareDifferent(content) -> {
+                                params.save(content)
+                                notifyRefresh(context)
+                                callback()
+                            }
+                            else -> (if (context is AppCompatActivity) context.snake(msg = "列表数据已是最新"))
+                        }
+                        context is AppCompatActivity ->
+                            context.showDialog {
+                                title = "连接失败"
+                                msg = "连接失败，错误如下：\n$content"
+                                confirmButton(text = "我知道了")
+                            }
+                        else -> pushNotify(context, title = "同步地址不可用", msg = content)
+                    }
+                }
+            }
+        }
+        if (context is AppCompatActivity)
+            context.showDialog {
+                title = "同步中"
+                progressContent = "正在通过自定义地址同步数据"
+                noCancelable()
+                doParse { cancel() }
+            }
+        else doParse()
+    }
+
+    /**
+     * 检查网络连接情况
+     * @param context 实例
+     * @param callback 已连接回调
+     */
+    private fun checkingInternetConnect(context: Context, callback: () -> Unit) =
+        if (context is AppCompatActivity) context.showDialog {
+            title = "准备中"
+            progressContent = "正在检查网络连接情况"
+            noCancelable()
+            baseCheckingInternetConnect(context) { isDone ->
+                cancel()
+                if (isDone) callback() else
+                    context.showDialog {
+                        title = "网络不可用"
+                        msg = "无法连接到互联网，请检查你当前的设备是否可以上网，且没有在手机管家中禁用本模块的联网权限。"
+                        confirmButton(text = "检查设置") {
+                            runCatching {
+                                context.startActivity(Intent().apply {
+                                    flags = Intent.FLAG_ACTIVITY_NEW_TASK
+                                    action = Settings.ACTION_APPLICATION_DETAILS_SETTINGS
+                                    data = Uri.fromParts("package", context.packageName, null)
+                                })
+                            }.onFailure { context.snake(msg = "启动应用信息页面失败") }
+                        }
+                        cancelButton()
+                    }
+            }
+        } else baseCheckingInternetConnect(context) { isDone ->
+            if (isDone) callback() else pushNotify(context, title = "网络不可用", msg = "网络连接失败，无法更新通知图标规则，点击重试", isRetry = true)
+        }
+
+    /**
+     * 检查网络连接情况
+     * @param context 实例
+     * @param result 已连接回调
+     */
+    private fun baseCheckingInternetConnect(context: Context, result: (Boolean) -> Unit) =
+        wait(context, url = "https://www.baidu.com") { isDone, _ -> result(isDone) }
+
+    /**
+     * 发送 GET 请求内容并等待
+     * @param context 实例
+     * @param url 请求地址
+     * @param result 回调 - ([Boolean] 是否成功,[String] 成功的内容或失败消息)
+     */
+    private fun wait(context: Context, url: String, result: (Boolean, String) -> Unit) = runCatching {
+        OkHttpClient().newBuilder().apply {
+            SSLSocketClient.sSLSocketFactory?.let { sslSocketFactory(it, SSLSocketClient.trustManager) }
+            hostnameVerifier(SSLSocketClient.hostnameVerifier)
+        }.build().newCall(
+            Request.Builder()
+                .url(url)
+                .get()
+                .build()
+        ).enqueue(object : Callback {
+            override fun onFailure(call: Call, e: IOException) {
+                (context as? Activity?)?.runOnUiThread { result(false, e.toString()) } ?: result(false, e.toString())
+            }
+
+            override fun onResponse(call: Call, response: Response) {
+                val bodyString = response.body.string()
+                (context as? Activity?)?.runOnUiThread { result(true, bodyString) } ?: result(true, bodyString)
+            }
+        })
+    }.onFailure { result(false, "URL 无效") }
+
+    /**
+     * 推送通知图标更新通知
+     * @param context 实例
+     */
+    private fun notifyRefresh(context: Context) {
+        if (context !is AppCompatActivity) pushNotify(context, title = "同步完成", msg = "已更新通知图标优化名单，点击查看")
+        SystemUITool.refreshSystemUI(context) { if (context is AppCompatActivity) context.snake(msg = "已更新通知图标优化名单") }
+    }
+
+    /**
+     * 根据实例类型决定推送通知还是弹出提示
+     * @param title 标题 - 仅对通知生效
+     * @param msg 消息内容
+     */
+    private fun Context.snakeOrNotify(title: String, msg: String) {
+        if (this !is AppCompatActivity) pushNotify(context = this, title, msg)
+        else snake(msg)
+    }
+
+    /**
+     * 推送通知
+     * @param context 实例 - 类型为 [AppCompatActivity] 时将不会推送通知
+     * @param title 通知标题
+     * @param msg 通知消息
+     * @param isRetry 是否发送重试动作 - 默认否
+     */
+    private fun pushNotify(context: Context, title: String, msg: String, isRetry: Boolean = false) {
+        if (context !is AppCompatActivity)
+            context.getSystemService<NotificationManager>()?.apply {
+                createNotificationChannel(
+                    NotificationChannel(
+                        NOTIFY_CHANNEL, "通知图标优化规则",
+                        NotificationManager.IMPORTANCE_DEFAULT
+                    )
+                )
+                notify(0, NotificationCompat.Builder(context, NOTIFY_CHANNEL).apply {
+                    setContentTitle(title)
+                    setContentText(msg)
+                    color = OS_COLOR
+                    setAutoCancel(true)
+                    setSmallIcon(R.drawable.ic_nf_icon_update)
+                    setSound(null)
+                    setDefaults(NotificationCompat.DEFAULT_ALL)
+                    setContentIntent(
+                        PendingIntent.getActivity(
+                            context, msg.hashCode(),
+                            Intent(context, ConfigureActivity::class.java).apply {
+                                if (isRetry) putExtra("isDirectUpdate", true) else putExtra("isShowUpdDialog", false)
+                            },
+                            if (Build.VERSION.SDK_INT < 31) PendingIntent.FLAG_UPDATE_CURRENT else PendingIntent.FLAG_IMMUTABLE
+                        )
+                    )
+                }.build())
+            }
+    }
+
+    /**
+     * 自动信任 SSL 证书
+     *
+     * 放行全部加密 SSL 请求
+     */
+    private object SSLSocketClient {
+
+        /**
+         * 格式化实例
+         * @return [SSLSocketFactory] or null
+         */
+        val sSLSocketFactory
+            get() = safeOfNull {
+                SSLContext.getInstance("TLS").let {
+                    it.init(null, arrayOf<TrustManager>(trustManager), SecureRandom())
+                    it.socketFactory
+                }
+            }
+
+        /**
+         * 使用的实例
+         * @return [HostnameVerifier]
+         */
+        val hostnameVerifier get() = HostnameVerifier { _, _ -> true }
+
+        /**
+         * 信任管理者
+         * @return [X509TrustManager]
+         */
+        val trustManager
+            get() = object : X509TrustManager {
+
+                override fun checkClientTrusted(chain: Array<X509Certificate?>?, authType: String?) {
+                    YLog.debug("TrustX509 --> $authType")
+                }
+
+                override fun checkServerTrusted(chain: Array<X509Certificate?>?, authType: String?) {
+                    YLog.debug("TrustX509 --> $authType")
+                }
+
+                override fun getAcceptedIssuers() = arrayOf<X509Certificate>()
+            }
+    }
+}

app/src/main/java/com/fankes/miui/notify/utils/tool/SystemUITool.kt

@@ -0,0 +1,264 @@
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2017-2023 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
+ *
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
+ *
+ * This file is created by fankes on 2022/2/8.
+ */
+package com.fankes.miui.notify.utils.tool
+
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import androidx.activity.result.ActivityResultLauncher
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.appcompat.app.AppCompatActivity
+import com.fankes.miui.notify.const.PackageName
+import com.fankes.miui.notify.data.ConfigData
+import com.fankes.miui.notify.ui.activity.MainActivity
+import com.fankes.miui.notify.utils.factory.delayedRun
+import com.fankes.miui.notify.utils.factory.execShell
+import com.fankes.miui.notify.utils.factory.isMIOS
+import com.fankes.miui.notify.utils.factory.showDialog
+import com.fankes.miui.notify.utils.factory.snake
+import com.fankes.miui.notify.utils.factory.systemFullVersion
+import com.google.android.material.snackbar.Snackbar
+import com.highcapable.yukihookapi.YukiHookAPI
+import com.highcapable.yukihookapi.hook.factory.dataChannel
+import com.highcapable.yukihookapi.hook.log.YLog
+import com.highcapable.yukihookapi.hook.log.data.YLogData
+import com.highcapable.yukihookapi.hook.param.PackageParam
+import com.highcapable.yukihookapi.hook.xposed.channel.data.ChannelData
+import java.util.Locale
+
+/**
+ * 系统界面工具
+ */
+object SystemUITool {
+
+    private val CALL_HOST_REFRESH_CACHING = ChannelData("call_host_refresh_caching", false)
+    private val CALL_MODULE_REFRESH_RESULT = ChannelData("call_module_refresh_result", false)
+
+    /** 当前全部调试日志 */
+    private var debugLogs = listOf<YLogData>()
+
+    /** 当前启动器实例 */
+    private var launcher: ActivityResultLauncher<String>? = null
+
+    /**
+     * 宿主注册监听
+     */
+    object Host {
+
+        /**
+         * 监听系统界面刷新改变
+         * @param param 实例
+         * @param result 回调 - ([Boolean] 是否成功)
+         */
+        fun onRefreshSystemUI(param: PackageParam, result: (Boolean) -> Boolean) {
+            param.dataChannel.with { wait(CALL_HOST_REFRESH_CACHING) { put(CALL_MODULE_REFRESH_RESULT, result(it)) } }
+        }
+    }
+
+    /**
+     * 检查模块是否激活
+     * @param context 实例
+     * @param result 成功后回调
+     */
+    fun checkingActivated(context: Context, result: (Boolean) -> Unit) =
+        context.dataChannel(PackageName.SYSTEMUI).checkingVersionEquals(result = result)
+
+    /**
+     * 注册导出调试日志启动器到 [AppCompatActivity]
+     * @param activity 实例
+     */
+    fun registerExportDebugLogsLauncher(activity: AppCompatActivity) {
+        launcher = activity.registerForActivityResult(ActivityResultContracts.CreateDocument("*/application")) { result ->
+            runCatching {
+                result?.let { e ->
+                    val content = "" +
+                        "================================================================\n" +
+                        "    Generated by MIUINativeNotifyIcon\n" +
+                        "    Project Url: https://github.com/fankes/MIUINativeNotifyIcon\n" +
+                        "================================================================\n\n" +
+                        "[Device Brand]: ${Build.BRAND}\n" +
+                        "[Device Model]: ${Build.MODEL}\n" +
+                        "[Display]: ${Build.DISPLAY}\n" +
+                        "[Android Version]: ${Build.VERSION.RELEASE}\n" +
+                        "[Android API Level]: ${Build.VERSION.SDK_INT}\n" +
+                        "[${if (isMIOS) "HyperOS" else "MIUI"} Version]: $systemFullVersion\n" +
+                        "[System Locale]: ${Locale.getDefault()}\n\n" + YLog.contents(debugLogs).trim()
+                    activity.contentResolver?.openOutputStream(e)?.apply { write(content.toByteArray()) }?.close()
+                    activity.snake(msg = "导出完成")
+                } ?: activity.snake(msg = "已取消操作")
+            }.onFailure { activity.snake(msg = "导出过程发生错误") }
+        }
+    }
+
+    /**
+     * 获取并导出全部调试日志
+     * @param context 实例
+     */
+    fun obtainAndExportDebugLogs(context: Context) {
+        /** 执行导出操作 */
+        fun doExport() {
+            context.dataChannel(PackageName.SYSTEMUI).obtainLoggerInMemoryData {
+                if (it.isNotEmpty()) {
+                    debugLogs = it
+                    runCatching { launcher?.launch("miui_notification_icons_processing_logs.log") }
+                        .onFailure { context.snake(msg = "启动系统文件选择器失败") }
+                } else context.snake(msg = "暂无调试日志")
+            }
+        }
+        if (YukiHookAPI.Status.isXposedModuleActive)
+            context.showDialog {
+                title = "导出全部调试日志"
+                msg = "调试日志中会包含当前系统推送的全部通知内容，其中可能包含你的个人隐私，" +
+                    "你可以在导出后的日志文件中选择将这些敏感信息模糊化处理再进行共享，" +
+                    "开发者使用并查看你导出的调试日志仅为排查与修复问题，并且在之后会及时销毁这些日志。\n\n" +
+                    "继续导出即代表你已阅读并知悉上述内容。"
+                confirmButton(text = "继续") { doExport() }
+                cancelButton()
+            }
+        else context.snake(msg = "模块没有激活，请先激活模块")
+    }
+
+    /** 当 Root 权限获取失败时显示对话框 */
+    private fun Context.showWhenAccessRootFail() =
+        showDialog {
+            title = "获取 Root 权限失败"
+            msg = "当前无法获取 Root 权限，请确认你的设备已经被 Root 且同意授予 Root 权限。\n" +
+                "如果你正在使用 Magisk 并安装了 Shamiko 模块，" +
+                "请确认当前是否正处于白名单模式。 (白名单模式将导致无法申请 Root 权限)"
+            confirmButton(text = "我知道了")
+        }
+
+    /**
+     * 打开 MIUI 通知显示设置界面
+     * @param context 实例
+     */
+    fun openMiuiNotificationDisplaySettings(context: Context) {
+        runCatching {
+            context.startActivity(Intent().apply {
+                component = ComponentName(
+                    "com.miui.notification",
+                    "miui.notification.management.activity.NotificationDisplaySettingsActivity"
+                )
+                flags = Intent.FLAG_ACTIVITY_NEW_TASK
+            })
+        }.onFailure {
+            execShell(
+                cmd = "am start -a" +
+                    "com.miui.notification " +
+                    "com.miui.notification/miui.notification.management.activity.NotificationDisplaySettingsActivity"
+            ).also {
+                when {
+                    it.isBlank() -> context.showWhenAccessRootFail()
+                    else -> context.snake(msg = "已发送请求，如果未打开则是当前系统不支持此功能")
+                }
+            }
+        }
+    }
+
+    /**
+     * 重启系统界面
+     * @param context 实例
+     */
+    fun restartSystemUI(context: Context) {
+        /** 动态刷新功能是否可用 */
+        val isDynamicAvailable = ConfigData.isEnableModule && MainActivity.isModuleRegular && MainActivity.isModuleValied
+        context.showDialog {
+            title = "重启系统界面"
+            msg = "你确定要立即重启系统界面吗？\n\n" +
+                "部分 MIUI 内测和开发版中使用了状态栏主题可能会发生主题失效的情况，这种情况请再重启一次即可。\n\n" +
+                "重启过程会黑屏并等待进入锁屏重新解锁。" + (if (isDynamicAvailable)
+                    "\n\n你也可以选择“立即生效”来动态刷新系统界面并生效当前模块设置。" else "")
+            confirmButton {
+                execShell(cmd = "pgrep systemui").also { pid ->
+                    if (pid.isNotBlank())
+                        execShell(cmd = "kill -9 $pid")
+                    else context.showWhenAccessRootFail()
+                }
+            }
+            cancelButton()
+            if (isDynamicAvailable) neutralButton(text = "立即生效") { refreshSystemUI(context) }
+        }
+    }
+
+    /**
+     * 刷新系统界面状态栏与通知图标
+     * @param context 实例
+     * @param isRefreshCacheOnly 仅刷新缓存不刷新图标和通知改变 - 默认：否
+     * @param callback 成功后回调
+     */
+    fun refreshSystemUI(context: Context? = null, isRefreshCacheOnly: Boolean = false, callback: () -> Unit = {}) {
+        /**
+         * 刷新系统界面
+         * @param result 回调结果
+         */
+        fun doRefresh(result: (Boolean) -> Unit) {
+            context?.dataChannel(PackageName.SYSTEMUI)?.with {
+                wait(CALL_MODULE_REFRESH_RESULT) { result(it) }
+                put(CALL_HOST_REFRESH_CACHING, isRefreshCacheOnly)
+            }
+        }
+        when {
+            YukiHookAPI.Status.isXposedModuleActive && context is AppCompatActivity ->
+                context.showDialog {
+                    title = "请稍后"
+                    progressContent = "正在等待系统界面刷新"
+                    /** 是否等待成功 */
+                    var isWaited = false
+                    /** 设置等待延迟 */
+                    delayedRun(ms = 5000) {
+                        if (isWaited) return@delayedRun
+                        cancel()
+                        context.snake(msg = "预计响应超时，建议重启系统界面", actionText = "立即重启") { restartSystemUI(context) }
+                    }
+                    checkingActivated(context) { isValied ->
+                        when {
+                            isValied.not() -> {
+                                cancel()
+                                isWaited = true
+                                context.snake(msg = "请重启系统界面以生效模块更新", actionText = "立即重启") { restartSystemUI(context) }
+                            }
+                            else -> doRefresh {
+                                cancel()
+                                isWaited = true
+                                callback()
+                                if (it.not()) context.snake(msg = "刷新失败，建议重启系统界面", actionText = "立即重启") { restartSystemUI(context) }
+                            }
+                        }
+                    }
+                    noCancelable()
+                }
+            YukiHookAPI.Status.isXposedModuleActive.not() && context is AppCompatActivity -> context.snake(msg = "模块没有激活，更改不会生效")
+            else -> doRefresh { callback() }
+        }
+    }
+
+    /**
+     * 显示需要重启系统界面的 [Snackbar]
+     * @param context 实例
+     */
+    fun showNeedRestartSnake(context: Context) =
+        if (YukiHookAPI.Status.isXposedModuleActive)
+            context.snake(msg = "设置需要重启系统界面才能生效", actionText = "立即重启") { restartSystemUI(context) }
+        else context.snake(msg = "模块没有激活，更改不会生效")
+}

app/src/main/java/com/fankes/miui/notify/view/MaterialSwitch.kt

@@ -1,68 +0,0 @@
-/*
- * Copyright (C) 2022. Fankes Studio(qzmmcn@163.com)
- *
- * This file is part of MIUINativeNotifyIcon.
- *
- * MIUINativeNotifyIcon is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * MIUINativeNotifyIcon is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * This file is Created by fankes on 2022/1/8.
- */
-
-@file:Suppress("SameParameterValue")
-
-package com.fankes.miui.notify.view
-
-import android.content.Context
-import android.content.res.ColorStateList
-import android.graphics.Color
-import android.util.AttributeSet
-import androidx.appcompat.widget.SwitchCompat
-import com.fankes.miui.notify.utils.dp
-import com.fankes.miui.notify.utils.drawable.drawabletoolbox.DrawableBuilder
-
-class MaterialSwitch(context: Context, attrs: AttributeSet?) : SwitchCompat(context, attrs) {
-
-    private fun toColors(selected: Int, pressed: Int, normal: Int): ColorStateList {
-        val colors = intArrayOf(selected, pressed, normal)
-        val states = arrayOfNulls<IntArray>(3)
-        states[0] = intArrayOf(android.R.attr.state_checked)
-        states[1] = intArrayOf(android.R.attr.state_pressed)
-        states[2] = intArrayOf()
-        return ColorStateList(states, colors)
-    }
-
-    init {
-        trackDrawable = DrawableBuilder()
-            .rectangle()
-            .rounded()
-            .solidColor(0xFF656565.toInt())
-            .height(20.dp)
-            .cornerRadius(15.dp)
-            .build()
-        thumbDrawable = DrawableBuilder()
-            .rectangle()
-            .rounded()
-            .solidColor(Color.WHITE)
-            .size(20.dp, 20.dp)
-            .cornerRadius(20.dp)
-            .strokeWidth(2.dp)
-            .strokeColor(Color.TRANSPARENT)
-            .build()
-        trackTintList = toColors(
-            0xFF656565.toInt(),
-            0xFFCCCCCC.toInt(),
-            0xFFCCCCCC.toInt()
-        )
-    }
-}

app/src/main/java/com/fankes/miui/notify/wrapper/BuildConfigWrapper.kt

@@ -0,0 +1,37 @@
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2017-2023 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
+ *
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
+ *
+ * This file is created by fankes on 2023/9/17.
+ */
+@file:Suppress("unused")
+
+package com.fankes.miui.notify.wrapper
+
+import com.fankes.miui.notify.BuildConfig
+
+/**
+ * 对 [BuildConfig] 的包装
+ */
+object BuildConfigWrapper {
+    const val APPLICATION_ID = BuildConfig.APPLICATION_ID
+    const val VERSION_NAME = BuildConfig.VERSION_NAME
+    const val VERSION_CODE = BuildConfig.VERSION_CODE
+    val isDebug = BuildConfig.DEBUG
+}

app/src/main/res/drawable/bg_button_round.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ripple xmlns:android="http://schemas.android.com/apk/res/android"
+    android:color="#777777">
+    <item>
+        <shape android:shape="rectangle">
+            <solid android:color="#66DAD9D9" />
+            <corners android:radius="15dp" />
+        </shape>
+    </item>
+</ripple>

app/src/main/res/drawable/bg_orange_round.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+    android:shape="rectangle">
+    <solid android:color="#FF7043" />
+    <corners android:radius="15dp" />
+</shape>

app/src/main/res/drawable/bg_yellow_round.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+    android:shape="rectangle">
+    <solid android:color="#FF9800" />
+    <corners android:radius="15dp" />
+</shape>

app/src/main/res/drawable/ic_about.xml

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="150.1dp"
+    android:height="150dp"
+    android:viewportWidth="1025"
+    android:viewportHeight="1024">
+    <path
+        android:fillColor="#ffffff"
+        android:pathData="M983.8,314.4c-25.7,-60.8 -62.5,-115.4 -109.4,-162.3 -46.9,-46.9 -101.5,-83.7 -162.3,-109.4 -62.9,-26.7 -129.9,-40.2 -198.8,-40.2S377.5,16 314.5,42.7C253.8,68.4 199.1,105.2 152.3,152.2c-46.9,46.9 -83.7,101.5 -109.4,162.3 -26.7,62.9 -40.2,129.9 -40.2,198.8s13.5,135.8 40.2,198.8c25.7,60.8 62.5,115.4 109.4,162.3 46.9,46.9 101.5,83.7 162.3,109.4 62.9,26.7 129.9,40.2 198.8,40.2s135.8,-13.5 198.8,-40.2c60.8,-25.7 115.4,-62.5 162.3,-109.4 46.9,-46.9 83.7,-101.5 109.4,-162.3 26.7,-62.9 40.2,-129.9 40.2,-198.8s-13.6,-135.9 -40.3,-198.9zM550.5,768.2c0,21 -17,38 -38,38s-38,-17 -38,-38L474.5,395.6c0,-21 17,-38 38,-38s38,17 38,38v372.6zM510.8,305.5c-29.2,0 -52.7,-23.7 -52.7,-52.7 0,-29.2 23.7,-52.7 52.7,-52.7 29.2,0 52.7,23.7 52.7,52.7 0.1,29.2 -23.6,52.7 -52.7,52.7z" />
+</vector>

app/src/main/res/drawable/ic_back.xml

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="192dp"
+    android:height="150.39165dp"
+    android:viewportWidth="1307"
+    android:viewportHeight="1024">
+    <path
+        android:fillColor="#ffffff"
+        android:pathData="M268.7,566.5h929.6c36.3,0 72.6,-29 72.6,-72.6 0,-36.3 -29,-72.6 -72.6,-72.6H305l297.8,-297.8c29,-29 29,-72.6 0,-101.7 -29,-29 -72.6,-29 -101.7,0L72.6,450.3c-14.5,14.5 -21.8,36.3 -21.8,58.1 0,21.8 0,43.6 21.8,58.1l428.5,428.5c29,29 72.6,29 101.7,0 29,-29 29,-72.6 0,-101.7l-334.1,-326.8z" />
+</vector>

app/src/main/res/drawable/ic_filter.xml

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="184.6dp"
+    android:height="150dp"
+    android:viewportWidth="1260"
+    android:viewportHeight="1024">
+    <path
+        android:fillColor="#ffffff"
+        android:pathData="M419.2,548.3L17,108.9C-23.6,64.4 13,0 79.7,0h846.5c66.6,0 103.3,64.4 62.8,108.9l-402.2,439.3v472.7c0,1.6 -1.3,2.9 -2.8,2.9a8.3,8.3 0,0 1,-5.2 -1.8l-154.3,-120a13.7,13.7 0,0 1,-5.3 -10.8L419.2,548.3zM838.2,511.9L1257.3,511.9L1257.3,597.2h-419.1L838.2,511.9zM838.2,682.5L1257.3,682.5v85.3h-419.1L838.2,682.5zM838.2,853.2L1257.3,853.2v85.3h-419.1v-85.3z" />
+</vector>

app/src/main/res/drawable/ic_function.xml

@@ -0,0 +1,52 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="32dp"
+    android:height="32dp"
+    android:viewportWidth="48"
+    android:viewportHeight="48">
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M11,16V42"
+        android:strokeWidth="4"
+        android:strokeColor="#ffffff"
+        android:strokeLineCap="round"
+        android:strokeLineJoin="round" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M24,29V42"
+        android:strokeWidth="4"
+        android:strokeColor="#ffffff"
+        android:strokeLineCap="round"
+        android:strokeLineJoin="round" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M24,19V6"
+        android:strokeWidth="4"
+        android:strokeColor="#ffffff"
+        android:strokeLineCap="round"
+        android:strokeLineJoin="round" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M37,6V32"
+        android:strokeWidth="4"
+        android:strokeColor="#ffffff"
+        android:strokeLineCap="round"
+        android:strokeLineJoin="round" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M11,16C13.761,16 16,13.761 16,11C16,8.239 13.761,6 11,6C8.239,6 6,8.239 6,11C6,13.761 8.239,16 11,16Z"
+        android:strokeWidth="4"
+        android:strokeColor="#ffffff"
+        android:strokeLineJoin="round" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M24,29C26.761,29 29,26.761 29,24C29,21.239 26.761,19 24,19C21.239,19 19,21.239 19,24C19,26.761 21.239,29 24,29Z"
+        android:strokeWidth="4"
+        android:strokeColor="#ffffff"
+        android:strokeLineJoin="round" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M37,42C39.761,42 42,39.761 42,37C42,34.239 39.761,32 37,32C34.239,32 32,34.239 32,37C32,39.761 34.239,42 37,42Z"
+        android:strokeWidth="4"
+        android:strokeColor="#ffffff"
+        android:strokeLineJoin="round" />
+</vector>

app/src/main/res/drawable/ic_github.xml

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="150dp"
+    android:height="150dp"
+    android:viewportWidth="1024"
+    android:viewportHeight="1024">
+    <path
+        android:fillColor="#ffffff"
+        android:pathData="M512,12.6c-282.8,0 -512,229.2 -512,512 0,226.2 146.7,418.1 350.1,485.8 25.6,4.7 35,-11.1 35,-24.6 0,-12.2 -0.5,-52.5 -0.7,-95.3 -142.5,31 -172.5,-60.4 -172.5,-60.4 -23.3,-59.2 -56.8,-74.9 -56.8,-74.9 -46.5,-31.8 3.5,-31.1 3.5,-31.1 51.4,3.6 78.5,52.8 78.5,52.8 45.7,78.3 119.8,55.6 149,42.6 4.6,-33.1 17.9,-55.7 32.5,-68.5 -113.7,-12.9 -233.3,-56.9 -233.3,-253 0,-55.9 20,-101.6 52.8,-137.4 -5.3,-12.9 -22.8,-65 5,-135.5 0,0 43,-13.8 140.8,52.5 40.8,-11.4 84.6,-17 128.2,-17.2 43.5,0.2 87.3,5.9 128.3,17.2 97.7,-66.2 140.6,-52.5 140.6,-52.5 27.9,70.5 10.3,122.6 5,135.5 32.8,35.8 52.7,81.5 52.7,137.4 0,196.6 -119.8,239.9 -233.8,252.6 18.4,15.9 34.7,47 34.7,94.8 0,68.5 -0.6,123.6 -0.6,140.5 0,13.6 9.2,29.6 35.2,24.6 203.3,-67.8 349.9,-259.6 349.9,-485.8 0,-282.8 -229.2,-512 -512,-512z" />
+</vector>

app/src/main/res/drawable/ic_home.xml

@@ -0,0 +1,25 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="32dp"
+    android:height="32dp"
+    android:viewportWidth="48"
+    android:viewportHeight="48">
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M9,18V42H39V18L24,6L9,18Z"
+        android:strokeWidth="4"
+        android:strokeColor="#ffffff"
+        android:strokeLineCap="round"
+        android:strokeLineJoin="round" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,29V42H29V29H19Z"
+        android:strokeWidth="4"
+        android:strokeColor="#ffffff"
+        android:strokeLineJoin="round" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M9,42H39"
+        android:strokeWidth="4"
+        android:strokeColor="#ffffff"
+        android:strokeLineCap="round" />
+</vector>

app/src/main/res/drawable/ic_info.xml

@@ -0,0 +1,30 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="32dp"
+    android:height="32dp"
+    android:viewportWidth="48"
+    android:viewportHeight="48">
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M24,44C29.523,44 34.523,41.761 38.142,38.142C41.761,34.523 44,29.523 44,24C44,18.477 41.761,13.477 38.142,9.858C34.523,6.239 29.523,4 24,4C18.477,4 13.477,6.239 9.858,9.858C6.239,13.477 4,18.477 4,24C4,29.523 6.239,34.523 9.858,38.142C13.477,41.761 18.477,44 24,44Z"
+        android:strokeWidth="4"
+        android:strokeColor="#ffffff"
+        android:strokeLineJoin="round" />
+    <path
+        android:fillColor="#ffffff"
+        android:fillType="evenOdd"
+        android:pathData="M24,11C25.381,11 26.5,12.119 26.5,13.5C26.5,14.881 25.381,16 24,16C22.619,16 21.5,14.881 21.5,13.5C21.5,12.119 22.619,11 24,11Z" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M24.5,34V20H23.5H22.5"
+        android:strokeWidth="4"
+        android:strokeColor="#ffffff"
+        android:strokeLineCap="round"
+        android:strokeLineJoin="round" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M21,34H28"
+        android:strokeWidth="4"
+        android:strokeColor="#ffffff"
+        android:strokeLineCap="round"
+        android:strokeLineJoin="round" />
+</vector>

app/src/main/res/drawable/ic_message.xml

@@ -0,0 +1,10 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="48dp"
+    android:height="48dp"
+    android:viewportWidth="1024"
+    android:viewportHeight="1024">
+    <path
+        android:fillColor="#ffffff"
+        android:pathData="m522.8,93.9c-244.2,0 -442.1,173.2 -442.1,386.9 0,122.1 64.9,230.9 165.8,301.7v195.7l193.7,-117.5c26.8,4.4 54.3,7 82.6,7 244.2,0 442.1,-173.2 442.1,-386.9C965,267.1 767.1,93.9 522.8,93.9Z"
+        android:strokeWidth="1.10883" />
+</vector>

app/src/main/res/drawable/ic_modify.xml

@@ -0,0 +1,36 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="32dp"
+    android:height="32dp"
+    android:viewportWidth="48"
+    android:viewportHeight="48">
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M20.071,9.586L15.828,5.343C15.047,4.562 13.781,4.562 13,5.343L7.343,11C6.562,11.781 6.562,13.047 7.343,13.828L11.586,18.071"
+        android:strokeWidth="4"
+        android:strokeColor="#ffffff"
+        android:strokeLineCap="round"
+        android:strokeLineJoin="round" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M28.929,37.414L33.171,41.657C33.952,42.438 35.219,42.438 36,41.657L41.657,36C42.438,35.219 42.438,33.953 41.657,33.172L37.414,28.929"
+        android:strokeWidth="4"
+        android:strokeColor="#ffffff"
+        android:strokeLineCap="round"
+        android:strokeLineJoin="round" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M36.021,6.322L41.677,11.979A2,2 0,0 1,41.677 14.808L14.807,41.678A2,2 0,0 1,11.979 41.678L6.322,36.021A2,2 132.403,0 1,6.322 33.192L33.192,6.322A2,2 102.008,0 1,36.021 6.322z"
+        android:strokeWidth="4"
+        android:strokeColor="#ffffff"
+        android:strokeLineCap="round"
+        android:strokeLineJoin="round" />
+    <path
+        android:fillColor="#ffffff"
+        android:pathData="M24,24m-2,0a2,2 0,1 1,4 0a2,2 0,1 1,-4 0" />
+    <path
+        android:fillColor="#ffffff"
+        android:pathData="M20,28m-2,0a2,2 0,1 1,4 0a2,2 0,1 1,-4 0" />
+    <path
+        android:fillColor="#ffffff"
+        android:pathData="M28,20m-2,0a2,2 0,1 1,4 0a2,2 0,1 1,-4 0" />
+</vector>

app/src/main/res/drawable/ic_nf_icon_update.xml

@@ -0,0 +1,10 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:tint="@color/white"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="#ffffffff"
+        android:pathData="M19.35,10.04C18.67,6.59 15.64,4 12,4 9.11,4 6.6,5.64 5.35,8.04 2.34,8.36 0,10.91 0,14c0,3.31 2.69,6 6,6h13c2.76,0 5,-2.24 5,-5 0,-2.64 -2.05,-4.78 -4.65,-4.96zM14,13v4h-4v-4H7l5,-5 5,5h-3z" />
+</vector>

app/src/main/res/drawable/ic_notify.xml

@@ -0,0 +1,20 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="32dp"
+    android:height="32dp"
+    android:viewportWidth="48"
+    android:viewportHeight="48">
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M10,38V18C10,10.268 16.268,4 24,4C31.732,4 38,10.268 38,18V38M4,38H44"
+        android:strokeWidth="4"
+        android:strokeColor="#ffffff"
+        android:strokeLineCap="round"
+        android:strokeLineJoin="round" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M24,44C26.761,44 29,41.761 29,39V38H19V39C19,41.761 21.239,44 24,44Z"
+        android:strokeWidth="4"
+        android:strokeColor="#ffffff"
+        android:strokeLineCap="round"
+        android:strokeLineJoin="round" />
+</vector>