✨ feat: changelog

✨ feat: 添加 B站视频 ID 匹配逻辑，优化收藏功能以支持 B站视频，确保收藏列表一致性

.cursor/rules/music-vue-rule.mdc

@@ -3,7 +3,7 @@ description: 这个规则是项目描述
 globs: 
 alwaysApply: false
 ---
-您是 TypeScript、Node.j、Vue3、Electron、naive-ui、VueUse 和 Tailwind 方面的专家。
+您是 TypeScript、Node.js、Vue3、Electron、naive-ui、VueUse 和 Tailwind 方面的专家。
 
 项目结构
 - 这是 Electron 项目，使用 Vue3 和 Pinia 进行开发的第三方网易云音乐播放器。

.eslintrc.cjs

@@ -5,7 +5,6 @@ module.exports = {
   extends: [
     'eslint:recommended',
     'plugin:@typescript-eslint/recommended', 
-    'eslint-config-airbnb-base',
     '@vue/typescript/recommended',
     'plugin:vue/vue3-recommended',
     'plugin:vue-scoped-css/base',

.gitignore

@@ -25,3 +25,5 @@ out
 .cursorrules
 
 .github/deploy_keys
+
+resources/android/**/*

CHANGELOG.md

@@ -1,22 +1,27 @@
 # 更新日志
 
-## v4.2.0
+## v4.6.0
+> 如果更新遇到问题，请前往 <a href="http://donate.alger.fun/download" target="_blank">下载 AlgerMusicPlayer</a>
+
+> 请我喝咖啡(支持作者) ☕️ <a href="http://donate.alger.fun/donate" target="_blank" style="color: red; font-weight: bold;">赏你</a>
+
+> 帮我点个 star <a href="https://github.com/algerkong/AlgerMusicPlayer" target="_blank">github star</a>
+
+> QQ群 976962720
 
 ### ✨ 新功能
-- 添加迷你播放器模式 （[0f55795](https://github.com/algerkong/AlgerMusicPlayer/commit/0f55795))
+- 增加音源重新解析功能 ([82a69d0](https://github.com/algerkong/AlgerMusicPlayer/commit/82a69d0))
-- 更新网易云音乐API版本，添加B站视频搜索功能和播放器组件 ([280fec1](https://github.com/algerkong/AlgerMusicPlayer/commit/280fec1))
+- 搜索列表添加下一首播放功能，修改播放逻辑搜索的歌曲点击播放不重新覆盖播放列表，添加全部播放功能 ([31640bb](https://github.com/algerkong/AlgerMusicPlayer/commit/31640bb)) (#216)
-- mac端添加状态栏 显示当前播放歌曲和操作按钮 ([374a7a8](https://github.com/algerkong/AlgerMusicPlayer/commit/374a7a8))
+- 增加windows和linux对arm64架构的支持([9f125f8](https://github.com/algerkong/AlgerMusicPlayer/commit/9f125f8))
-- 添加音频URL过期事件监听，自动重新获取B站和网易云音乐音频URL并恢复播放 ([ee6e9d4](https://github.com/algerkong/AlgerMusicPlayer/commit/ee6e9d4))
+- 添加"收藏"功能至托盘菜单 ([3c1a144](https://github.com/algerkong/AlgerMusicPlayer/commit/3c1a144))
-- 优化搜索功能，改进搜索历史管理和路由处理逻辑 ([477f8bb](https://github.com/algerkong/AlgerMusicPlayer/commit/477f8bb))
+- 修改将歌单列表改为页面 ([e2527c3](https://github.com/algerkong/AlgerMusicPlayer/commit/e2527c3))
-- 在播放列表中添加歌曲删除功能，优化播放列表管理逻辑 ([a5f694e](https://github.com/algerkong/AlgerMusicPlayer/commit/a5f694e)) (#94)
-- 优化歌词窗口字体控制按钮样式 ([c5e50c9](https://github.com/algerkong/AlgerMusicPlayer/commit/c5e50c9))
-- 优化首页banner加载逻辑 ([01ccad4](https://github.com/algerkong/AlgerMusicPlayer/commit/01ccad4))
-- 优化歌手详情页面 由抽屉改为页面 ([dfb8f55](https://github.com/algerkong/AlgerMusicPlayer/commit/dfb8f55))
-- 增加用户关注列表和关注用户详情页 可查看听歌排行和用户歌单 ([2924ad6](https://github.com/algerkong/AlgerMusicPlayer/commit/2924ad6))
-- 优化进度条 鼠标悬停直接显示进度信息 ([9ce872e](https://github.com/algerkong/AlgerMusicPlayer/commit/9ce872e))
-- 优化应用更新下载功能 可后台下载 弹出下载完成提示 不再自动关闭应用 ([23b2340](https://github.com/algerkong/AlgerMusicPlayer/commit/23b2340))
 
 ### 🐛 Bug 修复
-- 修复进度条多次拖动和多次暂停播放引发的歌曲重复播放bug ([cfe197c](https://github.com/algerkong/AlgerMusicPlayer/commit/cfe197c)) (#104)
+- 修复歌曲加入歌单失败问题 ([8045034](https://github.com/algerkong/AlgerMusicPlayer/commit/8045034))
-- 修复关闭按钮最小化 还在任务栏显示的bug ([e0d1305](https://github.com/algerkong/AlgerMusicPlayer/commit/e0d1305))
+
-- 修复播放列表中歌曲删除时类型不匹配的问题 ([8d6d052](https://github.com/algerkong/AlgerMusicPlayer/commit/8d6d052))
+### 🎨 优化
+- 优化播放器逻辑，改进播放失败处理，支持保持当前索引并增加重试机制，优化操作锁逻辑，添加超时检查机制，确保操作锁在超时后自动释放，增加超时处理([8ed13d4](https://github.com/algerkong/AlgerMusicPlayer/commit/8ed13d4))、([cb58abb](https://github.com/algerkong/AlgerMusicPlayer/commit/cb58abb)) ([9cc064c](https://github.com/algerkong/AlgerMusicPlayer/commit/9cc064c))
+- 更新 Electron 版本至 36.2.0，优化歌词视图的悬停效果 ([44f9709](https://github.com/algerkong/AlgerMusicPlayer/commit/44f9709))
+- 更新音乐源设置([618c345](https://github.com/algerkong/AlgerMusicPlayer/commit/618c345))
+- 修改 MiniPlayBar 组件，调整音量滑块的样式和交互方式，优化悬停效果 ([31ea3b7](https://github.com/algerkong/AlgerMusicPlayer/commit/31ea3b7))
+- 优化 MvPlayer 组件的关闭逻辑，简化音频暂停处理 ([b3de2ae](https://github.com/algerkong/AlgerMusicPlayer/commit/b3de2ae))、([15f4ea4](https://github.com/algerkong/AlgerMusicPlayer/commit/15f4ea4))

README.md

@@ -14,20 +14,22 @@
   - 支持歌单、MV、专辑等完整音乐服务
   - 灰色音乐资源解析（基于 @unblockneteasemusic/server）
   - 高品质音乐试听（需网易云VIP）
-  - 音乐文件下载（支持右键下载和批量下载）
+  - 音乐文件下载（支持右键下载和批量下载, 附带歌词封面等信息）
 - 🚀 技术特性
   - 本地化服务，无需依赖在线API (基于 netease-cloud-music-api)
   - 自动更新检测
-  - 全平台适配（Desktop & Web & Mobile Web）
+  - 全平台适配（Desktop & Web & Mobile Web & Android<后续> & ios<后续>）
 
 ## 项目简介
- 一个基于 electron typescript vue3 的桌面音乐播放器 适配 web端 桌面端 web移动端
+ 一个第三方音乐播放器、本地服务、桌面歌词、音乐下载、最高音质
 
 ## 预览地址
 [http://mc.alger.fun/](http://mc.alger.fun/)
 
 QQ群:789288579
 
+tg群:[AlgerMusic tg](https://t.me/+9efsKRuvKBk2NWVl)
+
 ## 软件截图
 ![首页白](./docs/image.png)
 ![首页黑](./docs/image3.png)

android/.gitignore

@@ -0,0 +1,101 @@
+# Using Android gitignore template: https://github.com/github/gitignore/blob/HEAD/Android.gitignore
+
+# Built application files
+*.apk
+*.aar
+*.ap_
+*.aab
+
+# Files for the ART/Dalvik VM
+*.dex
+
+# Java class files
+*.class
+
+# Generated files
+bin/
+gen/
+out/
+#  Uncomment the following line in case you need and you don't have the release build type files in your app
+# release/
+
+# Gradle files
+.gradle/
+build/
+
+# Local configuration file (sdk path, etc)
+local.properties
+
+# Proguard folder generated by Eclipse
+proguard/
+
+# Log Files
+*.log
+
+# Android Studio Navigation editor temp files
+.navigation/
+
+# Android Studio captures folder
+captures/
+
+# IntelliJ
+*.iml
+.idea/workspace.xml
+.idea/tasks.xml
+.idea/gradle.xml
+.idea/assetWizardSettings.xml
+.idea/dictionaries
+.idea/libraries
+# Android Studio 3 in .gitignore file.
+.idea/caches
+.idea/modules.xml
+# Comment next line if keeping position of elements in Navigation Editor is relevant for you
+.idea/navEditor.xml
+
+# Keystore files
+# Uncomment the following lines if you do not want to check your keystore files in.
+#*.jks
+#*.keystore
+
+# External native build folder generated in Android Studio 2.2 and later
+.externalNativeBuild
+.cxx/
+
+# Google Services (e.g. APIs or Firebase)
+# google-services.json
+
+# Freeline
+freeline.py
+freeline/
+freeline_project_description.json
+
+# fastlane
+fastlane/report.xml
+fastlane/Preview.html
+fastlane/screenshots
+fastlane/test_output
+fastlane/readme.md
+
+# Version control
+vcs.xml
+
+# lint
+lint/intermediates/
+lint/generated/
+lint/outputs/
+lint/tmp/
+# lint/reports/
+
+# Android Profiling
+*.hprof
+
+# Cordova plugins for Capacitor
+capacitor-cordova-android-plugins
+
+# Copied web assets
+app/src/main/assets/public
+
+# Generated Config files
+app/src/main/assets/capacitor.config.json
+app/src/main/assets/capacitor.plugins.json
+app/src/main/res/xml/config.xml

package.json

@@ -1,6 +1,6 @@
 {
   "name": "AlgerMusicPlayer",
-  "version": "4.2.0",
+  "version": "4.6.0",
   "description": "Alger Music Player",
   "author": "Alger <algerkc@qq.com>",
   "main": "./out/main/index.js",
@@ -21,53 +21,57 @@
     "build:linux": "npm run build && electron-builder --linux"
   },
   "dependencies": {
-    "@electron-toolkit/preload": "^3.0.0",
+    "@electron-toolkit/preload": "^3.0.1",
-    "@electron-toolkit/utils": "^3.0.0",
+    "@electron-toolkit/utils": "^4.0.0",
     "@unblockneteasemusic/server": "^0.27.8-patch.1",
+    "cors": "^2.8.5",
     "electron-store": "^8.1.0",
-    "electron-updater": "^6.1.7",
+    "express": "^4.18.2",
+    "electron-updater": "^6.6.2",
     "font-list": "^1.5.1",
     "netease-cloud-music-api-alger": "^4.26.1",
-    "vue-i18n": "9"
+    "node-id3": "^0.2.9",
+    "node-machine-id": "^1.1.12",
+    "vue-i18n": "^11.1.3"
   },
   "devDependencies": {
-    "@electron-toolkit/eslint-config": "^1.0.2",
+    "@electron-toolkit/eslint-config": "^2.1.0",
-    "@electron-toolkit/eslint-config-ts": "^2.0.0",
+    "@electron-toolkit/eslint-config-ts": "^3.1.0",
     "@electron-toolkit/tsconfig": "^1.0.1",
     "@rushstack/eslint-patch": "^1.10.3",
     "@tailwindcss/postcss7-compat": "^2.2.4",
     "@types/howler": "^2.2.12",
     "@types/node": "^20.14.8",
     "@types/tinycolor2": "^1.4.6",
-    "@typescript-eslint/eslint-plugin": "^7.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.30.1",
-    "@typescript-eslint/parser": "^7.0.0",
+    "@typescript-eslint/parser": "^8.30.1",
     "@vitejs/plugin-vue": "^5.0.5",
     "@vue/compiler-sfc": "^3.5.0",
-    "@vue/eslint-config-prettier": "^9.0.0",
+    "@vue/eslint-config-prettier": "^10.2.0",
-    "@vue/eslint-config-typescript": "^13.0.0",
+    "@vue/eslint-config-typescript": "^14.5.0",
     "@vue/runtime-core": "^3.5.0",
-    "@vueuse/core": "^11.0.3",
+    "@vueuse/core": "^11.3.0",
-    "@vueuse/electron": "^11.0.3",
+    "@vueuse/electron": "^11.3.0",
     "animate.css": "^4.1.1",
     "autoprefixer": "^10.4.20",
     "axios": "^1.7.7",
     "cross-env": "^7.0.3",
-    "electron": "^35.0.2",
+    "electron": "^36.1.0",
     "electron-builder": "^25.1.8",
-    "electron-vite": "^3.0.0",
+    "electron-vite": "^3.1.0",
-    "eslint": "^8.57.0",
+    "eslint": "^9.0.0",
-    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-config-prettier": "^10.1.2",
-    "eslint-config-prettier": "^9.0.0",
     "eslint-plugin-import": "^2.29.1",
     "eslint-plugin-prettier": "^5.1.3",
     "eslint-plugin-simple-import-sort": "^12.0.0",
-    "eslint-plugin-vue": "^9.26.0",
+    "eslint-plugin-vue": "^10.0.0",
-    "eslint-plugin-vue-scoped-css": "^2.7.2",
+    "eslint-plugin-vue-scoped-css": "^2.9.0",
     "howler": "^2.2.4",
     "lodash": "^4.17.21",
     "marked": "^15.0.4",
     "naive-ui": "^2.41.0",
     "pinia": "^3.0.1",
+    "pinyin-match": "^1.2.6",
     "postcss": "^8.5.3",
     "prettier": "^3.3.2",
     "remixicon": "^4.6.0",
@@ -95,6 +99,13 @@
         "repo": "AlgerMusicPlayer"
       }
     ],
+    "extraResources": [
+      {
+        "from": "resources/html",
+        "to": "html",
+        "filter": ["**/*"]
+      }
+    ],
     "mac": {
       "icon": "resources/icon.icns",
       "target": [

resources/html/remote-control.html

@@ -0,0 +1,486 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
+  <title>AlgerMusicPlayer 远程控制</title>
+  <style>
+    :root {
+      --primary-color: #007AFF;
+      --secondary-color: #5AC8FA;
+      --success-color: #4CD964;
+      --danger-color: #FF3B30;
+      --warning-color: #FF9500;
+      --light-gray: #F2F2F7;
+      --medium-gray: #E5E5EA;
+      --dark-gray: #8E8E93;
+      --text-color: #000000;
+      --text-secondary: #6C6C6C;
+      --background-color: #FFFFFF;
+    }
+
+    @media (prefers-color-scheme: dark) {
+      :root {
+        --primary-color: #0A84FF;
+        --secondary-color: #64D2FF;
+        --success-color: #30D158;
+        --danger-color: #FF453A;
+        --warning-color: #FF9F0A;
+        --light-gray: #1C1C1E;
+        --medium-gray: #2C2C2E;
+        --dark-gray: #8E8E93;
+        --text-color: #FFFFFF;
+        --text-secondary: #AEAEB2;
+        --background-color: #000000;
+      }
+    }
+
+    * {
+      margin: 0;
+      padding: 0;
+      box-sizing: border-box;
+      -webkit-tap-highlight-color: transparent;
+    }
+
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'SF Pro Text', 'Helvetica Neue', Arial, sans-serif;
+      line-height: 1.6;
+      color: var(--text-color);
+      background-color: var(--light-gray);
+      display: flex;
+      flex-direction: column;
+      min-height: 100vh;
+      padding: 0;
+      margin: 0;
+    }
+
+    .header {
+      position: sticky;
+      top: 0;
+      z-index: 100;
+      background-color: var(--background-color);
+      padding: 12px 16px;
+      text-align: center;
+      border-bottom: 1px solid var(--medium-gray);
+      backdrop-filter: blur(10px);
+      -webkit-backdrop-filter: blur(10px);
+    }
+
+    .header h1 {
+      font-size: 18px;
+      font-weight: 600;
+      margin: 0;
+    }
+
+    .container {
+      max-width: 540px;
+      margin: 0 auto;
+      padding: 16px;
+      width: 100%;
+      flex: 1;
+    }
+
+    .card {
+      background-color: var(--background-color);
+      border-radius: 12px;
+      padding: 16px;
+      margin-bottom: 16px;
+      box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+    }
+
+    .song-info {
+      display: flex;
+      align-items: center;
+      padding-bottom: 16px;
+    }
+
+    .song-cover {
+      width: 72px;
+      height: 72px;
+      border-radius: 8px;
+      object-fit: cover;
+      box-shadow: 0 2px 8px rgba(0,0,0,0.15);
+      background-color: var(--medium-gray);
+    }
+
+    .song-details {
+      margin-left: 16px;
+      flex: 1;
+    }
+
+    .song-details h2 {
+      margin: 0;
+      font-size: 18px;
+      font-weight: 600;
+      color: var(--text-color);
+      white-space: nowrap;
+      overflow: hidden;
+      text-overflow: ellipsis;
+    }
+
+    .song-details p {
+      margin: 4px 0 0;
+      font-size: 15px;
+      color: var(--text-secondary);
+      white-space: nowrap;
+      overflow: hidden;
+      text-overflow: ellipsis;
+    }
+
+    .play-state {
+      font-size: 14px;
+      color: var(--primary-color);
+      margin-top: 4px;
+      display: flex;
+      align-items: center;
+    }
+
+    .play-state::before {
+      content: '';
+      display: inline-block;
+      width: 8px;
+      height: 8px;
+      border-radius: 50%;
+      margin-right: 6px;
+    }
+
+    .playing .play-state::before {
+      background-color: var(--success-color);
+    }
+
+    .paused .play-state::before {
+      background-color: var(--warning-color);
+    }
+
+    .controls {
+      display: grid;
+      grid-template-columns: repeat(3, 1fr);
+      gap: 12px;
+      margin-bottom: 16px;
+    }
+
+    .extra-controls {
+      display: grid;
+      grid-template-columns: repeat(2, 1fr);
+      gap: 12px;
+    }
+
+    .btn {
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      background-color: var(--background-color);
+      color: var(--primary-color);
+      border: 1px solid var(--medium-gray);
+      padding: 16px 0;
+      border-radius: 12px;
+      cursor: pointer;
+      font-size: 14px;
+      font-weight: 500;
+      transition: all 0.2s ease;
+      user-select: none;
+      position: relative;
+      overflow: hidden;
+    }
+
+    .btn:active {
+      transform: scale(0.97);
+      opacity: 0.7;
+    }
+
+    .btn::before {
+      content: '';
+      position: absolute;
+      top: 0;
+      left: 0;
+      right: 0;
+      bottom: 0;
+      background-color: var(--primary-color);
+      opacity: 0;
+      transition: opacity 0.2s ease;
+      z-index: -1;
+    }
+
+    .btn:active::before {
+      opacity: 0.1;
+    }
+
+    .btn svg {
+      margin-bottom: 8px;
+      width: 24px;
+      height: 24px;
+      fill: var(--primary-color);
+    }
+
+    .btn-play svg {
+      width: 28px;
+      height: 28px;
+      margin-bottom: 6px;
+    }
+
+    .status-bar {
+      text-align: center;
+      padding: 8px 16px;
+      font-size: 14px;
+      color: var(--text-secondary);
+      background-color: var(--background-color);
+      border-top: 1px solid var(--medium-gray);
+      position: sticky;
+      bottom: 0;
+    }
+
+    .status-message {
+      display: inline-block;
+      transition: opacity 0.3s ease;
+    }
+
+    .status-message.fade {
+      opacity: 0;
+    }
+
+    .refresh-button {
+      color: var(--primary-color);
+      background: none;
+      border: none;
+      font-size: 14px;
+      cursor: pointer;
+      padding: 0;
+      margin-left: 8px;
+    }
+
+    @media (max-width: 350px) {
+      .controls, .extra-controls {
+        gap: 8px;
+      }
+      
+      .btn {
+        padding: 12px 0;
+        font-size: 12px;
+      }
+      
+      .btn svg {
+        width: 20px;
+        height: 20px;
+        margin-bottom: 6px;
+      }
+    }
+  </style>
+</head>
+<body>
+  <div class="header">
+    <h1>AlgerMusicPlayer 远程控制</h1>
+  </div>
+
+  <div class="container">
+    <div class="card" id="songInfoCard">
+      <div class="song-info">
+        <img id="songCover" class="song-cover" src="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='%238E8E93'%3E%3Cpath d='M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 14.5c-2.49 0-4.5-2.01-4.5-4.5S9.51 7.5 12 7.5s4.5 2.01 4.5 4.5-2.01 4.5-4.5 4.5zm0-5.5c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1z'/%3E%3C/svg%3E" alt="封面">
+        <div class="song-details">
+          <h2 id="songTitle">未在播放</h2>
+          <p id="songArtist">--</p>
+          <div class="play-state" id="playState">未播放</div>
+        </div>
+      </div>
+    </div>
+
+    <div class="card">
+      <div class="controls">
+        <button id="prevBtn" class="btn">
+          <svg viewBox="0 0 24 24" fill="currentColor">
+            <path d="M6 6h2v12H6zm3.5 6l8.5 6V6z"/>
+          </svg>
+          上一首
+        </button>
+        <button id="playBtn" class="btn btn-play">
+          <svg id="playIcon" viewBox="0 0 24 24" fill="currentColor">
+            <path d="M8 5v14l11-7z"/>
+          </svg>
+          播放/暂停
+        </button>
+        <button id="nextBtn" class="btn">
+          <svg viewBox="0 0 24 24" fill="currentColor">
+            <path d="M6 18l8.5-6L6 6v12zM16 6v12h2V6h-2z"/>
+          </svg>
+          下一首
+        </button>
+      </div>
+
+      <div class="extra-controls">
+        <button id="volumeDownBtn" class="btn">
+          <svg viewBox="0 0 24 24" fill="currentColor">
+            <path d="M18.5 12c0-1.77-1.02-3.29-2.5-4.03v8.05c1.48-.73 2.5-2.25 2.5-4.02zM5 9v6h4l5 5V4L9 9H5z"/>
+          </svg>
+          音量-
+        </button>
+        <button id="volumeUpBtn" class="btn">
+          <svg viewBox="0 0 24 24" fill="currentColor">
+            <path d="M3 9v6h4l5 5V4L7 9H3zm13.5 3c0-1.77-1.02-3.29-2.5-4.03v8.05c1.48-.73 2.5-2.25 2.5-4.02zM14 3.23v2.06c2.89.86 5 3.54 5 6.71s-2.11 5.85-5 6.71v2.06c4.01-.91 7-4.49 7-8.77s-2.99-7.86-7-8.77z"/>
+          </svg>
+          音量+
+        </button>
+      </div>
+    </div>
+
+    <div class="card">
+      <div class="extra-controls">
+        <button id="favoriteBtn" class="btn">
+          <svg viewBox="0 0 24 24" fill="currentColor">
+            <path d="M12 21.35l-1.45-1.32C5.4 15.36 2 12.28 2 8.5 2 5.42 4.42 3 7.5 3c1.74 0 3.41.81 4.5 2.09C13.09 3.81 14.76 3 16.5 3 19.58 3 22 5.42 22 8.5c0 3.78-3.4 6.86-8.55 11.54L12 21.35z"/>
+          </svg>
+          收藏
+        </button>
+        <button id="refreshBtn" class="btn">
+          <svg viewBox="0 0 24 24" fill="currentColor">
+            <path d="M17.65 6.35C16.2 4.9 14.21 4 12 4c-4.42 0-7.99 3.58-7.99 8s3.57 8 7.99 8c3.73 0 6.84-2.55 7.73-6h-2.08c-.82 2.33-3.04 4-5.65 4-3.31 0-6-2.69-6-6s2.69-6 6-6c1.66 0 3.14.69 4.22 1.78L13 11h7V4l-2.35 2.35z"/>
+          </svg>
+          刷新
+        </button>
+      </div>
+    </div>
+  </div>
+
+  <div class="status-bar">
+    <span id="status" class="status-message">准备就绪</span>
+  </div>
+
+  <script>
+    // 页面加载完成后执行
+    document.addEventListener('DOMContentLoaded', () => {
+      // 获取DOM元素
+      const songInfoCard = document.getElementById('songInfoCard');
+      const songTitle = document.getElementById('songTitle');
+      const songArtist = document.getElementById('songArtist');
+      const songCover = document.getElementById('songCover');
+      const playState = document.getElementById('playState');
+      const playBtn = document.getElementById('playBtn');
+      const playIcon = document.getElementById('playIcon');
+      const prevBtn = document.getElementById('prevBtn');
+      const nextBtn = document.getElementById('nextBtn');
+      const favoriteBtn = document.getElementById('favoriteBtn');
+      const volumeUpBtn = document.getElementById('volumeUpBtn');
+      const volumeDownBtn = document.getElementById('volumeDownBtn');
+      const refreshBtn = document.getElementById('refreshBtn');
+      const status = document.getElementById('status');
+      
+      let isPlaying = false;
+      
+      // 显示状态消息并淡出
+      function showStatus(message, autoClear = true) {
+        status.textContent = message;
+        status.classList.remove('fade');
+        
+        if (autoClear) {
+          setTimeout(() => {
+            status.classList.add('fade');
+          }, 2000);
+        }
+      }
+      
+      // 更新播放/暂停图标
+      function updatePlayIcon() {
+        if (isPlaying) {
+          playIcon.innerHTML = '<path d="M6 19h4V5H6v14zm8-14v14h4V5h-4z"/>';
+        } else {
+          playIcon.innerHTML = '<path d="M8 5v14l11-7z"/>';
+        }
+      }
+      
+      // 更新状态的函数
+      async function updateStatus() {
+        try {
+          showStatus('获取播放状态...', false);
+          
+          const response = await fetch('/api/status');
+          const data = await response.json();
+          
+          // 更新播放状态
+          isPlaying = data.isPlaying;
+          updatePlayIcon();
+          
+          // 更新UI
+          if (data.currentSong) {
+            songTitle.textContent = data.currentSong.name || '未知歌曲';
+            
+            if (data.currentSong.ar && data.currentSong.ar.length) {
+              songArtist.textContent = data.currentSong.ar.map(a => a.name).join(', ');
+            } else if (data.currentSong.artists && data.currentSong.artists.length) {
+              songArtist.textContent = data.currentSong.artists.map(a => a.name).join(', ');
+            } else {
+              songArtist.textContent = '未知艺术家';
+            }
+            
+            if (data.currentSong.picUrl) {
+              songCover.src = data.currentSong.picUrl;
+            }
+          } else {
+            songTitle.textContent = '未在播放';
+            songArtist.textContent = '--';
+            songCover.src = "data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='%238E8E93'%3E%3Cpath d='M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 14.5c-2.49 0-4.5-2.01-4.5-4.5S9.51 7.5 12 7.5s4.5 2.01 4.5 4.5-2.01 4.5-4.5 4.5zm0-5.5c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1z'/%3E%3C/svg%3E";
+          }
+          
+          // 更新播放状态
+          playState.textContent = isPlaying ? '正在播放' : '已暂停';
+          songInfoCard.className = isPlaying ? 'card playing' : 'card paused';
+          
+          showStatus('已更新', true);
+        } catch (error) {
+          console.error('获取状态失败:', error);
+          showStatus('获取状态失败');
+        }
+      }
+      
+      // 发送命令的函数
+      async function sendCommand(endpoint) {
+        try {
+          showStatus('发送命令中...', false);
+          const response = await fetch('/api/' + endpoint, { method: 'POST' });
+          const data = await response.json();
+          
+          showStatus(data.message || '命令已发送');
+          
+          // 稍等后更新状态
+          setTimeout(updateStatus, 500);
+        } catch (error) {
+          console.error('发送命令失败:', error);
+          showStatus('发送命令失败');
+        }
+      }
+      
+      // 绑定按钮事件
+      playBtn.addEventListener('click', () => sendCommand('toggle-play'));
+      prevBtn.addEventListener('click', () => sendCommand('prev'));
+      nextBtn.addEventListener('click', () => sendCommand('next'));
+      favoriteBtn.addEventListener('click', () => sendCommand('toggle-favorite'));
+      volumeUpBtn.addEventListener('click', () => sendCommand('volume-up'));
+      volumeDownBtn.addEventListener('click', () => sendCommand('volume-down'));
+      refreshBtn.addEventListener('click', updateStatus);
+      
+      // 初始加载状态
+      updateStatus();
+      
+      // 每1秒更新一次状态
+      setInterval(updateStatus, 1000);
+      
+      // 添加触摸反馈
+      const buttons = document.querySelectorAll('.btn');
+      buttons.forEach(btn => {
+        btn.addEventListener('touchstart', function() {
+          this.style.transform = 'scale(0.97)';
+          this.style.opacity = '0.7';
+        });
+        
+        btn.addEventListener('touchend', function() {
+          this.style.transform = 'scale(1)';
+          this.style.opacity = '1';
+        });
+      });
+
+      // 检测深色模式变化
+      window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', () => {
+        updateStatus();
+      });
+    });
+  </script>
+</body>
+</html> 

src/i18n/lang/en-US/common.ts

@@ -26,6 +26,7 @@ export default {
   delete: 'Delete',
   refresh: 'Refresh',
   retry: 'Retry',
+  reset: 'Reset',
   validation: {
     required: 'This field is required',
     invalidInput: 'Invalid input',

src/i18n/lang/en-US/comp.ts

@@ -101,5 +101,9 @@ export default {
   },
   userPlayList: {
     title: "{name}'s Playlist"
+  },
+  musicList: {
+    searchSongs: 'Search Songs',
+    noSearchResults: 'No search results'
   }
 };

src/i18n/lang/en-US/download.ts

@@ -1,6 +1,8 @@
 export default {
   title: 'Download Manager',
   localMusic: 'Local Music',
+  count: '{count} songs in total',
+  clearAll: 'Clear All',
   tabs: {
     downloading: 'Downloading',
     downloaded: 'Downloaded'
@@ -27,10 +29,21 @@ export default {
     confirm: 'Delete',
     cancel: 'Cancel',
     success: 'Successfully deleted',
-    failed: 'Failed to delete'
+    failed: 'Failed to delete',
+    fileNotFound: 'File not found or moved, removed from records',
+    recordRemoved: 'Failed to delete file, but removed from records'
+  },
+  clear: {
+    title: 'Clear Download Records',
+    message:
+      'Are you sure you want to clear all download records? This will not delete the actual music files, but will clear all records.',
+    confirm: 'Clear',
+    cancel: 'Cancel',
+    success: 'Download records cleared'
   },
   message: {
     downloadComplete: '{filename} download completed',
     downloadFailed: '{filename} download failed: {error}'
-  }
+  },
+  loading: 'Loading...'
 };

src/i18n/lang/en-US/player.ts

@@ -73,5 +73,27 @@ export default {
       acoustic: 'Acoustic',
       custom: 'Custom'
     }
+  },
+  // Sleep timer related
+  sleepTimer: {
+    title: 'Sleep Timer',
+    cancel: 'Cancel Timer',
+    timeMode: 'By Time',
+    songsMode: 'By Songs',
+    playlistEnd: 'After Playlist',
+    afterPlaylist: 'After Playlist Ends',
+    activeUntilEnd: 'Active until end of playlist',
+    minutes: 'min',
+    hours: 'hr',
+    songs: 'songs',
+    set: 'Set',
+    timerSetSuccess: 'Timer set for {minutes} minutes',
+    songsSetSuccess: 'Timer set for {songs} songs',
+    playlistEndSetSuccess: 'Timer set to end after playlist',
+    timerCancelled: 'Sleep timer cancelled',
+    timerEnded: 'Sleep timer ended',
+    playbackStopped: 'Music playback stopped',
+    minutesRemaining: '{minutes} min remaining',
+    songsRemaining: '{count} songs remaining'
   }
 };

src/i18n/lang/en-US/settings.ts

@@ -56,6 +56,15 @@ export default {
       dolby: 'Dolby Atmos',
       jymaster: 'Master'
     },
+    musicSources: 'Music Sources',
+    musicSourcesDesc: 'Select music sources for song resolution',
+    musicSourcesWarning: 'At least one music source must be selected',
+    musicUnblockEnable: 'Enable Music Unblocking',
+    musicUnblockEnableDesc: 'When enabled, attempts to resolve unplayable songs',
+    configureMusicSources: 'Configure Sources',
+    selectedMusicSources: 'Selected sources:',
+    noMusicSources: 'No sources selected',
+    gdmusicInfo: 'GD Music Station intelligently resolves music from multiple platforms automatically',
     autoPlay: 'Auto Play',
     autoPlayDesc: 'Auto resume playback when reopening the app'
   },
@@ -71,8 +80,12 @@ export default {
     shortcutDesc: 'Customize global shortcuts',
     download: 'Download Management',
     downloadDesc: 'Always show download list button',
+    unlimitedDownload: 'Unlimited Download',
+    unlimitedDownloadDesc: 'Enable unlimited download mode for music , default limit 300 songs',
     downloadPath: 'Download Directory',
-    downloadPathDesc: 'Choose download location for music files'
+    downloadPathDesc: 'Choose download location for music files',
+    remoteControl: 'Remote Control',
+    remoteControlDesc: 'Set remote control function'
   },
   network: {
     apiPort: 'Music API Port',
@@ -183,7 +196,12 @@ export default {
       dark: 'Dark'
     },
     hideMiniPlayBar: 'Hide Mini Play Bar',
-    hideLyrics: 'Hide Lyrics'
+    hideLyrics: 'Hide Lyrics',
+    tabs: {
+      interface: 'Interface',
+      display: 'Display',
+      typography: 'Typography'
+    }
   },
   shortcutSettings: {
     title: 'Shortcut Settings',
@@ -192,6 +210,8 @@ export default {
     shortcutConflict: 'Shortcut Conflict',
     inputPlaceholder: 'Click to input shortcut',
     resetShortcuts: 'Reset',
+    disableAll: 'Disable All',
+    enableAll: 'Enable All',
     togglePlay: 'Play/Pause',
     prevPlay: 'Previous',
     nextPlay: 'Next',
@@ -199,12 +219,28 @@ export default {
     volumeDown: 'Volume Down',
     toggleFavorite: 'Favorite/Unfavorite',
     toggleWindow: 'Show/Hide Window',
+    scopeGlobal: 'Global',
+    scopeApp: 'App Only',
+    enabled: 'Enabled',
+    disabled: 'Disabled',
     messages: {
       resetSuccess: 'Shortcuts reset successfully, please save',
       conflict: 'Shortcut conflict, please reset',
       saveSuccess: 'Shortcuts saved successfully',
       saveError: 'Failed to save shortcuts',
-      cancelEdit: 'Edit cancelled'
+      cancelEdit: 'Edit cancelled',
+      disableAll: 'All shortcuts disabled, please save to apply',
+      enableAll: 'All shortcuts enabled, please save to apply'
     }
+  },
+  remoteControl: {
+    title: 'Remote Control',
+    enable: 'Enable Remote Control',
+    port: 'Port',
+    allowedIps: 'Allowed IPs',
+    addIp: 'Add IP',
+    emptyListHint: 'Empty list means allow all IPs',
+    saveSuccess: 'Remote control settings saved',
+    accessInfo: 'Remote control access address:',
   }
 };

src/i18n/lang/en-US/songItem.ts

@@ -13,6 +13,6 @@ export default {
     downloadFailed: 'Download failed',
     downloadQueued: 'Added to download queue',
     addedToNextPlay: 'Added to play next',
-    getUrlFailed: 'Failed to get music download URL'
+    getUrlFailed: 'Failed to get music download URL, please check if logged in'
   }
 };

src/i18n/lang/zh-CN/common.ts

@@ -26,6 +26,7 @@ export default {
   delete: '删除',
   refresh: '刷新',
   retry: '重试',
+  reset: '重置',
   validation: {
     required: '此项是必填的',
     invalidInput: '输入无效',

src/i18n/lang/zh-CN/comp.ts

@@ -99,5 +99,9 @@ export default {
   },
   userPlayList: {
     title: '{name}的常听'
+  },
+  musicList: {
+    searchSongs: '搜索歌曲',
+    noSearchResults: '没有找到相关歌曲'
   }
 };

src/i18n/lang/zh-CN/download.ts

@@ -1,6 +1,8 @@
 export default {
   title: '下载管理',
   localMusic: '本地音乐',
+  count: '共 {count} 首歌曲',
+  clearAll: '清空记录',
   tabs: {
     downloading: '下载中',
     downloaded: '已下载'
@@ -27,10 +29,20 @@ export default {
     confirm: '确定删除',
     cancel: '取消',
     success: '删除成功',
-    failed: '删除失败'
+    failed: '删除失败',
+    fileNotFound: '文件不存在或已被移动，已从记录中移除',
+    recordRemoved: '文件删除失败，但已从记录中移除'
+  },
+  clear: {
+    title: '清空下载记录',
+    message: '确定要清空所有下载记录吗？此操作不会删除已下载的音乐文件，但将清空所有记录。',
+    confirm: '确定清空',
+    cancel: '取消',
+    success: '下载记录已清空'
   },
   message: {
     downloadComplete: '{filename} 下载完成',
     downloadFailed: '{filename} 下载失败: {error}'
-  }
+  },
+  loading: '加载中...'
 };

src/i18n/lang/zh-CN/player.ts

@@ -74,5 +74,27 @@ export default {
       acoustic: '原声',
       custom: '自定义'
     }
+  },
+  // 定时关闭功能相关
+  sleepTimer: {
+    title: '定时关闭',
+    cancel: '取消定时',
+    timeMode: '按时间关闭',
+    songsMode: '按歌曲数关闭',
+    playlistEnd: '播放完列表后关闭',
+    afterPlaylist: '播放完列表后关闭',
+    activeUntilEnd: '播放至列表结束',
+    minutes: '分钟',
+    hours: '小时',
+    songs: '首歌',
+    set: '设置',
+    timerSetSuccess: '已设置{minutes}分钟后关闭',
+    songsSetSuccess: '已设置播放{songs}首歌后关闭',
+    playlistEndSetSuccess: '已设置播放完列表后关闭',
+    timerCancelled: '已取消定时关闭',
+    timerEnded: '定时关闭已触发',
+    playbackStopped: '音乐播放已停止',
+    minutesRemaining: '剩余{minutes}分钟',
+    songsRemaining: '剩余{count}首歌'
   }
 };

src/i18n/lang/zh-CN/settings.ts

@@ -56,6 +56,15 @@ export default {
       dolby: '杜比全景声',
       jymaster: '超清母带'
     },
+    musicSources: '音源设置',
+    musicSourcesDesc: '选择音乐解析使用的音源平台',
+    musicSourcesWarning: '至少需要选择一个音源平台',
+    musicUnblockEnable: '启用音乐解析',
+    musicUnblockEnableDesc: '开启后将尝试解析无法播放的音乐',
+    configureMusicSources: '配置音源',
+    selectedMusicSources: '已选音源：',
+    noMusicSources: '未选择音源',
+    gdmusicInfo: 'GD音乐台可自动解析多个平台音源，自动选择最佳结果',
     autoPlay: '自动播放',
     autoPlayDesc: '重新打开应用时是否自动继续播放'
   },
@@ -71,8 +80,12 @@ export default {
     shortcutDesc: '自定义全局快捷键',
     download: '下载管理',
     downloadDesc: '是否始终显示下载列表按钮',
+    unlimitedDownload: '无限制下载',
+    unlimitedDownloadDesc: '开启后将无限制下载音乐（可能出现下载失败的情况）, 默认限制 300 首',
     downloadPath: '下载目录',
-    downloadPathDesc: '选择音乐文件的下载位置'
+    downloadPathDesc: '选择音乐文件的下载位置',
+    remoteControl: '远程控制',
+    remoteControlDesc: '设置远程控制功能'
   },
   network: {
     apiPort: '音乐API端口',
@@ -183,7 +196,12 @@ export default {
       dark: '暗色'
     },
     hideMiniPlayBar: '隐藏迷你播放栏',
-    hideLyrics: '隐藏歌词'
+    hideLyrics: '隐藏歌词',
+    tabs: {
+      interface: '界面',
+      typography: '文字',
+      display: '显示'
+    }
   },
   shortcutSettings: {
     title: '快捷键设置',
@@ -192,6 +210,8 @@ export default {
     shortcutConflict: '快捷键冲突',
     inputPlaceholder: '点击输入快捷键',
     resetShortcuts: '恢复默认',
+    disableAll: '全部禁用',
+    enableAll: '全部启用',
     togglePlay: '播放/暂停',
     prevPlay: '上一首',
     nextPlay: '下一首',
@@ -199,12 +219,28 @@ export default {
     volumeDown: '音量减少',
     toggleFavorite: '收藏/取消收藏',
     toggleWindow: '显示/隐藏窗口',
+    scopeGlobal: '全局',
+    scopeApp: '应用内',
+    enabled: '启用',
+    disabled: '禁用',
     messages: {
       resetSuccess: '已恢复默认快捷键，请记得保存',
       conflict: '存在冲突的快捷键，请重新设置',
       saveSuccess: '快捷键设置已保存',
       saveError: '保存快捷键失败，请重试',
-      cancelEdit: '已取消修改'
+      cancelEdit: '已取消修改',
+      disableAll: '已禁用所有快捷键，请记得保存',
+      enableAll: '已启用所有快捷键，请记得保存'
     }
+  },
+  remoteControl: {
+    title: '远程控制',
+    enable: '启用远程控制',
+    port: '服务端口',
+    allowedIps: '允许的IP地址',
+    addIp: '添加IP',
+    emptyListHint: '空列表表示允许所有IP访问',
+    saveSuccess: '远程控制设置已保存',
+    accessInfo: '远程控制访问地址:',
   }
 };

src/i18n/lang/zh-CN/songItem.ts

@@ -13,6 +13,6 @@ export default {
     downloadFailed: '下载失败',
     downloadQueued: '已加入下载队列',
     addedToNextPlay: '已添加到下一首播放',
-    getUrlFailed: '获取音乐下载地址失败'
+    getUrlFailed: '获取音乐下载地址失败，请检查是否登录'
   }
 };

src/main/index.ts

@@ -8,7 +8,9 @@ import { loadLyricWindow } from './lyric';
 import { initializeConfig } from './modules/config';
 import { initializeFileManager } from './modules/fileManager';
 import { initializeFonts } from './modules/fonts';
+import { initializeRemoteControl } from './modules/remoteControl';
 import { initializeShortcuts, registerShortcuts } from './modules/shortcuts';
+import { initializeStats, setupStatsHandlers } from './modules/statsService';
 import { initializeTray, updateCurrentSong, updatePlayState, updateTrayMenu } from './modules/tray';
 import { setupUpdateHandlers } from './modules/update';
 import { createMainWindow, initializeWindowManager } from './modules/window';
@@ -19,8 +21,6 @@ const iconPath = join(__dirname, '../../resources');
 const icon = nativeImage.createFromPath(
   process.platform === 'darwin'
     ? join(iconPath, 'icon.icns')
-    : process.platform === 'win32'
-      ? join(iconPath, 'favicon.ico')
     : join(iconPath, 'icon.png')
 );
 
@@ -50,6 +50,12 @@ function initialize() {
   // 初始化托盘
   initializeTray(iconPath, mainWindow);
 
+  // 初始化统计服务
+  initializeStats();
+
+  // 设置统计相关的IPC处理程序
+  setupStatsHandlers(ipcMain);
+
   // 启动音乐API
   startMusicApi();
 
@@ -59,6 +65,9 @@ function initialize() {
   // 初始化快捷键
   initializeShortcuts(mainWindow);
 
+  // 初始化远程控制服务
+  initializeRemoteControl(mainWindow);
+
   // 初始化更新处理程序
   setupUpdateHandlers(mainWindow);
 }

src/main/lyric.ts

@@ -84,15 +84,18 @@ const createWin = () => {
     frame: false,
     show: false,
     transparent: true,
+    opacity: 1,
     hasShadow: false,
     alwaysOnTop: true,
     resizable: true,
+    roundedCorners: false,
     // 添加跨屏幕支持选项
     webPreferences: {
       preload: join(__dirname, '../preload/index.js'),
       sandbox: false,
       contextIsolation: true
-    }
+    },
+    backgroundColor: '#00000000'
   });
 
   // 监听窗口关闭事件

src/main/modules/deviceInfo.ts

@@ -0,0 +1,63 @@
+import { app } from 'electron';
+import Store from 'electron-store';
+import { machineIdSync } from 'node-machine-id';
+import os from 'os';
+
+const store = new Store();
+
+/**
+ * 获取设备唯一标识符
+ * 优先使用存储的ID，如果没有则获取机器ID并存储
+ */
+export function getDeviceId(): string {
+  let deviceId = store.get('deviceId') as string | undefined;
+
+  if (!deviceId) {
+    try {
+      // 使用node-machine-id获取设备唯一标识
+      deviceId = machineIdSync(true);
+    } catch (error) {
+      console.error('获取机器ID失败:', error);
+      // 如果获取失败，使用主机名和MAC地址组合作为备选方案
+      const networkInterfaces = os.networkInterfaces();
+      let macAddress = '';
+
+      // 尝试获取第一个非内部网络接口的MAC地址
+      Object.values(networkInterfaces).forEach((interfaces) => {
+        if (interfaces) {
+          interfaces.forEach((iface) => {
+            if (!iface.internal && !macAddress && iface.mac !== '00:00:00:00:00:00') {
+              macAddress = iface.mac;
+            }
+          });
+        }
+      });
+
+      deviceId = `${os.hostname()}-${macAddress}`.replace(/:/g, '');
+    }
+
+    // 存储设备ID
+    if (deviceId) {
+      store.set('deviceId', deviceId);
+    } else {
+      // 如果所有方法都失败，使用随机ID
+      deviceId = Math.random().toString(36).substring(2, 15);
+      store.set('deviceId', deviceId);
+    }
+  }
+
+  return deviceId;
+}
+
+/**
+ * 获取系统信息
+ */
+export function getSystemInfo() {
+  return {
+    osType: os.type(),
+    osVersion: os.release(),
+    osArch: os.arch(),
+    platform: process.platform,
+    appVersion: app.getVersion()
+  };
+}

src/main/modules/fileManager.ts

@@ -1,9 +1,14 @@
 import axios from 'axios';
-import { app, dialog, ipcMain, protocol, shell } from 'electron';
+import { app, dialog, ipcMain, Notification, protocol, shell } from 'electron';
 import Store from 'electron-store';
 import * as fs from 'fs';
+import * as http from 'http';
+import * as https from 'https';
+import * as NodeID3 from 'node-id3';
 import * as path from 'path';
 
+import { getStore } from './config';
+
 const MAX_CONCURRENT_DOWNLOADS = 3;
 const downloadQueue: { url: string; filename: string; songInfo: any; type?: string }[] = [];
 let activeDownloads = 0;
@@ -117,20 +122,37 @@ export function initializeFileManager() {
   });
 
   // 获取已下载音乐列表
-  ipcMain.handle('get-downloaded-music', () => {
+  ipcMain.handle('get-downloaded-music', async () => {
     try {
       const store = new Store();
       const songInfos = store.get('downloadedSongs', {}) as Record<string, any>;
 
-      // 过滤出实际存在的文件
+      // 异步处理文件存在性检查
-      const validSongs = Object.entries(songInfos)
+      const entriesArray = Object.entries(songInfos);
-        .filter(([path]) => fs.existsSync(path))
+      const validEntriesPromises = await Promise.all(
-        .map(([_, info]) => info)
+        entriesArray.map(async ([path, info]) => {
+          try {
+            const exists = await fs.promises.access(path)
+              .then(() => true)
+              .catch(() => false);
+            return exists ? info : null;
+          } catch (error) {
+            console.error('Error checking file existence:', error);
+            return null;
+          }
+        })
+      );
+
+      // 过滤有效的歌曲并排序
+      const validSongs = validEntriesPromises
+        .filter(song => song !== null)
         .sort((a, b) => (b.downloadTime || 0) - (a.downloadTime || 0));
 
       // 更新存储，移除不存在的文件记录
       const newSongInfos = validSongs.reduce((acc, song) => {
+        if (song && song.path) {
           acc[song.path] = song;
+        }
         return acc;
       }, {});
       store.set('downloadedSongs', newSongInfos);
@@ -170,6 +192,13 @@ export function initializeFileManager() {
     downloadStore.set('history', []);
   });
 
+  // 添加清除已下载音乐记录的处理函数
+  ipcMain.handle('clear-downloaded-music', () => {
+    const store = new Store();
+    store.set('downloadedSongs', {});
+    return true;
+  });
+
   // 添加清除音频缓存的处理函数
   ipcMain.on('clear-audio-cache', () => {
     audioCacheStore.set('cache', {});
@@ -269,7 +298,7 @@ function sanitizeFilename(filename: string): string {
 }
 
 /**
- * 下载音乐功能
+ * 下载音乐和歌词
  */
 async function downloadMusic(
   event: Electron.IpcMainEvent,
@@ -284,8 +313,11 @@ async function downloadMusic(
   let writer: fs.WriteStream | null = null;
 
   try {
-    const store = new Store();
+    // 使用配置Store来获取设置
-    const downloadPath = (store.get('set.downloadPath') as string) || app.getPath('downloads');
+    const configStore = getStore();
+    const downloadPath =
+      (configStore.get('set.downloadPath') as string) || app.getPath('downloads');
+    const apiPort = configStore.get('set.musicApiPort') || 30488;
 
     // 清理文件名中的非法字符
     const sanitizedFilename = sanitizeFilename(filename);
@@ -313,7 +345,9 @@ async function downloadMusic(
       url,
       method: 'GET',
       responseType: 'stream',
-      timeout: 30000 // 30秒超时
+      timeout: 30000, // 30秒超时
+      httpAgent: new http.Agent({ keepAlive: true }),
+      httpsAgent: new https.Agent({ keepAlive: true })
     });
 
     writer = fs.createWriteStream(finalFilePath);
@@ -351,9 +385,121 @@ async function downloadMusic(
       throw new Error('文件下载不完整');
     }
 
+    // 下载歌词
+    let lyricData = null;
+    let lyricsContent = '';
+    try {
+      if (songInfo?.id) {
+        // 下载歌词，使用配置的端口
+        const lyricsResponse = await axios.get(
+          `http://localhost:${apiPort}/lyric?id=${songInfo.id}`
+        );
+        if (lyricsResponse.data && (lyricsResponse.data.lrc || lyricsResponse.data.tlyric)) {
+          lyricData = lyricsResponse.data;
+
+          // 处理歌词内容
+          if (lyricsResponse.data.lrc && lyricsResponse.data.lrc.lyric) {
+            lyricsContent = lyricsResponse.data.lrc.lyric;
+
+            // 如果有翻译歌词，合并到主歌词中
+            if (lyricsResponse.data.tlyric && lyricsResponse.data.tlyric.lyric) {
+              // 解析原歌词和翻译
+              const originalLyrics = parseLyrics(lyricsResponse.data.lrc.lyric);
+              const translatedLyrics = parseLyrics(lyricsResponse.data.tlyric.lyric);
+
+              // 合并歌词
+              const mergedLyrics = mergeLyrics(originalLyrics, translatedLyrics);
+              lyricsContent = mergedLyrics;
+            }
+          }
+
+          // 不再单独写入歌词文件，只保存在ID3标签中
+          console.log('歌词已准备好，将写入ID3标签');
+        }
+      }
+    } catch (lyricError) {
+      console.error('下载歌词失败:', lyricError);
+      // 继续处理，不影响音乐下载
+    }
+
+    // 下载封面
+    let coverImageBuffer: Buffer | null = null;
+    try {
+      if (songInfo?.picUrl || songInfo?.al?.picUrl) {
+        const picUrl = songInfo.picUrl || songInfo.al?.picUrl;
+        if (picUrl && picUrl !== '/images/default_cover.png') {
+          const coverResponse = await axios({
+            url: picUrl.replace('http://', 'https://'),
+            method: 'GET',
+            responseType: 'arraybuffer',
+            timeout: 10000
+          });
+
+          // 获取封面图片的buffer
+          coverImageBuffer = Buffer.from(coverResponse.data);
+
+          // 不再单独保存封面文件，只保存在ID3标签中
+          console.log('封面已准备好，将写入ID3标签');
+        }
+      }
+    } catch (coverError) {
+      console.error('下载封面失败:', coverError);
+      // 继续处理，不影响音乐下载
+    }
+
+    // 在写入ID3标签前，先移除可能存在的旧标签
+    try {
+      NodeID3.removeTags(finalFilePath);
+    } catch (err) {
+      console.error('Error removing existing ID3 tags:', err);
+    }
+
+    // 强化ID3标签的写入格式
+
+    const artistNames =
+      (songInfo?.ar || songInfo?.song?.artists)?.map((a: any) => a.name).join('/ ') || '未知艺术家';
+    const tags = {
+      title: filename,
+      artist: artistNames,
+      TPE1: artistNames,
+      TPE2: artistNames,
+      album: songInfo?.al?.name || songInfo?.song?.album?.name || songInfo?.name || filename,
+      APIC: {
+        // 专辑封面
+        imageBuffer: coverImageBuffer,
+        type: {
+          id: 3,
+          name: 'front cover'
+        },
+        description: 'Album cover',
+        mime: 'image/jpeg'
+      },
+      USLT: {
+        // 歌词
+        language: 'chi',
+        description: 'Lyrics',
+        text: lyricsContent || ''
+      },
+      trackNumber: songInfo?.no || undefined,
+      year: songInfo?.publishTime
+        ? new Date(songInfo.publishTime).getFullYear().toString()
+        : undefined
+    };
+
+    try {
+      const success = NodeID3.write(tags, finalFilePath);
+      if (!success) {
+        console.error('Failed to write ID3 tags');
+      } else {
+        console.log('ID3 tags written successfully');
+      }
+    } catch (err) {
+      console.error('Error writing ID3 tags:', err);
+    }
+
     // 保存下载信息
     try {
-      const songInfos = store.get('downloadedSongs', {}) as Record<string, any>;
+      const songInfos = configStore.get('downloadedSongs', {}) as Record<string, any>;
       const defaultInfo = {
         name: filename,
         ar: [{ name: '本地音乐' }],
@@ -364,24 +510,48 @@ async function downloadMusic(
         id: songInfo?.id || 0,
         name: songInfo?.name || filename,
         filename,
-        picUrl: songInfo?.picUrl || defaultInfo.picUrl,
+        picUrl: songInfo?.picUrl || songInfo?.al?.picUrl || defaultInfo.picUrl,
         ar: songInfo?.ar || defaultInfo.ar,
+        al: songInfo?.al || {
+          picUrl: songInfo?.picUrl || defaultInfo.picUrl,
+          name: songInfo?.name || filename
+        },
         size: totalSize,
         path: finalFilePath,
         downloadTime: Date.now(),
-        al: songInfo?.al || { picUrl: songInfo?.picUrl || defaultInfo.picUrl },
+        type: type || 'mp3',
-        type: type || 'mp3'
+        lyric: lyricData
       };
 
       // 保存到下载记录
       songInfos[finalFilePath] = newSongInfo;
-      store.set('downloadedSongs', songInfos);
+      configStore.set('downloadedSongs', songInfos);
 
       // 添加到下载历史
       const history = downloadStore.get('history', []) as any[];
       history.unshift(newSongInfo);
       downloadStore.set('history', history);
 
+      // 发送桌面通知
+      try {
+        const artistNames =
+          (songInfo?.ar || songInfo?.song?.artists)?.map((a: any) => a.name).join('/') ||
+          '未知艺术家';
+        const notification = new Notification({
+          title: '下载完成',
+          body: `${songInfo?.name || filename} - ${artistNames}`,
+          silent: false
+        });
+
+        notification.on('click', () => {
+          shell.showItemInFolder(finalFilePath);
+        });
+
+        notification.show();
+      } catch (notifyError) {
+        console.error('发送通知失败:', notifyError);
+      }
+
       // 发送下载完成事件
       event.reply('music-download-complete', {
         success: true,
@@ -416,3 +586,56 @@ async function downloadMusic(
     });
   }
 }
+
+// 辅助函数 - 解析歌词文本成时间戳和内容的映射
+function parseLyrics(lyricsText: string): Map<string, string> {
+  const lyricMap = new Map<string, string>();
+  const lines = lyricsText.split('\n');
+
+  for (const line of lines) {
+    // 匹配时间标签，形如 [00:00.000]
+    const timeTagMatches = line.match(/\[\d{2}:\d{2}(\.\d{1,3})?\]/g);
+    if (!timeTagMatches) continue;
+
+    // 提取歌词内容（去除时间标签）
+    const content = line.replace(/\[\d{2}:\d{2}(\.\d{1,3})?\]/g, '').trim();
+    if (!content) continue;
+
+    // 将每个时间标签与歌词内容关联
+    for (const timeTag of timeTagMatches) {
+      lyricMap.set(timeTag, content);
+    }
+  }
+
+  return lyricMap;
+}
+
+// 辅助函数 - 合并原文歌词和翻译歌词
+function mergeLyrics(
+  originalLyrics: Map<string, string>,
+  translatedLyrics: Map<string, string>
+): string {
+  const mergedLines: string[] = [];
+
+  // 对每个时间戳，组合原始歌词和翻译
+  for (const [timeTag, originalContent] of originalLyrics.entries()) {
+    const translatedContent = translatedLyrics.get(timeTag);
+
+    // 添加原始歌词行
+    mergedLines.push(`${timeTag}${originalContent}`);
+
+    // 如果有翻译，添加翻译行（时间戳相同，这样可以和原歌词同步显示）
+    if (translatedContent) {
+      mergedLines.push(`${timeTag}${translatedContent}`);
+    }
+  }
+
+  // 按时间顺序排序
+  mergedLines.sort((a, b) => {
+    const timeA = a.match(/\[\d{2}:\d{2}(\.\d{1,3})?\]/)?.[0] || '';
+    const timeB = b.match(/\[\d{2}:\d{2}(\.\d{1,3})?\]/)?.[0] || '';
+    return timeA.localeCompare(timeB);
+  });
+
+  return mergedLines.join('\n');
+}

src/main/modules/remoteControl.ts

@@ -0,0 +1,231 @@
+import { ipcMain } from 'electron';
+import express from 'express';
+import cors from 'cors';
+import os from 'os';
+import { getStore } from './config';
+import path from 'path';
+import fs from 'fs';
+
+// 定义远程控制相关接口
+export interface RemoteControlConfig {
+  enabled: boolean;
+  port: number;
+  allowedIps: string[];
+}
+
+// 默认配置
+export const defaultRemoteControlConfig: RemoteControlConfig = {
+  enabled: false,
+  port: 31888,
+  allowedIps: []
+};
+
+let app: express.Application | null = null;
+let server: any = null;
+let mainWindowRef: Electron.BrowserWindow | null = null;
+let currentSong: any = null;
+let isPlaying: boolean = false;
+
+// 获取本地IP地址
+function getLocalIpAddresses(): string[] {
+  const interfaces = os.networkInterfaces();
+  const addresses: string[] = [];
+
+  for (const key in interfaces) {
+    const iface = interfaces[key];
+    if (iface) {
+      for (const alias of iface) {
+        if (alias.family === 'IPv4' && !alias.internal) {
+          addresses.push(alias.address);
+        }
+      }
+    }
+  }
+
+  return addresses;
+}
+
+// 初始化远程控制服务
+export function initializeRemoteControl(mainWindow: Electron.BrowserWindow) {
+  mainWindowRef = mainWindow;
+  const store = getStore() as any;
+  let config = store.get('remoteControl') as RemoteControlConfig;
+
+  // 如果配置不存在，使用默认配置
+  if (!config) {
+    config = defaultRemoteControlConfig;
+    store.set('remoteControl', config);
+  }
+
+  // 监听当前歌曲变化
+  ipcMain.on('update-current-song', (_, song: any) => {
+    currentSong = song;
+  });
+
+  // 监听播放状态变化
+  ipcMain.on('update-play-state', (_, playing: boolean) => {
+    isPlaying = playing;
+  });
+
+  // 监听远程控制配置变化
+  ipcMain.on('update-remote-control-config', (_, newConfig: RemoteControlConfig) => {
+    if (server) {
+      stopServer();
+    }
+    
+    store.set('remoteControl', newConfig);
+    
+    if (newConfig.enabled) {
+      startServer(newConfig);
+    }
+  });
+
+  // 获取远程控制配置
+  ipcMain.handle('get-remote-control-config', () => {
+    const config = store.get('remoteControl') as RemoteControlConfig;
+    return config || defaultRemoteControlConfig;
+  });
+
+  // 获取本地IP地址
+  ipcMain.handle('get-local-ip-addresses', () => {
+    return getLocalIpAddresses();
+  });
+
+  // 如果启用了远程控制，启动服务器
+  if (config.enabled) {
+    startServer(config);
+  }
+}
+
+// 启动远程控制服务器
+function startServer(config: RemoteControlConfig) {
+  if (!mainWindowRef) {
+    console.error('主窗口未初始化，无法启动远程控制服务');
+    return;
+  }
+
+  app = express();
+  
+  // 跨域配置
+  app.use(cors());
+  app.use(express.json());
+  
+  // IP 过滤中间件
+  app.use((req, res, next) => {
+    const clientIp = req.ip || req.socket.remoteAddress || '';
+    const cleanIp = clientIp.replace(/^::ffff:/, ''); // 移除IPv6前缀
+    console.log('config',config)
+    if (config.allowedIps.length === 0 || config.allowedIps.includes(cleanIp)) {
+      next();
+    } else {
+      res.status(403).json({ error: '未授权的IP地址' });
+    }
+  });
+
+  // 路由配置
+  setupRoutes(app);
+
+  // 启动服务器
+  try {
+    server = app.listen(config.port, () => {
+      console.log(`远程控制服务已启动，监听端口: ${config.port}`);
+    });
+  } catch (error) {
+    console.error('启动远程控制服务失败:', error);
+  }
+}
+
+// 停止远程控制服务器
+function stopServer() {
+  if (server) {
+    server.close();
+    server = null;
+    app = null;
+    console.log('远程控制服务已停止');
+  }
+}
+
+// 设置路由
+function setupRoutes(app: express.Application) {
+  // 获取当前播放状态
+  app.get('/api/status', (_, res) => {
+    res.json({
+      isPlaying,
+      currentSong
+    });
+  });
+
+  // 播放/暂停
+  app.post('/api/toggle-play', (_, res) => {
+    if (!mainWindowRef) {
+      return res.status(500).json({ error: '主窗口未初始化' });
+    }
+    mainWindowRef.webContents.send('global-shortcut', 'togglePlay');
+    res.json({ success: true, message: '已发送播放/暂停指令' });
+  });
+
+  // 上一首
+  app.post('/api/prev', (_, res) => {
+    if (!mainWindowRef) {
+      return res.status(500).json({ error: '主窗口未初始化' });
+    }
+    mainWindowRef.webContents.send('global-shortcut', 'prevPlay');
+    res.json({ success: true, message: '已发送上一首指令' });
+  });
+
+  // 下一首
+  app.post('/api/next', (_, res) => {
+    if (!mainWindowRef) {
+      return res.status(500).json({ error: '主窗口未初始化' });
+    }
+    mainWindowRef.webContents.send('global-shortcut', 'nextPlay');
+    res.json({ success: true, message: '已发送下一首指令' });
+  });
+
+  // 音量加
+  app.post('/api/volume-up', (_, res) => {
+    if (!mainWindowRef) {
+      return res.status(500).json({ error: '主窗口未初始化' });
+    }
+    mainWindowRef.webContents.send('global-shortcut', 'volumeUp');
+    res.json({ success: true, message: '已发送音量加指令' });
+  });
+
+  // 音量减
+  app.post('/api/volume-down', (_, res) => {
+    if (!mainWindowRef) {
+      return res.status(500).json({ error: '主窗口未初始化' });
+    }
+    mainWindowRef.webContents.send('global-shortcut', 'volumeDown');
+    res.json({ success: true, message: '已发送音量减指令' });
+  });
+
+  // 收藏/取消收藏
+  app.post('/api/toggle-favorite', (_, res) => {
+    if (!mainWindowRef) {
+      return res.status(500).json({ error: '主窗口未初始化' });
+    }
+    mainWindowRef.webContents.send('global-shortcut', 'toggleFavorite');
+    res.json({ success: true, message: '已发送收藏/取消收藏指令' });
+  });
+
+  // 提供远程控制界面HTML
+  app.get('/', (_, res) => {
+    try {
+      const resourcesPath = process.resourcesPath || '';
+      const isDev = process.env.NODE_ENV === 'development';
+      const htmlPath = path.join(process.cwd(), 'resources', 'html', 'remote-control.html');
+      const finalPath = isDev ? htmlPath : path.join(resourcesPath, 'html', 'remote-control.html');
+      
+      if (fs.existsSync(finalPath)) {
+        res.sendFile(finalPath);
+      } else {
+        res.status(404).send('远程控制界面文件未找到');
+        console.error('远程控制界面文件不存在:', finalPath);
+      }
+    } catch (error) {
+      console.error('加载远程控制界面失败:', error);
+      res.status(500).send('加载远程控制界面失败');
+    }
+  });
+} 

src/main/modules/shortcuts.ts

@@ -7,66 +7,93 @@ ipcMain.on('get-platform', (event) => {
   event.returnValue = process.platform;
 });
 
+// 定义快捷键配置接口
+export interface ShortcutConfig {
+  key: string;
+  enabled: boolean;
+  scope: 'global' | 'app';
+}
+
+export interface ShortcutsConfig {
+  [key: string]: ShortcutConfig;
+}
+
 // 定义默认快捷键
-export const defaultShortcuts = {
+export const defaultShortcuts: ShortcutsConfig = {
-  togglePlay: 'CommandOrControl+Alt+P',
+  togglePlay: { key: 'CommandOrControl+Alt+P', enabled: true, scope: 'global' },
-  prevPlay: 'CommandOrControl+Alt+Left',
+  prevPlay: { key: 'Alt+Left', enabled: true, scope: 'global' },
-  nextPlay: 'CommandOrControl+Alt+Right',
+  nextPlay: { key: 'Alt+Right', enabled: true, scope: 'global' },
-  volumeUp: 'CommandOrControl+Alt+Up',
+  volumeUp: { key: 'Alt+Up', enabled: true, scope: 'app' },
-  volumeDown: 'CommandOrControl+Alt+Down',
+  volumeDown: { key: 'Alt+Down', enabled: true, scope: 'app' },
-  toggleFavorite: 'CommandOrControl+Alt+L',
+  toggleFavorite: { key: 'CommandOrControl+Alt+L', enabled: true, scope: 'app' },
-  toggleWindow: 'CommandOrControl+Alt+Shift+M'
+  toggleWindow: { key: 'CommandOrControl+Alt+Shift+M', enabled: true, scope: 'global' }
 };
 
 let mainWindowRef: Electron.BrowserWindow | null = null;
 
 // 注册快捷键
-export function registerShortcuts(mainWindow: Electron.BrowserWindow) {
+export function registerShortcuts(
+  mainWindow: Electron.BrowserWindow,
+  shortcutsConfig?: ShortcutsConfig
+) {
   mainWindowRef = mainWindow;
   const store = getStore();
-  const shortcuts = store.get('shortcuts');
+  const shortcuts =
+    shortcutsConfig || (store.get('shortcuts') as ShortcutsConfig) || defaultShortcuts;
 
   // 注销所有已注册的快捷键
   globalShortcut.unregisterAll();
 
-  // 显示/隐藏主窗口
+  // 对旧格式数据进行兼容处理
-  globalShortcut.register(shortcuts.toggleWindow, () => {
+  if (shortcuts && typeof shortcuts.togglePlay === 'string') {
+    // 将 shortcuts 强制转换为 unknown，再转为 Record<string, string>
+    const oldShortcuts = { ...shortcuts } as unknown as Record<string, string>;
+    const newShortcuts: ShortcutsConfig = {};
+
+    Object.entries(oldShortcuts).forEach(([key, value]) => {
+      newShortcuts[key] = {
+        key: value,
+        enabled: true,
+        scope: ['volumeUp', 'volumeDown', 'toggleFavorite'].includes(key) ? 'app' : 'global'
+      };
+    });
+
+    store.set('shortcuts', newShortcuts);
+    registerShortcuts(mainWindow, newShortcuts);
+    return;
+  }
+
+  // 注册全局快捷键
+  Object.entries(shortcuts).forEach(([action, config]) => {
+    const { key, enabled, scope } = config as ShortcutConfig;
+
+    // 只注册启用且作用域为全局的快捷键
+    if (!enabled || scope !== 'global') return;
+
+    try {
+      switch (action) {
+        case 'toggleWindow':
+          globalShortcut.register(key, () => {
             if (mainWindow.isVisible()) {
               mainWindow.hide();
             } else {
               mainWindow.show();
             }
           });
-
+          break;
-  // 播放/暂停
+        default:
-  globalShortcut.register(shortcuts.togglePlay, () => {
+          globalShortcut.register(key, () => {
-    mainWindow.webContents.send('global-shortcut', 'togglePlay');
+            mainWindow.webContents.send('global-shortcut', action);
+          });
+          break;
+      }
+    } catch (error) {
+      console.error(`注册快捷键 ${key} 失败:`, error);
+    }
   });
 
-  // 上一首
+  // 通知渲染进程更新应用内快捷键
-  globalShortcut.register(shortcuts.prevPlay, () => {
+  mainWindow.webContents.send('update-app-shortcuts', shortcuts);
-    mainWindow.webContents.send('global-shortcut', 'prevPlay');
-  });
-
-  // 下一首
-  globalShortcut.register(shortcuts.nextPlay, () => {
-    mainWindow.webContents.send('global-shortcut', 'nextPlay');
-  });
-
-  // 音量增加
-  globalShortcut.register(shortcuts.volumeUp, () => {
-    mainWindow.webContents.send('global-shortcut', 'volumeUp');
-  });
-
-  // 音量减少
-  globalShortcut.register(shortcuts.volumeDown, () => {
-    mainWindow.webContents.send('global-shortcut', 'volumeDown');
-  });
-
-  // 收藏当前歌曲
-  globalShortcut.register(shortcuts.toggleFavorite, () => {
-    mainWindow.webContents.send('global-shortcut', 'toggleFavorite');
-  });
 }
 
 // 初始化快捷键
@@ -85,4 +112,11 @@ export function initializeShortcuts(mainWindow: Electron.BrowserWindow) {
       registerShortcuts(mainWindowRef);
     }
   });
+
+  // 监听快捷键更新事件
+  ipcMain.on('update-shortcuts', (_, shortcutsConfig: ShortcutsConfig) => {
+    if (mainWindowRef) {
+      registerShortcuts(mainWindowRef, shortcutsConfig);
+    }
+  });
 }

src/main/modules/statsService.ts

@@ -0,0 +1,122 @@
+import axios from 'axios';
+import { app } from 'electron';
+import Store from 'electron-store';
+
+import { getDeviceId, getSystemInfo } from './deviceInfo';
+
+const store = new Store();
+
+// 统计服务配置
+const STATS_API_URL = 'http://donate.alger.fun/state/api/stats';
+
+/**
+ * 记录应用安装/启动
+ */
+export async function recordInstallation(): Promise<void> {
+  try {
+    const deviceId = getDeviceId();
+    const systemInfo = getSystemInfo();
+
+    // 发送请求到统计服务器
+    await axios.post(`${STATS_API_URL}/installation`, {
+      deviceId,
+      osType: systemInfo.osType,
+      osVersion: systemInfo.osVersion,
+      appVersion: systemInfo.appVersion
+    });
+
+    console.log('应用启动统计已记录');
+
+    // 记录最后一次启动时间
+    store.set('lastStartTime', new Date().toISOString());
+  } catch (error) {
+    console.error('记录应用启动统计失败:', error);
+  }
+}
+
+/**
+ * 设置 IPC 处理程序以接收渲染进程的统计请求
+ * @param ipcMain Electron IPC主对象
+ */
+export function setupStatsHandlers(ipcMain: Electron.IpcMain): void {
+  // 处理页面访问统计
+  ipcMain.handle('record-visit', async (_, page: string, userId?: string) => {
+    try {
+      const deviceId = getDeviceId();
+
+      await axios.post(`${STATS_API_URL}/visit`, {
+        deviceId,
+        userId,
+        page
+      });
+
+      return { success: true };
+    } catch (error) {
+      console.error('记录页面访问统计失败:', error);
+      return { success: false, error: (error as Error).message };
+    }
+  });
+
+  // 处理播放统计
+  ipcMain.handle(
+    'record-play',
+    async (
+      _,
+      songData: {
+        userId: string | null;
+        songId: string | number;
+        songName: string;
+        artistName: string;
+        duration?: number;
+        completedPlay?: boolean;
+      }
+    ) => {
+      try {
+        const { songId, songName, artistName, duration = 0, completedPlay = false } = songData;
+        const deviceId = getDeviceId();
+
+        await axios.post(`${STATS_API_URL}/play`, {
+          deviceId,
+          userId: songData.userId,
+          songId: songId.toString(),
+          songName,
+          artistName,
+          duration,
+          completedPlay
+        });
+
+        return { success: true };
+      } catch (error) {
+        console.error('记录播放统计失败:', error);
+        return { success: false, error: (error as Error).message };
+      }
+    }
+  );
+
+  // 处理获取统计摘要
+  ipcMain.handle('get-stats-summary', async () => {
+    try {
+      const response = await axios.get(`${STATS_API_URL}/summary`);
+      return response.data;
+    } catch (error) {
+      console.error('获取统计摘要失败:', error);
+      throw error;
+    }
+  });
+}
+
+/**
+ * 应用启动时初始化统计服务
+ */
+export function initializeStats(): void {
+  // 记录应用启动统计
+  recordInstallation().catch((error) => {
+    console.error('初始化统计服务失败:', error);
+  });
+
+  // 注册应用退出时的回调
+  app.on('will-quit', () => {
+    // 可以在这里添加应用退出时的统计逻辑
+    console.log('应用退出');
+  });
+}

src/main/server.ts

@@ -5,16 +5,22 @@ import server from 'netease-cloud-music-api-alger/server';
 import os from 'os';
 import path from 'path';
 
-import { unblockMusic } from './unblockMusic';
+import { unblockMusic, type Platform } from './unblockMusic';
 
 const store = new Store();
 if (!fs.existsSync(path.resolve(os.tmpdir(), 'anonymous_token'))) {
   fs.writeFileSync(path.resolve(os.tmpdir(), 'anonymous_token'), '', 'utf-8');
 }
 
-// 处理解锁音乐请求
+// 设置音乐解析的处理程序
-ipcMain.handle('unblock-music', async (_, id, data) => {
+ipcMain.handle('unblock-music', async (_event, id, songData, enabledSources) => {
-  return unblockMusic(id, data);
+  try {
+    const result = await unblockMusic(id, songData, 1, enabledSources as Platform[]);
+    return result;
+  } catch (error) {
+    console.error('音乐解析失败:', error);
+    return { error: (error as Error).message || '未知错误' };
+  }
 });
 
 async function startMusicApi(): Promise<void> {

src/main/set.json

@@ -20,5 +20,8 @@
   "autoPlay": false,
   "downloadPath": "",
   "language": "zh-CN",
-  "alwaysShowDownloadButton": false
+  "alwaysShowDownloadButton": false,
+  "unlimitedDownload": false,
+  "enableMusicUnblock": true,
+  "enabledMusicSources": ["migu", "kugou", "pyncmd", "bilibili", "youtube"]
 }

src/main/unblockMusic.ts

@@ -6,6 +6,8 @@ interface SongData {
   name: string;
   artists: Array<{ name: string }>;
   album?: { name: string };
+  ar?: Array<{ name: string }>;
+  al?: { name: string };
 }
 
 interface ResponseData {
@@ -27,21 +29,26 @@ interface UnblockResult {
   };
 }
 
+// 所有可用平台
+export const ALL_PLATFORMS: Platform[] = ['migu', 'kugou', 'pyncmd', 'kuwo', 'bilibili', 'youtube'];
+
 /**
  * 音乐解析函数
  * @param id 歌曲ID
  * @param songData 歌曲信息
  * @param retryCount 重试次数
+ * @param enabledPlatforms 启用的平台列表，默认为所有平台
  * @returns Promise<UnblockResult>
  */
 const unblockMusic = async (
   id: number | string,
   songData: SongData,
-  retryCount = 3
+  retryCount = 1,
+  enabledPlatforms?: Platform[]
 ): Promise<UnblockResult> => {
-  // 所有可用平台
+  const platforms = enabledPlatforms || ALL_PLATFORMS;
-  const platforms: Platform[] = ['migu', 'kugou', 'pyncmd', 'joox', 'kuwo', 'bilibili', 'youtube'];
+  songData.album = songData.album || songData.al;
-
+  songData.artists = songData.artists || songData.ar;
   const retry = async (attempt: number): Promise<UnblockResult> => {
     try {
       const data = await match(parseInt(String(id), 10), platforms,songData);
@@ -58,7 +65,7 @@ const unblockMusic = async (
     } catch (err) {
       if (attempt < retryCount) {
         // 延迟重试，每次重试增加延迟时间
-        await new Promise((resolve) => setTimeout(resolve, 1000 * attempt));
+        await new Promise((resolve) => setTimeout(resolve, 100 * attempt));
         return retry(attempt + 1);
       }
 

src/preload/index.d.ts

@@ -1,31 +1,42 @@
 import { ElectronAPI } from '@electron-toolkit/preload';
 
-declare global {
+interface API {
-  interface Window {
-    electron: ElectronAPI;
-    api: {
-      sendLyric: (data: string) => void;
-      openLyric: () => void;
   minimize: () => void;
   maximize: () => void;
   close: () => void;
-      dragStart: (data: string) => void;
+  dragStart: (data: any) => void;
   miniTray: () => void;
   miniWindow: () => void;
   restore: () => void;
   restart: () => void;
   resizeWindow: (width: number, height: number) => void;
   resizeMiniWindow: (showPlaylist: boolean) => void;
-      unblockMusic: (id: number, data: any) => Promise<any>;
+  openLyric: () => void;
+  sendLyric: (data: any) => void;
+  sendSong: (data: any) => void;
+  unblockMusic: (id: number, data: any, enabledSources?: string[]) => Promise<any>;
   onLyricWindowClosed: (callback: () => void) => void;
   startDownload: (url: string) => void;
   onDownloadProgress: (callback: (progress: number, status: string) => void) => void;
   onDownloadComplete: (callback: (success: boolean, filePath: string) => void) => void;
-      removeDownloadListeners: () => void;
   onLanguageChanged: (callback: (locale: string) => void) => void;
+  removeDownloadListeners: () => void;
   invoke: (channel: string, ...args: any[]) => Promise<any>;
-      sendSong: (data: any) => void;
+}
-    };
+
+// 自定义IPC渲染进程通信接口
+interface IpcRenderer {
+  send: (channel: string, ...args: any[]) => void;
+  invoke: (channel: string, ...args: any[]) => Promise<any>;
+  on: (channel: string, listener: (...args: any[]) => void) => () => void;
+  removeAllListeners: (channel: string) => void;
+}
+
+declare global {
+  interface Window {
+    electron: ElectronAPI;
+    api: API;
+    ipcRenderer: IpcRenderer;
     $message: any;
   }
 }

src/preload/index.ts

@@ -16,7 +16,7 @@ const api = {
   openLyric: () => ipcRenderer.send('open-lyric'),
   sendLyric: (data) => ipcRenderer.send('send-lyric', data),
   sendSong: (data) => ipcRenderer.send('update-current-song', data),
-  unblockMusic: (id) => ipcRenderer.invoke('unblock-music', id),
+  unblockMusic: (id, data, enabledSources) => ipcRenderer.invoke('unblock-music', id, data, enabledSources),
   // 歌词窗口关闭事件
   onLyricWindowClosed: (callback: () => void) => {
     ipcRenderer.on('lyric-window-closed', () => callback());
@@ -47,7 +47,11 @@ const api = {
       'get-system-fonts',
       'get-cached-lyric',
       'cache-lyric',
-      'clear-lyric-cache'
+      'clear-lyric-cache',
+      // 统计相关
+      'record-visit',
+      'record-play',
+      'get-stats-summary'
     ];
     if (validChannels.includes(channel)) {
       return ipcRenderer.invoke(channel, ...args);
@@ -56,6 +60,29 @@ const api = {
   }
 };
 
+// 创建带类型的ipcRenderer对象，暴露给渲染进程
+const ipc = {
+  // 发送消息到主进程（无返回值）
+  send: (channel: string, ...args: any[]) => {
+    ipcRenderer.send(channel, ...args);
+  },
+  // 调用主进程方法（有返回值）
+  invoke: (channel: string, ...args: any[]) => {
+    return ipcRenderer.invoke(channel, ...args);
+  },
+  // 监听主进程消息
+  on: (channel: string, listener: (...args: any[]) => void) => {
+    ipcRenderer.on(channel, (_, ...args) => listener(...args));
+    return () => {
+      ipcRenderer.removeListener(channel, listener);
+    };
+  },
+  // 移除所有监听器
+  removeAllListeners: (channel: string) => {
+    ipcRenderer.removeAllListeners(channel);
+  }
+};
+
 // Use `contextBridge` APIs to expose Electron APIs to
 // renderer only if context isolation is enabled, otherwise
 // just add to the DOM global.
@@ -63,6 +90,7 @@ if (process.contextIsolated) {
   try {
     contextBridge.exposeInMainWorld('electron', electronAPI);
     contextBridge.exposeInMainWorld('api', api);
+    contextBridge.exposeInMainWorld('ipcRenderer', ipc);
   } catch (error) {
     console.error(error);
   }
@@ -71,4 +99,6 @@ if (process.contextIsolated) {
   window.electron = electronAPI;
   // @ts-ignore (define in dts)
   window.api = api;
+  // @ts-ignore (define in dts)
+  window.ipcRenderer = ipc;
 }

src/renderer/App.vue

@@ -25,7 +25,7 @@ import { isElectron, isLyricWindow } from '@/utils';
 
 import { initAudioListeners } from './hooks/MusicHook';
 import { isMobile } from './utils';
-import { initShortcut } from './utils/shortcut';
+import { useAppShortcuts } from './utils/appShortcuts';
 
 const { locale } = useI18n();
 const settingsStore = useSettingsStore();
@@ -101,6 +101,9 @@ if (isElectron) {
   });
 }
 
+// 使用应用内快捷键
+useAppShortcuts();
+
 onMounted(async () => {
   if (isLyricWindow.value) {
     return;
@@ -112,10 +115,10 @@ onMounted(async () => {
     // 使用 nextTick 确保 DOM 更新后再初始化
     await nextTick();
     initAudioListeners();
+    if (isElectron) {
       window.api.sendSong(cloneDeep(playerStore.playMusic));
     }
-  // 初始化快捷键
+  }
-  initShortcut();
 });
 </script>
 

src/renderer/api/donation.ts

@@ -15,6 +15,6 @@ export interface Donor {
  * 获取捐赠列表
  */
 export const getDonationList = async (): Promise<Donor[]> => {
-  const { data } = await axios.get('http://110.42.251.190:8766/api/donations');
+  const { data } = await axios.get('http://donate.alger.fun/api/donations');
   return data;
 };

src/renderer/api/gdmusic.ts

@@ -0,0 +1,189 @@
+import axios from 'axios';
+import type { MusicSourceType } from '@/type/music';
+
+/**
+ * GD音乐台解析服务
+ */
+export interface GDMusicResponse {
+  url: string;
+  br: number;
+  size: number;
+  md5: string;
+  platform: string;
+  gain: number;
+}
+
+export interface ParsedMusicResult {
+  data: {
+    data: GDMusicResponse;
+    params: {
+      id: number;
+      type: string;
+    }
+  }
+}
+
+/**
+ * 从GD音乐台解析音乐URL
+ * @param id 音乐ID
+ * @param data 音乐数据，包含名称和艺术家信息
+ * @param quality 音质设置
+ * @returns 解析后的音乐URL及相关信息
+ */
+export const parseFromGDMusic = async (
+  id: number, 
+  data: any, 
+  quality: string = '320'
+): Promise<ParsedMusicResult | null> => {
+  try {
+    // 处理不同数据结构
+    if (!data) {
+      console.error('GD音乐台解析：歌曲数据为空');
+      throw new Error('歌曲数据为空');
+    }
+    
+    const songName = data.name || '';
+    let artistNames = '';
+    
+    // 处理不同的艺术家字段结构
+    if (data.artists && Array.isArray(data.artists)) {
+      artistNames = data.artists.map(artist => artist.name).join(' ');
+    } else if (data.ar && Array.isArray(data.ar)) {
+      artistNames = data.ar.map(artist => artist.name).join(' ');
+    } else if (data.artist) {
+      artistNames = typeof data.artist === 'string' ? data.artist : '';
+    }
+    
+    const searchQuery = `${songName} ${artistNames}`.trim();
+    
+    if (!searchQuery || searchQuery.length < 2) {
+      console.error('GD音乐台解析：搜索查询过短', { name: songName, artists: artistNames });
+      throw new Error('搜索查询过短');
+    }
+    
+    // 所有可用的音乐源
+    const allSources = [
+      'tencent', 'kugou', 'kuwo', 'migu', 'netease', 
+      'joox', 'ytmusic', 'spotify', 'qobuz', 'deezer'
+    ] as MusicSourceType[];
+    
+    console.log('GD音乐台开始搜索:', searchQuery);
+    
+    // 依次尝试所有音源
+    for (const source of allSources) {
+      try {
+        const result = await searchAndGetUrl(source, searchQuery, quality);
+        if (result) {
+          console.log(`GD音乐台成功通过 ${result.source} 解析音乐!`);
+          // 返回符合原API格式的数据
+          return {
+            data: {
+              data: {
+                url: result.url.replace(/\\/g, ''),
+                br: parseInt(result.br, 10) * 1000 || 320000,
+                size: result.size || 0,
+                md5: '',
+                platform: 'gdmusic',
+                gain: 0
+              },
+              params: {
+                id: parseInt(String(id), 10),
+                type: 'song'
+              }
+            }
+          };
+        }
+      } catch (error) {
+        console.error(`GD音乐台 ${source} 音源解析失败:`, error);
+        // 该音源失败，继续尝试下一个音源
+        continue;
+      }
+    }
+    
+    console.log('GD音乐台所有音源均解析失败');
+    return null;
+  } catch (error) {
+    console.error('GD音乐台解析完全失败:', error);
+    return null;
+  }
+};
+
+/**
+ * 获取音质映射
+ * @param qualitySetting 设置中的音质选项
+ * @returns 映射到GD音乐台的音质参数
+ */
+export const getQualityMapping = (qualitySetting: string): string => {
+  const qualityMap: Record<string, string> = {
+    standard: '128',
+    higher: '320',
+    exhigh: '320',
+    lossless: '740',
+    hires: '999',
+    jyeffect: '999',
+    sky: '999',
+    dolby: '999',
+    jymaster: '999'
+  };
+  return qualityMap[qualitySetting] || '320';
+};
+
+interface GDMusicUrlResult {
+  url: string;
+  br: string;
+  size: number;
+  source: string;
+}
+
+const baseUrl = 'https://music-api.gdstudio.xyz/api.php';
+
+/**
+ * 在指定音源搜索歌曲并获取URL
+ * @param source 音源
+ * @param searchQuery 搜索关键词
+ * @param quality 音质
+ * @returns 音乐URL结果
+ */
+async function searchAndGetUrl(
+  source: MusicSourceType, 
+  searchQuery: string, 
+  quality: string
+): Promise<GDMusicUrlResult | null> {
+  // 1. 搜索歌曲
+  const searchUrl = `${baseUrl}?types=search&source=${source}&name=${encodeURIComponent(searchQuery)}&count=1&pages=1`;
+  console.log(`GD音乐台尝试音源 ${source} 搜索:`, searchUrl);
+  
+  const searchResponse = await axios.get(searchUrl, { timeout: 5000 });
+  
+  if (searchResponse.data && Array.isArray(searchResponse.data) && searchResponse.data.length > 0) {
+    const firstResult = searchResponse.data[0];
+    if (!firstResult || !firstResult.id) {
+      console.log(`GD音乐台 ${source} 搜索结果无效`);
+      return null;
+    }
+    
+    const trackId = firstResult.id;
+    const trackSource = firstResult.source || source;
+    
+    // 2. 获取歌曲URL
+    const songUrl = `${baseUrl}?types=url&source=${trackSource}&id=${trackId}&br=${quality}`;
+    console.log(`GD音乐台尝试获取 ${trackSource} 歌曲URL:`, songUrl);
+    
+    const songResponse = await axios.get(songUrl, { timeout: 5000 });
+    
+    if (songResponse.data && songResponse.data.url) {
+      return {
+        url: songResponse.data.url,
+        br: songResponse.data.br,
+        size: songResponse.data.size || 0,
+        source: trackSource
+      };
+    } else {
+      console.log(`GD音乐台 ${trackSource} 未返回有效URL`);
+      return null;
+    }
+  } else {
+    console.log(`GD音乐台 ${source} 搜索结果为空`);
+    return null;
+  }
+} 

src/renderer/api/login.ts

@@ -15,7 +15,7 @@ export function createQr(key: any) {
 // 获取二维码状态
 //  /login/qr/check
 export function checkQr(key: any) {
-  return request.get('/login/qr/check', { params: { key } });
+  return request.get('/login/qr/check', { params: { key, noCookie: true } });
 }
 
 // 获取登录状态

src/renderer/api/music.ts

@@ -4,6 +4,8 @@ import type { ILyric } from '@/type/lyric';
 import { isElectron } from '@/utils';
 import request from '@/utils/request';
 import requestMusic from '@/utils/request_music';
+import { cloneDeep } from 'lodash';
+import { parseFromGDMusic, getQualityMapping } from './gdmusic';
 
 const { addData, getData, deleteData } = musicDB;
 
@@ -78,10 +80,39 @@ export const getMusicLrc = async (id: number) => {
   }
 };
 
-export const getParsingMusicUrl = (id: number, data: any) => {
+export const getParsingMusicUrl = async (id: number, data: any) => {
-  if (isElectron) {
+  const settingStore = useSettingsStore();
-    return window.api.unblockMusic(id, data);
+  
+  // 如果禁用了音乐解析功能，则直接返回空结果
+  if (!settingStore.setData.enableMusicUnblock) {
+    return Promise.resolve({ data: { code: 404, message: '音乐解析功能已禁用' } });
   }
+  
+  // 检查是否选择了GD音乐台解析
+  const enabledSources = settingStore.setData.enabledMusicSources || [];
+  if (enabledSources.includes('gdmusic')) {
+    // 获取音质设置并转换为GD音乐台格式
+    try {
+      const quality = getQualityMapping(settingStore.setData.musicQuality || 'higher');
+      
+      // 调用封装的GD音乐台解析服务
+      const gdResult = await parseFromGDMusic(id, data, quality);
+      if (gdResult) {
+        return gdResult;
+      }
+    } catch (error) {
+      console.error('GD音乐台解析失败:', error);
+    }
+      
+    console.log('GD音乐台所有音源均解析失败，尝试使用unblockMusic');
+  }
+  
+  // 如果GD音乐台解析失败或者未启用，尝试使用unblockMusic
+  if (isElectron) {
+    const filteredSources = enabledSources.filter(source => source !== 'gdmusic');
+    return window.api.unblockMusic(id, cloneDeep(data), cloneDeep(filteredSources));
+  }
+  
   return requestMusic.get<any>('/music', { params: { id } });
 };
 

src/renderer/api/stats.ts

@@ -0,0 +1,75 @@
+import { isElectron } from '@/utils';
+
+import { useUserStore } from '../store/modules/user';
+
+/**
+ * 获取用户ID
+ * @returns 用户ID或null
+ */
+function getUserId(): string | null {
+  const userStore = useUserStore();
+  return userStore.user?.userId?.toString() || null;
+}
+
+/**
+ * 记录页面访问
+ * @param page 页面名称或路径
+ */
+export async function recordVisit(page: string): Promise<void> {
+  if (!isElectron) return;
+  try {
+    const userId = getUserId();
+    await window.api.invoke('record-visit', page, userId);
+    console.log(`页面访问已记录: ${page}`);
+  } catch (error) {
+    console.error('记录页面访问失败:', error);
+  }
+}
+
+/**
+ * 记录歌曲播放
+ * @param songId 歌曲ID
+ * @param songName 歌曲名称
+ * @param artistName 艺术家名称
+ * @param duration 时长（秒）
+ * @param completedPlay 是否完整播放
+ */
+export async function recordPlay(
+  songId: string | number,
+  songName: string,
+  artistName: string,
+  duration: number = 0,
+  completedPlay: boolean = false
+): Promise<void> {
+  if (!isElectron) return;
+  try {
+    const userId = getUserId();
+
+    await window.api.invoke('record-play', {
+      userId,
+      songId,
+      songName,
+      artistName,
+      duration,
+      completedPlay
+    });
+
+    console.log(`歌曲播放已记录: ${songName}`);
+  } catch (error) {
+    console.error('记录歌曲播放失败:', error);
+  }
+}
+
+/**
+ * 获取统计摘要
+ * @returns 统计数据摘要
+ */
+export async function getStatsSummary(): Promise<any> {
+  if (!isElectron) return null;
+  try {
+    return await window.api.invoke('get-stats-summary');
+  } catch (error) {
+    console.error('获取统计摘要失败:', error);
+    return null;
+  }
+}

src/renderer/components.d.ts

@@ -17,8 +17,12 @@ declare module 'vue' {
     NCarouselItem: typeof import('naive-ui')['NCarouselItem']
     NCheckbox: typeof import('naive-ui')['NCheckbox']
     NCheckboxGroup: typeof import('naive-ui')['NCheckboxGroup']
+    NCollapse: typeof import('naive-ui')['NCollapse']
+    NCollapseItem: typeof import('naive-ui')['NCollapseItem']
+    NCollapseTransition: typeof import('naive-ui')['NCollapseTransition']
     NConfigProvider: typeof import('naive-ui')['NConfigProvider']
     NDialogProvider: typeof import('naive-ui')['NDialogProvider']
+    NDivider: typeof import('naive-ui')['NDivider']
     NDrawer: typeof import('naive-ui')['NDrawer']
     NDrawerContent: typeof import('naive-ui')['NDrawerContent']
     NDropdown: typeof import('naive-ui')['NDropdown']
@@ -26,6 +30,8 @@ declare module 'vue' {
     NEmpty: typeof import('naive-ui')['NEmpty']
     NForm: typeof import('naive-ui')['NForm']
     NFormItem: typeof import('naive-ui')['NFormItem']
+    NGrid: typeof import('naive-ui')['NGrid']
+    NGridItem: typeof import('naive-ui')['NGridItem']
     NIcon: typeof import('naive-ui')['NIcon']
     NImage: typeof import('naive-ui')['NImage']
     NInput: typeof import('naive-ui')['NInput']
@@ -46,6 +52,7 @@ declare module 'vue' {
     NTabPane: typeof import('naive-ui')['NTabPane']
     NTabs: typeof import('naive-ui')['NTabs']
     NTag: typeof import('naive-ui')['NTag']
+    NText: typeof import('naive-ui')['NText']
     NTooltip: typeof import('naive-ui')['NTooltip']
     NVirtualList: typeof import('naive-ui')['NVirtualList']
     RouterLink: typeof import('vue-router')['RouterLink']

src/renderer/components/MusicList.vue

@@ -12,21 +12,39 @@
   >
     <div class="music-page">
       <div class="music-header h-12 flex items-center justify-between">
-        <n-ellipsis :line-clamp="1">
+        <n-ellipsis :line-clamp="1" class="flex-shrink-0 mr-3">
           <div class="music-title">
             {{ name }}
           </div>
         </n-ellipsis>
-        <div class="music-close">
+
+        <!-- 搜索框 -->
+        <div class="flex-grow flex-1 flex items-center justify-end">
+          <div class="search-container">
+            <n-input
+              v-model:value="searchKeyword"
+              :placeholder="t('comp.musicList.searchSongs')"
+              clearable
+              round
+              size="small"
+            >
+              <template #prefix>
+                <i class="icon iconfont ri-search-line text-sm"></i>
+              </template>
+            </n-input>
+          </div>
+        </div>
+        <div class="music-close flex-shrink-0 ml-3">
           <i class="icon iconfont ri-close-line" @click="close"></i>
         </div>
       </div>
+
       <div class="music-content">
         <!-- 左侧歌单信息 -->
         <div class="music-info">
           <div class="music-cover">
             <n-image
-              :src="getImgUrl(cover ? listInfo?.coverImgUrl : displayedSongs[0]?.picUrl, '500y500')"
+              :src="getCoverImgUrl"
               class="cover-img"
               preview-disabled
               :class="setAnimationClass('animate__fadeIn')"
@@ -49,16 +67,25 @@
         <!-- 右侧歌曲列表 -->
         <div class="music-list-container">
           <div class="music-list">
-            <n-scrollbar @scroll="handleScroll">
             <n-spin :show="loadingList || loading">
               <div class="music-list-content">
-                  <div
+                <div v-if="filteredSongs.length === 0 && searchKeyword" class="no-result">
-                    v-for="(item, index) in displayedSongs"
+                  {{ t('comp.musicList.noSearchResults') }}
-                    :key="item.id"
+                </div>
-                    class="double-item"
+
-                    :class="setAnimationClass('animate__bounceInUp')"
+                <!-- 虚拟列表，设置正确的固定高度 -->
-                    :style="getItemAnimationDelay(index)"
+                <n-virtual-list
+                  ref="songListRef"
+                  class="song-virtual-list"
+                  style="height: calc(70vh - 60px)"
+                  :items="filteredSongs"
+                  :item-size="70"
+                  item-resizable
+                  key-field="id"
+                  @scroll="handleVirtualScroll"
                 >
+                  <template #default="{ item }">
+                    <div class="double-item">
                       <song-item
                         :item="formatSong(item)"
                         :can-remove="canRemove"
@@ -66,16 +93,10 @@
                         @remove-song="(id) => emit('remove-song', id)"
                       />
                     </div>
-                  <div v-if="isLoadingMore" class="loading-more">
+                  </template>
-                    {{ t('common.loadingMore') }}
+                </n-virtual-list>
-                  </div>
-                  <div v-if="!hasMore" class="loading-more">
-                    {{ t('common.noMore') }}
-                  </div>
-                  <play-bottom />
               </div>
             </n-spin>
-            </n-scrollbar>
           </div>
           <play-bottom />
         </div>
@@ -85,19 +106,20 @@
 </template>
 
 <script setup lang="ts">
+import PinyinMatch from 'pinyin-match';
 import { computed, onUnmounted, ref, watch } from 'vue';
 import { useI18n } from 'vue-i18n';
 
 import { getMusicDetail } from '@/api/music';
 import SongItem from '@/components/common/SongItem.vue';
 import { usePlayerStore } from '@/store/modules/player';
-import { getImgUrl, isMobile, setAnimationClass, setAnimationDelay } from '@/utils';
+import { SongResult } from '@/type/music';
+import { getImgUrl, isMobile, setAnimationClass } from '@/utils';
 
 import PlayBottom from './common/PlayBottom.vue';
 
 const { t } = useI18n();
 const playerStore = usePlayerStore();
-
 const props = withDefaults(
   defineProps<{
     show: boolean;
@@ -125,12 +147,14 @@ const emit = defineEmits(['update:show', 'update:loading', 'remove-song']);
 const page = ref(0);
 const pageSize = 40;
 const isLoadingMore = ref(false);
-const displayedSongs = ref<any[]>([]);
+const displayedSongs = ref<SongResult[]>([]);
 const loadingList = ref(false);
 const loadedIds = ref(new Set<number>()); // 用于追踪已加载的歌曲ID
 const isPlaylistLoading = ref(false); // 标记是否正在加载播放列表
-const completePlaylist = ref<any[]>([]); // 存储完整的播放列表
+const completePlaylist = ref<SongResult[]>([]); // 存储完整的播放列表
 const hasMore = ref(true); // 标记是否还有更多数据可加载
+const searchKeyword = ref(''); // 搜索关键词
+const isFullPlaylistLoaded = ref(false); // 标记完整播放列表是否已加载完成
 
 // 计算总数
 const total = computed(() => {
@@ -140,8 +164,66 @@ const total = computed(() => {
   return props.songList.length;
 });
 
+const getCoverImgUrl = computed(() => {
+  if (props.listInfo?.coverImgUrl) {
+    return props.listInfo.coverImgUrl;
+  }
+
+  const song = props.songList[0];
+  if (song?.picUrl) {
+    return song.picUrl;
+  }
+  if (song?.al?.picUrl) {
+    return song.al.picUrl;
+  }
+  if (song?.album?.picUrl) {
+    return song.album.picUrl;
+  }
+  return '';
+});
+
+// 过滤歌曲列表
+const filteredSongs = computed(() => {
+  if (!searchKeyword.value) {
+    return displayedSongs.value;
+  }
+
+  const keyword = searchKeyword.value.toLowerCase().trim();
+  return displayedSongs.value.filter((song) => {
+    const songName = song.name?.toLowerCase() || '';
+    const albumName = song.al?.name?.toLowerCase() || '';
+    const artists = song.ar || song.artists || [];
+
+    // 原始文本匹配
+    const nameMatch = songName.includes(keyword);
+    const albumMatch = albumName.includes(keyword);
+    const artistsMatch = artists.some((artist: any) => {
+      return artist.name?.toLowerCase().includes(keyword);
+    });
+
+    // 拼音匹配
+    const namePinyinMatch = song.name && PinyinMatch.match(song.name, keyword);
+    const albumPinyinMatch = song.al?.name && PinyinMatch.match(song.al.name, keyword);
+    const artistsPinyinMatch = artists.some((artist: any) => {
+      return artist.name && PinyinMatch.match(artist.name, keyword);
+    });
+
+    return (
+      nameMatch ||
+      albumMatch ||
+      artistsMatch ||
+      namePinyinMatch ||
+      albumPinyinMatch ||
+      artistsPinyinMatch
+    );
+  });
+});
+
 // 格式化歌曲数据
 const formatSong = (item: any) => {
+  if (!item) {
+    return null;
+  }
   return {
     ...item,
     picUrl: item.al?.picUrl || item.picUrl,
@@ -163,25 +245,44 @@ const loadSongs = async (ids: number[], appendToList = true, updateComplete = fa
   if (ids.length === 0) return [];
 
   try {
+    console.log(`请求歌曲详情，ID数量: ${ids.length}`);
     const { data } = await getMusicDetail(ids);
-    if (data?.songs) {
-      // 更新已加载ID集合
-      const newSongs = data.songs.filter((song: any) => !loadedIds.value.has(song.id));
 
-      newSongs.forEach((song: any) => {
+    if (data?.songs) {
+      console.log(`API返回歌曲数量: ${data.songs.length}`);
+
+      // 直接使用API返回的所有歌曲，不再过滤已加载的歌曲
+      // 因为当需要完整加载列表时，我们希望获取所有歌曲，即使ID可能重复
+      const { songs } = data;
+
+      // 只在非更新完整列表时执行过滤
+      let newSongs = songs;
+      if (!updateComplete) {
+        // 在普通加载模式下继续过滤已加载的歌曲，避免重复
+        newSongs = songs.filter((song: any) => !loadedIds.value.has(song.id));
+        console.log(`过滤已加载ID后剩余歌曲数量: ${newSongs.length}`);
+      }
+
+      // 更新已加载ID集合
+      songs.forEach((song: any) => {
         loadedIds.value.add(song.id);
       });
 
+      // 追加到显示列表 - 仅当appendToList=true时添加到displayedSongs
       if (appendToList) {
         displayedSongs.value.push(...newSongs);
       }
 
+      // 更新完整播放列表 - 仅当updateComplete=true时添加到completePlaylist
       if (updateComplete) {
-        completePlaylist.value.push(...newSongs);
+        completePlaylist.value.push(...songs);
+        console.log(`已添加到完整播放列表，当前完整列表长度: ${completePlaylist.value.length}`);
       }
 
-      return newSongs;
+      return updateComplete ? songs : newSongs;
     }
+    console.log('API返回无歌曲数据');
+    return [];
   } catch (error) {
     console.error('加载歌曲失败:', error);
   }
@@ -191,41 +292,127 @@ const loadSongs = async (ids: number[], appendToList = true, updateComplete = fa
 
 // 加载完整播放列表
 const loadFullPlaylist = async () => {
-  if (isPlaylistLoading.value) return;
+  if (isPlaylistLoading.value || isFullPlaylistLoaded.value) return;
+
   isPlaylistLoading.value = true;
-  completePlaylist.value = [...displayedSongs.value]; // 先用当前已加载的歌曲初始化
+  // 记录开始时间
+  const startTime = Date.now();
+  console.log(`开始加载完整播放列表，当前显示列表长度: ${displayedSongs.value.length}`);
 
   try {
-    // 如果没有trackIds，直接使用当前歌曲列表
+    // 如果没有trackIds，直接使用当前歌曲列表并标记为已完成
     if (!props.listInfo?.trackIds) {
+      isFullPlaylistLoaded.value = true;
+      console.log('无trackIds信息，使用当前列表作为完整列表');
       return;
     }
 
-    // 获取所有未加载的歌曲ID
+    // 获取所有trackIds
     const allIds = props.listInfo.trackIds.map((item) => item.id);
-    const unloadedIds = allIds.filter((id) => !loadedIds.value.has(id));
+    console.log(`歌单共有歌曲ID: ${allIds.length}首`);
+
+    // 重置completePlaylist和当前显示歌曲ID集合，保证不会重复添加歌曲
+    completePlaylist.value = [];
+
+    // 使用Set记录所有已加载的歌曲ID
+    const loadedSongIds = new Set<number>();
+
+    // 将当前显示列表中的歌曲和ID添加到集合中
+    displayedSongs.value.forEach((song) => {
+      loadedSongIds.add(song.id as number);
+      // 将已有歌曲添加到completePlaylist
+      completePlaylist.value.push(song);
+    });
+
+    console.log(
+      `已有显示歌曲: ${displayedSongs.value.length}首，已有ID数量: ${loadedSongIds.size}`
+    );
+
+    // 过滤出尚未加载的歌曲ID
+    const unloadedIds = allIds.filter((id) => !loadedSongIds.has(id));
+    console.log(`还需要加载的歌曲ID数量: ${unloadedIds.length}`);
 
-    // 如果所有歌曲都已加载，直接返回
     if (unloadedIds.length === 0) {
+      console.log('所有歌曲已加载，无需再次加载');
+      isFullPlaylistLoaded.value = true;
+      hasMore.value = false;
       return;
     }
 
-    // 分批加载未加载的歌曲
+    // 分批加载所有未加载的歌曲
     const batchSize = 500; // 每批加载的歌曲数量
+
     for (let i = 0; i < unloadedIds.length; i += batchSize) {
       const batchIds = unloadedIds.slice(i, i + batchSize);
       if (batchIds.length === 0) continue;
 
-      await loadSongs(batchIds, false, true);
+      console.log(`请求第${Math.floor(i / batchSize) + 1}批歌曲，数量: ${batchIds.length}`);
+      // 关键修改: 设置appendToList为false，避免loadSongs直接添加到displayedSongs
+      const loadedBatch = await loadSongs(batchIds, false, false);
+
+      // 添加新加载的歌曲到displayedSongs
+      if (loadedBatch.length > 0) {
+        // 过滤掉已有的歌曲，确保不会重复添加
+        const newSongs = loadedBatch.filter((song) => !loadedSongIds.has(song.id as number));
+
+        // 更新已加载ID集合
+        newSongs.forEach((song) => {
+          loadedSongIds.add(song.id as number);
+        });
+
+        console.log(`新增${newSongs.length}首歌曲到显示列表`);
+
+        // 更新显示列表和完整播放列表
+        if (newSongs.length > 0) {
+          // 添加到显示列表
+          displayedSongs.value = [...displayedSongs.value, ...newSongs];
+
+          // 添加到完整播放列表
+          completePlaylist.value.push(...newSongs);
+
+          // 如果当前正在播放的列表与这个列表匹配，实时更新播放列表
+          const currentPlaylist = playerStore.playList;
+          if (currentPlaylist.length > 0 && currentPlaylist[0].id === displayedSongs.value[0]?.id) {
+            console.log('实时更新当前播放列表');
+            playerStore.setPlayList(displayedSongs.value.map(formatSong));
+          }
+        }
+      }
 
       // 添加小延迟避免请求过于密集
       if (i + batchSize < unloadedIds.length) {
-        // 使用 setTimeout 直接延迟，避免 Promise 相关的 linter 错误
         await new Promise<void>((resolve) => {
-          setTimeout(() => resolve(), 300);
+          setTimeout(() => resolve(), 100);
         });
       }
     }
+
+    // 加载完成，更新状态
+    isFullPlaylistLoaded.value = true;
+    hasMore.value = false;
+
+    // 计算加载耗时
+    const endTime = Date.now();
+    const timeUsed = Math.round(((endTime - startTime) / 1000) * 100) / 100;
+
+    console.log(
+      `完整播放列表加载完成，共加载${displayedSongs.value.length}首歌曲，耗时${timeUsed}秒`
+    );
+    console.log(`歌单应有${allIds.length}首歌，实际加载${displayedSongs.value.length}首`);
+
+    // 检查加载的歌曲数量是否与预期相符
+    if (displayedSongs.value.length !== allIds.length) {
+      console.warn(
+        `警告: 加载的歌曲数量(${displayedSongs.value.length})与歌单应有数量(${allIds.length})不符`
+      );
+
+      // 如果数量不符，可能是API未返回所有歌曲，打印缺失的歌曲ID
+      if (displayedSongs.value.length < allIds.length) {
+        const loadedIds = new Set(displayedSongs.value.map((song) => song.id));
+        const missingIds = allIds.filter((id) => !loadedIds.has(id));
+        console.warn(`缺失的歌曲ID: ${missingIds.join(', ')}`);
+      }
+    }
   } catch (error) {
     console.error('加载完整播放列表失败:', error);
   } finally {
@@ -235,16 +422,31 @@ const loadFullPlaylist = async () => {
 
 // 处理播放
 const handlePlay = async () => {
-  // 先使用当前已加载的歌曲开始播放
+  // 当搜索状态下播放时，只播放过滤后的歌曲
+  if (searchKeyword.value) {
+    playerStore.setPlayList(filteredSongs.value.map(formatSong));
+    return;
+  }
+
+  // 如果完整播放列表已加载完成
+  if (isFullPlaylistLoaded.value && completePlaylist.value.length > 0) {
+    playerStore.setPlayList(completePlaylist.value.map(formatSong));
+    return;
+  }
+
+  // 如果完整播放列表未加载完成，先使用当前已加载的歌曲开始播放
   playerStore.setPlayList(displayedSongs.value.map(formatSong));
 
-  // 在后台加载完整播放列表
+  // 如果完整播放列表正在加载中，不需要重新触发加载
-  loadFullPlaylist().then(() => {
+  if (isPlaylistLoading.value) {
-    // 加载完成后，更新播放列表为完整列表
+    return;
-    if (completePlaylist.value.length > 0) {
+  }
-      playerStore.setPlayList(completePlaylist.value.map(formatSong));
+
+  // 在后台继续加载完整播放列表（如果未加载完成）
+  if (!isFullPlaylistLoaded.value) {
+    console.log('播放时继续在后台加载完整列表');
+    loadFullPlaylist();
   }
-  });
 };
 
 const close = () => {
@@ -253,19 +455,27 @@ const close = () => {
 
 // 加载更多歌曲
 const loadMoreSongs = async () => {
-  // 检查是否正在加载或已经加载完成
+  if (isFullPlaylistLoaded.value) {
+    hasMore.value = false;
+    return;
+  }
+
+  if (searchKeyword.value) {
+    return;
+  }
+
   if (isLoadingMore.value || displayedSongs.value.length >= total.value) {
     hasMore.value = false;
     return;
   }
 
   isLoadingMore.value = true;
+
   try {
     const start = displayedSongs.value.length;
     const end = Math.min(start + pageSize, total.value);
 
     if (props.listInfo?.trackIds) {
-      // 获取这一批次需要加载的所有ID
       const trackIdsToLoad = props.listInfo.trackIds
         .slice(start, end)
         .map((item) => item.id)
@@ -275,7 +485,6 @@ const loadMoreSongs = async () => {
         await loadSongs(trackIdsToLoad, true, false);
       }
     } else if (start < props.songList.length) {
-      // 直接使用 songList 分页
       const newSongs = props.songList.slice(start, end);
       newSongs.forEach((song) => {
         if (!loadedIds.value.has(song.id)) {
@@ -285,7 +494,6 @@ const loadMoreSongs = async () => {
       });
     }
 
-    // 更新是否还有更多数据的状态
     hasMore.value = displayedSongs.value.length < total.value;
   } catch (error) {
     console.error('加载更多歌曲失败:', error);
@@ -295,28 +503,23 @@ const loadMoreSongs = async () => {
   }
 };
 
-// 修改滚动处理函数
+// 处理虚拟列表滚动事件
-const handleScroll = (e: Event) => {
+const handleVirtualScroll = (e: any) => {
-  const target = e.target as HTMLElement;
+  if (!e || !e.target) return;
-  if (!target) return;
 
-  const { scrollTop, scrollHeight, clientHeight } = target;
+  const { scrollTop, scrollHeight, clientHeight } = e.target;
   const threshold = 200;
 
   if (
     scrollHeight - scrollTop - clientHeight < threshold &&
     !isLoadingMore.value &&
-    hasMore.value
+    hasMore.value &&
+    !searchKeyword.value // 搜索状态下不触发加载更多
   ) {
     loadMoreSongs();
   }
 };
 
-const getItemAnimationDelay = (index: number) => {
-  const currentPageIndex = index % pageSize;
-  return setAnimationDelay(currentPageIndex, 20);
-};
-
 // 重置列表状态
 const resetListState = () => {
   page.value = 0;
@@ -325,6 +528,8 @@ const resetListState = () => {
   completePlaylist.value = [];
   hasMore.value = true;
   loadingList.value = false;
+  searchKeyword.value = ''; // 重置搜索关键词
+  isFullPlaylistLoaded.value = false; // 重置完整播放列表状态
 };
 
 // 初始化歌曲列表
@@ -339,6 +544,15 @@ const initSongList = (songs: any[]) => {
   hasMore.value = displayedSongs.value.length < total.value;
 };
 
+watch(
+  () => props.listInfo,
+  (newListInfo) => {
+    if (newListInfo?.trackIds) {
+      loadFullPlaylist();
+    }
+  },
+  { deep: true }
+);
 // 修改 songList 监听器
 watch(
   () => props.songList,
@@ -359,6 +573,14 @@ watch(
   { immediate: true }
 );
 
+// 监听搜索关键词变化
+watch(searchKeyword, () => {
+  // 当搜索关键词为空时，考虑加载更多歌曲
+  if (!searchKeyword.value && hasMore.value && displayedSongs.value.length < total.value) {
+    loadMoreSongs();
+  }
+});
+
 // 组件卸载时清理状态
 onUnmounted(() => {
   isPlaylistLoading.value = false;
@@ -422,13 +644,35 @@ onUnmounted(() => {
     &-content {
       @apply min-h-[calc(80vh-60px)];
     }
-
-    :deep(.n-virtual-list__scroll) {
-      scrollbar-width: none;
-      &::-webkit-scrollbar {
-        display: none;
   }
 }
+
+.search-container {
+  @apply max-w-md;
+
+  :deep(.n-input) {
+    @apply bg-light-200 dark:bg-dark-200;
+  }
+
+  .icon {
+    @apply text-gray-500 dark:text-gray-400;
+  }
+}
+
+.no-result {
+  @apply text-center py-8 text-gray-500 dark:text-gray-400;
+}
+
+/* 虚拟列表样式 */
+.song-virtual-list {
+  :deep(.n-virtual-list__scroll) {
+    scrollbar-width: thin;
+    &::-webkit-scrollbar {
+      width: 4px;
+    }
+    &::-webkit-scrollbar-thumb {
+      @apply bg-gray-400 dark:bg-gray-600 rounded;
+    }
   }
 }
 
@@ -452,6 +696,18 @@ onUnmounted(() => {
       @apply flex-1 ml-4;
     }
   }
+
+  .music-title {
+    @apply text-base;
+  }
+
+  .search-container {
+    @apply max-w-[50%];
+  }
+
+  .song-virtual-list {
+    height: calc(80vh - 120px) !important;
+  }
 }
 
 .loading-more {

src/renderer/components/common/DownloadDrawer.vue

@@ -90,10 +90,25 @@
           <!-- 已下载列表 -->
           <n-tab-pane name="downloaded" :tab="t('download.tabs.downloaded')" class="h-full">
             <div class="downloaded-list">
-              <div v-if="downloadedList.length === 0" class="empty-tip">
+              <div v-if="isLoadingDownloaded" class="loading-tip">
+                <n-spin size="medium" />
+                <span class="loading-text">{{ t('download.loading') }}</span>
+              </div>
+              <div v-else-if="downloadedList.length === 0" class="empty-tip">
                 <n-empty :description="t('download.empty.noDownloaded')" />
               </div>
               <div v-else class="downloaded-content">
+                <div class="downloaded-header">
+                  <div class="header-title">
+                    {{ t('download.count', { count: downloadedList.length }) }}
+                  </div>
+                  <n-button secondary size="small" @click="showClearConfirm = true">
+                    <template #icon>
+                      <i class="iconfont ri-delete-bin-line mr-1"></i>
+                    </template>
+                    {{ t('download.clearAll') }}
+                  </n-button>
+                </div>
                 <div class="downloaded-items">
                   <div v-for="item in downList" :key="item.path" class="downloaded-item">
                     <div class="downloaded-item-content">
@@ -172,12 +187,38 @@
       }}</n-button>
     </template>
   </n-modal>
+
+  <!-- 清空确认对话框 -->
+  <n-modal
+    v-model:show="showClearConfirm"
+    preset="dialog"
+    type="warning"
+    :title="t('download.clear.title')"
+  >
+    <template #header>
+      <div class="flex items-center">
+        <i class="iconfont ri-delete-bin-line mr-2 text-xl"></i>
+        <span>{{ t('download.clear.title') }}</span>
+      </div>
+    </template>
+    <div class="delete-confirm-content">
+      {{ t('download.clear.message') }}
+    </div>
+    <template #action>
+      <n-button size="small" @click="showClearConfirm = false">{{
+        t('download.clear.cancel')
+      }}</n-button>
+      <n-button size="small" type="warning" @click="clearDownloadRecords">{{
+        t('download.clear.confirm')
+      }}</n-button>
+    </template>
+  </n-modal>
 </template>
 
 <script setup lang="ts">
 import type { ProgressStatus } from 'naive-ui';
 import { useMessage } from 'naive-ui';
-import { computed, onMounted, ref } from 'vue';
+import { computed, onMounted, ref, watch } from 'vue';
 import { useI18n } from 'vue-i18n';
 
 import { getMusicDetail } from '@/api/music';
@@ -225,9 +266,7 @@ const downloadedList = ref<DownloadedItem[]>(
   JSON.parse(localStorage.getItem('downloadedList') || '[]')
 );
 
-const downList = computed(() => {
+const downList = computed(() => downloadedList.value);
-  return (downloadedList.value as DownloadedItem[]).reverse();
-});
 
 // 计算下载中的任务数量
 const downloadingCount = computed(() => {
@@ -313,36 +352,50 @@ const handleDelete = (item: DownloadedItem) => {
 
 // 确认删除
 const confirmDelete = async () => {
-  if (!itemToDelete.value) return;
+  const item = itemToDelete.value;
+  if (!item) return;
 
   try {
     const success = await window.electron.ipcRenderer.invoke(
       'delete-downloaded-music',
-      itemToDelete.value.path
+      item.path
     );
+
     if (success) {
-      localStorage.setItem(
+      const newList = downloadedList.value.filter(i => i.id !== item.id);
-        'downloadedList',
+      downloadedList.value = newList;
-        JSON.stringify(
+      localStorage.setItem('downloadedList', JSON.stringify(newList));
-          downloadedList.value.filter(
-            (item) => item.id !== (itemToDelete.value as DownloadedItem).id
-          )
-        )
-      );
-      await refreshDownloadedList();
       message.success(t('download.delete.success'));
     } else {
-      message.error(t('download.delete.failed'));
+      message.warning(t('download.delete.fileNotFound'));
     }
   } catch (error) {
     console.error('Failed to delete music:', error);
-    message.error(t('download.delete.failed'));
+    message.warning(t('download.delete.recordRemoved'));
   } finally {
     showDeleteConfirm.value = false;
     itemToDelete.value = null;
   }
 };
 
+// 清空下载记录相关
+const showClearConfirm = ref(false);
+
+// 清空下载记录
+const clearDownloadRecords = async () => {
+  try {
+    downloadedList.value = [];
+    localStorage.setItem('downloadedList', '[]');
+    await window.electron.ipcRenderer.invoke('clear-downloaded-music');
+    message.success(t('download.clear.success'));
+  } catch (error) {
+    console.error('Failed to clear download records:', error);
+    message.error(t('download.clear.failed'));
+  } finally {
+    showClearConfirm.value = false;
+  }
+};
+
 // 播放音乐
 // const handlePlay = async (musicInfo: SongResult) => {
 //   await playerStore.setPlay(musicInfo);
@@ -350,20 +403,30 @@ const confirmDelete = async () => {
 //   playerStore.setIsPlay(true);
 // };
 
+// 添加加载状态
+const isLoadingDownloaded = ref(false);
+
 // 获取已下载音乐列表
 const refreshDownloadedList = async () => {
+  if (isLoadingDownloaded.value) return; // 防止重复加载
+  
   try {
-    let saveList: any = [];
+    isLoadingDownloaded.value = true;
     const list = await window.electron.ipcRenderer.invoke('get-downloaded-music');
+    
     if (!Array.isArray(list) || list.length === 0) {
-      saveList = [];
+      downloadedList.value = [];
+      localStorage.setItem('downloadedList', '[]');
       return;
     }
 
-    const songIds = list.filter((item) => item.id).map((item) => item.id);
+    const songIds = list.filter(item => item.id).map(item => item.id);
+    if (songIds.length === 0) {
+      downloadedList.value = list;
+      localStorage.setItem('downloadedList', JSON.stringify(list));
+      return;
+    }
 
-    // 如果有歌曲ID，获取详细信息
-    if (songIds.length > 0) {
     try {
       const detailRes = await getMusicDetail(songIds);
       const songDetails = detailRes.data.songs.reduce((acc, song) => {
@@ -371,44 +434,33 @@ const refreshDownloadedList = async () => {
         return acc;
       }, {});
 
-        saveList = list.map((item) => {
+      const updatedList = list.map(item => ({
-          const songDetail = songDetails[item.id];
-          return {
         ...item,
-            picUrl: songDetail?.al?.picUrl || item.picUrl || '/images/default_cover.png',
+        picUrl: songDetails[item.id]?.al?.picUrl || item.picUrl || '/images/default_cover.png',
-            ar: songDetail?.ar || item.ar || [{ name: t('download.localMusic') }]
+        ar: songDetails[item.id]?.ar || item.ar || [{ name: t('download.localMusic') }]
-          };
+      }));
-        });
+
-      } catch (detailError) {
+      downloadedList.value = updatedList;
-        console.error('Failed to get music details:', detailError);
+      localStorage.setItem('downloadedList', JSON.stringify(updatedList));
-        saveList = list;
+    } catch (error) {
+      console.error('Failed to get music details:', error);
+      downloadedList.value = list;
+      localStorage.setItem('downloadedList', JSON.stringify(list));
     }
-    } else {
-      saveList = list;
-    }
-    setLocalDownloadedList(saveList);
   } catch (error) {
     console.error('Failed to get downloaded music list:', error);
     downloadedList.value = [];
+    localStorage.setItem('downloadedList', '[]');
+  } finally {
+    isLoadingDownloaded.value = false;
   }
 };
 
-const setLocalDownloadedList = (list: DownloadedItem[]) => {
-  const localList = localStorage.getItem('downloadedList');
-  // 合并 去重
-  const saveList = [...(localList ? JSON.parse(localList) : []), ...list];
-  const uniqueList = saveList.filter(
-    (item, index, self) => index === self.findIndex((t) => t.id === item.id)
-  );
-  localStorage.setItem('downloadedList', JSON.stringify(uniqueList));
-  downloadedList.value = uniqueList;
-};
-
 // 监听抽屉显示状态
 watch(
   () => showDrawer.value,
   (newVal) => {
-    if (newVal) {
+    if (newVal && !isLoadingDownloaded.value) {
       refreshDownloadedList();
     }
   }
@@ -421,6 +473,12 @@ onMounted(() => {
   // 监听下载进度
   window.electron.ipcRenderer.on('music-download-progress', (_, data) => {
     const existingItem = downloadList.value.find((item) => item.filename === data.filename);
+
+    // 如果进度为100%，将状态设置为已完成
+    if (data.progress === 100) {
+      data.status = 'completed';
+    }
+
     if (existingItem) {
       Object.assign(existingItem, {
         ...data,
@@ -440,15 +498,14 @@ onMounted(() => {
   });
 
   // 监听下载完成
-  window.electron.ipcRenderer.on('music-download-complete', (_, data) => {
+  window.electron.ipcRenderer.on('music-download-complete', async (_, data) => {
     if (data.success) {
-      // 从下载列表中移除
+      downloadList.value = downloadList.value.filter(item => item.filename !== data.filename);
-      downloadList.value = downloadList.value.filter((item) => item.filename !== data.filename);
+      // 延迟刷新已下载列表，避免文件系统未完全写入
-      // 刷新已下载列表
+      setTimeout(() => refreshDownloadedList(), 500);
-      refreshDownloadedList();
       message.success(t('download.message.downloadComplete', { filename: data.filename }));
     } else {
-      const existingItem = downloadList.value.find((item) => item.filename === data.filename);
+      const existingItem = downloadList.value.find(item => item.filename === data.filename);
       if (existingItem) {
         Object.assign(existingItem, {
           status: 'error',
@@ -456,12 +513,10 @@ onMounted(() => {
           progress: 0
         });
         setTimeout(() => {
-          downloadList.value = downloadList.value.filter((item) => item.filename !== data.filename);
+          downloadList.value = downloadList.value.filter(item => item.filename !== data.filename);
         }, 3000);
       }
-      message.error(
+      message.error(t('download.message.downloadFailed', { filename: data.filename, error: data.error }));
-        t('download.message.downloadFailed', { filename: data.filename, error: data.error })
-      );
     }
   });
 
@@ -523,9 +578,18 @@ const handleDrawerClose = () => {
   @apply flex-1 overflow-hidden pb-40;
 }
 
+.downloaded-header {
+  @apply flex items-center justify-between p-4 bg-light-100 dark:bg-dark-200 sticky top-0 z-10;
+  @apply border-b border-gray-100 dark:border-gray-800;
+
+  .header-title {
+    @apply text-sm font-medium text-gray-600 dark:text-gray-400;
+  }
+}
+
 .download-items,
 .downloaded-items {
-  @apply space-y-3;
+  @apply space-y-3 p-4;
 }
 
 .total-progress {

src/renderer/components/common/SongItem.vue

@@ -293,14 +293,17 @@ const downloadMusic = async () => {
     // 构建文件名
     const artistNames = (props.item.ar || props.item.song?.artists)?.map((a) => a.name).join(',');
     const filename = `${props.item.name} - ${artistNames}`;
+    console.log('props.item', props.item);
 
+    const songData = cloneDeep(props.item);
+    songData.ar = songData.ar || songData.song?.artists;
     // 发送下载请求
     window.electron.ipcRenderer.send('download-music', {
       url: data.url,
       type: data.type,
       filename,
       songInfo: {
-        ...cloneDeep(props.item),
+        ...songData,
         downloadTime: Date.now()
       }
     });

src/renderer/components/home/RecommendAlbum.vue

@@ -26,7 +26,7 @@
       v-model:show="showMusic"
       :name="albumName"
       :song-list="songList"
-      :cover="false"
+      :cover="true"
       :loading="loadingList"
       :list-info="albumInfo"
     />
@@ -62,17 +62,19 @@ const handleClick = async (item: any) => {
   loadingList.value = true;
   showMusic.value = true;
   const res = await getAlbum(item.id);
-  songList.value = res.data.songs.map((song: any) => {
+  const { songs, album } = res.data;
-    song.al.picUrl = song.al.picUrl || item.picUrl;
+  songList.value = songs.map((song: any) => {
+    song.al.picUrl = song.al.picUrl || album.picUrl;
+    song.picUrl = song.al.picUrl || album.picUrl || song.picUrl;
     return song;
   });
   albumInfo.value = {
-    ...res.data.album,
+    ...album,
     creator: {
-      avatarUrl: res.data.album.artist.img1v1Url,
+      avatarUrl: album.artist.img1v1Url,
-      nickname: `${res.data.album.artist.name} - ${res.data.album.company}`
+      nickname: `${album.artist.name} - ${album.company}`
     },
-    description: res.data.album.description
+    description: album.description
   };
   loadingList.value = false;
 };

src/renderer/components/home/TopBanner.vue

@@ -61,19 +61,27 @@
               >
                 <div class="user-play-item-img">
                   <img :src="getImgUrl(item.coverImgUrl, '200y200')" alt="" />
-                  <div class="user-play-item-overlay">
-                    <div class="user-play-item-play-btn">
-                      <i class="iconfont icon-playfill text-3xl text-white"></i>
-                    </div>
-                  </div>
                   <div class="user-play-item-title">
                     <div class="user-play-item-title-name">{{ item.name }}</div>
+
+                    <div class="user-play-item-list">
+                      <div
+                        v-for="song in item.tracks"
+                        :key="song.id"
+                        class="user-play-item-list-name"
+                      >
+                        {{ song.name }}
+                      </div>
+                    </div>
                   </div>
                   <div class="user-play-item-count">
                     <div class="user-play-item-count-tag">
                       {{ t('common.songCount', { count: item.trackCount }) }}
                     </div>
                   </div>
+                  <div class="user-play-item-direct-play" @click.stop="handlePlayPlaylist(item.id)">
+                    <i class="iconfont icon-playfill text-xl text-white"></i>
+                  </div>
                 </div>
               </div>
             </div>
@@ -92,7 +100,7 @@
             @click="handleArtistClick(item.id)"
           >
             <div
-              :style="setBackgroundImg(getImgUrl(item.picUrl, '500y500'))"
+              :style="setBackgroundImg(getImgUrl(item.picUrl || item.avatar || item.cover, '500y500'))"
               class="recommend-singer-item-bg"
             ></div>
             <div class="recommend-singer-item-count p-2 text-base text-gray-200 z-10">
@@ -142,14 +150,16 @@ import { useI18n } from 'vue-i18n';
 
 import { getDayRecommend, getHotSinger } from '@/api/home';
 import { getListDetail } from '@/api/list';
+import { getMusicDetail } from '@/api/music';
 import { getUserPlaylist } from '@/api/user';
 import MusicList from '@/components/MusicList.vue';
 import { useArtist } from '@/hooks/useArtist';
-import { useUserStore } from '@/store';
+import { usePlayerStore, useUserStore } from '@/store';
 import { IDayRecommend } from '@/type/day_recommend';
 import { Playlist } from '@/type/list';
 import type { IListDetail } from '@/type/listDetail';
-import type { IHotSinger } from '@/type/singer';
+import { SongResult } from '@/type/music';
+import type { Artist, IHotSinger } from '@/type/singer';
 import {
   getImgUrl,
   isMobile,
@@ -157,8 +167,10 @@ import {
   setAnimationDelay,
   setBackgroundImg
 } from '@/utils';
+import { getArtistDetail } from '@/api/artist';
 
 const userStore = useUserStore();
+const playerStore = usePlayerStore();
 
 const { t } = useI18n();
 
@@ -235,11 +247,27 @@ const getCarouselItemStyleForPlaylist = (playlistCount: number) => {
 };
 
 onMounted(async () => {
-  await loadData();
+  loadNonUserData();
 });
 
-const loadData = async () => {
+const JayChouId = 6452;
+const loadArtistData = async () => {
   try {
+    const { data: artistData }: { data: { data: { artist: Artist } } } = await getArtistDetail(JayChouId);
+    console.log('artistData', artistData);
+    if (hotSingerData.value) {
+      // 将周杰伦数据放在第一位
+      hotSingerData.value.artists = [artistData.data.artist, ...hotSingerData.value.artists];
+    }
+  } catch (error) {
+    console.error('获取周杰伦数据失败:', error);
+  }
+}
+
+// 加载不需要登录的数据
+const loadNonUserData = async () => {
+  try {
+
         // 获取每日推荐
         try {
       const {
@@ -247,9 +275,21 @@ const loadData = async () => {
       } = await getDayRecommend();
       dayRecommendData.value = dayRecommend as unknown as IDayRecommend;
     } catch (error) {
-      console.error('error', error);
+      console.error('获取每日推荐失败:', error);
     }
+    // 获取热门歌手
+    const { data: singerData } = await getHotSinger({ offset: 0, limit: 5 });
+    hotSingerData.value = singerData;
 
+    await loadArtistData();
+  } catch (error) {
+    console.error('加载热门歌手数据失败:', error);
+  }
+};
+
+// 加载需要登录的数据
+const loadUserData = async () => {
+  try {
     if (userStore.user) {
       const { data: playlistData } = await getUserPlaylist(userStore.user?.userId);
       // 确保最多只显示4个歌单，并按播放次数排序
@@ -257,12 +297,8 @@ const loadData = async () => {
         .sort((a, b) => b.playCount - a.playCount)
         .slice(0, 4);
     }
-
-    // 获取热门歌手
-    const { data: singerData } = await getHotSinger({ offset: 0, limit: 5 });
-    hotSingerData.value = singerData;
   } catch (error) {
-    console.error('error', error);
+    console.error('加载用户数据失败:', error);
   }
 };
 
@@ -293,10 +329,97 @@ const toPlaylist = async (id: number) => {
   }
 };
 
+// 添加直接播放歌单的方法
+const handlePlayPlaylist = async (id: number) => {
+  try {
+    // 先显示加载状态
+    playlistLoading.value = true;
+
+    // 获取歌单详情
+    const { data } = await getListDetail(id);
+
+    if (data?.playlist) {
+      // 先使用已有的tracks开始播放（这些是已经在歌单详情中返回的前几首歌曲）
+      if (data.playlist.tracks?.length > 0) {
+        // 格式化歌曲列表
+        const initialSongs = data.playlist.tracks.map((track) => ({
+          ...track,
+          source: 'netease',
+          picUrl: track.al.picUrl
+        })) as unknown as SongResult[];
+
+        // 设置播放列表
+        playerStore.setPlayList(initialSongs);
+
+        // 开始播放第一首
+        await playerStore.setPlay(initialSongs[0]);
+
+        // 如果有trackIds，异步加载完整歌单
+        if (data.playlist.trackIds?.length > initialSongs.length) {
+          loadFullPlaylist(data.playlist.trackIds, initialSongs);
+        }
+      }
+    }
+
+    // 关闭加载状态
+    playlistLoading.value = false;
+  } catch (error) {
+    console.error('播放歌单失败:', error);
+    playlistLoading.value = false;
+  }
+};
+
+// 异步加载完整歌单
+const loadFullPlaylist = async (trackIds: { id: number }[], initialSongs: SongResult[]) => {
+  try {
+    // 获取已加载歌曲的ID集合，避免重复加载
+    const loadedIds = new Set(initialSongs.map((song) => song.id));
+
+    // 筛选出未加载的ID
+    const unloadedTrackIds = trackIds
+      .filter((item) => !loadedIds.has(item.id as number))
+      .map((item) => item.id);
+
+    if (unloadedTrackIds.length === 0) return;
+
+    // 分批获取歌曲详情，每批最多获取500首
+    const batchSize = 500;
+    const allSongs = [...initialSongs];
+
+    for (let i = 0; i < unloadedTrackIds.length; i += batchSize) {
+      const batchIds = unloadedTrackIds.slice(i, i + batchSize);
+      if (batchIds.length > 0) {
+        try {
+          const { data: songsData } = await getMusicDetail(batchIds);
+          if (songsData?.songs?.length) {
+            const formattedSongs = songsData.songs.map((item) => ({
+              ...item,
+              source: 'netease',
+              picUrl: item.al.picUrl
+            })) as unknown as SongResult[];
+
+            allSongs.push(...formattedSongs);
+          }
+        } catch (error) {
+          console.error('获取批次歌曲详情失败:', error);
+        }
+      }
+    }
+
+    // 更新完整的播放列表但保持当前播放的歌曲不变
+    if (allSongs.length > initialSongs.length) {
+      console.log('更新播放列表，总歌曲数:', allSongs.length);
+      playerStore.setPlayList(allSongs);
+    }
+  } catch (error) {
+    console.error('加载完整歌单失败:', error);
+  }
+};
+
 // 监听登录状态
 watchEffect(() => {
   if (userStore.user) {
-    loadData();
+    loadUserData();
   }
 });
 
@@ -416,18 +539,12 @@ const getPlaylistGridClass = (length: number) => {
       &:hover {
         transform: translateY(-5px);
         box-shadow: 0 10px 30px rgba(0, 0, 0, 0.15);
-        .user-play-item-overlay {
-          opacity: 1;
-        }
       }
 
       img {
         @apply absolute inset-0 w-full h-full object-cover;
       }
     }
-    &-overlay {
-      @apply absolute inset-0 bg-black bg-opacity-30 flex items-center justify-center opacity-0 transition-opacity duration-300;
-    }
     &-title {
       @apply absolute top-0 left-0 right-0 p-2 bg-gradient-to-b from-black/70 to-transparent z-10;
       &-name {
@@ -435,11 +552,17 @@ const getPlaylistGridClass = (length: number) => {
       }
     }
     &-count {
-      @apply absolute bottom-2 right-2 z-10;
+      @apply absolute bottom-2 left-2 z-10;
       &-tag {
         @apply px-2 py-0.5 text-xs text-white bg-black/50 backdrop-blur-sm rounded-full;
       }
     }
+    &-direct-play {
+      @apply absolute bottom-2 right-2 z-20 w-10 h-10 rounded-full bg-green-600 hover:bg-green-700 flex items-center justify-center cursor-pointer transform scale-90 hover:scale-100 transition-all;
+      &:hover {
+        @apply shadow-lg;
+      }
+    }
     &-play-btn {
       @apply flex items-center justify-center;
       transform: scale(0.8);

src/renderer/components/lyric/LyricSettings.vue

@@ -2,42 +2,72 @@
   <div class="settings-panel transparent-popover">
     <div class="settings-title">{{ t('settings.lyricSettings.title') }}</div>
     <div class="settings-content">
+      <n-tabs type="line" animated size="small">
+        <!-- 显示设置 -->
+        <n-tab-pane :name="'display'" :tab="t('settings.lyricSettings.tabs.display')">
+          <div class="tab-content">
+            <div class="settings-grid">
               <div class="settings-item">
                 <span>{{ t('settings.lyricSettings.pureMode') }}</span>
                 <n-switch v-model:value="config.pureModeEnabled" />
               </div>
-
               <div class="settings-item">
                 <span>{{ t('settings.lyricSettings.hideCover') }}</span>
                 <n-switch v-model:value="config.hideCover" />
               </div>
-
               <div class="settings-item">
                 <span>{{ t('settings.lyricSettings.centerDisplay') }}</span>
                 <n-switch v-model:value="config.centerLyrics" />
               </div>
-
               <div class="settings-item">
                 <span>{{ t('settings.lyricSettings.showTranslation') }}</span>
                 <n-switch v-model:value="config.showTranslation" />
               </div>
-
-      <div class="settings-item">
-        <span>{{ t('settings.lyricSettings.hidePlayBar') }}</span>
-        <n-switch v-model:value="config.hidePlayBar" />
-      </div>
-
-      <div class="settings-item">
-        <span>{{ t('settings.lyricSettings.hideMiniPlayBar') }}</span>
-        <n-switch v-model:value="config.hideMiniPlayBar" />
-      </div>
-
               <div class="settings-item">
                 <span>{{ t('settings.lyricSettings.hideLyrics') }}</span>
                 <n-switch v-model:value="config.hideLyrics" />
               </div>
+            </div>
+          </div>
+        </n-tab-pane>
 
-      <div class="settings-slider">
+        <!-- 界面设置 -->
+        <n-tab-pane :name="'interface'" :tab="t('settings.lyricSettings.tabs.interface')">
+          <div class="tab-content">
+            <div class="settings-grid">
+              <div class="settings-item">
+                <span>{{ t('settings.lyricSettings.hidePlayBar') }}</span>
+                <n-switch v-model:value="config.hidePlayBar" />
+              </div>
+              <div class="settings-item">
+                <span>{{ t('settings.lyricSettings.hideMiniPlayBar') }}</span>
+                <n-switch v-model:value="config.hideMiniPlayBar" />
+              </div>
+            </div>
+            <div class="theme-section">
+              <div class="section-title">{{ t('settings.lyricSettings.backgroundTheme') }}</div>
+              <n-radio-group v-model:value="config.theme" name="theme" class="theme-radio-group">
+                <n-space>
+                  <n-radio value="default">{{
+                    t('settings.lyricSettings.themeOptions.default')
+                  }}</n-radio>
+                  <n-radio value="light">{{
+                    t('settings.lyricSettings.themeOptions.light')
+                  }}</n-radio>
+                  <n-radio value="dark">{{
+                    t('settings.lyricSettings.themeOptions.dark')
+                  }}</n-radio>
+                </n-space>
+              </n-radio-group>
+            </div>
+          </div>
+        </n-tab-pane>
+
+        <!-- 文字设置 -->
+        <n-tab-pane :name="'typography'" :tab="t('settings.lyricSettings.tabs.typography')">
+          <div class="tab-content">
+            <div class="slider-section">
+              <div class="slider-item">
                 <span>{{ t('settings.lyricSettings.fontSize') }}</span>
                 <n-slider
                   v-model:value="config.fontSize"
@@ -52,7 +82,7 @@
                 />
               </div>
 
-      <div class="settings-slider">
+              <div class="slider-item">
                 <span>{{ t('settings.lyricSettings.letterSpacing') }}</span>
                 <n-slider
                   v-model:value="config.letterSpacing"
@@ -67,7 +97,7 @@
                 />
               </div>
 
-      <div class="settings-slider">
+              <div class="slider-item">
                 <span>{{ t('settings.lyricSettings.lineHeight') }}</span>
                 <n-slider
                   v-model:value="config.lineHeight"
@@ -81,16 +111,11 @@
                   }"
                 />
               </div>
-
-      <div class="settings-item">
-        <span>{{ t('settings.lyricSettings.backgroundTheme') }}</span>
-        <n-radio-group v-model:value="config.theme" name="theme">
-          <n-radio value="default">{{ t('settings.lyricSettings.themeOptions.default') }}</n-radio>
-          <n-radio value="light">{{ t('settings.lyricSettings.themeOptions.light') }}</n-radio>
-          <n-radio value="dark">{{ t('settings.lyricSettings.themeOptions.dark') }}</n-radio>
-        </n-radio-group>
             </div>
           </div>
+        </n-tab-pane>
+      </n-tabs>
+    </div>
   </div>
 </template>
 
@@ -98,39 +123,12 @@
 import { onMounted, ref, watch } from 'vue';
 import { useI18n } from 'vue-i18n';
 
+import { DEFAULT_LYRIC_CONFIG, LyricConfig } from '@/types/lyric';
+
 const { t } = useI18n();
-
+const config = ref<LyricConfig>({ ...DEFAULT_LYRIC_CONFIG });
-interface LyricConfig {
-  hideCover: boolean;
-  centerLyrics: boolean;
-  fontSize: number;
-  letterSpacing: number;
-  lineHeight: number;
-  showTranslation: boolean;
-  theme: 'default' | 'light' | 'dark';
-  hidePlayBar: boolean;
-  hideMiniPlayBar: boolean;
-  pureModeEnabled: boolean;
-  hideLyrics: boolean;
-}
-
-const config = ref<LyricConfig>({
-  hideCover: false,
-  centerLyrics: false,
-  fontSize: 22,
-  letterSpacing: 0,
-  lineHeight: 2,
-  showTranslation: true,
-  theme: 'default',
-  hidePlayBar: false,
-  hideMiniPlayBar: false,
-  pureModeEnabled: false,
-  hideLyrics: false
-});
-
 const emit = defineEmits(['themeChange']);
 
-// 监听配置变化并保存到本地存储
 watch(
   () => config.value,
   (newConfig) => {
@@ -139,7 +137,6 @@ watch(
   { deep: true }
 );
 
-// 监听主题变化
 watch(
   () => config.value.theme,
   (newTheme) => {
@@ -147,14 +144,12 @@ watch(
   }
 );
 
-// 更新 CSS 变量
 const updateCSSVariables = (config: LyricConfig) => {
   document.documentElement.style.setProperty('--lyric-font-size', `${config.fontSize}px`);
   document.documentElement.style.setProperty('--lyric-letter-spacing', `${config.letterSpacing}px`);
   document.documentElement.style.setProperty('--lyric-line-height', config.lineHeight.toString());
 };
 
-// 加载保存的配置
 onMounted(() => {
   const savedConfig = localStorage.getItem('music-full-config');
   if (savedConfig) {
@@ -170,14 +165,50 @@ defineExpose({
 
 <style scoped lang="scss">
 .settings-panel {
-  @apply p-4 w-72 rounded-lg relative overflow-hidden backdrop-blur-lg bg-black/10;
+  @apply p-4 w-80 rounded-lg relative overflow-hidden backdrop-blur-lg bg-black/10;
+
   .settings-title {
     @apply text-base font-bold mb-4;
     color: var(--text-color-active);
   }
 
   .settings-content {
-    @apply space-y-4;
+    :deep(.n-tabs-nav) {
+      @apply mb-3;
+    }
+
+    :deep(.n-tab-pane) {
+      @apply p-0;
+    }
+
+    :deep(.n-tabs-tab) {
+      @apply text-xs;
+      color: var(--text-color-primary);
+
+      &.n-tabs-tab--active {
+        color: var(--text-color-active);
+      }
+    }
+
+    :deep(.n-tabs-tab-wrapper) {
+      @apply pb-0;
+    }
+
+    :deep(.n-tabs-pane-wrapper) {
+      @apply px-2;
+    }
+
+    :deep(.n-tabs-bar) {
+      background-color: var(--text-color-active);
+    }
+  }
+
+  .tab-content {
+    @apply py-2;
+  }
+
+  .settings-grid {
+    @apply grid grid-cols-1 gap-3;
   }
 
   .settings-item {
@@ -188,22 +219,38 @@ defineExpose({
     }
   }
 
-  .settings-slider {
+  .section-title {
-    @apply space-y-2;
+    @apply text-sm font-medium mb-2;
-    @apply mb-10 !important;
+    color: var(--text-color-primary);
+  }
+
+  .theme-section {
+    @apply mt-4;
+  }
+
+  .slider-section {
+    @apply space-y-6;
+  }
+
+  .slider-item {
+    @apply space-y-2 mb-10 !important;
     span {
       @apply text-sm;
       color: var(--text-color-primary);
     }
   }
+
+  .theme-radio-group {
+    @apply flex;
+  }
 }
 
-// 修改 slider 字体颜色
 :deep(.n-slider-mark) {
   color: var(--text-color-primary) !important;
 }
-// 修改 radio 字体颜色
+
 :deep(.n-radio__label) {
   color: var(--text-color-active) !important;
+  @apply text-xs;
 }
 </style>

src/renderer/components/player/MiniPlayBar.vue

@@ -123,7 +123,7 @@ import SongItem from '@/components/common/SongItem.vue';
 import { allTime, artistList, nowTime, playMusic } from '@/hooks/MusicHook';
 import { useArtist } from '@/hooks/useArtist';
 import { audioService } from '@/services/audioService';
-import { usePlayerStore, useSettingsStore } from '@/store';
+import { isBilibiliIdMatch, usePlayerStore, useSettingsStore } from '@/store';
 import type { SongResult } from '@/type/music';
 import { getImgUrl } from '@/utils';
 
@@ -185,20 +185,31 @@ const mute = () => {
 
 // 收藏相关
 const isFavorite = computed(() => {
-  const numericId =
+  // 对于B站视频，使用ID匹配函数
-    typeof playMusic.value.id === 'string' ? parseInt(playMusic.value.id, 10) : playMusic.value.id;
+  if (playMusic.value.source === 'bilibili' && playMusic.value.bilibiliData?.bvid) {
-  return playerStore.favoriteList.includes(numericId);
+    return playerStore.favoriteList.some(id => isBilibiliIdMatch(id, playMusic.value.id));
+  }
+  
+  // 非B站视频直接比较ID
+  return playerStore.favoriteList.includes(playMusic.value.id);
 });
 
 const toggleFavorite = async (e: Event) => {
   e.stopPropagation();
-  const numericId =
+  
-    typeof playMusic.value.id === 'string' ? parseInt(playMusic.value.id, 10) : playMusic.value.id;
+  // 处理B站视频的收藏ID
+  let favoriteId = playMusic.value.id;
+  if (playMusic.value.source === 'bilibili' && playMusic.value.bilibiliData?.bvid) {
+    // 如果当前播放的是B站视频，且已有ID不包含--格式，则需要构造完整ID
+    if (!String(favoriteId).includes('--')) {
+      favoriteId = `${playMusic.value.bilibiliData.bvid}--${playMusic.value.song?.ar?.[0]?.id || 0}--${playMusic.value.bilibiliData.cid}`;
+    }
+  }
 
   if (isFavorite.value) {
-    playerStore.removeFromFavorite(numericId);
+    playerStore.removeFromFavorite(favoriteId);
   } else {
-    playerStore.addToFavorite(numericId);
+    playerStore.addToFavorite(favoriteId);
   }
 };
 
@@ -253,7 +264,7 @@ const togglePlaylist = () => {
 const scrollToPlayList = () => {
   setTimeout(() => {
     const currentIndex = playerStore.playListIndex;
-    const itemHeight = 52; // 每个列表项的高度
+    const itemHeight = 69; // 每个列表项的高度
     palyListRef.value?.scrollTo({
       top: currentIndex * itemHeight,
       behavior: 'smooth'
@@ -585,4 +596,16 @@ const setMusicFull = () => {
 .playlist-items {
   padding: 4px 0;
 }
+
+.dark {
+  .song-info {
+    .song-title {
+      color: var(--text-color-1, #fff);
+    }
+
+    .song-artist {
+      color: var(--text-color-2, #fff);
+    }
+  }
+}
 </style>

src/renderer/components/player/MobilePlayBar.vue

@@ -87,6 +87,9 @@
           </div>
         </n-popover>
       </div>
+
+      <!-- 定时关闭按钮 -->
+      <SleepTimerPopover mode="mobile" />
     </template>
 
     <!-- Mini模式 - 在musicFullVisible为false时显示 -->
@@ -152,6 +155,7 @@ import { useThrottleFn } from '@vueuse/core';
 import { computed, ref, watch } from 'vue';
 
 import SongItem from '@/components/common/SongItem.vue';
+import SleepTimerPopover from '@/components/player/SleepTimerPopover.vue';
 import { allTime, artistList, nowTime, playMusic, sound, textColors } from '@/hooks/MusicHook';
 import MusicFull from '@/layout/components/MusicFull.vue';
 import { audioService } from '@/services/audioService';

src/renderer/components/player/PlayBar.vue

@@ -144,6 +144,8 @@
         </template>
         <eq-control />
       </n-popover>
+      <!-- 定时关闭功能 -->
+      <sleep-timer-popover mode="desktop" />
       <n-popover
         trigger="click"
         :z-index="99999999"
@@ -194,6 +196,7 @@ import { useI18n } from 'vue-i18n';
 
 import SongItem from '@/components/common/SongItem.vue';
 import EqControl from '@/components/EQControl.vue';
+import SleepTimerPopover from '@/components/player/SleepTimerPopover.vue';
 import {
   allTime,
   artistList,
@@ -206,7 +209,10 @@ import {
 import { useArtist } from '@/hooks/useArtist';
 import MusicFull from '@/layout/components/MusicFull.vue';
 import { audioService } from '@/services/audioService';
-import { usePlayerStore } from '@/store/modules/player';
+import { 
+  isBilibiliIdMatch, 
+  usePlayerStore 
+} from '@/store/modules/player';
 import { useSettingsStore } from '@/store/modules/settings';
 import type { SongResult } from '@/type/music';
 import { getImgUrl, isElectron, isMobile, secondToMinute, setAnimationClass } from '@/utils';
@@ -417,22 +423,32 @@ const scrollToPlayList = (val: boolean) => {
 };
 
 const isFavorite = computed(() => {
-  // 将id转换为number，兼容B站视频ID
+  // 对于B站视频，使用ID匹配函数
-  const numericId =
+  if (playMusic.value.source === 'bilibili' && playMusic.value.bilibiliData?.bvid) {
-    typeof playMusic.value.id === 'string' ? parseInt(playMusic.value.id, 10) : playMusic.value.id;
+    return playerStore.favoriteList.some(id => isBilibiliIdMatch(id, playMusic.value.id));
-  return playerStore.favoriteList.includes(numericId);
+  }
+  
+  // 非B站视频直接比较ID
+  return playerStore.favoriteList.includes(playMusic.value.id);
 });
 
 const toggleFavorite = async (e: Event) => {
+  console.log('playMusic.value', playMusic.value);
   e.stopPropagation();
-  // 将id转换为number，兼容B站视频ID
+  
-  const numericId =
+  // 处理B站视频的收藏ID
-    typeof playMusic.value.id === 'string' ? parseInt(playMusic.value.id, 10) : playMusic.value.id;
+  let favoriteId = playMusic.value.id;
+  if (playMusic.value.source === 'bilibili' && playMusic.value.bilibiliData?.bvid) {
+    // 如果当前播放的是B站视频，且已有ID不包含--格式，则需要构造完整ID
+    if (!String(favoriteId).includes('--')) {
+      favoriteId = `${playMusic.value.bilibiliData.bvid}--${playMusic.value.song?.ar?.[0]?.id || 0}--${playMusic.value.bilibiliData.cid}`;
+    }
+  }
   
   if (isFavorite.value) {
-    playerStore.removeFromFavorite(numericId);
+    playerStore.removeFromFavorite(favoriteId);
   } else {
-    playerStore.addToFavorite(numericId);
+    playerStore.addToFavorite(favoriteId);
   }
 };
 

src/renderer/components/player/SleepTimerPopover.vue

@@ -0,0 +1,478 @@
+<template>
+  <n-popover
+    trigger="click"
+    :z-index="99999999"
+    content-class="sleep-timer"
+    raw
+    :show-arrow="false"
+    placement="top"
+    display-directive="show"
+  >
+    <template #trigger>
+      <n-tooltip trigger="hover" :z-index="9999999">
+        <template #trigger>
+          <div class="control-btn timer" :class="{ 'mobile-timer': mode === 'mobile' }">
+          <i 
+            class="iconfont ri-time-line"
+            :class="{ 'text-green-500': hasTimerActive }"
+          ></i>
+        </div>
+        </template>
+        {{ t('player.sleepTimer.title') }}
+      </n-tooltip>
+    </template>
+    <div class="sleep-timer-container" :class="{ 'mobile-sleep-timer-container': mode === 'mobile' }">
+      <div class="sleep-timer-back"></div>
+      
+      <div class="sleep-timer-content">
+        <div class="sleep-timer-title">{{ t('player.sleepTimer.title') }}</div>
+        
+        <div v-if="hasTimerActive" class="sleep-timer-active">
+          <div class="timer-status">
+            <template v-if="timerType === 'time'">
+              <div class="timer-value countdown-timer">{{ formattedRemainingTime }}</div>
+              <div class="timer-label">{{ t('player.sleepTimer.minutesRemaining', { minutes: Math.ceil(remainingMinutes/60) }) }}</div>
+            </template>
+            <template v-else-if="timerType === 'songs'">
+              <div class="timer-value">{{ remainingSongs }}</div>
+              <div class="timer-label">{{ t('player.sleepTimer.songsRemaining', { count: remainingSongs }) }}</div>
+            </template>
+            <template v-else-if="timerType === 'end'">
+              <div class="timer-value">{{ t('player.sleepTimer.activeUntilEnd') }}</div>
+              <div class="timer-label">{{ t('player.sleepTimer.afterPlaylist') }}</div>
+            </template>
+          </div>
+          
+          <n-button type="error" class="cancel-timer-btn" @click="handleCancelTimer" round>
+            {{ t('player.sleepTimer.cancel') }}
+          </n-button>
+        </div>
+        
+        <div v-else class="sleep-timer-options">
+          <!-- 按时间定时 -->
+          <div class="option-section">
+            <h4 class="option-title">{{ t('player.sleepTimer.timeMode') }}</h4>
+            <div class="time-options">
+              <n-button
+                v-for="minutes in [15, 30, 60, 90]"
+                :key="minutes"
+                size="small"
+                class="time-option-btn"
+                @click="handleSetTimeTimer(minutes)"
+                round
+              >
+                {{ minutes }}{{ t('player.sleepTimer.minutes') }}
+              </n-button>
+              <div class="custom-time">
+                <n-input-number
+                  v-model:value="customMinutes"
+                  :min="1"
+                  :max="300"
+                  size="small"
+                  class="custom-time-input"
+                  round
+                />
+                <n-button
+                  size="small"
+                  type="primary"
+                  class="custom-time-btn"
+                  :disabled="!customMinutes"
+                  @click="handleSetTimeTimer(customMinutes)"
+                  round
+                >
+                  {{ t('player.sleepTimer.set') }}
+                </n-button>
+              </div>
+            </div>
+          </div>
+          
+          <!-- 按歌曲数定时 -->
+          <div class="option-section">
+            <h4 class="option-title">{{ t('player.sleepTimer.songsMode') }}</h4>
+            <div class="songs-options">
+              <n-button
+                v-for="songs in [1, 3, 5, 10]"
+                :key="songs"
+                size="small"
+                class="songs-option-btn"
+                @click="handleSetSongsTimer(songs)"
+                round
+              >
+                {{ songs }}{{ t('player.sleepTimer.songs') }}
+              </n-button>
+              <div class="custom-songs">
+                <n-input-number
+                  v-model:value="customSongs"
+                  :min="1"
+                  :max="50"
+                  size="small"
+                  class="custom-songs-input"
+                  round
+                />
+                <n-button
+                  size="small"
+                  type="primary"
+                  class="custom-songs-btn"
+                  :disabled="!customSongs"
+                  @click="handleSetSongsTimer(customSongs)"
+                  round
+                >
+                  {{ t('player.sleepTimer.set') }}
+                </n-button>
+              </div>
+            </div>
+          </div>
+          
+          <!-- 播放完列表后关闭 -->
+          <div class="option-section playlist-end-section">
+            <n-button block class="playlist-end-btn" @click="handleSetPlaylistEndTimer" round>
+              {{ t('player.sleepTimer.playlistEnd') }}
+            </n-button>
+          </div>
+        </div>
+      </div>
+    </div>
+  </n-popover>
+</template>
+
+<script lang="ts" setup>
+import { computed, ref, onMounted, onUnmounted, watch } from 'vue';
+import { useI18n } from 'vue-i18n';
+import { storeToRefs } from 'pinia';
+
+import { usePlayerStore } from '@/store/modules/player';
+
+// 组件接收一个mode参数，用于标识是移动端还是桌面端
+defineProps({
+  mode: {
+    type: String,
+    default: 'desktop' // 'desktop' 或 'mobile'
+  }
+});
+
+const { t } = useI18n();
+const playerStore = usePlayerStore();
+
+// 从store获取所有相关状态
+const { sleepTimer} = storeToRefs(playerStore);
+
+// 本地状态，用于UI展示
+const customMinutes = ref(30);
+const customSongs = ref(5);
+// 添加一个刷新触发变量，用于强制更新倒计时
+const refreshTrigger = ref(0);
+
+// 计算属性，判断定时器状态
+const hasTimerActive = computed(() => {
+  return playerStore.hasSleepTimerActive;
+});
+
+const timerType = computed(() => {
+  return sleepTimer.value.type;
+});
+
+// 剩余时间（分钟）
+const remainingMinutes = computed(() => {
+  return playerStore.sleepTimerRemainingTime;
+});
+
+// 剩余歌曲数
+const remainingSongs = computed(() => {
+  return playerStore.sleepTimerRemainingSongs;
+});
+
+// 处理设置时间定时器
+function handleSetTimeTimer(minutes: number) {
+  playerStore.setSleepTimerByTime(minutes);
+}
+
+// 处理设置歌曲数定时器
+function handleSetSongsTimer(songs: number) {
+  playerStore.setSleepTimerBySongs(songs);
+}
+
+// 处理设置播放列表结束定时器
+function handleSetPlaylistEndTimer() {
+  playerStore.setSleepTimerAtPlaylistEnd();
+}
+
+// 处理取消定时器
+function handleCancelTimer() {
+  playerStore.clearSleepTimer();
+}
+
+// 格式化剩余时间为 HH:MM:SS
+const formattedRemainingTime = computed(() => {
+  // 依赖刷新触发器强制更新
+  void refreshTrigger.value;
+  
+  if (timerType.value !== 'time' || !sleepTimer.value.endTime) {
+    return '00:00:00';
+  }
+  
+  const remaining = Math.max(0, sleepTimer.value.endTime - Date.now());
+  const totalSeconds = Math.floor(remaining / 1000);
+  
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor((totalSeconds % 3600) / 60);
+  const seconds = Math.floor(totalSeconds % 60);
+  
+  const formattedHours = hours.toString().padStart(2, '0');
+  const formattedMinutes = minutes.toString().padStart(2, '0');
+  const formattedSeconds = seconds.toString().padStart(2, '0');
+  
+  return `${formattedHours}:${formattedMinutes}:${formattedSeconds}`;
+});
+
+// 监听剩余时间变化
+let timerInterval: number | null = null;
+
+onMounted(() => {
+  // 如果当前有定时器，开始更新UI
+  if (hasTimerActive.value && timerType.value === 'time') {
+    startTimerUpdate();
+  }
+  
+  // 监听定时器状态变化
+  watch(
+    () => [hasTimerActive.value, timerType.value], 
+    ([newHasTimer, newType]) => {
+      if (newHasTimer && newType === 'time') {
+        startTimerUpdate();
+      } else {
+        stopTimerUpdate();
+      }
+    }
+  );
+});
+
+// 启动定时器更新UI
+function startTimerUpdate() {
+  stopTimerUpdate(); // 先停止之前的计时器
+  
+  // 每秒更新UI
+  timerInterval = window.setInterval(() => {
+    // 更新刷新触发器，强制重新计算
+    refreshTrigger.value = Date.now();
+  }, 500) as unknown as number;
+}
+
+// 停止定时器更新UI
+function stopTimerUpdate() {
+  if (timerInterval) {
+    clearInterval(timerInterval);
+    timerInterval = null;
+  }
+}
+
+onUnmounted(() => {
+  stopTimerUpdate();
+});
+</script>
+
+<style lang="scss" scoped>
+.control-btn.timer {
+  @apply cursor-pointer;
+  
+  .iconfont {
+    @apply text-2xl m-4 transition-all duration-300 ease-in-out;
+    
+    &:hover {
+      @apply text-green-500 transform scale-110;
+    }
+  }
+
+  &.mobile-timer {
+    @apply flex items-center justify-center;
+    height: 56px;
+    width: 56px;
+  }
+}
+
+// 主容器样式
+.sleep-timer-container {
+  width: 380px;
+  height: auto;
+  @apply relative overflow-hidden;
+  border-radius: 16px;
+  box-shadow: 0 10px 25px rgba(0, 0, 0, 0.15), 0 0 1px rgba(0, 0, 0, 0.1);
+  transform-origin: top center;
+  animation: popoverEnter 0.2s cubic-bezier(0.3, 0, 0.2, 1);
+  
+  // 入场动画
+  @keyframes popoverEnter {
+    from {
+      opacity: 0;
+      transform: translateY(-10px) scale(0.98);
+    }
+    to {
+      opacity: 1;
+      transform: translateY(0) scale(1);
+    }
+  }
+  
+  // 移动端样式
+  &.mobile-sleep-timer-container {
+    width: 92vw;
+    max-width: 400px;
+    @apply rounded-t-2xl;
+    max-height: 500px;
+  }
+
+  // 背景毛玻璃效果
+  .sleep-timer-back {
+    @apply absolute top-0 left-0 w-full h-full dark:bg-gray-900 dark:bg-opacity-75 dark:border-gray-700;
+    backdrop-filter: blur(25px);
+    -webkit-backdrop-filter: blur(25px);
+    background-color: rgba(255, 255, 255, 0.75);
+    border: 1px solid rgba(255, 255, 255, 0.2);
+  }
+
+  // 内容区域
+  .sleep-timer-content {
+    @apply p-6 relative z-10;
+
+    // 标题
+    .sleep-timer-title {
+      @apply text-xl font-bold text-center mb-6 text-gray-800 dark:text-gray-100;
+      letter-spacing: 0.5px;
+    }
+
+    // 激活状态显示
+    .sleep-timer-active {
+      @apply flex flex-col items-center;
+
+      // 定时状态卡片
+      .timer-status {
+        @apply flex flex-col items-center justify-center p-8 mb-5 w-full rounded-2xl dark:bg-gray-800 dark:bg-opacity-40 dark:shadow-gray-900/20;
+        background-color: rgba(255, 255, 255, 0.5);
+        box-shadow: 0 1px 3px rgba(0, 0, 0, 0.05), 0 0 0 1px rgba(255, 255, 255, 0.1);
+        transition: all 0.3s ease;
+
+        // 定时值显示
+        .timer-value {
+          @apply text-4xl font-semibold mb-2 text-green-500;
+          
+          &.countdown-timer {
+            font-variant-numeric: tabular-nums;
+            letter-spacing: 2px;
+          }
+        }
+
+        // 标签文本
+        .timer-label {
+          @apply text-base text-gray-600 dark:text-gray-300;
+        }
+      }
+
+      // 取消按钮
+      .cancel-timer-btn {
+        @apply w-full py-3 text-base rounded-full transition-all duration-200;
+        
+        &:hover {
+          @apply transform scale-105 shadow-md;
+        }
+        
+        &:active {
+          @apply transform scale-95;
+        }
+      }
+    }
+
+    // 定时器选项区域
+    .sleep-timer-options {
+      @apply flex flex-col;
+
+      // 选项部分
+      .option-section {
+        @apply mb-7;
+
+        // 选项标题
+        .option-title {
+          @apply text-base font-medium mb-4 text-gray-700 dark:text-gray-200;
+          letter-spacing: 0.3px;
+        }
+
+        // 时间/歌曲选项容器
+        .time-options, .songs-options {
+          @apply flex flex-wrap gap-2;
+
+          // 选项按钮共享样式
+          .time-option-btn, .songs-option-btn {
+            @apply px-4 py-2 rounded-full text-gray-800 dark:text-gray-200 transition-all duration-200;
+            background-color: rgba(255, 255, 255, 0.5);
+            @apply dark:bg-gray-800 dark:bg-opacity-40 hover:bg-white dark:hover:bg-gray-700;
+            box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05), 0 0 0 1px rgba(255, 255, 255, 0.1);
+            @apply dark:shadow-gray-900/20;
+            
+            &:hover {
+              @apply transform scale-105 shadow-md;
+            }
+            
+            &:active {
+              @apply transform scale-95;
+            }
+          }
+
+          // 自定义输入区域
+          .custom-time, .custom-songs {
+            @apply flex items-center space-x-2 mt-4 w-full;
+
+            // 输入框
+            .custom-time-input, .custom-songs-input {
+              @apply flex-1;
+              
+              :deep(.n-input) {
+                @apply rounded-full dark:bg-gray-800 dark:bg-opacity-40 dark:border-gray-700;
+                backdrop-filter: blur(10px);
+                -webkit-backdrop-filter: blur(10px);
+                background-color: rgba(255, 255, 255, 0.5);
+                border: 1px solid rgba(255, 255, 255, 0.1);
+                transition: all 0.3s ease;
+                
+                &:hover, &:focus {
+                  box-shadow: 0 0 0 2px rgba(34, 197, 94, 0.2);
+                }
+              }
+            }
+
+            // 设置按钮
+            .custom-time-btn, .custom-songs-btn {
+              @apply py-2 px-4 rounded-full transition-all duration-200;
+              
+              &:hover {
+                @apply transform scale-105 shadow-md;
+              }
+              
+              &:active {
+                @apply transform scale-95;
+              }
+            }
+          }
+        }
+      }
+
+      // 播放列表结束选项
+      .playlist-end-section {
+        @apply mt-2;
+
+        .playlist-end-btn {
+          @apply py-3 text-base rounded-full text-gray-800 dark:text-gray-200 transition-all duration-200;
+          background-color: rgba(255, 255, 255, 0.5);
+          @apply dark:bg-gray-800 dark:bg-opacity-40 hover:bg-white dark:hover:bg-gray-700;
+          box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05), 0 0 0 1px rgba(255, 255, 255, 0.1);
+          @apply dark:shadow-gray-900/20;
+          
+          &:hover {
+            @apply transform scale-105 shadow-md;
+          }
+          
+          &:active {
+            @apply transform scale-95;
+          }
+        }
+      }
+    }
+  }
+}
+</style> 

src/renderer/components/settings/ClearCacheSettings.vue

@@ -0,0 +1,116 @@
+<template>
+  <n-modal
+    v-model:show="visible"
+    preset="dialog"
+    :title="t('settings.system.cache')"
+    :positive-text="t('common.confirm')"
+    :negative-text="t('common.cancel')"
+    @positive-click="handleConfirm"
+    @negative-click="handleCancel"
+  >
+    <n-space vertical>
+      <p>{{ t('settings.system.cacheClearTitle') }}</p>
+      <n-checkbox-group v-model:value="selectedTypes">
+        <n-space vertical>
+          <n-checkbox
+            v-for="option in clearCacheOptions"
+            :key="option.key"
+            :value="option.key"
+            :label="option.label"
+          >
+            <template #default>
+              <div>
+                <div>{{ t(`settings.system.cacheTypes.${option.key}.label`) }}</div>
+                <div class="text-gray-400 text-sm">
+                  {{ t(`settings.system.cacheTypes.${option.key}.description`) }}
+                </div>
+              </div>
+            </template>
+          </n-checkbox>
+        </n-space>
+      </n-checkbox-group>
+    </n-space>
+  </n-modal>
+</template>
+
+<script setup lang="ts">
+import { ref, watch, defineProps, defineEmits } from 'vue';
+import { useI18n } from 'vue-i18n';
+
+const props = defineProps({
+  show: {
+    type: Boolean,
+    default: false
+  }
+});
+
+const emit = defineEmits(['update:show', 'confirm']);
+
+const { t } = useI18n();
+const visible = ref(props.show);
+const selectedTypes = ref<string[]>([]);
+
+const clearCacheOptions = ref([
+  {
+    label: t('settings.system.cacheTypes.history.label'),
+    key: 'history',
+    description: t('settings.system.cacheTypes.history.description')
+  },
+  {
+    label: t('settings.system.cacheTypes.favorite.label'),
+    key: 'favorite',
+    description: t('settings.system.cacheTypes.favorite.description')
+  },
+  {
+    label: t('settings.system.cacheTypes.user.label'),
+    key: 'user',
+    description: t('settings.system.cacheTypes.user.description')
+  },
+  {
+    label: t('settings.system.cacheTypes.settings.label'),
+    key: 'settings',
+    description: t('settings.system.cacheTypes.settings.description')
+  },
+  {
+    label: t('settings.system.cacheTypes.downloads.label'),
+    key: 'downloads',
+    description: t('settings.system.cacheTypes.downloads.description')
+  },
+  {
+    label: t('settings.system.cacheTypes.resources.label'),
+    key: 'resources',
+    description: t('settings.system.cacheTypes.resources.description')
+  },
+  {
+    label: t('settings.system.cacheTypes.lyrics.label'),
+    key: 'lyrics',
+    description: t('settings.system.cacheTypes.lyrics.description')
+  }
+]);
+
+// 同步外部show属性变化
+watch(
+  () => props.show,
+  (newVal) => {
+    visible.value = newVal;
+  }
+);
+
+// 同步内部visible变化
+watch(
+  () => visible.value,
+  (newVal) => {
+    emit('update:show', newVal);
+  }
+);
+
+const handleConfirm = () => {
+  emit('confirm', selectedTypes.value);
+  selectedTypes.value = [];
+};
+
+const handleCancel = () => {
+  selectedTypes.value = [];
+  visible.value = false;
+};
+</script> 

src/renderer/components/settings/MusicSourceSettings.vue

@@ -0,0 +1,120 @@
+<template>
+  <n-modal
+    v-model:show="visible"
+    preset="dialog"
+    :title="t('settings.playback.musicSources')"
+    :positive-text="t('common.confirm')"
+    :negative-text="t('common.cancel')"
+    @positive-click="handleConfirm"
+    @negative-click="handleCancel"
+  >
+    <n-space vertical>
+      <p>{{ t('settings.playback.musicSourcesDesc') }}</p>
+      <n-checkbox-group v-model:value="selectedSources">
+        <n-grid :cols="2" :x-gap="12" :y-gap="8">
+          <n-grid-item v-for="source in musicSourceOptions" :key="source.value">
+            <n-checkbox :value="source.value">
+              {{ source.label }}
+              <template v-if="source.value === 'gdmusic'">
+                <n-tooltip>
+                  <template #trigger>
+                    <n-icon size="16" class="ml-1 text-blue-500 cursor-help">
+                      <i class="ri-information-line"></i>
+                    </n-icon>
+                  </template>
+                  {{ t('settings.playback.gdmusicInfo') }}
+                </n-tooltip>
+              </template>
+            </n-checkbox>
+          </n-grid-item>
+        </n-grid>
+      </n-checkbox-group>
+      <div v-if="selectedSources.length === 0" class="text-red-500 text-sm">
+        {{ t('settings.playback.musicSourcesWarning') }}
+      </div>
+
+      <!-- GD音乐台设置 -->
+      <div v-if="selectedSources.includes('gdmusic')" class="mt-4 border-t pt-4 border-gray-200 dark:border-gray-700">
+        <h3 class="text-base font-medium mb-2">GD音乐台(music.gdstudio.xyz)设置</h3>
+        <p class="text-sm text-gray-500 dark:text-gray-400 mb-2">
+          GD音乐台将自动尝试多个音乐平台进行解析，无需额外配置。优先级高于其他解析方式，但是请求可能较慢。感谢（music.gdstudio.xyz）
+        </p>
+      </div>
+    </n-space>
+  </n-modal>
+</template>
+
+<script setup lang="ts">
+import { ref, watch, defineProps, defineEmits } from 'vue';
+import { useI18n } from 'vue-i18n';
+import { type Platform } from '@/types/music';
+
+const props = defineProps({
+  show: {
+    type: Boolean,
+    default: false
+  },
+  sources: {
+    type: Array as () => Platform[],
+    default: () => ['migu', 'kugou', 'pyncmd', 'bilibili', 'youtube']
+  }
+});
+
+const emit = defineEmits(['update:show', 'update:sources']);
+
+const { t } = useI18n();
+const visible = ref(props.show);
+const selectedSources = ref<Platform[]>(props.sources);
+
+const musicSourceOptions = ref([
+  { label: 'MiGu音乐', value: 'migu' },
+  { label: '酷狗音乐', value: 'kugou' },
+  { label: 'pyncmd', value: 'pyncmd' },
+  { label: '酷我音乐', value: 'kuwo' },
+  { label: 'Bilibili音乐', value: 'bilibili' },
+  { label: 'YouTube', value: 'youtube' },
+  { label: 'GD音乐台', value: 'gdmusic' }
+]);
+
+// 同步外部show属性变化
+watch(
+  () => props.show,
+  (newVal) => {
+    visible.value = newVal;
+  }
+);
+
+// 同步内部visible变化
+watch(
+  () => visible.value,
+  (newVal) => {
+    emit('update:show', newVal);
+  }
+);
+
+// 同步外部sources属性变化
+watch(
+  () => props.sources,
+  (newVal) => {
+    selectedSources.value = [...newVal];
+  },
+  { deep: true }
+);
+
+const handleConfirm = () => {
+  // 确保至少选择一个音源
+  const defaultPlatforms = ['migu', 'kugou', 'pyncmd', 'bilibili', 'youtube'];
+  const valuesToEmit = selectedSources.value.length > 0 
+    ? [...new Set(selectedSources.value)] 
+    : defaultPlatforms;
+  
+  emit('update:sources', valuesToEmit);
+  visible.value = false;
+};
+
+const handleCancel = () => {
+  // 取消时还原为props传入的初始值
+  selectedSources.value = [...props.sources];
+  visible.value = false;
+};
+</script> 

src/renderer/components/settings/ProxySettings.vue

@@ -0,0 +1,152 @@
+<template>
+  <n-modal
+    v-model:show="visible"
+    preset="dialog"
+    :title="t('settings.network.proxy')"
+    :positive-text="t('common.confirm')"
+    :negative-text="t('common.cancel')"
+    :show-icon="false"
+    @positive-click="handleProxyConfirm"
+    @negative-click="handleCancel"
+  >
+    <n-form
+      ref="formRef"
+      :model="proxyForm"
+      :rules="proxyRules"
+      label-placement="left"
+      label-width="80"
+      require-mark-placement="right-hanging"
+    >
+      <n-form-item :label="t('settings.network.proxy')" path="protocol">
+        <n-select
+          v-model:value="proxyForm.protocol"
+          :options="[
+            { label: 'HTTP', value: 'http' },
+            { label: 'HTTPS', value: 'https' },
+            { label: 'SOCKS5', value: 'socks5' }
+          ]"
+        />
+      </n-form-item>
+      <n-form-item :label="t('settings.network.proxyHost')" path="host">
+        <n-input
+          v-model:value="proxyForm.host"
+          :placeholder="t('settings.network.proxyHostPlaceholder')"
+        />
+      </n-form-item>
+      <n-form-item :label="t('settings.network.proxyPort')" path="port">
+        <n-input-number
+          v-model:value="proxyForm.port"
+          :placeholder="t('settings.network.proxyPortPlaceholder')"
+          :min="1"
+          :max="65535"
+        />
+      </n-form-item>
+    </n-form>
+  </n-modal>
+</template>
+
+<script setup lang="ts">
+import { ref, watch, defineProps, defineEmits } from 'vue';
+import { useI18n } from 'vue-i18n';
+import { useMessage } from 'naive-ui';
+import type { FormRules } from 'naive-ui';
+
+const props = defineProps({
+  show: {
+    type: Boolean,
+    default: false
+  },
+  config: {
+    type: Object,
+    default: () => ({
+      protocol: 'http',
+      host: '127.0.0.1',
+      port: 7890
+    })
+  }
+});
+
+const emit = defineEmits(['update:show', 'confirm']);
+
+const { t } = useI18n();
+const message = useMessage();
+const formRef = ref();
+
+const visible = ref(props.show);
+const proxyForm = ref({
+  protocol: props.config.protocol || 'http',
+  host: props.config.host || '127.0.0.1',
+  port: props.config.port || 7890
+});
+
+const proxyRules: FormRules = {
+  protocol: {
+    required: true,
+    message: t('settings.validation.selectProxyProtocol'),
+    trigger: ['blur', 'change']
+  },
+  host: {
+    required: true,
+    message: t('settings.validation.proxyHost'),
+    trigger: ['blur', 'change'],
+    validator: (_rule, value) => {
+      if (!value) return false;
+      // 简单的IP或域名验证
+      const ipRegex = /^(\d{1,3}\.){3}\d{1,3}$|^localhost$|^[a-zA-Z0-9][-a-zA-Z0-9]{0,62}(\.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})+$/;
+      return ipRegex.test(value);
+    }
+  },
+  port: {
+    required: true,
+    message: t('settings.validation.portNumber'),
+    trigger: ['blur', 'change'],
+    validator: (_rule, value) => {
+      return value >= 1 && value <= 65535;
+    }
+  }
+};
+
+// 同步外部show属性变化
+watch(
+  () => props.show,
+  (newVal) => {
+    visible.value = newVal;
+  }
+);
+
+// 同步内部visible变化
+watch(
+  () => visible.value,
+  (newVal) => {
+    emit('update:show', newVal);
+  }
+);
+
+// 同步外部config变化
+watch(
+  () => props.config,
+  (newVal) => {
+    proxyForm.value = {
+      protocol: newVal.protocol || 'http',
+      host: newVal.host || '127.0.0.1',
+      port: newVal.port || 7890
+    };
+  },
+  { deep: true }
+);
+
+const handleProxyConfirm = async () => {
+  try {
+    await formRef.value?.validate();
+    emit('confirm', { ...proxyForm.value });
+    visible.value = false;
+    message.success(t('settings.network.messages.proxySuccess'));
+  } catch (err) {
+    message.error(t('settings.network.messages.proxyError'));
+  }
+};
+
+const handleCancel = () => {
+  visible.value = false;
+};
+</script> 

src/renderer/components/settings/ServerSetting.vue

@@ -0,0 +1,226 @@
+<template>
+  <n-modal
+    v-model:show="visible"
+    preset="card"
+    :title="t('settings.remoteControl.title')"
+    class="remote-control-modal"
+    style="max-width: 650px; width: 100%"
+  >
+    <n-scrollbar>
+      <div class="remote-control-setting">
+        <n-form label-placement="left" label-width="auto" :style="{ maxWidth: '640px' }">
+          <n-form-item :label="t('settings.remoteControl.enable')">
+            <n-switch v-model:value="remoteControlConfig.enabled" />
+          </n-form-item>
+
+          <n-form-item :label="t('settings.remoteControl.port')">
+            <n-input-number
+              v-model:value="remoteControlConfig.port"
+              :min="1024"
+              :max="65535"
+              :disabled="!remoteControlConfig.enabled"
+            />
+          </n-form-item>
+
+          <n-form-item :label="t('settings.remoteControl.allowedIps')">
+            <div class="allowed-ips-container">
+              <div v-for="(_, index) in remoteControlConfig.allowedIps" :key="index" class="ip-item">
+                <n-input v-model:value="remoteControlConfig.allowedIps[index]" :disabled="!remoteControlConfig.enabled" />
+                <n-button 
+                  quaternary 
+                  circle 
+                  type="error" 
+                  :disabled="!remoteControlConfig.enabled" 
+                  @click="removeIp(index)"
+                >
+                  <template #icon>
+                    <n-icon><i class="ri-delete-bin-line"></i></n-icon>
+                  </template>
+                </n-button>
+              </div>
+              <n-button 
+                secondary 
+                size="small" 
+                :disabled="!remoteControlConfig.enabled" 
+                @click="addIp"
+              >
+                <template #icon>
+                  <n-icon><i class="ri-add-line"></i></n-icon>
+                </template>
+                {{ t('settings.remoteControl.addIp') }}
+              </n-button>
+              <n-text depth="3" size="small" class="allow-all-hint">
+                {{ t('settings.remoteControl.emptyListHint') }}
+              </n-text>
+            </div>
+          </n-form-item>
+
+          <n-form-item>
+            <n-space>
+              <n-button 
+                type="primary" 
+                :disabled="!remoteControlConfig.enabled" 
+                @click="saveConfig"
+              >
+                {{ t('common.save') }}
+              </n-button>
+              <n-button @click="resetConfig">
+                {{ t('common.reset') }}
+              </n-button>
+            </n-space>
+          </n-form-item>
+
+          <n-collapse-transition :show="remoteControlConfig.enabled">
+            <div class="remote-info">
+              <n-alert type="info">
+                <template #icon>
+                  <n-icon><i class="ri-information-line"></i></n-icon>
+                </template>
+                <p>{{ t('settings.remoteControl.accessInfo') }}</p>
+                <div class="access-url">
+                  <n-tag type="success">
+                    http://localhost:{{ remoteControlConfig.port }}/
+                  </n-tag>
+                </div>
+                <div v-if="localIpAddresses.length" class="local-ips">
+                  <div v-for="ip in localIpAddresses" :key="ip" class="ip-address">
+                    <n-tag type="info">
+                      http://{{ ip }}:{{ remoteControlConfig.port }}/
+                    </n-tag>
+                  </div>
+                </div>
+              </n-alert>
+            </div>
+          </n-collapse-transition>
+        </n-form>
+      </div>
+    </n-scrollbar>
+  </n-modal>
+</template>
+
+<script setup lang="ts">
+import { onMounted, ref } from 'vue';
+import { useI18n } from 'vue-i18n';
+import { useMessage } from 'naive-ui';
+import { cloneDeep } from 'lodash';
+
+const { t } = useI18n();
+const message = useMessage();
+
+// 控制弹窗显示的属性
+const visible = defineModel('visible', { default: false });
+
+// 默认配置
+const defaultConfig:{
+  enabled: boolean,
+  port: number,
+  allowedIps: string[]
+} = {
+  enabled: false,
+  port: 31888,
+  allowedIps: []
+};
+
+// 远程控制配置
+const remoteControlConfig = ref({...defaultConfig});
+
+// 本地IP地址列表
+const localIpAddresses = ref<string[]>([]);
+
+// 获取本地IP地址
+const getLocalIpAddresses = () => {
+  if (window.electron) {
+    window.electron.ipcRenderer.invoke('get-local-ip-addresses').then((ips: string[]) => {
+      localIpAddresses.value = ips;
+    });
+  }
+};
+
+// 添加IP地址
+const addIp = () => {
+  remoteControlConfig.value.allowedIps.push('');
+};
+
+// 删除IP地址
+const removeIp = (index: number) => {
+  remoteControlConfig.value.allowedIps.splice(index, 1);
+};
+
+// 保存配置
+const saveConfig = () => {
+  // 过滤空IP
+  remoteControlConfig.value.allowedIps = remoteControlConfig.value.allowedIps.filter(ip => ip.trim() !== '');
+  
+  if (window.electron) {
+    window.electron.ipcRenderer.send('update-remote-control-config', cloneDeep(remoteControlConfig.value));
+    message.success(t('settings.remoteControl.saveSuccess'));
+  }
+};
+
+// 重置配置
+const resetConfig = () => {
+  if (window.electron) {
+    window.electron.ipcRenderer.invoke('get-remote-control-config').then((config) => {
+      if (config) {
+        remoteControlConfig.value = config;
+      } else {
+        remoteControlConfig.value = { ...defaultConfig };
+      }
+    });
+  }
+};
+
+// 组件挂载时，获取当前配置
+onMounted(async () => {
+  if (window.electron) {
+    try {
+      const config = await window.electron.ipcRenderer.invoke('get-remote-control-config');
+      if (config) {
+        remoteControlConfig.value = config;
+      }
+      // 获取本地IP地址
+      getLocalIpAddresses();
+    } catch (error) {
+      console.error('获取远程控制配置失败:', error);
+    }
+  }
+});
+</script>
+
+<style lang="scss" scoped>
+.remote-control-setting {
+  padding: 0 20px;
+}
+
+.allowed-ips-container {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  width: 100%;
+
+  .ip-item {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+  }
+
+  .allow-all-hint {
+    margin-top: 5px;
+  }
+}
+
+.remote-info {
+  margin-top: 16px;
+  
+  .access-url {
+    margin-top: 10px;
+  }
+  
+  .local-ips {
+    margin-top: 10px;
+    display: flex;
+    flex-direction: column;
+    gap: 5px;
+  }
+}
+</style> 

src/renderer/components/settings/ShortcutSettings.vue

@@ -16,11 +16,13 @@
                 <div class="shortcut-info">
                   <span class="shortcut-label">{{ getShortcutLabel(key) }}</span>
                 </div>
+                <div class="shortcut-controls">
                   <div class="shortcut-input">
                     <n-input
-                    :value="formatShortcut(shortcut)"
+                      :value="formatShortcut(shortcut.key)"
                       :status="duplicateKeys[key] ? 'error' : undefined"
                       :placeholder="t('settings.shortcutSettings.inputPlaceholder')"
+                      :disabled="!shortcut.enabled"
                       readonly
                       @keydown="(e) => handleKeyDown(e, key)"
                       @focus="() => startRecording(key)"
@@ -35,6 +37,34 @@
                       {{ t('settings.shortcutSettings.shortcutConflict') }}
                     </n-tooltip>
                   </div>
+                  <div class="shortcut-options">
+                    <n-tooltip trigger="hover">
+                      <template #trigger>
+                        <n-switch v-model:value="shortcut.enabled" size="small" />
+                      </template>
+                      {{
+                        shortcut.enabled
+                          ? t('settings.shortcutSettings.enabled')
+                          : t('settings.shortcutSettings.disabled')
+                      }}
+                    </n-tooltip>
+                    <n-tooltip v-if="shortcut.enabled" trigger="hover">
+                      <template #trigger>
+                        <n-select
+                          v-model:value="shortcut.scope"
+                          :options="scopeOptions"
+                          size="small"
+                          style="width: 100px"
+                        />
+                      </template>
+                      {{
+                        shortcut.scope === 'global'
+                          ? t('settings.shortcutSettings.scopeGlobal')
+                          : t('settings.shortcutSettings.scopeApp')
+                      }}
+                    </n-tooltip>
+                  </div>
+                </div>
               </div>
             </n-space>
           </n-scrollbar>
@@ -46,6 +76,12 @@
             <n-button size="small" @click="resetShortcuts">{{
               t('settings.shortcutSettings.resetShortcuts')
             }}</n-button>
+            <n-button size="small" type="warning" @click="disableAllShortcuts">{{
+              t('settings.shortcutSettings.disableAll')
+            }}</n-button>
+            <n-button size="small" type="success" @click="enableAllShortcuts">{{
+              t('settings.shortcutSettings.enableAll')
+            }}</n-button>
             <n-button type="primary" size="small" :disabled="hasConflict" @click="handleSave">
               {{ t('common.save') }}
             </n-button>
@@ -66,26 +102,37 @@ import { isElectron } from '@/utils';
 
 const { t } = useI18n();
 
+interface ShortcutConfig {
+  key: string;
+  enabled: boolean;
+  scope: 'global' | 'app';
+}
+
 interface Shortcuts {
-  togglePlay: string;
+  togglePlay: ShortcutConfig;
-  prevPlay: string;
+  prevPlay: ShortcutConfig;
-  nextPlay: string;
+  nextPlay: ShortcutConfig;
-  volumeUp: string;
+  volumeUp: ShortcutConfig;
-  volumeDown: string;
+  volumeDown: ShortcutConfig;
-  toggleFavorite: string;
+  toggleFavorite: ShortcutConfig;
-  toggleWindow: string;
+  toggleWindow: ShortcutConfig;
 }
 
 const defaultShortcuts: Shortcuts = {
-  togglePlay: 'CommandOrControl+Alt+P',
+  togglePlay: { key: 'CommandOrControl+Alt+P', enabled: true, scope: 'global' },
-  prevPlay: 'Alt+Left',
+  prevPlay: { key: 'Alt+Left', enabled: true, scope: 'global' },
-  nextPlay: 'Alt+Right',
+  nextPlay: { key: 'Alt+Right', enabled: true, scope: 'global' },
-  volumeUp: 'Alt+Up',
+  volumeUp: { key: 'Alt+Up', enabled: true, scope: 'app' },
-  volumeDown: 'Alt+Down',
+  volumeDown: { key: 'Alt+Down', enabled: true, scope: 'app' },
-  toggleFavorite: 'CommandOrControl+Alt+L',
+  toggleFavorite: { key: 'CommandOrControl+Alt+L', enabled: true, scope: 'app' },
-  toggleWindow: 'CommandOrControl+Alt+Shift+M'
+  toggleWindow: { key: 'CommandOrControl+Alt+Shift+M', enabled: true, scope: 'global' }
 };
 
+const scopeOptions = [
+  { label: t('settings.shortcutSettings.scopeGlobal'), value: 'global' },
+  { label: t('settings.shortcutSettings.scopeApp'), value: 'app' }
+];
+
 const shortcuts = ref<Shortcuts>(
   isElectron
     ? window.electron.ipcRenderer.sendSync('get-store-value', 'shortcuts') || defaultShortcuts
@@ -93,7 +140,7 @@ const shortcuts = ref<Shortcuts>(
 );
 
 // 临时存储编辑中的快捷键
-const tempShortcuts = ref<Shortcuts>({ ...shortcuts.value });
+const tempShortcuts = ref<Shortcuts>(cloneDeep(shortcuts.value));
 
 // 监听快捷键更新
 if (isElectron) {
@@ -101,7 +148,7 @@ if (isElectron) {
     const newShortcuts = window.electron.ipcRenderer.sendSync('get-store-value', 'shortcuts');
     if (newShortcuts) {
       shortcuts.value = newShortcuts;
-      tempShortcuts.value = { ...newShortcuts };
+      tempShortcuts.value = cloneDeep(newShortcuts);
     }
   });
 }
@@ -116,12 +163,27 @@ onMounted(() => {
     console.log('storedShortcuts', storedShortcuts);
     if (storedShortcuts) {
       shortcuts.value = storedShortcuts;
-      tempShortcuts.value = { ...storedShortcuts };
+      tempShortcuts.value = cloneDeep(storedShortcuts);
     } else {
       shortcuts.value = { ...defaultShortcuts };
-      tempShortcuts.value = { ...defaultShortcuts };
+      tempShortcuts.value = cloneDeep(defaultShortcuts);
       window.electron.ipcRenderer.send('set-store-value', 'shortcuts', defaultShortcuts);
     }
+
+    // 转换旧格式的快捷键数据到新格式
+    if (storedShortcuts && typeof storedShortcuts.togglePlay === 'string') {
+      const convertedShortcuts = {} as Shortcuts;
+      Object.entries(storedShortcuts).forEach(([key, value]) => {
+        convertedShortcuts[key as keyof Shortcuts] = {
+          key: value as string,
+          enabled: true,
+          scope: ['volumeUp', 'volumeDown', 'toggleFavorite'].includes(key) ? 'app' : 'global'
+        };
+      });
+      shortcuts.value = convertedShortcuts;
+      tempShortcuts.value = cloneDeep(convertedShortcuts);
+      window.electron.ipcRenderer.send('set-store-value', 'shortcuts', convertedShortcuts);
+    }
   }
 });
 
@@ -144,13 +206,21 @@ const message = useMessage();
 // 检查快捷键冲突
 const duplicateKeys = computed(() => {
   const result: Record<string, boolean> = {};
-  const usedShortcuts = new Set<string>();
+  const usedShortcuts = new Map<string, string>();
 
   Object.entries(tempShortcuts.value).forEach(([key, shortcut]) => {
-    if (usedShortcuts.has(shortcut)) {
+    // 只检查启用的快捷键
+    if (!shortcut.enabled) return;
+
+    const conflictKey = usedShortcuts.get(shortcut.key);
+    if (conflictKey) {
+      // 只有相同作用域的快捷键才会被认为冲突
+      const conflictScope = tempShortcuts.value[conflictKey as keyof Shortcuts].scope;
+      if (shortcut.scope === conflictScope) {
         result[key] = true;
+      }
     } else {
-      usedShortcuts.add(shortcut);
+      usedShortcuts.set(shortcut.key, key);
     }
   });
 
@@ -161,6 +231,8 @@ const duplicateKeys = computed(() => {
 const hasConflict = computed(() => Object.keys(duplicateKeys.value).length > 0);
 
 const startRecording = (key: keyof Shortcuts) => {
+  if (!tempShortcuts.value[key].enabled) return;
+
   isRecording.value = true;
   currentKey.value = key;
   // 禁用全局快捷键
@@ -220,12 +292,12 @@ const handleKeyDown = (e: KeyboardEvent, key: keyof Shortcuts) => {
   }
 
   if (!['Control', 'Alt', 'Shift', 'Meta', 'Command'].includes(keyName)) {
-    tempShortcuts.value[key] = [...modifiers, keyName].join('+');
+    tempShortcuts.value[key].key = [...modifiers, keyName].join('+');
   }
 };
 
 const resetShortcuts = () => {
-  tempShortcuts.value = { ...defaultShortcuts };
+  tempShortcuts.value = cloneDeep(defaultShortcuts);
   message.success(t('settings.shortcutSettings.messages.resetSuccess'));
 };
 
@@ -245,7 +317,7 @@ const saveShortcuts = () => {
       // 先保存到 store
       window.electron.ipcRenderer.send('set-store-value', 'shortcuts', shortcutsToSave);
       // 然后更新快捷键
-      window.electron.ipcRenderer.send('update-shortcuts');
+      window.electron.ipcRenderer.send('update-shortcuts', shortcutsToSave);
       message.success(t('settings.shortcutSettings.messages.saveSuccess'));
     } catch (error) {
       console.error('保存快捷键失败:', error);
@@ -255,7 +327,7 @@ const saveShortcuts = () => {
 };
 
 const cancelEdit = () => {
-  tempShortcuts.value = { ...shortcuts.value };
+  tempShortcuts.value = cloneDeep(shortcuts.value);
   message.info(t('settings.shortcutSettings.messages.cancelEdit'));
   emit('update:show', false);
 };
@@ -309,7 +381,7 @@ watch(visible, (newVal) => {
 // 处理弹窗关闭后的事件
 const handleAfterLeave = () => {
   // 重置临时数据
-  tempShortcuts.value = { ...shortcuts.value };
+  tempShortcuts.value = cloneDeep(shortcuts.value);
 };
 
 // 处理取消按钮点击
@@ -324,6 +396,22 @@ const handleSave = () => {
   visible.value = false;
   emit('change', shortcuts.value);
 };
+
+// 全部禁用快捷键
+const disableAllShortcuts = () => {
+  Object.keys(tempShortcuts.value).forEach((key) => {
+    tempShortcuts.value[key as keyof Shortcuts].enabled = false;
+  });
+  message.info(t('settings.shortcutSettings.messages.disableAll'));
+};
+
+// 全部启用快捷键
+const enableAllShortcuts = () => {
+  Object.keys(tempShortcuts.value).forEach((key) => {
+    tempShortcuts.value[key as keyof Shortcuts].enabled = true;
+  });
+  message.info(t('settings.shortcutSettings.messages.enableAll'));
+};
 </script>
 
 <style lang="scss" scoped>
@@ -359,16 +447,18 @@ const handleSave = () => {
     }
 
     .shortcut-info {
-      @apply flex flex-col;
+      @apply flex flex-col min-w-[150px];
 
       .shortcut-label {
         @apply text-base font-medium;
       }
     }
 
+    .shortcut-controls {
+      @apply flex items-center gap-3 flex-1;
+
       .shortcut-input {
-      @apply flex items-center gap-2;
+        @apply flex items-center gap-2 flex-1;
-      min-width: 200px;
 
         :deep(.n-input) {
           .n-input__input-el {
@@ -380,6 +470,11 @@ const handleSave = () => {
           @apply text-red-500;
         }
       }
+
+      .shortcut-options {
+        @apply flex items-center gap-2;
+      }
+    }
   }
 }
 </style>

src/renderer/hooks/MusicHistoryHook.ts

@@ -1,6 +1,7 @@
 // musicHistoryHooks
 import { useLocalStorage } from '@vueuse/core';
 
+import { recordPlay } from '@/api/stats';
 import type { SongResult } from '@/type/music';
 
 export const useMusicHistory = () => {
@@ -14,6 +15,25 @@ export const useMusicHistory = () => {
     } else {
       musicHistory.value.unshift({ ...music, count: 1 });
     }
+
+    // 记录播放统计
+    if (music?.id && music?.name) {
+      // 获取艺术家名称
+      let artistName = '未知艺术家';
+
+      if (music.ar) {
+        artistName = music.ar.map((artist) => artist.name).join('/');
+      } else if (music.song?.artists && music.song.artists.length > 0) {
+        artistName = music.song.artists.map((artist) => artist.name).join('/');
+      } else if (music.artists) {
+        artistName = music.artists.map((artist) => artist.name).join('/');
+      }
+
+      // 发送播放统计
+      recordPlay(music.id, music.name, artistName).catch((error) =>
+        console.error('记录播放统计失败:', error)
+      );
+    }
   };
 
   const delMusic = (music: SongResult) => {

src/renderer/hooks/MusicHook.ts

@@ -2,7 +2,6 @@ import { cloneDeep } from 'lodash';
 import { createDiscreteApi } from 'naive-ui';
 import { computed, nextTick, onUnmounted, ref, watch } from 'vue';
 
-import i18n from '@/../i18n/renderer';
 import { getBilibiliAudioUrl } from '@/api/bilibili';
 import useIndexedDB from '@/hooks/IndexDBHook';
 import { audioService } from '@/services/audioService';
@@ -235,70 +234,8 @@ const initProgressAnimation = () => {
 // 初始化进度动画
 initProgressAnimation();
 
-// 简化后的 watch 函数，只保留核心逻辑
+// 移除对 playerStore.playMusicUrl 的监听，因为播放逻辑已经在 player.ts 中处理
-watch(
+// 保留 watch 对 playerStore.playMusic 的监听以更新歌词数据
-  () => playerStore.playMusicUrl,
-  async (newVal) => {
-    if (newVal && playMusic.value) {
-      try {
-        // 保存当前播放状态
-        const shouldPlay = playerStore.play;
-
-        // 检查是否有保存的进度
-        let initialPosition = 0;
-        const savedProgress = JSON.parse(localStorage.getItem('playProgress') || '{}');
-        if (savedProgress.songId === playMusic.value.id) {
-          initialPosition = savedProgress.progress;
-        }
-
-        // 对于B站视频，检查URL是否有效
-        if (playMusic.value.source === 'bilibili' && (!newVal || newVal === 'undefined')) {
-          console.log('B站视频URL无效，尝试重新获取');
-
-          // 需要重新获取B站视频URL
-          if (playMusic.value.bilibiliData) {
-            try {
-              const proxyUrl = await getBilibiliAudioUrl(
-                playMusic.value.bilibiliData.bvid,
-                playMusic.value.bilibiliData.cid
-              );
-
-              // 设置URL到播放器状态
-              (playMusic.value as any).playMusicUrl = proxyUrl;
-              playerStore.playMusicUrl = proxyUrl;
-              newVal = proxyUrl;
-            } catch (error) {
-              console.error('获取B站音频URL失败:', error);
-              return;
-            }
-          }
-        }
-
-        // 播放新音频，传递是否应该播放的状态
-        const newSound = await audioService.play(newVal, playMusic.value, shouldPlay);
-        sound.value = newSound as Howl;
-
-        // 如果有保存的进度，设置播放位置
-        if (initialPosition > 0) {
-          newSound.seek(initialPosition);
-          // 同时更新进度条显示
-          nowTime.value = initialPosition;
-        }
-
-        setupAudioListeners();
-
-        // 确保状态与 localStorage 同步
-        localStorage.setItem('currentPlayMusic', JSON.stringify(playerStore.playMusic));
-        localStorage.setItem('currentPlayMusicUrl', newVal);
-      } catch (error) {
-        console.error('播放音频失败:', error);
-        // store.commit('setPlayMusic', false);
-        playerStore.setPlayMusic(false);
-        message.error(i18n.global.t('player.playFailed'));
-      }
-    }
-  }
-);
 
 watch(
   () => playerStore.playMusic,
@@ -395,7 +332,9 @@ const setupAudioListeners = () => {
   // 监听播放
   audioService.on('play', () => {
     playerStore.setPlayMusic(true);
+    if (isElectron) {
       window.api.sendSong(cloneDeep(playerStore.playMusic));
+    }
     clearInterval();
     interval = window.setInterval(() => {
       try {
@@ -1007,3 +946,27 @@ audioService.on('url_expired', async (expiredTrack) => {
     message.error('恢复播放失败，请手动点击播放');
   }
 });
+
+// 添加音频就绪事件监听器
+window.addEventListener('audio-ready', ((event: CustomEvent) => {
+  try {
+    const { sound: newSound } = event.detail;
+    if (newSound) {
+      // 更新本地 sound 引用
+      sound.value = newSound as Howl;
+      
+      // 设置音频监听器
+      setupAudioListeners();
+      
+      // 获取当前播放位置并更新显示
+      const currentPosition = newSound.seek() as number;
+      if (typeof currentPosition === 'number' && !Number.isNaN(currentPosition)) {
+        nowTime.value = currentPosition;
+      }
+      
+      console.log('音频就绪，已设置监听器并更新进度显示');
+    }
+  } catch (error) {
+    console.error('处理音频就绪事件出错:', error);
+  }
+}) as EventListener);

src/renderer/hooks/MusicListHook.ts

@@ -5,6 +5,7 @@ import { ref } from 'vue';
 import { getMusicLrc, getMusicUrl, getParsingMusicUrl } from '@/api/music';
 import { useMusicHistory } from '@/hooks/MusicHistoryHook';
 import { audioService } from '@/services/audioService';
+import { useSettingsStore } from '@/store';
 import type { ILyric, ILyricText, SongResult } from '@/type/music';
 import { getImgUrl } from '@/utils';
 import { getImageLinearBackground } from '@/utils/linearColor';
@@ -13,12 +14,16 @@ const musicHistory = useMusicHistory();
 
 // 获取歌曲url
 export const getSongUrl = async (id: any, songData: any, isDownloaded: boolean = false) => {
-  const { data } = await getMusicUrl(id, isDownloaded);
+  const settingsStore = useSettingsStore();
+  const { unlimitedDownload } = settingsStore.setData;
+
+  const { data } = await getMusicUrl(id, !unlimitedDownload);
   let url = '';
   let songDetail = null;
+
   try {
     if (data.data[0].freeTrialInfo || !data.data[0].url) {
-      const res = await getParsingMusicUrl(id, songData);
+      const res = await getParsingMusicUrl(id, cloneDeep(songData));
       url = res.data.data.url;
       songDetail = res.data.data;
     } else {

src/renderer/layout/AppLayout.vue

@@ -146,6 +146,7 @@ provide('openPlaylistDrawer', openPlaylistDrawer);
     overflow: auto;
     display: block;
     flex: none;
+    padding-bottom: 70px;
   }
 }
 </style>

src/renderer/layout/components/AppMenu.vue

@@ -113,8 +113,10 @@ const isText = ref(false);
   .app-menu {
     max-width: 100%;
     width: 100vw;
-    position: relative;
+    position: fixed;
-    z-index: 999999;
+    bottom: 0;
+    left: 0;
+    z-index: 99999;
     @apply bg-light dark:bg-black border-t border-gray-200 dark:border-gray-700;
 
     &-header {
@@ -122,7 +124,7 @@ const isText = ref(false);
     }
 
     &-list {
-      @apply flex justify-between;
+      @apply flex justify-between px-4;
     }
 
     &-item {

src/renderer/layout/components/MusicFull.vue

@@ -29,6 +29,7 @@
       </n-popover>
 
       <div
+        v-if="!config.hideCover"
         class="music-img"
         :class="{ 'only-cover': config.hideLyrics }"
         :style="{ color: textColors.theme === 'dark' ? '#000000' : '#ffffff' }"
@@ -74,7 +75,7 @@
       <div
         class="music-content"
         :class="{
-          center: config.centerLyrics && config.hideCover,
+          center: config.centerLyrics,
           hide: config.hideLyrics
         }"
       >
@@ -159,6 +160,7 @@ import {
 import { useArtist } from '@/hooks/useArtist';
 import { usePlayerStore } from '@/store/modules/player';
 import { useSettingsStore } from '@/store/modules/settings';
+import { DEFAULT_LYRIC_CONFIG, LyricConfig } from '@/types/lyric';
 import { getImgUrl, isMobile } from '@/utils';
 import { animateGradient, getHoverBackgroundColor, getTextColors } from '@/utils/linearColor';
 
@@ -173,34 +175,8 @@ const isDark = ref(false);
 const showStickyHeader = ref(false);
 const lyricSettingsRef = ref<InstanceType<typeof LyricSettings>>();
 
-interface LyricConfig {
-  hideCover: boolean;
-  centerLyrics: boolean;
-  fontSize: number;
-  letterSpacing: number;
-  lineHeight: number;
-  showTranslation: boolean;
-  theme: 'default' | 'light' | 'dark';
-  hidePlayBar: boolean;
-  pureModeEnabled: boolean;
-  hideMiniPlayBar: boolean;
-  hideLyrics: boolean;
-}
-
 // 移除 computed 配置
-const config = ref<LyricConfig>({
+const config = ref<LyricConfig>({ ...DEFAULT_LYRIC_CONFIG });
-  hideCover: false,
-  centerLyrics: false,
-  fontSize: 22,
-  letterSpacing: 0,
-  lineHeight: 1.5,
-  showTranslation: true,
-  theme: 'default',
-  hidePlayBar: false,
-  pureModeEnabled: false,
-  hideMiniPlayBar: false,
-  hideLyrics: false
-});
 
 // 监听设置组件的配置变化
 watch(
@@ -617,7 +593,7 @@ defineExpose({
     transition: all 0.3s ease;
 
     &.center {
-      @apply w-full;
+      @apply w-auto;
       .music-lrc {
         @apply w-full max-w-3xl mx-auto;
       }

src/renderer/main.ts

@@ -10,6 +10,7 @@ import pinia from '@/store';
 
 import App from './App.vue';
 import directives from './directive';
+import { initAppShortcuts } from './utils/appShortcuts';
 
 const app = createApp(App);
 
@@ -21,3 +22,6 @@ app.use(pinia);
 app.use(router);
 app.use(i18n);
 app.mount('#app');
+
+// 初始化应用内快捷键
+initAppShortcuts();

src/renderer/router/index.ts

@@ -1,5 +1,6 @@
 import { createRouter, createWebHashHistory } from 'vue-router';
 
+import { recordVisit } from '@/api/stats';
 import AppLayout from '@/layout/AppLayout.vue';
 import MiniLayout from '@/layout/MiniLayout.vue';
 import homeRouter from '@/router/home';
@@ -80,4 +81,13 @@ router.beforeEach((to, _, next) => {
   }
 });
 
+// 添加全局后置钩子，记录页面访问
+router.afterEach((to) => {
+  const pageName = to.name?.toString() || to.path;
+  // 使用setTimeout避免阻塞路由导航
+  setTimeout(() => {
+    recordVisit(pageName).catch((error) => console.error('记录页面访问失败:', error));
+  }, 100);
+});
+
 export default router;

src/renderer/services/audioService.ts

@@ -41,6 +41,11 @@ class AudioService {
 
   private seekDebounceTimer: NodeJS.Timeout | null = null;
 
+  // 添加操作锁防止并发操作
+  private operationLock = false;
+  private operationLockTimer: NodeJS.Timeout | null = null;
+  private operationLockTimeout = 5000; // 5秒超时
+
   constructor() {
     if ('mediaSession' in navigator) {
       this.initMediaSession();
@@ -356,8 +361,47 @@ class AudioService {
     }
   }
 
+  // 设置操作锁，带超时自动释放
+  private setOperationLock(): boolean {
+    if (this.operationLock) {
+      return false;
+    }
+    
+    this.operationLock = true;
+    
+    // 清除之前的定时器
+    if (this.operationLockTimer) {
+      clearTimeout(this.operationLockTimer);
+    }
+    
+    // 设置超时自动释放锁
+    this.operationLockTimer = setTimeout(() => {
+      console.warn('操作锁超时自动释放');
+      this.operationLock = false;
+      this.operationLockTimer = null;
+    }, this.operationLockTimeout);
+    
+    return true;
+  }
+  
+  // 释放操作锁
+  private releaseOperationLock(): void {
+    this.operationLock = false;
+    
+    if (this.operationLockTimer) {
+      clearTimeout(this.operationLockTimer);
+      this.operationLockTimer = null;
+    }
+  }
+
   // 播放控制相关
   play(url?: string, track?: SongResult, isPlay: boolean = true): Promise<Howl> {
+    // 如果操作锁已激活，说明有操作正在进行中，直接返回
+    if (!this.setOperationLock()) {
+      console.log('audioService: 操作锁激活，忽略当前播放请求');
+      return Promise.reject(new Error('操作锁激活，请等待当前操作完成'));
+    }
+
     // 如果没有提供新的 URL 和 track，且当前有音频实例，则继续播放
     if (this.currentSound && !url && !track) {
       // 如果有进行中的seek操作，等待其完成
@@ -366,15 +410,17 @@ class AudioService {
         this.seekLock = false;
       }
       this.currentSound.play();
+      this.releaseOperationLock();
       return Promise.resolve(this.currentSound);
     }
 
     // 如果没有提供必要的参数，返回错误
     if (!url || !track) {
+      this.releaseOperationLock();
       return Promise.reject(new Error('Missing required parameters: url and track'));
     }
 
-    return new Promise((resolve, reject) => {
+    return new Promise<Howl>((resolve, reject) => {
       let retryCount = 0;
       const maxRetries = 1;
 
@@ -507,11 +553,15 @@ class AudioService {
           }
         } catch (error) {
           console.error('Error creating audio instance:', error);
+          this.releaseOperationLock();
           reject(error);
         }
       };
 
       tryPlay();
+    }).finally(() => {
+      // 无论成功或失败都解除操作锁
+      this.releaseOperationLock();
     });
   }
 
@@ -524,6 +574,11 @@ class AudioService {
   }
 
   stop() {
+    if (!this.setOperationLock()) {
+      console.log('audioService: 操作锁激活，忽略当前停止请求');
+      return;
+    }
+    
     if (this.currentSound) {
       try {
         // 确保任何进行中的seek操作被取消
@@ -538,11 +593,14 @@ class AudioService {
       }
       this.currentSound = null;
     }
+    
     this.currentTrack = null;
     if ('mediaSession' in navigator) {
       navigator.mediaSession.playbackState = 'none';
     }
     this.disposeEQ();
+    
+    this.releaseOperationLock();
   }
 
   setVolume(volume: number) {
@@ -553,6 +611,11 @@ class AudioService {
   }
 
   seek(time: number) {
+    if (!this.setOperationLock()) {
+      console.log('audioService: 操作锁激活，忽略当前seek请求');
+      return;
+    }
+    
     if (this.currentSound) {
       try {
         // 直接执行seek操作，避免任何过滤或判断
@@ -564,9 +627,16 @@ class AudioService {
         console.error('Seek操作失败:', error);
       }
     }
+    
+    this.releaseOperationLock();
   }
 
   pause() {
+    if (!this.setOperationLock()) {
+      console.log('audioService: 操作锁激活，忽略当前暂停请求');
+      return;
+    }
+    
     if (this.currentSound) {
       try {
         // 如果有进行中的seek操作，等待其完成
@@ -579,6 +649,8 @@ class AudioService {
         console.error('Error pausing audio:', error);
       }
     }
+    
+    this.releaseOperationLock();
   }
 
   clearAllListeners() {

src/renderer/store/modules/player.ts

@@ -2,17 +2,21 @@ import { cloneDeep } from 'lodash';
 import { defineStore } from 'pinia';
 import { computed, ref } from 'vue';
 
+import i18n from '@/../i18n/renderer';
 import { getBilibiliAudioUrl } from '@/api/bilibili';
 import { getLikedList, getMusicLrc, getMusicUrl, getParsingMusicUrl } from '@/api/music';
 import { useMusicHistory } from '@/hooks/MusicHistoryHook';
+import { audioService } from '@/services/audioService';
 import type { ILyric, ILyricText, SongResult } from '@/type/music';
 import { getImgUrl } from '@/utils';
 import { getImageLinearBackground } from '@/utils/linearColor';
+import { createDiscreteApi } from 'naive-ui';
 
 import { useSettingsStore } from './settings';
 import { useUserStore } from './user';
 
 const musicHistory = useMusicHistory();
+const { message } = createDiscreteApi(['message']);
 
 const preloadingSounds = ref<Howl[]>([]);
 
@@ -25,6 +29,50 @@ function getLocalStorageItem<T>(key: string, defaultValue: T): T {
   }
 }
 
+// 比较B站视频ID的辅助函数
+export const isBilibiliIdMatch = (id1: string | number, id2: string | number): boolean => {
+  const str1 = String(id1);
+  const str2 = String(id2);
+  
+  // 如果两个ID都不包含--分隔符，直接比较
+  if (!str1.includes('--') && !str2.includes('--')) {
+    return str1 === str2;
+  }
+  
+  // 处理B站视频ID
+  if (str1.includes('--') || str2.includes('--')) {
+    // 尝试从ID中提取bvid和cid
+    const extractBvIdAndCid = (str: string) => {
+      if (!str.includes('--')) return { bvid: '', cid: '' };
+      const parts = str.split('--');
+      if (parts.length >= 3) {
+        // bvid--pid--cid格式
+        return { bvid: parts[0], cid: parts[2] };
+      } else if (parts.length === 2) {
+        // 旧格式或其他格式
+        return { bvid: '', cid: parts[1] };
+      }
+      return { bvid: '', cid: '' };
+    };
+    
+    const { bvid: bvid1, cid: cid1 } = extractBvIdAndCid(str1);
+    const { bvid: bvid2, cid: cid2 } = extractBvIdAndCid(str2);
+    
+    // 如果两个ID都有bvid，比较bvid和cid
+    if (bvid1 && bvid2) {
+      return bvid1 === bvid2 && cid1 === cid2;
+    }
+    
+    // 其他情况，只比较cid部分
+    if (cid1 && cid2) {
+      return cid1 === cid2;
+    }
+  }
+  
+  // 默认情况，直接比较完整ID
+  return str1 === str2;
+};
+
 // 提取公共函数：获取B站视频URL
 
 export const getSongUrl = async (
@@ -67,6 +115,7 @@ export const getSongUrl = async (
     }
   } catch (error) {
     console.error('error', error);
+    url = data.data[0].url || '';
   }
   if (isDownloaded) {
     return songDetail;
@@ -153,7 +202,15 @@ const getSongDetail = async (playMusic: SongResult) => {
     return { ...playMusic, backgroundColor, primaryColor } as SongResult;
   }
 
+  if (playMusic.expiredAt && playMusic.expiredAt < Date.now()) {
+    console.info(`歌曲已过期，重新获取: ${playMusic.name}`);
+    playMusic.playMusicUrl = undefined;
+  }
+
   const playMusicUrl = playMusic.playMusicUrl || (await getSongUrl(playMusic.id, playMusic));
+  playMusic.createdAt = Date.now();
+  // 半小时后过期
+  playMusic.expiredAt = playMusic.createdAt + 1800000;
   const { backgroundColor, primaryColor } =
     playMusic.backgroundColor && playMusic.primaryColor
       ? playMusic
@@ -266,6 +323,23 @@ const loadLrcAsync = async (playMusic: SongResult) => {
   playMusic.lyric = lyrics;
 };
 
+// 定时关闭类型
+export enum SleepTimerType {
+  NONE = 'none',         // 没有定时
+  TIME = 'time',         // 按时间定时
+  SONGS = 'songs',       // 按歌曲数定时
+  PLAYLIST_END = 'end'   // 播放列表播放完毕定时
+}
+
+// 定时关闭信息
+export interface SleepTimerInfo {
+  type: SleepTimerType;
+  value: number;         // 对于TIME类型，值以分钟为单位；对于SONGS类型，值为歌曲数量
+  endTime?: number;      // 何时结束（仅TIME类型）
+  startSongIndex?: number; // 开始时的歌曲索引（对于SONGS类型）
+  remainingSongs?: number; // 剩余歌曲数（对于SONGS类型）
+}
+
 export const usePlayerStore = defineStore('player', () => {
   const play = ref(false);
   const isPlay = ref(false);
@@ -275,9 +349,40 @@ export const usePlayerStore = defineStore('player', () => {
   const playListIndex = ref(getLocalStorageItem('playListIndex', 0));
   const playMode = ref(getLocalStorageItem('playMode', 0));
   const musicFull = ref(false);
-  const favoriteList = ref<number[]>(getLocalStorageItem('favoriteList', []));
+  const favoriteList = ref<Array<number | string>>(getLocalStorageItem('favoriteList', []));
   const savedPlayProgress = ref<number | undefined>();
   
+  // 定时关闭相关状态
+  const sleepTimer = ref<SleepTimerInfo>(getLocalStorageItem('sleepTimer', {
+    type: SleepTimerType.NONE,
+    value: 0
+  }));
+  
+  const timerInterval = ref<number | null>(null);
+  
+  // 当前定时关闭状态
+  const currentSleepTimer = computed(() => sleepTimer.value);
+  
+  // 判断是否有活跃的定时关闭
+  const hasSleepTimerActive = computed(() => sleepTimer.value.type !== SleepTimerType.NONE);
+  
+  // 获取剩余时间（用于UI显示）
+  const sleepTimerRemainingTime = computed(() => {
+    if (sleepTimer.value.type === SleepTimerType.TIME && sleepTimer.value.endTime) {
+      const remaining = Math.max(0, sleepTimer.value.endTime - Date.now());
+      return Math.ceil(remaining / 60000); // 转换为分钟并向上取整
+    }
+    return 0;
+  });
+  
+  // 获取剩余歌曲数（用于UI显示）
+  const sleepTimerRemainingSongs = computed(() => {
+    if (sleepTimer.value.type === SleepTimerType.SONGS) {
+      return sleepTimer.value.remainingSongs || 0;
+    }
+    return 0;
+  });
+  
   const currentSong = computed(() => playMusic.value);
   const isPlaying = computed(() => isPlay.value);
   const currentPlayList = computed(() => playList.value);
@@ -301,10 +406,12 @@ export const usePlayerStore = defineStore('player', () => {
         }
       } catch (error) {
         console.error('获取B站音频URL失败:', error);
-        throw error; // 向上抛出错误，让调用者处理
+        message.error(i18n.global.t('player.playFailed'));
+        return false; // 返回失败状态
       }
     }
 
+    try {
       const updatedPlayMusic = await getSongDetail(music);
       playMusic.value = updatedPlayMusic;
       playMusicUrl.value = updatedPlayMusic.playMusicUrl as string;
@@ -332,19 +439,64 @@ export const usePlayerStore = defineStore('player', () => {
 
       musicHistory.addMusic(playMusic.value);
 
-    playListIndex.value = playList.value.findIndex(
+      // 找到歌曲在播放列表中的索引，如果是通过 nextPlay/prevPlay 调用的，不会更新 playListIndex
+      const songIndex = playList.value.findIndex(
         (item: SongResult) => item.id === music.id && item.source === music.source
       );
       
-    fetchSongs(playList.value, playListIndex.value + 1, playListIndex.value + 6);
+      // 只有在 songIndex 有效，并且与当前 playListIndex 不同时才更新
+      // 这样可以避免与 nextPlay/prevPlay 中的索引更新冲突
+      if (songIndex !== -1 && songIndex !== playListIndex.value) {
+        console.log('歌曲索引不匹配，更新为:', songIndex);
+        playListIndex.value = songIndex;
+      }
+      
+      // 无论如何都预加载更多歌曲
+      if (songIndex !== -1) {
+        fetchSongs(playList.value, songIndex + 1, songIndex + 3);
+      } else {
+        console.warn('当前歌曲未在播放列表中找到');
+      }
+      
+      // 使用标记防止循环调用
+      let playInProgress = false;
+      
+      // 直接调用 playAudio 方法播放音频，不需要依赖外部监听
+      try {
+        if (playInProgress) {
+          console.warn('播放操作正在进行中，避免重复调用');
+          return true;
+        }
+        
+        playInProgress = true;
+        
+        // 因为调用 playAudio 前我们已经设置了 play.value，所以不需要额外传递 shouldPlay 参数
+        const result = await playAudio();
+        
+        playInProgress = false;
+        return !!result;
+      } catch (error) {
+        console.error('自动播放音频失败:', error);
+        playInProgress = false;
+        return false;
+      }
+    } catch (error) {
+      console.error('处理播放音乐失败:', error);
+      message.error(i18n.global.t('player.playFailed'));
+      return false;
+    }
   };
 
   const setPlay = async (song: SongResult) => {
     try {
-      await handlePlayMusic(song);
+      // 直接调用 handlePlayMusic，它会处理索引更新和播放逻辑
+      const success = await handlePlayMusic(song);
+      
+      // 记录到本地存储，保持一致性
       localStorage.setItem('currentPlayMusic', JSON.stringify(playMusic.value));
       localStorage.setItem('currentPlayMusicUrl', playMusicUrl.value);
-      return true;
+      
+      return success;
     } catch (error) {
       console.error('设置播放失败:', error);
       return false;
@@ -395,12 +547,203 @@ export const usePlayerStore = defineStore('player', () => {
     setPlayList(list);
   };
 
-  const nextPlay = async () => {
+  // 睡眠定时器功能
-    if (playList.value.length === 0) {
+  const setSleepTimerByTime = (minutes: number) => {
-      play.value = true;
+    // 清除现有定时器
+    clearSleepTimer();
+    
+    if (minutes <= 0) {
       return;
     }
     
+    const endTime = Date.now() + minutes * 60 * 1000;
+    
+    sleepTimer.value = {
+      type: SleepTimerType.TIME,
+      value: minutes,
+      endTime
+    };
+    
+    // 保存到本地存储
+    localStorage.setItem('sleepTimer', JSON.stringify(sleepTimer.value));
+    
+    // 设置定时器检查
+    timerInterval.value = window.setInterval(() => {
+      checkSleepTimer();
+    }, 1000) as unknown as number; // 每秒检查一次
+    
+    console.log(`设置定时关闭: ${minutes}分钟后`);
+    return true;
+  };
+  
+  // 睡眠定时器功能
+  const setSleepTimerBySongs = (songs: number) => {
+    // 清除现有定时器
+    clearSleepTimer();
+    
+    if (songs <= 0) {
+      return;
+    }
+    
+    sleepTimer.value = {
+      type: SleepTimerType.SONGS,
+      value: songs,
+      startSongIndex: playListIndex.value,
+      remainingSongs: songs
+    };
+    
+    // 保存到本地存储
+    localStorage.setItem('sleepTimer', JSON.stringify(sleepTimer.value));
+    
+    console.log(`设置定时关闭: 再播放${songs}首歌后`);
+    return true;
+  };
+  
+  // 睡眠定时器功能
+  const setSleepTimerAtPlaylistEnd = () => {
+    // 清除现有定时器
+    clearSleepTimer();
+    
+    sleepTimer.value = {
+      type: SleepTimerType.PLAYLIST_END,
+      value: 0
+    };
+    
+    // 保存到本地存储
+    localStorage.setItem('sleepTimer', JSON.stringify(sleepTimer.value));
+    
+    console.log('设置定时关闭: 播放列表结束时');
+    return true;
+  };
+  
+  // 取消定时关闭
+  const clearSleepTimer = () => {
+    if (timerInterval.value) {
+      window.clearInterval(timerInterval.value);
+      timerInterval.value = null;
+    }
+    
+    sleepTimer.value = {
+      type: SleepTimerType.NONE,
+      value: 0
+    };
+    
+    // 保存到本地存储
+    localStorage.setItem('sleepTimer', JSON.stringify(sleepTimer.value));
+    
+    console.log('取消定时关闭');
+    return true;
+  };
+  
+  // 检查定时关闭是否应该触发
+  const checkSleepTimer = () => {
+    if (sleepTimer.value.type === SleepTimerType.NONE) {
+      return;
+    }
+    
+    if (sleepTimer.value.type === SleepTimerType.TIME && sleepTimer.value.endTime) {
+      if (Date.now() >= sleepTimer.value.endTime) {
+        // 时间到，停止播放
+        stopPlayback();
+      }
+    } else if (sleepTimer.value.type === SleepTimerType.PLAYLIST_END) {
+      // 播放列表结束定时由nextPlay方法处理
+    }
+  };
+  
+  // 停止播放并清除定时器
+  const stopPlayback = () => {
+    console.log('定时器触发：停止播放');
+    
+    if (isPlaying.value) {
+      setIsPlay(false);
+      audioService.pause();
+    }
+    
+    // 如果使用Electron，发送通知
+    if (window.electron?.ipcRenderer) {
+      window.electron.ipcRenderer.send('show-notification', {
+        title: i18n.global.t('player.sleepTimer.timerEnded'),
+        body: i18n.global.t('player.sleepTimer.playbackStopped')
+      });
+    }
+    
+    // 清除定时器
+    clearSleepTimer();
+  };
+  
+  // 监听歌曲变化，处理按歌曲数定时和播放列表结束定时
+  const handleSongChange = () => {
+    console.log('歌曲已切换，检查定时器状态:', sleepTimer.value);
+    
+    // 处理按歌曲数定时
+    if (sleepTimer.value.type === SleepTimerType.SONGS && sleepTimer.value.remainingSongs !== undefined) {
+      sleepTimer.value.remainingSongs--;
+      console.log(`剩余歌曲数: ${sleepTimer.value.remainingSongs}`);
+      
+      // 保存到本地存储
+      localStorage.setItem('sleepTimer', JSON.stringify(sleepTimer.value));
+      
+      if (sleepTimer.value.remainingSongs <= 0) {
+        // 歌曲数到达，停止播放
+        console.log('已播放完设定的歌曲数，停止播放');
+        stopPlayback()
+        setTimeout(() => {
+          stopPlayback();
+        }, 1000);
+      }
+    }
+    
+    // 处理播放列表结束定时
+    if (sleepTimer.value.type === SleepTimerType.PLAYLIST_END) {
+      // 检查是否到达播放列表末尾
+      const isLastSong = (playListIndex.value === playList.value.length - 1);
+      
+      // 如果是列表最后一首歌且不是循环模式，则设置为在这首歌结束后停止
+      if (isLastSong && playMode.value !== 1) { // 1 是循环模式
+        console.log('已到达播放列表末尾，将在当前歌曲结束后停止播放');
+        // 转换为按歌曲数定时，剩余1首
+        sleepTimer.value = {
+          type: SleepTimerType.SONGS,
+          value: 1,
+          remainingSongs: 1
+        };
+        // 保存到本地存储
+        localStorage.setItem('sleepTimer', JSON.stringify(sleepTimer.value));
+      }
+    }
+  };
+
+  // 修改nextPlay方法，加入定时关闭检查逻辑
+  const nextPlay = async () => {
+    // 静态标志，防止多次调用造成递归
+    if ((nextPlay as any).isRunning) {
+      console.log('下一首播放正在执行中，忽略重复调用');
+      return;
+    }
+    
+    try {
+      (nextPlay as any).isRunning = true;
+      
+      if (playList.value.length === 0) {
+        play.value = true;
+        (nextPlay as any).isRunning = false;
+        return;
+      }
+
+      // 检查是否是播放列表的最后一首且设置了播放列表结束定时
+      if (playMode.value === 0 && playListIndex.value === playList.value.length - 1 && 
+          sleepTimer.value.type === SleepTimerType.PLAYLIST_END) {
+        // 已是最后一首且为顺序播放模式，触发停止
+        stopPlayback();
+        (nextPlay as any).isRunning = false;
+        return;
+      }
+
+      // 在切换前保存当前播放状态
+      const shouldPlayNext = play.value;
+      console.log('切换到下一首，当前播放状态:', shouldPlayNext ? '播放' : '暂停');
+
       let nowPlayListIndex: number;
 
       if (playMode.value === 2) {
@@ -411,10 +754,11 @@ export const usePlayerStore = defineStore('player', () => {
         nowPlayListIndex = (playListIndex.value + 1) % playList.value.length;
       }
 
+      // 重要：首先更新当前播放索引
       playListIndex.value = nowPlayListIndex;
       
       // 获取下一首歌曲
-    const nextSong = playList.value[playListIndex.value];
+      const nextSong = playList.value[nowPlayListIndex];
 
       // 如果是B站视频，确保重新获取URL
       if (nextSong.source === 'bilibili' && nextSong.bilibiliData) {
@@ -423,17 +767,58 @@ export const usePlayerStore = defineStore('player', () => {
         console.log('下一首是B站视频，已清除URL强制重新获取');
       }
 
-    await handlePlayMusic(nextSong);
+      // 尝试播放，并明确传递应该播放的状态
+      const success = await handlePlayMusic(nextSong, shouldPlayNext);
+      
+      if (!success) {
+        console.error('播放下一首失败，将从播放列表中移除此歌曲');
+        // 从播放列表中移除失败的歌曲
+        const newPlayList = [...playList.value];
+        newPlayList.splice(nowPlayListIndex, 1);
+        
+        if (newPlayList.length > 0) {
+          // 更新播放列表后，重新尝试播放下一首
+          setPlayList(newPlayList);
+          // 延迟一点时间再尝试下一首，避免立即触发可能导致的无限循环
+          setTimeout(() => {
+            (nextPlay as any).isRunning = false;
+            nextPlay();
+          }, 300);
+          return;
+        }
+      }
+      
+      // 歌曲切换成功，触发歌曲变更处理（用于定时关闭功能）
+      handleSongChange();
+    } catch (error) {
+      console.error('切换下一首出错:', error);
+    } finally {
+      (nextPlay as any).isRunning = false;
+    }
   };
 
   const prevPlay = async () => {
-    if (playList.value.length === 0) {
+    // 静态标志，防止多次调用造成递归
-      play.value = true;
+    if ((prevPlay as any).isRunning) {
+      console.log('上一首播放正在执行中，忽略重复调用');
       return;
     }
+    
+    try {
+      (prevPlay as any).isRunning = true;
+      
+      if (playList.value.length === 0) {
+        play.value = true;
+        (prevPlay as any).isRunning = false;
+        return;
+      }
+      
       const nowPlayListIndex =
         (playListIndex.value - 1 + playList.value.length) % playList.value.length;
 
+      // 重要：首先更新当前播放索引
+      playListIndex.value = nowPlayListIndex;
+        
       // 获取上一首歌曲
       const prevSong = playList.value[nowPlayListIndex];
 
@@ -444,8 +829,33 @@ export const usePlayerStore = defineStore('player', () => {
         console.log('上一首是B站视频，已清除URL强制重新获取');
       }
 
-    await handlePlayMusic(prevSong);
+      // 尝试播放，如果失败会返回false
-    await fetchSongs(playList.value, playListIndex.value - 5, nowPlayListIndex);
+      const success = await handlePlayMusic(prevSong);
+      
+      if (success) {
+        await fetchSongs(playList.value, playListIndex.value - 3, nowPlayListIndex);
+      } else {
+        console.error('播放上一首失败，将从播放列表中移除此歌曲');
+        // 从播放列表中移除失败的歌曲
+        const newPlayList = [...playList.value];
+        newPlayList.splice(nowPlayListIndex, 1);
+        
+        if (newPlayList.length > 0) {
+          // 更新播放列表后，重新尝试播放上一首
+          setPlayList(newPlayList);
+          // 延迟一点时间再尝试上一首，避免立即触发可能导致的无限循环
+          setTimeout(() => {
+            (prevPlay as any).isRunning = false;
+            prevPlay();
+          }, 300);
+          return;
+        }
+      }
+    } catch (error) {
+      console.error('切换上一首出错:', error);
+    } finally {
+      (prevPlay as any).isRunning = false;
+    }
   };
 
   const togglePlayMode = () => {
@@ -453,19 +863,31 @@ export const usePlayerStore = defineStore('player', () => {
     localStorage.setItem('playMode', JSON.stringify(playMode.value));
   };
 
-  const addToFavorite = async (id: number) => {
+  const addToFavorite = async (id: number | string) => {
-    if (!favoriteList.value.includes(id)) {
+    // 检查是否已存在相同的ID或内容相同的B站视频
+    const isAlreadyInList = favoriteList.value.some(existingId => 
+      typeof id === 'string' && id.includes('--') 
+        ? isBilibiliIdMatch(existingId, id)
+        : existingId === id
+    );
+    
+    if (!isAlreadyInList) {
       favoriteList.value.push(id);
       localStorage.setItem('favoriteList', JSON.stringify(favoriteList.value));
     }
   };
 
-  const removeFromFavorite = async (id: number) => {
+  const removeFromFavorite = async (id: number | string) => {
-    favoriteList.value = favoriteList.value.filter((item) => item !== id);
+    // 对于B站视频，需要根据bvid和cid来匹配
+    if (typeof id === 'string' && id.includes('--')) {
+      favoriteList.value = favoriteList.value.filter(existingId => !isBilibiliIdMatch(existingId, id));
+    } else {
+      favoriteList.value = favoriteList.value.filter(existingId => existingId !== id);
+    }
     localStorage.setItem('favoriteList', JSON.stringify(favoriteList.value));
   };
 
-  const removeFromPlayList = (id: number) => {
+  const removeFromPlayList = (id: number | string) => {
     const index = playList.value.findIndex((item) => item.id === id);
     if (index === -1) return;
 
@@ -559,6 +981,90 @@ export const usePlayerStore = defineStore('player', () => {
     localStorage.setItem('favoriteList', JSON.stringify(favoriteList.value));
   };
 
+  // 修改：处理音频播放的方法，使用事件触发机制
+  const playAudio = async () => {
+    if (!playMusicUrl.value || !playMusic.value) return null;
+    
+    try {
+      // 保存当前播放状态
+      const shouldPlay = play.value;
+      console.log('播放音频，当前播放状态:', shouldPlay ? '播放' : '暂停');
+
+      // 检查是否有保存的进度
+      let initialPosition = 0;
+      const savedProgress = JSON.parse(localStorage.getItem('playProgress') || '{}');
+      if (savedProgress.songId === playMusic.value.id) {
+        initialPosition = savedProgress.progress;
+      }
+
+      // 对于B站视频，检查URL是否有效
+      if (playMusic.value.source === 'bilibili' && (!playMusicUrl.value || playMusicUrl.value === 'undefined')) {
+        console.log('B站视频URL无效，尝试重新获取');
+
+        // 需要重新获取B站视频URL
+        if (playMusic.value.bilibiliData) {
+          try {
+            const proxyUrl = await getBilibiliAudioUrl(
+              playMusic.value.bilibiliData.bvid,
+              playMusic.value.bilibiliData.cid
+            );
+
+            // 设置URL到播放器状态
+            (playMusic.value as any).playMusicUrl = proxyUrl;
+            playMusicUrl.value = proxyUrl;
+          } catch (error) {
+            console.error('获取B站音频URL失败:', error);
+            message.error(i18n.global.t('player.playFailed'));
+            return null;
+          }
+        }
+      }
+
+      // 播放新音频，传递是否应该播放的状态
+      console.log('调用audioService.play，播放状态:', shouldPlay);
+      const newSound = await audioService.play(playMusicUrl.value, playMusic.value, shouldPlay);
+
+      // 如果有保存的进度，设置播放位置
+      if (initialPosition > 0) {
+        newSound.seek(initialPosition);
+      }
+
+      // 发布音频就绪事件，让 MusicHook.ts 来处理设置监听器
+      window.dispatchEvent(new CustomEvent('audio-ready', { detail: { sound: newSound, shouldPlay } }));
+
+      // 确保状态与 localStorage 同步
+      localStorage.setItem('currentPlayMusic', JSON.stringify(playMusic.value));
+      localStorage.setItem('currentPlayMusicUrl', playMusicUrl.value);
+      
+      return newSound;
+    } catch (error) {
+      console.error('播放音频失败:', error);
+      setPlayMusic(false);
+      
+      // 避免直接调用 nextPlay，改用延时避免无限循环
+      // 检查错误是否是由于操作锁引起的
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      if (errorMsg.includes('操作锁激活')) {
+        console.log('由于操作锁正在使用，将在500ms后重试');
+        // 操作锁错误，延迟后再尝试
+        setTimeout(() => {
+          // 检查当前播放列表是否有下一首
+          if (playList.value.length > 1) {
+            nextPlay();
+          }
+        }, 500);
+      } else {
+        // 其他错误，延迟更短时间后切换
+        setTimeout(() => {
+          nextPlay();
+        }, 100);
+      }
+      
+      message.error(i18n.global.t('player.playFailed'));
+      return null;
+    }
+  };
+
   return {
     play,
     isPlay,
@@ -571,6 +1077,17 @@ export const usePlayerStore = defineStore('player', () => {
     savedPlayProgress,
     favoriteList,
     
+    // 定时关闭相关
+    sleepTimer,
+    currentSleepTimer,
+    hasSleepTimerActive,
+    sleepTimerRemainingTime,
+    sleepTimerRemainingSongs,
+    setSleepTimerByTime,
+    setSleepTimerBySongs,
+    setSleepTimerAtPlaylistEnd,
+    clearSleepTimer,
+
     currentSong,
     isPlaying,
     currentPlayList,
@@ -589,6 +1106,7 @@ export const usePlayerStore = defineStore('player', () => {
     initializeFavoriteList,
     addToFavorite,
     removeFromFavorite,
-    removeFromPlayList
+    removeFromPlayList,
+    playAudio
   };
 });

src/renderer/store/modules/settings.ts

@@ -1,4 +1,4 @@
-import { cloneDeep } from 'lodash';
+import { cloneDeep, merge } from 'lodash';
 import { defineStore } from 'pinia';
 import { ref } from 'vue';
 
@@ -7,17 +7,6 @@ import { isElectron } from '@/utils';
 import { applyTheme, getCurrentTheme, ThemeType } from '@/utils/theme';
 
 export const useSettingsStore = defineStore('settings', () => {
-  // 初始化时先从存储中读取设置
-  const getInitialSettings = () => {
-    if (isElectron) {
-      const savedSettings = window.electron.ipcRenderer.sendSync('get-store-value', 'set');
-      return savedSettings || setDataDefault;
-    }
-    const savedSettings = localStorage.getItem('appSettings');
-    return savedSettings ? JSON.parse(savedSettings) : setDataDefault;
-  };
-
-  const setData = ref(getInitialSettings());
   const theme = ref<ThemeType>(getCurrentTheme());
   const isMobile = ref(false);
   const isMiniMode = ref(false);
@@ -29,6 +18,10 @@ export const useSettingsStore = defineStore('settings', () => {
   ]);
   const showDownloadDrawer = ref(false);
   
+  // 先声明 setData ref 但不初始化
+  const setData = ref<any>({});
+
+  // 先定义 setSetData 函数
   const setSetData = (data: any) => {
     // 合并现有设置和新设置
     const mergedData = {
@@ -44,6 +37,24 @@ export const useSettingsStore = defineStore('settings', () => {
     setData.value = cloneDeep(mergedData);
   };
 
+  // 初始化时先从存储中读取设置
+  const getInitialSettings = () => {
+    // 从存储中获取保存的设置
+    const savedSettings = isElectron
+      ? window.electron.ipcRenderer.sendSync('get-store-value', 'set')
+      : JSON.parse(localStorage.getItem('appSettings') || '{}');
+
+    // 合并默认设置和保存的设置
+    const mergedSettings = merge({}, setDataDefault, savedSettings);
+    
+    // 更新设置并返回
+    setSetData(mergedSettings);
+    return mergedSettings;
+  };
+
+  // 初始化 setData
+  setData.value = getInitialSettings();
+
   const toggleTheme = () => {
     theme.value = theme.value === 'dark' ? 'light' : 'dark';
     applyTheme(theme.value);

src/renderer/type/music.ts

@@ -24,7 +24,9 @@ export interface SongResult {
   program?: any;
   alg?: string;
   ar: Artist[];
+  artists?: Artist[];
   al: Album;
+  album?: Album;
   count: number;
   playMusicUrl?: string;
   playLoading?: boolean;
@@ -36,6 +38,10 @@ export interface SongResult {
     cid: number;
   };
   source?: 'netease' | 'bilibili';
+  // 过期时间
+  expiredAt?: number;
+  // 获取时间
+  createdAt?: number;
 }
 
 export interface Song {
@@ -233,3 +239,19 @@ export interface IArtists {
   img1v1: number;
   trans: null;
 }
+
+// 音乐源类型定义
+export type MusicSourceType = 
+  | 'tencent' 
+  | 'kugou' 
+  | 'kuwo' 
+  | 'migu' 
+  | 'netease' 
+  | 'joox' 
+  | 'ytmusic' 
+  | 'spotify' 
+  | 'qobuz' 
+  | 'deezer'
+  | 'gdmusic';
+  
+// 更多音乐相关的类型可以在这里定义

src/renderer/type/singer.ts

@@ -4,7 +4,7 @@ export interface IHotSinger {
   artists: Artist[];
 }
 
-interface Artist {
+export interface Artist {
   name: string;
   id: number;
   picId: number;
@@ -29,4 +29,6 @@ interface Artist {
   identifyTag?: any;
   alg?: any;
   fansCount?: any;
+  cover?: string;
+  avatar?: string;
 }

src/renderer/types/lyric.ts

@@ -0,0 +1,27 @@
+export interface LyricConfig {
+  hideCover: boolean;
+  centerLyrics: boolean;
+  fontSize: number;
+  letterSpacing: number;
+  lineHeight: number;
+  showTranslation: boolean;
+  theme: 'default' | 'light' | 'dark';
+  hidePlayBar: boolean;
+  pureModeEnabled: boolean;
+  hideMiniPlayBar: boolean;
+  hideLyrics: boolean;
+}
+
+export const DEFAULT_LYRIC_CONFIG: LyricConfig = {
+  hideCover: false,
+  centerLyrics: false,
+  fontSize: 22,
+  letterSpacing: 0,
+  lineHeight: 2,
+  showTranslation: true,
+  theme: 'default',
+  hidePlayBar: false,
+  hideMiniPlayBar: true,
+  pureModeEnabled: false,
+  hideLyrics: false
+};

src/renderer/types/music.ts

@@ -0,0 +1,5 @@
+// 音乐平台类型
+export type Platform = 'qq' | 'migu' | 'kugou' | 'pyncmd' | 'joox' | 'kuwo' | 'bilibili' | 'youtube' | 'gdmusic';
+
+// 默认平台列表
+export const DEFAULT_PLATFORMS: Platform[] = ['migu', 'kugou', 'pyncmd', 'bilibili', 'youtube']; 

src/renderer/utils/appShortcuts.ts

@@ -0,0 +1,235 @@
+import { onMounted, onUnmounted } from 'vue';
+
+import i18n from '@/../i18n/renderer';
+import { audioService } from '@/services/audioService';
+import { usePlayerStore, useSettingsStore } from '@/store';
+
+import { isElectron } from '.';
+import { showShortcutToast } from './shortcutToast';
+
+// 添加一个简单的防抖机制
+let actionTimeout: NodeJS.Timeout | null = null;
+const ACTION_DELAY = 300; // 毫秒
+
+interface ShortcutConfig {
+  key: string;
+  enabled: boolean;
+  scope: 'global' | 'app';
+}
+
+interface ShortcutsConfig {
+  [key: string]: ShortcutConfig;
+}
+
+const { t } = i18n.global;
+
+// 全局存储快捷键配置
+let appShortcuts: ShortcutsConfig = {};
+
+/**
+ * 处理快捷键动作
+ * @param action 快捷键动作
+ */
+export async function handleShortcutAction(action: string) {
+  // 如果存在未完成的动作，则忽略当前请求
+  if (actionTimeout) {
+    console.log('忽略快速连续的动作请求:', action);
+    return;
+  }
+
+  // 设置防抖锁
+  actionTimeout = setTimeout(() => {
+    actionTimeout = null;
+  }, ACTION_DELAY);
+
+  const playerStore = usePlayerStore();
+  const settingsStore = useSettingsStore();
+
+  const currentSound = audioService.getCurrentSound();
+  const showToast = (message: string, iconName: string) => {
+    if (settingsStore.isMiniMode) {
+      return;
+    }
+    showShortcutToast(message, iconName);
+  };
+
+  try {
+    switch (action) {
+      case 'togglePlay':
+        if (playerStore.play) {
+          await audioService.pause();
+          showToast(t('player.playBar.pause'), 'ri-pause-circle-line');
+        } else {
+          await audioService.play();
+          showToast(t('player.playBar.play'), 'ri-play-circle-line');
+        }
+        break;
+      case 'prevPlay':
+        await playerStore.prevPlay();
+        showToast(t('player.playBar.prev'), 'ri-skip-back-line');
+        break;
+      case 'nextPlay':
+        await playerStore.nextPlay();
+        showToast(t('player.playBar.next'), 'ri-skip-forward-line');
+        break;
+      case 'volumeUp':
+        if (currentSound && currentSound?.volume() < 1) {
+          currentSound?.volume((currentSound?.volume() || 0) + 0.1);
+          showToast(
+            `${t('player.playBar.volume')}${Math.round((currentSound?.volume() || 0) * 100)}%`,
+            'ri-volume-up-line'
+          );
+        }
+        break;
+      case 'volumeDown':
+        if (currentSound && currentSound?.volume() > 0) {
+          currentSound?.volume((currentSound?.volume() || 0) - 0.1);
+          showToast(
+            `${t('player.playBar.volume')}${Math.round((currentSound?.volume() || 0) * 100)}%`,
+            'ri-volume-down-line'
+          );
+        }
+        break;
+      case 'toggleFavorite': {
+        const isFavorite = playerStore.favoriteList.includes(Number(playerStore.playMusic.id));
+        const numericId = Number(playerStore.playMusic.id);
+        if (isFavorite) {
+          playerStore.removeFromFavorite(numericId);
+        } else {
+          playerStore.addToFavorite(numericId);
+        }
+        showToast(
+          isFavorite
+            ? t('player.playBar.favorite', { name: playerStore.playMusic.name })
+            : t('player.playBar.unFavorite', { name: playerStore.playMusic.name }),
+          isFavorite ? 'ri-heart-fill' : 'ri-heart-line'
+        );
+        break;
+      }
+      default:
+        console.log('未知的快捷键动作:', action);
+        break;
+    }
+  } catch (error) {
+    console.error(`执行快捷键动作 ${action} 时出错:`, error);
+  } finally {
+    // 确保在出错时也能清除超时
+    if (actionTimeout) {
+      clearTimeout(actionTimeout);
+      actionTimeout = null;
+    }
+  }
+}
+
+/**
+ * 检查按键是否匹配快捷键
+ * @param e KeyboardEvent
+ * @param shortcutKey 快捷键字符串
+ * @returns 是否匹配
+ */
+function matchShortcut(e: KeyboardEvent, shortcutKey: string): boolean {
+  const keys = shortcutKey.split('+');
+  const pressedKey = e.key.length === 1 ? e.key.toUpperCase() : e.key;
+
+  // 检查修饰键
+  const hasCommandOrControl = keys.includes('CommandOrControl');
+  const hasAlt = keys.includes('Alt');
+  const hasShift = keys.includes('Shift');
+
+  // 检查主键
+  let mainKey = keys.find((k) => !['CommandOrControl', 'Alt', 'Shift'].includes(k));
+  if (!mainKey) return false;
+
+  // 处理特殊键
+  if (mainKey === 'Left' && pressedKey === 'ArrowLeft') mainKey = 'ArrowLeft';
+  if (mainKey === 'Right' && pressedKey === 'ArrowRight') mainKey = 'ArrowRight';
+  if (mainKey === 'Up' && pressedKey === 'ArrowUp') mainKey = 'ArrowUp';
+  if (mainKey === 'Down' && pressedKey === 'ArrowDown') mainKey = 'ArrowDown';
+
+  // 检查是否所有条件都匹配
+  return (
+    hasCommandOrControl === (e.ctrlKey || e.metaKey) &&
+    hasAlt === e.altKey &&
+    hasShift === e.shiftKey &&
+    mainKey === pressedKey
+  );
+}
+
+/**
+ * 全局键盘事件处理函数
+ * @param e KeyboardEvent
+ */
+function handleKeyDown(e: KeyboardEvent) {
+  // 如果在输入框中则不处理快捷键
+  if (['INPUT', 'TEXTAREA'].includes((e.target as HTMLElement).tagName)) {
+    return;
+  }
+
+  Object.entries(appShortcuts).forEach(([action, config]) => {
+    if (config.enabled && config.scope === 'app' && matchShortcut(e, config.key)) {
+      e.preventDefault();
+      handleShortcutAction(action);
+    }
+  });
+}
+
+/**
+ * 更新应用内快捷键
+ * @param shortcuts 快捷键配置
+ */
+export function updateAppShortcuts(shortcuts: ShortcutsConfig) {
+  appShortcuts = shortcuts;
+}
+
+/**
+ * 初始化应用内快捷键
+ */
+export function initAppShortcuts() {
+  if (isElectron) {
+    // 监听全局快捷键事件
+    window.electron.ipcRenderer.on('global-shortcut', async (_, action: string) => {
+      handleShortcutAction(action);
+    });
+
+    // 监听应用内快捷键更新
+    window.electron.ipcRenderer.on('update-app-shortcuts', (_, shortcuts: ShortcutsConfig) => {
+      updateAppShortcuts(shortcuts);
+    });
+
+    // 获取初始快捷键配置
+    const storedShortcuts = window.electron.ipcRenderer.sendSync('get-store-value', 'shortcuts');
+    if (storedShortcuts) {
+      updateAppShortcuts(storedShortcuts);
+    }
+
+    // 添加键盘事件监听
+    document.addEventListener('keydown', handleKeyDown);
+  }
+}
+
+/**
+ * 清理应用内快捷键
+ */
+export function cleanupAppShortcuts() {
+  if (isElectron) {
+    // 移除全局事件监听
+    window.electron.ipcRenderer.removeAllListeners('global-shortcut');
+    window.electron.ipcRenderer.removeAllListeners('update-app-shortcuts');
+
+    // 移除键盘事件监听
+    document.removeEventListener('keydown', handleKeyDown);
+  }
+}
+
+/**
+ * 使用应用内快捷键的组合函数
+ */
+export function useAppShortcuts() {
+  onMounted(() => {
+    initAppShortcuts();
+  });
+
+  onUnmounted(() => {
+    cleanupAppShortcuts();
+  });
+}

src/renderer/utils/shortcut.ts

@@ -1,81 +0,0 @@
-import i18n from '@/../i18n/renderer';
-import { audioService } from '@/services/audioService';
-import { usePlayerStore, useSettingsStore } from '@/store';
-
-import { isElectron } from '.';
-import { showShortcutToast } from './shortcutToast';
-
-const { t } = i18n.global;
-
-export function initShortcut() {
-  if (isElectron) {
-    window.electron.ipcRenderer.on('global-shortcut', async (_, action: string) => {
-      const playerStore = usePlayerStore();
-      const settingsStore = useSettingsStore();
-
-      const currentSound = audioService.getCurrentSound();
-      const showToast = (message: string, iconName: string) => {
-        if (settingsStore.isMiniMode) {
-          return;
-        }
-        showShortcutToast(message, iconName);
-      };
-      switch (action) {
-        case 'togglePlay':
-          if (playerStore.play) {
-            await audioService.pause();
-            showToast(t('player.playBar.pause'), 'ri-pause-circle-line');
-          } else {
-            await audioService.play();
-            showToast(t('player.playBar.play'), 'ri-play-circle-line');
-          }
-          break;
-        case 'prevPlay':
-          playerStore.prevPlay();
-          showToast(t('player.playBar.prev'), 'ri-skip-back-line');
-          break;
-        case 'nextPlay':
-          playerStore.nextPlay();
-          showToast(t('player.playBar.next'), 'ri-skip-forward-line');
-          break;
-        case 'volumeUp':
-          if (currentSound && currentSound?.volume() < 1) {
-            currentSound?.volume((currentSound?.volume() || 0) + 0.1);
-            showToast(
-              `${t('player.playBar.volume')}${Math.round((currentSound?.volume() || 0) * 100)}%`,
-              'ri-volume-up-line'
-            );
-          }
-          break;
-        case 'volumeDown':
-          if (currentSound && currentSound?.volume() > 0) {
-            currentSound?.volume((currentSound?.volume() || 0) - 0.1);
-            showToast(
-              `${t('player.playBar.volume')}${Math.round((currentSound?.volume() || 0) * 100)}%`,
-              'ri-volume-down-line'
-            );
-          }
-          break;
-        case 'toggleFavorite': {
-          const isFavorite = playerStore.favoriteList.includes(Number(playerStore.playMusic.id));
-          const numericId = Number(playerStore.playMusic.id);
-          if (isFavorite) {
-            playerStore.removeFromFavorite(numericId);
-          } else {
-            playerStore.addToFavorite(numericId);
-          }
-          showToast(
-            isFavorite
-              ? t('player.playBar.favorite', { name: playerStore.playMusic.name })
-              : t('player.playBar.unFavorite', { name: playerStore.playMusic.name }),
-            isFavorite ? 'ri-heart-fill' : 'ri-heart-line'
-          );
-          break;
-        }
-        default:
-          console.log('未知的快捷键动作:', action);
-          break;
-      }
-    });
-  }
-}

src/renderer/views/artist/detail.vue

@@ -33,6 +33,7 @@
               @play="handlePlay"
             />
             <div v-if="songLoading" class="loading-more">{{ t('common.loading') }}</div>
+            <div v-else-if="songPage.hasMore" ref="songsLoadMoreRef" class="load-more-trigger"></div>
           </div>
         </div>
       </n-tab-pane>
@@ -54,6 +55,7 @@
               }"
             />
             <div v-if="albumLoading" class="loading-more">{{ t('common.loading') }}</div>
+            <div v-else-if="albumPage.hasMore" ref="albumsLoadMoreRef" class="load-more-trigger"></div>
           </div>
         </div>
       </n-tab-pane>
@@ -70,7 +72,7 @@
 </template>
 
 <script setup lang="ts">
-import { useDateFormat, useThrottleFn } from '@vueuse/core';
+import { useDateFormat } from '@vueuse/core';
 import { computed, onMounted, onUnmounted, ref, watch } from 'vue';
 import { useI18n } from 'vue-i18n';
 import { useRoute } from 'vue-router';
@@ -114,6 +116,12 @@ const albumPage = ref({
   hasMore: true
 });
 
+// 无限滚动引用
+const songsLoadMoreRef = ref<HTMLElement | null>(null);
+const albumsLoadMoreRef = ref<HTMLElement | null>(null);
+let songsObserver: IntersectionObserver | null = null;
+let albumsObserver: IntersectionObserver | null = null;
+
 // 加载歌手信息
 const loadArtistInfo = async () => {
   if (!artistId.value) return;
@@ -138,12 +146,12 @@ const loadArtistInfo = async () => {
 const resetPagination = () => {
   songPage.value = {
     page: 1,
-    pageSize: 30,
+    pageSize: 50,
     hasMore: true
   };
   albumPage.value = {
     page: 1,
-    pageSize: 30,
+    pageSize: 50,
     hasMore: true
   };
   songs.value = [];
@@ -181,6 +189,8 @@ const loadSongs = async () => {
       songs.value = page === 1 ? newSongs : [...songs.value, ...newSongs];
       songPage.value.hasMore = newSongs.length === pageSize;
       songPage.value.page++;
+    } else {
+      songPage.value.hasMore = false;
     }
   } catch (error) {
     console.error('加载歌曲失败:', error);
@@ -207,6 +217,8 @@ const loadAlbums = async () => {
       albums.value = page === 1 ? newAlbums : [...albums.value, ...newAlbums];
       albumPage.value.hasMore = newAlbums.length === pageSize;
       albumPage.value.page++;
+    } else {
+      albumPage.value.hasMore = false;
     }
   } catch (error) {
     console.error('加载专辑失败:', error);
@@ -229,29 +241,64 @@ const handlePlay = () => {
   );
 };
 
-// 添加滚动处理函数
+// 设置无限滚动观察器
-const handleScroll = useThrottleFn(() => {
+const setupIntersectionObservers = () => {
-  const scrollTop = window.pageYOffset || document.documentElement.scrollTop;
+  // 清除现有的观察器
-  const windowHeight = window.innerHeight;
+  if (songsObserver) songsObserver.disconnect();
-  const documentHeight = document.documentElement.scrollHeight;
+  if (albumsObserver) albumsObserver.disconnect();
 
-  if (documentHeight - (scrollTop + windowHeight) < 100) {
+  // 创建歌曲观察器
-    if (activeTab.value === 'songs') {
+  songsObserver = new IntersectionObserver((entries) => {
+    if (entries[0].isIntersecting && !songLoading.value && songPage.value.hasMore) {
       loadSongs();
-    } else if (activeTab.value === 'albums') {
+    }
+  }, { threshold: 0.1 });
+
+  // 创建专辑观察器
+  albumsObserver = new IntersectionObserver((entries) => {
+    if (entries[0].isIntersecting && !albumLoading.value && albumPage.value.hasMore) {
       loadAlbums();
     }
-  }
+  }, { threshold: 0.1 });
-}, 200);
+
+  // 监听标签页更改，重新设置观察器
+  watch(activeTab, (newTab) => {
+    nextTick(() => {
+      if (newTab === 'songs' && songsLoadMoreRef.value && songPage.value.hasMore) {
+        songsObserver?.observe(songsLoadMoreRef.value);
+      } else if (newTab === 'albums' && albumsLoadMoreRef.value && albumPage.value.hasMore) {
+        albumsObserver?.observe(albumsLoadMoreRef.value);
+      }
+    });
+  });
+
+  // 监听引用元素的变化
+  watch(songsLoadMoreRef, (el) => {
+    if (el && activeTab.value === 'songs' && songPage.value.hasMore) {
+      songsObserver?.observe(el);
+    }
+  });
+
+  watch(albumsLoadMoreRef, (el) => {
+    if (el && activeTab.value === 'albums' && albumPage.value.hasMore) {
+      albumsObserver?.observe(el);
+    }
+  });
+};
 
-// 监听页面滚动
 onMounted(() => {
   loadArtistInfo();
-  window.addEventListener('scroll', handleScroll);
+  
+  // 添加nextTick以确保DOM已更新
+  nextTick(() => {
+    setupIntersectionObservers();
+  });
 });
 
 onUnmounted(() => {
-  window.removeEventListener('scroll', handleScroll);
+  // 清理观察器
+  if (songsObserver) songsObserver.disconnect();
+  if (albumsObserver) albumsObserver.disconnect();
 });
 
 // 监听路由参数变化
@@ -260,6 +307,10 @@ watch(
   (newId) => {
     if (newId) {
       loadArtistInfo();
+      // 添加nextTick以确保DOM已更新
+      nextTick(() => {
+        setupIntersectionObservers();
+      });
     }
   }
 );
@@ -325,6 +376,10 @@ watch(
     @apply text-center py-4 text-gray-500 dark:text-gray-400;
   }
 
+  .load-more-trigger {
+    @apply h-4 w-full;
+  }
+
   .artist-description {
     .description-content {
       @apply text-sm leading-relaxed whitespace-pre-wrap;

src/renderer/views/bilibili/BilibiliPlayer.vue

@@ -233,7 +233,7 @@ const loadVideoSource = async () => {
 
         // 其他分P创建占位对象，稍后按需加载
         return {
-          id: `${videoDetail.value!.aid}--${page.cid}`, // 使用aid+cid作为唯一ID
+          id: `${bvid.value}--${page.page}--${page.cid}`, // 使用bvid--pid--cid作为唯一ID
           name: `${page.part || ''} - ${videoDetail.value!.title}`,
           picUrl: getBilibiliProxyUrl(videoDetail.value!.pic),
           type: 0,
@@ -242,7 +242,7 @@ const loadVideoSource = async () => {
           source: 'bilibili', // 设置来源为B站
           song: {
             name: `${page.part || ''} - ${videoDetail.value!.title}`,
-            id: `${videoDetail.value!.aid}--${page.cid}`,
+            id: `${bvid.value}--${page.page}--${page.cid}`,
             ar: [
               {
                 name: videoDetail.value!.owner.name,
@@ -286,7 +286,7 @@ const createSongFromBilibiliVideo = (): SongResult => {
   const title = `${pageName} - ${videoDetail.value.title}`;
 
   return {
-    id: `${videoDetail.value.aid}--${currentPage.value.cid}`, // 使用aid+cid作为唯一ID
+    id: `${bvid.value}--${currentPage.value.page}--${currentPage.value.cid}`, // 使用bvid--pid--cid作为唯一ID
     name: title,
     picUrl: getBilibiliProxyUrl(videoDetail.value.pic),
     type: 0,
@@ -297,7 +297,7 @@ const createSongFromBilibiliVideo = (): SongResult => {
     // playMusicUrl属性稍后通过loadSongUrl函数添加
     song: {
       name: title,
-      id: `${videoDetail.value.aid}--${currentPage.value.cid}`,
+      id: `${bvid.value}--${currentPage.value.page}--${currentPage.value.cid}`,
       ar: [
         {
           name: videoDetail.value.owner.name,

src/renderer/views/favorite/index.vue

@@ -54,12 +54,12 @@
         <div v-if="favoriteList.length === 0" class="empty-tip">
           <n-empty :description="t('favorite.emptyTip')" />
         </div>
-        <div v-else class="favorite-list">
+        <div v-else class="favorite-list" :class="{ 'max-w-[400px]': isComponent }">
           <song-item
             v-for="(song, index) in favoriteSongs"
             :key="song.id"
             :item="song"
-            :favorite="!isComponent"
+            :favorite="false"
             :class="setAnimationClass('animate__bounceInLeft')"
             :style="getItemAnimationDelay(index)"
             :selectable="isSelecting"
@@ -90,6 +90,7 @@ import { useI18n } from 'vue-i18n';
 import { useRouter } from 'vue-router';
 
 import { getMusicDetail } from '@/api/music';
+import { getBilibiliProxyUrl, getBilibiliVideoDetail } from '@/api/bilibili';
 import SongItem from '@/components/common/SongItem.vue';
 import { getSongUrl } from '@/hooks/MusicListHook';
 import { usePlayerStore } from '@/store';
@@ -193,11 +194,18 @@ const handleBatchDownload = async () => {
         failCount++;
         return;
       }
-
+      const songData = cloneDeep(song);
+      const songInfo = {
+        ...songData,
+        ar: songData.ar || songData.song?.artists,
+        downloadTime: Date.now()
+      };
+      console.log('songInfo', songInfo);
+      console.log('song', song);
       window.electron.ipcRenderer.send('download-music', {
         url,
         filename: `${song.name} - ${(song.ar || song.song?.artists)?.map((a) => a.name).join(',')}`,
-        songInfo: cloneDeep(song),
+        songInfo,
         type
       });
     });
@@ -210,7 +218,7 @@ const handleBatchDownload = async () => {
 };
 
 // 无限滚动相关
-const pageSize = 16;
+const pageSize = 100;
 const currentPage = ref(1);
 
 const props = defineProps({
@@ -224,6 +232,7 @@ const props = defineProps({
 const getCurrentPageIds = () => {
   const startIndex = (currentPage.value - 1) * pageSize;
   const endIndex = startIndex + pageSize;
+  // 返回原始ID，不进行类型转换
   return favoriteList.value.slice(startIndex, endIndex);
 };
 
@@ -241,12 +250,107 @@ const getFavoriteSongs = async () => {
   loading.value = true;
   try {
     const currentIds = getCurrentPageIds();
-    const res = await getMusicDetail(currentIds);
+    console.log('currentIds', currentIds);
+    
+    // 分离网易云音乐ID和B站视频ID
+    const musicIds = currentIds.filter((id) => typeof id === 'number') as number[];
+    // B站ID可能是字符串格式（包含"--"）或特定数字ID，如113911642789603
+    const bilibiliIds = currentIds.filter((id) => typeof id === 'string');
+    
+    console.log('处理数据:', {
+      musicIds,
+      bilibiliIds
+    });
+    
+    // 处理网易云音乐数据
+    let neteaseSongs: SongResult[] = [];
+    if (musicIds.length > 0) {
+      const res = await getMusicDetail(musicIds);
       if (res.data.songs) {
-      const newSongs = res.data.songs.map((song: SongResult) => ({
+        neteaseSongs = res.data.songs.map((song: SongResult) => ({
           ...song,
-        picUrl: song.al?.picUrl || ''
+          picUrl: song.al?.picUrl || '',
+          source: 'netease'
         }));
+      }
+    }
+    
+    // 处理B站视频数据
+    const bilibiliSongs: SongResult[] = [];
+    for (const biliId of bilibiliIds) {
+      const strBiliId = String(biliId);
+      console.log(`处理B站ID: ${strBiliId}`);
+      
+      if (strBiliId.includes('--')) {
+        // 从ID中提取B站视频信息 (bvid--pid--cid格式)
+        try {
+          const [bvid, pid, cid] = strBiliId.split('--');
+          if (!bvid || !pid || !cid) {
+            console.warn(`B站ID格式错误: ${strBiliId}, 正确格式应为 bvid--pid--cid`);
+            continue;
+          }
+          
+          const res = await getBilibiliVideoDetail(bvid);
+          const videoDetail = res.data;
+          
+          // 找到对应的分P
+          const page = videoDetail.pages.find(p => p.cid === Number(cid));
+          if (!page) {
+            console.warn(`未找到对应的分P: cid=${cid}`);
+            continue;
+          }
+          
+          const songData = {
+            id: strBiliId,
+            name: `${page.part || ''} - ${videoDetail.title}`,
+            picUrl: getBilibiliProxyUrl(videoDetail.pic),
+            ar: [
+              {
+                name: videoDetail.owner.name,
+                id: videoDetail.owner.mid
+              }
+            ],
+            al: {
+              name: videoDetail.title,
+              picUrl: getBilibiliProxyUrl(videoDetail.pic)
+            },
+            source: 'bilibili',
+            bilibiliData: {
+              bvid,
+              cid: Number(cid)
+            }
+          } as SongResult;
+          
+          bilibiliSongs.push(songData);
+        } catch (error) {
+          console.error(`获取B站视频详情失败 (${strBiliId}):`, error);
+        }
+      }
+    }
+    
+    console.log('获取数据统计:', {
+      neteaseSongs: neteaseSongs.length,
+      bilibiliSongs: bilibiliSongs.length
+    });
+    
+    // 合并数据，保持原有顺序
+    const newSongs = currentIds
+      .map(id => {
+        const strId = String(id);
+        
+        // 查找B站视频
+        if (typeof id === 'string') {
+          const found = bilibiliSongs.find(song => String(song.id) === strId);
+          if (found) return found;
+        }
+        
+        // 查找网易云音乐
+        const found = neteaseSongs.find(song => String(song.id) === strId);
+        return found;
+      })
+      .filter((song): song is SongResult => !!song);
+    
+    console.log(`最终歌曲列表: ${newSongs.length}首`);
 
     // 追加新数据而不是替换
     if (currentPage.value === 1) {
@@ -257,7 +361,6 @@ const getFavoriteSongs = async () => {
 
     // 判断是否还有更多数据
     noMore.value = favoriteSongs.value.length >= favoriteList.value.length;
-    }
   } catch (error) {
     console.error('获取收藏歌曲失败:', error);
   } finally {

src/renderer/views/history/index.vue

@@ -35,6 +35,7 @@
 import { onMounted, ref } from 'vue';
 import { useI18n } from 'vue-i18n';
 
+import { getBilibiliProxyUrl, getBilibiliVideoDetail } from '@/api/bilibili';
 import { getMusicDetail } from '@/api/music';
 import SongItem from '@/components/common/SongItem.vue';
 import { useMusicHistory } from '@/hooks/MusicHistoryHook';
@@ -55,7 +56,7 @@ const displayList = ref<SongResult[]>([]);
 const playerStore = usePlayerStore();
 
 // 无限滚动相关配置
-const pageSize = 20;
+const pageSize = 100;
 const currentPage = ref(1);
 
 // 获取当前页的音乐详情
@@ -71,18 +72,81 @@ const getHistorySongs = async () => {
     const endIndex = startIndex + pageSize;
     const currentPageItems = musicList.value.slice(startIndex, endIndex);
 
-    const currentIds = currentPageItems.map((item) => item.id as number);
+    // 分离网易云音乐和B站视频
-    const res = await getMusicDetail(currentIds);
+    const neteaseItems = currentPageItems.filter((item) => item.source !== 'bilibili');
+    const bilibiliItems = currentPageItems.filter((item) => item.source === 'bilibili');
 
+    // 处理网易云音乐
+    let neteaseSongs: SongResult[] = [];
+    if (neteaseItems.length > 0) {
+      const currentIds = neteaseItems.map((item) => item.id as number);
+      const res = await getMusicDetail(currentIds);
       if (res.data.songs) {
-      const newSongs = res.data.songs.map((song: SongResult) => {
+        neteaseSongs = res.data.songs.map((song: SongResult) => {
-        const historyItem = currentPageItems.find((item) => item.id === song.id);
+          const historyItem = neteaseItems.find((item) => item.id === song.id);
           return {
             ...song,
             picUrl: song.al?.picUrl || '',
-          count: historyItem?.count || 0
+            count: historyItem?.count || 0,
+            source: 'netease'
           };
         });
+      }
+    }
+
+    // 处理B站视频
+    const bilibiliSongs: SongResult[] = [];
+    for (const item of bilibiliItems) {
+      try {
+        const bvid = item.bilibiliData?.bvid;
+        if (!bvid) continue;
+
+        const res = await getBilibiliVideoDetail(bvid);
+        const videoDetail = res.data;
+
+        // 找到对应的分P
+        const page = videoDetail.pages.find((p) => p.cid === item.bilibiliData?.cid);
+        if (!page) continue;
+
+        bilibiliSongs.push({
+          id: `${bvid}--${page.page}--${page.cid}`,
+          name: `${page.part || ''} - ${videoDetail.title}`,
+          picUrl: getBilibiliProxyUrl(videoDetail.pic),
+          ar: [
+            {
+              name: videoDetail.owner.name,
+              id: videoDetail.owner.mid
+            }
+          ],
+          al: {
+            name: videoDetail.title,
+            picUrl: getBilibiliProxyUrl(videoDetail.pic)
+          },
+          source: 'bilibili',
+          count: item.count || 0,
+          bilibiliData: {
+            bvid,
+            cid: page.cid
+          }
+        } as SongResult);
+      } catch (error) {
+        console.error('获取B站视频详情失败:', error);
+      }
+    }
+
+    // 合并两种来源的数据，并保持原有顺序
+    const newSongs = currentPageItems
+      .map((item) => {
+        if (item.source === 'bilibili') {
+          return bilibiliSongs.find(
+            (song) =>
+              song.bilibiliData?.bvid === item.bilibiliData?.bvid &&
+              song.bilibiliData?.cid === item.bilibiliData?.cid
+          );
+        }
+        return neteaseSongs.find((song) => song.id === item.id);
+      })
+      .filter((song): song is SongResult => !!song);
 
     if (currentPage.value === 1) {
       displayList.value = newSongs;
@@ -91,7 +155,6 @@ const getHistorySongs = async () => {
     }
 
     noMore.value = displayList.value.length >= musicList.value.length;
-    }
   } catch (error) {
     console.error(t('history.getHistoryFailed'), error);
   } finally {

src/renderer/views/lyric/index.vue

@@ -59,7 +59,7 @@
               v-for="(line, index) in staticData.lrcArray"
               :key="index"
               class="lyric-line"
-              :style="lyricLineStyle"
+              :style="getDynamicLineStyle(line)"
               :class="{
                 'lyric-line-current': index === currentIndex,
                 'lyric-line-passed': index < currentIndex,
@@ -172,6 +172,16 @@ const handleMouseLeave = () => {
   if (!lyricSetting.value.isLock) return;
   isHovering.value = false;
   windowData.electron.ipcRenderer.send('set-ignore-mouse', false);
+  
+  // 强制重置背景色
+  const lyricWindow = document.querySelector('.lyric-window') as HTMLElement;
+  if (lyricWindow) {
+    lyricWindow.style.background = 'transparent';
+    // 使用 requestAnimationFrame 确保在下一帧重置
+    requestAnimationFrame(() => {
+      lyricWindow.style.background = 'transparent';
+    });
+  }
 };
 
 // 监听锁定状态变化
@@ -207,16 +217,41 @@ const wrapperStyle = computed(() => {
   // 计算容器中心点
   const containerCenter = containerHeight.value / 2;
 
-  // 计算当前行到顶部的距离（包含padding）
+  // 计算每行的实际高度
-  const currentLineTop =
+  const getLineHeight = (line: { text: string; trText: string }) => {
-    currentIndex.value * lineHeight.value + containerHeight.value * 0.2 + lineHeight.value; // 加上顶部padding
+    const baseHeight = lineHeight.value;
+    if (line.trText) {
+      const extraHeight = Math.round(fontSize.value * 0.6 * 1.4);
+      return baseHeight + extraHeight;
+    }
+    return baseHeight;
+  };
+
+  // 计算当前行之前所有行的累积高度
+  let accumulatedHeight = containerHeight.value * 0.2; // 顶部padding
+  for (let i = 0; i < currentIndex.value; i++) {
+    if (i < staticData.value.lrcArray.length) {
+      accumulatedHeight += getLineHeight(staticData.value.lrcArray[i]);
+    } else {
+      accumulatedHeight += lineHeight.value;
+    }
+  }
+
+  // 加上当前行的一半高度，使其居中
+  const currentLineHeight =
+    currentIndex.value < staticData.value.lrcArray.length
+      ? getLineHeight(staticData.value.lrcArray[currentIndex.value])
+      : lineHeight.value;
+  accumulatedHeight += currentLineHeight;
 
   // 计算偏移量，使当前行居中
-  const targetOffset = containerCenter - currentLineTop;
+  const targetOffset = containerCenter - accumulatedHeight;
 
   // 计算内容总高度（包含padding）
-  const contentHeight =
+  let contentHeight = containerHeight.value * 0.4; // 上下padding总和
-    staticData.value.lrcArray.length * lineHeight.value + containerHeight.value * 0.4; // 上下padding各20vh
+  for (const line of staticData.value.lrcArray) {
+    contentHeight += getLineHeight(line);
+  }
 
   // 计算最小和最大偏移量
   const minOffset = -(contentHeight - containerHeight.value);
@@ -231,9 +266,25 @@ const wrapperStyle = computed(() => {
   };
 });
 
-const lyricLineStyle = computed(() => ({
+// 新增：根据是否有翻译文本动态计算每行的样式
-  height: `${lineHeight.value}px`
+const getDynamicLineStyle = (line: { text: string; trText: string }) => {
-}));
+  // 默认行高
+  const defaultHeight = lineHeight.value;
+
+  // 如果有翻译文本，增加额外高度
+  if (line.trText) {
+    // 计算翻译文本的额外高度 (字体大小的0.6倍 * 行高比例1.4)
+    const extraHeight = Math.round(fontSize.value * 0.6 * 1.4);
+    return {
+      height: `${defaultHeight + extraHeight}px`
+    };
+  }
+
+  return {
+    height: `${defaultHeight}px`
+  };
+};
+
 // 更新容器高度和行高
 const updateContainerHeight = () => {
   if (!containerRef.value) return;
@@ -592,8 +643,12 @@ const handleNext = () => {
 </script>
 
 <style scoped>
-body {
+html,
+body,
+#app {
   background-color: transparent !important;
+  box-shadow: none !important;
+  border: none !important;
 }
 </style>
 
@@ -603,14 +658,13 @@ body {
   height: 100vh;
   position: relative;
   overflow: hidden;
-  background: transparent;
+  background: transparent !important;
   user-select: none;
-  transition: background-color 0.2s ease;
+  transition: background-color 0.3s ease;
   cursor: default;
   border-radius: 14px;
 
   &:hover {
-    background: rgba(44, 44, 44, 0.466);
     .control-bar {
       &-show {
         opacity: 1;
@@ -625,16 +679,22 @@ body {
 
   &.dark {
     --text-color: #ffffff;
-    --text-secondary: rgba(255, 255, 255, 0.6);
+    --text-secondary: #ffffffea;
     --highlight-color: #1db954;
     --control-bg: rgba(124, 124, 124, 0.3);
+    &:hover {
+      background: rgba(44, 44, 44, 0.466) !important;
+    }
   }
 
   &.light {
     --text-color: #333333;
-    --text-secondary: rgba(51, 51, 51, 0.6);
+    --text-secondary: #39393989;
     --highlight-color: #1db954;
     --control-bg: rgba(255, 255, 255, 0.3);
+    &:hover {
+      background: rgba(0, 0, 0, 0.434) !important;
+    }
   }
 }
 

src/renderer/views/set/index.vue

@@ -150,6 +150,39 @@
               />
             </div>
 
+            <div class="set-item" v-if="isElectron">
+              <div>
+                <div class="set-item-title">{{ t('settings.playback.musicSources') }}</div>
+                <div class="set-item-content">
+                  <div class="flex items-center gap-2">
+                    <n-switch v-model:value="setData.enableMusicUnblock">
+                      <template #checked>{{ t('common.on') }}</template>
+                      <template #unchecked>{{ t('common.off') }}</template>
+                    </n-switch>
+                    <span>{{ t('settings.playback.musicUnblockEnableDesc') }}</span>
+                  </div>
+                  <div v-if="setData.enableMusicUnblock" class="mt-2">
+                    <div class="text-sm">
+                      <span class="text-gray-500">{{ t('settings.playback.selectedMusicSources') }}</span>
+                      <span v-if="musicSources.length > 0" class="text-gray-400">
+                        {{ musicSources.join(', ') }}
+                      </span>
+                      <span v-else class="text-red-500 text-xs">
+                        {{ t('settings.playback.noMusicSources') }}
+                      </span>
+                    </div>
+                  </div>
+                </div>
+              </div>
+              <n-button 
+                size="small" 
+                :disabled="!setData.enableMusicUnblock"
+                @click="showMusicSourcesModal = true"
+              >
+                {{ t('settings.playback.configureMusicSources') }}
+              </n-button>
+            </div>
+
             <div class="set-item">
               <div>
                 <div class="set-item-title">{{ t('settings.playback.autoPlay') }}</div>
@@ -211,6 +244,19 @@
               </div>
             </div>
 
+            <div class="set-item">
+              <div>
+                <div class="set-item-title">{{ t('settings.application.unlimitedDownload') }}</div>
+                <div class="set-item-content">
+                  <n-switch v-model:value="setData.unlimitedDownload" class="mr-2">
+                    <template #checked>{{ t('common.on') }}</template>
+                    <template #unchecked>{{ t('common.off') }}</template>
+                  </n-switch>
+                  {{ t('settings.application.unlimitedDownloadDesc') }}
+                </div>
+              </div>
+            </div>
+
             <div class="set-item">
               <div>
                 <div class="set-item-title">{{ t('settings.application.downloadPath') }}</div>
@@ -225,6 +271,16 @@
                 }}</n-button>
               </div>
             </div>
+
+            <div class="set-item">
+              <div>
+                <div class="set-item-title">{{ t('settings.application.remoteControl') }}</div>
+                <div class="set-item-content">{{ t('settings.application.remoteControlDesc') }}</div>
+              </div>
+              <n-button size="small" @click="showRemoteControlModal = true">{{
+                t('common.configure')
+              }}</n-button>
+            </div>
           </div>
         </div>
 
@@ -372,97 +428,40 @@
       <play-bottom />
     </n-scrollbar>
 
+    <template v-if="isElectron">
       <!-- 快捷键设置弹窗 -->
       <shortcut-settings v-model:show="showShortcutModal" @change="handleShortcutsChange" />
 
       <!-- 代理设置弹窗 -->
-    <n-modal
+      <proxy-settings 
         v-model:show="showProxyModal" 
-      preset="dialog"
+        :config="proxyForm"
-      :title="t('settings.network.proxy')"
+        @confirm="handleProxyConfirm"
-      :positive-text="t('common.confirm')"
-      :negative-text="t('common.cancel')"
-      :show-icon="false"
-      @positive-click="handleProxyConfirm"
-      @negative-click="showProxyModal = false"
-    >
-      <n-form
-        ref="formRef"
-        :model="proxyForm"
-        :rules="proxyRules"
-        label-placement="left"
-        label-width="80"
-        require-mark-placement="right-hanging"
-      >
-        <n-form-item :label="t('settings.network.proxy')" path="protocol">
-          <n-select
-            v-model:value="proxyForm.protocol"
-            :options="[
-              { label: 'HTTP', value: 'http' },
-              { label: 'HTTPS', value: 'https' },
-              { label: 'SOCKS5', value: 'socks5' }
-            ]"
       />
-        </n-form-item>
+
-        <n-form-item :label="t('settings.network.proxyHost')" path="host">
+      <!-- 音源设置弹窗 -->
-          <n-input
+      <music-source-settings
-            v-model:value="proxyForm.host"
+        v-model:show="showMusicSourcesModal"
-            :placeholder="t('settings.network.proxyHostPlaceholder')"
+        v-model:sources="musicSources"
       />
-        </n-form-item>
+
-        <n-form-item :label="t('settings.network.proxyPort')" path="port">
+      <!-- 远程控制设置弹窗 -->
-          <n-input-number
+      <remote-control-setting v-model:visible="showRemoteControlModal" />
-            v-model:value="proxyForm.port"
+
-            :placeholder="t('settings.network.proxyPortPlaceholder')"
-            :min="1"
-            :max="65535"
-          />
-        </n-form-item>
-      </n-form>
-    </n-modal>
-    <!-- 清除缓存弹窗 -->
-    <n-modal
-      v-model:show="showClearCacheModal"
-      preset="dialog"
-      :title="t('settings.system.cache')"
-      :positive-text="t('common.confirm')"
-      :negative-text="t('common.cancel')"
-      @positive-click="clearCache"
-      @negative-click="
-        () => {
-          selectedCacheTypes = [];
-        }
-      "
-    >
-      <n-space vertical>
-        <p>{{ t('settings.system.cacheClearTitle') }}</p>
-        <n-checkbox-group v-model:value="selectedCacheTypes">
-          <n-space vertical>
-            <n-checkbox
-              v-for="option in clearCacheOptions"
-              :key="option.key"
-              :value="option.key"
-              :label="option.label"
-            >
-              <template #default>
-                <div>
-                  <div>{{ t(`settings.system.cacheTypes.${option.key}.label`) }}</div>
-                  <div class="text-gray-400 text-sm">
-                    {{ t(`settings.system.cacheTypes.${option.key}.description`) }}
-                  </div>
-                </div>
     </template>
-            </n-checkbox>
+
-          </n-space>
+    <!-- 清除缓存弹窗 -->
-        </n-checkbox-group>
+    <clear-cache-settings
-      </n-space>
+      v-model:show="showClearCacheModal"
-    </n-modal>
+      @confirm="clearCache"
+    />
+
+
   </div>
 </template>
 
 <script setup lang="ts">
 import { useDebounceFn } from '@vueuse/core';
-import type { FormRules } from 'naive-ui';
 import { useMessage } from 'naive-ui';
 import { computed, h, nextTick, onMounted, onUnmounted, ref, watch } from 'vue';
 import { useI18n } from 'vue-i18n';
@@ -473,14 +472,22 @@ import DonationList from '@/components/common/DonationList.vue';
 import PlayBottom from '@/components/common/PlayBottom.vue';
 import LanguageSwitcher from '@/components/LanguageSwitcher.vue';
 import ShortcutSettings from '@/components/settings/ShortcutSettings.vue';
+import ProxySettings from '@/components/settings/ProxySettings.vue';
+import ClearCacheSettings from '@/components/settings/ClearCacheSettings.vue';
+import MusicSourceSettings from '@/components/settings/MusicSourceSettings.vue';
+import RemoteControlSetting from '@/components/settings/ServerSetting.vue';
 import { useSettingsStore } from '@/store/modules/settings';
 import { useUserStore } from '@/store/modules/user';
 import { isElectron, isMobile } from '@/utils';
 import { openDirectory, selectDirectory } from '@/utils/fileOperation';
 import { checkUpdate, UpdateResult } from '@/utils/update';
+import { type Platform } from '@/types/music';
 
 import config from '../../../../package.json';
 
+// 所有平台默认值
+const ALL_PLATFORMS: Platform[] = ['migu', 'kugou', 'pyncmd', 'bilibili', 'youtube'];
+
 const settingsStore = useSettingsStore();
 const userStore = useUserStore();
 
@@ -595,41 +602,12 @@ const openDownloadPath = () => {
 };
 
 const showProxyModal = ref(false);
-const formRef = ref();
 const proxyForm = ref({
   protocol: 'http',
   host: '127.0.0.1',
   port: 7890
 });
 
-const proxyRules: FormRules = {
-  protocol: {
-    required: true,
-    message: t('settings.validation.selectProxyProtocol'),
-    trigger: ['blur', 'change']
-  },
-  host: {
-    required: true,
-    message: t('settings.validation.proxyHost'),
-    trigger: ['blur', 'change'],
-    validator: (_rule, value) => {
-      if (!value) return false;
-      // 简单的IP或域名验证
-      const ipRegex =
-        /^(\d{1,3}\.){3}\d{1,3}$|^localhost$|^[a-zA-Z0-9][-a-zA-Z0-9]{0,62}(\.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})+$/;
-      return ipRegex.test(value);
-    }
-  },
-  port: {
-    required: true,
-    message: t('settings.validation.portNumber'),
-    trigger: ['blur', 'change'],
-    validator: (_rule, value) => {
-      return value >= 1 && value <= 65535;
-    }
-  }
-};
-
 // 使用 store 中的字体列表
 const systemFonts = computed(() => settingsStore.systemFonts);
 
@@ -707,24 +685,16 @@ watch(
   { immediate: true, deep: true }
 );
 
-const handleProxyConfirm = async () => {
+const handleProxyConfirm = async (proxyConfig) => {
-  try {
-    await formRef.value?.validate();
   // 保存代理配置时保留enable状态
   setData.value = {
     ...setData.value,
     proxyConfig: {
       enable: setData.value.proxyConfig?.enable || false,
-        protocol: proxyForm.value.protocol,
+      ...proxyConfig
-        host: proxyForm.value.host,
-        port: proxyForm.value.port
     }
   };
-    showProxyModal.value = false;
   message.success(t('settings.network.messages.proxySuccess'));
-  } catch (err) {
-    message.error(t('settings.network.messages.proxyError'));
-  }
 };
 
 const validateAndSaveRealIP = () => {
@@ -770,48 +740,9 @@ const toggleDonationList = () => {
 
 // 清除缓存相关
 const showClearCacheModal = ref(false);
-const clearCacheOptions = ref([
-  {
-    label: t('settings.system.cacheTypes.history.label'),
-    key: 'history',
-    description: t('settings.system.cacheTypes.history.description')
-  },
-  {
-    label: t('settings.system.cacheTypes.favorite.label'),
-    key: 'favorite',
-    description: t('settings.system.cacheTypes.favorite.description')
-  },
-  {
-    label: t('settings.system.cacheTypes.user.label'),
-    key: 'user',
-    description: t('settings.system.cacheTypes.user.description')
-  },
-  {
-    label: t('settings.system.cacheTypes.settings.label'),
-    key: 'settings',
-    description: t('settings.system.cacheTypes.settings.description')
-  },
-  {
-    label: t('settings.system.cacheTypes.downloads.label'),
-    key: 'downloads',
-    description: t('settings.system.cacheTypes.downloads.description')
-  },
-  {
-    label: t('settings.system.cacheTypes.resources.label'),
-    key: 'resources',
-    description: t('settings.system.cacheTypes.resources.description')
-  },
-  {
-    label: t('settings.system.cacheTypes.lyrics.label'),
-    key: 'lyrics',
-    description: t('settings.system.cacheTypes.lyrics.description')
-  }
-]);
 
-const selectedCacheTypes = ref<string[]>([]);
+const clearCache = async (selectedCacheTypes) => {
-
+  const clearTasks = selectedCacheTypes.map(async (type) => {
-const clearCache = async () => {
-  const clearTasks = selectedCacheTypes.value.map(async (type) => {
     switch (type) {
       case 'history':
         localStorage.removeItem('musicHistory');
@@ -870,8 +801,6 @@ const clearCache = async () => {
 
   await Promise.all(clearTasks);
   message.success(t('settings.system.messages.clearSuccess'));
-  showClearCacheModal.value = false;
-  selectedCacheTypes.value = [];
 };
 
 const showShortcutModal = ref(false);
@@ -964,6 +893,29 @@ onMounted(() => {
     handleScroll({ target: { scrollTop: 0 } });
   });
 });
+
+// 音源设置相关
+const musicSources = computed({
+  get: () => {
+    if (!setData.value.enabledMusicSources) {
+      return ALL_PLATFORMS;
+    }
+    return setData.value.enabledMusicSources as Platform[];
+  },
+  set: (newValue: Platform[]) => {
+    // 确保至少选择一个音源
+    const valuesToSet = newValue.length > 0 ? [...new Set(newValue)] : ALL_PLATFORMS;
+    setData.value = {
+      ...setData.value,
+      enabledMusicSources: valuesToSet
+    };
+  }
+});
+
+const showMusicSourcesModal = ref(false);
+
+// 远程控制设置弹窗
+const showRemoteControlModal = ref(false);
 </script>
 
 <style lang="scss" scoped>

src/types/shortcuts.ts

@@ -0,0 +1,18 @@
+/**
+ * 快捷键配置
+ */
+export interface ShortcutConfig {
+  /** 快捷键字符串 */
+  key: string;
+  /** 是否启用 */
+  enabled: boolean;
+  /** 作用范围: global(全局) 或 app(仅应用内) */
+  scope: 'global' | 'app';
+}
+
+/**
+ * 快捷键配置集合
+ */
+export interface ShortcutsConfig {
+  [key: string]: ShortcutConfig;
+}