fix: prefer Gitea download URL when versions equal (China-reachable)

Same-version update was picking GitHub URL (crowded first) which downloads fail in China. Now Gitea info is inserted before GitHub so maxByOrNull takes the Gitea one on version tie. version 1.9.0 -> 1.9.1 (code 29 -> 30) Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
docs: update tagline
2026-07-10 14:35:59 +08:00 · 2026-07-10 14:22:21 +08:00 · 2026-07-10 14:19:57 +08:00 · 2026-07-10 14:15:19 +08:00 · 2026-07-10 14:13:53 +08:00 · 2026-07-10 13:40:15 +08:00
29 changed files with 2024 additions and 614 deletions
@@ -10,6 +10,7 @@ local.properties

 # Secrets — never commit
 gh-token.txt
+gitea-token.txt
 *.token

 # Android Studio / IntelliJ
@@ -31,3 +32,4 @@ test.json
 # Local assistant session helpers
 .claude/
 do.ps1
+CLAUDE.md
@@ -1,121 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## 项目概述
-
-**a2i** — 安卓通知转发到 iOS Bark。监听 Android 系统通知（短信、验证码、聊天等），通过 Bark Server 推送到 iOS 设备。iOS 端点击通知可跳转到对应 App（微信、QQ、Telegram）。
-
-## 环境配置（本机）
-
-环境变量需要在每次 shell 调用前显式导出：
-
-```bash
-export JAVA_HOME="D:/Dev/JDK-17"
-export ANDROID_HOME="D:/Dev/Android/SDK"
-```
-
- JDK 17: `D:\Dev\JDK-17`（项目使用 `sourceCompatibility = VERSION_17`）
- Android SDK: `D:\Dev\Android\SDK`
- Gradle 8.11.1（wrapper 内置）
- AGP 8.9.1 / Kotlin 2.1.0
-
-`local.properties` 已在项目根（`sdk.dir=D:\Dev\Android\SDK`），**不要提交**。
-
-## 构建与安装
-
-```bash
-# 编译 debug APK
-export JAVA_HOME="D:/Dev/JDK-17" ANDROID_HOME="D:/Dev/Android/SDK"
-./gradlew assembleDebug
-
-# 产物位置
-app/build/outputs/apk/debug/app-debug.apk
-
-# 安装到已连接的设备
-"D:/Dev/Android/SDK/platform-tools/adb.exe" install -r app/build/outputs/apk/debug/app-debug.apk
-```
-
-无 lint / 测试任务配置（项目未启用）。改完代码直接 `assembleDebug` 验证即可。
-
-构建可分发的 release APK（已绑定 debug 签名，产出可直接安装）：
-
-```bash
-export JAVA_HOME="D:/Dev/JDK-17" ANDROID_HOME="D:/Dev/Android/SDK"
-./gradlew assembleRelease
-# 产物：app/build/outputs/apk/release/app-release.apk
-adb install -r app/build/outputs/apk/release/app-release.apk
-```
-
-> `release` 复用 `debug` 签名配置（`signingConfigs.getByName("debug")`），适合个人发布到 GitHub Release；正式商店上架前需替换为独立的 release keystore。
-
-## 架构
-
-### 核心数据流
-
-```
-NotifyListenerService (系统通知入口)
-  → NotificationProcessor.process(sbn) → Decision(message?, reason, code, silent)
-    ├─ 在线：BarkClient.push(msg) → OkHttp POST；失败入 pending → RetryWorker (15min 周期)
-    └─ 离线：紧要通知(验证码/来电) → SmsFallbackForwarder 走短信兜底
-  → LogStore.addLog(...)（silent 的静默过滤不写日志）
-
-旁路（不经通知监听器）：
-  PhoneCallMonitor 轮询 getCallState() → 来电/未接构造 Decision 推送（绕过 MIUI 限制）
-  UpdateChecker 查 GitHub Releases → 新版本横幅 → 应用内下载 + 系统安装器
-```
-
-### 包结构 `com.a2i.forwarder`
-
-| 文件 | 职责 |
-|---|---|
-| `A2iApp.kt` | `Application` 单例；持有全局 `appScope`（`SupervisorJob+Dispatchers.Default`）与全局组件：三个 Store（`settings`/`appRules`/`logStore`）+ 监听类（`phoneCallMonitor`/`connectivityMonitor`/`carrierBalanceQuery`/`smsForwarder`/`updateChecker`）。全部经 `A2iApp.instance.xxx` 访问，`onCreate` 构造并 `start()`。UI 通过 `collectAsState()` 订阅 Store 的 `StateFlow`。 |
-| `service/NotifyListenerService.kt` | `NotificationListenerService` 实现；每条通知调 `processor.process()`，过滤后推送。 |
-| `core/NotificationProcessor.kt` | **核心决策点**。包含 LRU 去重缓存（5s）、脱敏检测（`*****` → 回退到 `tickerText`）、系统状态消息过滤、广告过滤、验证码提取、特殊 App 解析。返回 `Decision(message?, reason, appLabel, code)`。 |
-| `core/CodeExtractor.kt` | 三段正则：关键词+数字、数字+关键词、纯数字 4-8 位。检测到全 `*****` 时直接返回 null。 |
-| `core/AdFilter.kt` | 内置营销关键词 + 用户自定义关键词（`settings.adKeywords`）。 |
-| `core/AppParsers.kt` | 微信/QQ/Telegram 的 `clickUrl` 映射 + 重要消息关键词（@我、验证码、通话等）。 |
-| `core/BarkClient.kt` | OkHttp POST 到 `${server}/push`，超时 10/10/15s；对 connection closed / 超时 / TLS 中断等瞬时 IOException 自动重试 3 次（退避 600/1200ms），HTTP 4xx/5xx 不重试。 |
-| `core/RetryWorker.kt` | WorkManager 周期任务，每 15 分钟重发 `pending` 队列中的失败消息。 |
-| `core/LogStore.kt` | 最近 300 条日志 + 失败重发队列（≤100）。DataStore 持久化。 |
-| `core/IconExporter.kt` | 一键导出所有已安装 App 图标到用户选择的 SAF 目录（用于部署到 iOS Bark 图床）。 |
-| `core/PhoneCallMonitor.kt` | 轮询 `TelephonyManager.getCallState()`（800ms）感知来电/未接来电，构造 Decision 推送。绕过 MIUI 不向第三方监听器分发系统电话通知的限制。 |
-| `core/ConnectivityMonitor.kt` | `ConnectivityManager` + `NetworkCallback`，暴露 `isOnline: StateFlow<Boolean>`，供离线兜底判断。 |
-| `core/CarrierDetector.kt` | SIM MCC+MNC 映射到运营商（移动/联通/电信/广电），供短信兜底发免费查询码。 |
-| `core/CarrierBalanceQuery.kt` | 向运营商服务号发查询短信、解析回执余量、余额≤5 自动挂起。 |
-| `core/SmsFallbackForwarder.kt` | 断网时把紧要通知（验证码/来电）用短信发到 iPhone，5 分钟限频 + 余额检查。 |
-| `core/UpdateChecker.kt` | 查 GitHub Releases 最新版（24h 节流）→ 语义比较 → 下载 APK → FileProvider 调起系统安装器。 |
-| `store/SettingsStore.kt` | Bark 服务器列表、全局开关、广告关键词等。`MutableStateFlow` + DataStore。 |
-| `store/AppRulesStore.kt` | 黑/白名单模式 + 默认黑名单（系统 App + 输入法 + 三星剪贴板/键盘 + GMS + 录音机/相册/查找/密码管理 + 通话管理/AI通话）；默认黑名单带版本号 `bl_version`，升级时把新增噪音包合并进老用户黑名单（只增不删）。 |
-| `ui/nav/AppNav.kt` | 4 个底部 Tab + 日志页。 |
-| `ui/theme/*` | 固定品牌配色（`Color.kt`）、自定义 `Typography`（`Type.kt`），`A2iTheme` 关闭动态取色、统一深浅色方案（`Theme.kt`）。 |
-| `ui/screens/*.kt` | HomeScreen（品牌横幅 + 运行状态 + 统计 + 更新横幅 + 短信挂起提醒）、AppManageScreen、FilterScreen、SettingsScreen（Bark 服务 / 应用图标 / 断网短信兜底 / 关于与更新）、LogScreen、UpdateDialog（应用内更新弹窗）。 |
-| `ui/Components.kt` | 共享 UI 组件层：`ScreenTitle`、`SectionCard`、`SwitchRow`、`ClickRow`、`IconBox`、`StatusBadge`、`MetricBlock`，以及 `appVersionName(context)`、`drawableToImageBitmap(d)`、`isNotificationListenerEnabled(context)` 工具函数。 |
-
-### 重要约定
-
- **Store 全局单例**：所有 Store 通过 `A2iApp.instance.xxx` 访问。**不要**在 Compose 中创建新的 Store 实例。
- **协程作用域**：跨屏调用用 `app.appScope.launch { ... }`（Application 级别的 `SupervisorJob + Dispatchers.Default`）。
- **过滤流水线**（顺序很重要，在 `NotificationProcessor.process` 中）：
-  1. 全局开关 → 2. ongoing 过滤（静默）→ 3. App 黑/白名单 → 4. 空内容/脱敏 → 5. 噪音包名 → 6. 系统状态消息 → 7. 近空内容 → 8. 广告过滤 → 9. 已发短信（仅收不发）→ 10. 运营商余额回执拦截 → **11. 去重检查（5s 窗口）** → 12. 验证码提取 → 13. 特殊 App 解析 → 14. 构造 BarkMessage
- **Bark API** 字段映射在 `BarkMessage.kt`（`@SerialName`）：`device_key`/`autoCopy`/`isArchive` 用下划线/驼峰别名，其他用蛇形。
- **版本号**：`app/build.gradle.kts` 的 `versionCode`/`versionName`，运行时通过 `appVersionName(context)` 读取，首页底部居中显示 `v{version}`。**改完代码同步递增 versionCode/versionName，并更新本文档「版本与发布」一节的当前版本。**
-
-### 通知监听授权
-
-监听服务依赖 `Settings.ACTION_NOTIFICATION_LISTENER_SETTINGS` 授权。`HomeScreen` 检测授权状态，未授权时显示跳转按钮。授权是**一次性**的，卸载后需重新授权。
-
-### 调试日志
-
-`NotifyListenerService.handle()` 每次都会写一条 `ForwardLog` 到 `LogStore`（无论转发/过滤/失败），可在「日志」页查看最近 300 条。失败会自动加入 `pending` 队列，由 `RetryWorker` 后续重发。
-
-## 版本与发布
-
- 当前版本：`versionCode = 9`、`versionName = "1.5.1"`（位于 `app/build.gradle.kts`）。**每次改动后同步递增 versionCode/versionName，并同步更新本节。**
- 远端仓库：`https://github.com/lsxf/a2i.git`，默认分支 `main`。
- 提交策略：`.gitignore` 已排除 `app/build`、`.gradle`、`.kotlin`、`local.properties`、`.claude/`、`do.ps1`、`gh-token.txt`（发版用 token）、`*.token`、截图与临时文件，**不要**提交它们。
- 发版流程：
-  1. 递增 `versionCode`/`versionName` → `./gradlew assembleRelease`（产物 `app/build/outputs/apk/release/app-release.apk`）
-  2. `git tag -a v{versionName} -m "..."` → `git push origin v{versionName}`
-  3. 本机无 `gh` CLI：用 python(urllib) 调 GitHub API 创建 Release + 上传 APK。token 放仓库根 `gh-token.txt`（已 gitignore），脚本里 `open('gh-token.txt')` 读取，**勿**把 token 写进命令参数。注意 Git Bash 的 `/tmp` 与 Windows python 路径不一致，脚本内一律用项目相对路径。
- UI 现状：统一品牌科技感主题（固定品牌色 + 自定义 Typography + 共享组件层），深浅色双方案，关闭动态取色；新组件统一通过 `ui/Components.kt` 复用，避免各页面各拼一套样式。
@@ -1,13 +1,15 @@
-# A2i ·安到果（按倒过[呲牙]）
+# GotMsg ·有消息

-把安卓手机上的通知（短信、验证码、电话“有电话进来这个通知，不是电话呼叫转移”、微信、QQ、Telegram 等）实时转发到 iOS，通过 [Bark](https://github.com/Finb/Bark) 推送到 iPhone / iPad。在 iOS 上点击通知，还能一键跳转到对应的 App。
+把安卓手机上的通知（短信、验证码、电话“有电话进来这个通知，不是电话呼叫转移”、微信、QQ、Telegram 等）实时转发到 iOS / Android / 鸿蒙等接收端。iOS 可通过 [Bark](https://github.com/Finb/Bark) 推送到 iPhone / iPad；Android 可用 ntfy；鸿蒙可用 Meow。在 iOS 上点击通知，还能一键跳转到对应的 App。

-适用于把安卓备机的消息同步到 iOS 设备，不漏验证码、不漏重要聊天。
+适用于把安卓备机的消息同步到 iPhone 或其他安卓 / 鸿蒙手机，不漏验证码、不漏重要聊天。
+
+![GotMsg 设置页](screenshots/overview.png)

 ## 主要功能

 - **系统级通知监听**：接入 Android 通知监听服务，覆盖所有发出通知的 App。
- **Bark 推送**：支持官方 Bark 服务和自建 Bark Server，可保存多个服务器并随时切换。
+- **多通道推送**：支持 Bark、ntfy、Meow、电邮和短信兜底；每个通道可保存多个目标，勾选参与转发，并支持“发通一条就停”或全部广播。
 - **验证码自动提取**：自动识别通知中的验证码，收到即复制，也可点击复制。
 - **通知优化**：
  - 广告关键词过滤（内置 + 自定义）
@@ -35,14 +37,16 @@

 1. 在 iOS 上安装 [Bark](https://apps.apple.com/us/app/bark-customed-push/id1613210986)。
 2. 打开 Bark，复制你的专属推送地址，形如 `https://api.day.app/你的Key`。
-3. 在 a2i 的「设置」中添加服务器：
+3. 在 GotMsg 的「设置」中添加服务器：
   - 名称：随意，例如「我的 iPhone」
   - 服务器地址：`https://api.day.app`（自建则填自建地址）
   - Device Key：Bark 地址中的那段 Key

+如果接收端是 Android 或鸿蒙手机，也可以在「设置」里配置 ntfy 或 Meow；对应区块右上角有帮助按钮，按弹窗步骤填写服务器地址、Topic / Device Key 后点测试发送。
+
 ### 3. 授权通知监听

-打开 a2i，首页会提示「需要授权通知监听」。点击「前往系统授权」，在系统的通知访问设置中开启 a2i。
+打开 GotMsg，首页会提示「需要授权通知监听」。点击「前往系统授权」，在系统的通知访问设置中开启 GotMsg。

 > 授权是一次性的，卸载后重新安装需要再次授权。

@@ -56,12 +60,12 @@
 - **想同步聊天**：保持黑名单模式（默认），在「过滤」页开启「微信 / QQ / Telegram 优化」。
 - **通知没推过来**：先看「日志」页，每条通知（无论转发、过滤还是失败）都会记录原因。
 - **想让通知带图标**：参考下方「应用图标」一节。
- **电话通知不工作**：MIUI 会把系统电话通知限制为不向第三方通知监听器分发，本 App 通过轮询 `getCallonyState()` 绕过此限制。需要授予「电话」权限（设置 → 应用 → a2i → 权限 → 电话）。
+- **电话通知不工作**：MIUI 会把系统电话通知限制为不向第三方通知监听器分发，本 App 通过轮询 `getCallonyState()` 绕过此限制。需要授予「电话」权限（设置 → 应用 → GotMsg → 权限 → 电话）。
 - **断网收不到通知**：开启「设置 → 断网短信兜底」，填好 iPhone 号码、授予短信权限、设好手动额度。断网时验证码和来电会走短信（消耗套餐额度，5 分钟限 1 条）。

 ## 应用图标

-Bark 的 `icon` 字段需要一个公网可访问的图片 URL。a2i 支持把已安装 App 的图标批量导出到你选择的目录，方便上传到你自己的图床。
+Bark 的 `icon` 字段需要一个公网可访问的图片 URL。GotMsg 支持把已安装 App 的图标批量导出到你选择的目录，方便上传到你自己的图床。

 规则：转发时 `icon = 图标 URL 前缀 + 安卓包名 + .png`。在「设置 → 应用图标」里：

@@ -73,7 +77,7 @@ Bark 的 `icon` 字段需要一个公网可访问的图片 URL。a2i 支持把

 ## 自建 Bark 服务（可选）

-a2i 默认用 Bark 官方服务器（`https://api.day.app`），免费够用。如果想完全自控、不限速、不依赖第三方，可以自建 Bark Server。下面是三种零成本方案：
+GotMsg 默认用 Bark 官方服务器（`https://api.day.app`），免费够用。如果想完全自控、不限速、不依赖第三方，可以自建 Bark Server。下面是三种零成本方案：

 ### 方案 1：Vercel 云托管（最适合新手）

@@ -107,7 +111,7 @@ a2i 默认用 Bark 官方服务器（`https://api.day.app`），免费够用。

 - Kotlin + Jetpack Compose（Material 3）
 - AndroidX DataStore（持久化设置与日志）
- OkHttp（Bark 推送）
+- OkHttp（Bark / ntfy / Meow / 更新检查）
 - WorkManager（失败重试）
 - Navigation Compose（单 Activity 多页面）
 - 最低 Android 14（API 34），目标 Android 16（API 36）
@@ -13,8 +13,8 @@ android {
        applicationId = "com.a2i.forwarder"
        minSdk = 34
        targetSdk = 36
-        versionCode = 9
-        versionName = "1.5.1"
+        versionCode = 29
+        versionName = "1.9.0"
    }

    signingConfigs {
@@ -36,7 +36,7 @@ class BarkClient(private val server: BarkServer) {
     * HTTP 4xx/5xx 是服务端拒绝，重试无意义，直接抛出。
     */
    private suspend fun doPushWithRetry(msg: BarkMessage) {
-        val body = json.encodeToString(msg).toRequestBody(JSON)
+        val body = json.encodeToString(msg.copy(deviceKey = server.deviceKey)).toRequestBody(JSON)
        val url = server.server.trim().removeSuffix("/") + "/push"
        val req = Request.Builder().url(url).post(body).build()
        var lastError: IOException? = null
@@ -0,0 +1,41 @@
+package com.a2i.forwarder.core
+
+import com.a2i.forwarder.model.BarkMessage
+import com.a2i.forwarder.model.BarkServer
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+/**
+ * 多服务器容错推送：按列表顺序依次尝试，首个成功即止。
+ * 全失败 → 返回最后一个错误；空列表 → "无可用服务器"。
+ */
+object BarkSender {
+    /** stopOnFirst=true：首个成功即止；false：全部发送，至少一个成功即算成功。 */
+    suspend fun pushToEnabled(servers: List<BarkServer>, msg: BarkMessage, stopOnFirst: Boolean): Result<Unit> = withContext(Dispatchers.IO) {
+        runCatching {
+            require(servers.any()) { "无可用服务器" }
+            if (stopOnFirst) return@runCatching pushToFirst(servers, msg).getOrThrow()
+            var anyOk = false
+            var lastErr: Throwable? = null
+            for (s in servers) {
+                val r = BarkClient(s).push(msg)
+                if (r.isSuccess) anyOk = true else lastErr = r.exceptionOrNull()
+            }
+            if (!anyOk) throw lastErr ?: error("全部推送失败")
+        }
+    }
+
+    /** 首个成功即止（stopOnFirst=true 的实现）。 */
+    suspend fun pushToFirst(servers: List<BarkServer>, msg: BarkMessage): Result<Unit> = withContext(Dispatchers.IO) {
+        runCatching {
+            require(servers.any()) { "无可用服务器" }
+            var lastErr: Throwable? = null
+            for (s in servers) {
+                val r = BarkClient(s).push(msg)
+                if (r.isSuccess) return@runCatching
+                lastErr = r.exceptionOrNull()
+            }
+            throw lastErr ?: error("推送失败")
+        }
+    }
+}
@@ -0,0 +1,129 @@
+package com.a2i.forwarder.core
+
+import com.a2i.forwarder.A2iApp
+import com.a2i.forwarder.model.EmailServer
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import java.io.BufferedReader
+import java.io.BufferedWriter
+import java.io.InputStreamReader
+import java.io.OutputStreamWriter
+import java.util.Base64
+import javax.net.ssl.SSLSocket
+import javax.net.ssl.SSLSocketFactory
+
+/**
+ * SMTP 直连发送纯文本邮件（SMTPS/隐式 TLS，端口 465）。
+ * 在 [Dispatchers.IO] 上执行，不阻塞主线程。
+ */
+object EmailSender {
+    suspend fun send(
+        host: String, port: Int, user: String, password: String,
+        from: String, to: String, subject: String, body: String,
+    ): Result<Unit> = withContext(Dispatchers.IO) {
+        runCatching {
+            val factory = SSLSocketFactory.getDefault()
+            // 隐式 TLS：直接通过 SSLSocketFactory 创建 SSLSocket 连接 SMTP 服务器（推荐端口 465）
+            val ssl = factory.createSocket(host, port) as SSLSocket
+            ssl.soTimeout = 15_000
+            ssl.startHandshake()
+            val reader: BufferedReader = ssl.inputStream.bufferedReader()
+            val writer: BufferedWriter = ssl.outputStream.bufferedWriter()
+
+            fun read(): String = reader.readLine() ?: error("连接关闭")
+            fun cmd(c: String) { writer.write("$c\r\n"); writer.flush() }
+
+            fun expectEhlo(): String {
+                cmd("EHLO a2i")
+                var last = ""
+                do { last = read() } while (last.startsWith("250-"))
+                if (!last.startsWith("250 ")) error("EHLO: $last")
+                return last
+            }
+
+            var r = read()
+            if (!r.startsWith("220")) error("SMTP: $r")
+            expectEhlo()
+
+            if (user.isNotBlank() && password.isNotBlank()) {
+                cmd("AUTH LOGIN")
+                r = read()
+                if (!r.startsWith("334")) error("AUTH: $r")
+                cmd(Base64.getEncoder().encodeToString(user.toByteArray()))
+                r = read()
+                if (!r.startsWith("334")) error("AUTH user: $r")
+                cmd(Base64.getEncoder().encodeToString(password.toByteArray()))
+                r = read()
+                if (!r.startsWith("235")) error("AUTH pass: $r")
+            }
+
+            cmd("MAIL FROM:<$from>")
+            r = read()
+            if (!r.startsWith("250")) error("FROM: $r")
+
+            cmd("RCPT TO:<$to>")
+            r = read()
+            if (!r.startsWith("250")) error("TO: $r")
+
+            cmd("DATA")
+            r = read()
+            if (!r.startsWith("354")) error("DATA: $r")
+
+            writer.write(buildMime(from, to, subject, body))
+            writer.write("\r\n.\r\n")
+            writer.flush()
+            r = read()
+            if (!r.startsWith("250")) error("SEND: $r")
+
+            cmd("QUIT")
+            runCatching { ssl.close() }
+            Unit
+        }
+    }
+
+    private fun buildMime(from: String, to: String, subject: String, body: String): String {
+        val subjB64 = Base64.getEncoder().encodeToString(subject.toByteArray(Charsets.UTF_8))
+        val bodyB64 = Base64.getEncoder().encodeToString(body.toByteArray(Charsets.UTF_8))
+        return buildString {
+            append("From: <$from>\r\n")
+            append("To: <$to>\r\n")
+            append("Subject: =?UTF-8?B?$subjB64?=\r\n")
+            append("MIME-Version: 1.0\r\n")
+            append("Content-Type: text/plain; charset=UTF-8\r\n")
+            append("Content-Transfer-Encoding: base64\r\n")
+            append("\r\n")
+            append(bodyB64)
+        }
+    }
+
+    /** 多配置推送：stopOnFirst=true 首个成功止；false 全部发送，至少一个成功即算成功。 */
+    suspend fun pushToEnabled(configs: List<EmailServer>, title: String, body: String, stopOnFirst: Boolean): Result<Unit> = withContext(Dispatchers.IO) {
+        runCatching {
+            require(configs.any()) { "无邮箱配置" }
+            var anyOk = false
+            var lastErr: Throwable? = null
+            for (c in configs) {
+                val r = send(c.host, c.port, c.user, c.password, c.from, c.to, title, body)
+                if (r.isSuccess) {
+                    anyOk = true
+                    if (stopOnFirst) return@runCatching
+                } else {
+                    lastErr = r.exceptionOrNull()
+                }
+            }
+            if (!anyOk) throw lastErr ?: error("全部邮件发送失败")
+        }
+    }
+
+    /** 如果电邮转发已启用且收件人非空，异步发邮件（fire-and-forget，不阻塞主流程）。 */
+    fun trySend(app: A2iApp, title: String, body: String, scope: CoroutineScope) {
+        val s = app.settings
+        val configs = s.emailServers.value.filter { it.enabled && it.to.isNotBlank() && it.host.isNotBlank() }
+        if (configs.isEmpty()) return
+        scope.launch {
+            pushToEnabled(configs, title, body, s.emailStopOnFirst.value)
+        }
+    }
+}
@@ -0,0 +1,145 @@
+package com.a2i.forwarder.core
+
+import com.a2i.forwarder.A2iApp
+import com.a2i.forwarder.model.MeowServer
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+import org.json.JSONObject
+import java.io.IOException
+import java.util.concurrent.TimeUnit
+
+/**
+ * Meow for HarmonyOS push channel.
+ *
+ * Meow's public API shape is less standardized than Bark/ntfy in this app,
+ * so this sender accepts a user-provided endpoint and tries common JSON/GET forms.
+ */
+object MeowSender {
+    private val http = OkHttpClient.Builder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .writeTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(15, TimeUnit.SECONDS)
+        .retryOnConnectionFailure(true)
+        .build()
+
+    suspend fun send(
+        server: String,
+        deviceKey: String,
+        title: String,
+        body: String,
+    ): Result<Unit> = withContext(Dispatchers.IO) {
+        runCatching {
+            val endpoint = server.trim().removeSuffix("/")
+            val key = deviceKey.trim()
+            require(endpoint.isNotBlank()) { "Meow 服务器地址未填" }
+            require(key.isNotBlank()) { "Meow Device Key 未填" }
+
+            val attempts = buildRequests(endpoint, key, title.take(200), body.take(4000))
+            var last: Throwable? = null
+            for (req in attempts) {
+                val r = runCatching { doPushWithRetry(req) }
+                if (r.isSuccess) return@runCatching
+                last = r.exceptionOrNull()
+            }
+            throw last ?: error("Meow 推送失败")
+        }
+    }
+
+    suspend fun pushToEnabled(configs: List<MeowServer>, title: String, body: String, stopOnFirst: Boolean): Result<Unit> = withContext(Dispatchers.IO) {
+        runCatching {
+            require(configs.any()) { "无 Meow 配置" }
+            var anyOk = false
+            var lastErr: Throwable? = null
+            for (c in configs) {
+                val r = send(c.server, c.deviceKey, title, body)
+                if (r.isSuccess) {
+                    anyOk = true
+                    if (stopOnFirst) return@runCatching
+                } else {
+                    lastErr = r.exceptionOrNull()
+                }
+            }
+            if (!anyOk) throw lastErr ?: error("全部 Meow 推送失败")
+        }
+    }
+
+    fun trySend(app: A2iApp, title: String, body: String, scope: CoroutineScope) {
+        val s = app.settings
+        val configs = s.meowServers.value.filter { it.enabled && it.server.isNotBlank() && it.deviceKey.isNotBlank() }
+        if (configs.isEmpty()) return
+        scope.launch {
+            pushToEnabled(configs, title, body, s.meowStopOnFirst.value)
+        }
+    }
+
+    private fun buildRequests(endpoint: String, key: String, title: String, body: String): List<Request> {
+        val payload = JSONObject()
+            .put("deviceKey", key)
+            .put("device_key", key)
+            .put("key", key)
+            .put("title", title)
+            .put("content", body)
+            .put("message", body)
+            .put("body", body)
+            .toString()
+
+        val postTargets = listOf(endpoint, "$endpoint/push").distinct()
+        val postRequests = postTargets.map { url ->
+            Request.Builder()
+                .url(url)
+                .header("Authorization", "Bearer $key")
+                .header("X-Device-Key", key)
+                .post(payload.toRequestBody(JSON))
+                .build()
+        }
+
+        val getRequest = endpoint.toHttpUrlOrNull()?.newBuilder()
+            ?.addQueryParameter("deviceKey", key)
+            ?.addQueryParameter("key", key)
+            ?.addQueryParameter("title", title)
+            ?.addQueryParameter("content", body)
+            ?.addQueryParameter("message", body)
+            ?.build()
+            ?.let { url ->
+                Request.Builder()
+                    .url(url)
+                    .header("Authorization", "Bearer $key")
+                    .header("X-Device-Key", key)
+                    .get()
+                    .build()
+            }
+
+        return postRequests + listOfNotNull(getRequest)
+    }
+
+    private fun doPushWithRetry(req: Request) {
+        var lastError: IOException? = null
+        repeat(MAX_ATTEMPTS) { attempt ->
+            try {
+                http.newCall(req).execute().use { res ->
+                    if (res.isSuccessful) return
+                    error("HTTP ${res.code}")
+                }
+            } catch (e: IOException) {
+                lastError = e
+                if (attempt < MAX_ATTEMPTS - 1) {
+                    Thread.sleep(BACKOFF_MS[attempt])
+                }
+            } catch (e: IllegalStateException) {
+                throw e
+            }
+        }
+        throw lastError ?: error("Meow 推送失败")
+    }
+
+    private val JSON = "application/json; charset=utf-8".toMediaType()
+    private const val MAX_ATTEMPTS = 3
+    private val BACKOFF_MS = longArrayOf(600L, 1200L)
+}
@@ -49,6 +49,15 @@ class NotificationProcessor(private val context: Context) {
        "com.google.android.gms",
    )

+    // 静默过滤的包名：代理/VPN 客户端的常驻流量通知，高频且无意义，过滤不写日志
+    private val silentPackages = setOf(
+        "com.getsurfboard",                 // Surfboard
+        "com.github.metacubex.clash.meta",  // Clash Meta for Android
+        "com.github.kr328.clash",           // Clash for Android
+        "com.v2ray.ang",                    // v2rayNG
+        "com.milink.service",               // 小米设备互联（UniversalClipboardService 跨设备剪贴板等常驻通知）
+    )
+
    fun process(sbn: StatusBarNotification): Decision {
        val pkg = sbn.packageName
        val n = sbn.notification ?: return Decision(null, "无通知", pkg, null)
@@ -94,6 +103,14 @@ class NotificationProcessor(private val context: Context) {
        if (settings.skipOngoing.value && isOngoing)
            return Decision(null, "持续性通知", appLabel, null, silent = true)

+        // ---- 静默包名过滤（VPN/代理客户端的常驻流量通知，高频无意义，不写日志）----
+        if (pkg in silentPackages)
+            return Decision(null, "常驻通知静默", appLabel, null, silent = true)
+
+        // ---- 米家泛化状态通知静默（"设备状态"等概览；门锁/告警等具体事件保留）----
+        if (pkg == "com.xiaomi.smarthome" && content.contains("设备状态"))
+            return Decision(null, "米家状态通知静默", appLabel, null, silent = true)
+
        // ---- App 黑白名单 ----
        if (!rules.isForwardingOn(pkg))
            return Decision(null, "此 App 已关", appLabel, null)
@@ -171,7 +188,7 @@ class NotificationProcessor(private val context: Context) {
        val level = if (important) "timeSensitive" else "active"

        val msg = BarkMessage(
-            deviceKey = settings.currentServer.value?.deviceKey.orEmpty(),
+            deviceKey = "",
            title = msgTitle.take(100),
            body = content.ifBlank { title }.take(500),
            level = level,
@@ -0,0 +1,102 @@
+package com.a2i.forwarder.core
+
+import com.a2i.forwarder.A2iApp
+import com.a2i.forwarder.model.NtfyServer
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.RequestBody.Companion.toRequestBody
+import org.json.JSONObject
+import java.io.IOException
+import java.util.concurrent.TimeUnit
+
+/**
+ * ntfy 推送：用 JSON publish API（POST / with {topic,title,message}）。
+ * 注：raw body 会被 ntfy 当附件，必须用 JSON API 或 Message header。
+ * 对瞬时 IOException 自动重试 3 次（退避 600/1200ms）。
+ */
+object NtfySender {
+    private val http = OkHttpClient.Builder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .writeTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(15, TimeUnit.SECONDS)
+        .retryOnConnectionFailure(true)
+        .build()
+
+    suspend fun send(
+        server: String, topic: String, token: String,
+        title: String, body: String,
+    ): Result<Unit> = withContext(Dispatchers.IO) {
+        runCatching {
+            val payload = JSONObject()
+                .put("topic", topic.trim())
+                .put("title", title.take(200))
+                .put("message", body.take(4000))
+                .toString()
+            val req = Request.Builder()
+                .url(server.trim().removeSuffix("/"))
+                .apply { if (token.isNotBlank()) header("Authorization", "Bearer $token") }
+                .post(payload.toRequestBody(JSON))
+                .build()
+            doPushWithRetry(req)
+        }
+    }
+
+    /** 多配置推送：stopOnFirst=true 首个成功止；false 全部发送，至少一个成功即算成功。 */
+    suspend fun pushToEnabled(configs: List<NtfyServer>, title: String, body: String, stopOnFirst: Boolean): Result<Unit> = withContext(Dispatchers.IO) {
+        runCatching {
+            require(configs.any()) { "无 ntfy 配置" }
+            var anyOk = false
+            var lastErr: Throwable? = null
+            for (c in configs) {
+                val r = send(c.server, c.topic, c.token, title, body)
+                if (r.isSuccess) {
+                    anyOk = true
+                    if (stopOnFirst) return@runCatching
+                } else {
+                    lastErr = r.exceptionOrNull()
+                }
+            }
+            if (!anyOk) throw lastErr ?: error("全部 ntfy 推送失败")
+        }
+    }
+
+    private fun doPushWithRetry(req: Request) {
+        var lastError: IOException? = null
+        repeat(MAX_ATTEMPTS) { attempt ->
+            try {
+                http.newCall(req).execute().use { res ->
+                    if (res.isSuccessful) return
+                    error("HTTP ${res.code}")
+                }
+            } catch (e: IOException) {
+                lastError = e
+                if (attempt < MAX_ATTEMPTS - 1) {
+                    Thread.sleep(BACKOFF_MS[attempt])
+                }
+            } catch (e: IllegalStateException) {
+                // HTTP 错误码（error() 抛 IllegalStateException），不重试
+                throw e
+            }
+        }
+        throw lastError ?: error("ntfy 推送失败")
+    }
+
+    fun trySend(app: A2iApp, title: String, body: String, scope: CoroutineScope) {
+        val s = app.settings
+        val configs = s.ntfyServers.value.filter { it.enabled && it.topic.isNotBlank() }
+        if (configs.isEmpty()) return
+        scope.launch {
+            pushToEnabled(configs, title, body, s.ntfyStopOnFirst.value)
+        }
+    }
+
+    private val JSON = "application/json; charset=utf-8".toMediaType()
+    private const val MAX_ATTEMPTS = 3
+    private val BACKOFF_MS = longArrayOf(600L, 1200L)
+}
@@ -70,8 +70,6 @@ class PhoneCallMonitor(private val context: Context) {
        val app = A2iApp.instance
        val settings = app.settings
        if (!settings.forwardingEnabled.value) return
-        val server = settings.currentServer.value ?: return
-        if (server.deviceKey.isBlank()) return

        when {
            // IDLE → RINGING：来电
@@ -82,14 +80,14 @@ class PhoneCallMonitor(private val context: Context) {
                if (now - lastRingTime > 3000) {
                    lastRingTime = now
                    val msg = BarkMessage(
-                        deviceKey = server.deviceKey,
+                        deviceKey = "",
                        title = "来电",
                        body = "有电话进来",
                        level = "timeSensitive",
                        group = "phone_call",
                        isArchive = "1",
                    )
-                    pushToServer(server, msg, app, "来电")
+                    pushToServers(msg, app, "来电")
                }
            }

@@ -102,14 +100,14 @@ class PhoneCallMonitor(private val context: Context) {
            from == TelephonyManager.CALL_STATE_RINGING && to == TelephonyManager.CALL_STATE_IDLE -> {
                if (!offhook && ringing) {
                    val msg = BarkMessage(
-                        deviceKey = server.deviceKey,
+                        deviceKey = "",
                        title = "未接来电",
                        body = "未接来电",
                        level = "timeSensitive",
                        group = "phone_call",
                        isArchive = "1",
                    )
-                    pushToServer(server, msg, app, "未接来电")
+                    pushToServers(msg, app, "未接来电")
                }
                ringing = false
                offhook = false
@@ -123,14 +121,16 @@ class PhoneCallMonitor(private val context: Context) {
        }
    }

-    private fun pushToServer(
-        server: com.a2i.forwarder.model.BarkServer,
-        msg: BarkMessage,
-        app: A2iApp,
-        logBody: String,
-    ) {
+    private fun pushToServers(msg: BarkMessage, app: A2iApp, logBody: String) {
        scope.launch {
-            val result = BarkClient(server).push(msg)
+            val servers = app.settings.servers.value.filter { it.enabled && it.deviceKey.isNotBlank() }
+            if (servers.isEmpty()) {
+                EmailSender.trySend(app, msg.title ?: logBody, msg.body ?: "", scope)
+                NtfySender.trySend(app, msg.title ?: logBody, msg.body ?: "", scope)
+                MeowSender.trySend(app, msg.title ?: logBody, msg.body ?: "", scope)
+                return@launch
+            }
+            val result = BarkSender.pushToEnabled(servers, msg, app.settings.barkStopOnFirst.value)
            val now = System.currentTimeMillis()
            if (result.isSuccess) {
                app.logStore.addLog(
@@ -142,9 +142,12 @@ class PhoneCallMonitor(private val context: Context) {
                    ForwardLog(now, "phone_call", "电话", msg.title, logBody, "failed", reason)
                )
                app.logStore.addPending(
-                    PendingPush(UUID.randomUUID().toString(), now, server.id, json.encodeToString(msg))
+                    PendingPush(UUID.randomUUID().toString(), now, servers.first().id, json.encodeToString(msg))
                )
            }
+            EmailSender.trySend(app, msg.title ?: logBody, msg.body ?: "", scope)
+            NtfySender.trySend(app, msg.title ?: logBody, msg.body ?: "", scope)
+            MeowSender.trySend(app, msg.title ?: logBody, msg.body ?: "", scope)
        }
    }
 }
@@ -24,13 +24,11 @@ class RetryWorker(ctx: Context, params: WorkerParameters) : CoroutineWorker(ctx,

        var allOk = true
        val json = Json { ignoreUnknownKeys = true }
+        val servers = settings.servers.value.filter { it.enabled && it.deviceKey.isNotBlank() }
        for (p in list) {
-            val server = settings.servers.value.firstOrNull { it.id == p.serverId }
-                ?: settings.currentServer.value
-                ?: continue
-            if (server.deviceKey.isBlank()) { allOk = false; continue }
+            if (servers.isEmpty()) { allOk = false; break }
            val msg = runCatching { json.decodeFromString<com.a2i.forwarder.model.BarkMessage>(p.messageJson) }.getOrNull() ?: continue
-            val r = BarkClient(server).push(msg)
+            val r = BarkSender.pushToFirst(servers, msg)
            if (r.isSuccess) store.removePending(p.id) else allOk = false
        }
        return if (allOk) Result.success() else Result.retry()
@@ -32,17 +32,16 @@ class SmsFallbackForwarder(private val context: Context) {
        return t.contains("来电") || t.contains("未接")
    }

-    /** 尝试用短信转发。返回 true 表示已处理（无论成功失败）。 */
+    /** 尝试用短信转发（遍历所有启用的目标号，按 stopOnFirst 决定发通一条止还是全发）。 */
    fun forward(d: Decision) {
        scope.launch {
-            if (!settings.smsFallbackEnabled.value) return@launch
            if (settings.smsSuspended.value) {
                log(d, "failed", "短信已挂起（余额不足）")
                return@launch
            }
            if (!isSmsWorthy(d)) return@launch
-            val target = settings.smsTargetNumber.value.trim()
-            if (target.isBlank()) {
+            val targets = settings.smsTargets.value.filter { it.enabled && it.number.isNotBlank() }
+            if (targets.isEmpty()) {
                log(d, "failed", "未设置短信目标号")
                return@launch
            }
@@ -62,22 +61,34 @@ class SmsFallbackForwarder(private val context: Context) {
            }

            val body = compose(d).take(70)
+            val stopOnFirst = settings.smsStopOnFirst.value
+            var anyOk = false
+            var sentCount = 0
+            var lastReason = "短信发送失败"
+            for (t in targets) {
                val result = runCatching {
-                SmsManager.getDefault().sendTextMessage(target, null, body, null, null)
+                    SmsManager.getDefault().sendTextMessage(t.number.trim(), null, body, null, null)
                }
                if (result.isSuccess) {
+                    anyOk = true
+                    sentCount++
+                    if (stopOnFirst) break
+                } else {
+                    lastReason = result.exceptionOrNull()?.message ?: "短信发送失败"
+                }
+            }
+            if (anyOk) {
                settings.setLastSmsSentTime(now)
                log(d, "sent", "")
-                // 转发后刷新余额：自动模式发查询短信，手动模式递减
+                // 余额递减：按成功发送条数；自动模式发查询短信，手动模式递减
                val carrier = app.carrierBalanceQuery.currentCarrier()
                if (carrier.serviceNumber != null && carrier.queryCmd != null) {
                    app.carrierBalanceQuery.refresh()
                } else {
-                    app.carrierBalanceQuery.decrementManual()
+                    repeat(sentCount) { runCatching { app.carrierBalanceQuery.decrementManual() } }
                }
            } else {
-                val reason = result.exceptionOrNull()?.message ?: "短信发送失败"
-                log(d, "failed", reason)
+                log(d, "failed", lastReason)
            }
        }
    }
@@ -9,7 +9,9 @@ import com.a2i.forwarder.A2iApp
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import okhttp3.OkHttpClient
@@ -27,7 +29,7 @@ data class UpdateInfo(
 )

 /**
- * 应用内更新：拉取 GitHub Releases 最新版 → 版本比较 → 下载 APK → 调起系统安装器。
+ * 应用内更新：定时巡检 Gitea Releases 最新版 → 版本比较 → 醒目横幅 + 自动推送通知 → 下载 APK → 调起系统安装器。
 * Android targetSdk≥24 须用 FileProvider，targetSdk≥26 安装未知来源 APK 须 REQUEST_INSTALL_PACKAGES。
 */
 class UpdateChecker(private val context: Context) {
@@ -41,44 +43,113 @@ class UpdateChecker(private val context: Context) {

    val updateInfo = MutableStateFlow<UpdateInfo?>(null)
    val downloading = MutableStateFlow(false)
-    val downloadProgress = MutableStateFlow(0)        // 0..100
+    val downloadProgress = MutableStateFlow(0)
    val lastError = MutableStateFlow<String?>(null)
+    private var lastNotifiedVersion: String? = null  // 记录已推送的版本，避免重复通知

    fun start() {
-        scope.launch { check(force = false) }
+        scope.launch {
+            delay(5000)  // 启动 5 秒后首检，给网络/应用初始化留时间
+            doCheck(throttle = false, toggle = true)  // 启动必查（无视节流，但尊重开关）
+            while (isActive) {
+                delay(CHECK_INTERVAL_MS)  // 常驻期间每 24h 巡检一次
+                doCheck(throttle = true, toggle = true)
+            }
+        }
    }

-    suspend fun check(force: Boolean): Result<UpdateInfo?> = withContext(Dispatchers.IO) {
+    /** 手动检查：无视节流和开关（用户主动）。 */
+    suspend fun check(force: Boolean): Result<UpdateInfo?> = doCheck(throttle = !force, toggle = !force)
+
+    private suspend fun doCheck(throttle: Boolean, toggle: Boolean): Result<UpdateInfo?> = withContext(Dispatchers.IO) {
        runCatching {
            val settings = app.settings
+            if (toggle && !settings.updateCheckEnabled.value) return@runCatching updateInfo.value
            val now = System.currentTimeMillis()
-            if (!force) {
-                // 自动检查被关闭或未满 24h：保持现状，不发请求
-                if (!settings.updateCheckEnabled.value) return@runCatching updateInfo.value
-                if (now - settings.lastUpdateCheckTime.value < CHECK_INTERVAL_MS) return@runCatching updateInfo.value
-            }
-            val req = Request.Builder()
-                .url(RELEASES_API)
-                .header("Accept", "application/vnd.github+json")
-                .header("User-Agent", "a2i-android")
-                .get()
-                .build()
-            val info = http.newCall(req).execute().use { res ->
-                if (!res.isSuccessful) error("HTTP ${res.code}")
-                val body = res.body?.string() ?: error("空响应")
-                parseRelease(body)
+            if (throttle && now - settings.lastUpdateCheckTime.value < CHECK_INTERVAL_MS) return@runCatching updateInfo.value
+
+            // 先查 GitHub（公开默认源），从其 release notes 动态发现额外源（如自建 Gitea），取最高版本
+            // 同版本时 Gitea 优先（国内可达，GitHub 可能被墙导致下载失败）
+            val infos = mutableListOf<UpdateInfo>()
+            val gh = runCatching { fetchRelease(GITHUB_API) }.getOrNull()
+            if (gh != null) {
+                val giteaInfo = parseUpdateSource(gh.releaseNotes)?.let { runCatching { fetchRelease(it) }.getOrNull() }
+                // Gitea 放前面，同版本时优先用它下载（国内可达）
+                if (giteaInfo != null) infos.add(giteaInfo)
+                infos.add(gh)
            }
            settings.setLastUpdateCheck(now)
+            if (infos.isEmpty()) {
+                lastError.value = "所有更新源不可达"
+                return@runCatching updateInfo.value
+            }
            val current = currentVersionName()
-            val available = info != null &&
-                isNewer(info.latestVersion, current) &&
-                info.latestVersion != settings.ignoredVersion.value
-            updateInfo.value = if (available) info else null
+            val best = infos
+                .filter { isNewer(it.latestVersion, current) && it.latestVersion != settings.ignoredVersion.value }
+                .maxByOrNull { versionKey(it.latestVersion) }
+            val prev = updateInfo.value
+            if (best == null) {
+                updateInfo.value = null
+                lastNotifiedVersion = null
+            } else {
+                updateInfo.value = best
+            }
            lastError.value = null
+
+            // 发现新版且之前没推过通知 → 自动推送到所有已开启通道
+            if (best != null && best.latestVersion != lastNotifiedVersion) {
+                lastNotifiedVersion = best.latestVersion
+                notifyNewVersion(prev, best)
+            }
            updateInfo.value
        }.onFailure { lastError.value = it.message ?: "检查失败" }
    }

+    private fun fetchRelease(api: String): UpdateInfo? {
+        val req = Request.Builder()
+            .url(api)
+            .header("Accept", "application/json")
+            .header("User-Agent", "gotmsg-android")
+            .get()
+            .build()
+        return http.newCall(req).execute().use { res ->
+            if (!res.isSuccessful) error("HTTP ${res.code}")
+            parseRelease(res.body?.string() ?: error("空响应"))
+        }
+    }
+
+    private fun versionKey(v: String): String =
+        v.split(".").joinToString(".") { (it.substringBefore("-").toIntOrNull() ?: 0).toString().padStart(4, '0') }
+
+    /** 发现新版后，自动通过所有已开启的推送通道通知用户 */
+    private fun notifyNewVersion(prev: UpdateInfo?, info: UpdateInfo) {
+        val s = app.settings
+        val title = "🆕 GotMsg 新版本 v${info.latestVersion}"
+        val body = "发现 v${info.latestVersion}（当前 v${currentVersionName()}）\n${formatSize(info.apkSize)} · 点击更新\n\n${info.releaseNotes.take(300)}"
+        val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+
+        // Bark：通过 BarkSender 推送给第一个启用的服务器
+        val barkServers = s.servers.value.filter { it.enabled && it.deviceKey.isNotBlank() }
+        if (barkServers.isNotEmpty()) {
+            scope.launch {
+                val msg = com.a2i.forwarder.model.BarkMessage(
+                    deviceKey = "", title = title, body = body, level = "timeSensitive",
+                    group = "a2i_update", isArchive = "1",
+                )
+                BarkSender.pushToFirst(barkServers, msg)
+            }
+        }
+
+        // ntfy
+        NtfySender.trySend(app, title, body, scope)
+
+        // Meow
+        MeowSender.trySend(app, title, body, scope)
+
+        // 电邮
+        EmailSender.trySend(app, title, body, scope)
+    }
+
    private fun parseRelease(body: String): UpdateInfo? {
        val json = JSONObject(body)
        val tag = json.optString("tag_name").removePrefix("v").trim()
@@ -115,7 +186,7 @@ class UpdateChecker(private val context: Context) {
                val body = res.body ?: run { lastError.value = "空响应"; return@use null }
                val total = body.contentLength()
                val dir = context.getExternalFilesDir(null) ?: context.cacheDir
-                val target = File(dir, "a2i-${info.latestVersion}.apk")
+                val target = File(dir, "gotmsg-${info.latestVersion}.apk")
                target.outputStream().use { sink ->
                    val input = body.byteStream()
                    val buf = ByteArray(8 * 1024)
@@ -140,7 +211,6 @@ class UpdateChecker(private val context: Context) {
    }

    fun install(apk: File) {
-        // 国产 ROM 需用户先在系统设置开启「安装未知应用」
        if (!context.packageManager.canRequestPackageInstalls()) {
            val intent = Intent(Settings.ACTION_MANAGE_UNKNOWN_APP_SOURCES).apply {
                data = Uri.parse("package:${context.packageName}")
@@ -172,7 +242,6 @@ class UpdateChecker(private val context: Context) {
        }.getOrDefault("0")
    }

-    /** 语义版本比较：按 "." 分段逐段比，段数不等时短的补 0。 */
    fun isNewer(latest: String, current: String): Boolean {
        val l = latest.split(".").map { it.substringBefore("-").toIntOrNull() ?: 0 }
        val c = current.split(".").map { it.substringBefore("-").toIntOrNull() ?: 0 }
@@ -185,8 +254,31 @@ class UpdateChecker(private val context: Context) {
        return false
    }

+    /** 从 release notes 的 HTML 注释里解析额外更新源（加扰编码，兼容 Base64/明文）。 */
+    private fun parseUpdateSource(body: String): String? {
+        val raw = Regex("""update-source:\s*(\S+)""").find(body)?.groupValues?.getOrNull(1) ?: return null
+        // 加扰格式：Base64(反转(XOR(明文, key)))。尝试完整解扰，失败则依次尝试 Base64/明文。
+        val b64 = runCatching { java.util.Base64.getDecoder().decode(raw) }.getOrNull() ?: return raw
+        val unscrambled = unscramble(b64)
+        return unscrambled ?: runCatching { String(b64, Charsets.UTF_8) }.getOrNull() ?: raw
+    }
+
+    /** 解扰：反转字节 → XOR 每字节 → UTF-8 字符串。 */
+    private fun unscramble(data: ByteArray): String? = runCatching {
+        val key = SCRAMBLE_KEY
+        val reversed = data.reversedArray()
+        String(ByteArray(reversed.size) { i -> ((reversed[i].toInt() and 0xFF) xor (key[i % key.size].toInt() and 0xFF)).toByte() }, Charsets.UTF_8)
+    }.getOrNull()
+
    companion object {
-        const val RELEASES_API = "https://api.github.com/repos/lsxf/a2i/releases/latest"
+        const val GITHUB_API = "https://api.github.com/repos/lsxf/a2i/releases/latest"
        const val CHECK_INTERVAL_MS = 24L * 60 * 60 * 1000
+        private val SCRAMBLE_KEY = byteArrayOf(0x4B, 0x6F, 0x72, 0x6E)  // "Korn"
+    }
+
+    fun formatSize(bytes: Long): String {
+        if (bytes <= 0) return ""
+        val kb = bytes / 1024.0
+        return if (kb >= 1024) String.format("%.1f MB", kb / 1024) else String.format("%.0f KB", kb)
    }
 }
@@ -9,6 +9,47 @@ data class BarkServer(
    val name: String,
    val server: String,
    val deviceKey: String,
+    val enabled: Boolean = true,
 )

 const val OFFICIAL_BARK_SERVER = "https://api.day.app"
+
+@Serializable
+data class NtfyServer(
+    val id: String = UUID.randomUUID().toString(),
+    val name: String,
+    val server: String = "https://ntfy.sh",
+    val topic: String = "",
+    val token: String = "",
+    val enabled: Boolean = true,
+)
+
+@Serializable
+data class MeowServer(
+    val id: String = UUID.randomUUID().toString(),
+    val name: String,
+    val server: String = "",
+    val deviceKey: String = "",
+    val enabled: Boolean = true,
+)
+
+@Serializable
+data class EmailServer(
+    val id: String = UUID.randomUUID().toString(),
+    val name: String,
+    val host: String = "",
+    val port: Int = 465,
+    val user: String = "",
+    val password: String = "",
+    val from: String = "",
+    val to: String = "",
+    val enabled: Boolean = true,
+)
+
+@Serializable
+data class SmsTarget(
+    val id: String = UUID.randomUUID().toString(),
+    val name: String,
+    val number: String = "",
+    val enabled: Boolean = true,
+)
@@ -3,9 +3,12 @@ package com.a2i.forwarder.service
 import android.service.notification.NotificationListenerService
 import android.service.notification.StatusBarNotification
 import com.a2i.forwarder.A2iApp
-import com.a2i.forwarder.core.BarkClient
+import com.a2i.forwarder.core.BarkSender
+import com.a2i.forwarder.core.EmailSender
 import com.a2i.forwarder.core.ForwardLog
+import com.a2i.forwarder.core.MeowSender
 import com.a2i.forwarder.core.NotificationProcessor
+import com.a2i.forwarder.core.NtfySender
 import com.a2i.forwarder.core.PendingPush
 import com.a2i.forwarder.core.RetryWorker
 import kotlinx.coroutines.CoroutineScope
@@ -58,21 +61,27 @@ class NotifyListenerService : NotificationListenerService() {
            return
        }

-        val server = app.settings.currentServer.value
-        if (server == null || server.deviceKey.isBlank()) {
-            app.logStore.addLog(ForwardLog(now, sbn.packageName, d.appLabel, msg.title, msg.body, "failed", "未配置 Bark key"))
+        val servers = app.settings.servers.value.filter { it.enabled && it.deviceKey.isNotBlank() }
+        if (servers.isEmpty()) {
+            app.logStore.addLog(ForwardLog(now, sbn.packageName, d.appLabel, msg.title, msg.body, "failed", "未配置可用 Bark 服务器"))
+            EmailSender.trySend(app, msg.title ?: d.appLabel, msg.body, scope)
+            NtfySender.trySend(app, msg.title ?: d.appLabel, msg.body, scope)
+            MeowSender.trySend(app, msg.title ?: d.appLabel, msg.body, scope)
            return
        }

-        val result = BarkClient(server).push(msg)
+        val result = BarkSender.pushToEnabled(servers, msg, app.settings.barkStopOnFirst.value)
        if (result.isSuccess) {
            app.logStore.addLog(ForwardLog(now, sbn.packageName, d.appLabel, msg.title, msg.body, "sent", ""))
        } else {
            val reason = result.exceptionOrNull()?.message ?: "错误"
            app.logStore.addLog(ForwardLog(now, sbn.packageName, d.appLabel, msg.title, msg.body, "failed", reason))
            app.logStore.addPending(
-                PendingPush(UUID.randomUUID().toString(), now, server.id, json.encodeToString(msg))
+                PendingPush(UUID.randomUUID().toString(), now, servers.first().id, json.encodeToString(msg))
            )
        }
+        EmailSender.trySend(app, msg.title ?: d.appLabel, msg.body, scope)
+        NtfySender.trySend(app, msg.title ?: d.appLabel, msg.body, scope)
+        MeowSender.trySend(app, msg.title ?: d.appLabel, msg.body, scope)
    }
 }
@@ -10,7 +10,11 @@ import androidx.datastore.preferences.core.longPreferencesKey
 import androidx.datastore.preferences.core.stringPreferencesKey
 import androidx.datastore.preferences.preferencesDataStore
 import com.a2i.forwarder.model.BarkServer
+import com.a2i.forwarder.model.EmailServer
+import com.a2i.forwarder.model.MeowServer
+import com.a2i.forwarder.model.NtfyServer
 import com.a2i.forwarder.model.OFFICIAL_BARK_SERVER
+import com.a2i.forwarder.model.SmsTarget
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
@@ -31,7 +35,6 @@ class SettingsStore(

    private object K {
        val SERVERS = stringPreferencesKey("servers")
-        val CURRENT = stringPreferencesKey("current")
        val ICON_PREFIX = stringPreferencesKey("icon_prefix")
        val FWD = booleanPreferencesKey("forwarding")
        val CODE = booleanPreferencesKey("code")
@@ -39,18 +42,42 @@ class SettingsStore(
        val SPECIAL = booleanPreferencesKey("special")
        val SKIP_ONGOING = booleanPreferencesKey("skip_ongoing")
        val AD_KW = stringPreferencesKey("ad_keywords")
-        // 短信兜底
+        // 各通道「发通一条止 / 全发」开关
+        val BARK_STOP_FIRST = booleanPreferencesKey("bark_stop_first")
+        val NTFY_STOP_FIRST = booleanPreferencesKey("ntfy_stop_first")
+        val MEOW_STOP_FIRST = booleanPreferencesKey("meow_stop_first")
+        val EMAIL_STOP_FIRST = booleanPreferencesKey("email_stop_first")
+        val SMS_STOP_FIRST = booleanPreferencesKey("sms_stop_first")
+        // 短信兜底（目标号已列表化；运营商/余额/限频保持全局）
        val SMS_FALLBACK = booleanPreferencesKey("sms_fallback")
-        val SMS_TARGET = stringPreferencesKey("sms_target")
+        val SMS_TARGETS = stringPreferencesKey("sms_targets")
        val SMS_CARRIER = stringPreferencesKey("sms_carrier")
        val SMS_QUOTA = intPreferencesKey("sms_quota")
        val SMS_BALANCE = intPreferencesKey("sms_balance")
        val SMS_SUSPENDED = booleanPreferencesKey("sms_suspended")
        val SMS_LAST_SENT = longPreferencesKey("sms_last_sent")
+        // 电邮转发
+        val EMAIL_ENABLED = booleanPreferencesKey("email_enabled")
+        val EMAIL_SERVERS = stringPreferencesKey("email_servers")
+        val NTFY_SERVERS = stringPreferencesKey("ntfy_servers")
+        val MEOW_SERVERS = stringPreferencesKey("meow_servers")
        // 应用更新
        val UPDATE_CHECK_AUTO = booleanPreferencesKey("update_check_auto")
        val LAST_UPDATE_CHECK = longPreferencesKey("last_update_check")
        val IGNORED_VERSION = stringPreferencesKey("ignored_version")
+        // 配置版本（用于旧单组配置迁移）
+        val CONFIG_VERSION = intPreferencesKey("config_version")
+        // ---- 旧单组键（仅迁移用，迁移后清理）----
+        val SMS_TARGET = stringPreferencesKey("sms_target")
+        val EMAIL_HOST = stringPreferencesKey("email_smtp_host")
+        val EMAIL_PORT = intPreferencesKey("email_smtp_port")
+        val EMAIL_USER = stringPreferencesKey("email_smtp_user")
+        val EMAIL_PASS = stringPreferencesKey("email_smtp_pass")
+        val EMAIL_FROM = stringPreferencesKey("email_from")
+        val EMAIL_TO = stringPreferencesKey("email_to")
+        val NTFY_SERVER = stringPreferencesKey("ntfy_server")
+        val NTFY_TOPIC = stringPreferencesKey("ntfy_topic")
+        val NTFY_TOKEN = stringPreferencesKey("ntfy_token")
    }

    private val defaultServers = listOf(
@@ -60,8 +87,17 @@ class SettingsStore(
    private val _servers = MutableStateFlow(defaultServers)
    val servers = _servers.asStateFlow()

-    private val _currentServerId = MutableStateFlow(ID_OFFICIAL)
-    val currentServer = MutableStateFlow<BarkServer?>(defaultServers.first())
+    private val _ntfyServers = MutableStateFlow<List<NtfyServer>>(emptyList())
+    val ntfyServers = _ntfyServers.asStateFlow()
+
+    private val _meowServers = MutableStateFlow<List<MeowServer>>(emptyList())
+    val meowServers = _meowServers.asStateFlow()
+
+    private val _emailServers = MutableStateFlow<List<EmailServer>>(emptyList())
+    val emailServers = _emailServers.asStateFlow()
+
+    private val _smsTargets = MutableStateFlow<List<SmsTarget>>(emptyList())
+    val smsTargets = _smsTargets.asStateFlow()

    val iconPrefix = MutableStateFlow(DEFAULT_ICON_PREFIX)
    val forwardingEnabled = MutableStateFlow(true)
@@ -69,21 +105,30 @@ class SettingsStore(
    val adFilterEnabled = MutableStateFlow(true)
    val specialEnabled = MutableStateFlow(true)
    val skipOngoing = MutableStateFlow(true)
-    val adKeywords = MutableStateFlow<List<String>>(emptyList()) // 用户自定义关键词
+    val adKeywords = MutableStateFlow<List<String>>(emptyList())

-    // 短信兜底
+    // 各通道「发通一条止 / 全发」
+    val barkStopOnFirst = MutableStateFlow(true)
+    val ntfyStopOnFirst = MutableStateFlow(false)
+    val meowStopOnFirst = MutableStateFlow(false)
+    val emailStopOnFirst = MutableStateFlow(false)
+    val smsStopOnFirst = MutableStateFlow(false)
+
+    // 短信兜底（全局）
    val smsFallbackEnabled = MutableStateFlow(false)
-    val smsTargetNumber = MutableStateFlow("")
-    val smsCarrier = MutableStateFlow("auto")       // "auto" 或 Carrier.name
-    val smsManualQuota = MutableStateFlow(0)         // 手动额度（自动解析失败时回退用）
-    val smsBalance = MutableStateFlow(-1)            // 缓存余额，-1=未知
-    val smsSuspended = MutableStateFlow(false)       // 余额 ≤5 自动挂起
-    val lastSmsSentTime = MutableStateFlow(0L)       // 限频时间戳
+    val smsCarrier = MutableStateFlow("auto")
+    val smsManualQuota = MutableStateFlow(0)
+    val smsBalance = MutableStateFlow(-1)
+    val smsSuspended = MutableStateFlow(false)
+    val lastSmsSentTime = MutableStateFlow(0L)
+
+    // 电邮总开关
+    val emailForwardingEnabled = MutableStateFlow(false)

    // 应用更新
-    val updateCheckEnabled = MutableStateFlow(true)     // 自动检查更新开关
-    val lastUpdateCheckTime = MutableStateFlow(0L)      // 上次检查时间戳
-    val ignoredVersion = MutableStateFlow("")           // 用户忽略的版本号
+    val updateCheckEnabled = MutableStateFlow(true)
+    val lastUpdateCheckTime = MutableStateFlow(0L)
+    val ignoredVersion = MutableStateFlow("")

    init {
        scope.launch {
@@ -92,8 +137,6 @@ class SettingsStore(
                    ?.let { runCatching { json.decodeFromString<List<BarkServer>>(it) }.getOrNull() }
                    ?: defaultServers
                _servers.value = list
-                _currentServerId.value = p[K.CURRENT] ?: ID_OFFICIAL
-                currentServer.value = list.firstOrNull { it.id == _currentServerId.value } ?: list.firstOrNull()
                iconPrefix.value = p[K.ICON_PREFIX] ?: DEFAULT_ICON_PREFIX
                forwardingEnabled.value = p[K.FWD] ?: true
                codeEnabled.value = p[K.CODE] ?: true
@@ -103,59 +146,179 @@ class SettingsStore(
                adKeywords.value = p[K.AD_KW]
                    ?.let { runCatching { json.decodeFromString<List<String>>(it) }.getOrNull() }
                    ?: emptyList()
-                // 短信兜底
+                // 各通道 stopOnFirst
+                barkStopOnFirst.value = p[K.BARK_STOP_FIRST] ?: true
+                ntfyStopOnFirst.value = p[K.NTFY_STOP_FIRST] ?: false
+                meowStopOnFirst.value = p[K.MEOW_STOP_FIRST] ?: false
+                emailStopOnFirst.value = p[K.EMAIL_STOP_FIRST] ?: false
+                smsStopOnFirst.value = p[K.SMS_STOP_FIRST] ?: false
+                // 短信兜底全局
                smsFallbackEnabled.value = p[K.SMS_FALLBACK] ?: false
-                smsTargetNumber.value = p[K.SMS_TARGET] ?: ""
                smsCarrier.value = p[K.SMS_CARRIER] ?: "auto"
                smsManualQuota.value = p[K.SMS_QUOTA] ?: 0
                smsBalance.value = p[K.SMS_BALANCE] ?: -1
                smsSuspended.value = p[K.SMS_SUSPENDED] ?: false
                lastSmsSentTime.value = p[K.SMS_LAST_SENT] ?: 0L
+                // 电邮总开关
+                emailForwardingEnabled.value = p[K.EMAIL_ENABLED] ?: false
                // 应用更新
                updateCheckEnabled.value = p[K.UPDATE_CHECK_AUTO] ?: true
                lastUpdateCheckTime.value = p[K.LAST_UPDATE_CHECK] ?: 0L
                ignoredVersion.value = p[K.IGNORED_VERSION] ?: ""
+                // 列表配置
+                _ntfyServers.value = p[K.NTFY_SERVERS]
+                    ?.let { runCatching { json.decodeFromString<List<NtfyServer>>(it) }.getOrNull() }
+                    ?: emptyList()
+                _meowServers.value = p[K.MEOW_SERVERS]
+                    ?.let { runCatching { json.decodeFromString<List<MeowServer>>(it) }.getOrNull() }
+                    ?: emptyList()
+                _emailServers.value = p[K.EMAIL_SERVERS]
+                    ?.let { runCatching { json.decodeFromString<List<EmailServer>>(it) }.getOrNull() }
+                    ?: emptyList()
+                _smsTargets.value = p[K.SMS_TARGETS]
+                    ?.let { runCatching { json.decodeFromString<List<SmsTarget>>(it) }.getOrNull() }
+                    ?: emptyList()
+
+                // ---- 旧单组配置迁移（config_version < 2）----
+                val cfgVer = p[K.CONFIG_VERSION] ?: 1
+                if (cfgVer < 2) {
+                    migrateLegacyConfigs(p)
                }
            }
        }
+    }
+
+    /** 把旧的单组 ntfy/email/sms 配置转成列表的一条。 */
+    private suspend fun migrateLegacyConfigs(p: Preferences) {
+        var ntfyList = _ntfyServers.value
+        var emailList = _emailServers.value
+        var smsList = _smsTargets.value
+
+        val nTopic = p[K.NTFY_TOPIC]
+        if (!nTopic.isNullOrBlank() && ntfyList.isEmpty()) {
+            ntfyList = listOf(NtfyServer(name = "ntfy", server = p[K.NTFY_SERVER] ?: "https://ntfy.sh", topic = nTopic, token = p[K.NTFY_TOKEN] ?: ""))
+        }
+        val eHost = p[K.EMAIL_HOST]
+        val eTo = p[K.EMAIL_TO]
+        if (!eHost.isNullOrBlank() && emailList.isEmpty()) {
+            emailList = listOf(EmailServer(
+                name = "邮箱", host = eHost,
+                port = (p[K.EMAIL_PORT] ?: 465).let { if (it < 25) 465 else it },
+                user = p[K.EMAIL_USER] ?: "", password = p[K.EMAIL_PASS] ?: "",
+                from = p[K.EMAIL_FROM] ?: "", to = eTo ?: "",
+            ))
+        }
+        val sTarget = p[K.SMS_TARGET]
+        if (!sTarget.isNullOrBlank() && smsList.isEmpty()) {
+            smsList = listOf(SmsTarget(name = "iPhone", number = sTarget))
+        }
+
+        ds.edit { m ->
+            if (ntfyList.isNotEmpty()) {
+                m[K.NTFY_SERVERS] = json.encodeToString(ntfyList)
+                m.remove(K.NTFY_SERVER); m.remove(K.NTFY_TOPIC); m.remove(K.NTFY_TOKEN)
+            }
+            if (emailList.isNotEmpty()) {
+                m[K.EMAIL_SERVERS] = json.encodeToString(emailList)
+                listOf(K.EMAIL_HOST, K.EMAIL_PORT, K.EMAIL_USER, K.EMAIL_PASS, K.EMAIL_FROM, K.EMAIL_TO).forEach { m.remove(it) }
+            }
+            if (smsList.isNotEmpty()) {
+                m[K.SMS_TARGETS] = json.encodeToString(smsList)
+                m.remove(K.SMS_TARGET)
+            }
+            m[K.CONFIG_VERSION] = 2
+        }
+        _ntfyServers.value = ntfyList
+        _emailServers.value = emailList
+        _smsTargets.value = smsList
+    }

    private suspend fun edit(block: (androidx.datastore.preferences.core.MutablePreferences) -> Unit) =
        ds.edit(block)

+    // ---- Bark 服务器 CRUD ----
    private suspend fun saveServers(list: List<BarkServer>) {
        edit { it[K.SERVERS] = json.encodeToString(list) }
        _servers.value = list
-        refreshCurrent()
    }
-
    suspend fun addServer(name: String, server: String, key: String): BarkServer {
        val s = BarkServer(name = name.trim(), server = server.trim().removeSuffix("/"), deviceKey = key.trim())
        saveServers(_servers.value + s)
-        if (_servers.value.count { it.id == s.id } == 1 && currentServer.value?.deviceKey.isNullOrBlank()) {
-            setCurrent(s.id)
-        }
        return s
    }
-
    suspend fun updateServer(s: BarkServer) = saveServers(_servers.value.map { if (it.id == s.id) s.copy(server = s.server.trim().removeSuffix("/")) else it })
+    suspend fun deleteServer(id: String) = saveServers(_servers.value.filterNot { it.id == id })
+    suspend fun moveServer(id: String, up: Boolean) {
+        val list = _servers.value.toMutableList()
+        val i = list.indexOfFirst { it.id == id }
+        if (i in 1..list.lastIndex && up) { java.util.Collections.swap(list, i, i - 1); saveServers(list) }
+        else if (i in 0 until list.lastIndex && !up) { java.util.Collections.swap(list, i, i + 1); saveServers(list) }
+    }
+    suspend fun setServerEnabled(id: String, enabled: Boolean) = saveServers(_servers.value.map { if (it.id == id) it.copy(enabled = enabled) else it })

-    suspend fun deleteServer(id: String) {
-        val list = _servers.value.filterNot { it.id == id }
-        saveServers(list)
-        if (_currentServerId.value == id) {
-            setCurrent(if (list.isEmpty()) "" else list.first().id)
+    // ---- ntfy 服务器 CRUD ----
+    private suspend fun saveNtfyServers(list: List<NtfyServer>) {
+        edit { it[K.NTFY_SERVERS] = json.encodeToString(list) }
+        _ntfyServers.value = list
    }
+    suspend fun addNtfy(s: NtfyServer) { saveNtfyServers(_ntfyServers.value + s) }
+    suspend fun updateNtfy(s: NtfyServer) = saveNtfyServers(_ntfyServers.value.map { if (it.id == s.id) s else it })
+    suspend fun deleteNtfy(id: String) = saveNtfyServers(_ntfyServers.value.filterNot { it.id == id })
+    suspend fun moveNtfy(id: String, up: Boolean) {
+        val list = _ntfyServers.value.toMutableList()
+        val i = list.indexOfFirst { it.id == id }
+        if (i in 1..list.lastIndex && up) { java.util.Collections.swap(list, i, i - 1); saveNtfyServers(list) }
+        else if (i in 0 until list.lastIndex && !up) { java.util.Collections.swap(list, i, i + 1); saveNtfyServers(list) }
    }
+    suspend fun setNtfyEnabled(id: String, enabled: Boolean) = saveNtfyServers(_ntfyServers.value.map { if (it.id == id) it.copy(enabled = enabled) else it })

-    suspend fun setCurrent(id: String) {
-        edit { it[K.CURRENT] = id }
-        _currentServerId.value = id
-        refreshCurrent()
+    // ---- Meow 服务器 CRUD ----
+    private suspend fun saveMeowServers(list: List<MeowServer>) {
+        edit { it[K.MEOW_SERVERS] = json.encodeToString(list) }
+        _meowServers.value = list
    }
+    suspend fun addMeow(s: MeowServer) { saveMeowServers(_meowServers.value + s) }
+    suspend fun updateMeow(s: MeowServer) = saveMeowServers(_meowServers.value.map { if (it.id == s.id) s else it })
+    suspend fun deleteMeow(id: String) = saveMeowServers(_meowServers.value.filterNot { it.id == id })
+    suspend fun moveMeow(id: String, up: Boolean) {
+        val list = _meowServers.value.toMutableList()
+        val i = list.indexOfFirst { it.id == id }
+        if (i in 1..list.lastIndex && up) { java.util.Collections.swap(list, i, i - 1); saveMeowServers(list) }
+        else if (i in 0 until list.lastIndex && !up) { java.util.Collections.swap(list, i, i + 1); saveMeowServers(list) }
+    }
+    suspend fun setMeowEnabled(id: String, enabled: Boolean) = saveMeowServers(_meowServers.value.map { if (it.id == id) it.copy(enabled = enabled) else it })

-    private fun refreshCurrent() {
-        currentServer.value = _servers.value.firstOrNull { it.id == _currentServerId.value } ?: _servers.value.firstOrNull()
+    // ---- 电邮服务器 CRUD ----
+    private suspend fun saveEmailServers(list: List<EmailServer>) {
+        edit { it[K.EMAIL_SERVERS] = json.encodeToString(list) }
+        _emailServers.value = list
    }
+    suspend fun addEmail(s: EmailServer) { saveEmailServers(_emailServers.value + s) }
+    suspend fun updateEmail(s: EmailServer) = saveEmailServers(_emailServers.value.map { if (it.id == s.id) s else it })
+    suspend fun deleteEmail(id: String) = saveEmailServers(_emailServers.value.filterNot { it.id == id })
+    suspend fun moveEmail(id: String, up: Boolean) {
+        val list = _emailServers.value.toMutableList()
+        val i = list.indexOfFirst { it.id == id }
+        if (i in 1..list.lastIndex && up) { java.util.Collections.swap(list, i, i - 1); saveEmailServers(list) }
+        else if (i in 0 until list.lastIndex && !up) { java.util.Collections.swap(list, i, i + 1); saveEmailServers(list) }
+    }
+    suspend fun setEmailEnabled(id: String, enabled: Boolean) = saveEmailServers(_emailServers.value.map { if (it.id == id) it.copy(enabled = enabled) else it })
+
+    // ---- 短信目标 CRUD ----
+    private suspend fun saveSmsTargets(list: List<SmsTarget>) {
+        edit { it[K.SMS_TARGETS] = json.encodeToString(list) }
+        _smsTargets.value = list
+    }
+    suspend fun addSmsTarget(s: SmsTarget) { saveSmsTargets(_smsTargets.value + s) }
+    suspend fun updateSmsTarget(s: SmsTarget) = saveSmsTargets(_smsTargets.value.map { if (it.id == s.id) s else it })
+    suspend fun deleteSmsTarget(id: String) = saveSmsTargets(_smsTargets.value.filterNot { it.id == id })
+    suspend fun moveSmsTarget(id: String, up: Boolean) {
+        val list = _smsTargets.value.toMutableList()
+        val i = list.indexOfFirst { it.id == id }
+        if (i in 1..list.lastIndex && up) { java.util.Collections.swap(list, i, i - 1); saveSmsTargets(list) }
+        else if (i in 0 until list.lastIndex && !up) { java.util.Collections.swap(list, i, i + 1); saveSmsTargets(list) }
+    }
+    suspend fun setSmsTargetEnabled(id: String, enabled: Boolean) = saveSmsTargets(_smsTargets.value.map { if (it.id == id) it.copy(enabled = enabled) else it })

    suspend fun setIconPrefix(v: String) { edit { it[K.ICON_PREFIX] = v }; iconPrefix.value = v }
    suspend fun setForwarding(v: Boolean) { edit { it[K.FWD] = v }; forwardingEnabled.value = v }
@@ -168,8 +331,13 @@ class SettingsStore(
        adKeywords.value = list
    }

+    suspend fun setBarkStopOnFirst(v: Boolean) { edit { it[K.BARK_STOP_FIRST] = v }; barkStopOnFirst.value = v }
+    suspend fun setNtfyStopOnFirst(v: Boolean) { edit { it[K.NTFY_STOP_FIRST] = v }; ntfyStopOnFirst.value = v }
+    suspend fun setMeowStopOnFirst(v: Boolean) { edit { it[K.MEOW_STOP_FIRST] = v }; meowStopOnFirst.value = v }
+    suspend fun setEmailStopOnFirst(v: Boolean) { edit { it[K.EMAIL_STOP_FIRST] = v }; emailStopOnFirst.value = v }
+    suspend fun setSmsStopOnFirst(v: Boolean) { edit { it[K.SMS_STOP_FIRST] = v }; smsStopOnFirst.value = v }
+
    suspend fun setSmsFallback(v: Boolean) { edit { it[K.SMS_FALLBACK] = v }; smsFallbackEnabled.value = v }
-    suspend fun setSmsTargetNumber(v: String) { edit { it[K.SMS_TARGET] = v }; smsTargetNumber.value = v }
    suspend fun setSmsCarrier(v: String) { edit { it[K.SMS_CARRIER] = v }; smsCarrier.value = v }
    suspend fun setSmsManualQuota(v: Int) { edit { it[K.SMS_QUOTA] = v }; smsManualQuota.value = v }
    suspend fun setSmsBalance(v: Int) { edit { it[K.SMS_BALANCE] = v }; smsBalance.value = v }
@@ -180,6 +348,8 @@ class SettingsStore(
    suspend fun setLastUpdateCheck(v: Long) { edit { it[K.LAST_UPDATE_CHECK] = v }; lastUpdateCheckTime.value = v }
    suspend fun setIgnoredVersion(v: String) { edit { it[K.IGNORED_VERSION] = v }; ignoredVersion.value = v }

+    suspend fun setEmailForwarding(v: Boolean) { edit { it[K.EMAIL_ENABLED] = v }; emailForwardingEnabled.value = v }
+
    suspend fun snapshot() = ds.data.first()

    companion object {
@@ -7,6 +7,7 @@ import android.graphics.drawable.BitmapDrawable
 import android.graphics.drawable.Drawable
 import androidx.compose.foundation.BorderStroke
 import androidx.compose.foundation.background
+import androidx.compose.foundation.Image
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
@@ -68,6 +69,9 @@ fun SectionCard(
    title: String? = null,
    modifier: Modifier = Modifier,
    subtitle: String? = null,
+    titleIcon: ImageVector? = null,
+    titleIconTint: Color = MaterialTheme.colorScheme.primary,
+    headerAction: (@Composable () -> Unit)? = null,
    content: @Composable ColumnScope.() -> Unit,
 ) {
    Card(
@@ -79,12 +83,19 @@ fun SectionCard(
    ) {
        Column(Modifier.padding(16.dp)) {
            if (title != null) {
+                if (headerAction == null) {
+                    Row(verticalAlignment = Alignment.CenterVertically) {
+                        if (titleIcon != null) {
+                            Icon(titleIcon, null, tint = titleIconTint, modifier = Modifier.size(22.dp))
+                            Spacer(Modifier.width(8.dp))
+                        }
                        Text(
                            title,
                            style = MaterialTheme.typography.titleMedium,
                            fontWeight = FontWeight.SemiBold,
                            modifier = Modifier.padding(bottom = if (subtitle == null) 10.dp else 2.dp),
                        )
+                    }
                    if (subtitle != null) {
                        Text(
                            subtitle,
@@ -93,6 +104,38 @@ fun SectionCard(
                            modifier = Modifier.padding(bottom = 10.dp),
                        )
                    }
+                } else {
+                    Row(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .padding(bottom = 10.dp),
+                        verticalAlignment = Alignment.Top,
+                    ) {
+                        Column(Modifier.weight(1f)) {
+                            Row(verticalAlignment = Alignment.CenterVertically) {
+                                if (titleIcon != null) {
+                                    Icon(titleIcon, null, tint = titleIconTint, modifier = Modifier.size(22.dp))
+                                    Spacer(Modifier.width(8.dp))
+                                }
+                                Text(
+                                    title,
+                                    style = MaterialTheme.typography.titleMedium,
+                                    fontWeight = FontWeight.SemiBold,
+                                    modifier = Modifier.padding(bottom = if (subtitle == null) 0.dp else 2.dp),
+                                )
+                            }
+                            if (subtitle != null) {
+                                Text(
+                                    subtitle,
+                                    style = MaterialTheme.typography.bodySmall,
+                                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                                )
+                            }
+                        }
+                        Spacer(Modifier.width(12.dp))
+                        headerAction()
+                    }
+                }
            }
            content()
        }
@@ -1,7 +1,20 @@
 package com.a2i.forwarder.ui.nav

+import androidx.compose.animation.core.RepeatMode
+import androidx.compose.animation.core.animateFloat
+import androidx.compose.animation.core.infiniteRepeatable
+import androidx.compose.animation.core.rememberInfiniteTransition
+import androidx.compose.animation.core.tween
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.SystemUpdate
 import androidx.compose.material.icons.outlined.Apps
 import androidx.compose.material.icons.outlined.FilterAlt
 import androidx.compose.material.icons.outlined.Notifications
@@ -14,8 +27,15 @@ import androidx.compose.material3.NavigationBarItemDefaults
 import androidx.compose.material3.Scaffold
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.alpha
+import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.unit.dp
 import androidx.navigation.NavGraph.Companion.findStartDestination
@@ -23,11 +43,13 @@ import androidx.navigation.compose.NavHost
 import androidx.navigation.compose.composable
 import androidx.navigation.compose.currentBackStackEntryAsState
 import androidx.navigation.compose.rememberNavController
+import com.a2i.forwarder.A2iApp
 import com.a2i.forwarder.ui.screens.AppManageScreen
 import com.a2i.forwarder.ui.screens.FilterScreen
 import com.a2i.forwarder.ui.screens.HomeScreen
 import com.a2i.forwarder.ui.screens.LogScreen
 import com.a2i.forwarder.ui.screens.SettingsScreen
+import com.a2i.forwarder.ui.screens.UpdateDialog

 private sealed class Tab(val route: String, val label: String, val icon: ImageVector) {
    object Home : Tab("home", "首页", Icons.Outlined.Notifications)
@@ -46,6 +68,11 @@ fun AppRoot() {
    val current = backStack?.destination?.route
    val showBar = current in tabRoutes

+    val app = A2iApp.instance
+    val updateInfo by app.updateChecker.updateInfo.collectAsState()
+    var showUpdateDialog by remember { mutableStateOf(false) }
+
+    Box {
        Scaffold(
            containerColor = MaterialTheme.colorScheme.background,
            bottomBar = {
@@ -96,4 +123,49 @@ fun AppRoot() {
                composable("log") { LogScreen(onBack = { nav.popBackStack() }) }
            }
        }
+
+        // 浮动更新提醒小图标（跨所有页面，缓慢闪烁）
+        if (updateInfo != null) {
+            UpdateBadge(
+                modifier = Modifier.align(Alignment.TopEnd),
+                onClick = { showUpdateDialog = true },
+            )
+        }
+    }
+
+    if (showUpdateDialog && updateInfo != null) {
+        UpdateDialog(updateInfo!!, onDismiss = { showUpdateDialog = false })
+    }
+}
+
+/** 跨页面浮动更新提醒：右上角小圆点 + 缓慢闪烁动画。 */
+@Composable
+private fun UpdateBadge(modifier: Modifier = Modifier, onClick: () -> Unit) {
+    val transition = rememberInfiniteTransition(label = "updateBlink")
+    val pulseAlpha by transition.animateFloat(
+        initialValue = 0.35f,
+        targetValue = 1f,
+        animationSpec = infiniteRepeatable(
+            animation = tween(1200),
+            repeatMode = RepeatMode.Reverse,
+        ),
+        label = "pulseAlpha",
+    )
+
+    Box(
+        modifier = modifier
+            .padding(top = 12.dp, end = 12.dp)
+            .size(40.dp)
+            .alpha(pulseAlpha)
+            .background(MaterialTheme.colorScheme.primary, CircleShape)
+            .clickable(onClick = onClick),
+        contentAlignment = Alignment.Center,
+    ) {
+        Icon(
+            Icons.Filled.SystemUpdate,
+            contentDescription = "发现新版本，点击更新",
+            tint = Color.White,
+            modifier = Modifier.size(22.dp),
+        )
+    }
 }
@@ -61,7 +61,7 @@ fun FilterScreen() {
        modifier = Modifier.fillMaxSize().padding(horizontal = 16.dp),
        verticalArrangement = Arrangement.spacedBy(12.dp),
    ) {
-        item { ScreenTitle("过滤与优化", "减少噪音，保留真正需要同步到 iOS 的通知") }
+        item { ScreenTitle("过滤与优化", "减少噪音，保留真正需要转发的通知") }

        item {
            SectionCard("功能开关", subtitle = "规则按通知处理流水线顺序执行") {
@@ -2,6 +2,7 @@ package com.a2i.forwarder.ui.screens

 import android.content.Intent
 import android.provider.Settings
+import androidx.compose.foundation.BorderStroke
 import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
@@ -24,6 +25,7 @@ import androidx.compose.material.icons.filled.Settings
 import androidx.compose.material.icons.filled.WarningAmber
 import androidx.compose.material.icons.filled.SystemUpdate
 import androidx.compose.material3.Button
+import androidx.compose.material3.ButtonDefaults
 import androidx.compose.material3.FilledTonalButton
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
@@ -62,7 +64,7 @@ fun HomeScreen(onOpenLog: () -> Unit, onOpenSettings: () -> Unit) {
    val context = LocalContext.current
    val app = A2iApp.instance
    val forwarding by app.settings.forwardingEnabled.collectAsState()
-    val current by app.settings.currentServer.collectAsState()
+    val servers by app.settings.servers.collectAsState()
    val sent by app.logStore.sentCount.collectAsState()
    val filtered by app.logStore.filteredCount.collectAsState()
    val failed by app.logStore.failedCount.collectAsState()
@@ -97,21 +99,48 @@ fun HomeScreen(onOpenLog: () -> Unit, onOpenSettings: () -> Unit) {
        if (info != null) {
            item {
                SectionCard {
+                    Box(modifier = Modifier
+                        .fillMaxWidth()
+                        .background(
+                            brush = Brush.linearGradient(
+                                colors = listOf(MaterialTheme.colorScheme.tertiary, MaterialTheme.colorScheme.primary),
+                            ),
+                            shape = RoundedCornerShape(8.dp),
+                        )
+                        .padding(16.dp)
+                    ) {
+                        Column {
                            Row(verticalAlignment = Alignment.CenterVertically) {
-                        IconBox(icon = Icons.Filled.SystemUpdate, tint = MaterialTheme.colorScheme.primary)
+                                Box(
+                                    modifier = Modifier
+                                        .size(44.dp)
+                                        .background(Color.White.copy(alpha = 0.18f), RoundedCornerShape(8.dp)),
+                                    contentAlignment = Alignment.Center,
+                                ) {
+                                    Icon(Icons.Filled.SystemUpdate, null, tint = Color.White, modifier = Modifier.size(26.dp))
+                                }
                                Spacer(Modifier.width(12.dp))
                                Column(Modifier.weight(1f)) {
-                            Text("发现新版本 v${info.latestVersion}", style = MaterialTheme.typography.titleMedium)
+                                    Text("发现新版本", style = MaterialTheme.typography.titleLarge, color = Color.White, fontWeight = FontWeight.Bold)
                                    Text(
-                                "安装包 ${formatSize(info.apkSize)} · 点击立即更新",
-                                style = MaterialTheme.typography.bodySmall,
-                                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                                        "v${info.latestVersion} · ${formatSize(info.apkSize)} · 点击立即更新",
+                                        style = MaterialTheme.typography.bodyMedium,
+                                        color = Color.White.copy(alpha = 0.88f),
                                    )
                                }
-                        StatusBadge(text = "新", tint = MaterialTheme.colorScheme.primary)
+                                StatusBadge("🔄", tint = Color.White)
                            }
                            Spacer(Modifier.size(12.dp))
-                    Button(onClick = { showUpdateDialog = true }, modifier = Modifier.fillMaxWidth()) { Text("立即更新") }
+                            Button(
+                                onClick = { showUpdateDialog = true },
+                                modifier = Modifier.fillMaxWidth(),
+                                colors = ButtonDefaults.buttonColors(
+                                    containerColor = Color.White,
+                                    contentColor = MaterialTheme.colorScheme.primary,
+                                ),
+                            ) { Text("🚀 立即更新到 v${info.latestVersion}", fontWeight = FontWeight.Bold) }
+                        }
+                    }
                }
            }
        }
@@ -149,7 +178,7 @@ fun HomeScreen(onOpenLog: () -> Unit, onOpenSettings: () -> Unit) {
                    Column(Modifier.weight(1f)) {
                        Text(if (granted) "通知监听已开启" else "需要授权通知监听", style = MaterialTheme.typography.titleMedium)
                        Text(
-                            if (granted) "系统通知将按规则处理并推送到 Bark" else "授权后才能读取 Android 通知并转发",
+                            if (granted) "系统通知将按规则处理并多通道转发" else "授权后才能读取 Android 通知并转发",
                            style = MaterialTheme.typography.bodySmall,
                            color = MaterialTheme.colorScheme.onSurfaceVariant,
                        )
@@ -173,28 +202,21 @@ fun HomeScreen(onOpenLog: () -> Unit, onOpenSettings: () -> Unit) {
            SectionCard("运行状态", subtitle = "转发能力、目标服务器和日志入口") {
                SwitchRow(
                    title = "通知转发",
-                    subtitle = if (forwarding) "新通知会继续转发到 Bark" else "当前已暂停所有转发",
+                    subtitle = if (forwarding) "新通知会继续多通道转发" else "当前已暂停所有转发",
                    checked = forwarding,
                    icon = Icons.Filled.PowerSettingsNew,
                    tint = if (forwarding) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.onSurfaceVariant,
                ) { v ->
                    app.appScope.launch { app.settings.setForwarding(v) }
                }
+                val enabledServers = servers.filter { it.enabled && it.deviceKey.isNotBlank() }
                ClickRow(
-                    title = current?.name?.ifBlank { "未命名服务器" } ?: "未配置 Bark 服务器",
-                    subtitle = current?.server ?: "进入设置添加官方或自建 Bark 服务",
+                    title = if (enabledServers.isEmpty()) "未启用 Bark 服务器" else "Bark 服务器（${enabledServers.size} 个启用）",
+                    subtitle = enabledServers.firstOrNull()?.server ?: "进入设置勾选要转发的服务器",
                    icon = Icons.Filled.Settings,
                    tint = MaterialTheme.colorScheme.secondary,
                    onClick = onOpenSettings,
                )
-                if (current?.deviceKey.isNullOrBlank()) {
-                    Text(
-                        "当前服务器未填写 device key",
-                        style = MaterialTheme.typography.bodySmall,
-                        color = MaterialTheme.colorScheme.error,
-                        modifier = Modifier.padding(start = 50.dp),
-                    )
-                }
                ClickRow(
                    title = "查看转发日志",
                    subtitle = "最近 300 条处理记录",
@@ -263,8 +285,8 @@ private fun HomeHero(
                }
                Spacer(Modifier.width(12.dp))
                Column(Modifier.weight(1f)) {
-                    Text("a2i", style = MaterialTheme.typography.displaySmall, color = Color.White)
-                    Text("安卓通知转发到 iOS Bark", style = MaterialTheme.typography.bodyMedium, color = Color.White.copy(alpha = 0.82f))
+                    Text("GotMsg", style = MaterialTheme.typography.displaySmall, color = Color.White)
+                    Text("安卓通知多通道转发", style = MaterialTheme.typography.bodyMedium, color = Color.White.copy(alpha = 0.82f))
                }
                StatusBadge(
                    text = if (granted && forwarding) "运行中" else "待处理",
@@ -273,7 +295,7 @@ private fun HomeHero(
            }
            Spacer(Modifier.size(14.dp))
            Text(
-                if (granted && forwarding) "监听、过滤、提取验证码和推送链路已就绪。" else "完成授权并开启转发后，通知会按规则推送到 iOS。",
+                if (granted && forwarding) "监听、过滤、提取验证码和推送链路已就绪。" else "完成授权并开启转发后，通知会按规则转发到各通道。",
                style = MaterialTheme.typography.bodyMedium,
                color = Color.White.copy(alpha = 0.86f),
            )
@@ -55,7 +55,11 @@ fun UpdateDialog(info: UpdateInfo, onDismiss: () -> Unit) {
                        .heightIn(max = 240.dp)
                        .verticalScroll(rememberScrollState()),
                ) {
-                    val notes = info.releaseNotes.ifBlank { "（作者未提供更新说明）" }
+                    val notes = info.releaseNotes
+                        .lineSequence()
+                        .filterNot { it.contains("update-source") }
+                        .joinToString("\n")
+                        .ifBlank { "（作者未提供更新说明）" }
                    Text(notes, style = MaterialTheme.typography.bodyMedium)
                }
                if (downloading) {
@@ -66,7 +70,7 @@ fun UpdateDialog(info: UpdateInfo, onDismiss: () -> Unit) {
                    )
                    Spacer(Modifier.size(4.dp))
                    Text(
-                        "$progress%",
+                        "正在下载更新…",
                        style = MaterialTheme.typography.bodySmall,
                        color = MaterialTheme.colorScheme.onSurfaceVariant,
                    )
@@ -1,3 +1,3 @@
 <resources>
-    <string name="app_name">a2i</string>
+    <string name="app_name">GotMsg 有消息</string>
 </resources>