feat: 架构重构与跨平台媒体控制集成

## 后端 - 替换 rodio 为 symphonia + ringbuf，重构 audio.rs 播放引擎 - 重构 api.rs，使用 api_call! 宏统一 API 调用模式 - 新增 media_controls.rs，使用 souvlaki 实现跨平台系统媒体控制 (Linux MPRIS / Windows SMTC / macOS Now Playing) - 版本号升至 v0.5.0 ## 前端 - 新增 - 新增 SongListItem 通用组件 - 新增 useOnlineStatus composable，检测网络状态 - 新增 usePageCache composable，页面数据缓存与失效 - 新增 getCoverUrl()、formatDate() 工具函数 - 新增 emitPlaybackState() 同步播放状态到系统媒体控制 - 新增 mpris-command 事件监听，响应系统媒体控制命令 - 新增 Toast 离线/恢复在线提示 - 各页面新增断网恢复后自动重试加载 - 新增路由守卫：已登录用户访问 /login 重定向至首页 - 新增音量持久化（settings store + localStorage） - 新增禁用右键菜单与用户选择限制（输入框除外） ## 前端 - 变更 - Song 接口从 player.ts 迁移至 song.ts 并导出 - AlbumDetail/ArtistDetail/PlaylistDetail/RecentPlays/LocalMusic 迁移至 SongListItem - PlayerBar 队列列表迁移至 SongListItem，封面使用 getCoverUrl() - downloadSong 参数类型从内联对象改为 Song，使用 getCoverUrl() - 默认主题从 green 改为 blue，ThemeName 及相关列表中 blue 移至首位 - 全局快捷键从 Alt+Control 改为 Control+Alt 顺序 - formatShortcut 新增 KeyP → P 显示 - keep-alive 从 max=3 固定 include 改为 max=5 动态列表，窗口隐藏时释放 - App.vue 封面使用 getCoverUrl() 替代手动 al/album 回退 - formatPlayCount 提取常量 - Login.vue text-warning 改为 text-yellow-400 ## 前端 - 删除 - 删除 Search.vue（与 Discover.vue 重复） - 删除 SongItemMenu.vue（被 SongListItem 替代） ## 修复 - 更新器跳过版本逻辑：仅静默检查时跳过已忽略版本，手动检查不再跳过 - 重复播放同一首歌时无法恢复播放 - settings.ts 重复的 ThemeName 定义 - PlayerBar.vue modeTexts 缺少类型注解 - Home.vue map 回调参数缺少类型 - Settings.vue v-for key 类型不匹配
重构播放列表为右侧弹出式
2026-06-22 00:58:51 +08:00 · 2026-05-23 14:43:47 +08:00 · 2026-05-22 00:54:09 +08:00 · 2026-05-21 14:22:14 +08:00 · 2026-05-18 15:58:56 +08:00 · 2026-05-18 15:52:51 +08:00
46 changed files with 6448 additions and 1043 deletions
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@ -0,0 +1,81 @@
+name: Release with Updater
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  publish:
+    permissions:
+      contents: write   
+    strategy:
+      matrix:
+        include:
+          - os: ubuntu-latest
+            platform: linux
+          - os: windows-latest
+            platform: windows
+          - os: macos-latest
+            platform: macos
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable  
+
+      - name: Install Linux dependencies
+        if: matrix.os == 'ubuntu-latest'
+        run: |
+         sudo apt-get update
+         sudo apt-get install -y \
+         libasound2-dev \
+         libwebkit2gtk-4.1-dev \
+         build-essential \
+         curl \
+         wget \
+         file \
+         libssl-dev \
+         libgtk-3-dev \
+         libayatana-appindicator3-dev \
+         librsvg2-dev
+
+      - name: Install npm dependencies
+        run: npm install
+        
+      - name: Extract release notes for version
+        id: release_notes
+        shell: bash
+        run: |
+          VERSION="${{ github.ref_name }}"   
+          # 从 CHANGELOG.md 中提取 "## v0.3.0" 到下一个 "## " 之间的内容
+          NOTES=$(awk -v ver="## $VERSION" '$0 ~ ver {flag=1; next} /^## / && flag {exit} flag' CHANGELOG.md)
+
+          # 如果没有提取到内容，使用默认文本
+          if [ -z "$NOTES" ]; then
+            NOTES="See CHANGELOG.md for details."
+          fi
+
+          # 将多行内容写入环境变量(GitHub Actions 支持多行输入)
+          {
+            echo 'NOTES<<EOF'
+            echo "$NOTES"
+            echo EOF
+          } >> $GITHUB_ENV
+
+      - name: Build and publish with Tauri Action
+        uses: tauri-apps/tauri-action@v0
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+        with:
+          tagName: ${{ github.ref_name }}
+          releaseName: 'v__VERSION__'
+          releaseBody: ${{ env.NOTES }}  
+          releaseDraft: false
+          prerelease: false
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -0,0 +1,102 @@
+## v0.5.0
+
+### ✨ 新功能
+- **蓝牙耳机/键盘媒体键控制**：支持通过蓝牙耳机按钮、键盘媒体键、系统通知栏/锁屏面板控制播放、暂停、切歌（Windows / Linux / macOS）
+- **网络状态检测**：断网和恢复时弹出提示，网络恢复后自动重新加载页面内容
+- **音量记忆**：关闭应用后音量设置不丢失，下次打开自动恢复
+- **歌词翻译**：支持显示歌词翻译，可在漫游页面切换开关
+- **登录页优化**：已登录用户访问登录页会自动跳转回首页
+
+### 🎨 变更
+- 默认主题色改为天蓝色
+- 全局快捷键显示顺序调整为 Ctrl + Alt（之前是 Alt + Ctrl）
+- 快捷键显示优化：按键名更简洁，如 KeyP 显示为 P
+- 页面缓存优化：更多页面切换时保留状态，窗口隐藏时自动释放
+- 登录页等待确认时的文字颜色修正
+
+### 🐛 修复
+- 手动检查更新时，之前跳过的版本现在会正常弹出更新提示
+- 点击正在播放的歌曲无法恢复播放的问题
+- 部分内部类型定义问题导致的潜在隐患
+
+### ⚡ 底层优化
+- 音频播放引擎全面重构，播放更稳定
+- 后端 API 调用模式统一，代码更易维护
+- 歌曲数据模型统一，各页面显示更一致
+
+
+## v0.4.1
+
+添加音频输出外设选择
+
+
+## v0.4.0
+
+### ✨ 新功能
+- 添加歌曲的艺术家入口，歌曲的艺术家现可点击查看其他歌曲、专辑和介绍
+- 添加歌曲的评论查看功能
+
+### 🐛 修复
+- 修复私人漫游自动播放下一首调用多次问题
+
+### ⚡ 优化
+- 优化播放逻辑，歌曲列表在点击时候不再单首累加，而是直接获取当前列表所有的歌曲作为播放内容
+
+
+## v0.3.0
+
+### ✨ 新功能
+- **本地音乐页面**：支持浏览、播放本地歌曲，横向菜单添加「从磁盘删除」功能
+- **下载系统**：支持下载歌曲到自定义路径，保存完整元数据（封面/专辑/时长）
+- **封面补全**：本地音乐缺少封面时尝试从网易云 API 获取
+- **更新信息**：添加查看最新版更新日志按钮 
+- **下载路径**：支持自定义下载路径
+- **本地音乐**：支持本地音乐播放
+- **下载提示**：下载进度与完成提示
+- **快捷键绑定**：支持自定义全局和本地快捷键（播放/暂停、上一首/下一首、音量调节）
+
+### 🐛 修复
+- 修复私人漫游播完一首歌后跳三首的问题
+- 修复全屏漫游抽屉和漫游页面无封面歌曲显示破损图片
+- 修复 PlayerBar 无封面歌曲显示破损图片
+- 修复播放网络歌曲时进度条先走但无声音
+
+### ⚡ 优化
+- **流式播放**：边下载边播放，缓冲 64KB 后即刻开始，无需等待完整下载
+
+
+## v0.2.0
+
+### 🎵 播放
+- 优化私人漫游（个人 FM）功能
+- 新增歌曲喜欢/取消喜欢红心
+- 新增播放历史本地记录（最近 200 首）
+
+### 📋 歌单
+- 修改逻辑 我的歌单 不再显示收藏按钮
+- 收藏歌单支持取消收藏
+- 实现我的音乐功能
+- 实现历史播放记录功能
+
+### 🎨 外观
+- 全局复选框与选择框优化
+- 部分UI优化，统一风格
+
+### 🖥️ 窗口
+- 关闭窗口弹出确认弹窗：最小化到托盘 / 退出程序
+- 支持"不再询问"选项，可在设置中修改
+- 修复退出时 WebView2 报错（Error 1410）
+- 修复歌词抽屉全屏时候顶栏无法接收事件问题
+
+### 💾 持久化
+- Cookie 存储迁移至 Tauri app_data_dir
+- 播放历史持久化到 localStorage
+
+### ⚙️ 其他
+- 添加设置功能
+- 关于添加链接可直接访问仓库
+
+
+## v0.1.0
+
+Nekosonic 是一款基于 Tauri 2 + Rust 的跨平台桌面音乐播放器，音源主要来自网易云音乐，开箱即用。
--- a/README.md
+++ b/README.md
@ -1,25 +1,63 @@
 # Nekosonic

-一款轻量的跨平台的音乐播放器，支持Windows/Linux系统，音源主要源自的网易云音乐。
+一款轻量的跨平台音乐播放器，支持 Windows / Linux / macOS，音源源自网易云音乐。

 ## ✨ 特性

- 🔴 网易云账号登录（扫码）
- 🎵 多音质播放（标准 / 较高 / 极高 / 无损 / Hi-Res）
- 📻 私人漫游，沉浸式全屏歌词体验
- ❤️ 一键喜欢 / 取消喜欢
- 📋 歌单管理，收藏 / 取消收藏歌单
+### 播放
+
+- 🎵 在线音乐播放，流式缓冲边下边播
+- 🎵 多音质选择（标准 / 较高 / 极高 HQ / 无损 SQ / Hi-Res）
+- 🔄 播放模式切换（列表循环 / 随机播放 / 单曲循环）
+- ⏯ 播放控制（播放 / 暂停 / 上一首 / 下一首 / 进度跳转 / 音量调节）
+- 📋 播放队列管理（查看队列 / 移除歌曲 / 清空队列）
+- 📻 私人漫游 FM（个性化推荐，VIP 试听自动跳过）
+- 🎵 本地音乐播放（支持 mp3 / flac / wav / ogg / aac / m4a / wma / opus）
+- 🔊 音频输出设备选择
+- 🎧 系统媒体控制（蓝牙耳机/键盘媒体键/系统面板，支持 Linux / Windows / macOS）
+
+### 发现与浏览
+
+- 🔍 关键词搜索歌曲 + 热门搜索标签
+- 📋 歌单浏览（推荐歌单 / 排行榜 / 用户歌单 / 收藏歌单）
+- 📋 歌单详情（歌曲列表 + 收藏 / 取消收藏 + 歌单评论）
+- 🎤 歌手详情（热门歌曲 / 专辑 / 简介）
+- 💿 专辑详情（歌曲列表 + 播放全部）
 - 📅 每日推荐歌曲
- 🕐 本地播放历史记录
- 🔍 关键词搜索歌曲
- 🎤 实时滚动歌词
- 🌚 Light / Dark Mode 主题切换
- 🛠 更多特性添加中
+
+### 歌词与评论
+
+- 🎤 实时滚动歌词（自动滚动 / 点击跳转 / 渐变透明度）
+- 🎤 歌词翻译显示
+- 🎤 全屏漫游模式（大封面 + 歌词 / 评论双标签页）
+- 💬 歌曲评论查看（热门评论 + 无限滚动加载 + 点赞）
+
+### 收藏与下载
+
+- ❤️ 一键喜欢 / 取消喜欢（同步到网易云账号）
+- ⬇️ 歌曲下载（带进度显示 / VIP 拦截 / 元数据保存）
+- 🎵 本地音乐管理（列出 / 播放 / 删除 / 音频元数据与封面读取）
+- 🕐 本地播放历史记录（最多 200 首）
+
+### 账号
+
+- 🔴 网易云账号登录（二维码扫码 / 手机号密码）
+- 🔑 登录态持久化（重启后自动恢复）
+
+### 系统与设置
+
+- 📡 系统托盘（播放控制 / 显示窗口 / 退出）
+- 🛡 单实例运行（防止重复启动）
+- ⌨️ 自定义快捷键（应用内 + 系统全局）
+- 🎨 多主题切换（天蓝 / 翠绿 / 玫红 / 紫罗兰 / 橙色 / 青色 / 粉色）
+- ⚙️ 关闭窗口行为设置（每次询问 / 最小化到托盘 / 直接退出）
+- 🔄 自动更新（启动静默检测 + 自定义弹窗 + 忽略版本 + 下载进度）
+- 📝 更新日志查看
+- 📶 网络状态检测（断网/恢复 Toast 提示 + 自动重试加载）

 ## 📦️ 安装

-访问本项目的 [Releases](https://gitea.atdunbg.xyz/atdunbg/Nekosonic-Music/releases) 页面下载安装包。
-
+访问本项目的 [Releases](https://github.com/atdunbg/Nekosonic-Music/releases) 页面下载安装包。

 ## 💻 配置开发环境

@ -49,19 +87,26 @@ npm run tauri build
 | 样式 | Tailwind CSS v4 + CSS 变量主题系统 |
 | 状态管理 | Pinia |
 | 路由 | Vue Router 4 |
-| 音频播放 | rodio (Rust) |
+| 音频解码 | symphonia + ringbuf (Rust) |
+| 媒体控制 | souvlaki (Linux MPRIS / Windows SMTC / macOS Now Playing) |
 | 网易云 API | ncm-api-rs |
 | 构建工具 | Vite 6 |

 ## ☑️ Todo

+- [x] 评论系统
+- [x] 歌曲下载
+- [x] 本地音乐管理
+- [x] 歌手详情页
+- [x] 专辑详情页
+- [x] 自定义全局快捷键
+- [x] 自动更新
+- [x] 歌词翻译
+- [x] 更多主题
+- [x] 系统媒体控制（蓝牙耳机/键盘媒体键）
 - [ ] MV 播放
 - [ ] 音乐云盘
- [ ] 评论系统
- [ ] 下载功能
- [ ] 自定义全局快捷键
- [ ] 歌词翻译
- [ ] 更多主题
+- [ ] 桌面歌词

 欢迎提 Issue 和 Pull request。

@ -71,11 +116,11 @@ npm run tauri build

 基于 [MIT license](https://opensource.org/licenses/MIT) 许可进行开源。

-
 ## 致谢

 - [ncm-api-rs](https://crates.io/crates/ncm-api-rs) — 网易云音乐 API 的 Rust 封装
 - [Tauri](https://tauri.app/) — 跨平台桌面应用框架
 - [Vue.js](https://vuejs.org/) — 渐进式 JavaScript 框架
 - [Tailwind CSS](https://tailwindcss.com/) — 实用优先的 CSS 框架
- [rodio](https://crates.io/crates/rodio) — Rust 音频播放库
+- [symphonia](https://crates.io/crates/symphonia) — Rust 纯音频解码库
+- [souvlaki](https://crates.io/crates/souvlaki) — 跨平台 OS 媒体控制库
--- a/package-lock.json
+++ b/package-lock.json
@ -1,15 +1,19 @@
 {
-  "name": "demo",
-  "version": "0.1.0",
+  "name": "nekosonic",
+  "version": "0.3.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
-      "name": "demo",
-      "version": "0.1.0",
+      "name": "nekosonic",
+      "version": "0.3.0",
      "dependencies": {
        "@tauri-apps/api": "^2",
+        "@tauri-apps/plugin-dialog": "^2.7.1",
+        "@tauri-apps/plugin-global-shortcut": "^2.3.1",
        "@tauri-apps/plugin-opener": "^2",
+        "@tauri-apps/plugin-process": "^2.3.1",
+        "@tauri-apps/plugin-updater": "^2.10.1",
        "axios": "^1.16.0",
        "howler": "^2.2.4",
        "pinia": "^3.0.4",
@ -1485,6 +1489,24 @@
        "node": ">= 10"
      }
    },
+    "node_modules/@tauri-apps/plugin-dialog": {
+      "version": "2.7.1",
+      "resolved": "https://registry.npmmirror.com/@tauri-apps/plugin-dialog/-/plugin-dialog-2.7.1.tgz",
+      "integrity": "sha512-OK1UBXYt+ojcmxMktzzuyonYIFta8CmAASpX+CA+DTGK24KlHjhYI6x2iOJ/TjZF4N7/ACK1oFmEOjIY9IhzOQ==",
+      "license": "MIT OR Apache-2.0",
+      "dependencies": {
+        "@tauri-apps/api": "^2.11.0"
+      }
+    },
+    "node_modules/@tauri-apps/plugin-global-shortcut": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmmirror.com/@tauri-apps/plugin-global-shortcut/-/plugin-global-shortcut-2.3.1.tgz",
+      "integrity": "sha512-vr40W2N6G63dmBPaha1TsBQLLURXG538RQbH5vAm0G/ovVZyXJrmZR1HF1W+WneNloQvwn4dm8xzwpEXRW560g==",
+      "license": "MIT OR Apache-2.0",
+      "dependencies": {
+        "@tauri-apps/api": "^2.8.0"
+      }
+    },
    "node_modules/@tauri-apps/plugin-opener": {
      "version": "2.5.4",
      "resolved": "https://registry.npmmirror.com/@tauri-apps/plugin-opener/-/plugin-opener-2.5.4.tgz",
@ -1494,6 +1516,24 @@
        "@tauri-apps/api": "^2.11.0"
      }
    },
+    "node_modules/@tauri-apps/plugin-process": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmmirror.com/@tauri-apps/plugin-process/-/plugin-process-2.3.1.tgz",
+      "integrity": "sha512-nCa4fGVaDL/B9ai03VyPOjfAHRHSBz5v6F/ObsB73r/dA3MHHhZtldaDMIc0V/pnUw9ehzr2iEG+XkSEyC0JJA==",
+      "license": "MIT OR Apache-2.0",
+      "dependencies": {
+        "@tauri-apps/api": "^2.8.0"
+      }
+    },
+    "node_modules/@tauri-apps/plugin-updater": {
+      "version": "2.10.1",
+      "resolved": "https://registry.npmmirror.com/@tauri-apps/plugin-updater/-/plugin-updater-2.10.1.tgz",
+      "integrity": "sha512-NFYMg+tWOZPJdzE/PpFj2qfqwAWwNS3kXrb1tm1gnBJ9mYzZ4WDRrwy8udzWoAnfGCHLuePNLY1WVCNHnh3eRA==",
+      "license": "MIT OR Apache-2.0",
+      "dependencies": {
+        "@tauri-apps/api": "^2.10.1"
+      }
+    },
    "node_modules/@types/estree": {
      "version": "1.0.8",
      "resolved": "https://registry.npmmirror.com/@types/estree/-/estree-1.0.8.tgz",
@ -1507,7 +1547,6 @@
      "integrity": "sha512-+qIYRKdNYJwY3vRCZMdJbPLJAtGjQBudzZzdzwQYkEPQd+PJGixUL5QfvCLDaULoLv+RhT3LDkwEfKaAkgSmNQ==",
      "dev": true,
      "license": "MIT",
-      "peer": true,
      "dependencies": {
        "undici-types": "~7.19.0"
      }
--- a/package.json
+++ b/package.json
@ -1,7 +1,7 @@
 {
  "name": "nekosonic",
  "private": true,
-  "version": "0.1.0",
+  "version": "0.3.0",
  "type": "module",
  "scripts": {
    "dev": "vite",
@ -11,7 +11,11 @@
  },
  "dependencies": {
    "@tauri-apps/api": "^2",
+    "@tauri-apps/plugin-dialog": "^2.7.1",
+    "@tauri-apps/plugin-global-shortcut": "^2.3.1",
    "@tauri-apps/plugin-opener": "^2",
+    "@tauri-apps/plugin-process": "^2.3.1",
+    "@tauri-apps/plugin-updater": "^2.10.1",
    "axios": "^1.16.0",
    "howler": "^2.2.4",
    "pinia": "^3.0.4",
--- a/src-tauri/Cargo.lock
+++ b/src-tauri/Cargo.lock
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "Nekosonic"
-version = "0.1.0"
+version = "0.5.0"
 description = "A Simple music app"
 authors = ["atdunbg"]
 edition = "2021"
@ -20,12 +20,32 @@ tauri-build = { version = "2", features = [] }
 [dependencies]
 tauri = { version = "2", features = ["tray-icon"] }
 tauri-plugin-opener = "2"
-rodio = "0.20"
+tauri-plugin-single-instance = "2"
+tauri-plugin-global-shortcut = "2"
+tauri-plugin-dialog = "2"
+symphonia = { version = "0.5", features = ["mp3", "aac", "flac", "wav", "ogg", "vorbis", "isomp4", "mkv"] }
+ringbuf = "0.4"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 cpal = { version = "0.15" }   
-reqwest = { version = "0.12", default-features = false, features = ["blocking", "rustls-tls"] }
+reqwest = { version = "0.12", default-features = false, features = ["blocking", "rustls-tls", "stream"] }
+futures-util = "0.3"
+dirs = "5"
+lofty = "0.22"
+base64 = "0.22"

 ncm-api-rs = "0.1"
 tokio = { version = "1", features = ["rt", "sync"] }   
+tauri-plugin-process = "2.3.1"
+tauri-plugin-updater = "2"
+
+[target.'cfg(target_os = "linux")'.dependencies]
+souvlaki = { version = "0.8", default-features = false, features = ["use_zbus"] }
+
+[target.'cfg(target_os = "windows")'.dependencies]
+souvlaki = "0.8"
+raw-window-handle = "0.6"
+
+[target.'cfg(target_os = "macos")'.dependencies]
+souvlaki = "0.8"

--- a/src-tauri/capabilities/default.json
+++ b/src-tauri/capabilities/default.json
@ -12,6 +12,15 @@
    "core:window:allow-close",
    "core:window:allow-hide",
    "core:window:allow-start-dragging",
-    "core:window:allow-toggle-maximize"
+    "core:window:allow-toggle-maximize",
+    "core:window:allow-unminimize",
+    "core:window:allow-show",
+    "core:window:allow-set-focus",
+    "global-shortcut:allow-is-registered",
+    "global-shortcut:allow-register",
+    "global-shortcut:allow-unregister",
+    "dialog:allow-open",
+    "process:allow-restart",
+    "updater:default"
  ]
 }
--- a/src-tauri/src/api.rs
+++ b/src-tauri/src/api.rs
@ -1,19 +1,78 @@
 use ncm_api_rs::{create_client, ApiClient, Query};
 use serde::Deserialize;
-use tauri::{Manager, State};
-use tokio::sync::Mutex;
+use serde_json::json;
+use tauri::{Manager, State, Emitter};
 use std::sync::Mutex as StdMutex;
 use std::sync::atomic::Ordering;

 use std::fs;
 use std::path::PathBuf;
+use std::io::Write;
+use std::hash::{Hash, Hasher};
+use lofty::file::{AudioFile, TaggedFileExt};
+use lofty::tag::Accessor;
+use base64::Engine;
+
+/// 统一的 API 调用宏，封装了「获取客户端 → 构建请求 → 发送 → 提取响应体」的完整流程。
+///
+/// 消除了每个 Tauri 命令中重复的 `client.lock().unwrap().clone()` + `build_query()` + `.map(|r| r.body.to_string())` 样板代码。
+///
+/// 提供三种调用方式：
+///
+/// 1. 无额外参数 — 仅使用 cookie 中的默认参数构建请求
+///    ```
+///    api_call!(state, get_playlist_detail)
+///    // 等价于:
+///    // let client = state.client.lock().unwrap().clone();
+///    // let q = state.build_query();
+///    // client.get_playlist_detail(&q).await.map(|r| r.body.to_string()).map_err(|e| e.to_string())
+///    ```
+///
+/// 2. 附加参数 — 在默认参数基础上追加键值对
+///    ```
+///    api_call!(state, song_url_v1, params: [("id", id), ("level", "standard")])
+///    // 等价于:
+///    // let q = state.build_query().param("id", id).param("level", "standard");
+///    // client.song_url_v1(&q).await...
+///    ```
+///
+/// 3. 预构建查询 — 直接传入已构建好的 Query 对象，跳过 build_query()
+///    ```
+///    api_call!(state, playlist_track_all, query: my_query)
+///    // 等价于:
+///    // client.playlist_track_all(&my_query).await...
+///    ```
+macro_rules! api_call {
+    ($state:expr, $method:ident) => {{
+        let client = $state.client.lock().unwrap().clone();
+        let q = $state.build_query();
+        client.$method(&q).await
+            .map(|r| r.body.to_string())
+            .map_err(|e| e.to_string())
+    }};
+    ($state:expr, $method:ident, params: [$(($key:expr, $val:expr)),* $(,)?]) => {{
+        let client = $state.client.lock().unwrap().clone();
+        let mut q = $state.build_query();
+        $(q = q.param($key, $val);)*
+        client.$method(&q).await
+            .map(|r| r.body.to_string())
+            .map_err(|e| e.to_string())
+    }};
+    ($state:expr, $method:ident, query: $q:expr) => {{
+        let client = $state.client.lock().unwrap().clone();
+        client.$method(&$q).await
+            .map(|r| r.body.to_string())
+            .map_err(|e| e.to_string())
+    }};
+}

 pub struct ApiController {
-    client: Mutex<ApiClient>,
+    client: StdMutex<ApiClient>,
    cookie: StdMutex<Option<String>>,
    cookie_path: PathBuf,
 }

+/// 将 Cookie 字符串列表转换为 `key=value; key=value` 格式
 fn cookies_to_key_values(cookies: &[String]) -> String {
    cookies
        .iter()
@ -25,6 +84,7 @@ fn cookies_to_key_values(cookies: &[String]) -> String {

 impl ApiController {

+    /// 创建新的 API 控制器，从本地文件恢复已保存的 Cookie
    pub fn new(app_data_dir: PathBuf) -> Self {
    let _ = fs::create_dir_all(&app_data_dir);
    let cookie_path = app_data_dir.join("netease_cookies.json");
@ -34,13 +94,14 @@ impl ApiController {

    let client = create_client(None);
    ApiController {
-        client: Mutex::new(client),
+        client: StdMutex::new(client),
        cookie: StdMutex::new(saved_cookie),
        cookie_path,
    }
 }

-fn build_query(&self) -> Query {
+    /// 构建带当前 Cookie 的 API 查询对象
+    fn build_query(&self) -> Query {
    let mut query = Query::new();
    if let Ok(cookie_guard) = self.cookie.lock() {
        if let Some(c) = cookie_guard.as_ref() {
@ -49,101 +110,117 @@ fn build_query(&self) -> Query {
    }
    query
 }
+    /// 将 Cookie 字符串持久化到本地文件并同步到 API 客户端
    fn save_cookie(&self, cookie_str: &str) {
        let _ = fs::write(&self.cookie_path, cookie_str);
+        if let Ok(mut client) = self.client.lock() {
+            client.set_cookie(cookie_str.to_string());
+        }
    }
 }

+/// 搜索查询参数
 #[derive(Deserialize)]
 pub struct SearchQuery { pub keyword: String }

+/// 手机号登录查询参数
 #[derive(Deserialize)]
 pub struct LoginQuery { pub phone: String, pub password: String }

+/// 二维码登录密钥查询参数
 #[derive(Deserialize)]
 pub struct QrKeyQuery { pub key: String }

 /// 搜索歌曲
 #[tauri::command]
 pub async fn search_songs(query: SearchQuery, state: State<'_, ApiController>) -> Result<String, String> {
-    let client = state.client.lock().await;
-    let q = state.build_query()
-        .param("keywords", &query.keyword)
-        .param("type", "1")
-        .param("limit", "30");
-    client.cloudsearch(&q).await
-        .map(|r| r.body.to_string())
-        .map_err(|e| e.to_string())
+    api_call!(state, cloudsearch, params: [("keywords", &query.keyword), ("type", "1"), ("limit", "30")])
 }

 /// 获取热搜词列表
 #[tauri::command]
 pub async fn get_hot_search(state: State<'_, ApiController>) -> Result<String, String> {
-    let client = state.client.lock().await;
-    let q = state.build_query();
-    client.search_hot_detail(&q).await
-        .map(|r| r.body.to_string())
-        .map_err(|e| e.to_string())
+    api_call!(state, search_hot_detail)
 }

+/// 歌单全部曲目查询参数
 #[derive(Deserialize)]
 pub struct PlaylistTrackAllQuery { pub id: u64, pub limit: Option<i64>, pub offset: Option<i64> }

 /// 获取歌单全部歌曲
 #[tauri::command]
 pub async fn playlist_track_all(query: PlaylistTrackAllQuery, state: State<'_, ApiController>) -> Result<String, String> {
-    let client = state.client.lock().await;
-    let q = state.build_query()
-        .param("id", &query.id.to_string())
-        .param("limit", &query.limit.unwrap_or(1000).to_string())
-        .param("offset", &query.offset.unwrap_or(0).to_string());
-    client.playlist_track_all(&q).await
-        .map(|r| r.body.to_string())
-        .map_err(|e| e.to_string())
+    api_call!(state, playlist_track_all, params: [("id", &query.id.to_string()), ("limit", &query.limit.unwrap_or(1000).to_string()), ("offset", &query.offset.unwrap_or(0).to_string())])
 }

+/// 歌曲播放地址查询参数
 #[derive(Deserialize)]
-pub struct SongUrlQuery { pub id: u64, pub level: Option<String> }
+pub struct SongUrlQuery { pub id: u64, pub level: Option<String>, pub fm_mode: Option<bool> }

-/// 获取歌曲播放地址
+/// 获取歌曲播放地址（返回完整 data 对象，包含 url、freeTrialInfo 等）
 #[tauri::command]
 pub async fn get_song_url(query: SongUrlQuery, state: State<'_, ApiController>) -> Result<String, String> {
-    let client = state.client.lock().await;
+    let client = state.client.lock().unwrap().clone();
    let level = query.level.as_deref().unwrap_or("standard");
-    let q = state.build_query()
-        .param("id", &query.id.to_string())
-        .param("level", level);
-    let resp = client.song_url_v1(&q).await.map_err(|e| e.to_string())?;
-    resp.body["data"][0]["url"].as_str()
-        .filter(|s| !s.is_empty())
-        .map(|s| s.to_string())
-        .ok_or_else(|| "暂无播放源".into())
+
+    let resp = if query.fm_mode.unwrap_or(false) {
+        let mut fm_cookie = state.cookie.lock().ok().and_then(|g| g.clone()).unwrap_or_default();
+        if !fm_cookie.contains("os=") {
+            fm_cookie = format!("{}; os=android; appver=8.10.05", fm_cookie);
+        }
+        let data = serde_json::json!({
+            "ids": format!("[{}]", query.id),
+            "level": level,
+            "encodeType": "flac",
+            "feeProcess": "true"
+        });
+        let option = ncm_api_rs::request::RequestOption {
+            crypto: ncm_api_rs::request::CryptoType::default(),
+            cookie: Some(fm_cookie),
+            ua: None,
+            proxy: None,
+            real_ip: None,
+            random_cn_ip: false,
+            e_r: None,
+            domain: None,
+            check_token: false,
+        };
+        client.request(
+            "/api/song/enhance/player/url/v1",
+            data,
+            option,
+        ).await.map_err(|e| e.to_string())?
+    } else {
+        let q = state.build_query()
+            .param("id", &query.id.to_string())
+            .param("level", level);
+        client.song_url_v1(&q).await.map_err(|e| e.to_string())?
+    };
+
+    let data = &resp.body["data"][0];
+    let url = data["url"].as_str().filter(|s| !s.is_empty());
+    if url.is_none() {
+        return Err("暂无播放源".into());
+    }
+    Ok(data.to_string())
 }

 /// 获取歌词
 #[tauri::command]
 pub async fn get_lyric(id: u64, state: State<'_, ApiController>) -> Result<String, String> {
-    let client = state.client.lock().await;
-    let q = state.build_query().param("id", &id.to_string());
-    client.lyric(&q).await
-        .map(|r| r.body.to_string())
-        .map_err(|e| e.to_string())
+    api_call!(state, lyric, params: [("id", &id.to_string())])
 }

 /// 获取歌单详情
 #[tauri::command]
 pub async fn get_playlist_detail(id: u64, state: State<'_, ApiController>) -> Result<String, String> {
-    let client = state.client.lock().await;
-    let q = state.build_query().param("id", &id.to_string());
-    client.playlist_detail(&q).await
-        .map(|r| r.body.to_string())
-        .map_err(|e| e.to_string())
+    api_call!(state, playlist_detail, params: [("id", &id.to_string())])
 }

 /// 手机号密码登录
 #[tauri::command]
 pub async fn login(query: LoginQuery, state: State<'_, ApiController>) -> Result<String, String> {
-    let client = state.client.lock().await;
+    let client = state.client.lock().unwrap().clone();
    let q = Query::new()
        .param("phone", &query.phone)
        .param("password", &query.password);
@ -169,7 +246,7 @@ pub async fn logout(state: State<'_, ApiController>) -> Result<(), String> {
 /// 获取二维码登录密钥
 #[tauri::command]
 pub async fn get_qr_key(state: State<'_, ApiController>) -> Result<String, String> {
-    let client = state.client.lock().await;
+    let client = state.client.lock().unwrap().clone();
    let q = state.build_query();
    let resp = client.login_qr_key(&q).await.map_err(|e| e.to_string())?;
    resp.body["unikey"]
@ -184,7 +261,7 @@ pub async fn create_qr(
    query: QrKeyQuery,
    state: State<'_, ApiController>,
 ) -> Result<String, String> {
-    let client = state.client.lock().await;
+    let client = state.client.lock().unwrap().clone();
    let q = state
        .build_query()
        .param("key", &query.key)
@ -200,7 +277,7 @@ pub async fn create_qr(
 /// 检查二维码扫码状态
 #[tauri::command]
 pub async fn check_qr_status(query: QrKeyQuery, state: State<'_, ApiController>) -> Result<String, String> {
-    let client = state.client.lock().await;
+    let client = state.client.lock().unwrap().clone();
    let q = state.build_query().param("key", &query.key);
    let resp = client.login_qr_check(&q).await.map_err(|e| e.to_string())?;
    if resp.body["code"].as_u64() == Some(803) && !resp.cookie.is_empty() {
@ -214,122 +291,80 @@ pub async fn check_qr_status(query: QrKeyQuery, state: State<'_, ApiController>)
 /// 获取当前登录状态
 #[tauri::command]
 pub async fn get_login_status(state: State<'_, ApiController>) -> Result<String, String> {
-    let client = state.client.lock().await;
-    let q = state.build_query();
-    client.user_account(&q).await
-        .map(|r| r.body.to_string())
-        .map_err(|e| e.to_string())
+    api_call!(state, user_account)
 }

 /// 获取用户歌单列表
 #[tauri::command]
 pub async fn user_playlist(uid: u64, state: State<'_, ApiController>) -> Result<String, String> {
-    let client = state.client.lock().await;
-    let q = state.build_query().param("uid", &uid.to_string());
-    let resp = client.user_playlist(&q).await.map_err(|e| e.to_string())?;
-    Ok(resp.body.to_string())
+    api_call!(state, user_playlist, params: [("uid", &uid.to_string())])
 }

 /// 获取每日推荐歌曲
 #[tauri::command]
 pub async fn recommend_songs(state: State<'_, ApiController>) -> Result<String, String> {
-    let client = state.client.lock().await;
-    let q = state.build_query();
-    let resp = client.recommend_songs(&q).await.map_err(|e| e.to_string())?;
-    Ok(resp.body.to_string())
+    api_call!(state, recommend_songs)
 }

 /// 获取推荐歌单
 #[tauri::command]
 pub async fn recommend_resource(state: State<'_, ApiController>) -> Result<String, String> {
-    let client = state.client.lock().await;
-    let q = state.build_query();
-    let resp = client.recommend_resource(&q).await.map_err(|e| e.to_string())?;
-    Ok(resp.body.to_string())
+    api_call!(state, recommend_resource)
 }

 /// 获取私人漫游歌曲
 #[tauri::command]
 pub async fn personal_fm(state: State<'_, ApiController>) -> Result<String, String> {
-    let client = state.client.lock().await;
-    let q = state.build_query();
-    let resp = client.personal_fm(&q).await.map_err(|e| e.to_string())?;
-    Ok(resp.body.to_string())
+    api_call!(state, personal_fm)
 }

 /// 获取歌曲详情
 #[tauri::command]
 pub async fn get_song_detail(id: String, state: State<'_, ApiController>) -> Result<String, String> {
-    let client = state.client.lock().await;
-    let q = state.build_query().param("ids", &id);
-    let resp = client.song_detail(&q).await.map_err(|e| e.to_string())?;
-    Ok(resp.body.to_string())
+    api_call!(state, song_detail, params: [("ids", &id)])
 }

+/// 用户播放记录查询参数
 #[derive(Deserialize)]
 pub struct UserRecordQuery { pub uid: u64, pub r#type: String }

+/// 喜欢/取消喜欢歌曲查询参数
 #[derive(Deserialize)]
 pub struct LikeSongQuery { pub id: u64, pub like: String }

 /// 获取喜欢的歌曲ID列表
 #[tauri::command]
 pub async fn likelist(uid: u64, state: State<'_, ApiController>) -> Result<String, String> {
-    let client = state.client.lock().await;
-    let q = state.build_query().param("uid", &uid.to_string());
-    client.likelist(&q).await
-        .map(|r| r.body.to_string())
-        .map_err(|e| e.to_string())
+    api_call!(state, likelist, params: [("uid", &uid.to_string())])
 }

 /// 获取用户播放记录
 #[tauri::command]
 pub async fn user_record(query: UserRecordQuery, state: State<'_, ApiController>) -> Result<String, String> {
-    let client = state.client.lock().await;
-    let q = state.build_query()
-        .param("uid", &query.uid.to_string())
-        .param("type", &query.r#type);
-    client.user_record(&q).await
-        .map(|r| r.body.to_string())
-        .map_err(|e| e.to_string())
+    api_call!(state, user_record, params: [("uid", &query.uid.to_string()), ("type", &query.r#type)])
 }

 /// 喜欢/取消喜欢歌曲
 #[tauri::command]
 pub async fn like_song(query: LikeSongQuery, state: State<'_, ApiController>) -> Result<String, String> {
-    let client = state.client.lock().await;
-    let q = state.build_query()
-        .param("id", &query.id.to_string())
-        .param("like", &query.like);
-    client.like(&q).await
-        .map(|r| r.body.to_string())
-        .map_err(|e| e.to_string())
+    api_call!(state, like, params: [("id", &query.id.to_string()), ("like", &query.like)])
 }

 /// 上报最近播放歌曲
 #[tauri::command]
 pub async fn record_recent_song(limit: u64, state: State<'_, ApiController>) -> Result<String, String> {
-    let client = state.client.lock().await;
-    let q = state.build_query().param("limit", &limit.to_string());
-    client.record_recent_song(&q).await
-        .map(|r| r.body.to_string())
-        .map_err(|e| e.to_string())
+    api_call!(state, record_recent_song, params: [("limit", &limit.to_string())])
 }

+/// 歌单收藏/取消收藏查询参数
 #[derive(Deserialize)]
 pub struct PlaylistSubscribeQuery { pub id: u64, pub subscribe: Option<bool> }

 /// 收藏/取消收藏歌单
 #[tauri::command]
 pub async fn playlist_subscribe(query: PlaylistSubscribeQuery, state: State<'_, ApiController>) -> Result<String, String> {
-    let client = state.client.lock().await;
    let t = if query.subscribe.unwrap_or(true) { "1" } else { "0" };
-    let q = state.build_query()
-        .param("id", &query.id.to_string())
-        .param("t", t);
-    client.playlist_subscribe(&q).await
-        .map(|r| r.body.to_string())
-        .map_err(|e| e.to_string())
+    api_call!(state, playlist_subscribe, params: [("id", &query.id.to_string()), ("t", t)])
 }

 /// 退出应用
@ -340,3 +375,523 @@ pub async fn exit_app(app_handle: tauri::AppHandle) {
        let _ = window.close();
    }
 }
+
+/// 本地歌曲信息结构体
+#[derive(serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LocalSongInfo {
+    pub id: u64,
+    pub name: String,
+    pub artist: String,
+    pub album: String,
+    pub duration: u64,
+    pub cover: Option<String>,
+    pub filename: String,
+    pub file_size: u64,
+    pub path: String,
+    pub local: bool,
+}
+
+/// 下载歌曲查询参数
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DownloadSongQuery {
+    pub id: u64,
+    pub name: String,
+    pub artist: String,
+    pub album: Option<String>,
+    pub duration: Option<u64>,
+    pub cover_url: Option<String>,
+    pub level: Option<String>,
+    pub download_path: Option<String>,
+}
+
+/// 下载歌曲到本地，支持进度回调，并保存元数据文件
+#[tauri::command]
+pub async fn download_song(
+    app_handle: tauri::AppHandle,
+    query: DownloadSongQuery,
+    state: State<'_, ApiController>,
+) -> Result<String, String> {
+    let level = query.level.as_deref().unwrap_or("standard");
+
+    let q = state.build_query()
+        .param("id", &query.id.to_string())
+        .param("level", level);
+    let client = state.client.lock().unwrap().clone();
+    let resp = client.song_url_v1(&q).await.map_err(|e| e.to_string())?;
+    let data = &resp.body["data"][0];
+    let url = data["url"].as_str().filter(|s| !s.is_empty());
+    let is_vip = data.get("freeTrialInfo").is_some_and(|v| !v.is_null());
+    if is_vip {
+        return Err("VIP歌曲无法下载".into());
+    }
+    if url.is_none() {
+        return Err("暂无下载源，可能需要 VIP 权限".into());
+    }
+    let url = url.unwrap();
+    let ext = if url.contains(".flac") { "flac" } else { "mp3" };
+    drop(client);
+
+    let download_dir = resolve_download_dir(&app_handle, query.download_path.as_deref());
+    let _ = fs::create_dir_all(&download_dir);
+
+    let safe_name = sanitize_filename(&query.name);
+    let safe_artist = sanitize_filename(&query.artist);
+    let filename = format!("{} - {}.{}", safe_artist, safe_name, ext);
+    let filepath = download_dir.join(&filename);
+
+    if filepath.exists() {
+        return Err("文件已存在".into());
+    }
+
+    let resp = reqwest::get(url).await.map_err(|e| format!("下载失败: {}", e))?;
+    let total_size = resp.content_length().unwrap_or(0);
+    let mut downloaded: u64 = 0;
+
+    let temp_path = filepath.with_extension(format!("{}.tmp", ext));
+    let mut file = fs::File::create(&temp_path).map_err(|e| format!("创建文件失败: {}", e))?;
+
+    let mut stream = resp.bytes_stream();
+    use futures_util::StreamExt;
+    let mut chunk_count: u64 = 0;
+    while let Some(chunk) = stream.next().await {
+        let chunk = chunk.map_err(|e| format!("读取失败: {}", e))?;
+        file.write_all(&chunk).map_err(|e| format!("写入失败: {}", e))?;
+        downloaded += chunk.len() as u64;
+        chunk_count += 1;
+        if chunk_count % 8 == 0 || downloaded == total_size {
+            let progress = if total_size > 0 {
+                (downloaded as f64 / total_size as f64) * 100.0
+            } else {
+                0.0
+            };
+            let _ = app_handle.emit("download-progress", json!({
+                "id": query.id,
+                "progress": progress,
+                "name": query.name,
+            }));
+        }
+    }
+    drop(file);
+
+    fs::rename(&temp_path, &filepath).map_err(|e| format!("重命名失败: {}", e))?;
+
+    let meta = json!({
+        "id": query.id,
+        "name": query.name,
+        "artist": query.artist,
+        "album": query.album,
+        "duration": query.duration,
+        "coverUrl": query.cover_url,
+        "filename": filename,
+    });
+    let meta_path = download_dir.join(format!("{}.json", query.id));
+    let mut meta_file = fs::File::create(&meta_path).map_err(|e| format!("创建元数据失败: {}", e))?;
+    meta_file.write_all(serde_json::to_string_pretty(&meta).unwrap().as_bytes())
+        .map_err(|e| format!("写入元数据失败: {}", e))?;
+
+    let _ = app_handle.emit("download-progress", json!({
+        "id": query.id,
+        "progress": 100.0,
+        "name": query.name,
+    }));
+
+    Ok(filename)
+}
+
+/// 列出本地已下载的歌曲，优先使用元数据文件补充信息
+#[tauri::command]
+pub fn list_local_songs(app_handle: tauri::AppHandle, download_path: Option<String>) -> Result<Vec<LocalSongInfo>, String> {
+    let download_dir = resolve_download_dir(&app_handle, download_path.as_deref());
+    if !download_dir.exists() {
+        return Ok(Vec::new());
+    }
+
+    let audio_exts = ["mp3", "flac", "wav", "ogg", "aac", "m4a", "wma", "opus"];
+
+    let mut meta_map: std::collections::HashMap<String, serde_json::Value> = std::collections::HashMap::new();
+    let entries = fs::read_dir(&download_dir).map_err(|e| format!("读取目录失败: {}", e))?;
+
+    for entry in entries.flatten() {
+        let path = entry.path();
+        if path.extension().map_or(false, |e| e == "json") {
+            if let Ok(content) = fs::read_to_string(&path) {
+                if let Ok(meta) = serde_json::from_str::<serde_json::Value>(&content) {
+                    if let Some(filename) = meta["filename"].as_str() {
+                        meta_map.insert(filename.to_string(), meta);
+                    }
+                }
+            }
+        }
+    }
+
+    let mut songs: Vec<LocalSongInfo> = Vec::new();
+    let entries = fs::read_dir(&download_dir).map_err(|e| format!("读取目录失败: {}", e))?;
+
+    for entry in entries.flatten() {
+        let path = entry.path();
+        let ext = path.extension().and_then(|e| e.to_str()).unwrap_or("");
+        if !audio_exts.contains(&ext.to_lowercase().as_str()) {
+            continue;
+        }
+
+        let filename = path.file_name().unwrap_or_default().to_string_lossy().to_string();
+        let file_size = fs::metadata(&path).map(|m| m.len()).unwrap_or(0);
+
+        let (title, artist, album, duration_ms, cover_b64) = read_audio_metadata(&path);
+
+        if let Some(meta) = meta_map.get(&filename) {
+            let meta_title = meta["name"].as_str().unwrap_or("");
+            let meta_artist = meta["artist"].as_str().unwrap_or("");
+            let meta_album = meta["album"].as_str().unwrap_or("");
+            let meta_duration = meta["duration"].as_u64().unwrap_or(0);
+            let meta_cover_url = meta["coverUrl"].as_str().unwrap_or("");
+
+            let final_title = if title.is_empty() { meta_title.to_string() } else { title };
+            let final_artist = if artist.is_empty() { meta_artist.to_string() } else { artist };
+            let final_album = if album.is_empty() { meta_album.to_string() } else { album };
+            let final_duration = if duration_ms == 0 { meta_duration } else { duration_ms };
+            let final_cover = cover_b64.or_else(|| {
+                if meta_cover_url.is_empty() { None } else { Some(meta_cover_url.to_string()) }
+            });
+
+            songs.push(LocalSongInfo {
+                id: meta["id"].as_u64().unwrap_or(0),
+                name: final_title,
+                artist: final_artist,
+                album: final_album,
+                duration: final_duration,
+                cover: final_cover,
+                filename,
+                file_size,
+                path: path.to_string_lossy().to_string(),
+                local: true,
+            });
+        } else {
+            let stem = path.file_stem().unwrap_or_default().to_string_lossy().to_string();
+            let (parsed_artist, parsed_name) = parse_filename(&stem);
+            let final_title = if title.is_empty() { parsed_name } else { title };
+            let final_artist = if artist.is_empty() { parsed_artist } else { artist };
+
+            let mut hasher = std::collections::hash_map::DefaultHasher::new();
+            filename.hash(&mut hasher);
+            let hash_id = hasher.finish();
+
+            songs.push(LocalSongInfo {
+                id: hash_id,
+                name: final_title,
+                artist: final_artist,
+                album,
+                duration: duration_ms,
+                cover: cover_b64,
+                filename,
+                file_size,
+                path: path.to_string_lossy().to_string(),
+                local: true,
+            });
+        }
+    }
+
+    Ok(songs)
+}
+
+/// 读取音频文件的元数据（标题、艺术家、专辑、时长、封面）
+fn read_audio_metadata(path: &PathBuf) -> (String, String, String, u64, Option<String>) {
+    match lofty::read_from_path(path) {
+        Ok(tagged_file) => {
+            let properties = tagged_file.properties();
+            let duration_ms = properties.duration().as_millis() as u64;
+
+            let tag = tagged_file.primary_tag();
+            let (title, artist, album) = if let Some(t) = tag {
+                let title = t.title().map(|s| s.to_string()).unwrap_or_default();
+                let artist = t.artist().map(|s| s.to_string()).unwrap_or_default();
+                let album = t.album().map(|s| s.to_string()).unwrap_or_default();
+                (title, artist, album)
+            } else {
+                (String::new(), String::new(), String::new())
+            };
+
+            let cover_b64 = if let Some(t) = tag {
+                if let Some(pic) = t.pictures().first() {
+                    let data = pic.data();
+                    let mime = pic.mime_type().map(|m| m.to_string()).unwrap_or_else(|| "image/jpeg".to_string());
+                    let b64 = base64::engine::general_purpose::STANDARD.encode(data);
+                    Some(format!("data:{};base64,{}", mime, b64))
+                } else {
+                    None
+                }
+            } else {
+                None
+            };
+
+            (title, artist, album, duration_ms, cover_b64)
+        }
+        Err(e) => {
+            eprintln!("[api] 读取音频元数据失败 {}: {}", path.display(), e);
+            (String::new(), String::new(), String::new(), 0, None)
+        }
+    }
+}
+
+/// 解析文件名，提取艺术家和歌曲名称（支持 "艺术家 - 歌名" 格式）
+fn parse_filename(stem: &str) -> (String, String) {
+    if let Some(pos) = stem.find(" - ") {
+        let artist = &stem[..pos];
+        let name = &stem[pos + 3..];
+        (artist.trim().to_string(), name.trim().to_string())
+    } else if let Some(pos) = stem.find('-') {
+        let artist = &stem[..pos];
+        let name = &stem[pos + 1..];
+        (artist.trim().to_string(), name.trim().to_string())
+    } else {
+        ("".to_string(), stem.trim().to_string())
+    }
+}
+
+/// 删除本地歌曲查询参数
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DeleteLocalSongQuery {
+    pub id: u64,
+    pub filename: String,
+    pub download_path: Option<String>,
+}
+
+/// 删除本地已下载的歌曲文件及其元数据
+#[tauri::command]
+pub fn delete_local_song(
+    app_handle: tauri::AppHandle,
+    query: DeleteLocalSongQuery,
+) -> Result<(), String> {
+    let download_dir = resolve_download_dir(&app_handle, query.download_path.as_deref());
+    let file_path = download_dir.join(&query.filename);
+    let meta_path = download_dir.join(format!("{}.json", query.id));
+
+    if file_path.exists() {
+        fs::remove_file(&file_path).map_err(|e| format!("删除文件失败: {}", e))?;
+    }
+    if meta_path.exists() {
+        fs::remove_file(&meta_path).map_err(|e| format!("删除元数据失败: {}", e))?;
+    }
+    Ok(())
+}
+
+/// 检查指定歌曲是否已下载到本地
+#[tauri::command]
+pub fn check_local_song(app_handle: tauri::AppHandle, id: u64, download_path: Option<String>) -> Result<bool, String> {
+    let download_dir = resolve_download_dir(&app_handle, download_path.as_deref());
+    let meta_path = download_dir.join(format!("{}.json", id));
+    Ok(meta_path.exists())
+}
+
+/// 解析下载目录，优先使用自定义路径，否则使用默认目录
+fn resolve_download_dir(app_handle: &tauri::AppHandle, custom_path: Option<&str>) -> PathBuf {
+    if let Some(path) = custom_path {
+        if !path.is_empty() {
+            return PathBuf::from(path);
+        }
+    }
+    get_default_download_dir(app_handle)
+}
+
+/// 获取默认下载目录，优先使用应用数据目录下的 downloads 子目录
+fn get_default_download_dir(app_handle: &tauri::AppHandle) -> PathBuf {
+    if let Ok(dir) = app_handle.path().app_data_dir() {
+        let download_dir = dir.join("downloads");
+        return download_dir;
+    }
+    let music_dir = dirs::audio_dir().unwrap_or_else(|| {
+        std::env::var("HOME")
+            .or_else(|_| std::env::var("USERPROFILE"))
+            .map(PathBuf::from)
+            .unwrap_or_else(|_| PathBuf::from("."))
+    });
+    music_dir.join("Nekosonic")
+}
+
+/// 获取默认下载路径字符串，供前端使用
+#[tauri::command]
+pub fn get_default_download_path(app_handle: tauri::AppHandle) -> String {
+    get_default_download_dir(&app_handle).to_string_lossy().to_string()
+}
+
+/// 清理文件名中的非法字符，将 `/ \ : * ? " < > |` 替换为下划线
+fn sanitize_filename(name: &str) -> String {
+    name.chars()
+        .map(|c| {
+            if c == '/' || c == '\\' || c == ':' || c == '*' || c == '?'
+                || c == '"' || c == '<' || c == '>' || c == '|'
+            {
+                '_'
+            } else {
+                c
+            }
+        })
+        .collect::<String>()
+        .trim()
+        .to_string()
+}
+
+/// 获取歌手详情
+#[tauri::command]
+pub async fn artist_detail(id: u64, state: State<'_, ApiController>) -> Result<String, String> {
+    api_call!(state, artist_detail, params: [("id", &id.to_string())])
+}
+
+/// 获取歌手歌曲列表
+#[tauri::command]
+pub async fn artist_songs(query: ArtistSongsQuery, state: State<'_, ApiController>) -> Result<String, String> {
+    let mut q = state.build_query().param("id", &query.id.to_string());
+    if let Some(ref order) = query.order {
+        q = q.param("order", order);
+    }
+    if let Some(limit) = query.limit {
+        q = q.param("limit", &limit.to_string());
+    }
+    if let Some(offset) = query.offset {
+        q = q.param("offset", &offset.to_string());
+    }
+    api_call!(state, artist_songs, query: q)
+}
+
+/// 歌手歌曲查询参数
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ArtistSongsQuery {
+    pub id: u64,
+    pub order: Option<String>,
+    pub limit: Option<u32>,
+    pub offset: Option<u32>,
+}
+
+/// 获取歌手专辑列表
+#[tauri::command]
+pub async fn artist_album(id: u64, limit: Option<u32>, offset: Option<u32>, state: State<'_, ApiController>) -> Result<String, String> {
+    let mut q = state.build_query().param("id", &id.to_string());
+    if let Some(limit) = limit {
+        q = q.param("limit", &limit.to_string());
+    }
+    if let Some(offset) = offset {
+        q = q.param("offset", &offset.to_string());
+    }
+    api_call!(state, artist_album, query: q)
+}
+
+/// 获取歌手简介
+#[tauri::command]
+pub async fn artist_desc(id: u64, state: State<'_, ApiController>) -> Result<String, String> {
+    api_call!(state, artist_desc, params: [("id", &id.to_string())])
+}
+
+/// 获取专辑详情
+#[tauri::command]
+pub async fn album_detail(id: u64, state: State<'_, ApiController>) -> Result<String, String> {
+    api_call!(state, album, params: [("id", &id.to_string())])
+}
+
+/// 获取最新评论
+#[tauri::command]
+pub async fn comment_new(query: CommentNewQuery, state: State<'_, ApiController>) -> Result<String, String> {
+    let mut q = state.build_query()
+        .param("type", &query.r#type.to_string())
+        .param("id", &query.id.to_string());
+    if let Some(sort_type) = query.sort_type {
+        q = q.param("sortType", &sort_type.to_string());
+    }
+    if let Some(page_no) = query.page_no {
+        q = q.param("pageNo", &page_no.to_string());
+    }
+    if let Some(page_size) = query.page_size {
+        q = q.param("pageSize", &page_size.to_string());
+    }
+    if let Some(cursor) = query.cursor {
+        q = q.param("cursor", &cursor.to_string());
+    }
+    api_call!(state, comment_new, query: q)
+}
+
+/// 最新评论查询参数
+#[derive(Deserialize)]
+pub struct CommentNewQuery {
+    pub r#type: u8,
+    pub id: u64,
+    #[serde(rename = "sortType")]
+    pub sort_type: Option<u8>,
+    #[serde(rename = "pageNo")]
+    pub page_no: Option<u32>,
+    #[serde(rename = "pageSize")]
+    pub page_size: Option<u32>,
+    pub cursor: Option<u64>,
+}
+
+/// 获取热门评论
+#[tauri::command]
+pub async fn comment_hot(query: CommentHotQuery, state: State<'_, ApiController>) -> Result<String, String> {
+    let mut q = state.build_query()
+        .param("type", &query.r#type.to_string())
+        .param("id", &query.id.to_string());
+    if let Some(limit) = query.limit {
+        q = q.param("limit", &limit.to_string());
+    }
+    if let Some(offset) = query.offset {
+        q = q.param("offset", &offset.to_string());
+    }
+    if let Some(before) = query.before {
+        q = q.param("before", &before.to_string());
+    }
+    api_call!(state, comment_hot, query: q)
+}
+
+/// 热门评论查询参数
+#[derive(Deserialize)]
+pub struct CommentHotQuery {
+    pub r#type: u8,
+    pub id: u64,
+    pub limit: Option<u32>,
+    pub offset: Option<u32>,
+    pub before: Option<u64>,
+}
+
+/// 获取评论楼层（子评论）
+#[tauri::command]
+pub async fn comment_floor(query: CommentFloorQuery, state: State<'_, ApiController>) -> Result<String, String> {
+    let mut q = state.build_query()
+        .param("parentCommentId", &query.parent_comment_id.to_string())
+        .param("type", &query.r#type.to_string())
+        .param("id", &query.id.to_string());
+    if let Some(limit) = query.limit {
+        q = q.param("limit", &limit.to_string());
+    }
+    if let Some(time) = query.time {
+        q = q.param("time", &time.to_string());
+    }
+    api_call!(state, comment_floor, query: q)
+}
+
+/// 评论楼层查询参数
+#[derive(Deserialize)]
+pub struct CommentFloorQuery {
+    #[serde(rename = "parentCommentId")]
+    pub parent_comment_id: u64,
+    pub r#type: u8,
+    pub id: u64,
+    pub limit: Option<u32>,
+    pub time: Option<u64>,
+}
+
+/// 点赞/取消点赞评论
+#[tauri::command]
+pub async fn comment_like(query: CommentLikeQuery, state: State<'_, ApiController>) -> Result<String, String> {
+    api_call!(state, comment_like, params: [("t", &query.t.to_string()), ("type", &query.r#type.to_string()), ("id", &query.id.to_string()), ("cid", &query.cid.to_string())])
+}
+
+/// 评论点赞查询参数
+#[derive(Deserialize)]
+pub struct CommentLikeQuery {
+    pub t: u8,
+    pub r#type: u8,
+    pub id: u64,
+    pub cid: u64,
+}
--- a/src-tauri/src/audio.rs
+++ b/src-tauri/src/audio.rs
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@ -1,12 +1,13 @@
 use tauri::{
    tray::{MouseButton, MouseButtonState, TrayIconBuilder, TrayIconEvent},
-    menu::{MenuBuilder, MenuItemBuilder},
+    menu::{MenuBuilder, MenuItemBuilder, PredefinedMenuItem},
    Manager, Emitter,
 };
 use std::sync::atomic::{AtomicBool, Ordering};

 mod api;
 mod audio;
+mod media_controls;
 use api::ApiController;
 use audio::AppAudio;

@ -17,7 +18,6 @@ pub fn run() {
    tauri::Builder::default()
        .setup(|app| {

-            // 注入控制器
            let app_data_dir = app.path().app_data_dir().expect("无法获取应用数据目录");
            let api_controller = ApiController::new(app_data_dir);
            app.manage(api_controller);
@ -26,36 +26,59 @@ pub fn run() {
            let app_audio = AppAudio(std::sync::Mutex::new(audio_controller));
            app.manage(app_audio);

-            // 托盘菜单
+            #[cfg(target_os = "windows")]
+            {
+                use raw_window_handle::HasWindowHandle;
+                use raw_window_handle::RawWindowHandle;
+                let hwnd = if let Some(win) = app.get_webview_window("main") {
+                    win.window_handle().ok().and_then(|h| {
+                        if let RawWindowHandle::Win32(h) = h.as_raw() {
+                            Some(h.hwnd.get() as *mut std::ffi::c_void)
+                        } else {
+                            None
+                        }
+                    })
+                } else {
+                    None
+                };
+                media_controls::start_media_controls(app.handle().clone(), hwnd);
+            }
+
+            #[cfg(not(target_os = "windows"))]
+            media_controls::start_media_controls(app.handle().clone(), None);
+
            let show = MenuItemBuilder::with_id("show", "显示窗口").build(app)?;
+            let _sep1 = PredefinedMenuItem::separator(app)?;
+            let prev = MenuItemBuilder::with_id("prev", "上一首").build(app)?;
            let play_pause = MenuItemBuilder::with_id("play_pause", "播放/暂停").build(app)?;
            let next = MenuItemBuilder::with_id("next", "下一首").build(app)?;
-            let prev = MenuItemBuilder::with_id("prev", "上一首").build(app)?;
+            let _sep2 = PredefinedMenuItem::separator(app)?;
            let quit = MenuItemBuilder::with_id("quit", "退出").build(app)?;

            let menu = MenuBuilder::new(app)
                .item(&show)
                .separator()
-                .item(&play_pause)
-                .item(&next)
-                .item(&prev)
+                .items(&[&prev, &play_pause, &next])
                .separator()
                .item(&quit)
                .build()?;

-            // 托盘图标（使用应用默认图标）
            let icon = app.default_window_icon().cloned().unwrap();

            let _tray = TrayIconBuilder::with_id("main-tray")
-                .tooltip("Nekosonic")
+                .tooltip("Nekosonic Music")
                .icon(icon)
+                .show_menu_on_left_click(false)
                .menu(&menu)
                .on_menu_event(|app, event| {
-                    let window = app.get_webview_window("main").unwrap();
                    match event.id().as_ref() {
                        "show" => {
-                            window.show().unwrap();
-                            window.set_focus().unwrap();
+                            if let Some(window) = app.get_webview_window("main") {
+                                let _ = window.show();
+                                let _ = window.unminimize();
+                                let _ = window.set_focus();
+                                let _ = app.emit("window-shown", ());
+                            }
                        }
                        "play_pause" => {
                            let _ = app.emit("tray-play-pause", ());
@ -83,16 +106,19 @@ pub fn run() {
                    } = event
                    {
                        let app = tray.app_handle();
-                        let window = app.get_webview_window("main").unwrap();
-                        window.show().unwrap();
-                        window.set_focus().unwrap();
+                        if let Some(window) = app.get_webview_window("main") {
+                            let _ = window.show();
+                            let _ = window.unminimize();
+                            let _ = window.set_focus();
+                            let _ = app.emit("window-shown", ());
+                        }
                    }
                })
                .build(app)?;

-            // 点击关闭按钮时隐藏到托盘
            let window = app.get_webview_window("main").unwrap();
            let window_clone = window.clone();
+            let app_handle = app.handle().clone();
            window.on_window_event(move |event| {
                if let tauri::WindowEvent::CloseRequested { api: close_api, .. } = event {
                    if ALLOW_EXIT.load(Ordering::SeqCst) {
@ -100,6 +126,7 @@ pub fn run() {
                    }
                    close_api.prevent_close();
                    let _ = window_clone.hide();
+                    let _ = app_handle.emit("window-hidden", ());
                }
            });

@ -132,15 +159,45 @@ pub fn run() {
            api::exit_app,

            audio::play_audio,
+            audio::play_local_audio,
            audio::pause_audio,
            audio::resume_audio,
            audio::stop_audio,
            audio::get_output_devices,
            audio::set_output_device,
            audio::seek_audio,
-            audio::set_volume
+            audio::get_audio_position,
+            audio::set_volume,
+
+            api::download_song,
+            api::list_local_songs,
+            api::delete_local_song,
+            api::check_local_song,
+            api::get_default_download_path,
+
+            api::artist_detail,
+            api::artist_songs,
+            api::artist_album,
+            api::artist_desc,
+            api::album_detail,
+            api::comment_new,
+            api::comment_hot,
+            api::comment_floor,
+            api::comment_like,
        ])
+        .plugin(tauri_plugin_process::init())
+        .plugin(tauri_plugin_updater::Builder::new().build())
        .plugin(tauri_plugin_opener::init())
+        .plugin(tauri_plugin_dialog::init())
+        .plugin(tauri_plugin_global_shortcut::Builder::new().build())
+        .plugin(tauri_plugin_single_instance::init(|app, _args, _cwd| {
+            if let Some(window) = app.get_webview_window("main") {
+                let _ = window.show();
+                let _ = window.set_focus();
+                let _ = window.unminimize();
+                let _ = app.emit("window-shown", ());
+            }
+        }))
        .run(tauri::generate_context!())
        .expect("error while running Nekosonic");
-}
+}
--- a/src-tauri/src/media_controls.rs
+++ b/src-tauri/src/media_controls.rs
@ -0,0 +1,121 @@
+use std::sync::{Arc, Mutex};
+use tauri::{AppHandle, Emitter, Listener};
+use souvlaki::{
+    MediaControlEvent, MediaControls, MediaMetadata, MediaPlayback,
+    PlatformConfig, SeekDirection,
+};
+
+struct MediaState {
+    controls: MediaControls,
+}
+
+pub fn start_media_controls(app_handle: AppHandle, hwnd: Option<*mut std::ffi::c_void>) {
+    let config = PlatformConfig {
+        dbus_name: "nekosonic",
+        display_name: "Nekosonic",
+        hwnd,
+    };
+
+    let mut controls = match MediaControls::new(config) {
+        Ok(c) => c,
+        Err(e) => {
+            eprintln!("Failed to create media controls: {e}");
+            return;
+        }
+    };
+
+    let ah = app_handle.clone();
+    if let Err(e) = controls.attach(move |event: MediaControlEvent| {
+        let cmd = match &event {
+            MediaControlEvent::Play => "Play",
+            MediaControlEvent::Pause => "Pause",
+            MediaControlEvent::Toggle => "PlayPause",
+            MediaControlEvent::Next => "Next",
+            MediaControlEvent::Previous => "Previous",
+            MediaControlEvent::Stop => "Stop",
+            MediaControlEvent::Raise => "Raise",
+            MediaControlEvent::Quit => "Quit",
+            MediaControlEvent::SetVolume(v) => {
+                let _ = ah.emit("mpris-command", format!("SetVolume:{v}"));
+                return;
+            }
+            MediaControlEvent::Seek(dir) => {
+                let offset_us = match dir {
+                    SeekDirection::Forward => 5_000_000i64,
+                    SeekDirection::Backward => -5_000_000i64,
+                };
+                let _ = ah.emit("mpris-command", format!("Seek:{offset_us}"));
+                return;
+            }
+            MediaControlEvent::SeekBy(dir, duration) => {
+                let offset_us: i64 = match dir {
+                    SeekDirection::Forward => duration.as_micros() as i64,
+                    SeekDirection::Backward => -(duration.as_micros() as i64),
+                };
+                let _ = ah.emit("mpris-command", format!("Seek:{offset_us}"));
+                return;
+            }
+            MediaControlEvent::SetPosition(pos) => {
+                let pos_us = pos.0.as_micros() as i64;
+                let _ = ah.emit("mpris-command", format!("SetPosition:{pos_us}"));
+                return;
+            }
+            MediaControlEvent::OpenUri(_) => return,
+        };
+        let _ = ah.emit("mpris-command", cmd);
+    }) {
+        eprintln!("Failed to attach media control handler: {e}");
+        return;
+    }
+
+    let state = Arc::new(Mutex::new(MediaState { controls }));
+    let state_for_listener = state.clone();
+
+    app_handle.listen("playback-state", move |event| {
+        if let Ok(data) = serde_json::from_str::<serde_json::Value>(event.payload()) {
+            let mut s = match state_for_listener.lock() {
+                Ok(s) => s,
+                Err(_) => return,
+            };
+
+            if let Some(status) = data.get("status").and_then(|v| v.as_str()) {
+                let playback = match status {
+                    "playing" => MediaPlayback::Playing { progress: None },
+                    "paused" => MediaPlayback::Paused { progress: None },
+                    _ => MediaPlayback::Stopped,
+                };
+                let _ = s.controls.set_playback(playback);
+            }
+
+            let title = data.get("title").and_then(|v| v.as_str()).unwrap_or("");
+            let album = data.get("album").and_then(|v| v.as_str()).unwrap_or("");
+            let artists = data
+                .get("artists")
+                .and_then(|v| v.as_array())
+                .map(|arr| {
+                    arr.iter()
+                        .filter_map(|a| a.as_str().map(|s| s.to_owned()))
+                        .collect::<Vec<_>>()
+                })
+                .unwrap_or_default();
+            let artist_str = artists.join(", ");
+            let cover_url = data.get("coverUrl").and_then(|v| v.as_str()).unwrap_or("");
+            let duration_us = data.get("durationUs").and_then(|v| v.as_i64()).unwrap_or(0);
+
+            let metadata = MediaMetadata {
+                title: if title.is_empty() { None } else { Some(title) },
+                album: if album.is_empty() { None } else { Some(album) },
+                artist: if artist_str.is_empty() { None } else { Some(&artist_str) },
+                cover_url: if cover_url.is_empty() { None } else { Some(cover_url) },
+                duration: if duration_us > 0 {
+                    Some(std::time::Duration::from_micros(duration_us as u64))
+                } else {
+                    None
+                },
+            };
+            let _ = s.controls.set_metadata(metadata);
+        }
+    });
+
+    std::mem::forget(state);
+}
--- a/src-tauri/tauri.conf.json
+++ b/src-tauri/tauri.conf.json
@ -1,7 +1,7 @@
 {
  "$schema": "https://schema.tauri.app/config/2",
  "productName": "Nekosonic",
-  "version": "0.2.0",
+  "version": "0.5.0",
  "identifier": "com.atdunbg.Nekosonic",
  "build": {
    "beforeDevCommand": "npm run dev",
@ -27,6 +27,7 @@
  },
  "bundle": {
    "active": true,
+    "createUpdaterArtifacts": true,
    "targets": "all",
    "icon": [
      "icons/32x32.png",
@ -34,6 +35,21 @@
      "icons/128x128@2x.png",
      "icons/icon.icns",
      "icons/icon.ico"
-    ]
+    ],
+    "windows": {
+      "webviewInstallMode": {
+        "type": "downloadBootstrapper"
+      }
+    }
+  },
+  "plugins": {
+    "updater": {
+      "active": true,
+      "endpoints": [
+        "https://github.com/atdunbg/Nekosonic-Music/releases/latest/download/latest.json"
+      ],
+      "dialog": false,
+      "pubkey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IDM1MDdCMTJCRTE3MUI4N0QKUldSOXVISGhLN0VITmM3ZkJlbjF3UGJrK3h6ellWZ2xSUG03b3d1RWlDeldSWk1nc0pic2J2MVkK"
+    }
  }
-}
+}
--- a/src/App.vue
+++ b/src/App.vue
@ -12,7 +12,7 @@
      </div>
    </div>

-    <div class="flex flex-1 overflow-hidden">
+    <div class="flex flex-1 overflow-hidden" v-if="windowVisible">
      <nav class="w-56 flex-shrink-0 flex flex-col bg-surface/80 backdrop-blur">
        <div class="flex-1 p-4 overflow-y-auto min-h-0">
          <div class="flex flex-col min-h-full">
@ -52,6 +52,12 @@
                <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><path d="M12 6v6l4 2"/></svg>
                最近播放
              </router-link>
+              <router-link to="/local-music"
+                class="flex items-center gap-3 px-3 py-2 rounded-lg transition-all duration-200 text-content-2 hover:text-content hover:bg-subtle"
+                active-class="!text-content !bg-muted">
+                <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M9 18V5l12-2v13"/><circle cx="6" cy="18" r="3"/><circle cx="18" cy="16" r="3"/></svg>
+                本地音乐
+              </router-link>
            </div>
          </div>

@ -118,7 +124,7 @@

      <main class="flex-1 overflow-y-auto pb-24">
        <router-view v-slot="{ Component }">
-          <keep-alive :max="3" include="HomeView,DiscoverView">
+          <keep-alive :max="5" :include="keepAliveInclude">
            <component :is="Component" />
          </keep-alive>
        </router-view>
@ -127,7 +133,7 @@

    <Transition name="drawer">
      <div
-        v-if="player.showRoamDrawer"
+        v-if="windowVisible && player.showRoamDrawer"
        class="fixed inset-0 z-50 flex flex-col backdrop-blur-xl bg-black/80"
      >
        <div class="h-10 flex items-center justify-between px-4 flex-shrink-0" data-tauri-drag-region>
@ -143,14 +149,49 @@
        <div class="flex-1 min-h-0 flex px-8 pb-8 gap-0">
          <div class="w-2/5 flex flex-col items-center justify-center flex-shrink-0">
            <img
-              :src="roamSong?.al?.picUrl || roamSong?.album?.picUrl"
+              v-if="roamCoverUrl && !roamCoverError"
+              :src="roamCoverUrl"
              class="w-72 h-72 rounded-3xl object-cover shadow-2xl mb-4"
+              @error="roamCoverError = true"
            />
+            <div
+              v-else
+              class="w-72 h-72 rounded-3xl bg-white/10 flex items-center justify-center shadow-2xl mb-4"
+            >
+              <svg width="64" height="64" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" class="text-white/30"><path d="M9 18V5l12-2v13"/><circle cx="6" cy="18" r="3"/><circle cx="18" cy="16" r="3"/></svg>
+            </div>
            <h1 class="text-2xl font-bold text-white text-center">{{ roamSong?.name }}</h1>
-            <p class="text-content-2 mt-2 text-center">{{ roamArtists }}</p>
+            <p class="text-content-2 mt-2 text-center">
+              <template v-for="(a, i) in roamSong?.ar || []" :key="a.id || i">
+                <span v-if="i > 0" class="text-content-3">/</span>
+                <span class="hover:text-accent-text cursor-pointer transition" @click="a.id && navigateFromDrawer({ name: 'artist', params: { id: a.id } })">{{ a.name }}</span>
+              </template>
+              <template v-if="roamSong?.al?.name">
+                <span class="text-content-3 mx-1">·</span>
+                <span class="hover:text-accent-text cursor-pointer transition" @click="roamSong!.al.id && navigateFromDrawer({ name: 'album', params: { id: roamSong!.al.id } })">{{ roamSong.al.name }}</span>
+              </template>
+            </p>
          </div>
          <div class="w-3/5 relative min-h-0 overflow-hidden flex flex-col">
-            <div ref="lyricScrollContainer" class="h-full overflow-y-auto custom-scroll px-4">
+            <div class="flex items-center gap-1 mb-3 px-4">
+              <button @click="roamTab = 'lyric'"
+                class="px-3 py-1 rounded-full text-sm transition"
+                :class="roamTab === 'lyric' ? 'bg-white/15 text-white font-medium' : 'text-white/50 hover:text-white/80'">
+                歌词
+              </button>
+              <button @click="roamTab = 'comment'"
+                class="px-3 py-1 rounded-full text-sm transition"
+                :class="roamTab === 'comment' ? 'bg-white/15 text-white font-medium' : 'text-white/50 hover:text-white/80'">
+                评论
+              </button>
+              <button v-if="hasTranslation" @click="toggleTranslation"
+                class="ml-auto px-2.5 py-1 rounded-full text-xs transition flex items-center gap-1"
+                :class="showTranslation ? 'bg-white/15 text-white font-medium' : 'text-white/40 hover:text-white/70'">
+                <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M5 8l6 6"/><path d="M4 14l6-6 2-3"/><path d="M2 5h12"/><path d="M7 2h1"/><path d="M22 22l-5-10-5 10"/><path d="M14 18h6"/></svg>
+                译
+              </button>
+            </div>
+            <div v-show="roamTab === 'lyric'" ref="lyricScrollContainer" class="flex-1 min-h-0 overflow-y-auto custom-scroll px-4">
              <div v-if="lyrics.length > 0" class="w-full max-w-lg mx-auto text-center"
                :style="{ paddingTop: roamLyricPadPx + 'px', paddingBottom: roamLyricPadPx + 'px' }">
                <p
@ -163,10 +204,14 @@
                  @mouseleave="roamLyricHovering = false"
                >
                  {{ line.text }}
+                  <span v-if="showTranslation && line.translation" class="block text-sm opacity-60 mt-1">{{ line.translation }}</span>
                </p>
              </div>
              <div v-else class="text-content-3 text-center mt-8">暂无歌词</div>
            </div>
+            <div v-show="roamTab === 'comment'" class="flex-1 min-h-0 overflow-y-auto px-4 pb-4">
+              <CommentSection v-if="roamSong" :type="0" :id="player.commentSongId || roamSong.id" :key="player.commentSongId || roamSong.id" />
+            </div>
          </div>
        </div>
      </div>
@ -175,6 +220,15 @@
    <PlayerBar v-if="player.currentSong" />
    <ToastContainer />

+    <UpdateDialog
+      :visible="updater.updateAvailable.value && !!updater.updateInfo.value"
+      :info="{ version: updater.updateInfo.value?.version || '', date: updater.updateInfo.value?.date ?? null, body: updater.updateInfo.value?.body ?? null, currentVersion: updater.currentVersion.value }"
+      :downloading="updater.downloading.value"
+      :download-progress="updater.downloadProgress.value"
+      @update="updater.downloadAndInstall()"
+      @ignore="updater.ignoreVersion(updater.updateInfo.value?.version || '')"
+    />
+
    <Transition name="fade">
      <div v-if="showCloseModal" class="fixed inset-0 z-[60] flex items-center justify-center bg-black/60 backdrop-blur-sm" @click.self="showCloseModal = false">
        <div class="bg-surface border border-line rounded-2xl shadow-2xl w-80 p-6 select-auto">
@ -224,16 +278,30 @@ import { useUserStore } from './stores/user';
 import { useSettingsStore, type CloseAction } from './stores/settings';
 import PlayerBar from './components/PlayerBar.vue';
 import ToastContainer from './components/ToastContainer.vue';
+import CommentSection from './components/CommentSection.vue';
+import UpdateDialog from './components/UpdateDialog.vue';
 import { usePlayerStore } from './stores/player';
+import { getCoverUrl } from './utils/song';
+import { useOnlineStatus } from './composables/useOnlineStatus';
+import { showToast } from './composables/useToast';
 import { useLyric } from './composables/UserLyric';
+import { useUpdater } from './composables/useUpdater';
 import { getCurrentWindow } from '@tauri-apps/api/window';
 import { listen } from '@tauri-apps/api/event';
+import { register, unregister } from '@tauri-apps/plugin-global-shortcut';

 const router = useRouter();
 const route = useRoute();
 const userStore = useUserStore();
 const player = usePlayerStore();
 const settings = useSettingsStore();
+const updater = useUpdater();
+const { isOnline } = useOnlineStatus();
+
+watch(isOnline, (val, old) => {
+  if (val && !old) showToast('网络已恢复', 'success');
+  else if (!val && old) showToast('网络已断开，部分功能不可用', 'error');
+});

 const createdPlaylists = ref<any[]>([]);
 const subPlaylists = ref<any[]>([]);
@ -242,6 +310,8 @@ const showSubPlaylists = ref(true);
 const searchQuery = ref('');
 const showCloseModal = ref(false);
 const closeDontAskAgain = ref(false);
+const windowVisible = ref(true);
+const keepAliveInclude = ref<string[]>(['HomeView', 'DiscoverView', 'FavoriteSongsView', 'DailySongsView', 'LocalMusicView']);

 watch(() => settings.theme, (val) => {
  document.documentElement.setAttribute('data-theme', val);
@ -252,11 +322,18 @@ function doSearch() {
  if (q) router.push({ path: '/discover', query: { q } });
 }

-const { lyrics, currentLyricIdx } = useLyric();
+const { lyrics, currentLyricIdx, hasTranslation, showTranslation, toggleTranslation } = useLyric();
 const lyricScrollContainer = ref<HTMLElement | null>(null);
 const roamLyricHovering = ref(false);
 const roamLyricPadPx = ref(0);
 const roamSong = computed(() => player.currentSong);
+const roamCoverError = ref(false);
+const roamTab = ref<'lyric' | 'comment'>('lyric');
+const roamCoverUrl = computed(() => {
+  if (!roamSong.value) return '';
+  return getCoverUrl(roamSong.value) || '';
+});
+watch(roamCoverUrl, () => { roamCoverError.value = false; });
 let roamResizeObserver: ResizeObserver | null = null;

 function updateRoamLyricPad() {
@ -267,6 +344,7 @@ function updateRoamLyricPad() {

 watch(() => player.showRoamDrawer, (val) => {
  if (val) {
+    roamTab.value = player.roamInitialTab;
    nextTick(() => {
      updateRoamLyricPad();
      if (roamResizeObserver) roamResizeObserver.disconnect();
@ -290,10 +368,6 @@ onBeforeUnmount(() => {
    roamResizeObserver = null;
  }
 });
-const roamArtists = computed(() => {
-  if (!roamSong.value) return '';
-  return roamSong.value.ar?.map((a: any) => a.name).join(' / ') || '';
-});

 watch(currentLyricIdx, () => {
  if (player.showRoamDrawer && !roamLyricHovering.value) {
@ -315,8 +389,8 @@ function getRoamLyricClass(idx: number): string {
    return 'roam-lyric-active text-accent-text font-semibold text-xl';
  }
  if (diff === 1) return 'text-content/70 text-lg';
-  if (diff === 2) return 'text-content-2/50 text-base';
-  return 'text-content-3/35 text-base';
+  if (diff === 2) return 'text-content-2/50 text-[1rem]';
+  return 'text-content-3/35 text-[1rem]';
 }

 function seekToRoamLyric(time: number) {
@ -325,6 +399,11 @@ function seekToRoamLyric(time: number) {
  }
 }

+function navigateFromDrawer(routeLocation: { name: string; params: any }) {
+  player.closeRoamDrawer();
+  router.push(routeLocation);
+}
+
 async function openRoamFromSidebar() {
  if (player.isFmMode) {
    player.openRoamDrawer();
@ -359,6 +438,8 @@ watch(() => userStore.isLoggedIn, (val) => {
 });

 onMounted(async () => {
+  document.addEventListener('contextmenu', (e) => e.preventDefault());
+
  if (userStore.isLoggedIn) {
    loadPlaylists();
    player.loadLikedIds();
@ -376,6 +457,16 @@ onMounted(async () => {
      });
    }
  } catch {}
+
+  updater.checkForUpdate(true);
+
+  // 恢复保存的输出设备设置
+  if(settings.outputDevice) {
+    try {
+      await invoke('set_output_device', { device: settings.outputDevice });
+    }
+    catch{}
+  }
 });

 const currentWindow = getCurrentWindow();
@ -416,14 +507,62 @@ onMounted(() => {
  const unlisten3 = listen('tray-prev', () => {
    player.prev();
  });
+  const unlisten4 = listen('window-hidden', () => {
+    windowVisible.value = false;
+    keepAliveInclude.value = [];
+  });
+  const unlisten5 = listen('window-shown', () => {
+    windowVisible.value = true;
+    keepAliveInclude.value = ['HomeView', 'DiscoverView', 'FavoriteSongsView', 'DailySongsView', 'LocalMusicView'];
+  });

  onBeforeUnmount(() => {
    unlisten1.then(fn => fn());
    unlisten2.then(fn => fn());
    unlisten3.then(fn => fn());
+    unlisten4.then(fn => fn());
+    unlisten5.then(fn => fn());
  });
 });

+async function registerGlobalShortcuts() {
+  const globalActions: Record<string, () => void> = {
+    globalPlayPause: () => player.toggle(),
+    globalPrev: () => player.prev(),
+    globalNext: () => player.next(),
+    globalVolUp: () => player.adjustVolume(5),
+    globalVolDown: () => player.adjustVolume(-5),
+  };
+  for (const [id, action] of Object.entries(globalActions)) {
+    const key = settings.shortcuts[id]?.key;
+    if (!key) continue;
+    try { await unregister(key); } catch {}
+    try {
+      await register(key, (event) => {
+        if (event.state === 'Pressed') action();
+      });
+    } catch {}
+  }
+}
+
+watch(() => settings.shortcuts, () => {
+  registerGlobalShortcuts();
+}, { deep: true });
+
+onMounted(() => {
+  registerGlobalShortcuts();
+});
+
+function parseShortcutKey(combo: string): { ctrl: boolean; alt: boolean; shift: boolean; code: string } {
+  const parts = combo.split('+');
+  return {
+    ctrl: parts.includes('Control'),
+    alt: parts.includes('Alt'),
+    shift: parts.includes('Shift'),
+    code: parts.find(p => !['Control', 'Alt', 'Shift'].includes(p)) || '',
+  };
+}
+
 onMounted(() => {
  function onKeydown(e: KeyboardEvent) {
    const el = e.target as HTMLElement;
@ -432,13 +571,26 @@ onMounted(() => {
      e.preventDefault();
      player.toggle();
    }
-    if ((e.ctrlKey || e.metaKey) && e.code === 'ArrowRight') {
-      e.preventDefault();
-      player.next();
-    }
-    if ((e.ctrlKey || e.metaKey) && e.code === 'ArrowLeft') {
-      e.preventDefault();
-      player.prev();
+
+    const localActions: Record<string, () => void> = {
+      playPause: () => player.toggle(),
+      prev: () => player.prev(),
+      next: () => player.next(),
+      volUp: () => player.adjustVolume(5),
+      volDown: () => player.adjustVolume(-5),
+    };
+    for (const [id, action] of Object.entries(localActions)) {
+      const key = settings.shortcuts[id]?.key;
+      if (!key) continue;
+      const parsed = parseShortcutKey(key);
+      const ctrlMatch = parsed.ctrl ? (e.ctrlKey || e.metaKey) : !e.ctrlKey && !e.metaKey;
+      const altMatch = parsed.alt ? e.altKey : !e.altKey;
+      const shiftMatch = parsed.shift ? e.shiftKey : !e.shiftKey;
+      if (ctrlMatch && altMatch && shiftMatch && e.code === parsed.code) {
+        e.preventDefault();
+        action();
+        return;
+      }
    }
  }
  window.addEventListener('keydown', onKeydown);
@ -460,10 +612,8 @@ onMounted(() => {
 .custom-scroll::-webkit-scrollbar { width: 0; display: none; }
 .roam-lyric-line:hover {
  background: var(--c-subtle);
-  color: var(--c-content) !important;
 }
 .roam-lyric-active:hover {
  background: var(--c-subtle) !important;
-  color: var(--c-content) !important;
 }
 </style>
--- a/src/components/CommentSection.vue
+++ b/src/components/CommentSection.vue
@ -0,0 +1,149 @@
+<template>
+  <div class="bg-subtle rounded-xl p-3" ref="scrollContainer">
+    <div v-if="loading" class="py-8 text-center text-content-2 text-sm">加载中...</div>
+
+    <div v-else-if="comments.length === 0" class="py-8 text-center">
+      <svg class="mx-auto mb-2 text-content-3" width="40" height="40" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M21 15a2 2 0 01-2 2H7l-4 4V5a2 2 0 012-2h14a2 2 0 012 2z"/></svg>
+      <p class="text-content-3 text-sm">暂无评论</p>
+    </div>
+
+    <div v-else class="space-y-3">
+      <div
+        v-for="comment in comments"
+        :key="comment.commentId"
+        class="p-3 rounded-xl bg-surface/50"
+      >
+        <div class="flex items-center gap-3">
+          <img :src="comment.user.avatarUrl" class="w-8 h-8 rounded-full object-cover flex-shrink-0" />
+          <div class="flex-1 min-w-0">
+            <p class="text-sm font-medium text-content truncate">{{ comment.user.nickname }}</p>
+            <p class="text-xs text-content-3">{{ new Date(comment.time).toLocaleDateString('zh-CN') }}</p>
+          </div>
+        </div>
+        <p class="mt-2 text-sm text-content-2 leading-relaxed">{{ comment.content }}</p>
+        <div class="mt-2 flex justify-end">
+          <button
+            @click="likeComment(comment.commentId)"
+            class="flex items-center gap-1 text-content-3 hover:text-danger transition text-xs"
+          >
+            <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78l1.06 1.06L12 21.23l7.78-7.78 1.06-1.06a5.5 5.5 0 000-7.78z"/></svg>
+            <span>{{ comment.likedCount }}</span>
+          </button>
+        </div>
+      </div>
+      <div ref="sentinel" class="h-1"></div>
+    </div>
+
+    <div v-if="loadingMore" class="py-4 text-center text-content-3 text-sm">加载中...</div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { ref, watch, onMounted, onBeforeUnmount, nextTick } from 'vue'
+import { invoke } from '@tauri-apps/api/core'
+
+const props = defineProps<{
+  type: number
+  id: number
+}>()
+
+const comments = ref<any[]>([])
+const loading = ref(false)
+const loadingMore = ref(false)
+const hasMore = ref(true)
+const pageNo = ref(1)
+const pageSize = 20
+const sentinel = ref<HTMLElement | null>(null)
+let observer: IntersectionObserver | null = null
+
+async function fetchComments(reset = false) {
+  if (reset) {
+    pageNo.value = 1
+    comments.value = []
+    hasMore.value = true
+  }
+
+  if (!hasMore.value) return
+
+  if (reset) {
+    loading.value = true
+  } else {
+    loadingMore.value = true
+  }
+
+  try {
+    const jsonStr: string = await invoke('comment_hot', {
+      query: {
+        type: props.type,
+        id: props.id,
+        limit: pageSize,
+        offset: (pageNo.value - 1) * pageSize
+      }
+    })
+    const data = JSON.parse(jsonStr)
+    const list = data.hotComments || []
+    if (reset) {
+      comments.value = list
+    } else {
+      comments.value.push(...list)
+    }
+    hasMore.value = list.length >= pageSize
+  } catch (e) {
+    console.error(e)
+  } finally {
+    loading.value = false
+    loadingMore.value = false
+  }
+}
+
+function loadMore() {
+  if (loadingMore.value || !hasMore.value) return
+  pageNo.value++
+  fetchComments()
+}
+
+async function likeComment(cid: number) {
+  try {
+    await invoke('comment_like', {
+      query: {
+        t: 1,
+        type: props.type,
+        id: props.id,
+        cid
+      }
+    })
+    const target = comments.value.find(c => c.commentId === cid)
+    if (target) {
+      target.likedCount++
+    }
+  } catch (e) {
+    console.error(e)
+  }
+}
+
+function setupObserver() {
+  if (observer) observer.disconnect()
+  observer = new IntersectionObserver((entries) => {
+    if (entries[0]?.isIntersecting) {
+      loadMore()
+    }
+  }, { rootMargin: '200px' })
+  nextTick(() => {
+    if (sentinel.value) {
+      observer!.observe(sentinel.value)
+    }
+  })
+}
+
+onMounted(() => {
+  fetchComments(true).then(() => setupObserver())
+})
+
+watch(() => props.id, () => {
+  fetchComments(true).then(() => setupObserver())
+})
+
+onBeforeUnmount(() => {
+  if (observer) observer.disconnect()
+})
+</script>
--- a/src/components/CustomSelect.vue
+++ b/src/components/CustomSelect.vue
@ -2,22 +2,22 @@
  <div class="relative" ref="container">
    <button
      @click="toggle"
-      class="flex items-center justify-between bg-subtle border border-line rounded-lg px-3 py-1.5 text-sm text-content outline-none transition min-w-[140px] hover:border-content-3 focus:border-accent focus:shadow-[0_0_0_2px_var(--c-accent-dim)]"
+      class="flex items-center justify-between bg-subtle border border-line rounded-lg px-3 py-1.5 text-sm text-content outline-none transition min-w-[140px] max-w-[320px] hover:border-content-3 focus:border-accent focus:shadow-[0_0_0_2px_var(--c-accent-dim)]"
      :class="{ 'border-accent shadow-[0_0_0_2px_var(--c-accent-dim)]': isOpen }"
    >
-      <span>{{ currentLabel }}</span>
+      <span class="truncate">{{ currentLabel }}</span>
      <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round" class="transition-transform flex-shrink-0 ml-2" :class="{ 'rotate-180': isOpen }"><polyline points="6 9 12 15 18 9"/></svg>
    </button>
    <Transition name="dropdown">
-      <div v-if="isOpen" class="absolute right-0 top-full mt-1 bg-surface border border-line rounded-lg shadow-xl z-50 py-1 min-w-full overflow-hidden">
+      <div v-if="isOpen" class="absolute right-0 top-full mt-1 bg-surface border border-line rounded-lg shadow-xl z-50 py-1 min-w-full max-w-[360px] overflow-hidden">
        <button
          v-for="(label, key) in options"
          :key="key"
          @click="select(key)"
-          class="w-full text-left px-3 py-2 text-sm transition flex items-center justify-between"
+          class="w-full text-left px-3 py-2 text-sm transition flex items-center justify-between gap-2"
          :class="modelValue === key ? 'bg-accent-dim text-accent-text' : 'text-content-2 hover:bg-subtle hover:text-content'"
        >
-          <span>{{ label }}</span>
+          <span class="truncate">{{ label }}</span>
          <svg v-if="modelValue === key" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round"><polyline points="20 6 9 17 4 12"/></svg>
        </button>
      </div>
--- a/src/components/PlayerBar.vue
+++ b/src/components/PlayerBar.vue
@ -14,19 +14,36 @@

    <div class="flex items-center px-6 h-16">
      <div class="flex items-center gap-3 w-56 min-w-0">
-        <img :src="player.currentSong?.al?.picUrl"
-          class="w-10 h-10 rounded-md object-cover flex-shrink-0 cursor-pointer hover:scale-105 transition-transform"
-          @click="player.toggleRoamDrawer()" title="全屏展示" />
+        <div v-if="getCoverUrl(player.currentSong)" class="w-10 h-10 rounded-md overflow-hidden flex-shrink-0 cursor-pointer hover:scale-105 transition-transform" @click="player.toggleRoamDrawer()" title="全屏展示">
+          <img :src="getCoverUrl(player.currentSong)" class="w-full h-full object-cover" />
+        </div>
+        <div v-else class="w-10 h-10 rounded-md flex-shrink-0 bg-muted flex items-center justify-center cursor-pointer hover:scale-105 transition-transform" @click="player.toggleRoamDrawer()" title="全屏展示">
+          <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="text-content-3"><path d="M9 18V5l12-2v13"/><circle cx="6" cy="18" r="3"/><circle cx="18" cy="16" r="3"/></svg>
+        </div>
        <div class="min-w-0 flex-1">
          <p class="text-sm font-medium truncate">{{ player.currentSong?.name }}</p>
          <p class="text-xs text-content-2 truncate">
-            {{player.currentSong?.ar?.map((a: any) => a.name).join('/')}}
+            <template v-for="(a, i) in player.currentSong?.ar || []" :key="a.id || i">
+              <span v-if="i > 0" class="text-content-3">/</span>
+              <span class="hover:text-accent-text cursor-pointer transition" @click.stop="a.id && router.push({ name: 'artist', params: { id: a.id } })">{{ a.name }}</span>
+            </template>
+            <template v-if="player.currentSong?.al?.name">
+              <span class="text-content-3 mx-1">·</span>
+              <span class="hover:text-accent-text cursor-pointer transition" @click.stop="player.currentSong!.al.id && router.push({ name: 'album', params: { id: player.currentSong!.al.id } })">{{ player.currentSong.al.name }}</span>
+            </template>
          </p>
        </div>
        <button @click="player.currentSong && player.toggleLike(player.currentSong.id)" class="flex-shrink-0 transition" :class="player.currentSong && player.isLiked(player.currentSong.id) ? 'text-danger' : 'text-content-3 hover:text-danger'">
          <svg v-if="player.currentSong && player.isLiked(player.currentSong.id)" width="16" height="16" viewBox="0 0 24 24" fill="currentColor"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78l1.06 1.06L12 21.23l7.78-7.78 1.06-1.06a5.5 5.5 0 000-7.78z"/></svg>
          <svg v-else width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78l1.06 1.06L12 21.23l7.78-7.78 1.06-1.06a5.5 5.5 0 000-7.78z"/></svg>
        </button>
+        <button v-if="player.currentSong" @click="player.openRoamDrawer('comment')" class="flex-shrink-0 text-content-3 hover:text-accent-text transition" title="评论">
+          <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M21 15a2 2 0 01-2 2H7l-4 4V5a2 2 0 012-2h14a2 2 0 012 2z"/></svg>
+        </button>
+        <button v-if="player.currentSong && !download.isDownloaded(player.currentSong!.id) && !download.isDownloading(player.currentSong!.id)" @click="download.downloadSong(player.currentSong)" class="flex-shrink-0 text-content-3 hover:text-accent-text transition" title="下载">
+          <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M21 15v4a2 2 0 01-2 2H5a2 2 0 01-2-2v-4"/><polyline points="7 10 12 15 17 10"/><line x1="12" y1="15" x2="12" y2="3"/></svg>
+        </button>
+        <svg v-if="player.currentSong && download.isDownloading(player.currentSong!.id)" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="flex-shrink-0 animate-spin text-content-3"><path d="M21 12a9 9 0 11-6.22-8.56"/></svg>
      </div>

      <div class="flex-1 flex flex-col items-center justify-center gap-1">
@ -62,11 +79,11 @@
      <div class="w-56 flex justify-end items-center gap-2">
        <div class="flex items-center gap-1">
          <button @click="toggleMute" class="text-content-2 hover:text-content transition">
-            <svg v-if="volume === 0" width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polygon points="11 5 6 9 2 9 2 15 6 15 11 19 11 5"/><line x1="23" y1="9" x2="17" y2="15"/><line x1="17" y1="9" x2="23" y2="15"/></svg>
+            <svg v-if="player.volume === 0" width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polygon points="11 5 6 9 2 9 2 15 6 15 11 19 11 5"/><line x1="23" y1="9" x2="17" y2="15"/><line x1="17" y1="9" x2="23" y2="15"/></svg>
            <svg v-else width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polygon points="11 5 6 9 2 9 2 15 6 15 11 19 11 5"/><path d="M19.07 4.93a10 10 0 010 14.14M15.54 8.46a5 5 0 010 7.07"/></svg>
          </button>
          <div class="relative w-20 h-6 flex items-center">
-            <input ref="volumeSlider" type="range" min="0" max="100" :value="volume"
+            <input ref="volumeSlider" type="range" min="0" max="100" :value="player.volume"
              :style="{ background: volumeBarBg }" @input="handleVolumeChange"
              class="vol-slider w-full h-1.5 rounded-full appearance-none cursor-pointer bg-emphasis outline-none" />
          </div>
@ -87,50 +104,100 @@
      </div>
    </div>

-    <Transition name="slide-up">
-      <div v-if="showQueuePanel"
-        class="border-t border-line bg-surface/95 backdrop-blur p-4 max-h-64 overflow-y-auto">
-        <div class="flex justify-between items-center mb-3">
-          <h3 class="text-sm font-semibold">播放列表 ({{ player.queue.length }})</h3>
-          <button @click="player.clearQueue()" class="text-xs text-danger hover:text-danger transition">清空</button>
-        </div>
-        <div class="space-y-1">
-          <div v-for="(song, idx) in player.queue" :key="song.id + '-' + idx" @click="playFromQueue(idx)" :class="[
-            'flex items-center gap-3 p-2 rounded-lg cursor-pointer transition',
-            idx === player.currentIndex ? 'bg-accent-dim text-content' : 'hover:bg-subtle text-content-2',
-          ]">
-            <span class="text-xs w-6 text-center">{{ idx + 1 }}</span>
-            <div class="flex-1 min-w-0">
-              <p class="text-xs font-medium truncate">{{ song.name }}</p>
-              <p class="text-xs text-content-3 truncate">
-                {{song.ar?.map((a: any) => a.name).join('/')}}
-              </p>
+    <Teleport to="body">
+      <Transition name="queue-fade">
+        <div v-if="showQueuePanel" class="fixed inset-0 z-[55] bg-black/40 backdrop-blur-[2px]" @click="showQueuePanel = false"></div>
+      </Transition>
+      <Transition name="queue-slide">
+        <div v-if="showQueuePanel"
+          class="fixed right-0 top-0 bottom-0 z-[56] w-[340px] bg-base/95 backdrop-blur border-l border-line flex flex-col shadow-2xl shadow-black/40">
+
+          <div class="px-5 pt-5 pb-3">
+            <div class="flex items-center justify-between">
+              <div>
+                <h3 class="text-[1rem] font-semibold text-content">播放列表</h3>
+                <p class="text-xs text-content-3 mt-0.5">{{ player.queue.length }} 首歌曲</p>
+              </div>
+              <div class="flex items-center gap-1">
+                <button @click="player.clearQueue()"
+                  class="px-2.5 py-1 text-xs text-content-3 hover:text-danger hover:bg-danger-dim rounded-lg transition">
+                  清空
+                </button>
+                <button @click="showQueuePanel = false"
+                  class="w-7 h-7 flex items-center justify-center rounded-lg text-content-3 hover:text-content hover:bg-subtle transition">
+                  <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><line x1="18" y1="6" x2="6" y2="18"/><line x1="6" y1="6" x2="18" y2="18"/></svg>
+                </button>
+              </div>
            </div>
-            <button @click.stop="player.removeFromQueue(idx)"
-              class="text-content-3 hover:text-danger transition text-sm">
-              <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><line x1="18" y1="6" x2="6" y2="18"/><line x1="6" y1="6" x2="18" y2="18"/></svg>
+          </div>
+
+          <div class="h-px mx-5 bg-line"></div>
+
+          <div ref="queueListEl" class="flex-1 overflow-y-auto px-3 py-2 relative">
+            <div v-if="player.queue.length === 0" class="flex flex-col items-center justify-center h-full text-content-4 gap-3">
+              <svg width="40" height="40" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" class="opacity-40">
+                <path d="M9 18V5l12-2v13"/><circle cx="6" cy="18" r="3"/><circle cx="18" cy="16" r="3"/>
+              </svg>
+              <p class="text-sm">播放列表为空</p>
+              <p class="text-xs text-content-4">去发现好听的音乐吧</p>
+            </div>
+
+            <SongListItem
+              v-for="(song, idx) in player.queue" :key="song.id + '-' + idx"
+              :id="'queue-item-' + idx"
+              :song="song"
+              :index="idx"
+              :is-current="idx === player.currentIndex"
+              show-playing-overlay
+              cover-size="w-9 h-9"
+              cover-size-param="?param=80y80"
+              :container-class="idx === player.currentIndex ? 'bg-muted hover:bg-muted gap-3 px-3 py-2 rounded-lg' : 'hover:bg-subtle gap-3 px-3 py-2 rounded-lg'"
+              @click="playFromQueue(idx)"
+            >
+              <template #actions>
+                <button @click.stop="player.removeFromQueue(idx)"
+                  class="w-6 h-6 flex items-center justify-center rounded-md text-content-4 hover:text-danger hover:bg-danger-dim transition opacity-0 group-hover:opacity-100 flex-shrink-0">
+                  <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><line x1="18" y1="6" x2="6" y2="18"/><line x1="6" y1="6" x2="18" y2="18"/></svg>
+                </button>
+              </template>
+            </SongListItem>
+
+            <div class="h-2"></div>
+
+            <button v-if="player.currentIndex >= 0 && player.queue.length > 0" v-show="!currentSongVisible"
+              @click="scrollToCurrent"
+              class="sticky bottom-3 float-right mr-1 w-9 h-9 flex items-center justify-center rounded-full bg-surface/90 backdrop-blur shadow-lg shadow-black/30 text-content-3 hover:text-accent-text hover:bg-accent-dim/50 transition-all duration-300"
+              title="定位到正在播放">
+              <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><line x1="22" y1="12" x2="18" y2="12"/><line x1="6" y1="12" x2="2" y2="12"/><line x1="12" y1="6" x2="12" y2="2"/><line x1="12" y1="22" x2="12" y2="18"/></svg>
            </button>
          </div>
        </div>
-      </div>
-    </Transition>
+      </Transition>
+    </Teleport>
  </div>
 </template>

 <script setup lang="ts">
-import { ref, computed, onBeforeUnmount, onMounted } from 'vue';
+import { ref, computed, watch, onBeforeUnmount, onMounted, nextTick } from 'vue';
 import { usePlayerStore, PlayMode } from '../stores/player';
+import { useDownload } from '../composables/useDownload';
 import { formatTime } from '../utils/format';
+import { getCoverUrl } from '../utils/song';
 import { invoke } from '@tauri-apps/api/core';
 import { listen } from '@tauri-apps/api/event';
+import { useRouter } from 'vue-router';
+import SongListItem from './SongListItem.vue';

+const router = useRouter();
 const player = usePlayerStore();
+const download = useDownload();
 const showQueuePanel = ref(false);
+const queueListEl = ref<HTMLElement | null>(null);
+const currentSongVisible = ref(true);
 const progressBar = ref<HTMLElement | null>(null);
 const isSeeking = ref(false);
 const previewTime = ref(0);
 const cacheProgress = ref(0);
-const volume = ref(100);
 const prevVolume = ref(100);

 let unlistenCache: (() => void) | null = null;
@ -145,7 +212,7 @@ onBeforeUnmount(() => {
  if (unlistenCache) unlistenCache();
 });

-const modeTexts = { loop: '列表循环', shuffle: '随机播放', 'repeat-one': '单曲循环' };
+const modeTexts: Record<PlayMode, string> = { loop: '列表循环', shuffle: '随机播放', 'repeat-one': '单曲循环' };
 const modeTitle = computed(() => modeTexts[player.playMode] || '列表循环');
 function togglePlayMode() {
  const modes: PlayMode[] = ['loop', 'shuffle', 'repeat-one'];
@ -154,13 +221,13 @@ function togglePlayMode() {
 }

 function toggleMute() {
-  if (volume.value > 0) {
-    prevVolume.value = volume.value;
-    volume.value = 0;
+  if (player.volume > 0) {
+    prevVolume.value = player.volume;
+    player.volume = 0;
  } else {
-    volume.value = prevVolume.value || 100;
+    player.volume = prevVolume.value || 100;
  }
-  invoke('set_volume', { vol: volume.value / 100 });
+  invoke('set_volume', { vol: player.volume / 100 });
 }

 let onDocMove: ((e: MouseEvent) => void) | null = null;
@ -218,31 +285,64 @@ function playFromQueue(index: number) {
  player.playCurrent();
 }

+function scrollToCurrent() {
+  const el = document.getElementById('queue-item-' + player.currentIndex);
+  if (el) {
+    el.scrollIntoView({ behavior: 'smooth', block: 'center' });
+  }
+}
+
+let currentSongObserver: IntersectionObserver | null = null;
+
+function setupCurrentSongObserver() {
+  if (currentSongObserver) {
+    currentSongObserver.disconnect();
+    currentSongObserver = null;
+  }
+  nextTick(() => {
+    const el = document.getElementById('queue-item-' + player.currentIndex);
+    if (!el || !queueListEl.value) return;
+    currentSongObserver = new IntersectionObserver(
+      ([entry]) => { currentSongVisible.value = entry.isIntersecting; },
+      { root: queueListEl.value, threshold: 0.5 }
+    );
+    currentSongObserver.observe(el);
+  });
+}
+
+watch(() => [showQueuePanel.value, player.currentIndex, player.queue.length], () => {
+  if (showQueuePanel.value) {
+    setupCurrentSongObserver();
+  } else {
+    if (currentSongObserver) {
+      currentSongObserver.disconnect();
+      currentSongObserver = null;
+    }
+    currentSongVisible.value = true;
+  }
+});
+
+onBeforeUnmount(() => {
+  if (currentSongObserver) {
+    currentSongObserver.disconnect();
+    currentSongObserver = null;
+  }
+});
+
 async function handleVolumeChange(e: Event) {
  const target = e.target as HTMLInputElement;
  const val = parseInt(target.value, 10);
-  volume.value = val;
+  player.volume = val;
  await invoke('set_volume', { vol: val / 100 });
 }

 const volumeBarBg = computed(() => {
-  const pct = volume.value;
+  const pct = player.volume;
  return `linear-gradient(to right, var(--c-accent) 0%, var(--c-accent) ${pct}%, var(--c-muted) ${pct}%)`;
 });
 </script>

 <style scoped>
-.slide-up-enter-active,
-.slide-up-leave-active {
-  transition: all 0.2s ease;
-}
-
-.slide-up-enter-from,
-.slide-up-leave-to {
-  opacity: 0;
-  transform: translateY(10px);
-}
-
 .vol-slider {
  -webkit-appearance: none;
  appearance: none;
@ -279,4 +379,31 @@ const volumeBarBg = computed(() => {
 .vol-slider::-webkit-slider-thumb:hover {
  transform: scale(1.2);
 }
+
+.queue-fade-enter-active,
+.queue-fade-leave-active {
+  transition: opacity 0.2s ease;
+}
+.queue-fade-enter-from,
+.queue-fade-leave-to {
+  opacity: 0;
+}
+
+.queue-slide-enter-active,
+.queue-slide-leave-active {
+  transition: transform 0.3s cubic-bezier(0.16, 1, 0.3, 1);
+}
+.queue-slide-enter-from,
+.queue-slide-leave-to {
+  transform: translateX(100%);
+}
+
+@keyframes eq-bounce-sm {
+  0%, 100% { height: 2px; }
+  50% { height: 10px; }
+}
+
+.eq-bar-sm {
+  animation: eq-bounce-sm 0.6s ease-in-out infinite;
+}
 </style>
--- a/src/components/SongItemMenu.vue
+++ b/src/components/SongItemMenu.vue
@ -0,0 +1,42 @@
+<template>
+  <div class="relative flex-shrink-0" ref="menuRef">
+    <button @click.stop="toggle" class="text-content-3 hover:text-content transition p-1 rounded-md hover:bg-subtle">
+      <svg width="16" height="16" viewBox="0 0 24 24" fill="currentColor"><circle cx="12" cy="5" r="2"/><circle cx="12" cy="12" r="2"/><circle cx="12" cy="19" r="2"/></svg>
+    </button>
+    <div v-if="open"
+      class="absolute right-0 top-full mt-1 bg-surface border border-line rounded-xl shadow-xl z-50 py-1 min-w-[120px]">
+      <button @click.stop="handleComment" class="w-full flex items-center gap-2 px-3 py-2 text-sm text-content-2 hover:bg-subtle hover:text-content transition">
+        <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M21 15a2 2 0 01-2 2H7l-4 4V5a2 2 0 012-2h14a2 2 0 012 2z"/></svg>
+        评论
+      </button>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { ref, onBeforeUnmount, onMounted } from 'vue';
+import { usePlayerStore } from '../stores/player';
+
+const player = usePlayerStore();
+const props = defineProps<{ songId: number }>();
+const open = ref(false);
+const menuRef = ref<HTMLElement | null>(null);
+
+function toggle() {
+  open.value = !open.value;
+}
+
+function handleComment() {
+  open.value = false;
+  player.openCommentForSong(props.songId);
+}
+
+function onClickOutside(e: MouseEvent) {
+  if (menuRef.value && !menuRef.value.contains(e.target as Node)) {
+    open.value = false;
+  }
+}
+
+onMounted(() => document.addEventListener('click', onClickOutside));
+onBeforeUnmount(() => document.removeEventListener('click', onClickOutside));
+</script>
--- a/src/components/SongListItem.vue
+++ b/src/components/SongListItem.vue
@ -0,0 +1,97 @@
+<template>
+  <div :class="['flex items-center gap-4 p-3 rounded-xl cursor-pointer transition group', containerClass]">
+    <slot name="index" :index="index" :is-current="isCurrent">
+      <span v-if="showIndex" class="text-xs text-content-3 w-6 text-right flex-shrink-0">{{ index + 1 }}</span>
+    </slot>
+
+    <div :class="['rounded-md overflow-hidden flex-shrink-0 relative', coverClass]">
+      <img v-if="coverSrc" :src="coverSrc" class="w-full h-full object-cover" loading="lazy" />
+      <div v-else class="w-full h-full bg-muted flex items-center justify-center">
+        <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" class="text-content-4"><path d="M9 18V5l12-2v13"/><circle cx="6" cy="18" r="3"/><circle cx="18" cy="16" r="3"/></svg>
+      </div>
+      <div v-if="isCurrent && showPlayingOverlay"
+        class="absolute inset-0 bg-black/30 flex items-center justify-center">
+        <div class="flex items-end gap-[2px] h-3">
+          <span class="eq-bar-sm w-[2px] bg-white rounded-full" style="animation-delay: 0s"></span>
+          <span class="eq-bar-sm w-[2px] bg-white rounded-full" style="animation-delay: 0.12s"></span>
+          <span class="eq-bar-sm w-[2px] bg-white rounded-full" style="animation-delay: 0.24s"></span>
+        </div>
+      </div>
+    </div>
+
+    <div class="flex-1 min-w-0">
+      <p class="text-sm font-medium truncate" :class="nameClass">{{ song.name }}</p>
+      <p class="text-xs text-content-2 truncate">
+        <template v-if="song.ar?.length">
+          <template v-for="(a, i) in song.ar" :key="a.id || i">
+            <span v-if="i > 0" class="text-content-3">/</span>
+            <span class="hover:text-accent-text cursor-pointer transition" @click.stop="a.id && router.push({ name: 'artist', params: { id: a.id } })">{{ a.name }}</span>
+          </template>
+        </template>
+        <template v-if="song.al?.name">
+          <span class="text-content-3 mx-1">·</span>
+          <span class="hover:text-accent-text cursor-pointer transition" @click.stop="song.al.id && router.push({ name: 'album', params: { id: song.al.id } })">{{ song.al.name }}</span>
+        </template>
+      </p>
+    </div>
+
+    <slot name="actions">
+      <button v-if="showLike" @click.stop="player.toggleLike(song.id)" class="text-content-3 hover:text-danger transition flex-shrink-0">
+        <svg v-if="player.isLiked(song.id)" width="16" height="16" viewBox="0 0 24 24" fill="currentColor" class="text-danger"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78l1.06 1.06L12 21.23l7.78-7.78 1.06-1.06a5.5 5.5 0 000-7.78z"/></svg>
+        <svg v-else width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78l1.06 1.06L12 21.23l7.78-7.78 1.06-1.06a5.5 5.5 0 000-7.78z"/></svg>
+      </button>
+      <button v-if="showDownload" @click.stop="download.downloadSong(song)" class="text-content-3 hover:text-accent-text transition flex-shrink-0" :title="download.isDownloaded(song.id) ? '已下载' : '下载'">
+        <svg v-if="download.isDownloading(song.id)" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="animate-spin"><path d="M21 12a9 9 0 11-6.22-8.56"/></svg>
+        <svg v-else-if="download.isDownloaded(song.id)" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="text-accent-text"><polyline points="20 6 9 17 4 12"/></svg>
+        <svg v-else width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M21 15v4a2 2 0 01-2 2H5a2 2 0 01-2-2v-4"/><polyline points="7 10 12 15 17 10"/><line x1="12" y1="15" x2="12" y2="3"/></svg>
+      </button>
+      <SongItemMenu v-if="showMenu" :song-id="song.id" />
+    </slot>
+
+    <span v-if="showDuration && song.dt" class="text-xs text-content-3 flex-shrink-0">{{ formatDuration(song.dt) }}</span>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { computed } from 'vue';
+import { useRouter } from 'vue-router';
+import { usePlayerStore } from '../stores/player';
+import { useDownload } from '../composables/useDownload';
+import { getCoverUrl, type Song } from '../utils/song';
+import { formatDuration } from '../utils/format';
+import SongItemMenu from './SongItemMenu.vue';
+
+const router = useRouter();
+const player = usePlayerStore();
+const download = useDownload();
+
+const props = withDefaults(defineProps<{
+  song: Song;
+  index: number;
+  isCurrent?: boolean;
+  showIndex?: boolean;
+  showLike?: boolean;
+  showDownload?: boolean;
+  showMenu?: boolean;
+  showDuration?: boolean;
+  showPlayingOverlay?: boolean;
+  coverSize?: string;
+  coverSizeParam?: string;
+  containerClass?: string;
+}>(), {
+  isCurrent: false,
+  showIndex: false,
+  showLike: false,
+  showDownload: false,
+  showMenu: false,
+  showDuration: false,
+  showPlayingOverlay: false,
+  coverSize: 'w-10 h-10',
+  coverSizeParam: '',
+  containerClass: 'hover:bg-subtle',
+});
+
+const coverClass = computed(() => props.coverSize);
+const coverSrc = computed(() => getCoverUrl(props.song, props.coverSizeParam));
+const nameClass = computed(() => props.isCurrent ? 'text-accent-text' : '');
+</script>
--- a/src/components/UpdateDialog.vue
+++ b/src/components/UpdateDialog.vue
@ -0,0 +1,87 @@
+<template>
+  <Transition name="fade">
+    <div v-if="visible" class="fixed inset-0 z-[70] flex items-center justify-center bg-black/60 backdrop-blur-sm" @click.self="!downloading && handleIgnore()">
+      <div class="bg-surface border border-line rounded-2xl shadow-2xl w-[440px] max-h-[80vh] flex flex-col select-auto">
+        <div class="p-6 pb-4">
+          <div class="flex items-center gap-3 mb-1">
+            <div class="w-10 h-10 rounded-xl bg-accent/15 flex items-center justify-center flex-shrink-0">
+              <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="text-accent-text"><path d="M21 15v4a2 2 0 01-2 2H5a2 2 0 01-2-2v-4"/><polyline points="7 10 12 15 17 10"/><line x1="12" y1="15" x2="12" y2="3"/></svg>
+            </div>
+            <div>
+              <h2 class="text-lg font-semibold text-content">发现新版本</h2>
+              <p class="text-xs text-content-3 mt-0.5">
+                v{{ info.currentVersion }} → <span class="text-accent-text font-medium">v{{ info.version }}</span>
+              </p>
+            </div>
+          </div>
+          <p v-if="info.date" class="text-xs text-content-3 mt-2 ml-[52px]">{{ formatDate(info.date) }}</p>
+        </div>
+
+        <div v-if="info.body" class="px-6 pb-4 flex-1 overflow-y-auto max-h-60 ml-[52px]">
+          <div class="text-sm text-content-2 leading-relaxed whitespace-pre-wrap">{{ info.body }}</div>
+        </div>
+        <div v-else class="px-6 pb-4 ml-[52px]">
+          <p class="text-sm text-content-3">暂无更新日志</p>
+        </div>
+
+        <div v-if="downloading" class="px-6 pb-2">
+          <div class="w-full bg-subtle rounded-full h-2 overflow-hidden">
+            <div class="h-full bg-accent rounded-full transition-all duration-300" :style="{ width: downloadProgress + '%' }"></div>
+          </div>
+          <p class="text-xs text-content-3 mt-1 text-center">正在下载更新 {{ downloadProgress }}%</p>
+        </div>
+
+        <div class="p-4 border-t border-line flex gap-3">
+          <button
+            @click="handleIgnore"
+            :disabled="downloading"
+            class="flex-1 py-2 rounded-lg bg-muted hover:bg-emphasis text-sm text-content-2 transition disabled:opacity-50"
+          >
+            忽略此版本
+          </button>
+          <button
+            @click="handleUpdate"
+            :disabled="downloading"
+            class="flex-1 py-2 rounded-lg bg-accent hover:bg-accent-hover text-white text-sm font-medium transition disabled:opacity-50"
+          >
+            {{ downloading ? `下载中 ${downloadProgress}%` : '立即更新' }}
+          </button>
+        </div>
+      </div>
+    </div>
+  </Transition>
+</template>
+
+<script setup lang="ts">
+import type { UpdateInfo } from '../composables/useUpdater'
+
+const props = defineProps<{
+  visible: boolean
+  info: UpdateInfo & { currentVersion: string }
+  downloading: boolean
+  downloadProgress: number
+}>()
+
+const emit = defineEmits<{
+  update: []
+  ignore: []
+}>()
+
+function handleUpdate() {
+  emit('update')
+}
+
+function handleIgnore() {
+  if (props.downloading) return
+  emit('ignore')
+}
+
+function formatDate(dateStr: string) {
+  try {
+    const d = new Date(dateStr)
+    return d.toLocaleDateString('zh-CN', { year: 'numeric', month: 'long', day: 'numeric' })
+  } catch {
+    return dateStr
+  }
+}
+</script>
--- a/src/composables/UserLyric.ts
+++ b/src/composables/UserLyric.ts
@ -1,6 +1,6 @@
 import { ref, watch } from 'vue';
 import { invoke } from '@tauri-apps/api/core';
-import { parseLrc, getCurrentLyricIndex, LyricLine } from '../utils/lyric';
+import { parseLrc, mergeTranslation, getCurrentLyricIndex, LyricLine } from '../utils/lyric';
 import { usePlayerStore } from '../stores/player';

 export function useLyric() {
@ -8,21 +8,33 @@ export function useLyric() {

  const lyrics = ref<LyricLine[]>([]);
  const currentLyricIdx = ref(-1);
+  const showTranslation = ref(true);
+  const hasTranslation = ref(false);

  watch(() => player.currentSong, async (song) => {
    if (!song) {
      lyrics.value = [];
      currentLyricIdx.value = -1;
+      hasTranslation.value = false;
      return;
    }
    try {
      const jsonStr: string = await invoke('get_lyric', { id: song.id });
      const data = JSON.parse(jsonStr);
      const lrc = data?.lrc?.lyric || '';
-      lyrics.value = lrc ? parseLrc(lrc) : [];
+      const tLrc = data?.tlyric?.lyric || '';
+      let parsed = lrc ? parseLrc(lrc) : [];
+      if (tLrc && parsed.length > 0) {
+        parsed = mergeTranslation(parsed, tLrc);
+        hasTranslation.value = parsed.some(l => l.translation);
+      } else {
+        hasTranslation.value = false;
+      }
+      lyrics.value = parsed;
      currentLyricIdx.value = -1;
    } catch {
      lyrics.value = [];
+      hasTranslation.value = false;
    }
  }, { immediate: true });

@ -34,8 +46,15 @@ export function useLyric() {
    }
  });

+  function toggleTranslation() {
+    showTranslation.value = !showTranslation.value;
+  }
+
  return {
    lyrics,
    currentLyricIdx,
+    hasTranslation,
+    showTranslation,
+    toggleTranslation,
  };
-}
+}
--- a/src/composables/useDownload.ts
+++ b/src/composables/useDownload.ts
@ -0,0 +1,136 @@
+import { reactive, watch } from 'vue';
+import { invoke } from '@tauri-apps/api/core';
+import { listen } from '@tauri-apps/api/event';
+import { useSettingsStore } from '../stores/settings';
+import { showToast } from '../composables/useToast';
+import { getCoverUrl, type Song } from '../utils/song';
+
+interface DownloadTask {
+  id: number;
+  name: string;
+  progress: number;
+}
+
+const downloadingIds = reactive<Set<number>>(new Set());
+const tasks = reactive<DownloadTask[]>([]);
+const localSongIds = reactive<Set<number>>(new Set());
+
+let listenerSetup = false;
+let storeSetup = false;
+
+async function setupDownloadListener() {
+  if (listenerSetup) return;
+  listenerSetup = true;
+  await listen<{ id: number; progress: number; name: string }>('download-progress', (event) => {
+    const { id, progress, name } = event.payload;
+    if (progress >= 100) {
+      const idx = tasks.findIndex(t => t.id === id);
+      if (idx >= 0) {
+        tasks.splice(idx, 1);
+        downloadingIds.delete(id);
+        showToast(`${name} 下载完成`, 'success');
+      }
+    } else {
+      const task = tasks.find(t => t.id === id);
+      if (task) {
+        task.progress = progress;
+      }
+    }
+  });
+}
+
+async function refreshLocalIds() {
+  try {
+    const settings = useSettingsStore();
+    const list: { id: number }[] = await invoke('list_local_songs', { downloadPath: settings.downloadPath || null });
+    localSongIds.clear();
+    for (const s of list) {
+      localSongIds.add(s.id);
+    }
+  } catch {}
+}
+
+function ensureStoreSetup() {
+  if (storeSetup) return;
+  storeSetup = true;
+  const settings = useSettingsStore();
+  refreshLocalIds();
+  watch(() => settings.downloadPath, () => {
+    refreshLocalIds();
+  });
+}
+
+function isDownloaded(songId: number): boolean {
+  return localSongIds.has(songId);
+}
+
+function isDownloading(songId: number): boolean {
+  return downloadingIds.has(songId);
+}
+
+function getDownloadProgress(songId: number): number {
+  const task = tasks.find(t => t.id === songId);
+  return task?.progress ?? 0;
+}
+
+async function downloadSong(song: Song) {
+  if (downloadingIds.has(song.id)) return;
+  if (localSongIds.has(song.id)) {
+    showToast(`${song.name} 已下载`, 'info');
+    return;
+  }
+
+  const settings = useSettingsStore();
+  const artist = song.ar?.map(a => a.name).join(' / ') || '未知';
+  const albumName = song.al?.name || null;
+  const durationVal = song.dt || null;
+  const coverUrl = getCoverUrl(song) || null;
+
+  downloadingIds.add(song.id);
+  tasks.push({ id: song.id, name: song.name, progress: 0 });
+
+  try {
+    await invoke('download_song', {
+      query: {
+        id: song.id,
+        name: song.name,
+        artist,
+        album: albumName,
+        duration: durationVal,
+        coverUrl,
+        level: settings.audioQuality,
+        downloadPath: settings.downloadPath || null,
+      },
+    });
+    localSongIds.add(song.id);
+  } catch (e: any) {
+    downloadingIds.delete(song.id);
+    const idx = tasks.findIndex(t => t.id === song.id);
+    if (idx >= 0) tasks.splice(idx, 1);
+    if (e === '文件已存在') {
+      localSongIds.add(song.id);
+      showToast(`${song.name} 已下载`, 'info');
+    } else if (e === 'VIP歌曲无法下载') {
+      showToast(`${song.name} 为 VIP 歌曲，无法下载`, 'error');
+    } else if (typeof e === 'string' && e.includes('VIP')) {
+      showToast(`${song.name} 需要 VIP 权限才能下载`, 'error');
+    } else {
+      showToast(`下载失败: ${e}`, 'error');
+    }
+  }
+}
+
+export function useDownload() {
+  setupDownloadListener();
+  ensureStoreSetup();
+  return {
+    downloadingIds,
+    tasks,
+    localSongIds,
+    isDownloaded,
+    isDownloading,
+    getDownloadProgress,
+    downloadSong,
+    refreshLocalIds,
+  };
+}
--- a/src/composables/useOnlineStatus.ts
+++ b/src/composables/useOnlineStatus.ts
@ -0,0 +1,30 @@
+import { ref, onMounted, onBeforeUnmount } from 'vue';
+
+const isOnline = ref(navigator.onLine);
+
+function update() {
+  isOnline.value = navigator.onLine;
+}
+
+let refCount = 0;
+
+export function useOnlineStatus() {
+  onMounted(() => {
+    refCount++;
+    if (refCount === 1) {
+      window.addEventListener('online', update);
+      window.addEventListener('offline', update);
+    }
+  });
+
+  onBeforeUnmount(() => {
+    refCount--;
+    if (refCount <= 0) {
+      refCount = 0;
+      window.removeEventListener('online', update);
+      window.removeEventListener('offline', update);
+    }
+  });
+
+  return { isOnline };
+}
--- a/src/composables/usePageCache.ts
+++ b/src/composables/usePageCache.ts
@ -0,0 +1,24 @@
+const cache = new Map<string, { data: any; ts: number }>();
+const TTL = 5 * 60 * 1000;
+
+export function pageCacheGet(key: string): any | null {
+  const entry = cache.get(key);
+  if (!entry) return null;
+  if (Date.now() - entry.ts > TTL) {
+    cache.delete(key);
+    return null;
+  }
+  return entry.data;
+}
+
+export function pageCacheSet(key: string, data: any) {
+  cache.set(key, { data, ts: Date.now() });
+}
+
+export function pageCacheDelete(key: string) {
+  cache.delete(key);
+}
+
+export function pageCacheInvalidate(key: string) {
+  cache.delete(key);
+}
--- a/src/composables/useUpdater.ts
+++ b/src/composables/useUpdater.ts
@ -0,0 +1,142 @@
+import { ref } from 'vue'
+import { check } from '@tauri-apps/plugin-updater'
+import { relaunch } from '@tauri-apps/plugin-process'
+import { getVersion } from '@tauri-apps/api/app'
+
+export interface UpdateInfo {
+  version: string
+  date: string | null
+  body: string | null
+}
+
+const IGNORED_VERSION_KEY = 'updater_ignored_version'
+
+export function useUpdater() {
+  const checking = ref(false)
+  const downloading = ref(false)
+  const downloadProgress = ref(0)
+  const updateAvailable = ref(false)
+  const updateInfo = ref<UpdateInfo | null>(null)
+  const currentVersion = ref('')
+  const error = ref('')
+
+  async function getCurrentVersion() {
+    try {
+      currentVersion.value = await getVersion()
+    } catch {
+      currentVersion.value = ''
+    }
+  }
+
+  function getIgnoredVersion(): string {
+    try {
+      return localStorage.getItem(IGNORED_VERSION_KEY) || ''
+    } catch {
+      return ''
+    }
+  }
+
+  function setIgnoredVersion(version: string) {
+    try {
+      localStorage.setItem(IGNORED_VERSION_KEY, version)
+    } catch {}
+  }
+
+  async function checkForUpdate(silent = false): Promise<UpdateInfo | null> {
+    if (checking.value) return null
+    checking.value = true
+    error.value = ''
+    updateAvailable.value = false
+    updateInfo.value = null
+
+    try {
+      await getCurrentVersion()
+      const result = await check()
+
+      if (!result) {
+        if (!silent) error.value = '当前已是最新版本'
+        return null
+      }
+
+      const info: UpdateInfo = {
+        version: result.version,
+        date: result.date ?? null,
+        body: result.body ?? null,
+      }
+
+      const ignored = getIgnoredVersion()
+      if (info.version === ignored && silent) {
+        return null
+      }
+
+      updateAvailable.value = true
+      updateInfo.value = info
+      return info
+    } catch (e: any) {
+      if (!silent) error.value = `检查更新失败: ${e}`
+      return null
+    } finally {
+      checking.value = false
+    }
+  }
+
+  async function downloadAndInstall() {
+    if (downloading.value) return
+    downloading.value = true
+    downloadProgress.value = 0
+    error.value = ''
+
+    try {
+      const result = await check()
+      if (!result) {
+        error.value = '未找到可用更新'
+        return
+      }
+
+      let downloaded = 0
+      let contentLength = 0
+      await result.downloadAndInstall((event) => {
+        switch (event.event) {
+          case 'Started':
+            contentLength = event.data.contentLength ?? 0
+            break
+          case 'Progress':
+            downloaded += event.data.chunkLength
+            if (contentLength > 0) {
+              downloadProgress.value = Math.round((downloaded / contentLength) * 100)
+            }
+            break
+          case 'Finished':
+            downloadProgress.value = 100
+            break
+        }
+      })
+
+      await relaunch()
+    } catch (e: any) {
+      error.value = `更新失败: ${e}`
+    } finally {
+      downloading.value = false
+    }
+  }
+
+  function ignoreVersion(version: string) {
+    setIgnoredVersion(version)
+    updateAvailable.value = false
+    updateInfo.value = null
+  }
+
+  return {
+    checking,
+    downloading,
+    downloadProgress,
+    updateAvailable,
+    updateInfo,
+    currentVersion,
+    error,
+    checkForUpdate,
+    downloadAndInstall,
+    ignoreVersion,
+    getCurrentVersion,
+  }
+}
--- a/src/router/index.ts
+++ b/src/router/index.ts
@ -6,9 +6,9 @@ import Login from '@/views/Login.vue';
 import FavoriteSongs from '@/views/FavoriteSongs.vue';
 import RecentPlays from '@/views/RecentPlays.vue';
 import DailySongs from '@/views/DailySongs.vue';
+import LocalMusic from '@/views/LocalMusic.vue';
 import Settings from '@/views/Settings.vue';

-
 const routes = [
  { path: '/', name: 'home', component: Home },
  { path: '/discover', name: 'discover', component: Discover },
@ -17,12 +17,29 @@ const routes = [
  { path: '/favorites', name: 'favorites', component: FavoriteSongs },
  { path: '/recent', name: 'recent', component: RecentPlays },
  { path: '/daily', name: 'daily', component: DailySongs },
-  { path: '/login', name: 'login', component: Login },
+  { path: '/local-music', name: 'local-music', component: LocalMusic },
+  { path: '/login', name: 'login', component: Login, meta: { guest: true } },
  { path: '/playlist/:id', name: 'playlist', component: PlaylistDetail },
+  { path: '/artist/:id', name: 'artist', component: () => import('@/views/ArtistDetail.vue') },
+  { path: '/album/:id', name: 'album', component: () => import('@/views/AlbumDetail.vue') },
  { path: '/settings', name: 'settings', component: Settings },
 ];

-export default createRouter({
+const router = createRouter({
  history: createWebHistory(),
  routes,
-});
+});
+
+router.beforeEach((to) => {
+  if (to.meta.guest) {
+    const raw = localStorage.getItem('user');
+    if (raw) {
+      try {
+        const data = JSON.parse(raw);
+        if (data?.userId) return { name: 'home' };
+      } catch {}
+    }
+  }
+});
+
+export default router;
--- a/src/stores/player.ts
+++ b/src/stores/player.ts
@ -1,38 +1,16 @@
 import { defineStore } from 'pinia';
-import { ref , watch } from 'vue';
+import { ref, watch, nextTick } from 'vue';
 import { invoke } from '@tauri-apps/api/core';
-import { normalizeSong } from '../utils/song';
+import { normalizeSong, type Song } from '../utils/song';
 import { useSettingsStore } from './settings';
 import { useUserStore } from './user';
+import { showToast } from '../composables/useToast';

 export type PlayMode = 'loop' | 'shuffle' | 'repeat-one';
+export type { Song };

-export interface Song {
-  id: number;
-  name: string;
-  ar: { name: string }[];
-  al: { picUrl: string };
-  dt?: number;
-
-  // 兼容不同接口返回的可选字段
-  album?: { picUrl?: string };
-  artists?: { name: string }[];
-  duration?: number;   // 某些接口的时长字段（单位可能是秒）
-}
-
-const cacheProgress = ref(0);
-
-// 监听 Tauri 事件（需要在适当位置初始化一次）
-import { listen } from '@tauri-apps/api/event';
-
-export function setupCacheProgressListener() {
-  listen<number>('cache-progress', (event) => {
-    cacheProgress.value = event.payload;
-  });
-}
-
-// 在 store 定义外调用 setupCacheProgressListener()，或者在应用入口调用
-
+import { listen, emit } from '@tauri-apps/api/event';
+import { getCurrentWindow } from '@tauri-apps/api/window';

 function loadRecentLocal(): Song[] {
  try {
@ -59,13 +37,34 @@ export const usePlayerStore = defineStore('player', () => {
  const queue = ref<Song[]>([]);
  const currentIndex = ref(-1);

+  const settings = useSettingsStore();
+  const volume = ref(settings.volume);
+
+  watch(volume, (val) => { settings.volume = val; });
+
  let tickInterval: ReturnType<typeof setInterval> | null = null;
+  function setTickInterval(v: ReturnType<typeof setInterval> | null) { _tickInterval = v; tickInterval = v; }

  const recentLocal = ref<Song[]>(loadRecentLocal());
  const MAX_RECENT = 200;

  const likedIds = ref<Set<number>>(loadLikedIdsFromStorage());

+  function emitPlaybackState() {
+    const song = currentSong.value;
+    const status = playing.value ? 'playing' : (song ? 'paused' : 'stopped');
+    emit('playback-state', {
+      status,
+      title: song?.name || '',
+      album: song?.al?.name || '',
+      artists: song?.ar?.map(a => a.name) || [],
+      coverUrl: song?.al?.picUrl || '',
+      durationUs: (song?.dt || 0) * 1000,
+      positionUs: Math.round(currentTime.value * 1_000_000),
+      volume: volume.value / 100,
+    });
+  }
+
  function isLiked(songId: number): boolean {
    return likedIds.value.has(songId);
  }
@ -124,9 +123,11 @@ export const usePlayerStore = defineStore('player', () => {
    fmNextCallback = null;
  }

-  // 播放私人漫游歌曲（清空队列，只播放这一首）
-  async function playFmSong(song: any) {
-    // 如果缺少时长，尝试从详情接口获取
+  let fmVipSkipCount = 0;
+  const MAX_FM_VIP_SKIP = 10;
+
+  async function playFmSong(song: Song) {
+    if (tickInterval) { clearInterval(tickInterval); setTickInterval(null); }
    if (!song.dt || song.dt === 0) {
      try {
        const jsonStr: string = await invoke('get_song_detail', { id: String(song.id) });
@ -145,30 +146,66 @@ export const usePlayerStore = defineStore('player', () => {
    currentIndex.value = -1;
    playing.value = false;

+    fmSong.value = song;
    currentSong.value = song;
    try {
-      const settings = useSettingsStore();
-      const url: string = await invoke('get_song_url', { query: { id: Number(song.id), level: settings.audioQuality } });
+      const jsonStr: string = await invoke('get_song_url', { query: { id: Number(song.id), level: settings.audioQuality, fm_mode: true } });
+      const data = JSON.parse(jsonStr);
+      const url: string | undefined = data.url;
      if (!url) throw new Error('无播放源');
+
+      if (data.freeTrialInfo) {
+        console.warn('FM VIP 试听歌曲，自动跳过', song.name);
+        showToast(`${song.name} 为 VIP 试听，已跳过`, 'info');
+        fmVipSkipCount++;
+        if (fmVipSkipCount >= MAX_FM_VIP_SKIP) {
+          console.warn('FM 连续跳过 VIP 歌曲过多，停止');
+          fmVipSkipCount = 0;
+          disableFmMode();
+          return;
+        }
+        if (fmNextCallback) {
+          fmNextCallback();
+        } else {
+          disableFmMode();
+        }
+        return;
+      }
+
+      fmVipSkipCount = 0;
      await invoke('play_audio', { url });
+      await waitForAudioStart();
      playing.value = true;
      duration.value = (song.dt || 0) / 1000;
      currentTime.value = 0;
      startTick();
      addRecent(song);
+      emitPlaybackState();
    } catch (e) {
      console.error('FM播放失败', e);
      playing.value = false;
+      if (fmNextCallback) {
+        fmNextCallback();
+      } else {
+        disableFmMode();
+      }
    }
  }

-  // 播放指定歌曲（如果不在队列中则加入并切换）
  async function play(song: Song) {
    disableFmMode();

    const idx = queue.value.findIndex(s => s.id === song.id);
+    if (idx !== -1 && idx === currentIndex.value && currentSong.value?.id === song.id) {
+      if (!playing.value) {
+        await invoke('resume_audio');
+        playing.value = true;
+        startTick();
+      }
+      return;
+    }
+
    if (idx === -1) {
-      // 未在队列中，添加到队列并播放该位置
      queue.value.push(song);
      currentIndex.value = queue.value.length - 1;
    } else {
@ -177,7 +214,40 @@ export const usePlayerStore = defineStore('player', () => {
    await playCurrent();
  }

+  async function playFromList(songs: Song[], startIndex: number) {
+    disableFmMode();
+    if (songs.length === 0) return;
+
+    const targetSong = songs[startIndex];
+    if (targetSong && currentSong.value?.id === targetSong.id && currentIndex.value >= 0) {
+      const sameQueue = queue.value.length === songs.length
+        && queue.value.every((s, i) => s.id === songs[i].id);
+      if (sameQueue) {
+        if (!playing.value) {
+          await invoke('resume_audio');
+          playing.value = true;
+          startTick();
+        }
+        return;
+      }
+    }
+
+    queue.value = [...songs];
+    currentIndex.value = Math.max(0, Math.min(startIndex, songs.length - 1));
+    await playCurrent();
+  }
+
+  let vipSkipCount = 0;
+  const MAX_VIP_SKIP = 10;
+
+  function waitForAudioStart(): Promise<void> {
+    return new Promise<void>((resolve) => {
+      _audioStartedResolve = resolve;
+    });
+  }
+
  async function playCurrent() {
+    if (tickInterval) { clearInterval(tickInterval); setTickInterval(null); }
    const song = queue.value[currentIndex.value];
    if (!song?.id) {
      console.error('无效的歌曲数据', song);
@ -185,40 +255,99 @@ export const usePlayerStore = defineStore('player', () => {
    }

    try {
-      // 重置状态
      currentSong.value = song;
      playing.value = false;
      currentTime.value = 0;
      duration.value = (song.dt || 0) / 1000;

-      const settings = useSettingsStore();
-      const url: string = await invoke('get_song_url', { query: { id: Number(song.id), level: settings.audioQuality } });
+      if (song.localPath) {
+        await invoke('play_local_audio', { path: song.localPath });
+        await waitForAudioStart();
+        playing.value = true;
+      startTick();
+      addRecent(song);
+      emitPlaybackState();
+      return;
+    }
+
+      const jsonStr: string = await invoke('get_song_url', { query: { id: Number(song.id), level: settings.audioQuality } });
+      const data = JSON.parse(jsonStr);
+      const url: string | undefined = data.url;
+
      if (!url) {
        console.error('未获取到有效播放地址', song);
        return;
      }

+      if (data.freeTrialInfo) {
+        console.warn('VIP 试听歌曲，自动跳过', song.name);
+        showToast(`${song.name} 为 VIP 试听，已跳过`, 'info');
+        vipSkipCount++;
+        if (vipSkipCount >= MAX_VIP_SKIP) {
+          console.warn('连续跳过 VIP 歌曲过多，停止跳过');
+          vipSkipCount = 0;
+          return;
+        }
+        next();
+        return;
+      }
+
      await invoke('play_audio', { url });
+      await waitForAudioStart();
      playing.value = true;
      startTick();
      addRecent(song);
+      vipSkipCount = 0;
+      emitPlaybackState();
    } catch (e) {
      console.error('播放失败', e);
      playing.value = false;
    }
  }

+  let onSeekStart: (() => void) | null = null;
+
  function startTick() {
    if (tickInterval) clearInterval(tickInterval);
-    tickInterval = setInterval(() => {
+    let seekGuard = false;
+    onSeekStart = () => { seekGuard = true; };
+    let syncCounter = 1;
+    let lastSyncPos = -1;
+    let backendFrozen = false;
+    setTickInterval(setInterval(async () => {
      if (playing.value && duration.value > 0) {
-        currentTime.value += 0.25;
-        if (currentTime.value >= duration.value) {
+        if (seekGuard) return;
+        syncCounter++;
+        if (syncCounter >= 2) {
+          syncCounter = 0;
+          try {
+            const pos = await invoke<number>('get_audio_position');
+            if (pos >= currentTime.value - 0.5) {
+              currentTime.value = pos;
+            }
+            if (lastSyncPos < 0) {
+              lastSyncPos = pos;
+            } else if (pos <= lastSyncPos + 0.05) {
+              backendFrozen = true;
+              lastSyncPos = pos;
+            } else {
+              backendFrozen = false;
+              lastSyncPos = pos;
+            }
+          } catch {}
+        } else {
+          if (!backendFrozen) {
+            const next = currentTime.value + 0.25;
+            if (next <= duration.value) {
+              currentTime.value = next;
+            }
+          }
+        }
+        if (currentTime.value > duration.value) {
          currentTime.value = duration.value;
-          next(); // 自动下一首
        }
      }
-    }, 250);
+    }, 250));
  }

  async function toggle() {
@ -229,6 +358,7 @@ export const usePlayerStore = defineStore('player', () => {
      await invoke('resume_audio');
      playing.value = true;
    }
+    emitPlaybackState();
  }

  async function stop() {
@ -236,8 +366,9 @@ export const usePlayerStore = defineStore('player', () => {
    playing.value = false;
    currentSong.value = null;
    currentTime.value = 0;
-    if (tickInterval) clearInterval(tickInterval);
-    disableFmMode(); // 停止时退出漫游
+    if (tickInterval) { clearInterval(tickInterval); setTickInterval(null); }
+    disableFmMode();
+    emitPlaybackState();
  }


@ -248,7 +379,6 @@ export const usePlayerStore = defineStore('player', () => {
    playCurrent();
  }

-  // 批量添加歌曲到队列并播放第一首（用于“播放全部”）
  async function playAll(songs: Song[]) {
    if (songs.length === 0) return;
    queue.value = [...songs];
@ -260,22 +390,17 @@ export const usePlayerStore = defineStore('player', () => {
    if (index < 0 || index >= queue.value.length) return;
    const isCurrent = index === currentIndex.value;
    if (isCurrent) {
-      // 如果移除的是当前正在播放的歌曲，先停止，然后调整索引
      stop();
      queue.value.splice(index, 1);
-      // 如果队列变空，则重置
      if (queue.value.length === 0) {
        currentIndex.value = -1;
        return;
      }
-      // 保持索引不变，但如果删的是最后一个，索引需要退一位
      if (currentIndex.value >= queue.value.length) {
        currentIndex.value = queue.value.length - 1;
      }
-      // 不自动播放，等用户手动选择
    } else {
      queue.value.splice(index, 1);
-      // 调整当前索引
      if (index < currentIndex.value) {
        currentIndex.value -= 1;
      }
@ -290,22 +415,30 @@ export const usePlayerStore = defineStore('player', () => {

  async function seek(time: number) {
    try {
-      await invoke('seek_audio', { time });
      currentTime.value = time;
+      if (onSeekStart) onSeekStart();
+      await invoke('seek_audio', { time });
+      startTick();
+      emitPlaybackState();
    } catch (e) {
      console.error('seek 失败', e);
    }
  }

+  async function adjustVolume(delta: number) {
+    const newVol = Math.max(0, Math.min(100, volume.value + delta));
+    volume.value = newVol;
+    await invoke('set_volume', { vol: newVol / 100 });
+    emitPlaybackState();
+  }
+

-  // 在 defineStore 内部添加
  const playMode = ref<PlayMode>('loop');

  function setPlayMode(mode: PlayMode) {
    playMode.value = mode;
  }

-  // 重写 next() 以根据模式选择下一首
  function next() {
    if (isFmMode.value && fmNextCallback) {
      fmNextCallback();
@ -316,11 +449,9 @@ export const usePlayerStore = defineStore('player', () => {
    let nextIndex: number;
    switch (playMode.value) {
      case 'repeat-one':
-        // 单曲循环，不改变索引，只重新播放当前
        playCurrent();
        return;
      case 'shuffle':
-        // 随机下一首，且不与当前重复（除非只剩一首）
        if (queue.value.length === 1) {
          nextIndex = 0;
        } else {
@ -331,7 +462,6 @@ export const usePlayerStore = defineStore('player', () => {
        break;
      case 'loop':
      default:
-        // 顺序循环
        nextIndex = (currentIndex.value + 1) % queue.value.length;
        break;
    }
@ -340,9 +470,18 @@ export const usePlayerStore = defineStore('player', () => {
  }

  const showRoamDrawer = ref(false);
+  const roamInitialTab = ref<'lyric' | 'comment'>('lyric');
+  const commentSongId = ref<number | null>(null);

-  function openRoamDrawer() {
+  function openRoamDrawer(tab: 'lyric' | 'comment' = 'lyric') {
+    roamInitialTab.value = tab;
    showRoamDrawer.value = true;
+    nextTick(() => { roamInitialTab.value = 'lyric'; });
+  }
+
+  function openCommentForSong(songId: number) {
+    commentSongId.value = songId;
+    openRoamDrawer('comment');
  }

  function closeRoamDrawer() {
@ -360,7 +499,7 @@ export const usePlayerStore = defineStore('player', () => {
    const songs = data.data || data;
    if (songs && songs.length > 0) {
      const song = normalizeSong(songs[0]);
-      enableFmMode(() => loadFirstFmSong()); // 下一首回调
+      enableFmMode(() => loadFirstFmSong());
      await playFmSong(song);
      return true;
    }
@ -372,7 +511,7 @@ export const usePlayerStore = defineStore('player', () => {


 // -------- FM 专属状态 --------
-const fmSong = ref<any>(null);
+const fmSong = ref<Song | null>(null);
 const fmPlaying = ref(false);

 async function loadFm() {
@ -383,10 +522,9 @@ async function loadFm() {
    if (songs && songs.length > 0) {
      const song = normalizeSong(songs[0]);
      fmSong.value = song;
-      enableFmMode(nextFm);      // 设置下一首回调为 store 内的 nextFm
-      await playFmSong(song);   // 使用 FM 专用播放方法
+      enableFmMode(nextFm);
+      await playFmSong(song);
      fmPlaying.value = true;
-      // showRoamDrawer.value = true; // 自动打开全屏抽屉
    }
  } catch (e) {
    console.error('FM加载失败', e);
@ -396,17 +534,13 @@ async function loadFm() {
 async function toggleFm() {
  if (!fmSong.value) return;
  if (fmPlaying.value) {
-    // 当前 FM 正在播放，切换暂停/恢复
-    await toggle(); // 全局暂停/播放
+    await toggle();
    fmPlaying.value = playing.value;
  } else {
-    // FM 处于暂停状态，或者当前被其他歌曲打断
    if (currentSong.value?.id === fmSong.value.id) {
-      // FM 歌曲还是当前歌曲，直接恢复
      await toggle();
      fmPlaying.value = playing.value;
    } else {
-      // 当前播放的是其他歌曲，重新以 FM 模式播放 FM 歌曲
      enableFmMode(nextFm);
      await playFmSong(fmSong.value);
      fmPlaying.value = true;
@ -415,20 +549,71 @@ async function toggleFm() {
 }

 async function nextFm() {
-  await loadFm(); // 加载下一首 FM 歌曲
+  await loadFm();
 }

-// 监听全局播放变化，若用户选择了非 FM 歌曲，自动退出 FM 状态
+let _audioStartedResolve: (() => void) | null = null;
+let _tickInterval: ReturnType<typeof setInterval> | null = null;
+
+listen('audio-started', () => {
+  if (_audioStartedResolve) {
+    _audioStartedResolve();
+    _audioStartedResolve = null;
+  }
+});
+
+listen('audio-ended', () => {
+  if (_tickInterval) { clearInterval(_tickInterval); _tickInterval = null; }
+  const player = usePlayerStore();
+  player.next();
+});
+
+listen<string>('mpris-command', (event) => {
+  const cmd = event.payload;
+  const player = usePlayerStore();
+  if (cmd === 'Next') {
+    player.next();
+  } else if (cmd === 'Previous') {
+    player.prev();
+  } else if (cmd === 'PlayPause') {
+    player.toggle();
+  } else if (cmd === 'Play') {
+    if (!player.playing) player.toggle();
+  } else if (cmd === 'Pause') {
+    if (player.playing) player.toggle();
+  } else if (cmd === 'Stop') {
+    player.stop();
+  } else if (cmd.startsWith('SetVolume:')) {
+    const vol = parseFloat(cmd.slice(10));
+    if (!isNaN(vol)) {
+      player.volume = Math.round(vol * 100);
+      invoke('set_volume', { vol }).catch(() => {});
+    }
+  } else if (cmd.startsWith('Seek:')) {
+    const offsetUs = parseInt(cmd.slice(5), 10);
+    const offsetSec = offsetUs / 1_000_000;
+    const newPos = Math.max(0, Math.min(player.currentTime + offsetSec, player.duration));
+    player.seek(newPos);
+  } else if (cmd.startsWith('SetPosition:')) {
+    const posUs = parseInt(cmd.slice(13), 10);
+    const posSec = posUs / 1_000_000;
+    player.seek(posSec);
+  } else if (cmd === 'Raise') {
+    getCurrentWindow().show().catch(() => {});
+    getCurrentWindow().setFocus().catch(() => {});
+  } else if (cmd === 'Quit') {
+    getCurrentWindow().close().catch(() => {});
+  }
+});
+
 watch(currentSong, (newSong) => {
  if (isFmMode.value && newSong?.id !== fmSong.value?.id) {
    fmPlaying.value = false;
-    // 注意：不调用 disableFmMode，因为可能只是临时切歌，但卡片需要知道 FM 已停止
-    disableFmMode(); // 退出 FM 模式，让上一首按钮恢复
+    disableFmMode();
  }
 });

 watch(playing, (val) => {
-  // 只有当前正在播放的是 FM 歌曲时，才同步 fmPlaying
  if (currentSong.value?.id === fmSong.value?.id) {
    fmPlaying.value = val;
  } else {
@ -451,6 +636,7 @@ watch(playing, (val) => {
    playFmSong,
    setPlayMode,
    play,
+    playFromList,
    playAll,
    toggle,
    stop,
@ -458,6 +644,8 @@ watch(playing, (val) => {
    next,
    seek,
    playCurrent,
+    volume,
+    adjustVolume,

    removeFromQueue,
    clearQueue,
@ -470,6 +658,9 @@ watch(playing, (val) => {
    toggleLike,

    showRoamDrawer,
+    roamInitialTab,
+    commentSongId,
+    openCommentForSong,
    openRoamDrawer,
    closeRoamDrawer,
    toggleRoamDrawer,
@ -481,4 +672,4 @@ watch(playing, (val) => {
    toggleFm,
    nextFm,
  };
-});
+});
--- a/src/stores/settings.ts
+++ b/src/stores/settings.ts
@ -2,9 +2,29 @@ import { defineStore } from 'pinia';
 import { ref, watch } from 'vue';

 export type AudioQuality = 'standard' | 'higher' | 'exhigh' | 'lossless' | 'hires';
-export type ThemeMode = 'dark' | 'light';
+export type ThemeName = 'blue' | 'green' | 'rose' | 'violet' | 'orange' | 'cyan' | 'pink';
 export type CloseAction = 'ask' | 'minimize' | 'exit';

+export const themeLabels: Record<ThemeName, string> = {
+  blue: '天蓝',
+  green: '翠绿',
+  rose: '玫红',
+  violet: '紫罗兰',
+  orange: '橙色',
+  cyan: '青色',
+  pink: '粉色',
+};
+
+export const themeColors: Record<ThemeName, string> = {
+  blue: '#3b82f6',
+  green: '#22c55e',
+  rose: '#f43f5e',
+  violet: '#8b5cf6',
+  orange: '#f97316',
+  cyan: '#06b6d4',
+  pink: '#ec4899',
+};
+
 export const qualityLabels: Record<AudioQuality, string> = {
  standard: '标准',
  higher: '较高',
@ -19,23 +39,60 @@ export const closeActionLabels: Record<CloseAction, string> = {
  exit: '直接退出',
 };

+export interface ShortcutBinding {
+  key: string;
+  label: string;
+}
+
+export const defaultShortcuts: Record<string, ShortcutBinding> = {
+  playPause: { key: 'Control+KeyP', label: '播放/暂停' },
+  prev: { key: 'Control+ArrowLeft', label: '上一首' },
+  next: { key: 'Control+ArrowRight', label: '下一首' },
+  volUp: { key: 'Control+ArrowUp', label: '音量增加' },
+  volDown: { key: 'Control+ArrowDown', label: '音量减小' },
+  globalPlayPause: { key: 'Control+Alt+KeyP', label: '播放/暂停（全局）' },
+  globalPrev: { key: 'Control+Alt+ArrowLeft', label: '上一首（全局）' },
+  globalNext: { key: 'Control+Alt+ArrowRight', label: '下一首（全局）' },
+  globalVolUp: { key: 'Control+Alt+ArrowUp', label: '音量增加（全局）' },
+  globalVolDown: { key: 'Control+Alt+ArrowDown', label: '音量减小（全局）' },
+};
+
 interface SettingsData {
  audioQuality: AudioQuality;
  downloadPath: string;
-  theme: ThemeMode;
+  theme: ThemeName;
  closeAction: CloseAction;
+  shortcuts: Record<string, ShortcutBinding>;
+  outputDevice: string | null;
+  volume: number;
 }

 function loadSettings(): SettingsData {
  try {
    const raw = localStorage.getItem('app_settings');
-    if (raw) return JSON.parse(raw);
+    if (raw) {
+      const parsed = JSON.parse(raw);
+      const theme = parsed.theme || parsed.accentColor || 'blue';
+      const validThemes: ThemeName[] = ['blue', 'green', 'rose', 'violet', 'orange', 'cyan', 'pink'];
+      return {
+        audioQuality: parsed.audioQuality || 'standard',
+        downloadPath: parsed.downloadPath || '',
+        theme: validThemes.includes(theme) ? theme : 'blue',
+        closeAction: parsed.closeAction || 'ask',
+        shortcuts: { ...defaultShortcuts, ...(parsed.shortcuts || {}) },
+        outputDevice: parsed.outputDevice || null,
+        volume: typeof parsed.volume === 'number' ? parsed.volume : 100,
+      };
+    }
  } catch {}
  return {
    audioQuality: 'standard',
    downloadPath: '',
-    theme: 'dark',
+    theme: 'blue',
    closeAction: 'ask',
+    shortcuts: { ...defaultShortcuts },
+    outputDevice: null,
+    volume: 100,
  };
 }

@ -44,8 +101,11 @@ export const useSettingsStore = defineStore('settings', () => {

  const audioQuality = ref<AudioQuality>(saved.audioQuality);
  const downloadPath = ref<string>(saved.downloadPath);
-  const theme = ref<ThemeMode>(saved.theme);
+  const theme = ref<ThemeName>(saved.theme);
  const closeAction = ref<CloseAction>(saved.closeAction || 'ask');
+  const shortcuts = ref<Record<string, ShortcutBinding>>(saved.shortcuts);
+  const outputDevice = ref<string | null>(saved.outputDevice);
+  const volume = ref<number>(saved.volume);

  function setAudioQuality(q: AudioQuality) {
    audioQuality.value = q;
@ -55,7 +115,7 @@ export const useSettingsStore = defineStore('settings', () => {
    downloadPath.value = p;
  }

-  function setTheme(t: ThemeMode) {
+  function setTheme(t: ThemeName) {
    theme.value = t;
  }

@ -63,12 +123,37 @@ export const useSettingsStore = defineStore('settings', () => {
    closeAction.value = a;
  }

-  watch([audioQuality, downloadPath, theme, closeAction], () => {
+  function setShortcut(id: string, key: string) {
+    shortcuts.value = { ...shortcuts.value, [id]: { ...shortcuts.value[id], key } };
+  }
+
+  function resetShortcuts() {
+    shortcuts.value = { ...defaultShortcuts };
+  }
+
+  function setOutputDevice(device: string | null) {
+    outputDevice.value = device;
+  }
+
+  function resetAll() {
+    audioQuality.value = 'standard';
+    downloadPath.value = '';
+    theme.value = 'blue';
+    closeAction.value = 'ask';
+    shortcuts.value = { ...defaultShortcuts };
+    outputDevice.value = null;
+    volume.value = 100;
+  }
+
+  watch([audioQuality, downloadPath, theme, closeAction, shortcuts, outputDevice, volume], () => {
    const data: SettingsData = {
      audioQuality: audioQuality.value,
      downloadPath: downloadPath.value,
      theme: theme.value,
      closeAction: closeAction.value,
+      shortcuts: shortcuts.value,
+      outputDevice: outputDevice.value,
+      volume: volume.value,
    };
    localStorage.setItem('app_settings', JSON.stringify(data));
  }, { deep: true });
@ -78,9 +163,16 @@ export const useSettingsStore = defineStore('settings', () => {
    downloadPath,
    theme,
    closeAction,
+    shortcuts,
+    outputDevice,
+    volume,
    setAudioQuality,
    setDownloadPath,
    setTheme,
    setCloseAction,
+    setOutputDevice,
+    setShortcut,
+    resetShortcuts,
+    resetAll,
  };
 });
--- a/src/style.css
+++ b/src/style.css
@ -23,18 +23,19 @@
 }

@layer base {
-  :root {
-    --c-bg: #030712;
-    --c-surface: #111827;
-    --c-subtle: rgba(255, 255, 255, 0.05);
-    --c-muted: rgba(255, 255, 255, 0.10);
-    --c-emphasis: rgba(255, 255, 255, 0.18);
+  :root,
+  [data-theme="green"] {
+    --c-bg: #020c06;
+    --c-surface: #0a1a10;
+    --c-subtle: rgba(34, 197, 94, 0.06);
+    --c-muted: rgba(34, 197, 94, 0.10);
+    --c-emphasis: rgba(34, 197, 94, 0.18);
    --c-content: #ffffff;
    --c-content-2: #9ca3af;
    --c-content-3: #6b7280;
    --c-content-4: #4b5563;
-    --c-line: rgba(255, 255, 255, 0.10);
-    --c-line-2: rgba(255, 255, 255, 0.05);
+    --c-line: rgba(255, 255, 255, 0.08);
+    --c-line-2: rgba(255, 255, 255, 0.04);
    --c-accent: #22c55e;
    --c-accent-hover: #16a34a;
    --c-accent-text: #4ade80;
@ -45,26 +46,136 @@
    --c-info: #3b82f6;
  }

-  [data-theme="light"] {
-    --c-bg: #f3f4f6;
-    --c-surface: #ffffff;
-    --c-subtle: rgba(0, 0, 0, 0.04);
-    --c-muted: rgba(0, 0, 0, 0.08);
-    --c-emphasis: rgba(0, 0, 0, 0.12);
-    --c-content: #111827;
-    --c-content-2: #4b5563;
+  [data-theme="rose"] {
+    --c-bg: #0c0206;
+    --c-surface: #1a0a10;
+    --c-subtle: rgba(244, 63, 94, 0.06);
+    --c-muted: rgba(244, 63, 94, 0.10);
+    --c-emphasis: rgba(244, 63, 94, 0.18);
+    --c-content: #ffffff;
+    --c-content-2: #9ca3af;
    --c-content-3: #6b7280;
-    --c-content-4: #9ca3af;
-    --c-line: rgba(0, 0, 0, 0.10);
-    --c-line-2: rgba(0, 0, 0, 0.05);
-    --c-accent: #16a34a;
-    --c-accent-hover: #15803d;
-    --c-accent-text: #16a34a;
-    --c-accent-dim: rgba(22, 163, 74, 0.15);
-    --c-danger: #dc2626;
-    --c-danger-dim: rgba(220, 38, 38, 0.15);
-    --c-warning: #ca8a04;
-    --c-info: #2563eb;
+    --c-content-4: #4b5563;
+    --c-line: rgba(255, 255, 255, 0.08);
+    --c-line-2: rgba(255, 255, 255, 0.04);
+    --c-accent: #f43f5e;
+    --c-accent-hover: #e11d48;
+    --c-accent-text: #fb7185;
+    --c-accent-dim: rgba(244, 63, 94, 0.20);
+    --c-danger: #ef4444;
+    --c-danger-dim: rgba(239, 68, 68, 0.20);
+    --c-warning: #eab308;
+    --c-info: #3b82f6;
+  }
+
+  [data-theme="blue"] {
+    --c-bg: #02060c;
+    --c-surface: #0a101a;
+    --c-subtle: rgba(59, 130, 246, 0.06);
+    --c-muted: rgba(59, 130, 246, 0.10);
+    --c-emphasis: rgba(59, 130, 246, 0.18);
+    --c-content: #ffffff;
+    --c-content-2: #9ca3af;
+    --c-content-3: #6b7280;
+    --c-content-4: #4b5563;
+    --c-line: rgba(255, 255, 255, 0.08);
+    --c-line-2: rgba(255, 255, 255, 0.04);
+    --c-accent: #3b82f6;
+    --c-accent-hover: #2563eb;
+    --c-accent-text: #60a5fa;
+    --c-accent-dim: rgba(59, 130, 246, 0.20);
+    --c-danger: #ef4444;
+    --c-danger-dim: rgba(239, 68, 68, 0.20);
+    --c-warning: #eab308;
+    --c-info: #8b5cf6;
+  }
+
+  [data-theme="violet"] {
+    --c-bg: #06020c;
+    --c-surface: #120a1a;
+    --c-subtle: rgba(139, 92, 246, 0.06);
+    --c-muted: rgba(139, 92, 246, 0.10);
+    --c-emphasis: rgba(139, 92, 246, 0.18);
+    --c-content: #ffffff;
+    --c-content-2: #9ca3af;
+    --c-content-3: #6b7280;
+    --c-content-4: #4b5563;
+    --c-line: rgba(255, 255, 255, 0.08);
+    --c-line-2: rgba(255, 255, 255, 0.04);
+    --c-accent: #8b5cf6;
+    --c-accent-hover: #7c3aed;
+    --c-accent-text: #a78bfa;
+    --c-accent-dim: rgba(139, 92, 246, 0.20);
+    --c-danger: #ef4444;
+    --c-danger-dim: rgba(239, 68, 68, 0.20);
+    --c-warning: #eab308;
+    --c-info: #3b82f6;
+  }
+
+  [data-theme="orange"] {
+    --c-bg: #0c0602;
+    --c-surface: #1a120a;
+    --c-subtle: rgba(249, 115, 22, 0.06);
+    --c-muted: rgba(249, 115, 22, 0.10);
+    --c-emphasis: rgba(249, 115, 22, 0.18);
+    --c-content: #ffffff;
+    --c-content-2: #9ca3af;
+    --c-content-3: #6b7280;
+    --c-content-4: #4b5563;
+    --c-line: rgba(255, 255, 255, 0.08);
+    --c-line-2: rgba(255, 255, 255, 0.04);
+    --c-accent: #f97316;
+    --c-accent-hover: #ea580c;
+    --c-accent-text: #fb923c;
+    --c-accent-dim: rgba(249, 115, 22, 0.20);
+    --c-danger: #ef4444;
+    --c-danger-dim: rgba(239, 68, 68, 0.20);
+    --c-warning: #eab308;
+    --c-info: #3b82f6;
+  }
+
+  [data-theme="cyan"] {
+    --c-bg: #020c0c;
+    --c-surface: #0a1a1a;
+    --c-subtle: rgba(6, 182, 212, 0.06);
+    --c-muted: rgba(6, 182, 212, 0.10);
+    --c-emphasis: rgba(6, 182, 212, 0.18);
+    --c-content: #ffffff;
+    --c-content-2: #9ca3af;
+    --c-content-3: #6b7280;
+    --c-content-4: #4b5563;
+    --c-line: rgba(255, 255, 255, 0.08);
+    --c-line-2: rgba(255, 255, 255, 0.04);
+    --c-accent: #06b6d4;
+    --c-accent-hover: #0891b2;
+    --c-accent-text: #22d3ee;
+    --c-accent-dim: rgba(6, 182, 212, 0.20);
+    --c-danger: #ef4444;
+    --c-danger-dim: rgba(239, 68, 68, 0.20);
+    --c-warning: #eab308;
+    --c-info: #3b82f6;
+  }
+
+  [data-theme="pink"] {
+    --c-bg: #0c020a;
+    --c-surface: #1a0a16;
+    --c-subtle: rgba(236, 72, 153, 0.06);
+    --c-muted: rgba(236, 72, 153, 0.10);
+    --c-emphasis: rgba(236, 72, 153, 0.18);
+    --c-content: #ffffff;
+    --c-content-2: #9ca3af;
+    --c-content-3: #6b7280;
+    --c-content-4: #4b5563;
+    --c-line: rgba(255, 255, 255, 0.08);
+    --c-line-2: rgba(255, 255, 255, 0.04);
+    --c-accent: #ec4899;
+    --c-accent-hover: #db2777;
+    --c-accent-text: #f472b6;
+    --c-accent-dim: rgba(236, 72, 153, 0.20);
+    --c-danger: #ef4444;
+    --c-danger-dim: rgba(239, 68, 68, 0.20);
+    --c-warning: #eab308;
+    --c-info: #3b82f6;
  }

  html {
@ -78,11 +189,19 @@
    @apply antialiased;
    font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif;
    background: var(--c-bg);
+    color: var(--c-content);
    position: fixed;
    inset: 0;
    overflow: hidden;
    overscroll-behavior: none;
    touch-action: none;
+    user-select: none;
+    -webkit-user-select: none;
+  }
+
+  input, textarea, [contenteditable="true"] {
+    user-select: text;
+    -webkit-user-select: text;
  }

  ::-webkit-scrollbar {
--- a/src/utils/format.ts
+++ b/src/utils/format.ts
@ -12,9 +12,18 @@ export function formatTime(sec: number): string {
  return `${m}:${s.toString().padStart(2, '0')}`;
 }

+const YI = 100_000_000;
+const WAN = 10_000;
+
 export function formatPlayCount(count: number): string {
  if (!count) return '0';
-  if (count >= 100000000) return (count / 100000000).toFixed(1) + '亿';
-  if (count >= 10000) return (count / 10000).toFixed(1) + '万';
+  if (count >= YI) return (count / YI).toFixed(1) + '亿';
+  if (count >= WAN) return (count / WAN).toFixed(1) + '万';
  return count.toString();
 }
+
+export function formatDate(ts: number): string {
+  if (!ts) return '';
+  const d = new Date(ts);
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+}
--- a/src/utils/lyric.ts
+++ b/src/utils/lyric.ts
@ -1,6 +1,7 @@
 export interface LyricLine {
-  time: number;  // 秒
+  time: number;
  text: string;
+  translation?: string;
 }

 export function parseLrc(lrcStr: string): LyricLine[] {
@ -20,11 +21,37 @@ export function parseLrc(lrcStr: string): LyricLine[] {
      }
    }
  }
-  // 按时长排序
  result.sort((a, b) => a.time - b.time);
  return result;
 }

+export function mergeTranslation(lyrics: LyricLine[], tLrcStr: string): LyricLine[] {
+  if (!tLrcStr) return lyrics;
+  const tLines = parseLrc(tLrcStr);
+  if (tLines.length === 0) return lyrics;
+
+  const tMap = new Map<number, string>();
+  for (const t of tLines) {
+    const key = Math.round(t.time * 100);
+    tMap.set(key, t.text);
+  }
+
+  return lyrics.map(line => {
+    const key = Math.round(line.time * 100);
+    const translation = tMap.get(key);
+    if (translation) {
+      return { ...line, translation };
+    }
+    for (let offset = -3; offset <= 3; offset++) {
+      const t = tMap.get(key + offset);
+      if (t) {
+        return { ...line, translation: t };
+      }
+    }
+    return line;
+  });
+}
+
 export function getCurrentLyricIndex(lyrics: LyricLine[], currentTime: number): number {
  let index = -1;
  for (let i = 0; i < lyrics.length; i++) {
@ -35,4 +62,4 @@ export function getCurrentLyricIndex(lyrics: LyricLine[], currentTime: number):
    }
  }
  return index;
-}
+}
--- a/src/utils/song.ts
+++ b/src/utils/song.ts
@ -1,18 +1,35 @@
-/**
- * 统一规范化歌曲对象，确保 al.picUrl、ar、dt 字段存在且合理
- */
-export function normalizeSong(song: any) {
-  const normalized = { ...song };
-  // 封面 / 艺术家兼容
-  if (!normalized.al?.picUrl && normalized.album?.picUrl) {
-    normalized.al = { ...normalized.al, picUrl: normalized.album.picUrl };
-  }
-  if (!normalized.ar || normalized.ar.length === 0) {
-    normalized.ar = normalized.artists || [];
-  }
-  // 时长：只保留合理的 dt（100ms ~ 2小时），否则置 0
-  if (!normalized.dt || normalized.dt < 100 || normalized.dt > 7200000) {
-    normalized.dt = 0;
-  }
-  return normalized;
-}
+export interface Song {
+  id: number;
+  name: string;
+  ar: { id?: number; name: string }[];
+  al: { id?: number; picUrl: string; name?: string };
+  dt?: number;
+  localPath?: string;
+}
+
+export function normalizeSong(song: any): Song {
+  const al = {
+    id: song.al?.id || song.album?.id,
+    picUrl: song.al?.picUrl || song.album?.picUrl || '',
+    name: song.al?.name || song.album?.name,
+  };
+  const ar = (song.ar && song.ar.length > 0) ? song.ar : (song.artists || []);
+  let dt = song.dt || song.duration || 0;
+  if (dt < 100 || dt > 7200000) dt = 0;
+  return {
+    id: song.id,
+    name: song.name,
+    ar,
+    al,
+    dt,
+    localPath: song.localPath,
+  };
+}
+
+export function getCoverUrl(song: Song | null, sizeParam = ''): string {
+  if (!song) return '';
+  const raw = song.al?.picUrl || '';
+  if (!raw) return '';
+  if (!sizeParam || raw.startsWith('data:')) return raw;
+  return raw + sizeParam;
+}
--- a/src/views/AlbumDetail.vue
+++ b/src/views/AlbumDetail.vue
@ -0,0 +1,120 @@
+<template>
+  <div class="p-8 text-content">
+    <button @click="$router.back()" class="mb-4 text-content-2 hover:text-content transition">
+      ← 返回
+    </button>
+
+    <div v-if="album" class="flex gap-6 mb-8">
+      <img :src="album.picUrl" class="w-44 h-44 rounded-xl object-cover shadow-lg flex-shrink-0" />
+      <div class="flex flex-col justify-between min-w-0">
+        <div>
+          <h1 class="text-2xl font-bold leading-tight">{{ album.name }}</h1>
+          <div v-if="album.artists?.length" class="flex items-center gap-1 mt-2 text-sm text-content-2">
+            <template v-for="(ar, idx) in album.artists" :key="ar.id">
+              <span v-if="(idx as number) > 0" class="text-content-3">/</span>
+              <span
+                class="hover:text-accent-text cursor-pointer transition"
+                @click="ar.id && router.push({ name: 'artist', params: { id: ar.id } })"
+              >{{ ar.name }}</span>
+            </template>
+          </div>
+          <p class="text-xs text-content-3 mt-2">
+            {{ formatDate(album.publishTime) }} · {{ songs.length }} 首歌曲
+          </p>
+        </div>
+        <div class="flex items-center gap-3 mt-4">
+          <button
+            @click="playAll"
+            class="px-5 py-2 bg-accent hover:bg-accent-hover rounded-full text-white font-medium transition flex items-center gap-2"
+          >
+            <svg width="16" height="16" viewBox="0 0 16 16" fill="currentColor"><path d="M4 2.5v11l9-5.5z"/></svg>
+            播放全部
+          </button>
+        </div>
+      </div>
+    </div>
+
+    <div v-if="loading" class="text-content-2">加载中...</div>
+
+    <div v-else class="space-y-1">
+      <SongListItem
+        v-for="(song, index) in songs"
+        :key="song.id"
+        :song="song"
+        :index="index"
+        :is-current="player.currentSong?.id === song.id"
+        show-index
+        show-like
+        show-download
+        show-menu
+        show-duration
+        show-playing-overlay
+        :container-class="player.currentSong?.id === song.id ? 'bg-accent-dim hover:bg-accent-dim' : 'hover:bg-subtle'"
+        @click="player.playFromList(songs, index)"
+      >
+        <template #index="{ index: idx, isCurrent }">
+          <div class="w-6 text-right flex-shrink-0 flex items-center justify-end h-5">
+            <div v-if="isCurrent" class="flex items-center justify-end">
+              <div class="flex items-center gap-[3px] h-4">
+                <span class="w-[3px] bg-accent-text rounded-full animate-bounce" style="height: 50%; animation-delay: 0ms"></span>
+                <span class="w-[3px] bg-accent-text rounded-full animate-bounce" style="height: 100%; animation-delay: 150ms"></span>
+                <span class="w-[3px] bg-accent-text rounded-full animate-bounce" style="height: 35%; animation-delay: 300ms"></span>
+              </div>
+            </div>
+            <template v-else>
+              <span class="text-xs text-content-3 group-hover:hidden">{{ idx + 1 }}</span>
+              <svg class="hidden group-hover:block text-content" width="14" height="14" viewBox="0 0 16 16" fill="currentColor"><path d="M4 2.5v11l9-5.5z"/></svg>
+            </template>
+          </div>
+        </template>
+      </SongListItem>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { ref, onMounted, watch } from 'vue';
+import { useRoute, useRouter } from 'vue-router';
+import { invoke } from '@tauri-apps/api/core';
+import { usePlayerStore } from '../stores/player';
+import { normalizeSong, type Song } from '../utils/song';
+import { formatDate } from '../utils/format';
+import SongListItem from '../components/SongListItem.vue';
+
+const route = useRoute();
+const router = useRouter();
+const player = usePlayerStore();
+
+const album = ref<any>(null);
+const songs = ref<Song[]>([]);
+const loading = ref(true);
+
+async function fetchAlbum(id: number) {
+  loading.value = true;
+  album.value = null;
+  songs.value = [];
+  try {
+    const jsonStr: string = await invoke('album_detail', { id });
+    const data = JSON.parse(jsonStr);
+    album.value = data.album;
+    songs.value = (data.songs || []).map(normalizeSong);
+  } catch (e) {
+    console.error(e);
+  } finally {
+    loading.value = false;
+  }
+}
+
+onMounted(() => {
+  fetchAlbum(Number(route.params.id));
+});
+
+watch(() => route.params.id, (newId) => {
+  if (newId) fetchAlbum(Number(newId));
+});
+
+function playAll() {
+  if (songs.value.length === 0) return;
+  player.playAll(songs.value);
+}
+</script>
--- a/src/views/ArtistDetail.vue
+++ b/src/views/ArtistDetail.vue
@ -0,0 +1,165 @@
+<template>
+  <div class="p-8 text-content">
+    <button @click="$router.back()" class="mb-4 text-content-2 hover:text-content transition">
+      ← 返回
+    </button>
+
+    <div v-if="artist" class="flex gap-6 mb-8">
+      <img :src="artist.cover" class="w-44 h-44 rounded-xl object-cover shadow-lg flex-shrink-0" />
+      <div class="flex flex-col justify-between min-w-0">
+        <div>
+          <h1 class="text-2xl font-bold leading-tight">{{ artist.name }}</h1>
+          <p class="text-xs text-content-3 mt-2">
+            {{ formatPlayCount(artist.followeds || 0) }} 粉丝 · {{ artist.musicSize || 0 }} 首歌曲
+          </p>
+        </div>
+        <div class="flex items-center gap-3 mt-4">
+          <button
+            @click="playAll"
+            class="px-5 py-2 bg-accent hover:bg-accent-hover rounded-full text-white font-medium transition flex items-center gap-2"
+          >
+            <svg width="16" height="16" viewBox="0 0 16 16" fill="currentColor"><path d="M4 2.5v11l9-5.5z"/></svg>
+            播放全部
+          </button>
+        </div>
+      </div>
+    </div>
+
+    <div class="flex gap-2 mb-6">
+      <button
+        v-for="tab in tabs"
+        :key="tab.key"
+        @click="activeTab = tab.key"
+        class="px-4 py-1.5 rounded-full text-sm transition"
+        :class="activeTab === tab.key ? 'bg-accent text-white' : 'bg-subtle text-content-2 hover:bg-muted'"
+      >
+        {{ tab.label }}
+      </button>
+    </div>
+
+    <div v-if="loading" class="text-content-2">加载中...</div>
+
+    <template v-else>
+      <div v-if="activeTab === 'songs'" class="space-y-1">
+        <SongListItem
+          v-for="(song, index) in songs"
+          :key="song.id"
+          :song="song"
+          :index="index"
+          :is-current="player.currentSong?.id === song.id"
+          show-index
+          show-like
+          show-download
+          show-menu
+          show-duration
+          show-playing-overlay
+          :container-class="player.currentSong?.id === song.id ? 'bg-accent-dim hover:bg-accent-dim' : 'hover:bg-subtle'"
+          @click="player.playFromList(songs, index)"
+        >
+          <template #index="{ index: idx, isCurrent }">
+            <div class="w-6 text-right flex-shrink-0 flex items-center justify-end h-5">
+              <div v-if="isCurrent" class="flex items-center justify-end">
+                <div class="flex items-center gap-[3px] h-4">
+                  <span class="w-[3px] bg-accent-text rounded-full animate-bounce" style="height: 50%; animation-delay: 0ms"></span>
+                  <span class="w-[3px] bg-accent-text rounded-full animate-bounce" style="height: 100%; animation-delay: 150ms"></span>
+                  <span class="w-[3px] bg-accent-text rounded-full animate-bounce" style="height: 35%; animation-delay: 300ms"></span>
+                </div>
+              </div>
+              <template v-else>
+                <span class="text-xs text-content-3 group-hover:hidden">{{ idx + 1 }}</span>
+                <svg class="hidden group-hover:block text-content" width="14" height="14" viewBox="0 0 16 16" fill="currentColor"><path d="M4 2.5v11l9-5.5z"/></svg>
+              </template>
+            </div>
+          </template>
+        </SongListItem>
+      </div>
+
+      <div v-if="activeTab === 'albums'" class="grid grid-cols-2 md:grid-cols-3 lg:grid-cols-4 gap-4">
+        <div
+          v-for="album in albums"
+          :key="album.id"
+          @click="router.push({ name: 'album', params: { id: album.id } })"
+          class="bg-subtle rounded-xl overflow-hidden hover:bg-muted transition cursor-pointer"
+        >
+          <img :src="album.picUrl" class="w-full aspect-square object-cover" />
+          <div class="p-3">
+            <p class="text-sm font-medium truncate">{{ album.name }}</p>
+            <p class="text-xs text-content-2 mt-1">{{ formatDate(album.publishTime) }}</p>
+          </div>
+        </div>
+      </div>
+
+      <div v-if="activeTab === 'desc'" class="max-w-2xl">
+        <p class="text-sm text-content-2 leading-relaxed whitespace-pre-wrap">{{ briefDesc }}</p>
+      </div>
+    </template>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { ref, onMounted, watch } from 'vue';
+import { useRoute, useRouter } from 'vue-router';
+import { invoke } from '@tauri-apps/api/core';
+import { usePlayerStore } from '../stores/player';
+import { formatPlayCount, formatDate } from '../utils/format';
+import { normalizeSong, type Song } from '../utils/song';
+import SongListItem from '../components/SongListItem.vue';
+
+const route = useRoute();
+const router = useRouter();
+const player = usePlayerStore();
+
+const artist = ref<any>(null);
+const songs = ref<Song[]>([]);
+const albums = ref<any[]>([]);
+const briefDesc = ref('');
+const loading = ref(true);
+const activeTab = ref('songs');
+
+const tabs = [
+  { key: 'songs', label: '热门歌曲' },
+  { key: 'albums', label: '专辑' },
+  { key: 'desc', label: '简介' },
+];
+
+async function fetchArtist(id: number) {
+  loading.value = true;
+  artist.value = null;
+  songs.value = [];
+  albums.value = [];
+  briefDesc.value = '';
+  try {
+    const [detailStr, songsStr, albumStr, descStr] = await Promise.all([
+      invoke('artist_detail', { id }) as Promise<string>,
+      invoke('artist_songs', { query: { id, order: 'hot', limit: 50, offset: 0 } }) as Promise<string>,
+      invoke('artist_album', { id, limit: 30, offset: 0 }) as Promise<string>,
+      invoke('artist_desc', { id }) as Promise<string>,
+    ]);
+    const detailData = JSON.parse(detailStr);
+    artist.value = detailData.artist;
+    const songsData = JSON.parse(songsStr);
+    songs.value = (songsData.songs || []).map(normalizeSong);
+    const albumData = JSON.parse(albumStr);
+    albums.value = albumData.hotAlbums || [];
+    const descData = JSON.parse(descStr);
+    briefDesc.value = descData.briefDesc || '';
+  } catch (e) {
+    console.error(e);
+  } finally {
+    loading.value = false;
+  }
+}
+
+onMounted(() => {
+  fetchArtist(Number(route.params.id));
+});
+
+watch(() => route.params.id, (newId) => {
+  if (newId) fetchArtist(Number(newId));
+});
+
+function playAll() {
+  if (songs.value.length === 0) return;
+  player.playAll(songs.value);
+}
+</script>
--- a/src/views/DailySongs.vue
+++ b/src/views/DailySongs.vue
@ -15,66 +15,87 @@
    </div>
    <div v-if="loading" class="text-content-2">加载中...</div>
    <div v-else class="space-y-2">
-      <div
+      <SongListItem
        v-for="(song, index) in songs"
        :key="song.id"
-        @click="player.play(song)"
-        class="flex items-center gap-4 p-3 rounded-xl hover:bg-subtle transition cursor-pointer group"
-        :class="{ 'bg-accent-dim': isCurrentSong(song.id) }"
+        :song="song"
+        :index="index"
+        :is-current="isCurrentSong(song.id)"
+        show-index
+        show-like
+        show-download
+        show-menu
+        show-duration
+        show-playing-overlay
+        :container-class="isCurrentSong(song.id) ? 'bg-accent-dim hover:bg-accent-dim' : 'hover:bg-subtle'"
+        @click="player.playFromList(songs, index)"
      >
-        <div class="w-6 text-right flex-shrink-0 flex items-center justify-end h-5">
-          <div v-if="isCurrentSong(song.id)" class="flex items-center justify-end">
-            <div class="flex items-center gap-[3px] h-4">
-              <span class="w-[3px] bg-accent-text rounded-full animate-bounce" style="height: 50%; animation-delay: 0ms"></span>
-              <span class="w-[3px] bg-accent-text rounded-full animate-bounce" style="height: 100%; animation-delay: 150ms"></span>
-              <span class="w-[3px] bg-accent-text rounded-full animate-bounce" style="height: 35%; animation-delay: 300ms"></span>
+        <template #index="{ index: idx, isCurrent }">
+          <div class="w-6 text-right flex-shrink-0 flex items-center justify-end h-5">
+            <div v-if="isCurrent" class="flex items-center justify-end">
+              <div class="flex items-center gap-[3px] h-4">
+                <span class="w-[3px] bg-accent-text rounded-full animate-bounce" style="height: 50%; animation-delay: 0ms"></span>
+                <span class="w-[3px] bg-accent-text rounded-full animate-bounce" style="height: 100%; animation-delay: 150ms"></span>
+                <span class="w-[3px] bg-accent-text rounded-full animate-bounce" style="height: 35%; animation-delay: 300ms"></span>
+              </div>
            </div>
+            <template v-else>
+              <span class="text-xs text-content-3 group-hover:hidden">{{ idx + 1 }}</span>
+              <svg class="hidden group-hover:block text-content" width="14" height="14" viewBox="0 0 16 16" fill="currentColor"><path d="M4 2.5v11l9-5.5z"/></svg>
+            </template>
          </div>
-          <template v-else>
-            <span class="text-xs text-content-3 group-hover:hidden">{{ index + 1 }}</span>
-            <svg class="hidden group-hover:block text-content" width="14" height="14" viewBox="0 0 16 16" fill="currentColor"><path d="M4 2.5v11l9-5.5z"/></svg>
-          </template>
-        </div>
-        <img :src="song.al?.picUrl" class="w-10 h-10 rounded object-cover flex-shrink-0" />
-        <div class="flex-1 min-w-0">
-          <p class="text-sm font-medium truncate" :class="isCurrentSong(song.id) ? 'text-accent-text' : ''">{{ song.name }}</p>
-          <p class="text-xs text-content-2 truncate">
-            {{ song.ar?.map((a: any) => a.name).join(' / ') }}
-          </p>
-        </div>
-        <button @click.stop="player.toggleLike(song.id)" class="text-content-3 hover:text-danger transition flex-shrink-0">
-          <svg v-if="player.isLiked(song.id)" width="16" height="16" viewBox="0 0 24 24" fill="currentColor" class="text-danger"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78l1.06 1.06L12 21.23l7.78-7.78 1.06-1.06a5.5 5.5 0 000-7.78z"/></svg>
-          <svg v-else width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78l1.06 1.06L12 21.23l7.78-7.78 1.06-1.06a5.5 5.5 0 000-7.78z"/></svg>
-        </button>
-        <span class="text-xs text-content-3">{{ formatDuration(song.dt) }}</span>
-      </div>
+        </template>
+      </SongListItem>
    </div>
  </div>
 </template>

 <script setup lang="ts">
-import { ref, onMounted } from 'vue';
+import { ref, onMounted, watch } from 'vue';
 import { invoke } from '@tauri-apps/api/core';
+import SongListItem from '../components/SongListItem.vue';
 import { usePlayerStore } from '../stores/player';
-import { formatDuration } from '../utils/format';
+import { pageCacheGet, pageCacheSet, pageCacheInvalidate } from '../composables/usePageCache';
+import { normalizeSong, type Song } from '../utils/song';
+import { useOnlineStatus } from '../composables/useOnlineStatus';
+
+defineOptions({ name: 'DailySongsView' });

 const player = usePlayerStore();
-const songs = ref<any[]>([]);
+const { isOnline } = useOnlineStatus();
+const songs = ref<Song[]>([]);
 const loading = ref(true);

 function isCurrentSong(songId: number): boolean {
  return player.currentSong?.id === songId;
 }

-onMounted(async () => {
+async function loadData() {
+  const cached = pageCacheGet('dailySongs');
+  if (cached) {
+    songs.value = cached;
+    loading.value = false;
+    return;
+  }
+  loading.value = true;
  try {
    const jsonStr: string = await invoke('recommend_songs');
    const data = JSON.parse(jsonStr);
-    songs.value = data.data?.dailySongs || [];
+    songs.value = (data.data?.dailySongs || []).map(normalizeSong);
+    pageCacheSet('dailySongs', songs.value);
  } catch (e) {
    console.error(e);
  } finally {
    loading.value = false;
  }
+}
+
+onMounted(loadData);
+
+watch(isOnline, (val, old) => {
+  if (val && !old && songs.value.length === 0) {
+    pageCacheInvalidate('dailySongs');
+    loadData();
+  }
 });
 </script>
--- a/src/views/Discover.vue
+++ b/src/views/Discover.vue
@ -2,7 +2,6 @@
  <div class="p-8 text-content">
    <h1 class="text-2xl font-bold mb-4">发现音乐</h1>

-    <!-- 搜索框 -->
    <input
      v-model="keyword"
      @keyup.enter="handleSearch"
@ -10,7 +9,6 @@
      class="mb-4 w-full rounded-xl bg-muted p-3 text-content placeholder-content-2 outline-none backdrop-blur"
    />

-    <!-- 热门搜索标签（仅在没有搜索且未显示结果时出现） -->
    <div v-if="!hasSearched && !loading && hotTags.length" class="mb-6">
      <h2 class="text-sm font-semibold mb-3">🔥 热门搜索</h2>
      <div class="flex flex-wrap gap-2">
@ -25,32 +23,19 @@
      </div>
    </div>

-    <!-- 输出设备选择 -->
-    <!-- <div class="mb-4">
-      <label class="mr-2 text-sm text-content-2">输出设备：</label>
-      <select v-model="selectedDevice" @change="changeDevice" class="bg-muted text-white rounded p-1 text-sm">
-        <option :value="null">跟随系统默认</option>
-        <option v-for="dev in devices" :key="dev" :value="dev">{{ dev }}</option>
-      </select>
-    </div> -->
-
-    <!-- 搜索结果 -->
    <div v-if="loading" class="text-content-2">搜索中...</div>
    <div v-else class="space-y-3">
-      <div
-        v-for="song in results"
+      <SongListItem
+        v-for="(song, index) in results"
        :key="song.id"
-        @click="playSong(song)"
-        class="flex items-center gap-4 p-3 rounded-xl backdrop-blur-md bg-subtle hover:bg-muted border border-line-2 cursor-pointer transition"
-      >
-        <img :src="song.al?.picUrl" class="w-12 h-12 rounded-lg object-cover" />
-        <div>
-          <p class="font-medium">{{ song.name }}</p>
-          <p class="text-sm text-content-2">
-            {{ song.ar?.map((a: any) => a.name).join(' / ') }}
-          </p>
-        </div>
-      </div>
+        :song="song"
+        :index="index"
+        show-download
+        show-menu
+        cover-size="w-12 h-12"
+        container-class="backdrop-blur-md bg-subtle hover:bg-muted border border-line-2"
+        @click="player.playFromList(results, index)"
+      />
      <p v-if="!loading && hasSearched && results.length === 0" class="text-content-2">无结果</p>
    </div>
  </div>
@ -59,35 +44,43 @@
 <script setup lang="ts">
 defineOptions({ name: 'DiscoverView' });

-import { ref, onMounted } from 'vue';
+import { ref, onMounted, watch } from 'vue';
 import { useRouter, useRoute } from 'vue-router';
 import { invoke } from '@tauri-apps/api/core';
 import { usePlayerStore } from '../stores/player';
+import SongListItem from '../components/SongListItem.vue';
+import { normalizeSong, type Song } from '../utils/song';
+import { pageCacheGet, pageCacheSet, pageCacheInvalidate } from '../composables/usePageCache';
+import { useOnlineStatus } from '../composables/useOnlineStatus';

 const router = useRouter();
 const route = useRoute();
 const player = usePlayerStore();
+const { isOnline } = useOnlineStatus();

 const keyword = ref('');
-const results = ref<any[]>([]);
+const results = ref<Song[]>([]);
 const loading = ref(false);
 const hasSearched = ref(false);
 const hotTags = ref<any[]>([]);

-const devices = ref<string[]>([]);
+async function loadHotTags() {
+  const cached = pageCacheGet('discover_hotTags');
+  if (cached) {
+    hotTags.value = cached;
+  } else {
+    try {
+      const json = await invoke('get_hot_search');
+      const data = JSON.parse(json as string);
+      hotTags.value = (data.data || []).slice(0, 12);
+      pageCacheSet('discover_hotTags', hotTags.value);
+    } catch {}
+  }
+}

 onMounted(async () => {
-  // 获取输出设备列表
-  try { devices.value = await invoke('get_output_devices'); } catch {}
+  await loadHotTags();

-  // 获取热门搜索
-  try {
-    const json = await invoke('get_hot_search');
-    const data = JSON.parse(json as string);
-    hotTags.value = (data.data || []).slice(0, 12);
-  } catch {}
-
-  // 检查路由是否有查询关键词，自动搜索
  const q = route.query.q as string;
  if (q) {
    keyword.value = q;
@ -96,6 +89,13 @@ onMounted(async () => {
  }
 });

+watch(isOnline, (val, old) => {
+  if (val && !old && hotTags.value.length === 0) {
+    pageCacheInvalidate('discover_hotTags');
+    loadHotTags();
+  }
+});
+
 async function handleSearch() {
  if (!keyword.value.trim()) return;
  loading.value = true;
@ -103,7 +103,7 @@ async function handleSearch() {
  try {
    const jsonStr: string = await invoke('search_songs', { query: { keyword: keyword.value } });
    const data = JSON.parse(jsonStr);
-    results.value = data.result?.songs || [];
+    results.value = (data.result?.songs || []).map(normalizeSong);
  } catch (e) {
    console.error('搜索出错：', e);
  } finally {
@ -115,9 +115,4 @@ function searchTag(tag: string) {
  keyword.value = tag;
  handleSearch();
 }
-
-async function playSong(song: any) {
-  player.play(song);
-}
-
 </script>
--- a/src/views/FavoriteSongs.vue
+++ b/src/views/FavoriteSongs.vue
@ -19,48 +19,52 @@
    <div v-else-if="loading" class="text-content-2">加载中...</div>
    <div v-else-if="songs.length === 0" class="text-content-2">暂无喜欢的音乐</div>
    <div v-else class="space-y-2">
-      <div
+      <SongListItem
        v-for="(song, index) in songs"
        :key="song.id"
-        @click="player.play(song)"
-        class="flex items-center gap-4 p-3 rounded-xl hover:bg-subtle transition cursor-pointer"
-      >
-        <span class="text-xs text-content-3 w-6 text-right">{{ index + 1 }}</span>
-        <img :src="song.al?.picUrl" class="w-10 h-10 rounded object-cover" />
-        <div class="flex-1 min-w-0">
-          <p class="text-sm font-medium truncate">{{ song.name }}</p>
-          <p class="text-xs text-content-2 truncate">
-            {{ song.ar?.map((a: any) => a.name).join(' / ') }}
-          </p>
-        </div>
-        <button @click.stop="player.toggleLike(song.id)" class="text-content-3 hover:text-danger transition flex-shrink-0">
-          <svg v-if="player.isLiked(song.id)" width="16" height="16" viewBox="0 0 24 24" fill="currentColor" class="text-danger"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78l1.06 1.06L12 21.23l7.78-7.78 1.06-1.06a5.5 5.5 0 000-7.78z"/></svg>
-          <svg v-else width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78l1.06 1.06L12 21.23l7.78-7.78 1.06-1.06a5.5 5.5 0 000-7.78z"/></svg>
-        </button>
-        <span class="text-xs text-content-3">{{ formatDuration(song.dt) }}</span>
-      </div>
+        :song="song"
+        :index="index"
+        show-index
+        show-like
+        show-download
+        show-menu
+        show-duration
+        @click="player.playFromList(songs, index)"
+      />
    </div>
  </div>
 </template>

 <script setup lang="ts">
-import { ref, onMounted } from 'vue';
+import { ref, onMounted, watch } from 'vue';
 import { invoke } from '@tauri-apps/api/core';
+import SongListItem from '../components/SongListItem.vue';
 import { usePlayerStore } from '../stores/player';
 import { useUserStore } from '../stores/user';
-import { normalizeSong } from '../utils/song';
-import { formatDuration } from '../utils/format';
+import { normalizeSong, type Song } from '../utils/song';
+import { pageCacheGet, pageCacheSet, pageCacheInvalidate } from '../composables/usePageCache';
+import { useOnlineStatus } from '../composables/useOnlineStatus';
+
+defineOptions({ name: 'FavoriteSongsView' });

 const player = usePlayerStore();
 const userStore = useUserStore();
-const songs = ref<any[]>([]);
+const { isOnline } = useOnlineStatus();
+const songs = ref<Song[]>([]);
 const loading = ref(true);

-onMounted(async () => {
+async function loadData() {
  if (!userStore.isLoggedIn) {
    loading.value = false;
    return;
  }
+  const cached = pageCacheGet('favoriteSongs');
+  if (cached) {
+    songs.value = cached;
+    loading.value = false;
+    return;
+  }
+  loading.value = true;
  try {
    const playlistJson: string = await invoke('user_playlist', { uid: userStore.user!.userId });
    const playlistData = JSON.parse(playlistJson);
@ -73,10 +77,20 @@ onMounted(async () => {
    const trackJson: string = await invoke('playlist_track_all', { query: { id: likePlaylistId } });
    const trackData = JSON.parse(trackJson);
    songs.value = (trackData.songs || []).map(normalizeSong);
+    pageCacheSet('favoriteSongs', songs.value);
  } catch (e) {
    console.error(e);
  } finally {
    loading.value = false;
  }
+}
+
+onMounted(loadData);
+
+watch(isOnline, (val, old) => {
+  if (val && !old && userStore.isLoggedIn && songs.value.length === 0) {
+    pageCacheInvalidate('favoriteSongs');
+    loadData();
+  }
 });
 </script>
--- a/src/views/Home.vue
+++ b/src/views/Home.vue
@ -13,7 +13,7 @@
            <p class="text-xs text-white/60 mb-1">📅 {{ todayStr }}</p>
            <h2 class="text-2xl font-bold">每日推荐</h2>
          </div>
-          <p class="text-xs text-white/60">根据你的口味生成，每天 6:00 更新</p>
+          <p class="text-xs text-white/60">根据你的口味生成，每天凌晨更新</p>
        </div>
        <div class="absolute right-4 top-1/2 -translate-y-1/2 text-6xl opacity-20">🎧</div>
      </div>
@ -80,9 +80,9 @@
    <!-- 第二行：为你推荐（需登录） -->
    <div v-if="userStore.isLoggedIn && recPlaylists.length" class="mb-10">
      <h2 class="text-xl font-semibold mb-4">🎯 为你推荐</h2>
-      <div class="grid grid-cols-2 md:grid-cols-3 lg:grid-cols-4 gap-4">
+      <div class="grid grid-cols-2 md:grid-cols-3 lg:grid-cols-4 xl:grid-cols-5 2xl:grid-cols-6 gap-4">
        <div v-for="pl in recPlaylists" :key="pl.id" @click="goPlaylist(pl.id)"
-          class="bg-subtle rounded-xl overflow-hidden hover:bg-muted transition cursor-pointer">
+          class="bg-subtle rounded-xl overflow-hidden hover:bg-muted transition cursor-pointer max-w-[220px] justify-self-center w-full">
          <img :src="pl.picUrl" class="w-full aspect-square object-cover" />
          <div class="p-3">
            <p class="text-sm font-medium truncate">{{ pl.name }}</p>
@ -95,9 +95,9 @@
    <!-- 第三行：热门歌单（排行榜） -->
    <div>
      <h2 class="text-xl font-semibold mb-4">📈 热门歌单</h2>
-      <div class="grid grid-cols-2 md:grid-cols-3 lg:grid-cols-4 gap-4">
+      <div class="grid grid-cols-2 md:grid-cols-3 lg:grid-cols-4 xl:grid-cols-5 2xl:grid-cols-6 gap-4">
        <div v-for="pl in rankPlaylists" :key="pl.id" @click="goPlaylist(pl.id)"
-          class="bg-subtle rounded-xl overflow-hidden hover:bg-muted transition cursor-pointer backdrop-blur-sm">
+          class="bg-subtle rounded-xl overflow-hidden hover:bg-muted transition cursor-pointer backdrop-blur-sm max-w-[220px] justify-self-center w-full">
          <img :src="pl.coverImgUrl" class="w-full aspect-square object-cover" />
          <div class="p-3">
            <p class="text-sm font-medium truncate">{{ pl.name }}</p>
@ -109,15 +109,21 @@
 </template>

 <script setup lang="ts">
-import { ref, onMounted } from 'vue';
+import { ref, onMounted, watch } from 'vue';
 import { useRouter } from 'vue-router';
 import { invoke } from '@tauri-apps/api/core';
 import { useUserStore } from '../stores/user';
 import { usePlayerStore } from '../stores/player';
+import { pageCacheGet, pageCacheSet, pageCacheInvalidate } from '../composables/usePageCache';
+import { useOnlineStatus } from '../composables/useOnlineStatus';
+import { getCoverUrl } from '../utils/song';
+
+defineOptions({ name: 'HomeView' });

 const player = usePlayerStore();
 const router = useRouter();
 const userStore = useUserStore();
+const { isOnline } = useOnlineStatus();

 const rankPlaylists = ref<any[]>([]);
 const recPlaylists = ref<any[]>([]);
@ -128,17 +134,15 @@ import { computed } from 'vue';


 const fmCoverUrl = computed(() => {
-  return player.fmSong?.al?.picUrl || player.fmSong?.album?.picUrl || '';
+  return getCoverUrl(player.fmSong) || '';
 });
 const fmDisplayName = computed(() => player.fmSong?.name || '私人漫游');
 const fmDisplayArtists = computed(() => {
  if (!player.fmSong) return '';
-  return player.fmSong.ar?.map((a: any) => a.name).join(' / ') ||
-         player.fmSong.artists?.map((a: any) => a.name).join(' / ') || '';
+  return player.fmSong.ar?.map((a: { name: string }) => a.name).join(' / ') || '';
 });


-// 首次点击播放按钮：开始 FM 并播放
 async function startFmPlay() {
  if (!player.fmSong) {
    await player.loadFm();
@ -159,11 +163,14 @@ function onFmCardClick() {
  player.openRoamDrawer();
 }

-onMounted(async () => {
-  const d = new Date();
-  todayStr.value = `${d.getMonth() + 1}月${d.getDate()}日`;
+async function loadData() {
+  const cached = pageCacheGet('home');
+  if (cached) {
+    rankPlaylists.value = cached.rankPlaylists || [];
+    recPlaylists.value = cached.recPlaylists || [];
+    return;
+  }

-  // 排行榜
  const results = await Promise.allSettled(
    RANK_IDS.map(id => invoke('get_playlist_detail', { id }))
  );
@ -175,7 +182,6 @@ onMounted(async () => {
    })
    .filter(Boolean);

-  // 推荐歌单（需登录）
  if (userStore.isLoggedIn) {
    try {
      const json = await invoke('recommend_resource');
@ -183,6 +189,21 @@ onMounted(async () => {
      recPlaylists.value = data.recommend || [];
    } catch { }
  }
+
+  pageCacheSet('home', { rankPlaylists: rankPlaylists.value, recPlaylists: recPlaylists.value });
+}
+
+onMounted(async () => {
+  const d = new Date();
+  todayStr.value = `${d.getMonth() + 1}月${d.getDate()}日`;
+  await loadData();
+});
+
+watch(isOnline, (val, old) => {
+  if (val && !old && rankPlaylists.value.length === 0 && recPlaylists.value.length === 0) {
+    pageCacheInvalidate('home');
+    loadData();
+  }
 });

 function goDaily() {
--- a/src/views/LocalMusic.vue
+++ b/src/views/LocalMusic.vue
@ -0,0 +1,210 @@
+<template>
+  <div class="p-8 text-content">
+    <button @click="$router.back()" class="mb-4 text-content-2 hover:text-content transition">
+      ← 返回
+    </button>
+    <div class="flex items-center gap-4 mb-6">
+      <h1 class="text-2xl font-bold">本地音乐</h1>
+      <span v-if="songs.length" class="text-xs text-content-3">{{ songs.length }} 首</span>
+      <button
+        v-if="songs.length"
+        @click="refresh"
+        class="px-3 py-1 bg-muted hover:bg-emphasis rounded-full text-xs transition"
+      >
+        刷新
+      </button>
+    </div>
+    <div v-if="loading" class="text-content-2">加载中...</div>
+    <div v-else-if="songs.length === 0" class="text-content-3">
+      当前文件夹下没有音乐文件，支持 mp3、flac、wav、ogg、aac、m4a 格式
+    </div>
+    <div v-else class="space-y-2">
+      <SongListItem
+        v-for="(song, index) in normalizedSongs"
+        :key="song.id + '-' + index"
+        :song="song"
+        :index="index"
+        :is-current="player.currentSong?.id === song.id"
+        show-index
+        show-duration
+        :container-class="player.currentSong?.id === song.id ? 'bg-subtle hover:bg-subtle' : 'hover:bg-subtle'"
+        @click="player.playFromList(normalizedSongs, index)"
+      >
+        <template #actions>
+          <span class="text-xs text-content-3 flex-shrink-0">{{ formatFileSize(songs[index].fileSize) }}</span>
+          <div class="relative flex-shrink-0">
+            <button
+              @click.stop="toggleMenu(songs[index].id)"
+              class="text-content-3 hover:text-content transition p-1 rounded hover:bg-muted"
+              title="更多"
+            >
+              <svg width="16" height="16" viewBox="0 0 24 24" fill="currentColor"><circle cx="5" cy="12" r="1.5"/><circle cx="12" cy="12" r="1.5"/><circle cx="19" cy="12" r="1.5"/></svg>
+            </button>
+            <Transition name="fade">
+              <div v-if="openMenuId === songs[index].id" class="absolute right-0 top-full mt-1 w-44 bg-surface border border-line rounded-xl shadow-2xl overflow-hidden z-50" @click.stop>
+                <button @click="confirmDelete(songs[index])" class="w-full flex items-center gap-2.5 px-4 py-2.5 text-sm text-danger/80 hover:bg-danger/10 transition">
+                  <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="3 6 5 6 21 6"/><path d="M19 6v14a2 2 0 01-2 2H7a2 2 0 01-2-2V6m3 0V4a2 2 0 012-2h4a2 2 0 012 2v2"/></svg>
+                  从磁盘中删除
+                </button>
+              </div>
+            </Transition>
+          </div>
+        </template>
+      </SongListItem>
+    </div>
+
+    <Transition name="fade">
+      <div v-if="showDeleteConfirm" class="fixed inset-0 z-50 flex items-center justify-center bg-black/60 backdrop-blur-sm" @click.self="showDeleteConfirm = false">
+        <div class="bg-surface border border-line rounded-2xl shadow-2xl w-80 p-6 select-auto">
+          <h2 class="text-lg font-semibold text-content mb-1">确认删除</h2>
+          <p class="text-sm text-content-2 mb-5">确定要删除「{{ deleteTarget?.name }}」吗？此操作不可撤销。</p>
+          <div class="flex gap-3">
+            <button @click="showDeleteConfirm = false"
+              class="flex-1 py-2 rounded-lg bg-muted hover:bg-emphasis text-sm text-content-2 transition">
+              取消
+            </button>
+            <button @click="doDelete"
+              class="flex-1 py-2 rounded-lg bg-danger/20 hover:bg-danger/30 text-danger text-sm font-medium transition">
+              删除
+            </button>
+          </div>
+        </div>
+      </div>
+    </Transition>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { ref, computed, onMounted, onBeforeUnmount } from 'vue';
+import { invoke } from '@tauri-apps/api/core';
+import { usePlayerStore } from '../stores/player';
+import { useDownload } from '../composables/useDownload';
+import { useSettingsStore } from '../stores/settings';
+import { showToast } from '../composables/useToast';
+import { pageCacheSet, pageCacheInvalidate } from '../composables/usePageCache';
+import SongListItem from '../components/SongListItem.vue';
+import type { Song } from '../utils/song';
+
+defineOptions({ name: 'LocalMusicView' });
+
+const player = usePlayerStore();
+const download = useDownload();
+const settings = useSettingsStore();
+
+interface LocalSong {
+  id: number;
+  name: string;
+  artist: string;
+  album: string;
+  duration: number;
+  cover: string | null;
+  filename: string;
+  fileSize: number;
+  path: string;
+  local: boolean;
+}
+
+const songs = ref<LocalSong[]>([]);
+const loading = ref(true);
+const showDeleteConfirm = ref(false);
+const deleteTarget = ref<LocalSong | null>(null);
+const openMenuId = ref<number | null>(null);
+
+const normalizedSongs = computed(() => songs.value.map(toSong));
+
+function toggleMenu(id: number) {
+  openMenuId.value = openMenuId.value === id ? null : id;
+}
+
+function closeMenu() {
+  openMenuId.value = null;
+}
+
+onMounted(() => { document.addEventListener('click', closeMenu); });
+onBeforeUnmount(() => { document.removeEventListener('click', closeMenu); });
+
+async function refresh() {
+  loading.value = true;
+  pageCacheInvalidate('localMusic');
+  try {
+    const list = await invoke<LocalSong[]>('list_local_songs', { downloadPath: settings.downloadPath || null });
+    songs.value = list;
+    pageCacheSet('localMusic', list);
+    fetchMissingCovers();
+  } catch (e) {
+    console.error(e);
+  } finally {
+    loading.value = false;
+  }
+}
+
+async function fetchMissingCovers() {
+  const missing = songs.value.filter(s => !s.cover && s.id > 0 && s.id < 1e12);
+  if (missing.length === 0) return;
+  const ids = [...new Set(missing.map(s => s.id))];
+  try {
+    const jsonStr: string = await invoke('get_song_detail', { id: JSON.stringify(ids) });
+    const data = JSON.parse(jsonStr);
+    const detailMap = new Map<number, string>();
+    for (const s of data.songs || []) {
+      const url = s.al?.picUrl;
+      if (url && s.id) detailMap.set(s.id, url + '?param=100y100');
+    }
+    for (const song of missing) {
+      const url = detailMap.get(song.id);
+      if (url) song.cover = url;
+    }
+  } catch {}
+}
+
+onMounted(refresh);
+
+function formatFileSize(bytes: number): string {
+  if (bytes === 0) return '0 B';
+  const units = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  return (bytes / Math.pow(1024, i)).toFixed(i > 0 ? 1 : 0) + ' ' + units[i];
+}
+
+function toSong(local: LocalSong): Song {
+  return {
+    id: local.id,
+    name: local.name,
+    ar: local.artist ? [{ name: local.artist }] : [],
+    al: { picUrl: local.cover || '', name: local.album || undefined },
+    dt: local.duration || undefined,
+    localPath: local.path,
+  };
+}
+
+function confirmDelete(song: LocalSong) {
+  openMenuId.value = null;
+  deleteTarget.value = song;
+  showDeleteConfirm.value = true;
+}
+
+async function doDelete() {
+  if (!deleteTarget.value) return;
+  try {
+    await invoke('delete_local_song', { query: { id: deleteTarget.value.id, filename: deleteTarget.value.filename, downloadPath: settings.downloadPath || null } });
+    songs.value = songs.value.filter(s => s.id !== deleteTarget.value!.id);
+    download.localSongIds.delete(deleteTarget.value.id);
+    showToast('已删除', 'success');
+  } catch (e) {
+    showToast('删除失败', 'error');
+  }
+  showDeleteConfirm.value = false;
+  deleteTarget.value = null;
+}
+</script>
+
+<style scoped>
+.fade-enter-active,
+.fade-leave-active {
+  transition: opacity 0.15s ease;
+}
+.fade-enter-from,
+.fade-leave-to {
+  opacity: 0;
+}
+</style>
--- a/src/views/Login.vue
+++ b/src/views/Login.vue
@ -88,7 +88,7 @@ function startPolling() {
                statusColor.value = 'text-content-2';
            } else if (code === 802) {
                statusText.value = '请在手机上确认登录';
-                statusColor.value = 'text-warning';
+                statusColor.value = 'text-yellow-400';
            } else if (code === 803) {
                clearInterval(pollTimer!);
                statusText.value = '登录成功！';
--- a/src/views/PlaylistDetail.vue
+++ b/src/views/PlaylistDetail.vue
@ -45,39 +45,41 @@
    <div v-if="loading" class="text-content-2">加载中...</div>

    <div v-else class="space-y-1">
-      <div
+      <SongListItem
        v-for="(song, index) in songs"
        :key="song.id"
-        @click="playSingle(song)"
-        class="flex items-center gap-4 p-3 rounded-xl hover:bg-subtle transition cursor-pointer group"
-        :class="{ 'bg-accent-dim': isCurrentSong(song.id) }"
+        :song="song"
+        :index="index"
+        :is-current="player.currentSong?.id === song.id"
+        show-index
+        show-like
+        show-download
+        show-menu
+        show-duration
+        show-playing-overlay
+        :container-class="player.currentSong?.id === song.id ? 'bg-accent-dim hover:bg-accent-dim' : 'hover:bg-subtle'"
+        @click="player.playFromList(songs, index)"
      >
-        <div class="w-6 text-right flex-shrink-0 flex items-center justify-end h-5">
-          <div v-if="isCurrentSong(song.id)" class="flex items-center justify-end">
-            <div class="flex items-center gap-[3px] h-4">
-              <span class="w-[3px] bg-accent-text rounded-full animate-bounce" style="height: 50%; animation-delay: 0ms"></span>
-              <span class="w-[3px] bg-accent-text rounded-full animate-bounce" style="height: 100%; animation-delay: 150ms"></span>
-              <span class="w-[3px] bg-accent-text rounded-full animate-bounce" style="height: 35%; animation-delay: 300ms"></span>
+        <template #index="{ index: idx, isCurrent }">
+          <div class="w-6 text-right flex-shrink-0 flex items-center justify-end h-5">
+            <div v-if="isCurrent" class="flex items-center justify-end">
+              <div class="flex items-center gap-[3px] h-4">
+                <span class="w-[3px] bg-accent-text rounded-full animate-bounce" style="height: 50%; animation-delay: 0ms"></span>
+                <span class="w-[3px] bg-accent-text rounded-full animate-bounce" style="height: 100%; animation-delay: 150ms"></span>
+                <span class="w-[3px] bg-accent-text rounded-full animate-bounce" style="height: 35%; animation-delay: 300ms"></span>
+              </div>
            </div>
+            <template v-else>
+              <span class="text-xs text-content-3 group-hover:hidden">{{ idx + 1 }}</span>
+              <svg class="hidden group-hover:block text-content" width="14" height="14" viewBox="0 0 16 16" fill="currentColor"><path d="M4 2.5v11l9-5.5z"/></svg>
+            </template>
          </div>
-          <template v-else>
-            <span class="text-xs text-content-3 group-hover:hidden">{{ index + 1 }}</span>
-            <svg class="hidden group-hover:block text-content" width="14" height="14" viewBox="0 0 16 16" fill="currentColor"><path d="M4 2.5v11l9-5.5z"/></svg>
-          </template>
-        </div>
-        <img :src="song.al?.picUrl" class="w-10 h-10 rounded object-cover flex-shrink-0" />
-        <div class="flex-1 min-w-0">
-          <p class="text-sm font-medium truncate" :class="isCurrentSong(song.id) ? 'text-accent-text' : ''">{{ song.name }}</p>
-          <p class="text-xs text-content-2 truncate">
-            {{ song.ar?.map((a: any) => a.name).join(' / ') }}
-          </p>
-        </div>
-        <button @click.stop="player.toggleLike(song.id)" class="text-content-3 hover:text-danger transition flex-shrink-0">
-          <svg v-if="player.isLiked(song.id)" width="16" height="16" viewBox="0 0 24 24" fill="currentColor" class="text-danger"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78l1.06 1.06L12 21.23l7.78-7.78 1.06-1.06a5.5 5.5 0 000-7.78z"/></svg>
-          <svg v-else width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78l1.06 1.06L12 21.23l7.78-7.78 1.06-1.06a5.5 5.5 0 000-7.78z"/></svg>
-        </button>
-        <span class="text-xs text-content-3">{{ formatDuration(song.dt) }}</span>
-      </div>
+        </template>
+      </SongListItem>
+    </div>
+
+    <div v-if="playlist" class="mt-8">
+      <CommentSection :type="2" :id="Number(route.params.id)" />
    </div>
  </div>
 </template>
@ -89,14 +91,17 @@ import { invoke } from '@tauri-apps/api/core';
 import { usePlayerStore } from '../stores/player';
 import { useUserStore } from '../stores/user';
 import { showToast } from '../composables/useToast';
-import { formatDuration, formatPlayCount } from '../utils/format';
+import { formatPlayCount } from '../utils/format';
+import { normalizeSong, type Song } from '../utils/song';
+import SongListItem from '../components/SongListItem.vue';
+import CommentSection from '../components/CommentSection.vue';

 const route = useRoute();
 const player = usePlayerStore();
 const userStore = useUserStore();

 const playlist = ref<any>(null);
-const songs = ref<any[]>([]);
+const songs = ref<Song[]>([]);
 const loading = ref(true);
 const subscribed = ref(false);

@ -113,7 +118,7 @@ async function fetchPlaylist(id: number) {
    const jsonStr: string = await invoke('get_playlist_detail', { id });
    const data = JSON.parse(jsonStr);
    playlist.value = data.playlist;
-    songs.value = data.playlist.tracks || [];
+    songs.value = (data.playlist.tracks || []).map(normalizeSong);
    subscribed.value = data.playlist.subscribed || false;
  } catch (e) {
    console.error(e);
@ -131,14 +136,6 @@ watch(() => route.params.id, (newId) => {
  if (newId) fetchPlaylist(Number(newId));
 });

-function isCurrentSong(songId: number): boolean {
-  return player.currentSong?.id === songId;
-}
-
-async function playSingle(song: any) {
-  player.play(song);
-}
-
 function playAll() {
  if (songs.value.length === 0) return;
  player.playAll(songs.value);
--- a/src/views/RecentPlays.vue
+++ b/src/views/RecentPlays.vue
@ -6,33 +6,44 @@
    <h1 class="text-2xl font-bold mb-6">最近播放</h1>
    <div v-if="player.recentLocal.length === 0" class="text-content-3">还没有播放记录，去听首歌吧</div>
    <div v-else class="space-y-2">
-      <div
+      <SongListItem
        v-for="(song, index) in player.recentLocal"
        :key="song.id"
-        @click="player.play(song)"
-        class="flex items-center gap-4 p-3 rounded-xl hover:bg-subtle transition cursor-pointer"
+        :song="song"
+        :index="index"
+        :is-current="player.currentSong?.id === song.id"
+        show-index
+        show-like
+        show-download
+        show-menu
+        show-duration
+        show-playing-overlay
+        :container-class="player.currentSong?.id === song.id ? 'bg-accent-dim hover:bg-accent-dim' : 'hover:bg-subtle'"
+        @click="player.playFromList(player.recentLocal, index)"
      >
-        <span class="text-xs text-content-3 w-6 text-right">{{ index + 1 }}</span>
-        <img :src="song.al?.picUrl" class="w-10 h-10 rounded object-cover" />
-        <div class="flex-1 min-w-0">
-          <p class="text-sm font-medium truncate">{{ song.name }}</p>
-          <p class="text-xs text-content-2 truncate">
-            {{ song.ar?.map((a: any) => a.name).join(' / ') }}
-          </p>
-        </div>
-        <button @click.stop="player.toggleLike(song.id)" class="text-content-3 hover:text-danger transition flex-shrink-0">
-          <svg v-if="player.isLiked(song.id)" width="16" height="16" viewBox="0 0 24 24" fill="currentColor" class="text-danger"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78l1.06 1.06L12 21.23l7.78-7.78 1.06-1.06a5.5 5.5 0 000-7.78z"/></svg>
-          <svg v-else width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78l1.06 1.06L12 21.23l7.78-7.78 1.06-1.06a5.5 5.5 0 000-7.78z"/></svg>
-        </button>
-        <span class="text-xs text-content-3">{{ formatDuration(song.dt ?? 0) }}</span>
-      </div>
+        <template #index="{ index: idx, isCurrent }">
+          <div class="w-6 text-right flex-shrink-0 flex items-center justify-end h-5">
+            <div v-if="isCurrent" class="flex items-center justify-end">
+              <div class="flex items-center gap-[3px] h-4">
+                <span class="w-[3px] bg-accent-text rounded-full animate-bounce" style="height: 50%; animation-delay: 0ms"></span>
+                <span class="w-[3px] bg-accent-text rounded-full animate-bounce" style="height: 100%; animation-delay: 150ms"></span>
+                <span class="w-[3px] bg-accent-text rounded-full animate-bounce" style="height: 35%; animation-delay: 300ms"></span>
+              </div>
+            </div>
+            <template v-else>
+              <span class="text-xs text-content-3 group-hover:hidden">{{ idx + 1 }}</span>
+              <svg class="hidden group-hover:block text-content" width="14" height="14" viewBox="0 0 16 16" fill="currentColor"><path d="M4 2.5v11l9-5.5z"/></svg>
+            </template>
+          </div>
+        </template>
+      </SongListItem>
    </div>
  </div>
 </template>

 <script setup lang="ts">
 import { usePlayerStore } from '../stores/player';
-import { formatDuration } from '../utils/format';
+import SongListItem from '../components/SongListItem.vue';

 const player = usePlayerStore();
 </script>
--- a/src/views/Roam.vue
+++ b/src/views/Roam.vue
@ -12,13 +12,28 @@

    <template v-else>
      <img
-        :src="currentSong.al?.picUrl || currentSong.album?.picUrl"
+        v-if="coverUrl && !coverError"
+        :src="coverUrl"
        class="w-80 h-80 rounded-3xl object-cover shadow-2xl mb-8"
+        @error="coverError = true"
      />
+      <div
+        v-else
+        class="w-80 h-80 rounded-3xl bg-muted flex items-center justify-center shadow-2xl mb-8"
+      >
+        <svg width="64" height="64" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" class="text-content-3"><path d="M9 18V5l12-2v13"/><circle cx="6" cy="18" r="3"/><circle cx="18" cy="16" r="3"/></svg>
+      </div>

      <h1 class="text-3xl font-bold mb-2">{{ currentSong.name }}</h1>
      <p class="text-lg text-content-2 mb-8">
-        {{ artists }}
+        <template v-for="(a, i) in currentSong.ar || []" :key="a.id || i">
+          <span v-if="i > 0" class="text-content-3">/</span>
+          <span class="hover:text-accent-text cursor-pointer transition" @click="a.id && router.push({ name: 'artist', params: { id: a.id } })">{{ a.name }}</span>
+        </template>
+        <template v-if="currentSong.al?.name">
+          <span class="text-content-3 mx-1">·</span>
+          <span class="hover:text-accent-text cursor-pointer transition" @click="currentSong.al.id && router.push({ name: 'album', params: { id: currentSong.al.id } })">{{ currentSong.al.name }}</span>
+        </template>
      </p>

      <div class="flex items-center gap-8">
@ -46,12 +61,17 @@
 </template>

 <script setup lang="ts">
-import { computed, onMounted } from 'vue';
+import { ref, computed, watch, onMounted } from 'vue';
 import { usePlayerStore } from '../stores/player';
 import { invoke } from '@tauri-apps/api/core';
-import { normalizeSong } from '../utils/song';
+import { normalizeSong, getCoverUrl } from '../utils/song';
+import { useRouter } from 'vue-router';
+import { useOnlineStatus } from '../composables/useOnlineStatus';

 const player = usePlayerStore();
+const router = useRouter();
+const { isOnline } = useOnlineStatus();
+const coverError = ref(false);

 const currentSong = computed(() => {
  if (player.isFmMode && player.currentSong) {
@ -60,12 +80,13 @@ const currentSong = computed(() => {
  return null;
 });

-const artists = computed(() => {
+const coverUrl = computed(() => {
  if (!currentSong.value) return '';
-  return currentSong.value.ar?.map((a: any) => a.name).join(' / ') ||
-         currentSong.value.artists?.map((a: any) => a.name).join(' / ') || '';
+  return getCoverUrl(currentSong.value) || '';
 });

+watch(coverUrl, () => { coverError.value = false; });
+
 onMounted(async () => {
  if (!player.isFmMode || !player.currentSong) {
    await startFm();
@ -90,4 +111,10 @@ async function startFm() {
 async function nextSong() {
  await startFm();
 }
+
+watch(isOnline, (val, old) => {
+  if (val && !old && !currentSong.value) {
+    startFm();
+  }
+});
 </script>
--- a/src/views/Search.vue
+++ b/src/views/Search.vue
@ -1,92 +0,0 @@
-<template>
-  <div class="text-content">
-    <h1 class="text-2xl font-bold mb-4">搜索</h1>
-
-    <input
-      v-model="keyword"
-      @keyup.enter="handleSearch"
-      placeholder="搜索歌曲..."
-      class="mb-6 w-full rounded-xl bg-muted p-3 text-content placeholder-content-2 outline-none backdrop-blur"
-    />
-
-    <div v-if="loading" class="text-content-2">搜索中...</div>
-    <div v-else class="space-y-3">
-      <div
-        v-for="song in results"
-        :key="song.id"
-        @click="playSong(song)"
-        class="flex items-center gap-4 p-3 rounded-xl backdrop-blur-md bg-subtle hover:bg-muted border border-line-2 cursor-pointer transition-all duration-200 hover:scale-[1.01] active:scale-95"
-      >
-        <img :src="song.al?.picUrl" class="w-12 h-12 rounded-lg object-cover" />
-        <div>
-          <p class="font-medium">{{ song.name }}</p>
-          <p class="text-sm text-content-2">
-            {{ song.ar?.map((a: any) => a.name).join(' / ') }}
-          </p>
-        </div>
-      </div>
-      <p v-if="!loading && hasSearched && results.length === 0" class="text-content-2">无结果</p>
-    </div>
-
-  </div>
-</template>
-
-<script setup lang="ts">
-defineOptions({ name: 'SearchView' });
-
-import { useRoute } from 'vue-router';
-import { watch } from 'vue';
-import { ref, onMounted } from 'vue';
-import { invoke } from '@tauri-apps/api/core';
-import { usePlayerStore } from '../stores/player';
-import { useRouter } from 'vue-router';
-const router = useRouter();
-
-const keyword = ref('');
-const results = ref<any[]>([]);
-const loading = ref(false);
-const hasSearched = ref(false);
-const player = usePlayerStore();
-
-const route = useRoute();
-watch(
-  () => route.query.q,
-  (newQ) => {
-    if (newQ) {
-      keyword.value = newQ as string;
-      handleSearch();
-      router.replace({ query: {} });
-    }
-  },
-  { immediate: true }
-);
-
-async function handleSearch() {
-  if (!keyword.value.trim()) return;
-  loading.value = true;
-  hasSearched.value = true;
-  try {
-    const jsonStr: string = await invoke('search_songs', { query: { keyword: keyword.value } });
-    const data = JSON.parse(jsonStr);
-    results.value = data.result?.songs || [];
-  } catch (e) {
-    console.error('搜索出错：', e);
-  } finally {
-    loading.value = false;
-  }
-}
-
-async function playSong(song: any) {
-  try {
-    await player.play(song);
-  } catch (e) {
-    alert('暂无播放源或需登录');
-  }
-}
-
-const devices = ref<string[]>([]);
-
-onMounted(async () => {
-  devices.value = await invoke('get_output_devices');
-});
-</script>
--- a/src/views/Settings.vue
+++ b/src/views/Settings.vue
@ -1,5 +1,5 @@
 <template>
-  <div class="p-8 text-content max-w-2xl">
+  <div class="p-8 text-content">
    <button @click="$router.back()" class="mb-4 text-content-2 hover:text-content transition">
      ← 返回
    </button>
@ -8,6 +8,14 @@
    <section class="mb-8">
      <h2 class="text-sm text-content-2 uppercase tracking-wider mb-4">播放</h2>
      <div class="space-y-5">
+        <div class="flex items-center justify-between">
+          <div>
+            <p class="text-sm font-medium">输出设备</p>
+            <p class="text-xs text-content-3 mt-0.5">选择音频播放设备</p>
+          </div>
+          <CustomSelect v-model="selectedDevice" :options="deviceOptions" />
+        </div>
+
        <div class="flex items-center justify-between">
          <div>
            <p class="text-sm font-medium">音质选择</p>
@ -20,23 +28,19 @@

    <section class="mb-8">
      <h2 class="text-sm text-content-2 uppercase tracking-wider mb-4">外观</h2>
-      <div class="space-y-5">
-        <div class="flex items-center justify-between">
-          <div>
-            <p class="text-sm font-medium">主题</p>
-            <p class="text-xs text-content-3 mt-0.5">切换应用主题</p>
-          </div>
-          <div class="flex bg-subtle rounded-lg p-0.5">
-            <button
-              v-for="t in themeOptions"
-              :key="t.value"
-              @click="settings.setTheme(t.value)"
-              class="px-3 py-1.5 rounded-md text-sm transition"
-              :class="settings.theme === t.value ? 'bg-muted text-content' : 'text-content-3 hover:text-content-2'"
-            >
-              {{ t.label }}
-            </button>
-          </div>
+      <div>
+        <p class="text-sm font-medium mb-3">主题色</p>
+        <div class="grid grid-cols-4 gap-3">
+          <button
+            v-for="(color, key) in themeColors"
+            :key="key"
+            @click="settings.setTheme(key)"
+            class="flex flex-col items-center gap-2 p-3 rounded-xl transition-all border-2"
+            :class="settings.theme === key ? 'border-white/30 bg-white/5 scale-[1.02]' : 'border-transparent bg-subtle hover:bg-muted'"
+          >
+            <div class="w-8 h-8 rounded-full shadow-md" :style="{ backgroundColor: color }"></div>
+            <span class="text-xs" :class="settings.theme === key ? 'text-content font-medium' : 'text-content-3'">{{ themeLabels[key] }}</span>
+          </button>
        </div>
      </div>
    </section>
@ -64,28 +68,89 @@
              <p class="text-xs text-content-3 mt-0.5">歌曲下载保存位置</p>
            </div>
          </div>
-          <div class="flex gap-2">
-            <input
-              v-model="downloadPathInput"
-              type="text"
-              placeholder="例如：~/Music/Nekosonic"
-              class="flex-1 bg-subtle border border-line rounded-lg px-3 py-2 text-sm text-content placeholder-content-4 outline-none focus:border-accent/50 transition"
-            />
+          <div class="flex gap-2 items-center">
+            <div class="flex-1 bg-subtle border border-line rounded-lg px-3 py-2 text-sm text-content-2 truncate" :title="settings.downloadPath || defaultDownloadPath">
+              {{ settings.downloadPath || defaultDownloadPath }}
+            </div>
            <button
-              @click="saveDownloadPath"
-              class="px-4 py-2 bg-accent-dim hover:bg-accent-dim text-accent-text rounded-lg text-sm transition"
+              @click="pickDownloadFolder"
+              class="px-4 py-2 rounded-lg text-sm font-medium transition-all duration-200 bg-accent/15 text-accent-text hover:bg-accent/25 active:scale-95"
            >
-              保存
+              选择文件夹
+            </button>
+            <button
+              v-if="settings.downloadPath"
+              @click="clearDownloadPath"
+              class="px-3 py-2 rounded-lg text-sm font-medium transition-all duration-200 bg-muted text-content-2 hover:bg-emphasis hover:text-content active:scale-95"
+              title="重置为默认路径"
+            >
+              重置
            </button>
          </div>
        </div>
      </div>
    </section>

+    <section class="mb-8">
+      <h2 class="text-sm text-content-2 uppercase tracking-wider mb-4">快捷键</h2>
+      <div class="space-y-3">
+        <div
+          v-for="(sc, id) in settings.shortcuts"
+          :key="id"
+          class="flex items-center justify-between p-3 bg-subtle rounded-xl"
+        >
+          <div>
+            <p class="text-sm font-medium">{{ sc.label }}</p>
+          </div>
+          <div class="flex items-center gap-1.5">
+            <button
+              v-if="sc.key !== defaultShortcuts[id]?.key"
+              @click="settings.setShortcut(String(id), defaultShortcuts[id].key)"
+              class="w-6 h-6 flex items-center justify-center rounded-md text-content-4 hover:text-danger hover:bg-danger/10 transition"
+              title="恢复默认"
+            >
+              <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><line x1="18" y1="6" x2="6" y2="18"/><line x1="6" y1="6" x2="18" y2="18"/></svg>
+            </button>
+            <button
+              @click="startRecording(String(id))"
+              class="px-3 py-1.5 rounded-lg text-sm transition min-w-[120px] text-center"
+              :class="recordingId === String(id) ? 'bg-accent text-white' : 'bg-muted hover:bg-emphasis text-content-2'"
+            >
+              {{ recordingId === String(id) ? '按下新快捷键...' : formatShortcut(sc.key) }}
+            </button>
+          </div>
+        </div>
+        <button
+          @click="resetShortcuts"
+          class="text-xs text-content-3 hover:text-danger transition"
+        >
+          恢复默认快捷键
+        </button>
+      </div>
+    </section>
+
+    <section class="mb-8">
+      <h2 class="text-sm text-content-2 uppercase tracking-wider mb-4">其他</h2>
+      <div class="space-y-3">
+        <div class="flex items-center justify-between p-3 bg-subtle rounded-xl">
+          <div>
+            <p class="text-sm font-medium">恢复默认设置</p>
+            <p class="text-xs text-content-3 mt-0.5">重置所有设置为初始状态</p>
+          </div>
+          <button
+            @click="handleResetAll"
+            class="px-3 py-1.5 rounded-lg text-sm bg-muted hover:bg-emphasis text-danger transition"
+          >
+            重置
+          </button>
+        </div>
+      </div>
+    </section>
+
    <section class="mb-8">
      <h2 class="text-sm text-content-2 uppercase tracking-wider mb-4">关于</h2>
      <div class="space-y-4">
-        <a @click.prevent="openUrl('https://gitea.atdunbg.xyz/atdunbg/Nekosonic-Music')"
+        <a @click.prevent="openUrl('https://github.com/atdunbg/Nekosonic-Music')"
          class="flex items-center gap-4 p-4 bg-subtle rounded-xl hover:bg-muted transition cursor-pointer">
          <img src="../assets/app-icon.png" class="w-12 h-12 rounded-xl flex-shrink-0" alt="Nekosonic" />
          <div>
@ -96,35 +161,134 @@
        <p class="text-xs text-content-3 leading-relaxed">
          Nekosonic 是一款高颜值的跨平台第三方网易云音乐桌面客户端，基于 Tauri 2 + Vue 3 构建，提供轻量流畅的音乐播放体验。
        </p>
-        <button
-          @click="checkUpdate"
-          :disabled="checkingUpdate"
-          class="flex items-center gap-2 px-4 py-2 bg-subtle hover:bg-muted rounded-lg text-sm transition"
-        >
-          <svg v-if="!checkingUpdate" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M21 12a9 9 0 01-9 9m9-9a9 9 0 00-9-9m9 9H3m9 9a9 9 0 01-9-9m9 9c1.66 0 3-4.03 3-9s-1.34-9-3-9m0 18c-1.66 0-3-4.03-3-9s1.34-9 3-9m-9 9a9 9 0 019-9"/></svg>
-          <svg v-else class="animate-spin" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M21 12a9 9 0 11-6.22-8.56"/></svg>
-          {{ checkingUpdate ? '检查中...' : '检查更新(暂未实现)' }}
-        </button>
-        <p v-if="updateMessage" class="text-xs" :class="updateMessageClass">{{ updateMessage }}</p>
+        <div class="flex items-center gap-2">
+          <button
+            @click="handleCheckUpdate"
+            :disabled="updater.checking.value"
+            class="flex items-center gap-2 px-4 py-2 bg-subtle hover:bg-muted rounded-lg text-sm transition"
+          >
+            <svg v-if="!updater.checking.value" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M14 2H6a2 2 0 00-2 2v16a2 2 0 002 2h12a2 2 0 002-2V8z"/><polyline points="14 2 14 8 20 8"/><line x1="16" y1="13" x2="8" y2="13"/><line x1="16" y1="17" x2="8" y2="17"/><polyline points="10 9 9 9 8 9"/></svg>
+            <svg v-else class="animate-spin" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M21 12a9 9 0 11-6.22-8.56"/></svg>
+            {{ updater.checking.value ? '检查中...' : '检查更新' }}
+          </button>
+          <button
+            @click="fetchChangelog"
+            :disabled="fetchingChangelog"
+            class="flex items-center gap-2 px-4 py-2 bg-subtle hover:bg-muted rounded-lg text-sm transition"
+          >
+            <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M14 2H6a2 2 0 00-2 2v16a2 2 0 002 2h12a2 2 0 002-2V8z"/><polyline points="14 2 14 8 20 8"/><line x1="16" y1="13" x2="8" y2="13"/><line x1="16" y1="17" x2="8" y2="17"/></svg>
+            {{ fetchingChangelog ? '获取中...' : '更新日志' }}
+          </button>
+        </div>
+        <p v-if="updater.error.value" class="text-xs text-content-3">{{ updater.error.value }}</p>
      </div>
    </section>
+    <Transition name="fade">
+      <div v-if="showResetConfirm" class="fixed inset-0 z-50 flex items-center justify-center bg-black/60 backdrop-blur-sm" @click.self="showResetConfirm = false">
+        <div class="bg-surface border border-line rounded-2xl shadow-2xl w-80 p-6 select-auto">
+          <h2 class="text-lg font-semibold text-content mb-1">确认重置</h2>
+          <p class="text-sm text-content-2 mb-5">所有设置将恢复为默认值，此操作不可撤销。</p>
+          <div class="flex gap-3">
+            <button @click="showResetConfirm = false"
+              class="flex-1 py-2 rounded-lg bg-muted hover:bg-emphasis text-sm text-content-2 transition">
+              取消
+            </button>
+            <button @click="confirmResetAll"
+              class="flex-1 py-2 rounded-lg bg-danger/20 hover:bg-danger/30 text-danger text-sm font-medium transition">
+              确认重置
+            </button>
+          </div>
+        </div>
+      </div>
+    </Transition>
+
+    <Transition name="fade">
+      <div v-if="showChangelogModal" class="fixed inset-0 z-50 flex items-center justify-center bg-black/60 backdrop-blur-sm" @click.self="showChangelogModal = false">
+        <div class="bg-surface border border-line rounded-2xl shadow-2xl w-[480px] max-h-[80vh] flex flex-col select-auto">
+          <div class="p-6 pb-4">
+            <div class="flex items-center justify-between mb-1">
+              <h2 class="text-lg font-semibold text-content">更新日志</h2>
+              <span v-if="changelogRelease" class="text-xs font-medium px-2 py-0.5 rounded-full bg-accent/15 text-accent-text">v{{ changelogRelease.tag_name?.replace('v', '') }}</span>
+            </div>
+            <p v-if="changelogRelease?.published_at" class="text-xs text-content-3 mt-1">{{ formatDate(changelogRelease.published_at) }}</p>
+          </div>
+          <div v-if="changelogRelease?.body" class="px-6 pb-4 flex-1 overflow-y-auto max-h-60">
+            <div class="text-sm text-content-2 leading-relaxed whitespace-pre-wrap">{{ changelogRelease.body }}</div>
+          </div>
+          <div v-else class="px-6 pb-4">
+            <p class="text-sm text-content-3">暂无更新日志</p>
+          </div>
+          <div class="p-4 border-t border-line flex gap-3">
+            <button @click="showChangelogModal = false"
+              class="flex-1 py-2 rounded-lg bg-muted hover:bg-emphasis text-sm text-content-2 transition">
+              关闭
+            </button>
+            <button v-if="changelogRelease?.html_url" @click="openUrl(changelogRelease.html_url)"
+              class="flex-1 py-2 rounded-lg bg-accent/20 hover:bg-accent/30 text-accent-text text-sm font-medium transition">
+              在 GitHub 中查看
+            </button>
+          </div>
+        </div>
+      </div>
+    </Transition>
+
  </div>
 </template>

 <script setup lang="ts">
-import { ref, computed, onMounted } from 'vue';
-import { useSettingsStore, qualityLabels, closeActionLabels, type CloseAction } from '../stores/settings';
+import { ref, computed, onMounted, onBeforeUnmount } from 'vue';
+import { useSettingsStore, qualityLabels, closeActionLabels, defaultShortcuts, themeLabels, themeColors, type CloseAction } from '../stores/settings';
 import { useToast } from '../composables/useToast';
+import { useUpdater } from '../composables/useUpdater';
+import { invoke } from '@tauri-apps/api/core';
 import { getVersion } from '@tauri-apps/api/app';
 import { openUrl } from '@tauri-apps/plugin-opener';
+import { open } from '@tauri-apps/plugin-dialog';
 import CustomSelect from '../components/CustomSelect.vue';

 const settings = useSettingsStore();
 const { showToast } = useToast();
+const updater = useUpdater();
+
+const devices = ref<string[]>([]);
+const deviceOptions = computed(() => {
+  const options: Record<string, string> = { '': '跟随系统默认' };
+  for (const name of devices.value) {
+    options[name] = name;
+  }
+  return options;
+});
+
+const selectedDevice = computed({
+  get: () => settings.outputDevice || '',
+  set: (val: string) => {
+    const device = val === '' ? null : val;
+    settings.setOutputDevice(device);
+    invoke('set_output_device', { device }).then(() => {
+      showToast(device ? `已切换到: ${device}` : '已切换到系统默认', 'success');
+    }).catch((e) => {
+      console.error('切换设备失败: ', e);
+      showToast('切换设备失败', 'error');
+    });
+  }
+});
+
+async function loadDevices() {
+  try {
+    devices.value = await invoke<string[]>('get_output_devices');
+  } catch (e) {
+    console.error('获取设备失败: ', e);
+  }
+}

 const appVersion = ref('');
+const defaultDownloadPath = ref('');
 onMounted(async () => {
  appVersion.value = await getVersion();
+  try {
+    defaultDownloadPath.value = await invoke<string>('get_default_download_path');
+  } catch { }
+  loadDevices();
 });

 const closeActionValue = computed({
@ -132,33 +296,134 @@ const closeActionValue = computed({
  set: (val: CloseAction) => settings.setCloseAction(val),
 });

-const downloadPathInput = ref(settings.downloadPath);
-const checkingUpdate = ref(false);
-const updateMessage = ref('');
-const updateMessageClass = ref('text-content-2');
-
-const themeOptions = [
-  { label: '深色', value: 'dark' as const },
-  { label: '浅色', value: 'light' as const },
-];
-
-function saveDownloadPath() {
-  settings.setDownloadPath(downloadPathInput.value.trim());
-  showToast('下载路径已保存', 'success');
-}
-
-async function checkUpdate() {
-  checkingUpdate.value = true;
-  updateMessage.value = '';
-  try {
-    await new Promise(r => setTimeout(r, 1500));
-    updateMessage.value = '当前已是最新版本';
-    updateMessageClass.value = 'text-accent-text';
-  } catch {
-    updateMessage.value = '检查更新失败，请稍后重试';
-    updateMessageClass.value = 'text-danger';
-  } finally {
-    checkingUpdate.value = false;
+async function pickDownloadFolder() {
+  const selected = await open({
+    directory: true,
+    multiple: false,
+    title: '选择下载路径',
+  });
+  if (selected) {
+    settings.setDownloadPath(selected);
+    showToast('下载路径已更新', 'success');
  }
 }
+
+function clearDownloadPath() {
+  settings.setDownloadPath('');
+  showToast('已重置为默认路径', 'success');
+}
+
+async function handleCheckUpdate() {
+  const result = await updater.checkForUpdate(false);
+  if (!result) {
+    showToast(updater.error.value || '当前已是最新版本', 'info');
+  }
+}
+
+const fetchingChangelog = ref(false);
+const changelogRelease = ref<any>(null);
+const showChangelogModal = ref(false);
+
+async function fetchChangelog() {
+  fetchingChangelog.value = true;
+  try {
+    const resp = await fetch('https://api.github.com/repos/atdunbg/Nekosonic-Music/releases?per_page=1');
+    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+    const releases = await resp.json();
+    if (releases && releases.length > 0) {
+      changelogRelease.value = releases[0];
+      showChangelogModal.value = true;
+    } else {
+      showToast('暂无发布版本', 'info');
+    }
+  } catch (e: any) {
+    showToast(`获取失败: ${e}`, 'error');
+  } finally {
+    fetchingChangelog.value = false;
+  }
+}
+
+function formatDate(dateStr: string) {
+  try {
+    const d = new Date(dateStr);
+    return d.toLocaleDateString('zh-CN', { year: 'numeric', month: 'long', day: 'numeric' });
+  } catch {
+    return dateStr;
+  }
+}
+
+const recordingId = ref<string | null>(null);
+
+function formatShortcut(key: string): string {
+  return key
+    .replace('Control', 'Ctrl')
+    .replace('ArrowLeft', '←')
+    .replace('ArrowRight', '→')
+    .replace('ArrowUp', '↑')
+    .replace('ArrowDown', '↓')
+    .replace(/Key([A-Z])/g, '$1')
+    .replace(/\+/g, ' + ');
+}
+
+function startRecording(id: string) {
+  recordingId.value = id;
+}
+
+function resetShortcuts() {
+  settings.resetShortcuts();
+  showToast('快捷键已恢复默认', 'success');
+}
+
+const showResetConfirm = ref(false);
+
+function handleResetAll() {
+  showResetConfirm.value = true;
+}
+
+function confirmResetAll() {
+  settings.resetAll();
+  showResetConfirm.value = false;
+  showToast('已恢复默认设置', 'success');
+}
+
+function onRecordingKeydown(e: KeyboardEvent) {
+  if (!recordingId.value) return;
+  e.preventDefault();
+  e.stopPropagation();
+
+  if (e.key === 'Escape') {
+    recordingId.value = null;
+    return;
+  }
+
+  const parts: string[] = [];
+  if (e.ctrlKey || e.metaKey) parts.push('Control');
+  if (e.altKey) parts.push('Alt');
+  if (e.shiftKey) parts.push('Shift');
+
+  const ignoredKeys = ['Control', 'Alt', 'Shift', 'Meta'];
+  if (!ignoredKeys.includes(e.key)) {
+    parts.push(e.code);
+  }
+
+  if (parts.length > 0 && !ignoredKeys.includes(e.key)) {
+    const hasModifier = parts.includes('Control') || parts.includes('Alt') || parts.includes('Shift');
+    if (!hasModifier) {
+      showToast('快捷键必须包含 Ctrl、Alt 或 Shift', 'error');
+      recordingId.value = null;
+      return;
+    }
+    const combo = parts.join('+');
+    settings.setShortcut(recordingId.value, combo);
+    recordingId.value = null;
+  }
+}
+
+onMounted(() => {
+  window.addEventListener('keydown', onRecordingKeydown, true);
+});
+
+onBeforeUnmount(() => {
+  window.removeEventListener('keydown', onRecordingKeydown, true);
+});
 </script>
--- a/tsconfig.node.json
+++ b/tsconfig.node.json
@ -7,4 +7,4 @@
    "allowSyntheticDefaultImports": true
  },
  "include": ["vite.config.ts"]
-}
+}
Author	SHA1	Message	Date
Atdunbg	65ed71503e	feat: 架构重构与跨平台媒体控制集成 ## 后端 - 替换 rodio 为 symphonia + ringbuf，重构 audio.rs 播放引擎 - 重构 api.rs，使用 api_call! 宏统一 API 调用模式 - 新增 media_controls.rs，使用 souvlaki 实现跨平台系统媒体控制 (Linux MPRIS / Windows SMTC / macOS Now Playing) - 版本号升至 v0.5.0 ## 前端 - 新增 - 新增 SongListItem 通用组件 - 新增 useOnlineStatus composable，检测网络状态 - 新增 usePageCache composable，页面数据缓存与失效 - 新增 getCoverUrl()、formatDate() 工具函数 - 新增 emitPlaybackState() 同步播放状态到系统媒体控制 - 新增 mpris-command 事件监听，响应系统媒体控制命令 - 新增 Toast 离线/恢复在线提示 - 各页面新增断网恢复后自动重试加载 - 新增路由守卫：已登录用户访问 /login 重定向至首页 - 新增音量持久化（settings store + localStorage） - 新增禁用右键菜单与用户选择限制（输入框除外） ## 前端 - 变更 - Song 接口从 player.ts 迁移至 song.ts 并导出 - AlbumDetail/ArtistDetail/PlaylistDetail/RecentPlays/LocalMusic 迁移至 SongListItem - PlayerBar 队列列表迁移至 SongListItem，封面使用 getCoverUrl() - downloadSong 参数类型从内联对象改为 Song，使用 getCoverUrl() - 默认主题从 green 改为 blue，ThemeName 及相关列表中 blue 移至首位 - 全局快捷键从 Alt+Control 改为 Control+Alt 顺序 - formatShortcut 新增 KeyP → P 显示 - keep-alive 从 max=3 固定 include 改为 max=5 动态列表，窗口隐藏时释放 - App.vue 封面使用 getCoverUrl() 替代手动 al/album 回退 - formatPlayCount 提取常量 - Login.vue text-warning 改为 text-yellow-400 ## 前端 - 删除 - 删除 Search.vue（与 Discover.vue 重复） - 删除 SongItemMenu.vue（被 SongListItem 替代） ## 修复 - 更新器跳过版本逻辑：仅静默检查时跳过已忽略版本，手动检查不再跳过 - 重复播放同一首歌时无法恢复播放 - settings.ts 重复的 ThemeName 定义 - PlayerBar.vue modeTexts 缺少类型注解 - Home.vue map 回调参数缺少类型 - Settings.vue v-for key 类型不匹配	2026-05-23 14:43:47 +08:00
Atdunbg	970fb15f5a	重构播放列表为右侧弹出式播放列表可以定位正在播放的歌曲位置添加歌词翻译新增快捷键播放/暂停重构主题设置，支持多种主题修复评论playerbar查看点击后一直默认评论打开抽屉页面问题	2026-05-22 00:54:09 +08:00
Atdunbg	cf21c96eaf	更新版本至 v0.4.1	2026-05-21 14:22:14 +08:00
Atdunbg	987d34f58b	修改changelog	2026-05-18 15:58:56 +08:00
Atdunbg	baa6235c56	添加设置音频输出选择	2026-05-18 15:52:51 +08:00
Atdunbg	38c079ed5c	更新README	2026-05-16 15:29:58 +08:00
Atdunbg	68e3b92a6a	设置页面自适应，添加查看最新版本日志按钮	2026-05-16 13:34:10 +08:00
Atdunbg	d718ee5b42	修复错误workflow变量	2026-05-16 12:36:29 +08:00
Atdunbg	966825c885	添加自动更新功能	2026-05-16 12:17:41 +08:00
Atdunbg	e8efc7275a	更新workflow	2026-05-16 02:20:34 +08:00
Atdunbg	0740d9be29	更新workflow	2026-05-16 02:02:36 +08:00
Atdunbg	d2546ca93c	Update Linux dependencies in release workflow	2026-05-16 01:35:48 +08:00
Atdunbg	29df8ca491	添加意外删除的'vite.config.ts'文件	2026-05-16 01:06:40 +08:00
Atdunbg	3158338d0b	添加意外删除的'tsconfig.node.json'文件	2026-05-16 00:54:01 +08:00
Atdunbg	79fb001ae7	修改错误的workflow命名	2026-05-16 00:48:02 +08:00
Atdunbg	fd4bbb4a0a	添加 CHANGELOG	2026-05-16 00:41:49 +08:00
Atdunbg	3b800e451f	- 歌手相关功能添加: 添加歌曲的艺术家入口, 歌曲的艺术家现可点击查看其他歌曲，专辑和介绍 - 歌曲评论功能添加: 添加歌曲的评论查看功能 - 修复私人漫游自动播放下一首调用多次问题 - 优化播放逻辑，歌曲列表在点击时候不在单首累加, 而是直接获取当前列表所有的歌曲作为播放内容	2026-05-16 00:11:37 +08:00
Atdunbg	718d3ed641	feat: v0.3.0 - 流式播放、本地音乐、下载系统、漫游修复 ### 新功能 - 流式播放：边下载边播放，缓冲 64KB 后即刻开始，无需等待完整下载 - 本地音乐页面：支持浏览、播放本地歌曲，横向菜单含「从磁盘删除」 - 下载系统：支持下载歌曲到自定义路径，保存完整元数据（封面/专辑/时长） - 封面补全：本地音乐缺少封面时自动从网易云 API 获取 - 更新信息：接入 Gitea Releases API，查看最新版更新日志 ### 修复 - 修复私人漫游播完一首歌后跳三首的问题（双重触发：audio-ended + startTick） - 修复全屏漫游抽屉和漫游页面无封面歌曲显示破损图片 - 修复 PlayerBar 无封面歌曲显示破损图片 - 修复下载路径修改后不生效（Rust serde camelCase 映射） - 修复本地音乐始终只显示默认路径歌曲 - 修复下载完成提示弹出 4 次 - 修复播放网络歌曲时进度条先走但无声音（audio-started 事件同步） ### 优化 - PlayerBar 下载状态：未下载显示下载按钮，下载中显示进度，已下载不显示 - audio.rs 新增 manual_stop 标志防止 stop_audio 触发虚假 audio-ended - player.ts 新增 waitForAudioStart() 确保 playing 状态与实际播放同步 - 切歌/停止时立即清除 tickInterval 防止重复触发 next()	2026-05-15 02:24:48 +08:00
Atdunbg	02f7df4201	设置应用为单例，防止多个实例同时存在	2026-05-12 06:31:37 +08:00