feat: multi-config lists for ntfy/email/sms + per-channel stopOnFirst

All four forwarding channels now support multiple configurations (add/
edit/delete/reorder/enable per item, matching Bark server UX):

- model: NtfyServer, EmailServer, SmsTarget data classes
- SettingsStore: ntfyServers/emailServers/smsTargets as List; full CRUD
  (add/update/delete/move/setEnabled); legacy single-config auto-migrated
  to list via config_version; 4 stopOnFirst toggles (bark=true, others
  false)
- BarkSender/NtfySender/EmailSender: pushToEnabled(configs, stopOnFirst)
  — stopOnFirst=true: first success stops; false: send to all
- SmsFallbackForwarder: forward iterates smsTargets per stopOnFirst
- UI: each channel SectionCard has toggle + stopOnFirst switch + config
  list + add button; ConfigRow + ConfigDialog reusable components
- version 1.7.3 -> 1.8.0 (code 16 -> 17)

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

.gitignore

@@ -8,6 +8,11 @@ app/build/
 local.properties
 .do-session
 
+# Secrets — never commit
+gh-token.txt
+gitea-token.txt
+*.token
+
 # Android Studio / IntelliJ
 .idea/
 *.iml
@@ -27,3 +32,4 @@ test.json
 # Local assistant session helpers
 .claude/
 do.ps1
+CLAUDE.md

CLAUDE.md

@@ -1,108 +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)
-  → BarkClient.push(msg) → OkHttp POST
-  → LogStore.addLog(...)
-失败 → 加入 pending → RetryWorker (WorkManager, 15min 周期)
-```
-
-### 包结构 `com.a2i.forwarder`
-
-| 文件 | 职责 |
-|---|---|
-| `A2iApp.kt` | `Application` 单例；持有全局 `appScope` 和三个 Store（`settings`、`appRules`、`logStore`）。Store 都用 `MutableStateFlow`，UI 通过 `collectAsState()` 订阅。 |
-| `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。 |
-| `core/RetryWorker.kt` | WorkManager 周期任务，每 15 分钟重发 `pending` 队列中的失败消息。 |
-| `core/LogStore.kt` | 最近 300 条日志 + 失败重发队列（≤100）。DataStore 持久化。 |
-| `core/IconExporter.kt` | 一键导出所有已安装 App 图标到用户选择的 SAF 目录（用于部署到 iOS Bark 图床）。 |
-| `store/SettingsStore.kt` | Bark 服务器列表、全局开关、广告关键词等。`MutableStateFlow` + DataStore。 |
-| `store/AppRulesStore.kt` | 黑/白名单模式 + 默认黑名单（系统 App + 三星剪贴板/键盘 + GMS）。 |
-| `ui/nav/AppNav.kt` | 4 个底部 Tab + 日志页。 |
-| `ui/theme/*` | 固定品牌配色（`Color.kt`）、自定义 `Typography`（`Type.kt`），`A2iTheme` 关闭动态取色、统一深浅色方案（`Theme.kt`）。 |
-| `ui/screens/*.kt` | HomeScreen（品牌横幅 + 运行状态面板 + 统计指标）、AppManageScreen、FilterScreen、SettingsScreen、LogScreen。 |
-| `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. 去重检查（5s 窗口）** → 10. 验证码提取 → 11. 特殊 App 解析 → 12. 构造 BarkMessage
-- **Bark API** 字段映射在 `BarkMessage.kt`（`@SerialName`）：`device_key`/`autoCopy`/`isArchive` 用下划线/驼峰别名，其他用蛇形。
-- **版本号**：`app/build.gradle.kts` 的 `versionCode`/`versionName`，运行时通过 `appVersionName(context)` 读取，首页底部居中显示 `v{version}`。改完代码记得同步递增。
-
-### 通知监听授权
-
-监听服务依赖 `Settings.ACTION_NOTIFICATION_LISTENER_SETTINGS` 授权。`HomeScreen` 检测授权状态，未授权时显示跳转按钮。授权是**一次性**的，卸载后需重新授权。
-
-### 调试日志
-
-`NotifyListenerService.handle()` 每次都会写一条 `ForwardLog` 到 `LogStore`（无论转发/过滤/失败），可在「日志」页查看最近 300 条。失败会自动加入 `pending` 队列，由 `RetryWorker` 后续重发。
-
-## 版本与发布
-
-- 当前版本：`versionCode = 3`、`versionName = "1.2.0"`（位于 `app/build.gradle.kts`）。改完代码记得同步递增。
-- 远端仓库：`https://github.com/lsxf/a2i.git`，默认分支 `main`。
-- 提交策略：`.gitignore` 已排除 `app/build`、`.gradle`、`.kotlin`、`local.properties`、`.claude/`、`do.ps1`、截图与临时文件，**不要**提交它们。
-- 发版流程：本地打 tag（`git tag -a v1.2.0 -m "..."`）→ `git push origin v1.2.0` → 在 GitHub Releases 基于 tag 发布，并上传 `app-release.apk` 作为二进制附件。
-- UI 现状：统一品牌科技感主题（固定品牌色 + 自定义 Typography + 共享组件层），深浅色双方案，关闭动态取色；新组件统一通过 `ui/Components.kt` 复用，避免各页面各拼一套样式。

README.md

@@ -1,8 +1,8 @@
-# a2i
+# A2i ·安到果（按倒过[呲牙]）
 
-把安卓手机上的通知（短信、验证码、微信、QQ、Telegram 等）实时转发到 iOS，通过 [Bark](https://github.com/Finb/Bark) 推送到 iPhone / iPad。在 iOS 上点击通知，还能一键跳转到对应的 App。
+把安卓手机上的通知（短信、验证码、电话“有电话进来这个通知，不是电话呼叫转移”、微信、QQ、Telegram 等）实时转发到 iOS，通过 [Bark](https://github.com/Finb/Bark) 推送到 iPhone / iPad。在 iOS 上点击通知，还能一键跳转到对应的 App。
 
-适用于把主力安卓机的消息同步到 iOS 设备，不漏验证码、不漏重要聊天。
+适用于把安卓备机的消息同步到 iOS 设备，不漏验证码、不漏重要聊天。
 
 ## 主要功能
 
@@ -17,7 +17,13 @@
 - **应用级规则**：黑名单 / 白名单两种模式，可按 App 单独控制是否转发。
 - **失败自动重试**：发送失败的通知进入待重发队列，由 WorkManager 定期重试，也可手动触发。
 - **本地日志**：保留最近 300 条处理记录，方便排查为什么某条通知被过滤或发送失败。
-- **图标导出**：一键导出已安装 App 的图标，便于部署到 Bark 图床，让通知带上来源图标。
+- **电话来电通知**：通过轮询 `getCallState()` 实时感知来电和未接来电（绕过 MIUI 对系统电话通知的限制，需授予"电话"权限）。
+- **断网短信兜底**：无网络时自动把验证码、来电用短信发到 iPhone。
+  - 自动识别运营商（移动/联通/电信/广电），发免费查询短信拿套餐内短信余量
+  - 余额 ≤5 条自动停用，下次打开 App 提醒
+  - 每 5 分钟最多发 1 条，避免刷屏
+  - 自动解析失败时回退手动额度计数
+- **应用内更新**：每天自动检查 GitHub 新版本，发现新版后一键下载并通过系统安装器升级，无需手动去网页下载。
 
 ## 快速开始
 
@@ -50,6 +56,8 @@
 - **想同步聊天**：保持黑名单模式（默认），在「过滤」页开启「微信 / QQ / Telegram 优化」。
 - **通知没推过来**：先看「日志」页，每条通知（无论转发、过滤还是失败）都会记录原因。
 - **想让通知带图标**：参考下方「应用图标」一节。
+- **电话通知不工作**：MIUI 会把系统电话通知限制为不向第三方通知监听器分发，本 App 通过轮询 `getCallonyState()` 绕过此限制。需要授予「电话」权限（设置 → 应用 → a2i → 权限 → 电话）。
+- **断网收不到通知**：开启「设置 → 断网短信兜底」，填好 iPhone 号码、授予短信权限、设好手动额度。断网时验证码和来电会走短信（消耗套餐额度，5 分钟限 1 条）。
 
 ## 应用图标
 
@@ -63,6 +71,38 @@ Bark 的 `icon` 字段需要一个公网可访问的图片 URL。a2i 支持把
 
 留空前缀则不显示图标。
 
+## 自建 Bark 服务（可选）
+
+a2i 默认用 Bark 官方服务器（`https://api.day.app`），免费够用。如果想完全自控、不限速、不依赖第三方，可以自建 Bark Server。下面是三种零成本方案：
+
+### 方案 1：Vercel 云托管（最适合新手）
+
+把 Bark 后端跑在 Vercel 的 Serverless 上，每次推送触发一个云函数，不挂进程、完全免费。
+
+- 平台：[Vercel](https://vercel.com) · 代码：[GitHub](https://github.com)
+- 在 GitHub 搜索 `bark-server-vercel`，项目 README 里通常有 **Deploy with Vercel** 按钮，一键克隆部署
+
+### 方案 2：Cloudflare Workers（最稳定）
+
+把轻量 JS 转发代码部署到 Cloudflare 全球边缘节点，免费额度每天 10 万次请求，个人用属于「溢出」状态。
+
+- 平台：[Cloudflare](https://www.cloudflare.com)
+- 在 GitHub 搜索 `bark-server-cloudflare` 或 `bark cloudflare worker`，在 Cloudflare 后台新建 Worker 粘贴脚本保存即可
+
+### 方案 3：免费 VPS + Docker（最高自主权）
+
+在永久免费的 Linux 虚拟机上用 Docker 跑官方 bark-server。
+
+- 官方服务端：[finab/bark-server](https://github.com/finab/bark-server)
+- 反向代理 + 免费 HTTPS 证书：[Nginx Proxy Manager](https://nginxproxymanager.com)
+- 免费 VPS：[Oracle Cloud 永久免费层](https://www.oracle.com/cloud/free/)、[AWS 一年免费套餐](https://aws.amazon.com/free/)
+
+### ⚠️ 防坑提示
+
+国内网络下，Vercel 的 `*.vercel.app` 和 Cloudflare 的 `*.workers.dev` 二级域名可能间歇性无法访问。**终极方案**：注册一个便宜的个人域名（或找免费域名），解析托管到 Cloudflare，然后把 Vercel / Worker 绑到**自定义域名**上——既稳定又秒达。
+
+自建完成后，在「设置 → Bark 服务器」里填自建地址即可。
+
 ## 技术栈
 
 - Kotlin + Jetpack Compose（Material 3）

app/build.gradle.kts

@@ -13,8 +13,8 @@ android {
         applicationId = "com.a2i.forwarder"
         minSdk = 34
         targetSdk = 36
-        versionCode = 3
+        versionCode = 17
-        versionName = "1.2.0"
+        versionName = "1.8.0"
     }
 
     signingConfigs {

app/src/main/AndroidManifest.xml

@@ -4,11 +4,14 @@
 
     <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.READ_PHONE_STATE" />
+    <uses-permission android:name="android.permission.SEND_SMS" />
     <uses-permission android:name="android.permission.QUERY_ALL_PACKAGES"
         tools:ignore="QueryAllPackagesPermission" />
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
     <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <uses-permission android:name="android.permission.REQUEST_INSTALL_PACKAGES" />
 
     <application
         android:name=".A2iApp"
@@ -43,5 +46,15 @@
             </intent-filter>
         </service>
 
+        <provider
+            android:name="androidx.core.content.FileProvider"
+            android:authorities="${applicationId}.fileprovider"
+            android:exported="false"
+            android:grantUriPermissions="true">
+            <meta-data
+                android:name="android.support.FILE_PROVIDER_PATHS"
+                android:resource="@xml/file_paths" />
+        </provider>
+
     </application>
 </manifest>

app/src/main/java/com/a2i/forwarder/A2iApp.kt

@@ -1,7 +1,13 @@
 package com.a2i.forwarder
 
 import android.app.Application
+import com.a2i.forwarder.core.CarrierBalanceQuery
+import com.a2i.forwarder.core.CarrierDetector
+import com.a2i.forwarder.core.ConnectivityMonitor
 import com.a2i.forwarder.core.LogStore
+import com.a2i.forwarder.core.PhoneCallMonitor
+import com.a2i.forwarder.core.SmsFallbackForwarder
+import com.a2i.forwarder.core.UpdateChecker
 import com.a2i.forwarder.store.AppRulesStore
 import com.a2i.forwarder.store.SettingsStore
 import kotlinx.coroutines.CoroutineScope
@@ -17,6 +23,16 @@ class A2iApp : Application() {
         private set
     lateinit var logStore: LogStore
         private set
+    lateinit var phoneCallMonitor: PhoneCallMonitor
+        private set
+    lateinit var connectivityMonitor: ConnectivityMonitor
+        private set
+    lateinit var carrierBalanceQuery: CarrierBalanceQuery
+        private set
+    lateinit var smsForwarder: SmsFallbackForwarder
+        private set
+    lateinit var updateChecker: UpdateChecker
+        private set
 
     override fun onCreate() {
         super.onCreate()
@@ -24,6 +40,14 @@ class A2iApp : Application() {
         settings = SettingsStore(this, appScope)
         appRules = AppRulesStore(this, appScope)
         logStore = LogStore(this, appScope)
+        phoneCallMonitor = PhoneCallMonitor(this)
+        phoneCallMonitor.start()
+        connectivityMonitor = ConnectivityMonitor(this)
+        connectivityMonitor.start()
+        carrierBalanceQuery = CarrierBalanceQuery(this)
+        smsForwarder = SmsFallbackForwarder(this)
+        updateChecker = UpdateChecker(this)
+        updateChecker.start()
     }
 
     companion object {

app/src/main/java/com/a2i/forwarder/core/BarkClient.kt

@@ -3,6 +3,7 @@ package com.a2i.forwarder.core
 import com.a2i.forwarder.model.BarkMessage
 import com.a2i.forwarder.model.BarkServer
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.withContext
 import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
@@ -10,6 +11,7 @@ import okhttp3.MediaType.Companion.toMediaType
 import okhttp3.OkHttpClient
 import okhttp3.Request
 import okhttp3.RequestBody.Companion.toRequestBody
+import java.io.IOException
 import java.util.concurrent.TimeUnit
 
 class BarkClient(private val server: BarkServer) {
@@ -24,16 +26,37 @@ class BarkClient(private val server: BarkServer) {
     suspend fun push(msg: BarkMessage): Result<Unit> = withContext(Dispatchers.IO) {
         runCatching {
             require(server.deviceKey.isNotBlank()) { "device key 为空" }
-            val body = json.encodeToString(msg).toRequestBody(JSON)
+            doPushWithRetry(msg)
+        }
+    }
+
+    /**
+     * 带重试的推送：对 connection closed / 超时 / TLS 中断等瞬时 IOException 自动重试。
+     * OkHttp 的 retryOnConnectionFailure 不覆盖 POST 读响应阶段的连接中断，故在此手动补。
+     * HTTP 4xx/5xx 是服务端拒绝，重试无意义，直接抛出。
+     */
+    private suspend fun doPushWithRetry(msg: BarkMessage) {
+        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
+        repeat(MAX_ATTEMPTS) { attempt ->
+            try {
                 http.newCall(req).execute().use { res ->
-                if (!res.isSuccessful) error("HTTP ${res.code}")
+                    if (res.isSuccessful) return
+                    error("HTTP ${res.code}")
+                }
+            } catch (e: IOException) {
+                lastError = e
+                if (attempt < MAX_ATTEMPTS - 1) delay(BACKOFF_MS.getOrElse(attempt) { 1000L })
             }
         }
+        throw lastError ?: error("推送失败")
     }
 
     companion object {
         private val JSON = "application/json; charset=utf-8".toMediaType()
+        private const val MAX_ATTEMPTS = 3
+        private val BACKOFF_MS = longArrayOf(600L, 1200L)
     }
 }

app/src/main/java/com/a2i/forwarder/core/BarkSender.kt

@@ -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("推送失败")
+        }
+    }
+}

app/src/main/java/com/a2i/forwarder/core/CarrierBalanceQuery.kt

@@ -0,0 +1,90 @@
+package com.a2i.forwarder.core
+
+import android.Manifest
+import android.content.Context
+import android.content.pm.PackageManager
+import android.telephony.SmsManager
+import androidx.core.content.ContextCompat
+import com.a2i.forwarder.A2iApp
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+
+/**
+ * 运营商短信余额查询：
+ * - refresh()：向运营商服务号发免费查询短信（若运营商支持），回执由 NotificationProcessor 解析。
+ * - 手动模式：递减 smsManualQuota 作为余额。
+ * - parseReply()：从运营商回执短信正文中提取剩余短信条数，供 NotificationProcessor 调用。
+ */
+class CarrierBalanceQuery(private val context: Context) {
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+
+    private val settings get() = A2iApp.instance.settings
+
+    /** 触发一次余额查询（自动模式发短信，手动模式递减额度）。 */
+    suspend fun refresh() {
+        val carrier = currentCarrier()
+        // 自动模式：发查询短信到运营商（免费，不走限频）
+        if (carrier.serviceNumber != null && carrier.queryCmd != null) {
+            sendSms(carrier.serviceNumber, carrier.queryCmd)
+            return
+        }
+        // 手动模式：余额 = 手动额度，不额外查询
+    }
+
+    /** 转发成功后扣减余额（手动模式 / 自动解析失败时）。 */
+    suspend fun decrementManual() {
+        val q = settings.smsManualQuota.value
+        if (q > 0) {
+            val newQ = q - 1
+            settings.setSmsManualQuota(newQ)
+            settings.setSmsBalance(newQ)
+            checkSuspend(newQ)
+        }
+    }
+
+    /** 解析运营商回执，提取剩余短信条数。返回 null 表示解析失败。供 NotificationProcessor 调用。 */
+    fun parseReply(text: String): Int? {
+        // 匹配 "短信剩余XX条" / "短信：XX条" / "短信余量XX条" 等
+        val patterns = listOf(
+            Regex("""短信[^0-9]*(\d+)\s*条"""),
+            Regex("""短信余[额度][^0-9]*(\d+)"""),
+        )
+        for (p in patterns) {
+            val m = p.find(text) ?: continue
+            val n = m.groupValues.getOrNull(1)?.toIntOrNull() ?: continue
+            if (n in 0..9999) return n
+        }
+        return null
+    }
+
+    /** 回执解析成功后更新余额并检查是否需要挂起。 */
+    suspend fun applyParsedBalance(count: Int) {
+        settings.setSmsBalance(count)
+        checkSuspend(count)
+    }
+
+    private suspend fun checkSuspend(balance: Int) {
+        if (balance in 0..5 && !settings.smsSuspended.value) {
+            settings.setSmsSuspended(true)
+        }
+    }
+
+    fun currentCarrier(): CarrierDetector.Carrier {
+        val stored = settings.smsCarrier.value
+        return if (stored == "auto") CarrierDetector.detect(context)
+        else CarrierDetector.Carrier.fromName(stored)
+    }
+
+    private fun sendSms(dest: String, body: String) {
+        if (ContextCompat.checkSelfPermission(context, Manifest.permission.SEND_SMS)
+            != PackageManager.PERMISSION_GRANTED
+        ) return
+        scope.launch {
+            runCatching {
+                SmsManager.getDefault().sendTextMessage(dest, null, body, null, null)
+            }
+        }
+    }
+}

app/src/main/java/com/a2i/forwarder/core/CarrierDetector.kt

@@ -0,0 +1,54 @@
+package com.a2i.forwarder.core
+
+import android.content.Context
+import android.os.Build
+import android.telephony.TelephonyManager
+
+/**
+ * 运营商检测：根据 SIM 的 MCC+MNC 映射到国内运营商。
+ * 提供余额查询用的服务号 + 查询指令。
+ */
+object CarrierDetector {
+
+    enum class Carrier(
+        val displayName: String,
+        val serviceNumber: String?,   // 余额查询服务号（免费）
+        val queryCmd: String?,        // 查询指令（发送到此服务号）
+    ) {
+        CHINA_MOBILE("中国移动", "10086", "CXDX"),
+        CHINA_UNICOM("中国联通", "10010", "CXTC"),
+        CHINA_TELECOM("中国电信", "10001", "108"),
+        CHINA_BROADCASTING("中国广电", "10099", null), // 无统一查询指令
+        UNKNOWN("未知运营商", null, null);
+
+        companion object {
+            fun fromName(name: String?): Carrier =
+                entries.firstOrNull { it.name == name } ?: UNKNOWN
+        }
+    }
+
+    // MCC+MNC → 运营商（中国大陆 460）
+    private val mncMap = mapOf(
+        // 中国移动
+        "46000" to Carrier.CHINA_MOBILE, "46002" to Carrier.CHINA_MOBILE,
+        "46004" to Carrier.CHINA_MOBILE, "46007" to Carrier.CHINA_MOBILE,
+        // 中国联通
+        "46001" to Carrier.CHINA_UNICOM, "46006" to Carrier.CHINA_UNICOM,
+        "46009" to Carrier.CHINA_UNICOM,
+        // 中国电信
+        "46003" to Carrier.CHINA_TELECOM, "46005" to Carrier.CHINA_TELECOM,
+        "46011" to Carrier.CHINA_TELECOM, "46012" to Carrier.CHINA_TELECOM,
+        // 中国广电
+        "46015" to Carrier.CHINA_BROADCASTING, "46018" to Carrier.CHINA_BROADCASTING,
+    )
+
+    fun detect(context: Context): Carrier {
+        return runCatching {
+            val tm = context.getSystemService(Context.TELEPHONY_SERVICE) as? TelephonyManager
+                ?: return Carrier.UNKNOWN
+            val simOperator = tm.simOperator   // 形如 "46000"
+            if (simOperator.isNullOrBlank() || simOperator.length < 5) return Carrier.UNKNOWN
+            mncMap[simOperator] ?: Carrier.UNKNOWN
+        }.getOrDefault(Carrier.UNKNOWN)
+    }
+}

app/src/main/java/com/a2i/forwarder/core/ConnectivityMonitor.kt

@@ -0,0 +1,54 @@
+package com.a2i.forwarder.core
+
+import android.content.Context
+import android.net.ConnectivityManager
+import android.net.Network
+import android.net.NetworkCapabilities
+import android.net.NetworkRequest
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+
+/**
+ * 监听网络连通性（是否能访问互联网）。
+ * 暴露 isOnline: StateFlow<Boolean>，断网时短信兜底转发器据此降级。
+ */
+class ConnectivityMonitor(private val context: Context) {
+    private val _isOnline = MutableStateFlow(false)
+    val isOnline = _isOnline.asStateFlow()
+
+    private var registered = false
+
+    private val callback = object : ConnectivityManager.NetworkCallback() {
+        override fun onAvailable(network: Network) { refresh() }
+        override fun onLost(network: Network) { refresh() }
+        override fun onCapabilitiesChanged(network: Network, caps: NetworkCapabilities) { refresh() }
+    }
+
+    fun start() {
+        if (registered) return
+        val cm = context.getSystemService(Context.CONNECTIVITY_SERVICE) as? ConnectivityManager
+            ?: return
+        val request = NetworkRequest.Builder()
+            .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
+            .build()
+        runCatching { cm.registerNetworkCallback(request, callback) }
+        registered = true
+        refresh()
+    }
+
+    fun stop() {
+        if (!registered) return
+        val cm = context.getSystemService(Context.CONNECTIVITY_SERVICE) as? ConnectivityManager
+        runCatching { cm?.unregisterNetworkCallback(callback) }
+        registered = false
+    }
+
+    private fun refresh() {
+        val cm = context.getSystemService(Context.CONNECTIVITY_SERVICE) as? ConnectivityManager ?: return
+        val active = cm.activeNetwork
+        val caps = active?.let { cm.getNetworkCapabilities(it) }
+        _isOnline.value = caps != null &&
+            caps.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) &&
+            caps.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
+    }
+}

app/src/main/java/com/a2i/forwarder/core/EmailSender.kt

@@ -0,0 +1,130 @@
+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
+        if (!s.emailForwardingEnabled.value) return
+        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)
+        }
+    }
+}

app/src/main/java/com/a2i/forwarder/core/NotificationProcessor.kt

@@ -16,6 +16,7 @@ class NotificationProcessor(private val context: Context) {
         val reason: String,
         val appLabel: String,
         val code: String?,
+        val silent: Boolean = false,   // true = 静默过滤，不写日志
     )
 
     // ========== 去重缓存 ==========
@@ -48,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)
@@ -88,10 +98,18 @@ class NotificationProcessor(private val context: Context) {
         if (!settings.forwardingEnabled.value)
             return Decision(null, "全局转发已关", appLabel, null)
 
-        // ---- 持续性通知过滤 ----
+        // ---- 持续性通知过滤（静默，不进日志）----
         val isOngoing = n.flags and Notification.FLAG_ONGOING_EVENT != 0
         if (settings.skipOngoing.value && isOngoing)
-            return Decision(null, "持续性通知", appLabel, null)
+            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))
@@ -122,6 +140,16 @@ class NotificationProcessor(private val context: Context) {
         if (settings.adFilterEnabled.value && AdFilter.isAd("$title $content $sub", settings.adKeywords.value))
             return Decision(null, "广告过滤", appLabel, null)
 
+        // ---- 短信"发出"过滤：只保留收到的短信 ----
+        if (isSentSmsNotification(pkg, title, content))
+            return Decision(null, "已发短信（仅收不发）", appLabel, null)
+
+        // ---- 运营商余额回执拦截：解析短信余量，不转发 ----
+        val balanceParsed = tryParseCarrierBalance(pkg, title, content)
+        if (balanceParsed != null) {
+            return Decision(null, "运营商余额回执（${balanceParsed}条）", appLabel, null)
+        }
+
         // ---- 去重检查 ----
         val dedupKey = "$pkg|${title.take(80)}|${content.take(80)}"
         val lastTime = dedupCache[dedupKey]
@@ -160,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,
@@ -188,4 +216,47 @@ class NotificationProcessor(private val context: Context) {
     private fun isSystemStatusMessage(text: String): Boolean {
         return systemStatusPatterns.any { it.containsMatchIn(text) }
     }
+
+    /** 短信 App 列表 */
+    private val smsPackages = setOf(
+        "com.android.mms",
+        "com.google.android.apps.messaging",
+        "com.samsung.android.messaging",
+        "com.android.messaging",
+    )
+
+    /** 发出的短信通知关键词 */
+    private val sentSmsPatterns = listOf(
+        Regex("""发送中"""),
+        Regex("""正在发送"""),
+        Regex("""已发送"""),
+        Regex("""发送成功"""),
+        Regex("""短信已发出"""),
+        Regex("""消息已发出"""),
+        Regex("""sending""", RegexOption.IGNORE_CASE),
+        Regex("""message sent""", RegexOption.IGNORE_CASE),
+        Regex("""sent$""", RegexOption.IGNORE_CASE),
+    )
+
+    /** 判断是否为发出的短信通知（而非收到的） */
+    private fun isSentSmsNotification(pkg: String, title: String, content: String): Boolean {
+        if (pkg !in smsPackages) return false
+        val blob = "$title $content"
+        return sentSmsPatterns.any { it.containsMatchIn(blob) }
+    }
+
+    /**
+     * 拦截运营商余额回执短信：title 是运营商服务号（10086/10010/10001/10099），
+     * 解析正文中的剩余短信条数，写入设置并按"过滤"处理。
+     * 返回解析到的条数（已处理），返回 null 表示不是回执或解析失败。
+     */
+    private fun tryParseCarrierBalance(pkg: String, title: String, content: String): Int? {
+        if (pkg !in smsPackages) return null
+        val serviceNumbers = setOf("10086", "10010", "10001", "10099")
+        if (title.trim() !in serviceNumbers) return null
+        val app = A2iApp.instance
+        val count = app.carrierBalanceQuery.parseReply("$title $content") ?: return null
+        kotlinx.coroutines.runBlocking { app.carrierBalanceQuery.applyParsedBalance(count) }
+        return count
+    }
 }

app/src/main/java/com/a2i/forwarder/core/NtfySender.kt

@@ -0,0 +1,103 @@
+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
+        if (!s.ntfyEnabled.value) return
+        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)
+}

app/src/main/java/com/a2i/forwarder/core/PhoneCallMonitor.kt

@@ -0,0 +1,151 @@
+package com.a2i.forwarder.core
+
+import android.Manifest
+import android.content.Context
+import android.content.pm.PackageManager
+import android.telephony.TelephonyManager
+import androidx.core.content.ContextCompat
+import com.a2i.forwarder.A2iApp
+import com.a2i.forwarder.model.BarkMessage
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+import java.util.UUID
+
+/**
+ * 通过轮询 TelephonyManager.getCallState() 监听来电状态。
+ * MIUI 不会把系统电话通知分发给第三方监听器，TelephonyCallback 也不生效，
+ * 所以这里用最原始但最可靠的方式：每 800ms 读一次 call state。
+ *
+ * getCallState() 只是读内存中的 int，不涉及硬件操作，耗电极低。
+ */
+class PhoneCallMonitor(private val context: Context) {
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+    private val json = Json { encodeDefaults = true; ignoreUnknownKeys = true }
+
+    private var lastState = TelephonyManager.CALL_STATE_IDLE
+    private var ringing = false
+    private var offhook = false
+    private var running = false
+
+    /** 上一次推送"来电"的时间，防止重复推送 */
+    private var lastRingTime = 0L
+
+    fun start() {
+        if (running) return
+        if (ContextCompat.checkSelfPermission(context, Manifest.permission.READ_PHONE_STATE)
+            != PackageManager.PERMISSION_GRANTED
+        ) return
+
+        running = true
+        lastState = TelephonyManager.CALL_STATE_IDLE
+        ringing = false
+        offhook = false
+
+        scope.launch {
+            val tm = context.getSystemService(Context.TELEPHONY_SERVICE) as? TelephonyManager
+            if (tm == null) { running = false; return@launch }
+
+            while (isActive && running) {
+                val state = tm.callState
+                if (state != lastState) {
+                    handleTransition(lastState, state)
+                    lastState = state
+                }
+                delay(800)
+            }
+        }
+    }
+
+    fun stop() {
+        running = false
+    }
+
+    private fun handleTransition(from: Int, to: Int) {
+        val app = A2iApp.instance
+        val settings = app.settings
+        if (!settings.forwardingEnabled.value) return
+
+        when {
+            // IDLE → RINGING：来电
+            from == TelephonyManager.CALL_STATE_IDLE && to == TelephonyManager.CALL_STATE_RINGING -> {
+                ringing = true
+                offhook = false
+                val now = System.currentTimeMillis()
+                if (now - lastRingTime > 3000) {
+                    lastRingTime = now
+                    val msg = BarkMessage(
+                        deviceKey = "",
+                        title = "来电",
+                        body = "有电话进来",
+                        level = "timeSensitive",
+                        group = "phone_call",
+                        isArchive = "1",
+                    )
+                    pushToServers(msg, app, "来电")
+                }
+            }
+
+            // RINGING → OFFHOOK：接听
+            from == TelephonyManager.CALL_STATE_RINGING && to == TelephonyManager.CALL_STATE_OFFHOOK -> {
+                offhook = true
+            }
+
+            // RINGING → IDLE：未接（响了但没接）
+            from == TelephonyManager.CALL_STATE_RINGING && to == TelephonyManager.CALL_STATE_IDLE -> {
+                if (!offhook && ringing) {
+                    val msg = BarkMessage(
+                        deviceKey = "",
+                        title = "未接来电",
+                        body = "未接来电",
+                        level = "timeSensitive",
+                        group = "phone_call",
+                        isArchive = "1",
+                    )
+                    pushToServers(msg, app, "未接来电")
+                }
+                ringing = false
+                offhook = false
+            }
+
+            // OFFHOOK → IDLE：正常挂断，不推送
+            from == TelephonyManager.CALL_STATE_OFFHOOK && to == TelephonyManager.CALL_STATE_IDLE -> {
+                ringing = false
+                offhook = false
+            }
+        }
+    }
+
+    private fun pushToServers(msg: BarkMessage, app: A2iApp, logBody: String) {
+        scope.launch {
+            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)
+                return@launch
+            }
+            val result = BarkSender.pushToEnabled(servers, msg, app.settings.barkStopOnFirst.value)
+            val now = System.currentTimeMillis()
+            if (result.isSuccess) {
+                app.logStore.addLog(
+                    ForwardLog(now, "phone_call", "电话", msg.title, logBody, "sent", "")
+                )
+            } else {
+                val reason = result.exceptionOrNull()?.message ?: "错误"
+                app.logStore.addLog(
+                    ForwardLog(now, "phone_call", "电话", msg.title, logBody, "failed", reason)
+                )
+                app.logStore.addPending(
+                    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)
+        }
+    }
+}

app/src/main/java/com/a2i/forwarder/core/RetryWorker.kt

@@ -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 }
+            if (servers.isEmpty()) { allOk = false; break }
-                ?: settings.currentServer.value
-                ?: continue
-            if (server.deviceKey.isBlank()) { allOk = false; continue }
             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()

app/src/main/java/com/a2i/forwarder/core/SmsFallbackForwarder.kt

@@ -0,0 +1,117 @@
+package com.a2i.forwarder.core
+
+import android.Manifest
+import android.content.Context
+import android.content.pm.PackageManager
+import android.telephony.SmsManager
+import androidx.core.content.ContextCompat
+import com.a2i.forwarder.A2iApp
+import com.a2i.forwarder.core.NotificationProcessor.Decision
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+
+/**
+ * 短信兜底转发器：断网时把紧要通知（验证码、来电）用短信发到 iPhone。
+ * 限频：每 5 分钟最多 1 条转发短信。余额 ≤5 时自动挂起。
+ */
+class SmsFallbackForwarder(private val context: Context) {
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+    private val RATE_LIMIT_MS = 5 * 60 * 1000L
+
+    private val app get() = A2iApp.instance
+    private val settings get() = app.settings
+
+    /** 判断该通知是否值得走短信（断网资源宝贵）。 */
+    fun isSmsWorthy(d: Decision): Boolean {
+        if (d.code != null) return true                      // 验证码
+        val msg = d.message ?: return false
+        if (msg.group == "phone_call") return true           // 来电/未接来电
+        val t = msg.title.orEmpty()
+        return t.contains("来电") || t.contains("未接")
+    }
+
+    /** 尝试用短信转发（遍历所有启用的目标号，按 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 targets = settings.smsTargets.value.filter { it.enabled && it.number.isNotBlank() }
+            if (targets.isEmpty()) {
+                log(d, "failed", "未设置短信目标号")
+                return@launch
+            }
+            // 限频
+            val now = System.currentTimeMillis()
+            val elapsed = now - settings.lastSmsSentTime.value
+            if (elapsed < RATE_LIMIT_MS) {
+                log(d, "filtered", "限频（${RATE_LIMIT_MS - elapsed}ms 内）")
+                return@launch
+            }
+            // 权限
+            if (ContextCompat.checkSelfPermission(context, Manifest.permission.SEND_SMS)
+                != PackageManager.PERMISSION_GRANTED
+            ) {
+                log(d, "failed", "无 SEND_SMS 权限")
+                return@launch
+            }
+
+            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(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 {
+                    repeat(sentCount) { runCatching { app.carrierBalanceQuery.decrementManual() } }
+                }
+            } else {
+                log(d, "failed", lastReason)
+            }
+        }
+    }
+
+    private fun compose(d: Decision): String {
+        val code = d.code
+        return if (code != null) {
+            "[验证码]${d.appLabel}: $code"
+        } else {
+            val m = d.message!!
+            "${m.title.orEmpty().ifBlank { d.appLabel }}: ${m.body}".trim()
+        }
+    }
+
+    private fun log(d: Decision, status: String, reason: String) {
+        scope.launch {
+            val now = System.currentTimeMillis()
+            val title = d.code?.let { "验证码" } ?: d.message?.title ?: d.appLabel
+            val content = d.code ?: d.message?.body ?: ""
+            app.logStore.addLog(
+                ForwardLog(now, "sms_fallback", d.appLabel, title, content, status, reason)
+            )
+        }
+    }
+}

app/src/main/java/com/a2i/forwarder/core/UpdateChecker.kt

@@ -0,0 +1,262 @@
+package com.a2i.forwarder.core
+
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import android.provider.Settings
+import androidx.core.content.FileProvider
+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
+import okhttp3.Request
+import org.json.JSONObject
+import java.io.File
+import java.util.concurrent.TimeUnit
+
+data class UpdateInfo(
+    val latestVersion: String,
+    val apkUrl: String,
+    val apkSize: Long,
+    val releaseNotes: String,
+    val releasePageUrl: String,
+)
+
+/**
+ * 应用内更新：定时巡检 Gitea Releases 最新版 → 版本比较 → 醒目横幅 + 自动推送通知 → 下载 APK → 调起系统安装器。
+ * Android targetSdk≥24 须用 FileProvider，targetSdk≥26 安装未知来源 APK 须 REQUEST_INSTALL_PACKAGES。
+ */
+class UpdateChecker(private val context: Context) {
+    private val app get() = A2iApp.instance
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+    private val http = OkHttpClient.Builder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .retryOnConnectionFailure(true)
+        .build()
+
+    val updateInfo = MutableStateFlow<UpdateInfo?>(null)
+    val downloading = MutableStateFlow(false)
+    val downloadProgress = MutableStateFlow(0)
+    val lastError = MutableStateFlow<String?>(null)
+    private var lastNotifiedVersion: String? = null  // 记录已推送的版本，避免重复通知
+
+    fun start() {
+        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?> = 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 (throttle && now - settings.lastUpdateCheckTime.value < CHECK_INTERVAL_MS) return@runCatching updateInfo.value
+
+            // 双源查询（Gitea 国内优先 + GitHub 备用），任一不通跳过，取最高版本
+            val infos = RELEASES_APIS.mapNotNull { api ->
+                runCatching { fetchRelease(api) }.getOrNull()
+            }
+            settings.setLastUpdateCheck(now)
+            if (infos.isEmpty()) {
+                lastError.value = "所有更新源不可达"
+                return@runCatching updateInfo.value
+            }
+            val current = currentVersionName()
+            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", "a2i-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 = "🆕 a2i 新版本 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)
+
+        // 电邮
+        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()
+        if (tag.isEmpty()) return null
+        val assets = json.optJSONArray("assets") ?: return null
+        var apkUrl = ""
+        var apkSize = 0L
+        for (i in 0 until assets.length()) {
+            val a = assets.optJSONObject(i) ?: continue
+            if (a.optString("name").endsWith(".apk", ignoreCase = true)) {
+                apkUrl = a.optString("browser_download_url")
+                apkSize = a.optLong("size")
+                break
+            }
+        }
+        if (apkUrl.isEmpty()) return null
+        return UpdateInfo(
+            latestVersion = tag,
+            apkUrl = apkUrl,
+            apkSize = apkSize,
+            releaseNotes = json.optString("body").orEmpty(),
+            releasePageUrl = json.optString("html_url").orEmpty(),
+        )
+    }
+
+    suspend fun download(info: UpdateInfo): File? = withContext(Dispatchers.IO) {
+        downloading.value = true
+        downloadProgress.value = 0
+        lastError.value = null
+        try {
+            val req = Request.Builder().url(info.apkUrl).get().build()
+            http.newCall(req).execute().use { res ->
+                if (!res.isSuccessful) { lastError.value = "HTTP ${res.code}"; return@use null }
+                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")
+                target.outputStream().use { sink ->
+                    val input = body.byteStream()
+                    val buf = ByteArray(8 * 1024)
+                    var read = 0L
+                    while (true) {
+                        val n = input.read(buf)
+                        if (n <= 0) break
+                        sink.write(buf, 0, n)
+                        read += n
+                        if (total > 0) downloadProgress.value = (read * 100 / total).toInt()
+                    }
+                }
+                downloadProgress.value = 100
+                target
+            }
+        } catch (e: Exception) {
+            lastError.value = e.message ?: "下载失败"
+            null
+        } finally {
+            downloading.value = false
+        }
+    }
+
+    fun install(apk: File) {
+        if (!context.packageManager.canRequestPackageInstalls()) {
+            val intent = Intent(Settings.ACTION_MANAGE_UNKNOWN_APP_SOURCES).apply {
+                data = Uri.parse("package:${context.packageName}")
+                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+            }
+            runCatching { context.startActivity(intent) }
+            return
+        }
+        val uri = FileProvider.getUriForFile(context, "${context.packageName}.fileprovider", apk)
+        val intent = Intent(Intent.ACTION_VIEW).apply {
+            setDataAndType(uri, "application/vnd.android.package-archive")
+            addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
+            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+        }
+        runCatching { context.startActivity(intent) }
+    }
+
+    fun ignoreVersion(v: String) {
+        scope.launch {
+            app.settings.setIgnoredVersion(v)
+            updateInfo.value = null
+        }
+    }
+
+    private fun currentVersionName(): String {
+        return runCatching {
+            @Suppress("DEPRECATION")
+            context.packageManager.getPackageInfo(context.packageName, 0).versionName ?: "0"
+        }.getOrDefault("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 }
+        val n = maxOf(l.size, c.size)
+        for (i in 0 until n) {
+            val lv = l.getOrElse(i) { 0 }
+            val cv = c.getOrElse(i) { 0 }
+            if (lv != cv) return lv > cv
+        }
+        return false
+    }
+
+    companion object {
+        // 双源：Gitea（国内优先）+ GitHub（备用），任一不通跳过，取最高版本
+        val RELEASES_APIS = listOf(
+            "https://git.sunlunfan.com/api/v1/repos/song/a2i/releases/latest",
+            "https://api.github.com/repos/lsxf/a2i/releases/latest",
+        )
+        const val CHECK_INTERVAL_MS = 24L * 60 * 60 * 1000
+    }
+
+    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)
+    }
+}

app/src/main/java/com/a2i/forwarder/model/Models.kt

@@ -9,6 +9,38 @@ 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 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,
+)

app/src/main/java/com/a2i/forwarder/service/NotifyListenerService.kt

@@ -3,9 +3,11 @@ 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.NotificationProcessor
+import com.a2i.forwarder.core.NtfySender
 import com.a2i.forwarder.core.PendingPush
 import com.a2i.forwarder.core.RetryWorker
 import kotlinx.coroutines.CoroutineScope
@@ -40,25 +42,43 @@ class NotifyListenerService : NotificationListenerService() {
         val msg = d.message
 
         if (msg == null) {
+            // 静默过滤（如持续性通知）不写日志
+            if (!d.silent) {
                 app.logStore.addLog(ForwardLog(now, sbn.packageName, d.appLabel, "", "", "filtered", d.reason))
+            }
             return
         }
 
-        val server = app.settings.currentServer.value
+        // ---- 断网兜底：离线时紧要通知走短信，其余不转发避免离线堆积 ----
-        if (server == null || server.deviceKey.isBlank()) {
+        val online = app.connectivityMonitor.isOnline.value
-            app.logStore.addLog(ForwardLog(now, sbn.packageName, d.appLabel, msg.title, msg.body, "failed", "未配置 Bark key"))
+        if (!online) {
+            if (app.smsForwarder.isSmsWorthy(d)) {
+                app.smsForwarder.forward(d)
+            } else {
+                app.logStore.addLog(ForwardLog(now, sbn.packageName, d.appLabel, msg.title, msg.body, "filtered", "离线非紧要通知"))
+            }
             return
         }
 
-        val result = BarkClient(server).push(msg)
+        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)
+            return
+        }
+
+        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)
     }
 }

app/src/main/java/com/a2i/forwarder/store/AppRulesStore.kt

@@ -4,6 +4,7 @@ import android.content.Context
 import androidx.datastore.core.DataStore
 import androidx.datastore.preferences.core.Preferences
 import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.intPreferencesKey
 import androidx.datastore.preferences.core.stringPreferencesKey
 import androidx.datastore.preferences.core.stringSetPreferencesKey
 import androidx.datastore.preferences.preferencesDataStore
@@ -25,6 +26,7 @@ class AppRulesStore(
         val MODE = stringPreferencesKey("mode")
         val BLACK = stringSetPreferencesKey("blacklist")
         val WHITE = stringSetPreferencesKey("whitelist")
+        val BL_VERSION = intPreferencesKey("bl_version")
     }
 
     val mode = MutableStateFlow(RuleMode.BLACKLIST)
@@ -35,7 +37,14 @@ class AppRulesStore(
         scope.launch {
             ds.data.collect { p ->
                 mode.value = runCatching { RuleMode.valueOf(p[K.MODE] ?: "BLACKLIST") }.getOrDefault(RuleMode.BLACKLIST)
-                blacklist.value = p[K.BLACK] ?: defaultBlacklist
+                // 默认黑名单版本迁移：把新增的噪音包补进老用户的黑名单（只增不删）
+                val ver = p[K.BL_VERSION] ?: 1
+                var black = p[K.BLACK] ?: defaultBlacklist
+                if (ver < DEFAULT_BL_VERSION) {
+                    black = black + blAdded
+                    ds.edit { it[K.BLACK] = black; it[K.BL_VERSION] = DEFAULT_BL_VERSION }
+                }
+                blacklist.value = black
                 whitelist.value = p[K.WHITE] ?: emptySet()
             }
         }
@@ -69,13 +78,26 @@ class AppRulesStore(
     }
 
     companion object {
+        private const val DEFAULT_BL_VERSION = 3
+
+        // 默认黑名单增量（累积，用于老用户版本迁移，只补不删）
+        private val blAdded = setOf(
+            // v2
+            "com.android.soundrecorder",      // 录音机
+            "com.google.android.apps.photos", // 相册
+            "com.xiaomi.finddevice",          // 查找手机
+            "com.miui.passwords",             // 密码管理
+            // v3：通话过程中的系统状态通知，会与来电(PhoneCallMonitor)重复
+            "com.android.server.telecom",     // 通话管理
+            "com.xiaomi.aiasst.service",      // AI通话
+        )
+
         val defaultBlacklist = setOf(
             // Android 系统
             "com.android.systemui",
             "com.android.settings",
             "com.android.permissioncontroller",
-            "com.android.phone",
+            // 注意：com.android.phone / com.android.incallui 不在黑名单中，电话通知需要转发
-            "com.android.incallui",
             // 输入法
             "com.google.android.inputmethod",
             "com.google.android.inputmethod.latin",
@@ -92,6 +114,14 @@ class AppRulesStore(
             "com.google.android.gms.persistent",
             // a2i 自身
             "com.a2i.forwarder",
+            // [v2] 纯噪音 App：转发无意义，默认屏蔽
+            "com.android.soundrecorder",      // 录音机
+            "com.google.android.apps.photos", // 相册
+            "com.xiaomi.finddevice",          // 查找手机
+            "com.miui.passwords",             // 密码管理
+            // [v3] 通话状态噪音：来电由 PhoneCallMonitor 独立处理，这两个会重复
+            "com.android.server.telecom",     // 通话管理
+            "com.xiaomi.aiasst.service",      // AI通话
         )
     }
 }

app/src/main/java/com/a2i/forwarder/store/SettingsStore.kt

@@ -5,10 +5,15 @@ import androidx.datastore.core.DataStore
 import androidx.datastore.preferences.core.Preferences
 import androidx.datastore.preferences.core.booleanPreferencesKey
 import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.intPreferencesKey
+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.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
@@ -29,7 +34,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")
@@ -37,6 +41,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 EMAIL_STOP_FIRST = booleanPreferencesKey("email_stop_first")
+        val SMS_STOP_FIRST = booleanPreferencesKey("sms_stop_first")
+        // 短信兜底（目标号已列表化；运营商/余额/限频保持全局）
+        val SMS_FALLBACK = booleanPreferencesKey("sms_fallback")
+        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")
+        // ntfy 转发
+        val NTFY_ENABLED = booleanPreferencesKey("ntfy_enabled")
+        val NTFY_SERVERS = stringPreferencesKey("ntfy_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(
@@ -46,16 +86,45 @@ class SettingsStore(
     private val _servers = MutableStateFlow(defaultServers)
     val servers = _servers.asStateFlow()
 
-    private val _currentServerId = MutableStateFlow(ID_OFFICIAL)
+    private val _ntfyServers = MutableStateFlow<List<NtfyServer>>(emptyList())
-    val currentServer = MutableStateFlow<BarkServer?>(defaultServers.first())
+    val ntfyServers = _ntfyServers.asStateFlow()
 
-    val iconPrefix = MutableStateFlow("")
+    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)
     val codeEnabled = MutableStateFlow(true)
     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 emailStopOnFirst = MutableStateFlow(false)
+    val smsStopOnFirst = MutableStateFlow(false)
+
+    // 短信兜底（全局）
+    val smsFallbackEnabled = MutableStateFlow(false)
+    val smsCarrier = MutableStateFlow("auto")
+    val smsManualQuota = MutableStateFlow(0)
+    val smsBalance = MutableStateFlow(-1)
+    val smsSuspended = MutableStateFlow(false)
+    val lastSmsSentTime = MutableStateFlow(0L)
+
+    // 电邮/ntfy 总开关
+    val emailForwardingEnabled = MutableStateFlow(false)
+    val ntfyEnabled = MutableStateFlow(false)
+
+    // 应用更新
+    val updateCheckEnabled = MutableStateFlow(true)
+    val lastUpdateCheckTime = MutableStateFlow(0L)
+    val ignoredVersion = MutableStateFlow("")
 
     init {
         scope.launch {
@@ -64,9 +133,7 @@ class SettingsStore(
                     ?.let { runCatching { json.decodeFromString<List<BarkServer>>(it) }.getOrNull() }
                     ?: defaultServers
                 _servers.value = list
-                _currentServerId.value = p[K.CURRENT] ?: ID_OFFICIAL
+                iconPrefix.value = p[K.ICON_PREFIX] ?: DEFAULT_ICON_PREFIX
-                currentServer.value = list.firstOrNull { it.id == _currentServerId.value } ?: list.firstOrNull()
-                iconPrefix.value = p[K.ICON_PREFIX] ?: ""
                 forwardingEnabled.value = p[K.FWD] ?: true
                 codeEnabled.value = p[K.CODE] ?: true
                 adFilterEnabled.value = p[K.AD] ?: true
@@ -75,47 +142,160 @@ 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
+                emailStopOnFirst.value = p[K.EMAIL_STOP_FIRST] ?: false
+                smsStopOnFirst.value = p[K.SMS_STOP_FIRST] ?: false
+                // 短信兜底全局
+                smsFallbackEnabled.value = p[K.SMS_FALLBACK] ?: false
+                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
+                // 电邮/ntfy 总开关
+                emailForwardingEnabled.value = p[K.EMAIL_ENABLED] ?: false
+                ntfyEnabled.value = p[K.NTFY_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()
+                _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) {
+    // ---- ntfy 服务器 CRUD ----
-        val list = _servers.value.filterNot { it.id == id }
+    private suspend fun saveNtfyServers(list: List<NtfyServer>) {
-        saveServers(list)
+        edit { it[K.NTFY_SERVERS] = json.encodeToString(list) }
-        if (_currentServerId.value == id) {
+        _ntfyServers.value = list
-            setCurrent(if (list.isEmpty()) "" else list.first().id)
     }
+    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) {
+    // ---- 电邮服务器 CRUD ----
-        edit { it[K.CURRENT] = id }
+    private suspend fun saveEmailServers(list: List<EmailServer>) {
-        _currentServerId.value = id
+        edit { it[K.EMAIL_SERVERS] = json.encodeToString(list) }
-        refreshCurrent()
+        _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 })
 
-    private fun refreshCurrent() {
+    // ---- 短信目标 CRUD ----
-        currentServer.value = _servers.value.firstOrNull { it.id == _currentServerId.value } ?: _servers.value.firstOrNull()
+    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 }
@@ -128,9 +308,29 @@ 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 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 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 }
+    suspend fun setSmsSuspended(v: Boolean) { edit { it[K.SMS_SUSPENDED] = v }; smsSuspended.value = v }
+    suspend fun setLastSmsSentTime(v: Long) { edit { it[K.SMS_LAST_SENT] = v }; lastSmsSentTime.value = v }
+
+    suspend fun setUpdateCheckEnabled(v: Boolean) { edit { it[K.UPDATE_CHECK_AUTO] = v }; updateCheckEnabled.value = v }
+    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 setNtfyEnabled(v: Boolean) { edit { it[K.NTFY_ENABLED] = v }; ntfyEnabled.value = v }
+
     suspend fun snapshot() = ds.data.first()
 
     companion object {
         const val ID_OFFICIAL = "official"
+        const val DEFAULT_ICON_PREFIX = "https://raw.githubusercontent.com/lsxf/a2i/main/icons/"
     }
 }

app/src/main/java/com/a2i/forwarder/ui/screens/HomeScreen.kt

@@ -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
@@ -22,7 +23,9 @@ import androidx.compose.material.icons.filled.Notifications
 import androidx.compose.material.icons.filled.PowerSettingsNew
 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
@@ -61,10 +64,13 @@ 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()
+    val smsSuspended by app.settings.smsSuspended.collectAsState()
+    val update by app.updateChecker.updateInfo.collectAsState()
+    var showUpdateDialog by remember { mutableStateOf(false) }
 
     var granted by remember { mutableStateOf(isNotificationListenerEnabled(context)) }
     val lifecycleOwner = LocalLifecycleOwner.current
@@ -89,6 +95,78 @@ fun HomeScreen(onOpenLog: () -> Unit, onOpenSettings: () -> Unit) {
             )
         }
 
+        val info = update
+        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) {
+                                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("发现新版本", style = MaterialTheme.typography.titleLarge, color = Color.White, fontWeight = FontWeight.Bold)
+                                    Text(
+                                        "v${info.latestVersion} · ${formatSize(info.apkSize)} · 点击立即更新",
+                                        style = MaterialTheme.typography.bodyMedium,
+                                        color = Color.White.copy(alpha = 0.88f),
+                                    )
+                                }
+                                StatusBadge("🔄", tint = Color.White)
+                            }
+                            Spacer(Modifier.size(12.dp))
+                            Button(
+                                onClick = { showUpdateDialog = true },
+                                modifier = Modifier.fillMaxWidth(),
+                                colors = ButtonDefaults.buttonColors(
+                                    containerColor = Color.White,
+                                    contentColor = MaterialTheme.colorScheme.primary,
+                                ),
+                            ) { Text("🚀 立即更新到 v${info.latestVersion}", fontWeight = FontWeight.Bold) }
+                        }
+                    }
+                }
+            }
+        }
+
+        if (smsSuspended) {
+            item {
+                SectionCard {
+                    Row(verticalAlignment = Alignment.CenterVertically) {
+                        IconBox(
+                            icon = Icons.Filled.WarningAmber,
+                            tint = MaterialTheme.colorScheme.error,
+                        )
+                        Spacer(Modifier.width(12.dp))
+                        Column(Modifier.weight(1f)) {
+                            Text("短信兜底已停用", style = MaterialTheme.typography.titleMedium)
+                            Text(
+                                "短信余额不足，断网转发已关闭。请在「设置 → 断网短信兜底」补充额度",
+                                style = MaterialTheme.typography.bodySmall,
+                                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                            )
+                        }
+                    }
+                }
+            }
+        }
+
         item {
             SectionCard {
                 Row(verticalAlignment = Alignment.CenterVertically) {
@@ -131,21 +209,14 @@ fun HomeScreen(onOpenLog: () -> Unit, onOpenSettings: () -> Unit) {
                 ) { v ->
                     app.appScope.launch { app.settings.setForwarding(v) }
                 }
+                val enabledServers = servers.filter { it.enabled && it.deviceKey.isNotBlank() }
                 ClickRow(
-                    title = current?.name?.ifBlank { "未命名服务器" } ?: "未配置 Bark 服务器",
+                    title = if (enabledServers.isEmpty()) "未启用 Bark 服务器" else "Bark 服务器（${enabledServers.size} 个启用）",
-                    subtitle = current?.server ?: "进入设置添加官方或自建 Bark 服务",
+                    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 条处理记录",
@@ -177,6 +248,11 @@ fun HomeScreen(onOpenLog: () -> Unit, onOpenSettings: () -> Unit) {
             )
         }
     }
+
+    if (showUpdateDialog) {
+        val info = update
+        if (info != null) UpdateDialog(info, onDismiss = { showUpdateDialog = false })
+    }
 }
 
 @Composable

app/src/main/java/com/a2i/forwarder/ui/screens/LogScreen.kt

@@ -16,6 +16,7 @@ import androidx.compose.foundation.lazy.items
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.automirrored.filled.ArrowBack
+import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
@@ -25,7 +26,9 @@ import androidx.compose.material3.TextButton
 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.platform.LocalContext
@@ -51,6 +54,7 @@ fun LogScreen(onBack: () -> Unit) {
     val logs by app.logStore.logs.collectAsState()
     val pending by app.logStore.pending.collectAsState()
     val df = remember { SimpleDateFormat("MM-dd HH:mm:ss", Locale.getDefault()) }
+    var showClearDialog by remember { mutableStateOf(false) }
 
     Column(Modifier.fillMaxSize()) {
         Surface(
@@ -66,7 +70,7 @@ fun LogScreen(onBack: () -> Unit) {
                     Text("转发日志", style = MaterialTheme.typography.titleLarge)
                     Text("最近 300 条通知处理记录", style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant)
                 }
-                TextButton(onClick = { app.appScope.launch { app.logStore.clearLogs() } }) { Text("清空") }
+                TextButton(onClick = { showClearDialog = true }) { Text("清空") }
             }
         }
 
@@ -103,6 +107,29 @@ fun LogScreen(onBack: () -> Unit) {
             }
         }
     }
+
+    if (showClearDialog) {
+        AlertDialog(
+            onDismissRequest = { showClearDialog = false },
+            title = { Text("清空日志") },
+            text = { Text("选择清空范围：") },
+            confirmButton = {
+                TextButton(onClick = {
+                    showClearDialog = false
+                    app.appScope.launch { app.logStore.clearLogs() }
+                }) { Text("仅清空日志") }
+            },
+            dismissButton = {
+                TextButton(onClick = {
+                    showClearDialog = false
+                    app.appScope.launch {
+                        app.logStore.clearLogs()
+                        app.logStore.resetCounters()
+                    }
+                }) { Text("日志+计数器") }
+            },
+        )
+    }
 }
 
 @Composable

app/src/main/java/com/a2i/forwarder/ui/screens/SettingsScreen.kt

@@ -7,7 +7,6 @@ import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
 import androidx.compose.foundation.BorderStroke
 import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
@@ -24,22 +23,26 @@ import androidx.compose.material.icons.filled.Add
 import androidx.compose.material.icons.filled.Delete
 import androidx.compose.material.icons.filled.Edit
 import androidx.compose.material.icons.filled.History
+import androidx.compose.material.icons.filled.KeyboardArrowDown
+import androidx.compose.material.icons.filled.KeyboardArrowUp
 import androidx.compose.material.icons.filled.RestartAlt
 import androidx.compose.material.icons.filled.Settings
+import androidx.compose.material.icons.filled.SystemUpdateAlt
+import androidx.compose.material.icons.filled.Update
 import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.Button
+import androidx.compose.material3.Checkbox
 import androidx.compose.material3.CircularProgressIndicator
-import androidx.compose.material3.FilledTonalButton
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.OutlinedButton
 import androidx.compose.material3.OutlinedTextField
-import androidx.compose.material3.RadioButton
 import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
@@ -54,14 +57,21 @@ import androidx.compose.ui.unit.dp
 import androidx.documentfile.provider.DocumentFile
 import com.a2i.forwarder.A2iApp
 import com.a2i.forwarder.core.BarkClient
+import com.a2i.forwarder.core.EmailSender
 import com.a2i.forwarder.core.IconExporter
+import com.a2i.forwarder.core.NtfySender
 import com.a2i.forwarder.model.BarkMessage
 import com.a2i.forwarder.model.BarkServer
+import com.a2i.forwarder.model.EmailServer
+import com.a2i.forwarder.model.NtfyServer
 import com.a2i.forwarder.model.OFFICIAL_BARK_SERVER
+import com.a2i.forwarder.model.SmsTarget
 import com.a2i.forwarder.ui.ClickRow
 import com.a2i.forwarder.ui.ScreenTitle
 import com.a2i.forwarder.ui.SectionCard
 import com.a2i.forwarder.ui.StatusBadge
+import com.a2i.forwarder.ui.SwitchRow
+import com.a2i.forwarder.ui.appVersionName
 import kotlinx.coroutines.launch
 
 @Composable
@@ -69,256 +79,410 @@ fun SettingsScreen(onOpenLog: () -> Unit) {
     val context = LocalContext.current
     val app = A2iApp.instance
     val servers by app.settings.servers.collectAsState()
-    val current by app.settings.currentServer.collectAsState()
+    val ntfyServers by app.settings.ntfyServers.collectAsState()
+    val emailServers by app.settings.emailServers.collectAsState()
+    val smsTargets by app.settings.smsTargets.collectAsState()
+    val barkStopFirst by app.settings.barkStopOnFirst.collectAsState()
+    val ntfyStopFirst by app.settings.ntfyStopOnFirst.collectAsState()
+    val emailStopFirst by app.settings.emailStopOnFirst.collectAsState()
+    val smsStopFirst by app.settings.smsStopOnFirst.collectAsState()
+    val ntfyEnabled by app.settings.ntfyEnabled.collectAsState()
+    val emailEnabled by app.settings.emailForwardingEnabled.collectAsState()
+    val smsFallback by app.settings.smsFallbackEnabled.collectAsState()
     val iconPrefix by app.settings.iconPrefix.collectAsState()
+    val smsBalance by app.settings.smsBalance.collectAsState()
+    val smsSuspended by app.settings.smsSuspended.collectAsState()
+    val smsManualQuota by app.settings.smsManualQuota.collectAsState()
+    val updateAuto by app.settings.updateCheckEnabled.collectAsState()
+    val updateInfo by app.updateChecker.updateInfo.collectAsState()
+
     val prefs = remember { context.getSharedPreferences("a2i_ui", Context.MODE_PRIVATE) }
     var treeUri by remember { mutableStateOf<Uri?>(prefs.getString("icon_tree", null)?.let { runCatching { Uri.parse(it) }.getOrNull() }) }
     var exporting by remember { mutableStateOf(false) }
     var exportResult by remember { mutableStateOf<String?>(null) }
-    var testing by remember { mutableStateOf(false) }
+    var checking by remember { mutableStateOf(false) }
-    var testMsg by remember { mutableStateOf<String?>(null) }
+    var checkMsg by remember { mutableStateOf<String?>(null) }
-    var showAdd by remember { mutableStateOf(false) }
+    val detectedCarrier = remember { com.a2i.forwarder.core.CarrierDetector.detect(context) }
-    var editing by remember { mutableStateOf<BarkServer?>(null) }
+    val hasSmsPerm = remember {
-
+        androidx.core.content.ContextCompat.checkSelfPermission(context, android.Manifest.permission.SEND_SMS) ==
+            android.content.pm.PackageManager.PERMISSION_GRANTED
+    }
+    val smsPermLauncher = rememberLauncherForActivityResult(ActivityResultContracts.RequestPermission()) { }
     val treeLauncher = rememberLauncherForActivityResult(ActivityResultContracts.OpenDocumentTree()) { uri ->
         if (uri != null) {
-            runCatching {
+            runCatching { context.contentResolver.takePersistableUriPermission(uri, Intent.FLAG_GRANT_READ_URI_PERMISSION or Intent.FLAG_GRANT_WRITE_URI_PERMISSION) }
-                context.contentResolver.takePersistableUriPermission(
-                    uri,
-                    Intent.FLAG_GRANT_READ_URI_PERMISSION or Intent.FLAG_GRANT_WRITE_URI_PERMISSION,
-                )
-            }
             prefs.edit().putString("icon_tree", uri.toString()).apply()
             treeUri = uri
         }
     }
 
+    // 弹窗状态
+    var showAddBark by remember { mutableStateOf(false) }
+    var editingBark by remember { mutableStateOf<BarkServer?>(null) }
+    var showAddNtfy by remember { mutableStateOf(false) }
+    var editingNtfy by remember { mutableStateOf<NtfyServer?>(null) }
+    var showAddEmail by remember { mutableStateOf(false) }
+    var editingEmail by remember { mutableStateOf<EmailServer?>(null) }
+    var showAddSms by remember { mutableStateOf(false) }
+    var editingSms by remember { mutableStateOf<SmsTarget?>(null) }
+
     LazyColumn(
         modifier = Modifier.fillMaxSize().padding(horizontal = 16.dp),
         verticalArrangement = Arrangement.spacedBy(12.dp),
     ) {
-        item { ScreenTitle("设置", "管理 Bark 服务、图标资源和维护操作") }
+        item { ScreenTitle("设置", "管理各转发通道、图标和维护") }
 
+        // ===== Bark 服务器 =====
         item {
-            SectionCard("Bark 服务器", subtitle = "官方服务和自建服务可以并存，当前服务器用于所有推送") {
+            SectionCard("Bark 服务器", subtitle = "勾选的服务器参与转发；开关切换容错/广播") {
-                if (servers.isEmpty()) {
+                SwitchRow(
-                    Text("暂无服务器，请先添加。", style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant)
+                    title = "发通一条就停",
-                } else {
+                    subtitle = if (barkStopFirst) "容错模式：首个成功即止" else "广播模式：每个都发",
+                    checked = barkStopFirst,
+                    icon = Icons.Filled.Settings,
+                ) { v -> app.appScope.launch { app.settings.setBarkStopOnFirst(v) } }
+                if (servers.isNotEmpty()) {
+                    Spacer(Modifier.size(8.dp))
                     Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
-                        servers.forEach { s ->
+                        servers.forEachIndexed { i, s ->
-                            ServerRow(
+                            ServerRow(s, i == 0, i == servers.lastIndex,
-                                server = s,
+                                onToggle = { v -> app.appScope.launch { app.settings.setServerEnabled(s.id, v) } },
-                                selected = s.id == current?.id,
+                                onEdit = { editingBark = s },
-                                onSelect = { app.appScope.launch { app.settings.setCurrent(s.id) } },
-                                onEdit = { editing = s },
                                 onDelete = { app.appScope.launch { app.settings.deleteServer(s.id) } },
+                                onMoveUp = { app.appScope.launch { app.settings.moveServer(s.id, true) } },
+                                onMoveDown = { app.appScope.launch { app.settings.moveServer(s.id, false) } },
                             )
                         }
                     }
                 }
-                Button(
+                AddButton { showAddBark = true }
-                    onClick = { showAdd = true },
-                    modifier = Modifier.fillMaxWidth().padding(top = 12.dp),
-                ) {
-                    Icon(Icons.Filled.Add, null, modifier = Modifier.size(18.dp))
-                    Spacer(Modifier.width(8.dp))
-                    Text("添加服务器")
             }
-                FilledTonalButton(
-                    onClick = {
-                        app.appScope.launch {
-                            testing = true
-                            testMsg = testPush(app)
-                            testing = false
         }
-                    },
+
-                    modifier = Modifier.fillMaxWidth().padding(top = 8.dp),
+        // ===== ntfy =====
-                    enabled = !testing,
+        item {
-                ) {
+            SectionCard("ntfy 转发", subtitle = "POST 推送到 ntfy 服务") {
-                    if (testing) {
+                SwitchRow(title = "启用 ntfy 转发", subtitle = if (ntfyEnabled) "已开启" else "已关闭", checked = ntfyEnabled) { v -> app.appScope.launch { app.settings.setNtfyEnabled(v) } }
-                        CircularProgressIndicator(Modifier.size(18.dp), strokeWidth = 2.dp)
+                if (ntfyEnabled) {
-                    } else {
+                    SwitchRow(title = "发通一条就停", subtitle = if (ntfyStopFirst) "容错：首个成功止" else "广播：每个都发", checked = ntfyStopFirst) { v -> app.appScope.launch { app.settings.setNtfyStopOnFirst(v) } }
-                        Icon(Icons.AutoMirrored.Filled.Send, null, modifier = Modifier.size(18.dp))
+                    if (ntfyServers.isNotEmpty()) {
-                    }
+                        Spacer(Modifier.size(8.dp))
-                    Spacer(Modifier.width(8.dp))
+                        Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
-                    Text("发送测试推送")
+                            ntfyServers.forEachIndexed { i, s ->
-                }
+                                ConfigRow(
-                testMsg?.let {
+                                    title = s.name.ifBlank { s.topic },
-                    Text(
+                                    subtitle = "${s.server} · topic: ${s.topic}${if (s.token.isNotBlank()) " · token已填" else ""}",
-                        it,
+                                    enabled = s.enabled, isFirst = i == 0, isLast = i == ntfyServers.lastIndex,
-                        style = MaterialTheme.typography.bodySmall,
+                                    onToggle = { v -> app.appScope.launch { app.settings.setNtfyEnabled(s.id, v) } },
-                        color = if (it.startsWith("已发送")) MaterialTheme.colorScheme.tertiary else MaterialTheme.colorScheme.error,
+                                    onEdit = { editingNtfy = s }, onDelete = { app.appScope.launch { app.settings.deleteNtfy(s.id) } },
-                        modifier = Modifier.padding(top = 8.dp),
+                                    onMoveUp = { app.appScope.launch { app.settings.moveNtfy(s.id, true) } },
+                                    onMoveDown = { app.appScope.launch { app.settings.moveNtfy(s.id, false) } },
+                                    onTest = { app.appScope.launch { NtfySender.send(s.server, s.topic, s.token, "a2i测试", "ntfy配置测试") } },
                                 )
                             }
                         }
                     }
+                    AddButton { showAddNtfy = true }
+                }
+            }
+        }
 
+        // ===== 电邮 =====
+        item {
+            SectionCard("电邮转发", subtitle = "SMTPS 直发邮件") {
+                SwitchRow(title = "启用电邮转发", subtitle = if (emailEnabled) "已开启" else "已关闭", checked = emailEnabled) { v -> app.appScope.launch { app.settings.setEmailForwarding(v) } }
+                if (emailEnabled) {
+                    SwitchRow(title = "发通一条就停", subtitle = if (emailStopFirst) "容错：首个成功止" else "广播：每个都发", checked = emailStopFirst) { v -> app.appScope.launch { app.settings.setEmailStopOnFirst(v) } }
+                    if (emailServers.isNotEmpty()) {
+                        Spacer(Modifier.size(8.dp))
+                        Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                            emailServers.forEachIndexed { i, s ->
+                                ConfigRow(
+                                    title = s.name.ifBlank { s.to },
+                                    subtitle = "${s.host}:${s.port} · ${s.user} → ${s.to}",
+                                    enabled = s.enabled, isFirst = i == 0, isLast = i == emailServers.lastIndex,
+                                    onToggle = { v -> app.appScope.launch { app.settings.setEmailEnabled(s.id, v) } },
+                                    onEdit = { editingEmail = s }, onDelete = { app.appScope.launch { app.settings.deleteEmail(s.id) } },
+                                    onMoveUp = { app.appScope.launch { app.settings.moveEmail(s.id, true) } },
+                                    onMoveDown = { app.appScope.launch { app.settings.moveEmail(s.id, false) } },
+                                    onTest = { app.appScope.launch { EmailSender.send(s.host, s.port, s.user, s.password, s.from, s.to, "a2i测试", "电邮配置测试") } },
+                                )
+                            }
+                        }
+                    }
+                    AddButton { showAddEmail = true }
+                }
+            }
+        }
+
+        // ===== 短信兜底 =====
+        item {
+            SectionCard("断网短信兜底", subtitle = "无网络时把验证码/来电用短信发出去") {
+                SwitchRow(title = "启用短信兜底", subtitle = if (smsFallback) "已开启" else "已关闭", checked = smsFallback) { v -> app.appScope.launch { app.settings.setSmsFallback(v) } }
+                if (smsFallback) {
+                    SwitchRow(title = "发通一条就停", subtitle = if (smsStopFirst) "容错：首个成功止" else "广播：每个都发", checked = smsStopFirst) { v -> app.appScope.launch { app.settings.setSmsStopOnFirst(v) } }
+                    if (!hasSmsPerm) {
+                        Spacer(Modifier.size(4.dp))
+                        OutlinedButton(onClick = { smsPermLauncher.launch(android.Manifest.permission.SEND_SMS) }, modifier = Modifier.fillMaxWidth()) { Text("授予短信权限") }
+                    }
+                    if (smsTargets.isNotEmpty()) {
+                        Spacer(Modifier.size(8.dp))
+                        Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                            smsTargets.forEachIndexed { i, s ->
+                                ConfigRow(
+                                    title = s.name.ifBlank { s.number },
+                                    subtitle = s.number,
+                                    enabled = s.enabled, isFirst = i == 0, isLast = i == smsTargets.lastIndex,
+                                    onToggle = { v -> app.appScope.launch { app.settings.setSmsTargetEnabled(s.id, v) } },
+                                    onEdit = { editingSms = s }, onDelete = { app.appScope.launch { app.settings.deleteSmsTarget(s.id) } },
+                                    onMoveUp = { app.appScope.launch { app.settings.moveSmsTarget(s.id, true) } },
+                                    onMoveDown = { app.appScope.launch { app.settings.moveSmsTarget(s.id, false) } },
+                                    onTest = null,
+                                )
+                            }
+                        }
+                    }
+                    AddButton { showAddSms = true }
+                    Spacer(Modifier.size(8.dp))
+                    val balanceText = when {
+                        smsSuspended -> "已挂起（余额不足）"
+                        smsBalance < 0 -> "余额未知"
+                        else -> "剩余约 $smsBalance 条"
+                    }
+                    Text("运营商：${detectedCarrier.displayName}  ·  余额：$balanceText  ·  手动额度：$smsManualQuota", style = MaterialTheme.typography.bodySmall, color = if (smsSuspended) MaterialTheme.colorScheme.error else MaterialTheme.colorScheme.onSurfaceVariant)
+                }
+            }
+        }
+
+        // ===== 应用图标 =====
         item {
             SectionCard("应用图标", subtitle = "导出 App 图标后，Bark 通知可按包名显示图标") {
-                OutlinedTextField(
+                OutlinedTextField(value = iconPrefix, onValueChange = { app.appScope.launch { app.settings.setIconPrefix(it) } }, label = { Text("图标 URL 前缀") }, modifier = Modifier.fillMaxWidth(), singleLine = true)
-                    value = iconPrefix,
+                Text("导出目录：${treeUri?.let { DocumentFile.fromTreeUri(context, it)?.name } ?: "未选择"}", style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant, modifier = Modifier.padding(top = 8.dp))
-                    onValueChange = { app.appScope.launch { app.settings.setIconPrefix(it) } },
+                Row(modifier = Modifier.fillMaxWidth().padding(top = 10.dp), horizontalArrangement = Arrangement.spacedBy(8.dp)) {
-                    label = { Text("图标 URL 前缀") },
-                    supportingText = { Text("转发时 icon = 前缀 + 包名 + .png；留空则不显示图标") },
-                    modifier = Modifier.fillMaxWidth(),
-                    singleLine = true,
-                )
-                Text(
-                    "导出目录：${treeUri?.let { DocumentFile.fromTreeUri(context, it)?.name } ?: "未选择"}",
-                    style = MaterialTheme.typography.bodySmall,
-                    color = MaterialTheme.colorScheme.onSurfaceVariant,
-                    modifier = Modifier.padding(top = 8.dp),
-                )
-                Row(
-                    modifier = Modifier.fillMaxWidth().padding(top = 10.dp),
-                    horizontalArrangement = Arrangement.spacedBy(8.dp),
-                ) {
                     OutlinedButton(onClick = { treeLauncher.launch(null) }, modifier = Modifier.weight(1f)) { Text("选择目录") }
-                    Button(
+                    Button(onClick = {
-                        onClick = {
                         val u = treeUri ?: return@Button
-                            app.appScope.launch {
+                        app.appScope.launch { exporting = true; val r = IconExporter(context).exportAll(u); exporting = false; exportResult = "共 ${r.total} 个，成功 ${r.ok}，失败 ${r.fail}" }
-                                exporting = true
+                    }, enabled = treeUri != null && !exporting, modifier = Modifier.weight(1f)) {
-                                val r = IconExporter(context).exportAll(u)
-                                exporting = false
-                                exportResult = "共 ${r.total} 个，成功 ${r.ok}，失败 ${r.fail}"
-                            }
-                        },
-                        enabled = treeUri != null && !exporting,
-                        modifier = Modifier.weight(1f),
-                    ) {
                         if (exporting) CircularProgressIndicator(Modifier.size(18.dp), strokeWidth = 2.dp) else Text("导出图标")
                     }
                 }
-                exportResult?.let {
+                exportResult?.let { Text(it, style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.primary, modifier = Modifier.padding(top = 8.dp)) }
-                    Text(it, style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.primary, modifier = Modifier.padding(top = 8.dp))
-                }
             }
         }
 
+        // ===== 更新 =====
+        item {
+            SectionCard("更新", subtitle = "版本检查（数据来自 Gitea + GitHub 双源）") {
+                SwitchRow(title = "自动检查更新", subtitle = "启动时检查 + 每 24 小时巡检", checked = updateAuto, icon = Icons.Filled.Update) { v -> app.appScope.launch { app.settings.setUpdateCheckEnabled(v) } }
+                ClickRow(
+                    title = "检查更新",
+                    subtitle = "当前 v${appVersionName(context)}" + (updateInfo?.let { " · 已发现 v${it.latestVersion}" } ?: " · 点击立即检查"),
+                    icon = Icons.Filled.SystemUpdateAlt,
+                    onClick = { app.appScope.launch { checking = true; checkMsg = null; val r = app.updateChecker.check(force = true); checking = false; checkMsg = when { !r.isSuccess -> "检查失败：${r.exceptionOrNull()?.message}"; r.getOrNull() != null -> "发现新版本，请到首页更新"; else -> "已是最新版本" } } },
+                )
+                if (checking) {
+                    Row(modifier = Modifier.fillMaxWidth().padding(vertical = 4.dp), verticalAlignment = Alignment.CenterVertically) {
+                        CircularProgressIndicator(Modifier.size(16.dp), strokeWidth = 2.dp)
+                        Spacer(Modifier.width(8.dp))
+                        Text("正在检查…", style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant)
+                    }
+                }
+                checkMsg?.let { Text(it, style = MaterialTheme.typography.bodySmall, color = if (it.startsWith("已是")) MaterialTheme.colorScheme.tertiary else MaterialTheme.colorScheme.error, modifier = Modifier.padding(start = 50.dp, top = 2.dp)) }
+            }
+        }
+
+        // ===== 维护 =====
         item {
             SectionCard("维护", subtitle = "日志查看和本地统计清理") {
                 ClickRow("转发日志", "查看 / 清空最近记录", icon = Icons.Filled.History, onClick = onOpenLog)
-                ClickRow("重置计数器", "清零转发 / 过滤 / 失败统计", icon = Icons.Filled.RestartAlt, tint = MaterialTheme.colorScheme.error) {
+                ClickRow("重置计数器", "清零转发 / 过滤 / 失败统计", icon = Icons.Filled.RestartAlt, tint = MaterialTheme.colorScheme.error) { app.appScope.launch { app.logStore.resetCounters() } }
-                    app.appScope.launch { app.logStore.resetCounters() }
-                }
             }
         }
 
         item {
-            Box(Modifier.fillMaxWidth().padding(top = 4.dp, bottom = 18.dp), contentAlignment = Alignment.Center) {
+            Spacer(Modifier.padding(top = 4.dp, bottom = 18.dp))
-                Text(
-                    "a2i · 安卓通知转发到 iOS Bark\n图标需 iOS 15+；点击通知会打开 iOS 对应 App",
-                    style = MaterialTheme.typography.bodySmall,
-                    color = MaterialTheme.colorScheme.onSurfaceVariant,
-                )
-            }
         }
     }
 
-    if (showAdd) {
+    // 弹窗
-        ServerDialog(
+    if (showAddBark) ServerDialog(onDismiss = { showAddBark = false }, onConfirm = { n, s, k -> app.appScope.launch { app.settings.addServer(n, s, k) }; showAddBark = false })
-            onDismiss = { showAdd = false },
+    editingBark?.let { srv -> ServerDialog(initial = srv, onDismiss = { editingBark = null }, onConfirm = { n, s, k -> app.appScope.launch { app.settings.updateServer(srv.copy(name = n, server = s, deviceKey = k)) }; editingBark = null }) }
-            onConfirm = { n, s, k ->
+    if (showAddNtfy) NtfyConfigDialog(onDismiss = { showAddNtfy = false }, onConfirm = { n, sv, t, tk -> app.appScope.launch { app.settings.addNtfy(NtfyServer(name = n, server = sv, topic = t, token = tk)) }; showAddNtfy = false })
-                app.appScope.launch {
+    editingNtfy?.let { srv -> NtfyConfigDialog(initial = srv, onDismiss = { editingNtfy = null }, onConfirm = { n, sv, t, tk -> app.appScope.launch { app.settings.updateNtfy(srv.copy(name = n, server = sv, topic = t, token = tk)) }; editingNtfy = null }) }
-                    val ns = app.settings.addServer(n, s, k)
+    if (showAddEmail) EmailConfigDialog(onDismiss = { showAddEmail = false }, onConfirm = { c -> app.appScope.launch { app.settings.addEmail(c) }; showAddEmail = false })
-                    app.settings.setCurrent(ns.id)
+    editingEmail?.let { srv -> EmailConfigDialog(initial = srv, onDismiss = { editingEmail = null }, onConfirm = { c -> app.appScope.launch { app.settings.updateEmail(c.copy(id = srv.id)) }; editingEmail = null }) }
-                }
+    if (showAddSms) SmsConfigDialog(onDismiss = { showAddSms = false }, onConfirm = { n, num -> app.appScope.launch { app.settings.addSmsTarget(SmsTarget(name = n, number = num)) }; showAddSms = false })
-                showAdd = false
+    editingSms?.let { srv -> SmsConfigDialog(initial = srv, onDismiss = { editingSms = null }, onConfirm = { n, num -> app.appScope.launch { app.settings.updateSmsTarget(srv.copy(name = n, number = num)) }; editingSms = null }) }
-            },
-        )
-    }
-    editing?.let { srv ->
-        ServerDialog(
-            initial = srv,
-            onDismiss = { editing = null },
-            onConfirm = { n, s, k ->
-                app.appScope.launch { app.settings.updateServer(srv.copy(name = n, server = s, deviceKey = k)) }
-                editing = null
-            },
-        )
-    }
 }
 
 @Composable
-private fun ServerRow(
+private fun AddButton(onClick: () -> Unit) {
-    server: BarkServer,
+    Button(onClick = onClick, modifier = Modifier.fillMaxWidth().padding(top = 12.dp)) {
-    selected: Boolean,
+        Icon(Icons.Filled.Add, null, modifier = Modifier.size(18.dp))
-    onSelect: () -> Unit,
+        Spacer(Modifier.width(8.dp))
-    onEdit: () -> Unit,
+        Text("添加")
-    onDelete: () -> Unit,
+    }
+}
+
+/** 通用配置行（ntfy/电邮/短信 共用，仿 ServerRow 简化版）。 */
+@Composable
+private fun ConfigRow(
+    title: String, subtitle: String, enabled: Boolean,
+    isFirst: Boolean, isLast: Boolean,
+    onToggle: (Boolean) -> Unit, onEdit: () -> Unit, onDelete: () -> Unit,
+    onMoveUp: () -> Unit, onMoveDown: () -> Unit, onTest: (() -> Unit)?,
 ) {
     Surface(
-        modifier = Modifier.fillMaxWidth(),
+        modifier = Modifier.fillMaxWidth(), shape = RoundedCornerShape(8.dp),
-        shape = RoundedCornerShape(8.dp),
+        color = if (enabled) MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.40f) else MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.36f),
-        color = if (selected) MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.55f) else MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.36f),
+        border = BorderStroke(1.dp, if (enabled) MaterialTheme.colorScheme.primary.copy(alpha = 0.30f) else MaterialTheme.colorScheme.outlineVariant),
-        border = BorderStroke(1.dp, if (selected) MaterialTheme.colorScheme.primary.copy(alpha = 0.32f) else MaterialTheme.colorScheme.outlineVariant),
     ) {
-        Row(Modifier.fillMaxWidth().padding(8.dp), verticalAlignment = Alignment.CenterVertically) {
+        Column(Modifier.padding(start = 4.dp, end = 4.dp, top = 2.dp, bottom = 4.dp)) {
-            RadioButton(selected = selected, onClick = onSelect)
-            Column(Modifier.weight(1f)) {
             Row(verticalAlignment = Alignment.CenterVertically) {
-                    Text(
+                Checkbox(checked = enabled, onCheckedChange = onToggle)
-                        server.name.ifBlank { "未命名" },
+                Column(Modifier.weight(1f)) {
-                        style = MaterialTheme.typography.bodyLarge,
+                    Text(title.ifBlank { "未命名" }, style = MaterialTheme.typography.bodyLarge, fontWeight = FontWeight.Medium, maxLines = 1, overflow = TextOverflow.Ellipsis)
-                        fontWeight = FontWeight.Medium,
+                    Text(subtitle, style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant, maxLines = 2, overflow = TextOverflow.Ellipsis, modifier = Modifier.padding(start = 0.dp))
-                        maxLines = 1,
-                        overflow = TextOverflow.Ellipsis,
-                        modifier = Modifier.weight(1f),
-                    )
-                    if (selected) StatusBadge("当前", MaterialTheme.colorScheme.primary)
                 }
-                Text(
+                if (onTest != null) {
-                    "${server.server} · key: ${if (server.deviceKey.isBlank()) "未填" else "已填"}",
+                    IconButton(onClick = onTest) { Icon(Icons.AutoMirrored.Filled.Send, "测试") }
-                    style = MaterialTheme.typography.bodySmall,
-                    color = MaterialTheme.colorScheme.onSurfaceVariant,
-                    maxLines = 1,
-                    overflow = TextOverflow.Ellipsis,
-                )
                 }
+                IconButton(onClick = onMoveUp, enabled = !isFirst) { Icon(Icons.Filled.KeyboardArrowUp, "上移") }
+                IconButton(onClick = onMoveDown, enabled = !isLast) { Icon(Icons.Filled.KeyboardArrowDown, "下移") }
                 IconButton(onClick = onEdit) { Icon(Icons.Filled.Edit, "编辑") }
                 IconButton(onClick = onDelete) { Icon(Icons.Filled.Delete, "删除") }
             }
         }
     }
+}
+
+// ===== Bark 服务器 Row + Dialog（保留原有） =====
+@Composable
+private fun ServerRow(
+    server: BarkServer, isFirst: Boolean, isLast: Boolean,
+    onToggle: (Boolean) -> Unit, onEdit: () -> Unit, onDelete: () -> Unit,
+    onMoveUp: () -> Unit, onMoveDown: () -> Unit,
+) {
+    val app = A2iApp.instance
+    var testing by remember { mutableStateOf(false) }
+    var testMsg by remember { mutableStateOf<String?>(null) }
+    Surface(
+        modifier = Modifier.fillMaxWidth(), shape = RoundedCornerShape(8.dp),
+        color = if (server.enabled) MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.40f) else MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.36f),
+        border = BorderStroke(1.dp, if (server.enabled) MaterialTheme.colorScheme.primary.copy(alpha = 0.30f) else MaterialTheme.colorScheme.outlineVariant),
+    ) {
+        Column(Modifier.padding(start = 4.dp, end = 4.dp, top = 2.dp, bottom = 6.dp)) {
+            Row(verticalAlignment = Alignment.CenterVertically) {
+                Checkbox(checked = server.enabled, onCheckedChange = onToggle)
+                Row(Modifier.weight(1f), verticalAlignment = Alignment.CenterVertically) {
+                    Text(server.name.ifBlank { "未命名" }, style = MaterialTheme.typography.bodyLarge, fontWeight = FontWeight.Medium, maxLines = 1, overflow = TextOverflow.Ellipsis, modifier = Modifier.weight(1f, fill = false))
+                    if (!server.enabled) { Spacer(Modifier.width(8.dp)); StatusBadge("停用", MaterialTheme.colorScheme.onSurfaceVariant) }
+                }
+                IconButton(onClick = { if (!testing) app.appScope.launch { testing = true; testMsg = testPush(app, server); testing = false } }, enabled = !testing) {
+                    if (testing) CircularProgressIndicator(Modifier.size(18.dp), strokeWidth = 2.dp) else Icon(Icons.AutoMirrored.Filled.Send, "测试")
+                }
+                IconButton(onClick = onEdit) { Icon(Icons.Filled.Edit, "编辑") }
+                IconButton(onClick = onDelete) { Icon(Icons.Filled.Delete, "删除") }
+            }
+            Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.padding(top = 2.dp)) {
+                Column(Modifier.weight(1f).padding(start = 36.dp)) {
+                    Text(server.server, style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant, maxLines = 2, overflow = TextOverflow.Ellipsis)
+                    Text("device key: " + if (server.deviceKey.isBlank()) "未填" else "已填（${server.deviceKey.length} 位）", style = MaterialTheme.typography.labelSmall, color = MaterialTheme.colorScheme.onSurfaceVariant)
+                }
+                IconButton(onClick = onMoveUp, enabled = !isFirst) { Icon(Icons.Filled.KeyboardArrowUp, "上移") }
+                IconButton(onClick = onMoveDown, enabled = !isLast) { Icon(Icons.Filled.KeyboardArrowDown, "下移") }
+            }
+            testMsg?.let { Text(it, style = MaterialTheme.typography.bodySmall, color = if (it.startsWith("已发送")) MaterialTheme.colorScheme.tertiary else MaterialTheme.colorScheme.error, modifier = Modifier.padding(start = 48.dp, top = 2.dp)) }
+        }
+    }
+}
 
 @Composable
-private fun ServerDialog(
+private fun ServerDialog(initial: BarkServer? = null, onDismiss: () -> Unit, onConfirm: (String, String, String) -> Unit) {
-    initial: BarkServer? = null,
-    onDismiss: () -> Unit,
-    onConfirm: (name: String, server: String, key: String) -> Unit,
-) {
     var name by remember { mutableStateOf(initial?.name ?: "") }
     var server by remember { mutableStateOf(initial?.server ?: OFFICIAL_BARK_SERVER) }
     var key by remember { mutableStateOf(initial?.deviceKey ?: "") }
-    AlertDialog(
+    ConfigDialogSkeleton(title = if (initial == null) "添加 Bark 服务器" else "编辑服务器", onDismiss = onDismiss, onConfirm = { onConfirm(name.trim(), server.trim().removeSuffix("/"), key.trim()) }) {
-        onDismissRequest = onDismiss,
-        icon = { Icon(Icons.Filled.Settings, null) },
-        title = { Text(if (initial == null) "添加服务器" else "编辑服务器") },
-        text = {
-            Column {
         OutlinedTextField(name, { name = it }, label = { Text("名称") }, singleLine = true, modifier = Modifier.fillMaxWidth())
         Spacer(Modifier.size(8.dp))
         OutlinedTextField(server, { server = it }, label = { Text("服务器地址") }, singleLine = true, modifier = Modifier.fillMaxWidth(), supportingText = { Text("官方：$OFFICIAL_BARK_SERVER") })
         Spacer(Modifier.size(8.dp))
         OutlinedTextField(key, { key = it }, label = { Text("Device Key") }, singleLine = true, modifier = Modifier.fillMaxWidth())
     }
-        },
+}
-        confirmButton = { TextButton(onClick = { onConfirm(name.trim(), server.trim(), key.trim()) }) { Text("保存") } },
+
+@Composable
+private fun NtfyConfigDialog(initial: NtfyServer? = null, onDismiss: () -> Unit, onConfirm: (String, String, String, String) -> Unit) {
+    var name by remember { mutableStateOf(initial?.name ?: "") }
+    var server by remember { mutableStateOf(initial?.server ?: "https://ntfy.sh") }
+    var topic by remember { mutableStateOf(initial?.topic ?: "") }
+    var token by remember { mutableStateOf(initial?.token ?: "") }
+    ConfigDialogSkeleton(title = if (initial == null) "添加 ntfy" else "编辑 ntfy", onDismiss = onDismiss, onConfirm = { onConfirm(name.trim(), server.trim().removeSuffix("/"), topic.trim(), token.trim()) }) {
+        OutlinedTextField(name, { name = it }, label = { Text("名称") }, singleLine = true, modifier = Modifier.fillMaxWidth())
+        Spacer(Modifier.size(8.dp))
+        OutlinedTextField(server, { server = it }, label = { Text("服务器") }, singleLine = true, modifier = Modifier.fillMaxWidth())
+        Spacer(Modifier.size(8.dp))
+        OutlinedTextField(topic, { topic = it }, label = { Text("Topic（必填）") }, singleLine = true, modifier = Modifier.fillMaxWidth())
+        Spacer(Modifier.size(8.dp))
+        OutlinedTextField(token, { token = it }, label = { Text("Token（可选）") }, singleLine = true, modifier = Modifier.fillMaxWidth())
+    }
+}
+
+@Composable
+private fun EmailConfigDialog(initial: EmailServer? = null, onDismiss: () -> Unit, onConfirm: (EmailServer) -> Unit) {
+    var name by remember { mutableStateOf(initial?.name ?: "") }
+    var host by remember { mutableStateOf(initial?.host ?: "") }
+    var port by remember { mutableStateOf((initial?.port ?: 465).toString()) }
+    var user by remember { mutableStateOf(initial?.user ?: "") }
+    var password by remember { mutableStateOf(initial?.password ?: "") }
+    var from by remember { mutableStateOf(initial?.from ?: "") }
+    var to by remember { mutableStateOf(initial?.to ?: "") }
+    ConfigDialogSkeleton(title = if (initial == null) "添加邮箱" else "编辑邮箱", onDismiss = onDismiss, onConfirm = { onConfirm(EmailServer(name = name.trim(), host = host.trim(), port = port.trim().toIntOrNull() ?: 465, user = user.trim(), password = password.trim(), from = from.trim(), to = to.trim())) }) {
+        OutlinedTextField(name, { name = it }, label = { Text("名称") }, singleLine = true, modifier = Modifier.fillMaxWidth())
+        Spacer(Modifier.size(8.dp))
+        Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+            OutlinedTextField(host, { host = it }, label = { Text("SMTP 主机") }, singleLine = true, modifier = Modifier.weight(1.5f))
+            OutlinedTextField(port, { port = it.filter { c -> c.isDigit() } }, label = { Text("端口") }, singleLine = true, modifier = Modifier.weight(1f))
+        }
+        Spacer(Modifier.size(8.dp))
+        OutlinedTextField(user, { user = it }, label = { Text("账号") }, singleLine = true, modifier = Modifier.fillMaxWidth())
+        Spacer(Modifier.size(8.dp))
+        OutlinedTextField(password, { password = it }, label = { Text("授权码/密码") }, singleLine = true, modifier = Modifier.fillMaxWidth())
+        Spacer(Modifier.size(8.dp))
+        OutlinedTextField(from, { from = it }, label = { Text("发件人") }, singleLine = true, modifier = Modifier.fillMaxWidth())
+        Spacer(Modifier.size(8.dp))
+        OutlinedTextField(to, { to = it }, label = { Text("收件人") }, singleLine = true, modifier = Modifier.fillMaxWidth())
+    }
+}
+
+@Composable
+private fun SmsConfigDialog(initial: SmsTarget? = null, onDismiss: () -> Unit, onConfirm: (String, String) -> Unit) {
+    var name by remember { mutableStateOf(initial?.name ?: "") }
+    var number by remember { mutableStateOf(initial?.number ?: "") }
+    ConfigDialogSkeleton(title = if (initial == null) "添加目标号" else "编辑目标号", onDismiss = onDismiss, onConfirm = { onConfirm(name.trim(), number.trim()) }) {
+        OutlinedTextField(name, { name = it }, label = { Text("名称") }, singleLine = true, modifier = Modifier.fillMaxWidth())
+        Spacer(Modifier.size(8.dp))
+        OutlinedTextField(number, { number = it }, label = { Text("手机号") }, singleLine = true, modifier = Modifier.fillMaxWidth())
+    }
+}
+
+@Composable
+private fun ConfigDialogSkeleton(title: String, onDismiss: () -> Unit, onConfirm: () -> Unit, content: @Composable () -> Unit) {
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        icon = { Icon(Icons.Filled.Settings, null) },
+        title = { Text(title) },
+        text = { Column { content() } },
+        confirmButton = { TextButton(onClick = onConfirm) { Text("保存") } },
         dismissButton = { TextButton(onClick = onDismiss) { Text("取消") } },
     )
 }
 
-private suspend fun testPush(app: A2iApp): String {
+private suspend fun testPush(app: A2iApp, server: BarkServer): String {
-    val s = app.settings.currentServer.value ?: return "未选择服务器"
+    if (server.deviceKey.isBlank()) return "未填写 device key"
-    if (s.deviceKey.isBlank()) return "未填写 device key"
+    val msg = BarkMessage(deviceKey = server.deviceKey, title = "a2i 测试", body = "如果你在 iOS 看到这条推送，说明配置成功", level = "active")
-    val msg = BarkMessage(
+    val r = BarkClient(server).push(msg)
-        deviceKey = s.deviceKey,
-        title = "a2i 测试",
-        body = "如果你在 iOS 看到这条推送，说明配置成功",
-        level = "active",
-    )
-    val r = BarkClient(s).push(msg)
     return if (r.isSuccess) "已发送，请查看 iOS 端" else "发送失败：${r.exceptionOrNull()?.message}"
 }

app/src/main/java/com/a2i/forwarder/ui/screens/UpdateDialog.kt

@@ -0,0 +1,121 @@
+package com.a2i.forwarder.ui.screens
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.heightIn
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Button
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.LinearProgressIndicator
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+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.unit.dp
+import com.a2i.forwarder.A2iApp
+import com.a2i.forwarder.core.UpdateInfo
+import kotlinx.coroutines.launch
+import java.io.File
+import java.util.Locale
+
+@Composable
+fun UpdateDialog(info: UpdateInfo, onDismiss: () -> Unit) {
+    val app = A2iApp.instance
+    val downloading by app.updateChecker.downloading.collectAsState()
+    val progress by app.updateChecker.downloadProgress.collectAsState()
+    var downloadedFile by remember { mutableStateOf<File?>(null) }
+
+    AlertDialog(
+        onDismissRequest = { if (!downloading) onDismiss() },
+        title = { Text("发现新版本 v${info.latestVersion}") },
+        text = {
+            Column {
+                Text(
+                    "安装包大小：${formatSize(info.apkSize)}",
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                )
+                Spacer(Modifier.size(8.dp))
+                Column(
+                    modifier = Modifier
+                        .heightIn(max = 240.dp)
+                        .verticalScroll(rememberScrollState()),
+                ) {
+                    val notes = info.releaseNotes.ifBlank { "（作者未提供更新说明）" }
+                    Text(notes, style = MaterialTheme.typography.bodyMedium)
+                }
+                if (downloading) {
+                    Spacer(Modifier.size(12.dp))
+                    LinearProgressIndicator(
+                        progress = { progress / 100f },
+                        modifier = Modifier.fillMaxWidth(),
+                    )
+                    Spacer(Modifier.size(4.dp))
+                    Text(
+                        "$progress%",
+                        style = MaterialTheme.typography.bodySmall,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    )
+                }
+                downloadedFile?.let {
+                    Spacer(Modifier.size(8.dp))
+                    Text(
+                        "下载完成，点击「安装」继续",
+                        style = MaterialTheme.typography.bodySmall,
+                        color = MaterialTheme.colorScheme.tertiary,
+                    )
+                }
+            }
+        },
+        confirmButton = {
+            if (downloadedFile == null) {
+                Button(
+                    onClick = {
+                        app.appScope.launch {
+                            val f = app.updateChecker.download(info)
+                            if (f != null) downloadedFile = f
+                        }
+                    },
+                    enabled = !downloading,
+                ) {
+                    if (downloading) {
+                        CircularProgressIndicator(Modifier.size(16.dp), strokeWidth = 2.dp)
+                    } else {
+                        Text("下载并安装")
+                    }
+                }
+            } else {
+                Button(onClick = { app.updateChecker.install(downloadedFile!!) }) { Text("安装") }
+            }
+        },
+        dismissButton = {
+            Row {
+                TextButton(
+                    onClick = { app.updateChecker.ignoreVersion(info.latestVersion); onDismiss() },
+                    enabled = !downloading,
+                ) { Text("忽略此版本") }
+                TextButton(onClick = onDismiss, enabled = !downloading) { Text("稍后") }
+            }
+        },
+    )
+}
+
+fun formatSize(bytes: Long): String {
+    if (bytes <= 0) return "未知"
+    val kb = bytes / 1024.0
+    return if (kb >= 1024) String.format(Locale.US, "%.1f MB", kb / 1024) else String.format(Locale.US, "%.0f KB", kb)
+}

app/src/main/res/xml/file_paths.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<paths>
+    <external-files-path name="updates" path="." />
+    <cache-path name="cache" path="." />
+</paths>