✨ feat: 更新版本至 4.8.0

添加任务栏缩略图控制按钮

.env.development

@@ -1,12 +1,4 @@
 # 你的接口地址 (必填)
-VITE_API_LOCAL = ***
-# 音乐破解接口地址
-VITE_API_MUSIC = ***
-# 代理地址
-VITE_API_PROXY = ***
-
-
-# 本地运行代理地址
-VITE_API_PROXY = /api
-VITE_API_MUSIC_PROXY = /music
-VITE_API_PROXY_MUSIC = /music_proxy
+VITE_API = http://127.0.0.1:30488
+# 音乐破解接口地址 web端
+VITE_API_MUSIC = ***

.eslintignore

@@ -0,0 +1,4 @@
+node_modules
+dist
+out
+.gitignore

.eslintrc.cjs

@@ -0,0 +1,137 @@
+/* eslint-env node */
+require('@rushstack/eslint-patch/modern-module-resolution');
+
+module.exports = {
+  extends: [
+    'eslint:recommended',
+    'plugin:@typescript-eslint/recommended', 
+    '@vue/typescript/recommended',
+    'plugin:vue/vue3-recommended',
+    'plugin:vue-scoped-css/base',
+    '@electron-toolkit',
+    '@electron-toolkit/eslint-config-ts/eslint-recommended',
+    'plugin:prettier/recommended'
+  ],
+  env: {
+    browser: true,
+    node: true,
+    jest: true,
+    es6: true
+  },
+  globals: {
+    defineProps: 'readonly',
+    defineEmits: 'readonly'
+  },
+  plugins: ['vue', '@typescript-eslint', 'simple-import-sort'],
+  parserOptions: {
+    parser: '@typescript-eslint/parser',
+    sourceType: 'module',
+    allowImportExportEverywhere: true,
+    ecmaFeatures: {
+      jsx: true
+    }
+  },
+  settings: {
+    'import/extensions': ['.js', '.jsx', '.ts', '.tsx']
+  },
+  rules: {
+    'vue/require-default-prop': 'off',
+    'vue/multi-word-component-names': 'off',
+    'no-underscore-dangle': 'off',
+    'no-nested-ternary': 'off',
+    'no-console': 'off',
+    'no-await-in-loop': 'off',
+    'no-continue': 'off',
+    'no-restricted-syntax': 'off',
+    'no-return-assign': 'off',
+    'no-unused-expressions': 'off',
+    'no-return-await': 'off',
+    'no-plusplus': 'off',
+    'no-param-reassign': 'off',
+    'no-shadow': 'off',
+    'guard-for-in': 'off',
+    'import/extensions': 'off',
+    'import/no-unresolved': 'off',
+    'import/no-extraneous-dependencies': 'off',
+    'import/prefer-default-export': 'off',
+    'import/first': 'off',
+    '@typescript-eslint/no-explicit-any': 'off',
+    '@typescript-eslint/explicit-module-boundary-types': 'off',
+    'vue/first-attribute-linebreak': 0,
+    '@typescript-eslint/no-unused-vars': [
+      'error',
+      {
+        argsIgnorePattern: '^_',
+        varsIgnorePattern: '^_'
+      }
+    ],
+    'no-unused-vars': [
+      'error',
+      {
+        argsIgnorePattern: '^_',
+        varsIgnorePattern: '^_'
+      }
+    ],
+    'no-use-before-define': 'off',
+    '@typescript-eslint/no-use-before-define': 'off',
+    '@typescript-eslint/ban-ts-comment': 'off',
+    '@typescript-eslint/ban-types': 'off',
+    'class-methods-use-this': 'off',
+    'simple-import-sort/imports': 'error',
+    'simple-import-sort/exports': 'error'
+  },
+  overrides: [
+    {
+      files: ['*.vue'],
+      rules: {
+        'vue/component-name-in-template-casing': [2, 'kebab-case'],
+        'vue/require-default-prop': 0,
+        'vue/multi-word-component-names': 0,
+        'vue/no-reserved-props': 0,
+        'vue/no-v-html': 0,
+        'vue-scoped-css/enforce-style-type': [
+          'error',
+          {
+            allows: ['scoped']
+          }
+        ],
+        '@typescript-eslint/explicit-function-return-type': 'off',
+        // 需要行尾分号
+        'prettier/prettier': ['error', { endOfLine: 'auto' }]
+      }
+    },
+    {
+      files: ['*.ts', '*.tsx'],
+      rules: {
+        'max-classes-per-file': 'off',
+        'no-await-in-loop': 'off',
+        'dot-notation': 'off',
+        'constructor-super': 'off',
+        'getter-return': 'off',
+        'no-const-assign': 'off',
+        'no-dupe-args': 'off',
+        'no-dupe-class-members': 'off',
+        'no-dupe-keys': 'off',
+        'no-func-assign': 'off',
+        'no-import-assign': 'off',
+        'no-new-symbol': 'off',
+        'no-obj-calls': 'off',
+        'no-redeclare': 'off',
+        'no-setter-return': 'off',
+        'no-this-before-super': 'off',
+        'no-undef': 'off',
+        'no-unreachable': 'off',
+        'no-unsafe-negation': 'off',
+        'no-var': 'error',
+        'prefer-const': 'error',
+        'prefer-rest-params': 'error',
+        'prefer-spread': 'error',
+        'valid-typeof': 'off',
+        'consistent-return': 'off',
+        'no-promise-executor-return': 'off',
+        'prefer-promise-reject-errors': 'off',
+        '@typescript-eslint/explicit-function-return-type': 'off'
+      }
+    }
+  ]
+};

.github/workflows/build.yml

@@ -77,6 +77,7 @@ jobs:
             dist/*.dmg
             dist/*.exe
             dist/*.deb
+            dist/*.rpm
             dist/*.AppImage
             dist/latest*.yml
             dist/*.blockmap

.github/workflows/deploy.yml

@@ -0,0 +1,51 @@
+name: Deploy Web
+
+on:
+  push:
+    branches:
+      - main # 或者您的主分支名称
+  workflow_dispatch: # 允许手动触发
+
+jobs:
+  build-and-deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: '18'
+          
+      - name: 创建环境变量文件
+        run: |
+          echo "VITE_API=${{ secrets.VITE_API }}" > .env.production.local
+          echo "VITE_API_MUSIC=${{ secrets.VITE_API_MUSIC }}" >> .env.production.local
+          # 添加其他需要的环境变量
+          cat .env.production.local # 查看创建的文件内容，调试用
+
+      - name: Install Dependencies
+        run: npm install
+
+      - name: Build
+        run: npm run build
+
+      - name: Deploy to Server
+        uses: appleboy/scp-action@master
+        with:
+          host: ${{ secrets.SERVER_HOST }}
+          username: ${{ secrets.SERVER_USERNAME }}
+          key: ${{ secrets.DEPLOY_KEY }}
+          source: "out/renderer/*"
+          target: ${{ secrets.DEPLOY_PATH }}
+          strip_components: 2
+
+      - name: Execute Remote Commands
+        uses: appleboy/ssh-action@master
+        with:
+          host: ${{ secrets.SERVER_HOST }}
+          username: ${{ secrets.SERVER_USERNAME }}
+          key: ${{ secrets.DEPLOY_KEY }}
+          script: |
+            cd ${{ secrets.DEPLOY_PATH }}
+            echo "部署完成于 $(date)"

.gitignore

@@ -16,7 +16,23 @@ dist.zip
 .vscode
 
 bun.lockb
+bun.lock
 
 .env.*.local
 
-out
+out
+
+.cursorrules
+
+.github/deploy_keys
+
+resources/android/**/*
+android/app/release
+
+.cursor
+
+.auto-imports.d.ts
+.components.d.ts
+
+src/renderer/auto-imports.d.ts
+src/renderer/components.d.ts

.husky/pre-commit

@@ -0,0 +1,2 @@
+echo "运行类型检查..."
+npm run typecheck 

.husky/pre-push

@@ -0,0 +1,2 @@
+echo "运行类型检查..."
+npm run typecheck 

.prettierignore

@@ -0,0 +1,6 @@
+out
+dist
+pnpm-lock.yaml
+LICENSE.md
+tsconfig.json
+tsconfig.*.json

.prettierrc.yaml

@@ -0,0 +1,5 @@
+singleQuote: true
+semi: true
+printWidth: 100
+trailingComma: none
+endOfLine: auto

CHANGELOG.md

@@ -1,11 +1,62 @@
 # 更新日志
 
-## [v3.3.0] - 2024-01-04
+## v4.8.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>
+
+> 微信公众号 微信搜索 <span style="font-weight: bold;">AlgerMusic</span>
+
+> QQ频道 AlgerMusic <a href="https://pd.qq.com/s/cs056n33q?b=5" target="_blank">加入频道</a>
 
 ### ✨ 新功能
-- 添加音质选择功能，优化灰色歌曲解析 (020aca7)
-- 收藏功能改为接口对接 与 网易云同步 (43c64b1)
-- 添加退出登录 (fcc47dc)
-- 优化登录失效处理 (9eb17fd)
-- 修复未登录状态下的收藏问题 (17ce268)
-- 优化更新检查和下载功能 (11ced6b)
+- 增强移动端播放页面效果，添加播放模式选择，添加横屏模式，添加播放列表功能 ([81b61e4](https://github.com/algerkong/AlgerMusicPlayer/commit/81b61e4))，([0d89e15](https://github.com/algerkong/AlgerMusicPlayer/commit/0d89e15))，([9345805](https://github.com/algerkong/AlgerMusicPlayer/commit/9345805))
+- 优化移动端界面动画效果，播放栏，返回效果等一系列功能
+- 添加下载管理页面, 引入文件类型检测库以支持多种音频格式,支持自定义文件名格式和下载路径配置 ([3ac3159](https://github.com/algerkong/AlgerMusicPlayer/commit/3ac3159)),([b203077](https://github.com/algerkong/AlgerMusicPlayer/commit/b203077))
+- 新增歌单导入功能 ([edd393c](https://github.com/algerkong/AlgerMusicPlayer/commit/edd393c))
+- 列表添加多选下载功能，支持批量选择和下载音乐 ([1221101](https://github.com/algerkong/AlgerMusicPlayer/commit/1221101)),([8988cdb](https://github.com/algerkong/AlgerMusicPlayer/commit/8988cdb))，([21b2fc0](https://github.com/algerkong/AlgerMusicPlayer/commit/21b2fc0))
+- Windows添加任务栏缩略图播放控制按钮 ([9bec67e](https://github.com/algerkong/AlgerMusicPlayer/commit/9bec67e))，([58ab990](https://github.com/algerkong/AlgerMusicPlayer/commit/58ab990)) 感谢[HE Cai](https://github.com/hecai84)的pr
+- 添加主窗口自适应大小功能，页面缩放功能，支持缩放因子的调整和重置 ([6170047](https://github.com/algerkong/AlgerMusicPlayer/commit/6170047)), ([e46df8a](https://github.com/algerkong/AlgerMusicPlayer/commit/e46df8a))
+- 添加歌词时间矫正功能，支持增加和减少矫正时间 ([c975344](https://github.com/algerkong/AlgerMusicPlayer/commit/c975344))
+
+### 🐛 Bug 修复
+- 修复音频初始化音量问题，完善翻译  ([#320](https://github.com/algerkong/AlgerMusicPlayer/pull/320))   感谢[Qumo](https://github.com/Hellodwadawd12312312)的pr
+- 重构每日推荐数据加载逻辑，提取为独立函数并优化用户状态判断 ([5e704a1](https://github.com/algerkong/AlgerMusicPlayer/commit/5e704a1))
+- 修复刷新后第一次播放出现的无法播放问题 ([6f1909a](https://github.com/algerkong/AlgerMusicPlayer/commit/6f1909a))
+- 修复更多设置弹窗被歌词窗口遮挡问题，并优化为互斥弹窗，优化样式 ([62e5166](https://github.com/algerkong/AlgerMusicPlayer/commit/62e5166))
+- 修复设置页面动画速度滑块样式和文本错误 ([e5adb8a](https://github.com/algerkong/AlgerMusicPlayer/commit/e5adb8a))
+- 修复音频服务相关问题 ([090103b](https://github.com/algerkong/AlgerMusicPlayer/commit/090103b)),([5ee60d7](https://github.com/algerkong/AlgerMusicPlayer/commit/5ee60d7))
+- 修复播放栏无法控制隐藏问题 ([d227ac8](https://github.com/algerkong/AlgerMusicPlayer/commit/d227ac8))
+
+
+### 🎨 优化
+- 优化歌曲列表组件布局([fabcf28](https://github.com/algerkong/AlgerMusicPlayer/commit/fabcf28))
+- 重构播放控制逻辑，添加播放进度恢复功能并清理无用代码 ([b9c38d2](https://github.com/algerkong/AlgerMusicPlayer/commit/b9c38d2))
+- 优化提示组件，支持位置和图标显示选项 ([155bdf2](https://github.com/algerkong/AlgerMusicPlayer/commit/155bdf2))
+- 添加mini播放栏鼠标滚轮调整音量，并优化音量滑块数字不展示问题 ([5c72785](https://github.com/algerkong/AlgerMusicPlayer/commit/5c72785))
+- 优化收藏和历史列表组件，添加加载状态管理和动画效果 ([5070a08](https://github.com/algerkong/AlgerMusicPlayer/commit/5070a08))
+- 翻译优化
+- 代码优化
+
+## 赞赏支持☕️
+[赞赏列表](http://donate.alger.fun/)
+<table>
+  <tr>
+    <th style="text-align:center">微信赞赏</th>
+    <th style="width:100px"></th>
+    <th style="text-align:center">支付宝赞赏</th>
+  </tr>
+  <tr>
+    <td align="center">
+      <img src="https://github.com/algerkong/algerkong/blob/main/wechat.jpg?raw=true" alt="WeChat QRcode" width="200"><br>
+      <h6>☕️喝点咖啡继续干</h6>
+    </td>
+    <td></td>
+    <td align="center">
+      <img src="https://github.com/algerkong/algerkong/blob/main/alipay.jpg?raw=true" alt="Alipay QRcode" width="200"><br>
+      <h6>🍔来个汉堡</h6>
+    </td>
+  </tr>
+</table>

DEV.md

@@ -0,0 +1,192 @@
+# Alger Music Player 开发文档
+
+## 项目结构
+
+### 技术栈
+
+- **前端框架**：Vue 3 + TypeScript
+- **UI 组件库**：naive-ui
+- **样式框架**：Tailwind CSS
+- **图标库**：remixicon
+- **状态管理**：Pinia
+- **工具库**：VueUse
+- **构建工具**：Vite, electron-vite
+- **打包工具**：electron-builder
+- **国际化**：vue-i18n
+- **HTTP 客户端**：axios
+- **本地存储**：electron-store localstorage
+- **网易云音乐 API**：netease-cloud-music-api
+- **音乐解锁**：@unblockneteasemusic/server
+
+### 项目结构
+
+```
+AlgerMusicPlayer/
+├── build/                  # 构建相关文件
+├── docs/                   # 项目文档
+├── node_modules/           # 依赖包
+├── out/                    # 构建输出目录
+├── resources/              # 资源文件
+├── src/                    # 源代码
+│   ├── i18n/               # 国际化配置
+│   │   ├── lang/           # 语言包
+│   │   ├── main.ts         # 主进程国际化入口
+│   │   └── renderer.ts     # 渲染进程国际化入口
+│   ├── main/               # Electron 主进程
+│   │   ├── modules/        # 主进程模块
+│   │   ├── index.ts        # 主进程入口
+│   │   ├── lyric.ts        # 歌词处理
+│   │   ├── server.ts       # 服务器
+│   │   ├── set.json        # 设置
+│   │   └── unblockMusic.ts # 音乐解锁
+│   ├── preload/            # 预加载脚本
+│   │   ├── index.ts        # 预加载脚本入口
+│   │   └── index.d.ts      # 预加载脚本类型声明
+│   └── renderer/           # Vue 渲染进程
+│       ├── api/            # API 请求
+│       ├── assets/         # 静态资源
+│       ├── components/     # 组件
+│       │   ├── common/     # 通用组件
+│       │   ├── home/       # 首页组件
+│       │   ├── lyric/      # 歌词组件
+│       │   ├── settings/   # 设置组件
+│       │   └── ...         # 其他组件
+│       ├── const/          # 常量定义
+│       ├── directive/      # 自定义指令
+│       ├── hooks/          # 自定义 Hooks
+│       ├── layout/         # 布局组件
+│       ├── router/         # 路由配置
+│       ├── services/       # 服务
+│       ├── store/          # Pinia 状态管理
+│       │   ├── modules/    # Pinia 模块
+│       │   └── index.ts    # Pinia 入口
+│       ├── type/           # 类型定义
+│       ├── types/          # 更多类型定义
+│       ├── utils/          # 工具函数
+│       ├── views/          # 页面视图
+│       ├── App.vue         # 根组件
+│       ├── index.css       # 全局样式
+│       ├── index.html      # HTML 模板
+│       ├── main.ts         # 渲染进程入口
+│       └── ...             # 其他文件
+├── .env.development        # 开发环境变量
+├── .env.development.local  # 本地开发环境变量
+├── .env.production.local   # 本地生产环境变量
+├── .eslintrc.cjs           # ESLint 配置
+├── .gitignore              # Git 忽略文件
+├── .prettierrc.yaml        # Prettier 配置
+├── electron-builder.yml    # electron-builder 配置
+├── electron.vite.config.ts # electron-vite 配置
+├── package.json            # 项目配置
+├── postcss.config.js       # PostCSS 配置
+├── tailwind.config.js      # Tailwind 配置
+├── tsconfig.json           # TypeScript 配置
+├── tsconfig.node.json      # 节点 TypeScript 配置
+└── tsconfig.web.json       # Web TypeScript 配置
+```
+
+### 主要组件说明
+
+#### 主进程 (src/main)
+
+主进程负责创建窗口、处理系统层面的交互以及与渲染进程的通信。
+
+- **index.ts**: 应用主入口，负责创建窗口和应用生命周期管理
+- **lyric.ts**: 歌词解析和处理
+- **unblockMusic.ts**: 网易云音乐解锁功能
+- **server.ts**: 本地服务器
+
+#### 预加载脚本 (src/preload)
+
+预加载脚本在渲染进程加载前执行，提供了渲染进程和主进程之间的桥接功能。
+
+#### 渲染进程 (src/renderer)
+
+渲染进程是基于 Vue 3 的前端应用，负责 UI 渲染和用户交互。
+
+- **components/**: 包含各种 UI 组件
+  - **common/**: 通用组件
+  - **home/**: 首页相关组件
+  - **lyric/**: 歌词显示组件
+  - **settings/**: 设置界面组件
+  - **MusicList.vue**: 音乐列表组件
+  - **MvPlayer.vue**: MV 播放器
+  - **EQControl.vue**: 均衡器控制
+  - **...**: 其他组件
+
+- **store/**: Pinia 状态管理
+  - **modules/**: 各功能模块的状态管理
+  - **index.ts**: 状态管理入口
+
+- **views/**: 页面视图组件
+
+- **router/**: 路由配置
+
+- **api/**: API 请求封装
+
+- **utils/**: 工具函数
+
+### 开发指南
+
+#### 命名约定
+
+- 目录使用 kebab-case (如: components/auth-wizard)
+- 组件文件名使用 PascalCase (如: AuthWizard.vue)
+- 可组合式函数使用 camelCase (如: useAuthState.ts)
+
+#### 代码风格
+
+- 使用 Composition API 和 `<script setup>` 语法
+- 使用 TypeScript 类型系统
+- 优先使用类型而非接口
+- 避免使用枚举，使用 const 对象代替
+- 使用 tailwind 实现响应式设计
+
+
+### 如何启动？
+安装依赖（最好使用node18+）：
+```
+npm install
+```
+
+
+#### 桌面端开发
+启动桌面端开发：
+```
+npm run dev
+```
+
+
+#### 网页端开发
+如果只启动网页端开发，需要自己部署服务  netease-cloud-music-api
+
+需要复制一份 `.env.development.local` 到 `src/renderer` 下
+```
+# .env.development.local
+
+# 你的接口地址 (必填)
+VITE_API = ***
+# 音乐破解接口地址
+VITE_API_MUSIC = ***
+```
+
+启动web端开发：
+```
+npm run dev:web
+```
+
+### 打包
+
+打包桌面端：
+```
+npm run build:win
+```
+打包后的文件在 /dist 下
+
+
+
+打包网页端：
+```
+npm run build
+```
+打包后的文件在 /out/renderer 下

README.md

@@ -1,96 +1,101 @@
-# Alger Music Player
-主要功能如下
 
-- 音乐推荐
-- 网易云登录
-- 播放历史
-- 桌面歌词
-- 歌单 mv 搜索 专辑等功能
-- 识别无法播放歌曲 并解析播放
-- 主题切换 更新检测
-- 本地服务 不依赖线上服务
-- 可听周杰伦（搜索专辑）
+<h2 align="center">🎵 Alger Music Player</h2>
+<div align="center">
+<div align="center">
+  <a href="https://github.com/algerkong/AlgerMusicPlayer/stargazers">
+    <img src="https://img.shields.io/github/stars/algerkong/AlgerMusicPlayer?style=for-the-badge&logo=github&label=Stars&logoColor=white&color=22c55e" alt="GitHub stars">
+  </a>
+  <a href="https://github.com/algerkong/AlgerMusicPlayer/releases">
+    <img src="https://img.shields.io/github/v/release/algerkong/AlgerMusicPlayer?style=for-the-badge&logo=github&label=Release&logoColor=white&color=1a67af" alt="GitHub release">
+  </a>
+  <a href="https://pd.qq.com/s/cs056n33q?b=5">
+    <img src="https://img.shields.io/badge/QQ频道-algermusic-blue?style=for-the-badge&color=yellow" alt="加入频道">
+  </a>
+  <a href="https://t.me/+9efsKRuvKBk2NWVl">
+    <img src="https://img.shields.io/badge/AlgerMusic-blue?style=for-the-badge&logo=telegram&logoColor=white&label=Telegram" alt="Telegram">
+  </a>
+   <a href="https://donate.alger.fun/">
+    <img src="https://img.shields.io/badge/%E9%A1%B9%E7%9B%AE%E6%8D%90%E8%B5%A0-blue?style=for-the-badge&logo=telegram&logoColor=pink&color=pink&label=%E8%B5%9E%E5%8A%A9" alt="赞助">
+  </a>
+</div>
+</div>
+<div align="center">
+  <a href="https://hellogithub.com/repository/607b849c598d48e08fe38789d156ebdc" target="_blank"><img src="https://api.hellogithub.com/v1/widgets/recommend.svg?rid=607b849c598d48e08fe38789d156ebdc&claim_uid=ObuMXUfeHBmk9TI&theme=neutral" alt="Featured｜HelloGitHub" width="160" height="32" /></a>
+</div>
+
+
+[项目下安装以及常用问题文档](https://www.yuque.com/alger-pfg5q/ip4f1a/bmgmfmghnhgwghkm?singleDoc#)
+
+主要功能如下
+- 🎵 音乐推荐
+- 🔐 网易云账号登录与同步
+- 📝 功能
+  - 播放历史记录
+  - 歌曲收藏管理
+  - 歌单 MV 排行榜 每日推荐
+  - 自定义快捷键配置（全局或应用内）
+- 🎨 界面与交互
+  - 沉浸式歌词显示（点击左下角封面进入）
+  - 独立桌面歌词窗口
+  - 明暗主题切换
+  - 迷你模式
+  - 状态栏控制
+  - 多语言支持
+  
+- 🎼 音乐功能
+  - 支持歌单、MV、专辑等完整音乐服务
+  - 灰色音乐资源解析（基于 @unblockneteasemusic/server）
+  - 音乐单独解析
+  - EQ均衡器
+  - 定时播放 远程控制播放 倍速播放
+  - 高品质音乐
+  - 音乐文件下载（支持右键下载和批量下载, 附带歌词封面等信息）
+  - 搜索 MV 音乐 专辑 歌单 bilibili
+  - 音乐单独选择音源解析
+- 🚀 技术特性
+  - 本地化服务，无需依赖在线API (基于 netease-cloud-music-api)
+  - 全平台适配（Desktop & Web & Mobile Web & Android<测试> & ios<后续>）
 
 ## 项目简介
- 一个基于 electron typescript vue3 的桌面音乐播放器 适配 web端 桌面端 web移动端
+ 一个第三方音乐播放器、本地服务、桌面歌词、音乐下载、最高音质
 
 ## 预览地址
-[http://mc.alger.fun/](http://mc.alger.fun/)
-
-QQ群:789288579
+[http://music.alger.fun/](http://music.alger.fun/)
 
 ## 软件截图
 ![首页白](./docs/image.png)
 ![首页黑](./docs/image3.png)
-![歌词](./docs/image1.png)
+![歌词](./docs/image6.png)
 ![桌面歌词](./docs/image2.png)
+![设置页面](./docs/image4.png)
+![音乐远程控制](./docs/image5.png)
 
-## 技术栈
-
-### 主要框架
-- Vue 3 - 渐进式 JavaScript 框架
-- TypeScript - JavaScript 的超集，添加了类型系统
-- Electron - 跨平台桌面应用开发框架
-- Vite - 下一代前端构建工具
-- Naive UI - 基于 Vue 3 的组件库
+## 项目启动
+```bash
+npm install
+npm run dev
+```
+## 开发文档
+点击这里[开发文档](./DEV.md)
 
 
-## 咖啡☕️
-|                                        微信                                        |                                       支付宝                                       |
+
+
+## 赞赏☕️
+[赞赏列表](http://donate.alger.fun/)
+|                                        微信赞赏                                        |                                       支付宝赞赏                                       |
 | :--------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------: |
-| <img src="https://github.com/algerkong/algerkong/blob/main/wechat.jpg?raw=true" alt="WeChat QRcode" width=200> | <img src="https://github.com/algerkong/algerkong/blob/main/alipay.jpg?raw=true" alt="Wechat QRcode" width=200> |
-
-## 项目运行
-```bash
-  # 安装依赖
-  npm install
-
-  # 运行项目 web
-  npm run dev
-
-  # 运行项目 electron
-  npm run start
-
-  # 打包项目 web
-  npm run build
-
-  # 打包项目 electron
-  npm run win ... 
-  # 具体看 package.json
-```
-#### 注意
-- 本地运行需要配置 .env.development 文件
-- 打包需要配置 .env.production 文件
-
-```bash
-  # .env.development
-  VITE_API_LOCAL = /api
-  VITE_API_MUSIC_PROXY = /music
-  VITE_API_PROXY_MUSIC = /music_proxy
-
-  # 你的接口地址 (必填)
-  VITE_API = ***
-  # 音乐po接口地址
-  VITE_API_MUSIC = ***
-  VITE_API_PROXY = ***
+| <img src="https://github.com/algerkong/algerkong/blob/main/wechat.jpg?raw=true" alt="WeChat QRcode" width=200> <br><small>喝点咖啡继续干</small> | <img src="https://github.com/algerkong/algerkong/blob/main/alipay.jpg?raw=true" alt="Wechat QRcode" width=200> <br><small>来包辣条吧~</small> |
 
 
-  # .env.production
-  # 你的接口地址 (必填)
-  VITE_API = ***
-  # 音乐po接口地址
-  VITE_API_MUSIC = ***
-  # 代理地址
-  VITE_API_PROXY = ***
-```
-
-## Stargazers over time
+## 项目统计
 [![Stargazers over time](https://starchart.cc/algerkong/AlgerMusicPlayer.svg?variant=adaptive)](https://starchart.cc/algerkong/AlgerMusicPlayer)
-
+![Alt](https://repobeats.axiom.co/api/embed/c4d01b3632e241c90cdec9508dfde86a7f54c9f5.svg "Repobeats analytics image")
 
 
 
 ## 欢迎提Issues
 
-## 免责声明
+## 声明
 本软件仅用于学习交流，禁止用于商业用途，否则后果自负。
+希望大家还是要多多支持官方正版，此软件仅用作开发教学。

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

auto-imports.d.ts

@@ -1,90 +0,0 @@
-/* eslint-disable */
-/* prettier-ignore */
-// @ts-nocheck
-// noinspection JSUnusedGlobalSymbols
-// Generated by unplugin-auto-import
-// biome-ignore lint: disable
-export {}
-declare global {
-  const EffectScope: (typeof import('vue'))['EffectScope'];
-  const computed: (typeof import('vue'))['computed'];
-  const createApp: (typeof import('vue'))['createApp'];
-  const customRef: (typeof import('vue'))['customRef'];
-  const defineAsyncComponent: (typeof import('vue'))['defineAsyncComponent'];
-  const defineComponent: (typeof import('vue'))['defineComponent'];
-  const effectScope: (typeof import('vue'))['effectScope'];
-  const getCurrentInstance: (typeof import('vue'))['getCurrentInstance'];
-  const getCurrentScope: (typeof import('vue'))['getCurrentScope'];
-  const h: (typeof import('vue'))['h'];
-  const inject: (typeof import('vue'))['inject'];
-  const isProxy: (typeof import('vue'))['isProxy'];
-  const isReactive: (typeof import('vue'))['isReactive'];
-  const isReadonly: (typeof import('vue'))['isReadonly'];
-  const isRef: (typeof import('vue'))['isRef'];
-  const markRaw: (typeof import('vue'))['markRaw'];
-  const nextTick: (typeof import('vue'))['nextTick'];
-  const onActivated: (typeof import('vue'))['onActivated'];
-  const onBeforeMount: (typeof import('vue'))['onBeforeMount'];
-  const onBeforeUnmount: (typeof import('vue'))['onBeforeUnmount'];
-  const onBeforeUpdate: (typeof import('vue'))['onBeforeUpdate'];
-  const onDeactivated: (typeof import('vue'))['onDeactivated'];
-  const onErrorCaptured: (typeof import('vue'))['onErrorCaptured'];
-  const onMounted: (typeof import('vue'))['onMounted'];
-  const onRenderTracked: (typeof import('vue'))['onRenderTracked'];
-  const onRenderTriggered: (typeof import('vue'))['onRenderTriggered'];
-  const onScopeDispose: (typeof import('vue'))['onScopeDispose'];
-  const onServerPrefetch: (typeof import('vue'))['onServerPrefetch'];
-  const onUnmounted: (typeof import('vue'))['onUnmounted'];
-  const onUpdated: (typeof import('vue'))['onUpdated'];
-  const onWatcherCleanup: (typeof import('vue'))['onWatcherCleanup'];
-  const provide: (typeof import('vue'))['provide'];
-  const reactive: (typeof import('vue'))['reactive'];
-  const readonly: (typeof import('vue'))['readonly'];
-  const ref: (typeof import('vue'))['ref'];
-  const resolveComponent: (typeof import('vue'))['resolveComponent'];
-  const shallowReactive: (typeof import('vue'))['shallowReactive'];
-  const shallowReadonly: (typeof import('vue'))['shallowReadonly'];
-  const shallowRef: (typeof import('vue'))['shallowRef'];
-  const toRaw: (typeof import('vue'))['toRaw'];
-  const toRef: (typeof import('vue'))['toRef'];
-  const toRefs: (typeof import('vue'))['toRefs'];
-  const toValue: (typeof import('vue'))['toValue'];
-  const triggerRef: (typeof import('vue'))['triggerRef'];
-  const unref: (typeof import('vue'))['unref'];
-  const useAttrs: (typeof import('vue'))['useAttrs'];
-  const useCssModule: (typeof import('vue'))['useCssModule'];
-  const useCssVars: (typeof import('vue'))['useCssVars'];
-  const useDialog: (typeof import('naive-ui'))['useDialog'];
-  const useId: (typeof import('vue'))['useId'];
-  const useLoadingBar: (typeof import('naive-ui'))['useLoadingBar'];
-  const useMessage: (typeof import('naive-ui'))['useMessage'];
-  const useModel: (typeof import('vue'))['useModel'];
-  const useNotification: (typeof import('naive-ui'))['useNotification'];
-  const useSlots: (typeof import('vue'))['useSlots'];
-  const useTemplateRef: (typeof import('vue'))['useTemplateRef'];
-  const watch: (typeof import('vue'))['watch'];
-  const watchEffect: (typeof import('vue'))['watchEffect'];
-  const watchPostEffect: (typeof import('vue'))['watchPostEffect'];
-  const watchSyncEffect: (typeof import('vue'))['watchSyncEffect'];
-}
-// for type re-export
-declare global {
-  // @ts-ignore
-  export type {
-    Component,
-    ComponentPublicInstance,
-    ComputedRef,
-    DirectiveBinding,
-    ExtractDefaultPropTypes,
-    ExtractPropTypes,
-    ExtractPublicPropTypes,
-    InjectionKey,
-    PropType,
-    Ref,
-    MaybeRef,
-    MaybeRefOrGetter,
-    VNode,
-    WritableComputedRef
-  } from 'vue';
-  import('vue');
-}

components.d.ts

@@ -1,33 +0,0 @@
-/* eslint-disable */
-// @ts-nocheck
-// Generated by unplugin-vue-components
-// Read more: https://github.com/vuejs/core/pull/3399
-export {};
-
-/* prettier-ignore */
-declare module 'vue' {
-  export interface GlobalComponents {
-    NAvatar: typeof import('naive-ui')['NAvatar']
-    NButton: typeof import('naive-ui')['NButton']
-    NCheckbox: typeof import('naive-ui')['NCheckbox']
-    NConfigProvider: typeof import('naive-ui')['NConfigProvider']
-    NDialogProvider: typeof import('naive-ui')['NDialogProvider']
-    NDrawer: typeof import('naive-ui')['NDrawer']
-    NDropdown: typeof import('naive-ui')['NDropdown']
-    NEllipsis: typeof import('naive-ui')['NEllipsis']
-    NEmpty: typeof import('naive-ui')['NEmpty']
-    NImage: typeof import('naive-ui')['NImage']
-    NInput: typeof import('naive-ui')['NInput']
-    NInputNumber: typeof import('naive-ui')['NInputNumber']
-    NLayout: typeof import('naive-ui')['NLayout']
-    NMessageProvider: typeof import('naive-ui')['NMessageProvider']
-    NModal: typeof import('naive-ui')['NModal']
-    NPopover: typeof import('naive-ui')['NPopover']
-    NScrollbar: typeof import('naive-ui')['NScrollbar']
-    NSlider: typeof import('naive-ui')['NSlider']
-    NSpin: typeof import('naive-ui')['NSpin']
-    NSwitch: typeof import('naive-ui')['NSwitch']
-    RouterLink: typeof import('vue-router')['RouterLink']
-    RouterView: typeof import('vue-router')['RouterView']
-  }
-}

electron.vite.config.ts

@@ -5,6 +5,7 @@ import AutoImport from 'unplugin-auto-import/vite';
 import { NaiveUiResolver } from 'unplugin-vue-components/resolvers';
 import Components from 'unplugin-vue-components/vite';
 import viteCompression from 'vite-plugin-compression';
+import VueDevTools from 'vite-plugin-vue-devtools';
 
 export default defineConfig({
   main: {
@@ -23,7 +24,7 @@ export default defineConfig({
     plugins: [
       vue(),
       viteCompression(),
-      // VueDevTools(),
+      VueDevTools(),
       AutoImport({
         imports: [
           'vue',
@@ -36,25 +37,9 @@ export default defineConfig({
         resolvers: [NaiveUiResolver()]
       })
     ],
+    publicDir: resolve('resources'),
     server: {
-      proxy: {
-        // with options
-        [process.env.VITE_API_LOCAL as string]: {
-          target: process.env.VITE_API,
-          changeOrigin: true,
-          rewrite: (path) => path.replace(new RegExp(`^${process.env.VITE_API_LOCAL}`), '')
-        },
-        [process.env.VITE_API_MUSIC_PROXY as string]: {
-          target: process.env.VITE_API_MUSIC,
-          changeOrigin: true,
-          rewrite: (path) => path.replace(new RegExp(`^${process.env.VITE_API_MUSIC_PROXY}`), '')
-        },
-        [process.env.VITE_API_PROXY_MUSIC as string]: {
-          target: process.env.VITE_API_PROXY,
-          changeOrigin: true,
-          rewrite: (path) => path.replace(new RegExp(`^${process.env.VITE_API_PROXY_MUSIC}`), '')
-        }
-      }
+      host: '0.0.0.0',
     }
   }
 });

package.json

@@ -1,11 +1,12 @@
 {
   "name": "AlgerMusicPlayer",
-  "version": "3.3.0",
+  "version": "4.8.0",
   "description": "Alger Music Player",
   "author": "Alger <algerkc@qq.com>",
   "main": "./out/main/index.js",
   "homepage": "https://github.com/algerkong/AlgerMusicPlayer",
   "scripts": {
+    "prepare": "husky",
     "format": "prettier --write .",
     "lint": "eslint . --ext .js,.jsx,.cjs,.mjs,.ts,.tsx,.cts,.mts,.vue --fix",
     "typecheck:node": "tsc --noEmit -p tsconfig.node.json --composite false",
@@ -13,7 +14,8 @@
     "typecheck": "npm run typecheck:node && npm run typecheck:web",
     "start": "electron-vite preview",
     "dev": "electron-vite dev",
-    "build": "npm run typecheck && electron-vite build",
+    "dev:web": "vite dev",
+    "build": "electron-vite build",
     "postinstall": "electron-builder install-app-deps",
     "build:unpack": "npm run build && electron-builder --dir",
     "build:win": "npm run build && electron-builder --win",
@@ -21,73 +23,97 @@
     "build:linux": "npm run build && electron-builder --linux"
   },
   "dependencies": {
-    "@electron-toolkit/preload": "^3.0.0",
-    "@electron-toolkit/utils": "^3.0.0",
+    "@electron-toolkit/preload": "^3.0.1",
+    "@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",
-    "netease-cloud-music-api-alger": "^4.25.0"
+    "electron-updater": "^6.6.2",
+    "electron-window-state": "^5.0.3",
+    "express": "^4.18.2",
+    "file-type": "^21.0.0",
+    "font-list": "^1.5.1",
+    "husky": "^9.1.7",
+    "music-metadata": "^11.2.3",
+    "netease-cloud-music-api-alger": "^4.26.1",
+    "node-id3": "^0.2.9",
+    "node-machine-id": "^1.1.12",
+    "vue-i18n": "^11.1.3"
   },
-  "devDependencies": { 
-    "marked": "^15.0.4",
-    "@electron-toolkit/eslint-config": "^1.0.2",
-    "@electron-toolkit/eslint-config-ts": "^2.0.0",
+  "devDependencies": {
+    "@electron-toolkit/eslint-config": "^2.1.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",
-    "@typescript-eslint/eslint-plugin": "^7.0.0",
-    "@typescript-eslint/parser": "^7.0.0",
+    "@types/tinycolor2": "^1.4.6",
+    "@typescript-eslint/eslint-plugin": "^8.30.1",
+    "@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-typescript": "^13.0.0",
+    "@vue/eslint-config-prettier": "^10.2.0",
+    "@vue/eslint-config-typescript": "^14.5.0",
     "@vue/runtime-core": "^3.5.0",
-    "@vueuse/core": "^11.0.3",
-    "@vueuse/electron": "^11.0.3",
+    "@vueuse/core": "^11.3.0",
+    "@vueuse/electron": "^11.3.0",
+    "animate.css": "^4.1.1",
     "autoprefixer": "^10.4.20",
     "axios": "^1.7.7",
     "cross-env": "^7.0.3",
-    "electron": "^31.0.2",
-    "electron-builder": "^24.13.3",
-    "electron-vite": "^2.3.0",
-    "eslint": "^8.57.0",
-    "eslint-config-airbnb-base": "^15.0.0",
-    "eslint-config-prettier": "^9.0.0",
+    "electron": "^35.2.0",
+    "electron-builder": "^25.1.8",
+    "electron-vite": "^3.1.0",
+    "eslint": "^9.0.0",
+    "eslint-config-prettier": "^10.1.2",
     "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-scoped-css": "^2.7.2",
+    "eslint-plugin-vue": "^10.0.0",
+    "eslint-plugin-vue-scoped-css": "^2.9.0",
     "howler": "^2.2.4",
     "lodash": "^4.17.21",
-    "naive-ui": "^2.39.0",
-    "postcss": "^8.4.49",
+    "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.2.0",
-    "sass": "^1.82.0",
-    "tailwindcss": "^3.4.15",
+    "remixicon": "^4.6.0",
+    "sass": "^1.86.0",
+    "tailwindcss": "^3.4.17",
+    "tinycolor2": "^1.6.0",
+    "tunajs": "^1.0.15",
     "typescript": "^5.5.2",
-    "unplugin-auto-import": "^0.18.2",
-    "unplugin-vue-components": "^0.27.4",
-    "vfonts": "^0.1.0",
-    "vite": "^5.3.1",
+    "unplugin-auto-import": "^19.1.1",
+    "unplugin-vue-components": "^28.4.1",
+    "vite": "^6.2.2",
     "vite-plugin-compression": "^0.5.1",
-    "vite-plugin-vue-devtools": "7.4.0",
-    "vue": "^3.4.30",
-    "vue-router": "^4.4.3",
-    "vue-tsc": "^2.0.22",
-    "vuex": "^4.1.0"
+    "vite-plugin-vue-devtools": "7.7.2",
+    "vue": "^3.5.13",
+    "vue-router": "^4.5.0",
+    "vue-tsc": "^2.0.22"
   },
   "build": {
     "appId": "com.alger.music",
     "productName": "AlgerMusicPlayer",
-    "publish": [{
-      "provider": "github",
-      "owner": "algerkong",
-      "repo": "AlgerMusicPlayer"
-    }],
+    "publish": [
+      {
+        "provider": "github",
+        "owner": "algerkong",
+        "repo": "AlgerMusicPlayer"
+      }
+    ],
+    "extraResources": [
+      {
+        "from": "resources/html",
+        "to": "html",
+        "filter": [
+          "**/*"
+        ]
+      }
+    ],
     "mac": {
       "icon": "resources/icon.icns",
       "target": [
@@ -112,11 +138,15 @@
       ]
     },
     "win": {
-      "icon": "resources/favicon.ico",
+      "icon": "resources/icon.ico",
       "target": [
         {
           "target": "nsis",
-          "arch": ["x64", "ia32"]
+          "arch": [
+            "x64",
+            "ia32",
+            "arm64"
+          ]
         }
       ],
       "artifactName": "${productName}-${version}-win-${arch}.${ext}",
@@ -127,11 +157,24 @@
       "target": [
         {
           "target": "AppImage",
-          "arch": ["x64"]
+          "arch": [
+            "x64",
+            "arm64"
+          ]
         },
         {
           "target": "deb",
-          "arch": ["x64"]
+          "arch": [
+            "x64",
+            "arm64"
+          ]
+        },
+        {
+          "target": "rpm",
+          "arch": [
+            "x64",
+            "arm64"
+          ]
         }
       ],
       "artifactName": "${productName}-${version}-linux-${arch}.${ext}",
@@ -141,8 +184,8 @@
     "nsis": {
       "oneClick": false,
       "allowToChangeInstallationDirectory": true,
-      "installerIcon": "resources/favicon.ico",
-      "uninstallerIcon": "resources/favicon.ico",
+      "installerIcon": "resources/icon.ico",
+      "uninstallerIcon": "resources/icon.ico",
       "createDesktopShortcut": true,
       "createStartMenuShortcut": true,
       "shortcutName": "AlgerMusicPlayer",

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/artist.ts

@@ -0,0 +1,5 @@
+export default {
+  hotSongs: 'Hot Songs',
+  albums: 'Albums',
+  description: 'Artist Introduction'
+};

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

@@ -0,0 +1,57 @@
+export default {
+  play: 'Play',
+  next: 'Next',
+  previous: 'Previous',
+  volume: 'Volume',
+  settings: 'Settings',
+  search: 'Search',
+  loading: 'Loading...',
+  loadingMore: 'Loading more...',
+  alipay: 'Alipay',
+  wechat: 'WeChat Pay',
+  on: 'On',
+  off: 'Off',
+  show: 'Show',
+  hide: 'Hide',
+  confirm: 'Confirm',
+  cancel: 'Cancel',
+  configure: 'Configure',
+  open: 'Open',
+  modify: 'Modify',
+  success: 'Operation Successful',
+  error: 'Operation Failed',
+  warning: 'Warning',
+  info: 'Info',
+  save: 'Save',
+  delete: 'Delete',
+  refresh: 'Refresh',
+  retry: 'Retry',
+  reset: 'Reset',
+  back: 'Back',
+  copySuccess: 'Copied to clipboard',
+  copyFailed: 'Copy failed',
+  validation: {
+    required: 'This field is required',
+    invalidInput: 'Invalid input',
+    selectRequired: 'Please select an option',
+    numberRange: 'Please enter a number between {min} and {max}',
+    ipAddress: 'Please enter a valid IP address',
+    portNumber: 'Please enter a valid port number (1-65535)'
+  },
+  viewMore: 'View More',
+  noMore: 'No more',
+  expand: 'Expand',
+  collapse: 'Collapse',
+  songCount: '{count} songs',
+  tray: {
+    show: 'Show',
+    quit: 'Quit',
+    playPause: 'Play/Pause',
+    prev: 'Previous',
+    next: 'Next',
+    pause: 'Pause',
+    play: 'Play',
+    favorite: 'Favorite'
+  },
+  language: 'Language'
+};

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

@@ -0,0 +1,192 @@
+export default {
+  installApp: {
+    description: 'Install the application for a better experience',
+    noPrompt: 'Do not prompt again',
+    install: 'Install now',
+    cancel: 'Cancel',
+    download: 'Download',
+    downloadFailed: 'Download failed',
+    downloadComplete: 'Download complete',
+    downloadProblem: 'Download problem? Go to',
+    downloadProblemLinkText: 'Download the latest version'
+  },
+  playlistDrawer: {
+    title: 'Add to playlist',
+    createPlaylist: 'Create new playlist',
+    cancelCreate: 'Cancel create',
+    create: 'Create',
+    playlistName: 'Playlist name',
+    privatePlaylist: 'Private playlist',
+    publicPlaylist: 'Public playlist',
+    createSuccess: 'Playlist created successfully',
+    createFailed: 'Playlist creation failed',
+    addSuccess: 'Song added successfully',
+    addFailed: 'Song addition failed',
+    private: 'Private',
+    public: 'Public',
+    count: 'songs',
+    loginFirst: 'Please login first',
+    getPlaylistFailed: 'Get playlist failed',
+    inputPlaylistName: 'Please enter the playlist name'
+  },
+  update: {
+    title: 'New version found',
+    currentVersion: 'Current version',
+    cancel: 'Do not update',
+    prepareDownload: 'Preparing to download...',
+    downloading: 'Downloading...',
+    nowUpdate: 'Update now',
+    downloadFailed: 'Download failed, please try again or download manually',
+    startFailed: 'Start download failed, please try again or download manually',
+    noDownloadUrl:
+      'No suitable installation package found for the current system, please download manually',
+    installConfirmTitle: 'Install Update',
+    installConfirmContent: 'Do you want to close the application and install the update?',
+    manualInstallTip:
+      'If the installer does not open automatically after closing the application, please find the file in your download folder and open it manually.',
+    yesInstall: 'Install Now',
+    noThanks: 'Later',
+    fileLocation: 'File Location',
+    copy: 'Copy Path',
+    copySuccess: 'Path copied to clipboard',
+    copyFailed: 'Copy failed',
+    backgroundDownload: 'Background Download'
+  },
+  coffee: {
+    title: 'Buy me a coffee',
+    alipay: 'Alipay',
+    wechat: 'Wechat',
+    alipayQR: 'Alipay QR code',
+    wechatQR: 'Wechat QR code',
+    coffeeDesc: 'A cup of coffee, a support',
+    coffeeDescLinkText: 'View more',
+    qqGroup: 'QQ group: algermusic',
+    messages: {
+      copySuccess: 'Copied to clipboard'
+    },
+    donateList: 'Buy me a coffee'
+  },
+  playlistType: {
+    title: 'Playlist Category',
+    showAll: 'Show all',
+    hide: 'Hide some'
+  },
+  recommendAlbum: {
+    title: 'Latest Album'
+  },
+  recommendSinger: {
+    title: 'Daily Recommendation',
+    songlist: 'Daily Recommendation List'
+  },
+  recommendSonglist: {
+    title: 'Weekly Hot Music'
+  },
+  searchBar: {
+    login: 'Login',
+    toLogin: 'To Login',
+    logout: 'Logout',
+    set: 'Settings',
+    theme: 'Theme',
+    restart: 'Restart',
+    refresh: 'Refresh',
+    currentVersion: 'Current Version',
+    searchPlaceholder: 'Search for something...',
+    zoom: 'Zoom',
+    zoom100: 'Zoom 100%',
+    resetZoom: 'Reset Zoom',
+    zoomDefault: 'Default Zoom'
+  },
+  titleBar: {
+    closeTitle: 'Choose how to close',
+    minimizeToTray: 'Minimize to Tray',
+    exitApp: 'Exit App',
+    rememberChoice: 'Remember my choice',
+    closeApp: 'Close App'
+  },
+  userPlayList: {
+    title: "{name}'s Playlist"
+  },
+  musicList: {
+    searchSongs: 'Search Songs',
+    noSearchResults: 'No search results',
+    switchToNormal: 'Switch to normal layout',
+    switchToCompact: 'Switch to compact layout',
+    playAll: 'Play All',
+    collect: 'Collect',
+    collectSuccess: 'Collect Success',
+    cancelCollectSuccess: 'Cancel Collect Success',
+    cancelCollect: 'Cancel Collect',
+    addToPlaylist: 'Add to Playlist',
+    addToPlaylistSuccess: 'Add to Playlist Success',
+    operationFailed: 'Operation Failed',
+    songsAlreadyInPlaylist: 'Songs already in playlist'
+  },
+  playlist: {
+    import: {
+      button: 'Import Playlist',
+      title: 'Import Playlist',
+      description: 'Import playlists via metadata, text, or links',
+      linkTab: 'Import by Link',
+      textTab: 'Import by Text',
+      localTab: 'Import by Metadata',
+      linkPlaceholder: 'Enter playlist links, one per line',
+      textPlaceholder: 'Enter song information in format: Song Name Artist Name',
+      localPlaceholder: 'Enter song metadata in JSON format',
+      linkTips: 'Supported link sources:',
+      linkTip1: 'Copy links after sharing playlists to WeChat/Weibo/QQ',
+      linkTip2: 'Directly copy playlist/profile links',
+      linkTip3: 'Directly copy article links',
+      textTips: 'Enter song information, one song per line',
+      textFormat: 'Format: Song Name Artist Name',
+      localTips: 'Add song metadata',
+      localFormat: 'Format example:',
+      songNamePlaceholder: 'Song Name',
+      artistNamePlaceholder: 'Artist Name',
+      albumNamePlaceholder: 'Album Name',
+      addSongButton: 'Add Song',
+      addLinkButton: 'Add Link',
+      importToStarPlaylist: 'Import to My Favorite Music',
+      playlistNamePlaceholder: 'Enter playlist name',
+      importButton: 'Start Import',
+      emptyLinkWarning: 'Please enter playlist links',
+      emptyTextWarning: 'Please enter song information',
+      emptyLocalWarning: 'Please enter song metadata',
+      invalidJsonFormat: 'Invalid JSON format',
+      importSuccess: 'Import task created successfully',
+      importFailed: 'Import failed',
+      importStatus: 'Import Status',
+      refresh: 'Refresh',
+      taskId: 'Task ID',
+      status: 'Status',
+      successCount: 'Success Count',
+      failReason: 'Failure Reason',
+      unknownError: 'Unknown error',
+      statusPending: 'Pending',
+      statusProcessing: 'Processing',
+      statusSuccess: 'Success',
+      statusFailed: 'Failed',
+      statusUnknown: 'Unknown',
+      taskList: 'Task List',
+      taskListTitle: 'Import Task List',
+      action: 'Action',
+      select: 'Select',
+      fetchTaskListFailed: 'Failed to fetch task list',
+      noTasks: 'No import tasks',
+      clearTasks: 'Clear Tasks',
+      clearTasksConfirmTitle: 'Confirm Clear',
+      clearTasksConfirmContent: 'Are you sure you want to clear all import task records? This action cannot be undone.',
+      confirm: 'Confirm',
+      cancel: 'Cancel',
+      clearTasksSuccess: 'Task list cleared',
+      clearTasksFailed: 'Failed to clear task list'
+    }
+  },
+  settings: 'Settings',
+  user: 'User',
+  toplist: 'Toplist',
+  history: 'History',
+  list: 'Playlist',
+  mv: 'MV',
+  home: 'Home',
+  search: 'Search'
+};

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

@@ -0,0 +1,9 @@
+export default {
+  description:
+    'Your donation will be used to support development and maintenance work, including but not limited to server maintenance, domain name renewal, etc.',
+  message: 'You can leave your email or github name when leaving a message.',
+  refresh: 'Refresh List',
+  toDonateList: 'Buy me a coffee',
+  title: 'Donation List',
+  noMessage: 'No Message'
+};

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

@@ -0,0 +1,91 @@
+export default {
+  title: 'Download Manager',
+  localMusic: 'Local Music',
+  count: '{count} songs in total',
+  clearAll: 'Clear All',
+  settings: 'Settings',
+  tabs: {
+    downloading: 'Downloading',
+    downloaded: 'Downloaded'
+  },
+  empty: {
+    noTasks: 'No download tasks',
+    noDownloaded: 'No downloaded songs',
+    noDownloadedHint: 'Download your favorite songs to listen offline'
+  },
+  progress: {
+    total: 'Total Progress: {progress}%'
+  },
+  items: 'items',
+  status: {
+    downloading: 'Downloading',
+    completed: 'Completed',
+    failed: 'Failed',
+    unknown: 'Unknown'
+  },
+  artist: {
+    unknown: 'Unknown Artist'
+  },
+  delete: {
+    title: 'Delete Confirmation',
+    message: 'Are you sure you want to delete "{filename}"? This action cannot be undone.',
+    confirm: 'Delete',
+    cancel: 'Cancel',
+    success: 'Successfully deleted',
+    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}',
+    alreadyDownloading: '{filename} is already downloading'
+  },
+  loading: 'Loading...',
+  playStarted: 'Play started: {name}',
+  playFailed: 'Play failed: {name}',
+  path: {
+    copied: 'Path copied to clipboard',
+    copyFailed: 'Failed to copy path'
+  },
+  settingsPanel: {
+    title: 'Download Settings',
+    path: 'Download Location',
+    pathDesc: 'Set where your music files will be saved',
+    pathPlaceholder: 'Please select download path',
+    noPathSelected: 'Please select download path first',
+    select: 'Select Folder',
+    open: 'Open Folder',
+    fileFormat: 'Filename Format',
+    fileFormatDesc: 'Set how downloaded music files will be named',
+    customFormat: 'Custom Format',
+    separator: 'Separator',
+    separators: {
+      dash: 'Space-dash-space',
+      underscore: 'Underscore',
+      space: 'Space'
+    },
+    dragToArrange: 'Sort or use arrow buttons to arrange:',
+    formatVariables: 'Available variables',
+    preview: 'Preview:',
+    saveSuccess: 'Download settings saved',
+    presets: {
+      songArtist: 'Song - Artist',
+      artistSong: 'Artist - Song',
+      songOnly: 'Song only'
+    },
+    components: {
+      songName: 'Song name',
+      artistName: 'Artist name',
+      albumName: 'Album name'
+    }
+  }
+};

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

@@ -0,0 +1,17 @@
+export default {
+  title: 'Favorites',
+  count: 'Total {count}',
+  batchDownload: 'Batch Download',
+  selectAll: 'All',
+  download: 'Download ({count})',
+  cancel: 'Cancel',
+  emptyTip: 'No favorite songs yet',
+  viewMore: 'View More',
+  noMore: 'No more',
+  downloadSuccess: 'Download completed',
+  downloadFailed: 'Download failed',
+  downloading: 'Downloading, please wait...',
+  selectSongsFirst: 'Please select songs to download first',
+  descending: 'Descending',
+  ascending: 'Ascending'
+};

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

@@ -0,0 +1,5 @@
+export default {
+  title: 'Play History',
+  playCount: '{count}',
+  getHistoryFailed: 'Failed to get play history'
+};

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

@@ -0,0 +1,29 @@
+import artist from './artist';
+import common from './common';
+import comp from './comp';
+import donation from './donation';
+import download from './download';
+import favorite from './favorite';
+import history from './history';
+import login from './login';
+import player from './player';
+import search from './search';
+import settings from './settings';
+import songItem from './songItem';
+import user from './user';
+
+export default {
+  common,
+  donation,
+  favorite,
+  history,
+  login,
+  player,
+  search,
+  settings,
+  songItem,
+  user,
+  download,
+  comp,
+  artist
+};

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

@@ -0,0 +1,22 @@
+export default {
+  title: {
+    qr: 'QR Code Login',
+    phone: 'Phone Login'
+  },
+  qrTip: 'Scan with NetEase Cloud Music APP',
+  phoneTip: 'Login with NetEase Cloud account',
+  placeholder: {
+    phone: 'Phone Number',
+    password: 'Password'
+  },
+  button: {
+    login: 'Login',
+    switchToQr: 'QR Code Login',
+    switchToPhone: 'Phone Login'
+  },
+  message: {
+    loginSuccess: 'Login successful',
+    loadError: 'Error loading login information',
+    qrCheckError: 'Error checking QR code status'
+  }
+};

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

@@ -0,0 +1,121 @@
+export default {
+  nowPlaying: 'Now Playing',
+  playlist: 'Playlist',
+  lyrics: 'Lyrics',
+  previous: 'Previous',
+  play: 'Play',
+  pause: 'Pause',
+  next: 'Next',
+  volumeUp: 'Volume Up',
+  volumeDown: 'Volume Down',
+  mute: 'Mute',
+  unmute: 'Unmute',
+  songNum: 'Song Number: {num}',
+  addCorrection: 'Add {num} seconds',
+  subtractCorrection: 'Subtract {num} seconds',
+  playFailed: 'Play Failed, Play Next Song',
+  playMode: {
+    sequence: 'Sequence',
+    loop: 'Loop',
+    random: 'Random'
+  },
+  fullscreen: {
+    enter: 'Enter Fullscreen',
+    exit: 'Exit Fullscreen'
+  },
+  close: 'Close',
+  modeHint: {
+    single: 'Single',
+    list: 'Next'
+  },
+  lrc: {
+    noLrc: 'No lyrics, please enjoy'
+  },
+  reparse: {
+    title: 'Select Music Source',
+    desc: 'Click a source to directly reparse the current song. This source will be used next time this song plays.',
+    success: 'Reparse successful',
+    failed: 'Reparse failed',
+    warning: 'Please select a music source',
+    bilibiliNotSupported: 'Bilibili videos do not support reparsing',
+    processing: 'Processing...'
+  },
+  playBar: {
+    expand: 'Expand Lyrics',
+    collapse: 'Collapse Lyrics',
+    like: 'Like',
+    lyric: 'Lyric',
+    noSongPlaying: 'No song playing',
+    eq: 'Equalizer',
+    playList: 'Play List',
+    reparse: 'Reparse',
+    playMode: {
+      sequence: 'Sequence',
+      loop: 'Loop',
+      random: 'Random'
+    },
+    play: 'Play',
+    pause: 'Pause',
+    prev: 'Previous',
+    next: 'Next',
+    volume: 'Volume',
+    favorite: 'Favorite {name}',
+    unFavorite: 'Unfavorite {name}',
+    playbackSpeed: 'Playback Speed',
+    advancedControls: 'Advanced Controls',
+  },
+  eq: {
+    title: 'Equalizer',
+    reset: 'Reset',
+    on: 'On',
+    off: 'Off',
+    bass: 'Bass',
+    midrange: 'Midrange',
+    treble: 'Treble',
+    presets: {
+      flat: 'Flat',
+      pop: 'Pop',
+      rock: 'Rock',
+      classical: 'Classical',
+      jazz: 'Jazz',
+      electronic: 'Electronic',
+      hiphop: 'Hip-Hop',
+      rb: 'R&B',
+      metal: 'Metal',
+      vocal: 'Vocal',
+      dance: 'Dance',
+      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'
+  },
+  playList: {
+    clearAll: 'Clear Playlist',
+    alreadyEmpty: 'Playlist is already empty',
+    cleared: 'Playlist cleared',
+    empty: 'Playlist is empty',
+    clearConfirmTitle: 'Clear Playlist',
+    clearConfirmContent: 'This will clear all songs in the playlist and stop the current playback. Continue?'
+  }
+};

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

@@ -0,0 +1,27 @@
+export default {
+  title: {
+    hotSearch: 'Hot Search',
+    searchList: 'Search Results',
+    searchHistory: 'Search History'
+  },
+  button: {
+    clear: 'Clear',
+    back: 'Back',
+    playAll: 'Play All'
+  },
+  loading: {
+    more: 'Loading...',
+    failed: 'Search failed'
+  },
+  noMore: 'No more results',
+  error: {
+    searchFailed: 'Search failed'
+  },
+  search: {
+    single: 'Single',
+    album: 'Album',
+    playlist: 'Playlist',
+    mv: 'MV',
+    bilibili: 'Bilibili'
+  }
+};

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

@@ -0,0 +1,263 @@
+export default {
+  theme: 'Theme',
+  language: 'Language',
+  regard: 'About',
+  logout: 'Logout',
+  sections: {
+    basic: 'Basic Settings',
+    playback: 'Playback Settings',
+    application: 'Application Settings',
+    network: 'Network Settings',
+    system: 'System Management',
+    donation: 'Donation',
+    regard: 'About'
+  },
+  basic: {
+    themeMode: 'Theme Mode',
+    themeModeDesc: 'Switch between light/dark theme',
+    language: 'Language Settings',
+    languageDesc: 'Change display language',
+    font: 'Font Settings',
+    fontDesc: 'Select fonts, prioritize fonts in order',
+    fontScope: {
+      global: 'Global',
+      lyric: 'Lyrics Only'
+    },
+    animation: 'Animation Speed',
+    animationDesc: 'Enable/disable animations',
+    animationSpeed: {
+      slow: 'Very Slow',
+      normal: 'Normal',
+      fast: 'Very Fast'
+    },
+    fontPreview: {
+      title: 'Font Preview',
+      chinese: 'Chinese',
+      english: 'English',
+      japanese: 'Japanese',
+      korean: 'Korean',
+      chineseText: '静夜思 床前明月光 疑是地上霜',
+      englishText: 'The quick brown fox jumps over the lazy dog',
+      japaneseText: 'あいうえお かきくけこ さしすせそ',
+      koreanText: '가나다라마 바사아자차 카타파하'
+    }
+  },
+  playback: {
+    quality: 'Audio Quality',
+    qualityDesc: 'Select music playback quality (VIP)',
+    qualityOptions: {
+      standard: 'Standard',
+      higher: 'Higher',
+      exhigh: 'Extreme',
+      lossless: 'Lossless',
+      hires: 'Hi-Res',
+      jyeffect: 'HD Surround',
+      sky: 'Immersive',
+      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',
+    showStatusBar: "Show Status Bar",
+    showStatusBarContent: "You can display the music control function in your mac status bar (effective after a restart)"
+  },
+  application: {
+    closeAction: 'Close Action',
+    closeActionDesc: 'Choose action when closing window',
+    closeOptions: {
+      ask: 'Ask Every Time',
+      minimize: 'Minimize to Tray',
+      close: 'Exit Directly'
+    },
+    shortcut: 'Shortcut Settings',
+    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',
+    remoteControl: 'Remote Control',
+    remoteControlDesc: 'Set remote control function'
+  },
+  network: {
+    apiPort: 'Music API Port',
+    apiPortDesc: 'Restart required after modification',
+    proxy: 'Proxy Settings',
+    proxyDesc: 'Enable proxy when unable to access music',
+    proxyHost: 'Proxy Host',
+    proxyHostPlaceholder: 'Enter proxy host',
+    proxyPort: 'Proxy Port',
+    proxyPortPlaceholder: 'Enter proxy port',
+    realIP: 'RealIP Settings',
+    realIPDesc: 'Use realIP parameter with mainland China IP to resolve access restrictions abroad',
+    messages: {
+      proxySuccess: 'Proxy settings saved, restart required to take effect',
+      proxyError: 'Please check your input',
+      realIPSuccess: 'RealIP settings saved',
+      realIPError: 'Please enter a valid IP address'
+    }
+  },
+  system: {
+    cache: 'Cache Management',
+    cacheDesc: 'Clear cache',
+    cacheClearTitle: 'Select cache types to clear:',
+    cacheTypes: {
+      history: {
+        label: 'Play History',
+        description: 'Clear played song records'
+      },
+      favorite: {
+        label: 'Favorites',
+        description: 'Clear local favorite songs (cloud favorites not affected)'
+      },
+      user: {
+        label: 'User Data',
+        description: 'Clear login info and user-related data'
+      },
+      settings: {
+        label: 'App Settings',
+        description: 'Clear all custom app settings'
+      },
+      downloads: {
+        label: 'Download History',
+        description: 'Clear download history (downloaded files not affected)'
+      },
+      resources: {
+        label: 'Music Resources',
+        description: 'Clear cached music files, lyrics and other resources'
+      },
+      lyrics: {
+        label: 'Lyrics Resources',
+        description: 'Clear cached lyrics resources'
+      }
+    },
+    restart: 'Restart',
+    restartDesc: 'Restart application',
+    messages: {
+      clearSuccess: 'Cache cleared successfully, some settings will take effect after restart'
+    }
+  },
+  about: {
+    version: 'Version',
+    checkUpdate: 'Check for Updates',
+    checking: 'Checking...',
+    latest: 'Already latest version',
+    hasUpdate: 'New version available',
+    gotoUpdate: 'Go to Update',
+    gotoGithub: 'Go to Github',
+    author: 'Author',
+    authorDesc: 'algerkong Give a star🌟',
+    messages: {
+      checkError: 'Failed to check for updates, please try again later'
+    }
+  },
+  validation: {
+    selectProxyProtocol: 'Please select proxy protocol',
+    proxyHost: 'Please enter proxy host',
+    portNumber: 'Please enter a valid port number (1-65535)'
+  },
+  lyricSettings: {
+    title: 'Lyric Settings',
+    tabs: {
+      display: 'Display',
+      interface: 'Interface',
+      typography: 'Typography',
+      mobile: 'Mobile'
+    },
+    pureMode: 'Pure Mode',
+    hideCover: 'Hide Cover',
+    centerDisplay: 'Center Display',
+    showTranslation: 'Show Translation',
+    hideLyrics: 'Hide Lyrics',
+    hidePlayBar: 'Hide Play Bar',
+    hideMiniPlayBar: 'Hide Mini Play Bar',
+    backgroundTheme: 'Background Theme',
+    themeOptions: {
+      default: 'Default',
+      light: 'Light',
+      dark: 'Dark'
+    },
+    fontSize: 'Font Size',
+    fontSizeMarks: {
+      small: 'Small',
+      medium: 'Medium',
+      large: 'Large'
+    },
+    letterSpacing: 'Letter Spacing',
+    letterSpacingMarks: {
+      compact: 'Compact',
+      default: 'Default',
+      loose: 'Loose'
+    },
+    lineHeight: 'Line Height',
+    lineHeightMarks: {
+      compact: 'Compact',
+      default: 'Default',
+      loose: 'Loose'
+    },
+    mobileLayout: 'Mobile Layout',
+    layoutOptions: {
+      default: 'Default',
+      ios: 'iOS Style',
+      android: 'Android Style'
+    },
+    mobileCoverStyle: 'Cover Style',
+    coverOptions: {
+      record: 'Record',
+      square: 'Square',
+      full: 'Full Screen'
+    },
+    lyricLines: 'Lyric Lines',
+    mobileUnavailable: 'This setting is only available on mobile devices'
+  },
+  shortcutSettings: {
+    title: 'Shortcut Settings',
+    shortcut: 'Shortcut',
+    shortcutDesc: 'Customize global shortcuts',
+    shortcutConflict: 'Shortcut Conflict',
+    inputPlaceholder: 'Click to input shortcut',
+    resetShortcuts: 'Reset',
+    disableAll: 'Disable All',
+    enableAll: 'Enable All',
+    togglePlay: 'Play/Pause',
+    prevPlay: 'Previous',
+    nextPlay: 'Next',
+    volumeUp: 'Volume Up',
+    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',
+      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

@@ -0,0 +1,28 @@
+export default {
+  menu: {
+    play: 'Play',
+    playNext: 'Play Next',
+    download: 'Download',
+    addToPlaylist: 'Add to Playlist',
+    favorite: 'Like',
+    unfavorite: 'Unlike',
+    removeFromPlaylist: 'Remove from Playlist',
+    dislike: 'Dislike',
+    undislike: 'Undislike',
+  },
+  message: {
+    downloading: 'Downloading, please wait...',
+    downloadFailed: 'Download failed',
+    downloadQueued: 'Added to download queue',
+    addedToNextPlay: 'Added to play next',
+    getUrlFailed: 'Failed to get music download URL, please check if logged in'
+  },
+  dialog: {
+    dislike:{
+      title: 'Dislike',
+      content: 'Are you sure you want to dislike this song?',
+      positiveText: 'Dislike',
+      negativeText: 'Cancel'
+    }
+  }
+};

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

@@ -0,0 +1,48 @@
+export default {
+  profile: {
+    followers: 'Followers',
+    following: 'Following',
+    level: 'Level'
+  },
+  playlist: {
+    created: 'Created Playlists',
+    mine: 'Mine',
+    trackCount: '{count} tracks',
+    playCount: 'Played {count} times'
+  },
+  ranking: {
+    title: 'Listening History',
+    playCount: '{count} times'
+  },
+  follow: {
+    title: 'Follow List',
+    viewPlaylist: 'View Playlist',
+    noFollowings: 'No Followings',
+    loadMore: 'Load More',
+    noSignature: 'This guy is lazy, nothing left',
+    userFollowsTitle: '\'s Followings',
+    myFollowsTitle: 'My Followings'
+  },
+  follower: {
+    title: 'Follower List',
+    noFollowers: 'No Followers',
+    loadMore: 'Load More',
+    userFollowersTitle: '\'s Followers',
+    myFollowersTitle: 'My Followers'
+  },
+  detail: {
+    playlists: 'Playlists',
+    records: 'Listening History',
+    noPlaylists: 'No Playlists',
+    noRecords: 'No Listening History',
+    artist: 'Artist',
+    noSignature: 'This guy is lazy, nothing left',
+    invalidUserId: 'Invalid User ID',
+    noRecordPermission: '{name} doesn\'t let you see your listening history'
+  },
+  message: {
+    loadFailed: 'Failed to load user page',
+    deleteSuccess: 'Successfully deleted',
+    deleteFailed: 'Failed to delete'
+  }
+};

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

@@ -0,0 +1,5 @@
+export default {
+  hotSongs: '热门歌曲',
+  albums: '专辑',
+  description: '艺人介绍'
+};

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

@@ -0,0 +1,56 @@
+export default {
+  play: '播放',
+  next: '下一首',
+  previous: '上一首',
+  volume: '音量',
+  settings: '设置',
+  search: '搜索',
+  loading: '加载中...',
+  loadingMore: '加载更多...',
+  alipay: '支付宝',
+  wechat: '微信支付',
+  on: '开启',
+  off: '关闭',
+  show: '显示',
+  hide: '隐藏',
+  confirm: '确认',
+  cancel: '取消',
+  configure: '配置',
+  open: '打开',
+  modify: '修改',
+  success: '操作成功',
+  error: '操作失败',
+  warning: '警告',
+  info: '提示',
+  save: '保存',
+  delete: '删除',
+  refresh: '刷新',
+  retry: '重试',
+  reset: '重置',
+  back: '返回',
+  copySuccess: '已复制到剪贴板',
+  copyFailed: '复制失败',
+  validation: {
+    required: '此项是必填的',
+    invalidInput: '输入无效',
+    selectRequired: '请选择一个选项',
+    numberRange: '请输入 {min} 到 {max} 之间的数字'
+  },
+  viewMore: '查看更多',
+  noMore: '没有更多了',
+  selectAll: '全选',
+  expand: '展开',
+  collapse: '收起',
+  songCount: '{count}首',
+  language: '语言',
+  tray: {
+    show: '显示',
+    quit: '退出',
+    playPause: '播放/暂停',
+    prev: '上一首',
+    next: '下一首',
+    pause: '暂停',
+    play: '播放',
+    favorite: '收藏'
+  }
+};

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

@@ -0,0 +1,190 @@
+export default {
+  installApp: {
+    description: '安装应用程序，获得更好的体验',
+    noPrompt: '不再提示',
+    install: '立即安装',
+    cancel: '暂不安装',
+    download: '下载',
+    downloadFailed: '下载失败',
+    downloadComplete: '下载完成',
+    downloadProblem: '下载遇到问题？去',
+    downloadProblemLinkText: '下载最新版本'
+  },
+  playlistDrawer: {
+    title: '添加到歌单',
+    createPlaylist: '创建新歌单',
+    cancelCreate: '取消创建',
+    create: '创建',
+    playlistName: '歌单名称',
+    privatePlaylist: '私密歌单',
+    publicPlaylist: '公开歌单',
+    createSuccess: '歌单创建成功',
+    createFailed: '歌单创建失败',
+    addSuccess: '歌曲添加成功',
+    addFailed: '歌曲添加失败',
+    private: '私密',
+    public: '公开',
+    count: '首歌曲',
+    loginFirst: '请先登录',
+    getPlaylistFailed: '获取歌单失败',
+    inputPlaylistName: '请输入歌单名称'
+  },
+  update: {
+    title: '发现新版本',
+    currentVersion: '当前版本',
+    cancel: '暂不更新',
+    prepareDownload: '准备下载...',
+    downloading: '下载中...',
+    nowUpdate: '立即更新',
+    downloadFailed: '下载失败，请重试或手动下载',
+    startFailed: '启动下载失败，请重试或手动下载',
+    noDownloadUrl: '未找到适合当前系统的安装包，请手动下载',
+    installConfirmTitle: '安装更新',
+    installConfirmContent: '是否关闭应用并安装更新？',
+    manualInstallTip: '如果关闭应用后没有正常弹出安装程序，请至下载文件夹查找文件并手动打开。',
+    yesInstall: '立即安装',
+    noThanks: '稍后安装',
+    fileLocation: '文件位置',
+    copy: '复制路径',
+    copySuccess: '路径已复制到剪贴板',
+    copyFailed: '复制失败',
+    backgroundDownload: '后台下载'
+  },
+  coffee: {
+    title: '请我喝咖啡',
+    alipay: '支付宝',
+    wechat: '微信支付',
+    alipayQR: '支付宝收款码',
+    wechatQR: '微信收款码',
+    coffeeDesc: '一杯咖啡，一份支持',
+    coffeeDescLinkText: '查看更多',
+    qqGroup: 'QQ频道：algermusic',
+    messages: {
+      copySuccess: '已复制到剪贴板'
+    },
+    donateList: '请我喝咖啡'
+  },
+  playlistType: {
+    title: '歌单分类',
+    showAll: '显示全部',
+    hide: '隐藏一些'
+  },
+  recommendAlbum: {
+    title: '最新专辑'
+  },
+  recommendSinger: {
+    title: '每日推荐',
+    songlist: '每日推荐列表'
+  },
+  recommendSonglist: {
+    title: '本周最热音乐'
+  },
+  searchBar: {
+    login: '登录',
+    toLogin: '去登录',
+    logout: '退出登录',
+    set: '设置',
+    theme: '主题',
+    restart: '重启',
+    refresh: '刷新',
+    currentVersion: '当前版本',
+    searchPlaceholder: '搜索点什么吧...',
+    zoom: '页面缩放',
+    zoom100: '标准缩放100%',
+    resetZoom: '点击重置缩放',
+    zoomDefault: '标准缩放'
+  },
+  titleBar: {
+    closeTitle: '请选择关闭方式',
+    minimizeToTray: '最小化到托盘',
+    exitApp: '退出应用',
+    rememberChoice: '记住我的选择',
+    closeApp: '关闭应用'
+  },
+  userPlayList: {
+    title: '{name}的常听'
+  },
+  musicList: {
+    searchSongs: '搜索歌曲',
+    noSearchResults: '没有找到相关歌曲',
+    switchToNormal: '切换到默认布局',
+    switchToCompact: '切换到紧凑布局',
+    playAll: '播放全部',
+    collect: '收藏',
+    collectSuccess: '收藏成功',
+    cancelCollectSuccess: '取消收藏成功',
+    operationFailed: '操作失败',
+    cancelCollect: '取消收藏',
+    addToPlaylist: '添加到播放列表',
+    addToPlaylistSuccess: '添加到播放列表成功',
+    songsAlreadyInPlaylist: '歌曲已存在于播放列表中'
+  },
+  playlist: {
+    import: {
+      button: '歌单导入',
+      title: '歌单导入',
+      description: '支持通过元数据/文字/链接三种方式导入歌单',
+      linkTab: '链接导入',
+      textTab: '文字导入',
+      localTab: '元数据导入',
+      linkPlaceholder: '请输入歌单链接，每行一个',
+      textPlaceholder: '请输入歌曲信息，格式为：歌曲名 歌手名',
+      localPlaceholder: '请输入JSON格式的歌曲元数据',
+      linkTips: '支持的链接来源：',
+      linkTip1: '将歌单分享到微信/微博/QQ后复制链接',
+      linkTip2: '直接复制歌单/个人主页链接',
+      linkTip3: '直接复制文章链接',
+      textTips: '请输入歌曲信息，每行一首歌',
+      textFormat: '格式：歌曲名 歌手名',
+      localTips: '请添加歌曲元数据',
+      localFormat: '格式示例：',
+      songNamePlaceholder: '歌曲名称',
+      artistNamePlaceholder: '艺术家名称',
+      albumNamePlaceholder: '专辑名称',
+      addSongButton: '添加歌曲',
+      addLinkButton: '添加链接',
+      importToStarPlaylist: '导入到我喜欢的音乐',
+      playlistNamePlaceholder: '请输入歌单名称',
+      importButton: '开始导入',
+      emptyLinkWarning: '请输入歌单链接',
+      emptyTextWarning: '请输入歌曲信息',
+      emptyLocalWarning: '请输入歌曲元数据',
+      invalidJsonFormat: 'JSON格式不正确',
+      importSuccess: '导入任务创建成功',
+      importFailed: '导入失败',
+      importStatus: '导入状态',
+      refresh: '刷新',
+      taskId: '任务ID',
+      status: '状态',
+      successCount: '成功数量',
+      failReason: '失败原因',
+      unknownError: '未知错误',
+      statusPending: '等待处理',
+      statusProcessing: '处理中',
+      statusSuccess: '导入成功',
+      statusFailed: '导入失败',
+      statusUnknown: '未知状态',
+      taskList: '任务列表',
+      taskListTitle: '导入任务列表',
+      action: '操作',
+      select: '选择',
+      fetchTaskListFailed: '获取任务列表失败',
+      noTasks: '暂无导入任务',
+      clearTasks: '清除任务',
+      clearTasksConfirmTitle: '确认清除',
+      clearTasksConfirmContent: '确定要清除所有导入任务记录吗？此操作不可恢复。',
+      confirm: '确认',
+      cancel: '取消',
+      clearTasksSuccess: '任务列表已清除',
+      clearTasksFailed: '清除任务列表失败'
+    }
+  },
+  settings: '设置',
+  user: '用户',
+  toplist: '排行榜',
+  history: '收藏历史',
+  list: '歌单',
+  mv: 'MV',
+  home: '首页',
+  search: '搜索'
+};

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

@@ -0,0 +1,8 @@
+export default {
+  description: '您的捐赠将用于支持开发和维护工作，包括但不限于服务器维护、域名续费等。',
+  message: '留言时可留下您的邮箱或 github名称。',
+  refresh: '刷新列表',
+  toDonateList: '请我喝咖啡',
+  noMessage: '暂无留言',
+  title: '捐赠列表'
+};

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

@@ -0,0 +1,87 @@
+export default {
+  title: '下载管理',
+  localMusic: '本地音乐',
+  count: '共 {count} 首歌曲',
+  clearAll: '清空记录',
+  settings: '设置',
+  tabs: {
+    downloading: '下载中',
+    downloaded: '已下载'
+  },
+  empty: {
+    noTasks: '暂无下载任务',
+    noDownloaded: '暂无已下载歌曲'
+  },
+  progress: {
+    total: '总进度: {progress}%'
+  },
+  status: {
+    downloading: '下载中',
+    completed: '已完成',
+    failed: '失败',
+    unknown: '未知'
+  },
+  artist: {
+    unknown: '未知歌手'
+  },
+  delete: {
+    title: '删除确认',
+    message: '确定要删除歌曲 "{filename}" 吗？此操作不可恢复。',
+    confirm: '确定删除',
+    cancel: '取消',
+    success: '删除成功',
+    failed: '删除失败',
+    fileNotFound: '文件不存在或已被移动，已从记录中移除',
+    recordRemoved: '文件删除失败，但已从记录中移除'
+  },
+  clear: {
+    title: '清空下载记录',
+    message: '确定要清空所有下载记录吗？此操作不会删除已下载的音乐文件，但将清空所有记录。',
+    confirm: '确定清空',
+    cancel: '取消',
+    success: '下载记录已清空'
+  },
+  message: {
+    downloadComplete: '{filename} 下载完成',
+    downloadFailed: '{filename} 下载失败: {error}'
+  },
+  loading: '加载中...',
+  playStarted: '开始播放: {name}',
+  playFailed: '播放失败: {name}',
+  path: {
+    copied: '路径已复制到剪贴板',
+    copyFailed: '复制路径失败'
+  },
+  settingsPanel: {
+    title: '下载设置',
+    path: '下载位置',
+    pathDesc: '设置音乐文件下载保存的位置',
+    pathPlaceholder: '请选择下载路径',
+    noPathSelected: '请先选择下载路径',
+    select: '选择文件夹',
+    open: '打开文件夹',
+    fileFormat: '文件名格式',
+    fileFormatDesc: '设置下载音乐时的文件命名格式',
+    customFormat: '自定义格式',
+    separator: '分隔符',
+    separators: {
+      dash: '空格-空格',
+      underscore: '下划线',
+      space: '空格'
+    },
+    dragToArrange: '拖动排序或使用箭头按钮调整顺序：',
+    formatVariables: '可用变量',
+    preview: '预览效果：',
+    saveSuccess: '下载设置已保存',
+    presets: {
+      songArtist: '歌曲名 - 歌手名',
+      artistSong: '歌手名 - 歌曲名',
+      songOnly: '仅歌曲名'
+    },
+    components: {
+      songName: '歌曲名',
+      artistName: '歌手名',
+      albumName: '专辑名'
+    }
+  }
+};

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

@@ -0,0 +1,13 @@
+export default {
+  title: '我的收藏',
+  count: '共 {count} 首',
+  batchDownload: '批量下载',
+  download: '下载 ({count})',
+  emptyTip: '还没有收藏歌曲',
+  downloadSuccess: '下载完成',
+  downloadFailed: '下载失败',
+  downloading: '正在下载中，请稍候...',
+  selectSongsFirst: '请先选择要下载的歌曲',
+  descending: '降',
+  ascending: '升'
+};

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

@@ -0,0 +1,5 @@
+export default {
+  title: '播放历史',
+  playCount: '{count}',
+  getHistoryFailed: '获取历史记录失败'
+};

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

@@ -0,0 +1,29 @@
+import artist from './artist';
+import common from './common';
+import comp from './comp';
+import donation from './donation';
+import download from './download';
+import favorite from './favorite';
+import history from './history';
+import login from './login';
+import player from './player';
+import search from './search';
+import settings from './settings';
+import songItem from './songItem';
+import user from './user';
+
+export default {
+  common,
+  donation,
+  favorite,
+  history,
+  login,
+  player,
+  search,
+  settings,
+  songItem,
+  user,
+  download,
+  comp,
+  artist
+};

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

@@ -0,0 +1,22 @@
+export default {
+  title: {
+    qr: '扫码登录',
+    phone: '手机号登录'
+  },
+  qrTip: '使用网易云APP扫码登录',
+  phoneTip: '使用网易云账号登录',
+  placeholder: {
+    phone: '手机号',
+    password: '密码'
+  },
+  button: {
+    login: '登录',
+    switchToQr: '扫码登录',
+    switchToPhone: '手机号登录'
+  },
+  message: {
+    loginSuccess: '登录成功',
+    loadError: '加载登录信息时出错',
+    qrCheckError: '检查二维码状态时出错'
+  }
+};

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

@@ -0,0 +1,122 @@
+export default {
+  nowPlaying: '正在播放',
+  playlist: '播放列表',
+  lyrics: '歌词',
+  previous: '上一个',
+  play: '播放',
+  pause: '暂停',
+  next: '下一个',
+  volumeUp: '音量增加',
+  volumeDown: '音量减少',
+  mute: '静音',
+  unmute: '取消静音',
+  songNum: '歌曲总数：{num}',
+  addCorrection: '提前 {num} 秒',
+  subtractCorrection: '延迟 {num} 秒',
+  playFailed: '当前歌曲播放失败，播放下一首',
+  playMode: {
+    sequence: '顺序播放',
+    loop: '单曲循环',
+    random: '随机播放'
+  },
+  fullscreen: {
+    enter: '全屏',
+    exit: '退出全屏'
+  },
+  close: '关闭',
+  modeHint: {
+    single: '单曲循环',
+    list: '自动播放下一个'
+  },
+  lrc: {
+    noLrc: '暂无歌词, 请欣赏'
+  },
+  reparse: {
+    title: '选择解析音源',
+    desc: '点击音源直接进行解析，下次播放此歌曲时将使用所选音源',
+    success: '重新解析成功',
+    failed: '重新解析失败',
+    warning: '请选择一个音源',
+    bilibiliNotSupported: 'B站视频不支持重新解析',
+    processing: '解析中...'
+  },
+  playBar: {
+    expand: '展开歌词',
+    collapse: '收起歌词',
+    like: '喜欢',
+    lyric: '歌词',
+    noSongPlaying: '没有正在播放的歌曲',
+    eq: '均衡器',
+    playList: '播放列表',
+    reparse: '重新解析',
+    playMode: {
+      sequence: '顺序播放',
+      loop: '循环播放',
+      random: '随机播放'
+    },
+    play: '开始播放',
+    pause: '暂停播放',
+    prev: '上一首',
+    next: '下一首',
+    volume: '音量',
+    favorite: '已收藏{name}',
+    unFavorite: '已取消收藏{name}',
+    miniPlayBar: '迷你播放栏',
+    playbackSpeed: '播放速度',
+    advancedControls: '更多设置s',
+  },
+  eq: {
+    title: '均衡器',
+    reset: '重置',
+    on: '开启',
+    off: '关闭',
+    bass: '低音',
+    midrange: '中音',
+    treble: '高音',
+    presets: {
+      flat: '平坦',
+      pop: '流行',
+      rock: '摇滚',
+      classical: '古典',
+      jazz: '爵士',
+      electronic: '电子',
+      hiphop: '嘻哈',
+      rb: 'R&B',
+      metal: '金属',
+      vocal: '人声',
+      dance: '舞曲',
+      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}首歌'
+  },
+  playList: {
+    clearAll: '清空播放列表',
+    alreadyEmpty: '播放列表已经为空',
+    cleared: '已清空播放列表',
+    empty: '播放列表为空',
+    clearConfirmTitle: '清空播放列表',
+    clearConfirmContent: '这将清空所有播放列表中的歌曲并停止当前播放。是否继续？'
+  }
+};

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

@@ -0,0 +1,27 @@
+export default {
+  title: {
+    hotSearch: '热搜列表',
+    searchList: '搜索列表',
+    searchHistory: '搜索历史'
+  },
+  button: {
+    clear: '清空',
+    back: '返回',
+    playAll: '播放列表'
+  },
+  loading: {
+    more: '加载中...',
+    failed: '搜索失败'
+  },
+  noMore: '没有更多了',
+  error: {
+    searchFailed: '搜索失败'
+  },
+  search: {
+    single: '单曲',
+    album: '专辑',
+    playlist: '歌单',
+    mv: 'MV',
+    bilibili: 'B站'
+  }
+};

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

@@ -0,0 +1,263 @@
+export default {
+  theme: '主题',
+  language: '语言',
+  regard: '关于',
+  logout: '退出登录',
+  sections: {
+    basic: '基础设置',
+    playback: '播放设置',
+    application: '应用设置',
+    network: '网络设置',
+    system: '系统管理',
+    donation: '捐赠支持',
+    regard: '关于'
+  },
+  basic: {
+    themeMode: '主题模式',
+    themeModeDesc: '切换日间/夜间主题',
+    language: '语言设置',
+    languageDesc: '切换显示语言',
+    font: '字体设置',
+    fontDesc: '选择字体，优先使用排在前面的字体',
+    fontScope: {
+      global: '全局',
+      lyric: '仅歌词'
+    },
+    animation: '动画速度',
+    animationDesc: '是否开启动画',
+    animationSpeed: {
+      slow: '极慢',
+      normal: '正常',
+      fast: '极快'
+    },
+    fontPreview: {
+      title: '字体预览',
+      chinese: '中文',
+      english: 'English',
+      japanese: '日本語',
+      korean: '한국어',
+      chineseText: '静夜思 床前明月光 疑是地上霜',
+      englishText: 'The quick brown fox jumps over the lazy dog',
+      japaneseText: 'あいうえお かきくけこ さしすせそ',
+      koreanText: '가나다라마 바사아자차 카타파하'
+    }
+  },
+  playback: {
+    quality: '音质设置',
+    qualityDesc: '选择音乐播放音质（网易云VIP）',
+    qualityOptions: {
+      standard: '标准',
+      higher: '较高',
+      exhigh: '极高',
+      lossless: '无损',
+      hires: 'Hi-Res',
+      jyeffect: '高清环绕声',
+      sky: '沉浸环绕声',
+      dolby: '杜比全景声',
+      jymaster: '超清母带'
+    },
+    musicSources: '音源设置',
+    musicSourcesDesc: '选择音乐解析使用的音源平台',
+    musicSourcesWarning: '至少需要选择一个音源平台',
+    musicUnblockEnable: '启用音乐解析',
+    musicUnblockEnableDesc: '开启后将尝试解析无法播放的音乐',
+    configureMusicSources: '配置音源',
+    selectedMusicSources: '已选音源：',
+    noMusicSources: '未选择音源',
+    gdmusicInfo: 'GD音乐台可自动解析多个平台音源，自动选择最佳结果',
+    autoPlay: '自动播放',
+    autoPlayDesc: '重新打开应用时是否自动继续播放',
+    showStatusBar: '是否显示状态栏控制功能',
+    showStatusBarContent: '可以在您的mac状态栏显示音乐控制功能(重启后生效)',
+  },
+  application: {
+    closeAction: '关闭行为',
+    closeActionDesc: '选择关闭窗口时的行为',
+    closeOptions: {
+      ask: '每次询问',
+      minimize: '最小化到托盘',
+      close: '直接退出'
+    },
+    shortcut: '快捷键设置',
+    shortcutDesc: '自定义全局快捷键',
+    download: '下载管理',
+    downloadDesc: '是否始终显示下载列表按钮',
+    unlimitedDownload: '无限制下载',
+    unlimitedDownloadDesc: '开启后将无限制下载音乐（可能出现下载失败的情况）, 默认限制 300 首',
+    downloadPath: '下载目录',
+    downloadPathDesc: '选择音乐文件的下载位置',
+    remoteControl: '远程控制',
+    remoteControlDesc: '设置远程控制功能'
+  },
+  network: {
+    apiPort: '音乐API端口',
+    apiPortDesc: '修改后需要重启应用',
+    proxy: '代理设置',
+    proxyDesc: '无法访问音乐时可以开启代理',
+    proxyHost: '代理地址',
+    proxyHostPlaceholder: '请输入代理地址',
+    proxyPort: '代理端口',
+    proxyPortPlaceholder: '请输入代理端口',
+    realIP: 'realIP设置',
+    realIPDesc: '由于限制,此项目在国外使用会受到限制可使用realIP参数,传进国内IP解决',
+    messages: {
+      proxySuccess: '代理设置已保存，重启应用后生效',
+      proxyError: '请检查输入是否正确',
+      realIPSuccess: '真实IP设置已保存',
+      realIPError: '请输入有效的IP地址'
+    }
+  },
+  system: {
+    cache: '缓存管理',
+    cacheDesc: '清除缓存',
+    cacheClearTitle: '请选择要清除的缓存类型：',
+    cacheTypes: {
+      history: {
+        label: '播放历史',
+        description: '清除播放过的歌曲记录'
+      },
+      favorite: {
+        label: '收藏记录',
+        description: '清除本地收藏的歌曲记录(不会影响云端收藏)'
+      },
+      user: {
+        label: '用户数据',
+        description: '清除登录信息和用户相关数据'
+      },
+      settings: {
+        label: '应用设置',
+        description: '清除应用的所有自定义设置'
+      },
+      downloads: {
+        label: '下载记录',
+        description: '清除下载历史记录(不会删除已下载的文件)'
+      },
+      resources: {
+        label: '音乐资源',
+        description: '清除已加载的音乐文件、歌词等资源缓存'
+      },
+      lyrics: {
+        label: '歌词资源',
+        description: '清除已加载的歌词资源缓存'
+      }
+    },
+    restart: '重启',
+    restartDesc: '重启应用',
+    messages: {
+      clearSuccess: '清除成功，部分设置在重启后生效'
+    }
+  },
+  about: {
+    version: '版本',
+    checkUpdate: '检查更新',
+    checking: '检查中...',
+    latest: '当前已是最新版本',
+    hasUpdate: '发现新版本',
+    gotoUpdate: '前往更新',
+    gotoGithub: '前往 Github',
+    author: '作者',
+    authorDesc: 'algerkong 点个star🌟呗',
+    messages: {
+      checkError: '检查更新失败，请稍后重试'
+    }
+  },
+  validation: {
+    selectProxyProtocol: '请选择代理协议',
+    proxyHost: '请输入代理地址',
+    portNumber: '请输入有效的端口号(1-65535)'
+  },
+  lyricSettings: {
+    title: '歌词设置',
+    tabs: {
+      display: '显示',
+      interface: '界面',
+      typography: '文字',
+      mobile: '移动端'
+    },
+    pureMode: '纯净模式',
+    hideCover: '隐藏封面',
+    centerDisplay: '居中显示',
+    showTranslation: '显示翻译',
+    hideLyrics: '隐藏歌词',
+    hidePlayBar: '隐藏播放栏',
+    hideMiniPlayBar: '隐藏迷你播放栏',
+    backgroundTheme: '背景主题',
+    themeOptions: {
+      default: '默认',
+      light: '亮色',
+      dark: '暗色'
+    },
+    fontSize: '字体大小',
+    fontSizeMarks: {
+      small: '小',
+      medium: '中',
+      large: '大'
+    },
+    letterSpacing: '字间距',
+    letterSpacingMarks: {
+      compact: '紧凑',
+      default: '默认',
+      loose: '宽松'
+    },
+    lineHeight: '行高',
+    lineHeightMarks: {
+      compact: '紧凑',
+      default: '默认',
+      loose: '宽松'
+    },
+    mobileLayout: '移动端布局',
+    layoutOptions: {
+      default: '默认',
+      ios: 'iOS风格',
+      android: '安卓风格'
+    },
+    mobileCoverStyle: '封面样式',
+    coverOptions: {
+      record: '唱片',
+      square: '方形',
+      full: '全屏'
+    },
+    lyricLines: '歌词行数',
+    mobileUnavailable: '此设置仅在移动端可用'
+  },
+  shortcutSettings: {
+    title: '快捷键设置',
+    shortcut: '快捷键',
+    shortcutDesc: '自定义快捷键',
+    shortcutConflict: '快捷键冲突',
+    inputPlaceholder: '点击输入快捷键',
+    resetShortcuts: '恢复默认',
+    disableAll: '全部禁用',
+    enableAll: '全部启用',
+    togglePlay: '播放/暂停',
+    prevPlay: '上一首',
+    nextPlay: '下一首',
+    volumeUp: '音量增加',
+    volumeDown: '音量减少',
+    toggleFavorite: '收藏/取消收藏',
+    toggleWindow: '显示/隐藏窗口',
+    scopeGlobal: '全局',
+    scopeApp: '应用内',
+    enabled: '启用',
+    disabled: '禁用',
+    messages: {
+      resetSuccess: '已恢复默认快捷键，请记得保存',
+      conflict: '存在冲突的快捷键，请重新设置',
+      saveSuccess: '快捷键设置已保存',
+      saveError: '保存快捷键失败，请重试',
+      cancelEdit: '已取消修改',
+      disableAll: '已禁用所有快捷键，请记得保存',
+      enableAll: '已启用所有快捷键，请记得保存'
+    }
+  },
+  remoteControl: {
+    title: '远程控制',
+    enable: '启用远程控制',
+    port: '服务端口',
+    allowedIps: '允许的IP地址',
+    addIp: '添加IP',
+    emptyListHint: '空列表表示允许所有IP访问',
+    saveSuccess: '远程控制设置已保存',
+    accessInfo: '远程控制访问地址:',
+  }
+};

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

@@ -0,0 +1,28 @@
+export default {
+  menu: {
+    play: '播放',
+    playNext: '下一首播放',
+    download: '下载歌曲',
+    addToPlaylist: '添加到歌单',
+    favorite: '喜欢',
+    unfavorite: '取消喜欢',
+    removeFromPlaylist: '从歌单中删除',
+    dislike: '不喜欢',
+    undislike: '取消不喜欢',
+  },
+  message: {
+    downloading: '正在下载中，请稍候...',
+    downloadFailed: '下载失败',
+    downloadQueued: '已加入下载队列',
+    addedToNextPlay: '已添加到下一首播放',
+    getUrlFailed: '获取音乐下载地址失败，请检查是否登录'
+  },
+  dialog: {
+    dislike: {
+      title: '提示！',
+      content: '确认不喜欢这首歌吗？再次进入将从每日推荐中排除。',
+      positiveText: '不喜欢',
+      negativeText: '取消'
+    }
+  }
+};

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

@@ -0,0 +1,48 @@
+export default {
+  profile: {
+    followers: '粉丝',
+    following: '关注',
+    level: '等级'
+  },
+  playlist: {
+    created: '创建的歌单',
+    mine: '我创建的',
+    trackCount: '{count}首',
+    playCount: '播放{count}次'
+  },
+  ranking: {
+    title: '听歌排行',
+    playCount: '{count}次'
+  },
+  follow: {
+    title: '关注列表',
+    viewPlaylist: '查看歌单',
+    noFollowings: '暂无关注',
+    loadMore: '加载更多',
+    noSignature: '这个家伙很懒，什么都没留下',
+    userFollowsTitle: '的关注',
+    myFollowsTitle: '我的关注'
+  },
+  follower: {
+    title: '粉丝列表',
+    noFollowers: '暂无粉丝',
+    loadMore: '加载更多',
+    userFollowersTitle: '的粉丝',
+    myFollowersTitle: '我的粉丝'
+  },
+  detail: {
+    playlists: '歌单',
+    records: '听歌排行',
+    noPlaylists: '暂无歌单',
+    noRecords: '暂无听歌记录',
+    artist: '歌手',
+    noSignature: '这个人很懒，什么都没留下',
+    invalidUserId: '用户ID无效',
+    noRecordPermission: '{name}不让你看听歌排行'
+  },
+  message: {
+    loadFailed: '加载用户页面失败',
+    deleteSuccess: '删除成功',
+    deleteFailed: '删除失败'
+  }
+};

src/i18n/main.ts

@@ -0,0 +1,38 @@
+import enUS from './lang/en-US';
+import zhCN from './lang/zh-CN';
+
+const messages = {
+  'zh-CN': zhCN,
+  'en-US': enUS
+} as const;
+
+type Language = keyof typeof messages;
+
+// 为主进程提供一个简单的 i18n 实现
+const mainI18n = {
+  global: {
+    currentLocale: 'zh-CN' as Language,
+    get locale() {
+      return this.currentLocale;
+    },
+    set locale(value: Language) {
+      this.currentLocale = value;
+    },
+    t(key: string) {
+      const keys = key.split('.');
+      let current: any = messages[this.currentLocale];
+      for (const k of keys) {
+        if (current[k] === undefined) {
+          // 如果找不到翻译，返回键名
+          return key;
+        }
+        current = current[k];
+      }
+      return current;
+    },
+    messages
+  }
+};
+
+export type { Language };
+export default mainI18n;

src/i18n/renderer.ts

@@ -0,0 +1,21 @@
+import { createI18n } from 'vue-i18n';
+
+import enUS from './lang/en-US';
+import zhCN from './lang/zh-CN';
+
+const messages = {
+  'zh-CN': zhCN,
+  'en-US': enUS
+};
+
+const i18n = createI18n({
+  legacy: false,
+  locale: 'zh-CN',
+  fallbackLocale: 'en-US',
+  messages,
+  globalInjection: true,
+  silentTranslationWarn: true,
+  silentFallbackWarn: true
+});
+
+export default i18n;

src/locale/zh-CN.json

@@ -0,0 +1,58 @@
+{
+  "settings": {
+    "lyricSettings": {
+      "title": "歌词设置",
+      "tabs": {
+        "display": "显示",
+        "interface": "界面",
+        "typography": "文字",
+        "mobile": "移动端"
+      },
+      "pureMode": "纯净模式",
+      "hideCover": "隐藏封面",
+      "centerDisplay": "居中显示",
+      "showTranslation": "显示翻译",
+      "hideLyrics": "隐藏歌词",
+      "hidePlayBar": "隐藏播放栏",
+      "hideMiniPlayBar": "隐藏迷你播放栏",
+      "backgroundTheme": "背景主题",
+      "themeOptions": {
+        "default": "默认",
+        "light": "亮色",
+        "dark": "暗色"
+      },
+      "fontSize": "字体大小",
+      "fontSizeMarks": {
+        "small": "小",
+        "medium": "中",
+        "large": "大"
+      },
+      "letterSpacing": "字间距",
+      "letterSpacingMarks": {
+        "compact": "紧凑",
+        "default": "默认",
+        "loose": "宽松"
+      },
+      "lineHeight": "行高",
+      "lineHeightMarks": {
+        "compact": "紧凑",
+        "default": "默认",
+        "loose": "宽松"
+      },
+      "mobileLayout": "移动端布局",
+      "layoutOptions": {
+        "default": "默认",
+        "ios": "iOS风格",
+        "android": "安卓风格"
+      },
+      "mobileCoverStyle": "封面样式",
+      "coverOptions": {
+        "record": "唱片",
+        "square": "方形",
+        "full": "全屏"
+      },
+      "lyricLines": "歌词行数",
+      "mobileUnavailable": "此设置仅在移动端可用"
+    }
+  }
+} 

src/main/index.ts

@@ -1,21 +1,27 @@
 import { electronApp, optimizer } from '@electron-toolkit/utils';
-import { app, globalShortcut, ipcMain, nativeImage } from 'electron';
+import { app, ipcMain, nativeImage } from 'electron';
 import { join } from 'path';
 
+import type { Language } from '../i18n/main';
+import i18n from '../i18n/main';
 import { loadLyricWindow } from './lyric';
-import { startMusicApi } from './server';
-import { initializeFileManager } from './modules/fileManager';
-import { initializeTray } from './modules/tray';
-import { createMainWindow, initializeWindowManager } from './modules/window';
 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';
+import { startMusicApi } from './server';
+import { initWindowSizeManager } from './modules/window-size';
 
 // 导入所有图标
 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')
 );
 
@@ -23,70 +29,129 @@ let mainWindow: Electron.BrowserWindow;
 
 // 初始化应用
 function initialize() {
-  // 初始化各个模块
-  initializeConfig();
+  // 初始化配置管理
+  const store = initializeConfig();
+
+  // 设置初始语言
+  const savedLanguage = store.get('set.language') as Language;
+  if (savedLanguage) {
+    i18n.global.locale = savedLanguage;
+  }
+
+  // 初始化文件管理
   initializeFileManager();
-  
-  // 创建主窗口
-  mainWindow = createMainWindow(icon);
-  
   // 初始化窗口管理
   initializeWindowManager();
-  
+  // 初始化字体管理
+  initializeFonts();
+
+  // 创建主窗口
+  mainWindow = createMainWindow(icon);
+
   // 初始化托盘
   initializeTray(iconPath, mainWindow);
-  
+
+  // 初始化统计服务
+  initializeStats();
+
+  // 设置统计相关的IPC处理程序
+  setupStatsHandlers(ipcMain);
+
   // 启动音乐API
   startMusicApi();
-  
+
   // 加载歌词窗口
   loadLyricWindow(ipcMain, mainWindow);
+
+  // 初始化快捷键
+  initializeShortcuts(mainWindow);
+
+  // 初始化远程控制服务
+  initializeRemoteControl(mainWindow);
+
+  // 初始化更新处理程序
+  setupUpdateHandlers(mainWindow);
 }
 
-// 应用程序准备就绪时的处理
-app.whenReady().then(() => {
-  // 设置应用ID
-  electronApp.setAppUserModelId('com.alger.music');
+// 检查是否为第一个实例
+const isSingleInstance = app.requestSingleInstanceLock();
 
-  // 监听窗口创建事件
-  app.on('browser-window-created', (_, window) => {
-    optimizer.watchWindowShortcuts(window);
-  });
-
-  // 初始化应用
-  initialize();
-
-  // macOS 激活应用时的处理
-  app.on('activate', function () {
-    if (mainWindow === null) initialize();
-  });
-});
-
-// 应用程序准备就绪后的快捷键设置
-app.on('ready', () => {
-  globalShortcut.register('CommandOrControl+Alt+Shift+M', () => {
-    if (mainWindow.isVisible()) {
-      mainWindow.hide();
-    } else {
+if (!isSingleInstance) {
+  app.quit();
+} else {
+  // 当第二个实例启动时，将焦点转移到第一个实例的窗口
+  app.on('second-instance', () => {
+    if (mainWindow) {
+      if (mainWindow.isMinimized()) {
+        mainWindow.restore();
+      }
       mainWindow.show();
+      mainWindow.focus();
     }
   });
-});
 
-// 所有窗口关闭时的处理
-app.on('window-all-closed', () => {
-  if (process.platform !== 'darwin') {
-    app.quit();
-  }
-});
+  // 应用程序准备就绪时的处理
+  app.whenReady().then(() => {
+    // 设置应用ID
+    electronApp.setAppUserModelId('com.alger.music');
 
-// 重启应用
-ipcMain.on('restart', () => {
-  app.relaunch();
-  app.exit(0);
-});
+    // 监听窗口创建事件
+    app.on('browser-window-created', (_, window) => {
+      optimizer.watchWindowShortcuts(window);
+    });
 
-// 获取系统架构信息
-ipcMain.on('get-arch', (event) => {
-  event.returnValue = process.arch;
-});
+    // 初始化窗口大小管理器
+    initWindowSizeManager();
+
+    // 初始化应用
+    initialize();
+
+    // macOS 激活应用时的处理
+    app.on('activate', () => {
+      if (mainWindow === null) initialize();
+    });
+  });
+
+  // 监听快捷键更新
+  ipcMain.on('update-shortcuts', () => {
+    registerShortcuts(mainWindow);
+  });
+
+  // 监听语言切换
+  ipcMain.on('change-language', (_, locale: Language) => {
+    // 更新主进程的语言设置
+    i18n.global.locale = locale;
+    // 更新托盘菜单
+    updateTrayMenu(mainWindow);
+    // 通知所有窗口语言已更改
+    mainWindow?.webContents.send('language-changed', locale);
+  });
+
+  // 监听播放状态变化
+  ipcMain.on('update-play-state', (_, playing: boolean) => {
+    updatePlayState(playing);
+  });
+
+  // 监听当前歌曲变化
+  ipcMain.on('update-current-song', (_, song: any) => {
+    updateCurrentSong(song);
+  });
+
+  // 所有窗口关闭时的处理
+  app.on('window-all-closed', () => {
+    if (process.platform !== 'darwin') {
+      app.quit();
+    }
+  });
+
+  // 重启应用
+  ipcMain.on('restart', () => {
+    app.relaunch();
+    app.exit(0);
+  });
+
+  // 获取系统架构信息
+  ipcMain.on('get-arch', (event) => {
+    event.returnValue = process.arch;
+  });
+}

src/main/lyric.ts

@@ -5,6 +5,12 @@ import path, { join } from 'path';
 const store = new Store();
 let lyricWindow: BrowserWindow | null = null;
 
+// 跟踪拖动状态
+let isDragging = false;
+
+// 添加窗口大小变化防护
+let originalSize = { width: 0, height: 0 };
+
 const createWin = () => {
   console.log('Creating lyric window');
 
@@ -15,31 +21,83 @@ const createWin = () => {
       y?: number;
       width?: number;
       height?: number;
+      displayId?: number;
     }) || {};
-  const { x, y, width, height } = windowBounds;
 
-  // 获取屏幕尺寸
-  const { width: screenWidth, height: screenHeight } = screen.getPrimaryDisplay().workAreaSize;
+  const { x, y, width, height, displayId } = windowBounds;
 
-  // 验证保存的位置是否有效
-  const validPosition =
-    x !== undefined && y !== undefined && x >= 0 && y >= 0 && x < screenWidth && y < screenHeight;
+  // 获取所有屏幕的信息
+  const displays = screen.getAllDisplays();
+  let isValidPosition = false;
+  let targetDisplay = displays[0]; // 默认使用主显示器
+
+  // 如果有显示器ID，尝试按ID匹配
+  if (displayId) {
+    const matchedDisplay = displays.find((d) => d.id === displayId);
+    if (matchedDisplay) {
+      targetDisplay = matchedDisplay;
+      console.log('Found matching display by ID:', displayId);
+    }
+  }
+
+  // 验证位置是否在任何显示器的范围内
+  if (x !== undefined && y !== undefined) {
+    for (const display of displays) {
+      const { bounds } = display;
+      if (
+        x >= bounds.x - 50 && // 允许一点偏移，避免卡在边缘
+        x < bounds.x + bounds.width + 50 &&
+        y >= bounds.y - 50 &&
+        y < bounds.y + bounds.height + 50
+      ) {
+        isValidPosition = true;
+        targetDisplay = display;
+        break;
+      }
+    }
+  }
+
+  // 确保宽高合理
+  const defaultWidth = 800;
+  const defaultHeight = 200;
+  const maxWidth = 1600; // 设置最大宽度限制
+  const maxHeight = 800; // 设置最大高度限制
+
+  const validWidth = width && width > 0 && width <= maxWidth ? width : defaultWidth;
+  const validHeight = height && height > 0 && height <= maxHeight ? height : defaultHeight;
+
+  // 确定窗口位置
+  let windowX = isValidPosition ? x : undefined;
+  let windowY = isValidPosition ? y : undefined;
+
+  // 如果位置无效，默认在当前显示器中居中
+  if (windowX === undefined || windowY === undefined) {
+    windowX = targetDisplay.bounds.x + (targetDisplay.bounds.width - validWidth) / 2;
+    windowY = targetDisplay.bounds.y + (targetDisplay.bounds.height - validHeight) / 2;
+  }
 
   lyricWindow = new BrowserWindow({
-    width: width || 800,
-    height: height || 200,
-    x: validPosition ? x : undefined,
-    y: validPosition ? y : undefined,
+    width: validWidth,
+    height: validHeight,
+    x: windowX,
+    y: windowY,
     frame: false,
     show: false,
     transparent: true,
+    opacity: 1,
     hasShadow: false,
     alwaysOnTop: true,
+    resizable: true,
+    roundedCorners: false,
+    titleBarStyle: 'hidden',
+    titleBarOverlay: false,
+    // 添加跨屏幕支持选项
     webPreferences: {
       preload: join(__dirname, '../preload/index.js'),
       sandbox: false,
       contextIsolation: true
-    }
+    },
+    backgroundColor: '#00000000'
   });
 
   // 监听窗口关闭事件
@@ -50,6 +108,22 @@ const createWin = () => {
     }
   });
 
+  // 监听窗口大小变化事件，保存新的尺寸
+  lyricWindow.on('resize', () => {
+    // 如果正在拖动，忽略大小调整事件
+    if (isDragging) return;
+
+    if (lyricWindow && !lyricWindow.isDestroyed()) {
+      const [width, height] = lyricWindow.getSize();
+      const [x, y] = lyricWindow.getPosition();
+
+      // 保存窗口位置和大小
+      store.set('lyricWindowBounds', { x, y, width, height });
+    }
+  });
+
+  lyricWindow.on('blur', () => lyricWindow && lyricWindow.setMaximizable(false))
+
   return lyricWindow;
 };
 
@@ -118,6 +192,7 @@ export const loadLyricWindow = (ipcMain: IpcMain, mainWin: BrowserWindow): void
     if (lyricWindow && !lyricWindow.isDestroyed()) {
       lyricWindow.webContents.send('lyric-window-close');
       mainWin.webContents.send('lyric-control-back', 'close');
+      mainWin.webContents.send('lyric-window-closed');
       lyricWindow.destroy();
       lyricWindow = null;
     }
@@ -136,26 +211,75 @@ export const loadLyricWindow = (ipcMain: IpcMain, mainWin: BrowserWindow): void
     }
   });
 
+  // 开始拖动时设置标志
+  ipcMain.on('lyric-drag-start', () => {
+    isDragging = true;
+    if (lyricWindow && !lyricWindow.isDestroyed()) {
+      // 记录原始窗口大小
+      const [width, height] = lyricWindow.getSize();
+      originalSize = { width, height };
+
+      // 在拖动时暂时禁用大小调整
+      lyricWindow.setResizable(false);
+    }
+  });
+
+  // 结束拖动时清除标志
+  ipcMain.on('lyric-drag-end', () => {
+    isDragging = false;
+    if (lyricWindow && !lyricWindow.isDestroyed()) {
+      // 确保窗口大小恢复原样
+      lyricWindow.setSize(originalSize.width, originalSize.height);
+
+      // 拖动结束后恢复可调整大小
+      lyricWindow.setResizable(true);
+    }
+  });
+
   // 处理拖动移动
   ipcMain.on('lyric-drag-move', (_, { deltaX, deltaY }) => {
-    if (!lyricWindow || lyricWindow.isDestroyed()) return;
+    if (!lyricWindow || lyricWindow.isDestroyed() || !isDragging) return;
 
     const [currentX, currentY] = lyricWindow.getPosition();
-    const { width: screenWidth, height: screenHeight } = screen.getPrimaryDisplay().workAreaSize;
-    const [windowWidth, windowHeight] = lyricWindow.getSize();
 
-    // 计算新位置，确保窗口不会移出屏幕
-    const newX = Math.max(0, Math.min(currentX + deltaX, screenWidth - windowWidth));
-    const newY = Math.max(0, Math.min(currentY + deltaY, screenHeight - windowHeight));
+    // 使用记录的原始大小，而不是当前大小
+    const windowWidth = originalSize.width;
+    const windowHeight = originalSize.height;
 
-    lyricWindow.setPosition(newX, newY);
+    // 计算新位置
+    const newX = currentX + deltaX;
+    const newY = currentY + deltaY;
 
-    // 保存新位置
-    store.set('lyricWindowBounds', {
-      ...lyricWindow.getBounds(),
-      x: newX,
-      y: newY
-    });
+    try {
+      // 获取当前鼠标所在的显示器
+      const mousePoint = screen.getCursorScreenPoint();
+      const currentDisplay = screen.getDisplayNearestPoint(mousePoint);
+
+      // 拖动期间使用setBounds确保大小不变，使用false避免动画卡顿
+      lyricWindow.setBounds(
+        {
+          x: newX,
+          y: newY,
+          width: windowWidth,
+          height: windowHeight
+        },
+        false
+      );
+
+      // 更新存储的位置
+      const windowBounds = {
+        x: newX,
+        y: newY,
+        width: windowWidth,
+        height: windowHeight,
+        displayId: currentDisplay.id // 记录当前显示器ID，有助于多屏幕处理
+      };
+      store.set('lyricWindowBounds', windowBounds);
+    } catch (error) {
+      console.error('Error during window drag:', error);
+      // 出错时尝试使用更简单的方法
+      lyricWindow.setPosition(newX, newY);
+    }
   });
 
   // 添加鼠标穿透事件处理

src/main/modules/cache.ts

@@ -0,0 +1,89 @@
+import { ipcMain } from 'electron';
+import Store from 'electron-store';
+
+interface LyricData {
+  id: number;
+  data: any;
+  timestamp: number;
+}
+
+interface StoreSchema {
+  lyrics: Record<number, LyricData>;
+}
+
+class CacheManager {
+  private store: Store<StoreSchema>;
+
+  constructor() {
+    this.store = new Store<StoreSchema>({
+      name: 'lyrics',
+      defaults: {
+        lyrics: {}
+      }
+    });
+  }
+
+  async cacheLyric(id: number, data: any) {
+    try {
+      const lyrics = this.store.get('lyrics');
+      lyrics[id] = {
+        id,
+        data,
+        timestamp: Date.now()
+      };
+      this.store.set('lyrics', lyrics);
+      return true;
+    } catch (error) {
+      console.error('Error caching lyric:', error);
+      return false;
+    }
+  }
+
+  async getCachedLyric(id: number) {
+    try {
+      const lyrics = this.store.get('lyrics');
+      const result = lyrics[id];
+
+      if (!result) return undefined;
+
+      // 检查缓存是否过期（24小时）
+      if (Date.now() - result.timestamp > 24 * 60 * 60 * 1000) {
+        delete lyrics[id];
+        this.store.set('lyrics', lyrics);
+        return undefined;
+      }
+
+      return result.data;
+    } catch (error) {
+      console.error('Error getting cached lyric:', error);
+      return undefined;
+    }
+  }
+
+  async clearLyricCache() {
+    try {
+      this.store.set('lyrics', {});
+      return true;
+    } catch (error) {
+      console.error('Error clearing lyric cache:', error);
+      return false;
+    }
+  }
+}
+
+export const cacheManager = new CacheManager();
+
+export function initializeCacheManager() {
+  // 添加歌词缓存相关的 IPC 处理
+  ipcMain.handle('cache-lyric', async (_, id: number, lyricData: any) => {
+    return await cacheManager.cacheLyric(id, lyricData);
+  });
+
+  ipcMain.handle('get-cached-lyric', async (_, id: number) => {
+    return await cacheManager.getCachedLyric(id);
+  });
+
+  ipcMain.handle('clear-lyric-cache', async () => {
+    return await cacheManager.clearLyricCache();
+  });
+}

src/main/modules/config.ts

@@ -1,16 +1,34 @@
 import { app, ipcMain } from 'electron';
 import Store from 'electron-store';
-import set from '../set.json';
 
-interface StoreType {
-  set: {
-    isProxy: boolean;
-    noAnimate: boolean;
-    animationSpeed: number;
-    author: string;
-    authorUrl: string;
-    musicApiPort: number;
+import set from '../set.json';
+import { defaultShortcuts } from './shortcuts';
+
+type SetConfig = {
+  isProxy: boolean;
+  proxyConfig: {
+    enable: boolean;
+    protocol: string;
+    host: string;
+    port: number;
   };
+  enableRealIP: boolean;
+  realIP: string;
+  noAnimate: boolean;
+  animationSpeed: number;
+  author: string;
+  authorUrl: string;
+  musicApiPort: number;
+  closeAction: 'ask' | 'minimize' | 'close';
+  musicQuality: string;
+  fontFamily: string;
+  fontScope: 'global' | 'lyric';
+  language: string;
+  showTopAction: boolean;
+};
+interface StoreType {
+  set: SetConfig;
+  shortcuts: typeof defaultShortcuts;
 }
 
 let store: Store<StoreType>;
@@ -22,7 +40,8 @@ export function initializeConfig() {
   store = new Store<StoreType>({
     name: 'config',
     defaults: {
-      set: set
+      set: set as SetConfig,
+      shortcuts: defaultShortcuts
     }
   });
 
@@ -39,4 +58,8 @@ export function initializeConfig() {
   });
 
   return store;
-} 
+}
+
+export function getStore() {
+  return store;
+}

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,13 +1,98 @@
-import { app, dialog, shell, ipcMain } from 'electron';
+import axios from 'axios';
+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 axios from 'axios';
+import * as os from 'os';
+import * as mm from 'music-metadata';
+import { fileTypeFromFile } from 'file-type';
+
+import { getStore } from './config';
+
+const MAX_CONCURRENT_DOWNLOADS = 3;
+const downloadQueue: { url: string; filename: string; songInfo: any; type?: string }[] = [];
+let activeDownloads = 0;
+
+// 创建一个store实例用于存储下载历史
+const downloadStore = new Store({
+  name: 'downloads',
+  defaults: {
+    history: []
+  }
+});
+
+// 创建一个store实例用于存储音频缓存
+const audioCacheStore = new Store({
+  name: 'audioCache',
+  defaults: {
+    cache: {}
+  }
+});
+
+// 保存已发送通知的文件，避免重复通知
+const sentNotifications = new Map();
 
 /**
  * 初始化文件管理相关的IPC监听
  */
 export function initializeFileManager() {
+  // 注册本地文件协议
+  protocol.registerFileProtocol('local', (request, callback) => {
+    try {
+      let url = request.url;
+      // local://C:/Users/xxx.mp3
+      let filePath = decodeURIComponent(url.replace('local:///', ''));
+      
+      // 兼容 local:///C:/Users/xxx.mp3 这种情况
+      if (/^\/[a-zA-Z]:\//.test(filePath)) {
+        filePath = filePath.slice(1);
+      }
+      
+      // 还原为系统路径格式
+      filePath = path.normalize(filePath);
+      
+      // 检查文件是否存在
+      if (!fs.existsSync(filePath)) {
+        console.error('File not found:', filePath);
+        callback({ error: -6 }); // net::ERR_FILE_NOT_FOUND
+        return;
+      }
+
+      callback({ path: filePath });
+    } catch (error) {
+      console.error('Error handling local protocol:', error);
+      callback({ error: -2 }); // net::FAILED
+    }
+  });
+
+  // 检查文件是否存在
+  ipcMain.handle('check-file-exists', (_, filePath) => {
+    try {
+      return fs.existsSync(filePath);
+    } catch (error) {
+      console.error('Error checking if file exists:', error);
+      return false;
+    }
+  });
+
+  // 获取支持的音频格式列表
+  ipcMain.handle('get-supported-audio-formats', () => {
+    return {
+      formats: [
+        { ext: 'mp3', name: 'MP3' },
+        { ext: 'm4a', name: 'M4A/AAC' },
+        { ext: 'flac', name: 'FLAC' },
+        { ext: 'wav', name: 'WAV' },
+        { ext: 'ogg', name: 'OGG Vorbis' },
+        { ext: 'aac', name: 'AAC' }
+      ],
+      default: 'mp3'
+    };
+  });
+
   // 通用的选择目录处理
   ipcMain.handle('select-directory', async () => {
     const result = await dialog.showOpenDialog({
@@ -18,27 +103,415 @@ export function initializeFileManager() {
   });
 
   // 通用的打开目录处理
-  ipcMain.on('open-directory', (_, path) => {
-    shell.openPath(path);
+  ipcMain.on('open-directory', (_, filePath) => {
+    try {
+      // 验证文件路径
+      if (!filePath) {
+        console.error('无效的文件路径: 路径为空');
+        return;
+      }
+
+      // 统一处理路径分隔符
+      const normalizedPath = path.normalize(filePath);
+
+      if (fs.statSync(normalizedPath).isDirectory()) {
+        shell.openPath(normalizedPath);
+      } else {
+        shell.showItemInFolder(normalizedPath);
+      }
+    } catch (error) {
+      console.error('打开路径失败:', error);
+    }
+  });
+
+  // 获取默认下载路径
+  ipcMain.handle('get-downloads-path', () => {
+    return app.getPath('downloads');
+  });
+  
+  // 获取存储的配置值
+  ipcMain.handle('get-store-value', (_, key) => {
+    const store = new Store();
+    return store.get(key);
+  });
+  
+  // 设置存储的配置值
+  ipcMain.on('set-store-value', (_, key, value) => {
+    const store = new Store();
+    store.set(key, value);
   });
 
   // 下载音乐处理
-  ipcMain.on('download-music', downloadMusic);
+  ipcMain.on('download-music', handleDownloadRequest);
+
+  // 检查文件是否已下载
+  ipcMain.handle('check-music-downloaded', (_, filename: string) => {
+    const store = new Store();
+    const downloadPath = (store.get('set.downloadPath') as string) || app.getPath('downloads');
+    const filePath = path.join(downloadPath, `${filename}.mp3`);
+    return fs.existsSync(filePath);
+  });
+
+  // 删除已下载的音乐
+  ipcMain.handle('delete-downloaded-music', async (_, filePath: string) => {
+    try {
+      if (fs.existsSync(filePath)) {
+        // 先删除文件
+        try {
+          await fs.promises.unlink(filePath);
+        } catch (error) {
+          console.error('Error deleting file:', error);
+        }
+
+        // 删除对应的歌曲信息
+        const store = new Store();
+        const songInfos = store.get('downloadedSongs', {}) as Record<string, any>;
+        delete songInfos[filePath];
+        store.set('downloadedSongs', songInfos);
+
+        return true;
+      }
+      return false;
+    } catch (error) {
+      console.error('Error deleting file:', error);
+      return false;
+    }
+  });
+
+  // 获取已下载音乐列表
+  ipcMain.handle('get-downloaded-music', async () => {
+    try {
+      const store = new Store();
+      const songInfos = store.get('downloadedSongs', {}) as Record<string, any>;
+
+      // 异步处理文件存在性检查
+      const entriesArray = Object.entries(songInfos);
+      const validEntriesPromises = await Promise.all(
+        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);
+
+      return validSongs;
+    } catch (error) {
+      console.error('Error getting downloaded music:', error);
+      return [];
+    }
+  });
+
+  // 检查歌曲是否已下载并返回本地路径
+  ipcMain.handle('check-song-downloaded', (_, songId: number) => {
+    const store = new Store();
+    const songInfos = store.get('downloadedSongs', {}) as Record<string, any>;
+
+    // 通过ID查找已下载的歌曲
+    for (const [path, info] of Object.entries(songInfos)) {
+      if (info.id === songId && fs.existsSync(path)) {
+        return {
+          isDownloaded: true,
+          localPath: `local://${path}`,
+          songInfo: info
+        };
+      }
+    }
+
+    return {
+      isDownloaded: false,
+      localPath: '',
+      songInfo: null
+    };
+  });
+
+  // 添加清除下载历史的处理函数
+  ipcMain.on('clear-downloads-history', () => {
+    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', {});
+    // 清除临时音频文件目录
+    const tempDir = path.join(app.getPath('userData'), 'AudioCache');
+    if (fs.existsSync(tempDir)) {
+      try {
+        fs.readdirSync(tempDir).forEach((file) => {
+          const filePath = path.join(tempDir, file);
+          if (file.endsWith('.mp3') || file.endsWith('.m4a')) {
+            fs.unlinkSync(filePath);
+          }
+        });
+      } catch (error) {
+        console.error('清除音频缓存文件失败:', error);
+      }
+    }
+  });
 }
 
 /**
- * 下载音乐功能
+ * 处理下载请求
  */
-async function downloadMusic(event: Electron.IpcMainEvent, { url, filename }: { url: string; filename: string }) {
+function handleDownloadRequest(
+  event: Electron.IpcMainEvent,
+  {
+    url,
+    filename,
+    songInfo,
+    type
+  }: { url: string; filename: string; songInfo?: any; type?: string }
+) {
+  // 检查是否已经在队列中或正在下载
+  if (downloadQueue.some((item) => item.filename === filename)) {
+    event.reply('music-download-error', {
+      filename,
+      error: '该歌曲已在下载队列中'
+    });
+    return;
+  }
+
+  // 检查是否已下载
+  const store = new Store();
+  const songInfos = store.get('downloadedSongs', {}) as Record<string, any>;
+
+  // 检查是否已下载（通过ID）
+  const isDownloaded =
+    songInfo?.id && Object.values(songInfos).some((info: any) => info.id === songInfo.id);
+
+  if (isDownloaded) {
+    event.reply('music-download-error', {
+      filename,
+      error: '该歌曲已下载'
+    });
+    return;
+  }
+
+  // 添加到下载队列
+  downloadQueue.push({ url, filename, songInfo, type });
+  event.reply('music-download-queued', {
+    filename,
+    songInfo
+  });
+
+  // 尝试开始下载
+  processDownloadQueue(event);
+}
+
+/**
+ * 处理下载队列
+ */
+async function processDownloadQueue(event: Electron.IpcMainEvent) {
+  if (activeDownloads >= MAX_CONCURRENT_DOWNLOADS || downloadQueue.length === 0) {
+    return;
+  }
+
+  const { url, filename, songInfo, type } = downloadQueue.shift()!;
+  activeDownloads++;
+
   try {
-    const store = new Store();
-    const downloadPath = store.get('set.downloadPath') as string || app.getPath('downloads');
+    await downloadMusic(event, { url, filename, songInfo, type });
+  } finally {
+    activeDownloads--;
+    processDownloadQueue(event);
+  }
+}
+
+/**
+ * 清理文件名中的非法字符
+ */
+function sanitizeFilename(filename: string): string {
+  // 替换 Windows 和 Unix 系统中的非法字符
+  return filename
+    .replace(/[<>:"/\\|?*]/g, '_') // 替换特殊字符为下划线
+    .replace(/\s+/g, ' ') // 将多个空格替换为单个空格
+    .trim(); // 移除首尾空格
+}
+
+/**
+ * 下载音乐和歌词
+ */
+async function downloadMusic(
+  event: Electron.IpcMainEvent,
+  {
+    url,
+    filename,
+    songInfo,
+    type = 'mp3'
+  }: { url: string; filename: string; songInfo: any; type?: string }
+) {
+  let finalFilePath = '';
+  let writer: fs.WriteStream | null = null;
+  let tempFilePath = '';
+
+  try {
+    // 使用配置Store来获取设置
+    const configStore = getStore();
+    const downloadPath =
+      (configStore.get('set.downloadPath') as string) || app.getPath('downloads');
+    const apiPort = configStore.get('set.musicApiPort') || 30488;
     
-    // 直接使用配置的下载路径
-    const filePath = path.join(downloadPath, `${filename}.mp3`);
+    // 获取文件名格式设置
+    const nameFormat = 
+      (configStore.get('set.downloadNameFormat') as string) || '{songName} - {artistName}';
+
+    // 根据格式创建文件名
+    let formattedFilename = filename;
+    if (songInfo) {
+      // 准备替换变量
+      const artistName = songInfo.ar?.map((a: any) => a.name).join('/') || '未知艺术家';
+      const songName = songInfo.name || filename;
+      const albumName = songInfo.al?.name || '未知专辑';
+      
+      // 应用自定义格式
+      formattedFilename = nameFormat
+        .replace(/\{songName\}/g, songName)
+        .replace(/\{artistName\}/g, artistName)
+        .replace(/\{albumName\}/g, albumName);
+    }
+
+    // 清理文件名中的非法字符
+    const sanitizedFilename = sanitizeFilename(formattedFilename);
+
+    // 创建临时文件路径 (在系统临时目录中创建)
+    const tempDir = path.join(os.tmpdir(), 'AlgerMusicPlayerTemp');
+    
+    // 确保临时目录存在
+    if (!fs.existsSync(tempDir)) {
+      fs.mkdirSync(tempDir, { recursive: true });
+    }
+    
+    tempFilePath = path.join(tempDir, `${Date.now()}_${sanitizedFilename}.tmp`);
+
+    // 先获取文件大小
+    const headResponse = await axios.head(url);
+    const totalSize = parseInt(headResponse.headers['content-length'] || '0', 10);
+
+    // 开始下载到临时文件
+    const response = await axios({
+      url,
+      method: 'GET',
+      responseType: 'stream',
+      timeout: 30000, // 30秒超时
+      httpAgent: new http.Agent({ keepAlive: true }),
+      httpsAgent: new https.Agent({ keepAlive: true })
+    });
+
+    writer = fs.createWriteStream(tempFilePath);
+    let downloadedSize = 0;
+
+    // 使用 data 事件来跟踪下载进度
+    response.data.on('data', (chunk: Buffer) => {
+      downloadedSize += chunk.length;
+      const progress = Math.round((downloadedSize / totalSize) * 100);
+      event.reply('music-download-progress', {
+        filename,
+        progress,
+        loaded: downloadedSize,
+        total: totalSize,
+        path: tempFilePath,
+        status: progress === 100 ? 'completed' : 'downloading',
+        songInfo: songInfo || {
+          name: filename,
+          ar: [{ name: '本地音乐' }],
+          picUrl: '/images/default_cover.png'
+        }
+      });
+    });
+
+    // 等待下载完成
+    await new Promise((resolve, reject) => {
+      writer!.on('finish', () => resolve(undefined));
+      writer!.on('error', (error) => reject(error));
+      response.data.pipe(writer!);
+    });
+
+    // 验证文件是否完整下载
+    const stats = fs.statSync(tempFilePath);
+    if (stats.size !== totalSize) {
+      throw new Error('文件下载不完整');
+    }
+
+    // 检测文件类型
+    let fileExtension = '';
+    
+    try {
+      // 首先尝试使用file-type库检测
+      const fileType = await fileTypeFromFile(tempFilePath);
+      if (fileType && fileType.ext) {
+        fileExtension = `.${fileType.ext}`;
+        console.log(`文件类型检测结果: ${fileType.mime}, 扩展名: ${fileExtension}`);
+      } else {
+        // 如果file-type无法识别，尝试使用music-metadata
+        const metadata = await mm.parseFile(tempFilePath);
+        if (metadata && metadata.format) {
+          // 根据format.container或codec判断扩展名
+          const formatInfo = metadata.format;
+          const container = formatInfo.container || '';
+          const codec = formatInfo.codec || '';
+          
+          // 音频格式映射表
+          const formatMap = {
+            'mp3': ['MPEG', 'MP3', 'mp3'],
+            'aac': ['AAC'],
+            'flac': ['FLAC'],
+            'ogg': ['Ogg', 'Vorbis'],
+            'wav': ['WAV', 'PCM'],
+            'm4a': ['M4A', 'MP4']
+          };
+          
+          // 查找匹配的格式
+          const format = Object.entries(formatMap).find(([_, keywords]) => 
+            keywords.some(keyword => container.includes(keyword) || codec.includes(keyword))
+          );
+          
+          // 设置文件扩展名，如果没找到则默认为mp3
+          fileExtension = format ? `.${format[0]}` : '.mp3';
+          
+          console.log(`music-metadata检测结果: 容器:${container}, 编码:${codec}, 扩展名: ${fileExtension}`);
+        } else {
+          // 两种方法都失败，使用传入的type或默认mp3
+          fileExtension = type ? `.${type}` : '.mp3';
+          console.log(`无法检测文件类型，使用默认扩展名: ${fileExtension}`);
+        }
+      }
+    } catch (err) {
+      console.error('检测文件类型失败:', err);
+      // 检测失败，使用传入的type或默认mp3
+      fileExtension = type ? `.${type}` : '.mp3';
+    }
+
+    // 使用检测到的文件扩展名创建最终文件路径
+    const filePath = path.join(downloadPath, `${sanitizedFilename}${fileExtension}`);
 
     // 检查文件是否已存在，如果存在则添加序号
-    let finalFilePath = filePath;
+    finalFilePath = filePath;
     let counter = 1;
     while (fs.existsSync(finalFilePath)) {
       const ext = path.extname(filePath);
@@ -47,23 +520,284 @@ async function downloadMusic(event: Electron.IpcMainEvent, { url, filename }: {
       counter++;
     }
 
-    const response = await axios({
-      url,
-      method: 'GET',
-      responseType: 'stream'
-    });
+    // 将临时文件移动到最终位置
+    fs.copyFileSync(tempFilePath, finalFilePath);
+    fs.unlinkSync(tempFilePath); // 删除临时文件
 
-    const writer = fs.createWriteStream(finalFilePath);
-    response.data.pipe(writer);
+    // 下载歌词
+    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;
 
-    writer.on('finish', () => {
-      event.reply('music-download-complete', { success: true, path: finalFilePath });
-    });
+          // 处理歌词内容
+          if (lyricsResponse.data.lrc && lyricsResponse.data.lrc.lyric) {
+            lyricsContent = lyricsResponse.data.lrc.lyric;
 
-    writer.on('error', (err) => {
-      event.reply('music-download-complete', { success: false, error: err.message });
-    });
+            // 如果有翻译歌词，合并到主歌词中
+            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;
+            }
+          }
+
+          console.log('歌词已准备好，将写入元数据');
+        }
+      }
+    } 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);
+          console.log('封面已准备好，将写入元数据');
+        }
+      }
+    } catch (coverError) {
+      console.error('下载封面失败:', coverError);
+      // 继续处理，不影响音乐下载
+    }
+
+    const fileFormat = fileExtension.toLowerCase();
+    const artistNames =
+      (songInfo?.ar || songInfo?.song?.artists)?.map((a: any) => a.name).join('/ ') || '未知艺术家';
+
+    // 根据文件类型处理元数据
+    if (['.mp3'].includes(fileFormat)) {
+      // 对MP3文件使用NodeID3处理ID3标签
+      try {
+        // 在写入ID3标签前，先移除可能存在的旧标签
+        NodeID3.removeTags(finalFilePath);
+        
+        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
+        };
+
+        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);
+      }
+    } else {
+      // 对于非MP3文件，使用music-metadata来写入元数据可能需要专门的库
+      // 或者根据不同文件类型使用专用工具，暂时只记录但不处理
+      console.log(`文件类型 ${fileFormat} 不支持使用NodeID3写入标签，跳过元数据写入`);
+    }
+
+    // 保存下载信息
+    try {
+      const songInfos = configStore.get('downloadedSongs', {}) as Record<string, any>;
+      const defaultInfo = {
+        name: filename,
+        ar: [{ name: '本地音乐' }],
+        picUrl: '/images/default_cover.png'
+      };
+
+      const newSongInfo = {
+        id: songInfo?.id || 0,
+        name: songInfo?.name || filename,
+        filename,
+        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(),
+        type: fileExtension.substring(1), // 去掉前面的点号，只保留扩展名
+        lyric: lyricData
+      };
+
+      // 保存到下载记录
+      songInfos[finalFilePath] = newSongInfo;
+      configStore.set('downloadedSongs', songInfos);
+
+      // 添加到下载历史
+      const history = downloadStore.get('history', []) as any[];
+      history.unshift(newSongInfo);
+      downloadStore.set('history', history);
+
+      // 避免重复发送通知
+      const notificationId = `download-${finalFilePath}`;
+      if (!sentNotifications.has(notificationId)) {
+        sentNotifications.set(notificationId, true);
+        
+        // 发送桌面通知
+        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();
+          
+          // 60秒后清理通知记录，释放内存
+          setTimeout(() => {
+            sentNotifications.delete(notificationId);
+          }, 60000);
+        } catch (notifyError) {
+          console.error('发送通知失败:', notifyError);
+        }
+      }
+
+      // 发送下载完成事件，确保只发送一次
+      event.reply('music-download-complete', {
+        success: true,
+        path: finalFilePath,
+        filename,
+        size: totalSize,
+        songInfo: newSongInfo
+      });
+    } catch (error) {
+      console.error('Error saving download info:', error);
+      throw new Error('保存下载信息失败');
+    }
   } catch (error: any) {
-    event.reply('music-download-complete', { success: false, error: error.message });
+    console.error('Download error:', error);
+
+    // 清理未完成的下载
+    if (writer) {
+      writer.end();
+    }
+    
+    // 清理临时文件
+    if (tempFilePath && fs.existsSync(tempFilePath)) {
+      try {
+        fs.unlinkSync(tempFilePath);
+      } catch (e) {
+        console.error('Failed to delete temporary file:', e);
+      }
+    }
+    
+    // 清理未完成的最终文件
+    if (finalFilePath && fs.existsSync(finalFilePath)) {
+      try {
+        fs.unlinkSync(finalFilePath);
+      } catch (e) {
+        console.error('Failed to delete incomplete download:', e);
+      }
+    }
+
+    event.reply('music-download-complete', {
+      success: false,
+      error: error.message || '下载失败',
+      filename
+    });
   }
-} 
+}
+
+// 辅助函数 - 解析歌词文本成时间戳和内容的映射
+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/fonts.ts

@@ -0,0 +1,42 @@
+import { ipcMain } from 'electron';
+import { getFonts } from 'font-list';
+
+/**
+ * 清理字体名称
+ * @param fontName 原始字体名称
+ * @returns 清理后的字体名称
+ */
+function cleanFontName(fontName: string): string {
+  return fontName
+    .trim()
+    .replace(/^["']|["']$/g, '') // 移除首尾的引号
+    .replace(/\s+/g, ' '); // 将多个空格替换为单个空格
+}
+
+/**
+ * 获取系统字体列表
+ */
+async function getSystemFonts(): Promise<string[]> {
+  try {
+    // 使用 font-list 获取系统字体
+    const fonts = await getFonts();
+    // 清理字体名称并去重
+    const cleanedFonts = [...new Set(fonts.map(cleanFontName))];
+    // 添加系统默认字体并排序
+    return ['system-ui', ...cleanedFonts].sort();
+  } catch (error) {
+    console.error('获取系统字体失败:', error);
+    // 如果获取失败，至少返回系统默认字体
+    return ['system-ui'];
+  }
+}
+
+/**
+ * 初始化字体管理模块
+ */
+export function initializeFonts() {
+  // 添加获取系统字体的 IPC 处理
+  ipcMain.handle('get-system-fonts', async () => {
+    return await getSystemFonts();
+  });
+}

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

@@ -0,0 +1,122 @@
+import { globalShortcut, ipcMain } from 'electron';
+
+import { getStore } from './config';
+
+// 添加获取平台信息的 IPC 处理程序
+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: ShortcutsConfig = {
+  togglePlay: { key: 'CommandOrControl+Alt+P', enabled: true, scope: 'global' },
+  prevPlay: { key: 'Alt+Left', enabled: true, scope: 'global' },
+  nextPlay: { key: 'Alt+Right', enabled: true, scope: 'global' },
+  volumeUp: { key: 'Alt+Up', enabled: true, scope: 'app' },
+  volumeDown: { key: 'Alt+Down', enabled: true, scope: 'app' },
+  toggleFavorite: { key: 'CommandOrControl+Alt+L', enabled: true, scope: 'app' },
+  toggleWindow: { key: 'CommandOrControl+Alt+Shift+M', enabled: true, scope: 'global' }
+};
+
+let mainWindowRef: Electron.BrowserWindow | null = null;
+
+// 注册快捷键
+export function registerShortcuts(
+  mainWindow: Electron.BrowserWindow,
+  shortcutsConfig?: ShortcutsConfig
+) {
+  mainWindowRef = mainWindow;
+  const store = getStore();
+  const shortcuts =
+    shortcutsConfig || (store.get('shortcuts') as ShortcutsConfig) || defaultShortcuts;
+
+  // 注销所有已注册的快捷键
+  globalShortcut.unregisterAll();
+
+  // 对旧格式数据进行兼容处理
+  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(key, () => {
+            mainWindow.webContents.send('global-shortcut', action);
+          });
+          break;
+      }
+    } catch (error) {
+      console.error(`注册快捷键 ${key} 失败:`, error);
+    }
+  });
+
+  // 通知渲染进程更新应用内快捷键
+  mainWindow.webContents.send('update-app-shortcuts', shortcuts);
+}
+
+// 初始化快捷键
+export function initializeShortcuts(mainWindow: Electron.BrowserWindow) {
+  mainWindowRef = mainWindow;
+  registerShortcuts(mainWindow);
+
+  // 监听禁用快捷键事件
+  ipcMain.on('disable-shortcuts', () => {
+    globalShortcut.unregisterAll();
+  });
+
+  // 监听启用快捷键事件
+  ipcMain.on('enable-shortcuts', () => {
+    if (mainWindowRef) {
+      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/modules/tray.ts

@@ -1,43 +1,440 @@
-import { app, Menu, nativeImage, Tray, BrowserWindow } from 'electron';
+import {
+  app,
+  BrowserWindow,
+  Menu,
+  MenuItem,
+  MenuItemConstructorOptions,
+  nativeImage,
+  Tray
+} from 'electron';
 import { join } from 'path';
 
+import type { Language } from '../../i18n/main';
+import i18n from '../../i18n/main';
+import { getStore } from './config';
+
+// 歌曲信息接口定义
+interface SongInfo {
+  name: string;
+  song: {
+    artists: Array<{ name: string; [key: string]: any }>;
+    [key: string]: any;
+  };
+  [key: string]: any;
+}
+
 let tray: Tray | null = null;
+// 为macOS状态栏添加控制图标
+let playPauseTray: Tray | null = null;
+let prevTray: Tray | null = null;
+let nextTray: Tray | null = null;
+let songTitleTray: Tray | null = null;
+
+let isPlaying = false;
+let currentSong: SongInfo | null = null;
+
+const LANGUAGES: { label: string; value: Language }[] = [
+  { label: '简体中文', value: 'zh-CN' },
+  { label: 'English', value: 'en-US' }
+];
+
+// 更新播放状态
+export function updatePlayState(playing: boolean) {
+  isPlaying = playing;
+  if (tray) {
+    updateTrayMenu(BrowserWindow.getAllWindows()[0]);
+  }
+  // 更新播放/暂停图标
+  updateStatusBarTray();
+}
+
+// 获取艺术家名称字符串
+function getArtistString(song: SongInfo | null): string {
+  if (!song || !song.song || !song.song.artists) return '';
+  return song.song.artists.map((item) => item.name).join(' / ');
+}
+
+// 获取歌曲完整标题（歌曲名 - 艺术家）
+function getSongTitle(song: SongInfo | null): string {
+  if (!song) return '未播放';
+  const artistStr = getArtistString(song);
+  return artistStr ? `${song.name} - ${artistStr}` : song.name;
+}
+
+// 更新当前播放的音乐信息
+export function updateCurrentSong(song: SongInfo | null) {
+  currentSong = song;
+  if (tray) {
+    updateTrayMenu(BrowserWindow.getAllWindows()[0]);
+  }
+  // 更新状态栏歌曲信息
+  updateStatusBarTray();
+}
+
+// 确保 macOS 状态栏图标能正确显示
+function getProperIconSize() {
+  // macOS 状态栏通常高度为22像素
+  const height = 18;
+  const width = 18;
+  return { width, height };
+}
+
+// 更新macOS状态栏图标
+function updateStatusBarTray() {
+  if (process.platform !== 'darwin') return;
+
+  const iconSize = getProperIconSize();
+
+  // 更新歌曲标题显示
+  if (songTitleTray) {
+    if (currentSong) {
+      // 限制歌曲名显示长度，添加作者名
+      const songName = currentSong.name.slice(0, 10);
+      let title = songName;
+      const artistStr = getArtistString(currentSong);
+      // 如果有艺术家名称，添加到标题中
+      if (artistStr) {
+        title = `${songName} - ${artistStr.slice(0, 6)}${artistStr.length > 6 ? '..' : ''}`;
+      }
+
+      // 设置标题和提示
+      songTitleTray.setTitle(title, {
+        fontType: 'monospacedDigit' // 使用等宽字体以确保更好的可读性
+      });
+
+      // 完整信息放在tooltip中
+      const fullTitle = getSongTitle(currentSong);
+      songTitleTray.setToolTip(fullTitle);
+      console.log('更新状态栏歌曲显示:', title, '完整信息:', fullTitle);
+    } else {
+      songTitleTray.setTitle('未播放', {
+        fontType: 'monospacedDigit'
+      });
+      songTitleTray.setToolTip('未播放');
+      console.log('更新状态栏歌曲显示: 未播放');
+    }
+  }
+
+  // 更新播放/暂停图标
+  if (playPauseTray) {
+    // 使用PNG图标替代文本
+    const iconPath = join(
+      app.getAppPath(),
+      'resources/icons',
+      isPlaying ? 'pause.png' : 'play.png'
+    );
+    const icon = nativeImage.createFromPath(iconPath).resize(iconSize);
+    icon.setTemplateImage(true); // 设置为模板图片，适合macOS深色/浅色模式
+    playPauseTray.setImage(icon);
+    playPauseTray.setToolTip(
+      isPlaying ? i18n.global.t('common.tray.pause') : i18n.global.t('common.tray.play')
+    );
+  }
+}
+
+// 导出更新菜单的函数
+export function updateTrayMenu(mainWindow: BrowserWindow) {
+  if (!tray) return;
+
+  // 如果是macOS，设置TouchBar
+  if (process.platform === 'darwin') {
+    // macOS 上使用直接的控制按钮
+    const menu = new Menu();
+
+    // 当前播放的音乐信息
+    if (currentSong) {
+      menu.append(
+        new MenuItem({
+          label: getSongTitle(currentSong),
+          enabled: false,
+          type: 'normal'
+        })
+      );
+      menu.append(new MenuItem({ type: 'separator' }));
+    }
+
+    // 上一首、播放/暂停、下一首的菜单项
+    // 在macOS上临时使用文本菜单项替代图标，确保基本功能正常
+    menu.append(
+      new MenuItem({
+        label: i18n.global.t('common.tray.prev'),
+        type: 'normal',
+        click: () => {
+          mainWindow.webContents.send('global-shortcut', 'prevPlay');
+        }
+      })
+    );
+
+    menu.append(
+      new MenuItem({
+        label: i18n.global.t(isPlaying ? 'common.tray.pause' : 'common.tray.play'),
+        type: 'normal',
+        click: () => {
+          mainWindow.webContents.send('global-shortcut', 'togglePlay');
+        }
+      })
+    );
+
+    // 收藏
+    menu.append(
+      new MenuItem({
+        label: i18n.global.t('common.tray.favorite'),
+        type: 'normal',
+        click: () => {
+          console.log('[Tray] 发送收藏命令 - macOS菜单');
+          mainWindow.webContents.send('global-shortcut', 'toggleFavorite');
+        }
+      })
+    );
+
+    menu.append(
+      new MenuItem({
+        label: i18n.global.t('common.tray.next'),
+        type: 'normal',
+        click: () => {
+          mainWindow.webContents.send('global-shortcut', 'nextPlay');
+        }
+      })
+    );
+
+    // 分隔符
+    menu.append(new MenuItem({ type: 'separator' }));
+
+    // 显示主窗口
+    menu.append(
+      new MenuItem({
+        label: i18n.global.t('common.tray.show'),
+        type: 'normal',
+        click: () => {
+          mainWindow.show();
+        }
+      })
+    );
+
+    // 语言切换子菜单
+    const languageSubmenu = Menu.buildFromTemplate(
+      LANGUAGES.map(({ label, value }) => ({
+        label,
+        type: 'radio',
+        checked: i18n.global.locale === value,
+        click: () => {
+          i18n.global.locale = value;
+          updateTrayMenu(mainWindow);
+          mainWindow.webContents.send('language-changed', value);
+        }
+      }))
+    );
+
+    menu.append(
+      new MenuItem({
+        label: i18n.global.t('common.language'),
+        type: 'submenu',
+        submenu: languageSubmenu
+      })
+    );
+
+    // 退出按钮
+    menu.append(
+      new MenuItem({
+        label: i18n.global.t('common.tray.quit'),
+        type: 'normal',
+        click: () => {
+          app.quit();
+        }
+      })
+    );
+
+    tray.setContextMenu(menu);
+  } else {
+    // Windows 和 Linux 使用原来的菜单样式
+    const menuTemplate: MenuItemConstructorOptions[] = [
+      // 当前播放的音乐信息
+      ...((currentSong
+        ? [
+            {
+              label: getSongTitle(currentSong),
+              enabled: false,
+              type: 'normal'
+            },
+            { type: 'separator' }
+          ]
+        : []) as MenuItemConstructorOptions[]),
+      {
+        label: i18n.global.t('common.tray.show'),
+        type: 'normal',
+        click: () => {
+          mainWindow.show();
+        }
+      },
+      {
+        label: i18n.global.t('common.tray.favorite'),
+        type: 'normal',
+        click: () => {
+          console.log('[Tray] 发送收藏命令 - Windows/Linux菜单');
+          mainWindow.webContents.send('global-shortcut', 'toggleFavorite');
+        }
+      },
+      { type: 'separator' },
+      {
+        label: i18n.global.t('common.tray.prev'),
+        type: 'normal',
+        click: () => {
+          mainWindow.webContents.send('global-shortcut', 'prevPlay');
+        }
+      },
+      {
+        label: i18n.global.t(isPlaying ? 'common.tray.pause' : 'common.tray.play'),
+        type: 'normal',
+        click: () => {
+          mainWindow.webContents.send('global-shortcut', 'togglePlay');
+        }
+      },
+      {
+        label: i18n.global.t('common.tray.next'),
+        type: 'normal',
+        click: () => {
+          mainWindow.webContents.send('global-shortcut', 'nextPlay');
+        }
+      },
+      { type: 'separator' },
+      {
+        label: i18n.global.t('common.language'),
+        type: 'submenu',
+        submenu: LANGUAGES.map(({ label, value }) => ({
+          label,
+          type: 'radio',
+          checked: i18n.global.locale === value,
+          click: () => {
+            i18n.global.locale = value;
+            updateTrayMenu(mainWindow);
+            mainWindow.webContents.send('language-changed', value);
+          }
+        }))
+      },
+      { type: 'separator' },
+      {
+        label: i18n.global.t('common.tray.quit'),
+        type: 'normal',
+        click: () => {
+          app.quit();
+        }
+      }
+    ];
+
+    const contextMenu = Menu.buildFromTemplate(menuTemplate);
+    tray.setContextMenu(contextMenu);
+  }
+}
+
+// 初始化状态栏Tray
+function initializeStatusBarTray(mainWindow: BrowserWindow) {
+  const store = getStore()
+  if (process.platform !== 'darwin' || !store.get('set.showTopAction')) return;
+
+  const iconSize = getProperIconSize();
+
+  // 创建下一首按钮（调整顺序，先创建下一首按钮）
+  const nextIcon = nativeImage
+    .createFromPath(join(app.getAppPath(), 'resources/icons', 'next.png'))
+    .resize(iconSize);
+  nextIcon.setTemplateImage(true); // 设置为模板图片，适合macOS深色/浅色模式
+  nextTray = new Tray(nextIcon);
+  nextTray.setToolTip(i18n.global.t('common.tray.next'));
+  nextTray.on('click', () => {
+    mainWindow.webContents.send('global-shortcut', 'nextPlay');
+  });
+
+  // 创建播放/暂停按钮
+  const playPauseIcon = nativeImage
+    .createFromPath(join(app.getAppPath(), 'resources/icons', isPlaying ? 'pause.png' : 'play.png'))
+    .resize(iconSize);
+  playPauseIcon.setTemplateImage(true); // 设置为模板图片，适合macOS深色/浅色模式
+  playPauseTray = new Tray(playPauseIcon);
+  playPauseTray.setToolTip(
+    isPlaying ? i18n.global.t('common.tray.pause') : i18n.global.t('common.tray.play')
+  );
+  playPauseTray.on('click', () => {
+    mainWindow.webContents.send('global-shortcut', 'togglePlay');
+  });
+
+  // 创建上一首按钮（调整顺序，最后创建上一首按钮）
+  const prevIcon = nativeImage
+    .createFromPath(join(app.getAppPath(), 'resources/icons', 'prev.png'))
+    .resize(iconSize);
+  prevIcon.setTemplateImage(true); // 设置为模板图片，适合macOS深色/浅色模式
+  prevTray = new Tray(prevIcon);
+  prevTray.setToolTip(i18n.global.t('common.tray.prev'));
+  prevTray.on('click', () => {
+    mainWindow.webContents.send('global-shortcut', 'prevPlay');
+  });
+
+  // 创建歌曲信息显示 - 需要使用特殊处理
+  const titleIcon = nativeImage
+    .createFromPath(join(app.getAppPath(), 'resources/icons', 'note.png'))
+    .resize({ width: 16, height: 16 });
+  titleIcon.setTemplateImage(true);
+  songTitleTray = new Tray(titleIcon);
+
+  // 初始化显示文本
+  const initialText = getSongTitle(currentSong);
+
+  // 在macOS上，特别设置title来显示文本，确保它能正确显示
+  songTitleTray.setTitle(initialText, {
+    fontType: 'monospacedDigit' // 使用等宽字体以确保更好的可读性
+  });
+
+  songTitleTray.setToolTip(initialText);
+  songTitleTray.on('click', () => {
+    mainWindow.show();
+  });
+
+  // 强制更新一次所有图标
+  updateStatusBarTray();
+
+  // 打印调试信息
+  console.log('状态栏初始化完成，歌曲显示标题:', initialText);
+}
 
 /**
  * 初始化系统托盘
  */
 export function initializeTray(iconPath: string, mainWindow: BrowserWindow) {
-  const trayIcon = nativeImage.createFromPath(join(iconPath, 'icon_16x16.png')).resize({ width: 16, height: 16 });
+  // 根据平台选择合适的图标
+  const iconSize = process.platform === 'darwin' ? 18 : 16;
+  const iconFile = process.platform === 'darwin' ? 'icon_16x16.png' : 'icon_16x16.png';
+
+  const trayIcon = nativeImage
+    .createFromPath(join(iconPath, iconFile))
+    .resize({ width: iconSize, height: iconSize });
+
   tray = new Tray(trayIcon);
 
-  // 创建一个上下文菜单
-  const contextMenu = Menu.buildFromTemplate([
-    {
-      label: '显示',
-      click: () => {
+  // 设置托盘图标的提示文字
+  tray.setToolTip('Alger Music Player');
+
+  // 初始化菜单
+  updateTrayMenu(mainWindow);
+
+  // 初始化状态栏控制按钮 (macOS)
+  initializeStatusBarTray(mainWindow);
+
+  // 在 macOS 上，点击图标时显示菜单
+  if (process.platform === 'darwin') {
+    tray.on('click', () => {
+      if (tray) {
+        tray.popUpContextMenu();
+      }
+    });
+  } else {
+    // 在其他平台上，点击图标时切换窗口显示状态
+    tray.on('click', () => {
+      if (mainWindow.isVisible()) {
+        mainWindow.hide();
+      } else {
         mainWindow.show();
-      },
-    },
-    {
-      label: '退出',
-      click: () => {
-        mainWindow.destroy();
-        app.quit();
-      },
-    },
-  ]);
-
-  // 设置系统托盘图标的上下文菜单
-  tray.setContextMenu(contextMenu);
-
-  // 当系统托盘图标被点击时，切换窗口的显示/隐藏
-  tray.on('click', () => {
-    if (mainWindow.isVisible()) {
-      mainWindow.hide();
-    } else {
-      mainWindow.show();
-    }
-  });
+      }
+    });
+  }
 
   return tray;
-} 
+}

src/main/modules/update.ts

@@ -0,0 +1,101 @@
+import axios from 'axios';
+import { spawn } from 'child_process';
+import { app, BrowserWindow, ipcMain } from 'electron';
+import * as fs from 'fs';
+import * as path from 'path';
+
+export function setupUpdateHandlers(_mainWindow: BrowserWindow) {
+  ipcMain.on('start-download', async (event, url: string) => {
+    try {
+      const response = await axios({
+        url,
+        method: 'GET',
+        responseType: 'stream',
+        onDownloadProgress: (progressEvent: { loaded: number; total?: number }) => {
+          if (!progressEvent.total) return;
+          const percent = Math.round((progressEvent.loaded / progressEvent.total) * 100);
+          const downloaded = (progressEvent.loaded / 1024 / 1024).toFixed(2);
+          const total = (progressEvent.total / 1024 / 1024).toFixed(2);
+          event.sender.send('download-progress', percent, `已下载 ${downloaded}MB / ${total}MB`);
+        }
+      });
+
+      const fileName = url.split('/').pop() || 'update.exe';
+      const downloadPath = path.join(app.getPath('downloads'), fileName);
+
+      // 创建写入流
+      const writer = fs.createWriteStream(downloadPath);
+
+      // 将响应流写入文件
+      response.data.pipe(writer);
+
+      // 处理写入完成
+      writer.on('finish', () => {
+        event.sender.send('download-complete', true, downloadPath);
+      });
+
+      // 处理写入错误
+      writer.on('error', (error) => {
+        console.error('Write file error:', error);
+        event.sender.send('download-complete', false, '');
+      });
+    } catch (error) {
+      console.error('Download failed:', error);
+      event.sender.send('download-complete', false, '');
+    }
+  });
+
+  ipcMain.on('install-update', (_event, filePath: string) => {
+    if (!fs.existsSync(filePath)) {
+      console.error('Installation file not found:', filePath);
+      return;
+    }
+
+    const { platform } = process;
+
+    // 先启动安装程序，再退出应用
+    try {
+      if (platform === 'win32') {
+        // 使用spawn替代exec，并使用detached选项确保子进程独立运行
+        const child = spawn(filePath, [], {
+          detached: true,
+          stdio: 'ignore'
+        });
+        child.unref();
+      } else if (platform === 'darwin') {
+        // 挂载 DMG 文件
+        const child = spawn('open', [filePath], {
+          detached: true,
+          stdio: 'ignore'
+        });
+        child.unref();
+      } else if (platform === 'linux') {
+        const ext = path.extname(filePath);
+        if (ext === '.AppImage') {
+          // 先添加执行权限
+          fs.chmodSync(filePath, '755');
+          const child = spawn(filePath, [], {
+            detached: true,
+            stdio: 'ignore'
+          });
+          child.unref();
+        } else if (ext === '.deb') {
+          const child = spawn('pkexec', ['dpkg', '-i', filePath], {
+            detached: true,
+            stdio: 'ignore'
+          });
+          child.unref();
+        }
+      }
+
+      // 给安装程序一点时间启动
+      setTimeout(() => {
+        app.quit();
+      }, 500);
+    } catch (error) {
+      console.error('启动安装程序失败:', error);
+      // 尽管出错，仍然尝试退出应用
+      app.quit();
+    }
+  });
+}

src/main/modules/window-size.ts

@@ -0,0 +1,700 @@
+import { app, BrowserWindow, ipcMain, screen } from 'electron';
+import Store from 'electron-store';
+
+const store = new Store();
+
+// 默认窗口尺寸
+export const DEFAULT_MAIN_WIDTH = 1200;
+export const DEFAULT_MAIN_HEIGHT = 780;
+export const DEFAULT_MINI_WIDTH = 340;
+export const DEFAULT_MINI_HEIGHT = 64;
+export const DEFAULT_MINI_EXPANDED_HEIGHT = 400;
+
+// 用于存储窗口状态的键名
+export const WINDOW_STATE_KEY = 'windowState';
+
+// 最小窗口尺寸
+let MIN_WIDTH = Math.round(DEFAULT_MAIN_WIDTH * 0.5);
+let MIN_HEIGHT = Math.round(DEFAULT_MAIN_HEIGHT * 0.5);
+
+// 标记IPC处理程序是否已注册
+let ipcHandlersRegistered = false;
+
+/**
+ * 窗口状态类型定义
+ */
+export interface WindowState {
+  width: number;
+  height: number;
+  x?: number;
+  y?: number;
+  isMaximized: boolean;
+}
+
+/**
+ * 窗口大小管理器
+ * 负责保存、恢复和维护窗口大小状态
+ */
+class WindowSizeManager {
+  private store: Store;
+  private mainWindow: BrowserWindow | null = null;
+  private savedState: WindowState | null = null;
+  private isInitialized: boolean = false;
+  
+  constructor() {
+    this.store = store;
+    // 初始化时不做与screen相关的操作，等app ready后再初始化
+  }
+  
+  /**
+   * 初始化窗口大小管理器
+   * 必须在app ready后调用
+   */
+  initialize(): void {
+    if (!app.isReady()) {
+      console.warn('WindowSizeManager.initialize() 必须在 app ready 之后调用！');
+      return;
+    }
+    
+    if (this.isInitialized) {
+      return;
+    }
+    
+    this.initMinimumWindowSize();
+    this.setupIPCHandlers();
+    this.isInitialized = true;
+    console.log('窗口大小管理器初始化完成');
+  }
+  
+  /**
+   * 设置主窗口引用
+   */
+  setMainWindow(win: BrowserWindow): void {
+    if (!this.isInitialized) {
+      this.initialize();
+    }
+    
+    this.mainWindow = win;
+    
+    // 读取保存的状态
+    this.savedState = this.getWindowState();
+    
+    // 监听重要事件
+    this.setupEventListeners(win);
+    
+    // 立即保存初始状态
+    this.saveWindowState(win);
+  }
+  
+  /**
+   * 初始化最小窗口尺寸
+   */
+  private initMinimumWindowSize(): void {
+    if (!app.isReady()) {
+      console.warn('不能在 app ready 之前访问 screen 模块');
+      return;
+    }
+    
+    try {
+      const { width: workAreaWidth, height: workAreaHeight } = screen.getPrimaryDisplay().workArea;
+      
+      // 根据工作区大小设置合理的最小尺寸
+      MIN_WIDTH = Math.min(Math.round(DEFAULT_MAIN_WIDTH * 0.5), Math.round(workAreaWidth * 0.3));
+      MIN_HEIGHT = Math.min(Math.round(DEFAULT_MAIN_HEIGHT * 0.5), Math.round(workAreaHeight * 0.3));
+      
+      console.log(`设置最小窗口尺寸: ${MIN_WIDTH}x${MIN_HEIGHT}`);
+    } catch (error) {
+      console.error('初始化最小窗口尺寸失败:', error);
+      // 使用默认值
+      MIN_WIDTH = Math.round(DEFAULT_MAIN_WIDTH * 0.5);
+      MIN_HEIGHT = Math.round(DEFAULT_MAIN_HEIGHT * 0.5);
+    }
+  }
+  
+  /**
+   * 设置事件监听器
+   */
+  private setupEventListeners(win: BrowserWindow): void {
+    // 监听窗口大小调整事件
+    win.on('resize', () => {
+      if (!win.isDestroyed() && !win.isMinimized()) {
+        this.saveWindowState(win);
+      }
+    });
+    
+    // 监听窗口移动事件
+    win.on('move', () => {
+      if (!win.isDestroyed() && !win.isMinimized()) {
+        this.saveWindowState(win);
+      }
+    });
+    
+    // 监听窗口最大化事件
+    win.on('maximize', () => {
+      if (!win.isDestroyed()) {
+        this.saveWindowState(win);
+      }
+    });
+    
+    // 监听窗口从最大化恢复事件
+    win.on('unmaximize', () => {
+      if (!win.isDestroyed()) {
+        this.saveWindowState(win);
+      }
+    });
+    
+    // 监听窗口关闭事件，确保保存最终状态
+    win.on('close', () => {
+      if (!win.isDestroyed()) {
+        this.saveWindowState(win);
+      }
+    });
+    
+    // 在页面加载完成后确保窗口大小正确
+    win.webContents.on('did-finish-load', () => {
+      this.enforceCorrectSize(win);
+    });
+    
+    // 在窗口准备好显示时确保尺寸正确
+    win.on('ready-to-show', () => {
+      this.enforceCorrectSize(win);
+    });
+  }
+  
+  /**
+   * 强制应用正确的窗口大小
+   */
+  private enforceCorrectSize(win: BrowserWindow): void {
+    if (!this.savedState || win.isMaximized() || win.isMinimized() || win.isDestroyed()) {
+      return;
+    }
+    
+    const [currentWidth, currentHeight] = win.getSize();
+    
+    if (Math.abs(currentWidth - this.savedState.width) > 2 || 
+        Math.abs(currentHeight - this.savedState.height) > 2) {
+      console.log(`强制调整窗口大小: 当前=${currentWidth}x${currentHeight}, 目标=${this.savedState.width}x${this.savedState.height}`);
+      
+      // 临时禁用minimum size限制
+      const [minWidth, minHeight] = win.getMinimumSize();
+      win.setMinimumSize(1, 1);
+      
+      // 强制设置正确大小
+      win.setSize(this.savedState.width, this.savedState.height, false);
+      
+      // 恢复原始minimum size
+      win.setMinimumSize(minWidth, minHeight);
+      
+      // 验证尺寸设置是否成功
+      const [newWidth, newHeight] = win.getSize();
+      console.log(`调整后窗口大小: ${newWidth}x${newHeight}`);
+      
+      // 如果调整后的大小仍然与目标不一致，尝试再次调整
+      if (Math.abs(newWidth - this.savedState.width) > 1 || 
+          Math.abs(newHeight - this.savedState.height) > 1) {
+        console.log(`窗口大小调整后仍不一致，将再次尝试调整`);
+        setTimeout(() => {
+          if (!win.isDestroyed() && !win.isMaximized() && !win.isMinimized()) {
+            win.setSize(this.savedState!.width, this.savedState!.height, false);
+          }
+        }, 50);
+      }
+      
+      // // 开始尺寸强制执行
+      // this.startSizeEnforcement(win);
+    }
+  }
+  
+  /**
+   * 开启尺寸强制执行定时器
+   */
+  // private startSizeEnforcement(win: BrowserWindow): void {
+  //   // 清除之前的定时器
+  //   if (this.enforceTimer) {
+  //     clearInterval(this.enforceTimer);
+  //     this.enforceTimer = null;
+  //   }
+    
+  //   this.enforceCount = 0;
+    
+  //   // 创建新的定时器，每50ms检查一次窗口大小
+  //   this.enforceTimer = setInterval(() => {
+  //     if (this.enforceCount >= this.MAX_ENFORCE_COUNT || 
+  //         !this.savedState || 
+  //         win.isDestroyed() || 
+  //         win.isMaximized() || 
+  //         win.isMinimized()) {
+  //       // 达到最大检查次数或不需要检查，清除定时器
+  //       if (this.enforceTimer) {
+  //         clearInterval(this.enforceTimer);
+  //         this.enforceTimer = null;
+  //       }
+  //       return;
+  //     }
+      
+  //     const [currentWidth, currentHeight] = win.getSize();
+      
+  //     if (Math.abs(currentWidth - this.savedState.width) > 2 || 
+  //         Math.abs(currentHeight - this.savedState.height) > 2) {
+  //       console.log(`[定时检查] 强制调整窗口大小: 当前=${currentWidth}x${currentHeight}, 目标=${this.savedState.width}x${this.savedState.height}`);
+        
+  //       // 临时禁用minimum size限制
+  //       const [minWidth, minHeight] = win.getMinimumSize();
+  //       win.setMinimumSize(1, 1);
+        
+  //       // 强制设置正确大小
+  //       win.setSize(this.savedState.width, this.savedState.height, false);
+        
+  //       // 恢复原始minimum size
+  //       win.setMinimumSize(minWidth, minHeight);
+        
+  //       // 验证尺寸设置是否成功
+  //       const [newWidth, newHeight] = win.getSize();
+  //       if (Math.abs(newWidth - this.savedState.width) <= 1 && 
+  //           Math.abs(newHeight - this.savedState.height) <= 1) {
+  //         console.log(`窗口大小已成功调整为目标尺寸: ${newWidth}x${newHeight}`);
+  //       }
+  //     }
+      
+  //     this.enforceCount++;
+  //   }, 50);
+  // }
+  
+  /**
+   * 获取窗口创建选项
+   */
+  getWindowOptions(): Electron.BrowserWindowConstructorOptions {
+    // 确保初始化
+    if (!this.isInitialized && app.isReady()) {
+      this.initialize();
+    }
+    
+    // 读取保存的状态
+    const savedState = this.getWindowState();
+    
+    // 准备选项
+    const options: Electron.BrowserWindowConstructorOptions = {
+      width: savedState?.width || DEFAULT_MAIN_WIDTH,
+      height: savedState?.height || DEFAULT_MAIN_HEIGHT,
+      minWidth: MIN_WIDTH,
+      minHeight: MIN_HEIGHT,
+      show: false,
+      frame: false,
+      webPreferences: {
+        nodeIntegration: false,
+        contextIsolation: true
+      }
+    };
+    
+    // 如果有保存的位置，且位置有效，则使用该位置
+    if (savedState?.x !== undefined && savedState?.y !== undefined && app.isReady()) {
+      if (this.isPositionVisible(savedState.x, savedState.y)) {
+        options.x = savedState.x;
+        options.y = savedState.y;
+      }
+    }
+    
+    console.log(`窗口创建选项: 大小=${options.width}x${options.height}, 位置=(${options.x}, ${options.y})`);
+    
+    return options;
+  }
+  
+  /**
+   * 应用窗口初始状态
+   * 在窗口创建后调用
+   */
+  applyInitialState(win: BrowserWindow): void {
+    const savedState = this.getWindowState();
+    
+    if (!savedState) {
+      win.center();
+      return;
+    }
+    
+    // 如果需要最大化，直接最大化
+    if (savedState.isMaximized) {
+      console.log('应用已保存的最大化状态');
+      win.maximize();
+    } 
+    // 如果位置无效，则居中显示
+    else if (!app.isReady() || savedState.x === undefined || savedState.y === undefined || 
+        !this.isPositionVisible(savedState.x, savedState.y)) {
+      console.log('保存的位置无效，窗口居中显示');
+      win.center();
+    }
+  }
+  
+  /**
+   * 保存窗口状态
+   */
+  saveWindowState(win: BrowserWindow): WindowState {
+    // 如果窗口已销毁，则返回之前的状态或默认状态
+    console.log('win.isDestroyed()',win.isDestroyed())
+    if (win.isDestroyed()) {
+      return this.savedState || {
+        width: DEFAULT_MAIN_WIDTH,
+        height: DEFAULT_MAIN_HEIGHT,
+        isMaximized: false
+      };
+    }
+    
+    const isMaximized = win.isMaximized();
+    let state: WindowState;
+    
+    if (isMaximized) {
+      // 如果窗口处于最大化状态，保存最大化标志
+      // 由于 Electron 的限制，最大化状态下 getBounds() 可能不准确
+      // 所以我们尽量保留之前保存的非最大化时的大小
+      const currentBounds = win.getBounds();
+      const previousSize = this.savedState && !this.savedState.isMaximized 
+        ? { width: this.savedState.width, height: this.savedState.height }
+        : { width: currentBounds.width, height: currentBounds.height };
+      
+      state = {
+        width: previousSize.width,
+        height: previousSize.height,
+        x: currentBounds.x,
+        y: currentBounds.y,
+        isMaximized: true
+      };
+    console.log('state IsMaximized',state)
+
+    } 
+    else if (win.isMinimized()) {
+      // 最小化状态下不保存窗口大小，因为可能不准确
+      console.log('state IsMinimized',this.savedState)
+      return this.savedState || {
+        width: DEFAULT_MAIN_WIDTH,
+        height: DEFAULT_MAIN_HEIGHT,
+        isMaximized: false
+      };
+    } 
+    else {
+      // 正常状态下保存当前大小和位置
+      const [width, height] = win.getSize();
+      const [x, y] = win.getPosition();
+      
+      state = {
+        width,
+        height,
+        x,
+        y,
+        isMaximized: false
+      };
+      console.log('state IsNormal',state)
+    }
+    
+    // 保存状态到存储
+    this.store.set(WINDOW_STATE_KEY, state);
+    console.log(`已保存窗口状态: ${JSON.stringify(state)}`);
+    
+    // 更新内部状态
+    this.savedState = state;
+    console.log('state',state)
+    
+    return state;
+  }
+  
+  /**
+   * 获取保存的窗口状态
+   */
+  getWindowState(): WindowState | null {
+    const state = this.store.get(WINDOW_STATE_KEY) as WindowState | undefined;
+    
+    if (!state) {
+      console.log('未找到保存的窗口状态，将使用默认值');
+      return null;
+    }
+    
+    // 验证尺寸，确保不小于最小值
+    const validatedState: WindowState = {
+      width: Math.max(MIN_WIDTH, state.width || DEFAULT_MAIN_WIDTH),
+      height: Math.max(MIN_HEIGHT, state.height || DEFAULT_MAIN_HEIGHT),
+      x: state.x,
+      y: state.y,
+      isMaximized: !!state.isMaximized
+    };
+    
+    console.log(`读取保存的窗口状态: ${JSON.stringify(validatedState)}`);
+    
+    return validatedState;
+  }
+  
+  /**
+   * 检查位置是否在可见屏幕范围内
+   */
+  isPositionVisible(x: number, y: number): boolean {
+    if (!app.isReady()) {
+      return false;
+    }
+    
+    try {
+      const displays = screen.getAllDisplays();
+      
+      for (const display of displays) {
+        const { x: screenX, y: screenY, width, height } = display.workArea;
+        if (
+          x >= screenX && 
+          x < screenX + width &&
+          y >= screenY && 
+          y < screenY + height
+        ) {
+          return true;
+        }
+      }
+    } catch (error) {
+      console.error('检查位置可见性失败:', error);
+      return false;
+    }
+    
+    return false;
+  }
+  
+  /**
+   * 计算适合当前缩放比的缩放因子
+   */
+  calculateContentZoomFactor(): number {
+    // 只有在 app 准备好后才能使用screen
+    if (!app.isReady()) {
+      return 1;
+    }
+    
+    try {
+      // 获取系统的缩放因子
+      const { scaleFactor } = screen.getPrimaryDisplay();
+      
+      // 缩放因子默认为1
+      let zoomFactor = 1;
+      
+      // 只在高DPI情况下调整
+      if (scaleFactor > 1) {
+        // 自定义逻辑来根据不同的缩放比例进行调整
+        if (scaleFactor >= 2.5) {
+          // 极高缩放比，例如4K屏幕用200%+缩放
+          zoomFactor = 0.7;
+        } else if (scaleFactor >= 2) {
+          // 高缩放比，例如200%
+          zoomFactor = 0.8;
+        } else if (scaleFactor >= 1.5) {
+          // 中等缩放比，例如150%
+          zoomFactor = 0.85;
+        } else if (scaleFactor > 1.25) {
+          // 略高缩放比，例如125%-149%
+          zoomFactor = 0.9;
+        } else {
+          // 低缩放比，不做调整
+          zoomFactor = 1;
+        }
+      }
+      
+      // 获取用户的自定义缩放设置（如果有）
+      const userZoomFactor = this.store.get('set.contentZoomFactor') as number | undefined;
+      if (userZoomFactor) {
+        zoomFactor = userZoomFactor;
+      }
+      
+      return zoomFactor;
+    } catch (error) {
+      console.error('计算内容缩放因子失败:', error);
+      return 1;
+    }
+  }
+  
+  /**
+   * 应用页面内容缩放
+   */
+  applyContentZoom(win: BrowserWindow): void {
+    const zoomFactor = this.calculateContentZoomFactor();
+    win.webContents.setZoomFactor(zoomFactor);
+    
+    if (app.isReady()) {
+      try {
+        console.log(`应用页面缩放因子: ${zoomFactor}, 系统缩放比: ${screen.getPrimaryDisplay().scaleFactor}`);
+      } catch (error) {
+        console.log(`应用页面缩放因子: ${zoomFactor}`);
+      }
+    } else {
+      console.log(`应用页面缩放因子: ${zoomFactor}`);
+    }
+  }
+  
+  /**
+   * 初始化IPC消息处理程序
+   */
+  setupIPCHandlers(): void {
+    // 防止重复注册IPC处理程序
+    if (ipcHandlersRegistered) {
+      console.log('IPC处理程序已注册，跳过重复注册');
+      return;
+    }
+    
+    console.log('注册窗口大小相关的IPC处理程序');
+    
+    // 标记为已注册
+    ipcHandlersRegistered = true;
+    
+    // 安全地移除已存在的处理程序（如果有）
+    const removeHandlerSafely = (channel: string) => {
+      try {
+        ipcMain.removeHandler(channel);
+      } catch (error) {
+        // 忽略错误，处理程序可能不存在
+      }
+    };
+    
+    // 为需要使用handle方法的通道先移除已有处理程序
+    removeHandlerSafely('get-content-zoom');
+    removeHandlerSafely('get-system-scale-factor');
+    
+    // 注册新的处理程序
+    ipcMain.on('set-content-zoom', (event, zoomFactor) => {
+      const win = BrowserWindow.fromWebContents(event.sender);
+      if (win && !win.isDestroyed()) {
+        win.webContents.setZoomFactor(zoomFactor);
+        this.store.set('set.contentZoomFactor', zoomFactor);
+      }
+    });
+    
+    ipcMain.handle('get-content-zoom', (event) => {
+      const win = BrowserWindow.fromWebContents(event.sender);
+      if (win && !win.isDestroyed()) {
+        return win.webContents.getZoomFactor();
+      }
+      return 1;
+    });
+    
+    ipcMain.handle('get-system-scale-factor', () => {
+      if (!app.isReady()) {
+        return 1;
+      }
+      
+      try {
+        return screen.getPrimaryDisplay().scaleFactor;
+      } catch (error) {
+        console.error('获取系统缩放因子失败:', error);
+        return 1;
+      }
+    });
+    
+    ipcMain.on('reset-content-zoom', (event) => {
+      const win = BrowserWindow.fromWebContents(event.sender);
+      if (win && !win.isDestroyed()) {
+        this.store.delete('set.contentZoomFactor');
+        this.applyContentZoom(win);
+      }
+    });
+    
+    ipcMain.on('resize-window', (event, width, height) => {
+      const win = BrowserWindow.fromWebContents(event.sender);
+      if (win && !win.isDestroyed()) {
+        console.log(`接收到调整窗口大小请求: ${width}x${height}`);
+        
+        // 确保尺寸不小于最小值
+        const adjustedWidth = Math.max(width, MIN_WIDTH);
+        const adjustedHeight = Math.max(height, MIN_HEIGHT);
+        
+        // 设置窗口的大小
+        win.setSize(adjustedWidth, adjustedHeight);
+        console.log(`窗口大小已调整为: ${adjustedWidth}x${adjustedHeight}`);
+        
+        // 保存窗口状态
+        this.saveWindowState(win);
+      }
+    });
+    
+    ipcMain.on('resize-mini-window', (event, showPlaylist) => {
+      const win = BrowserWindow.fromWebContents(event.sender);
+      if (win && !win.isDestroyed()) {
+        if (showPlaylist) {
+          console.log(`扩大迷你窗口至 ${DEFAULT_MINI_WIDTH} x ${DEFAULT_MINI_EXPANDED_HEIGHT}`);
+          win.setMinimumSize(DEFAULT_MINI_WIDTH, DEFAULT_MINI_HEIGHT);
+          win.setMaximumSize(DEFAULT_MINI_WIDTH, DEFAULT_MINI_EXPANDED_HEIGHT);
+          win.setSize(DEFAULT_MINI_WIDTH, DEFAULT_MINI_EXPANDED_HEIGHT, false);
+        } else {
+          console.log(`缩小迷你窗口至 ${DEFAULT_MINI_WIDTH} x ${DEFAULT_MINI_HEIGHT}`);
+          win.setMaximumSize(DEFAULT_MINI_WIDTH, DEFAULT_MINI_HEIGHT);
+          win.setMinimumSize(DEFAULT_MINI_WIDTH, DEFAULT_MINI_HEIGHT);
+          win.setSize(DEFAULT_MINI_WIDTH, DEFAULT_MINI_HEIGHT, false);
+        }
+      }
+    });
+    
+    // 只在app ready后设置显示器变化监听
+    if (app.isReady()) {
+      // 监听显示器变化事件
+      screen.on('display-metrics-changed', (_event, _display, changedMetrics) => {
+        if (this.mainWindow && !this.mainWindow.isDestroyed()) {
+          // 当缩放因子变化时，重新应用页面缩放
+          if (changedMetrics.includes('scaleFactor')) {
+            this.applyContentZoom(this.mainWindow);
+          }
+          
+          // 重新初始化最小尺寸
+          this.initMinimumWindowSize();
+        }
+      });
+    }
+    
+    // 监听 store 中的缩放设置变化
+    this.store.onDidChange('set.contentZoomFactor', () => {
+      if (this.mainWindow && !this.mainWindow.isDestroyed()) {
+        this.applyContentZoom(this.mainWindow);
+      }
+    });
+  }
+}
+
+// 创建窗口大小管理器实例
+const windowSizeManager = new WindowSizeManager();
+
+// 导出初始化函数
+export const initWindowSizeManager = (): void => {
+  // 等待app ready后再初始化
+  if (app.isReady()) {
+    windowSizeManager.initialize();
+  } else {
+    app.on('ready', () => {
+      windowSizeManager.initialize();
+    });
+  }
+};
+
+// 导出实例方法
+export const getWindowOptions = (): Electron.BrowserWindowConstructorOptions => {
+  return windowSizeManager.getWindowOptions();
+};
+
+export const applyInitialState = (win: BrowserWindow): void => {
+  windowSizeManager.applyInitialState(win);
+};
+
+export const saveWindowState = (win: BrowserWindow): WindowState => {
+  return windowSizeManager.saveWindowState(win);
+};
+
+export const getWindowState = (): WindowState | null => {
+  return windowSizeManager.getWindowState();
+};
+
+export const applyContentZoom = (win: BrowserWindow): void => {
+  windowSizeManager.applyContentZoom(win);
+};
+
+export const initWindowSizeHandlers = (mainWindow: BrowserWindow | null): void => {
+  // 确保app ready后再初始化
+  if (!app.isReady()) {
+    app.on('ready', () => {
+      if (mainWindow) {
+        windowSizeManager.setMainWindow(mainWindow);
+      }
+    });
+  } else {
+    if (mainWindow) {
+      windowSizeManager.setMainWindow(mainWindow);
+    }
+  }
+};
+
+export const calculateMinimumWindowSize = (): { minWidth: number; minHeight: number } => {
+  return { minWidth: MIN_WIDTH, minHeight: MIN_HEIGHT };
+}; 

src/main/modules/window.ts

@@ -1,10 +1,35 @@
-import { BrowserWindow, shell, ipcMain, app, session } from 'electron';
 import { is } from '@electron-toolkit/utils';
-import { join } from 'path';
+import { app, BrowserWindow, nativeImage, globalShortcut, ipcMain, screen, session, shell } from 'electron';
 import Store from 'electron-store';
+import { join } from 'path';
+import {
+  DEFAULT_MAIN_WIDTH,
+  DEFAULT_MAIN_HEIGHT,
+  DEFAULT_MINI_WIDTH,
+  DEFAULT_MINI_HEIGHT,
+  applyContentZoom,
+  saveWindowState,
+  applyInitialState,
+  initWindowSizeHandlers,
+  getWindowOptions,
+  getWindowState,
+  WindowState
+} from './window-size';
 
 const store = new Store();
 
+// 保存主窗口引用，以便在 activate 事件中使用
+let mainWindowInstance: BrowserWindow | null = null;
+let isPlaying = false;
+// 保存迷你模式前的窗口状态
+let preMiniModeState: WindowState = {
+  width: DEFAULT_MAIN_WIDTH,
+  height: DEFAULT_MAIN_HEIGHT,
+  x: undefined,
+  y: undefined,
+  isMaximized: false
+};
+
 /**
  * 初始化代理设置
  */
@@ -31,6 +56,38 @@ function initializeProxy() {
   }
 }
 
+function setThumbarButtons(window: BrowserWindow) {
+  window.setThumbarButtons([
+    {
+      tooltip: 'prev',
+      icon: nativeImage
+        .createFromPath(join(app.getAppPath(), 'resources/icons', 'prev.png')),
+      click() {
+        window.webContents.send('global-shortcut', 'prevPlay');
+      },
+    },
+
+    {
+      tooltip: isPlaying ? 'pause' : 'play',
+      icon: nativeImage
+        .createFromPath(join(app.getAppPath(), 'resources/icons', isPlaying ? 'pause.png' : 'play.png')),
+      click() {
+        window.webContents.send('global-shortcut', 'togglePlay');
+      },
+    },
+
+    {
+      tooltip: 'next',
+      icon: nativeImage
+        .createFromPath(join(app.getAppPath(), 'resources/icons', 'next.png')),
+      click() {
+        window.webContents.send('global-shortcut', 'nextPlay');
+      },
+    }
+  ]);
+}
+
+
 /**
  * 初始化窗口管理相关的IPC监听
  */
@@ -53,6 +110,7 @@ export function initializeWindowManager() {
       } else {
         win.maximize();
       }
+      // 状态保存在事件监听器中处理
     }
   });
 
@@ -71,34 +129,198 @@ export function initializeWindowManager() {
     }
   });
 
+  ipcMain.on('mini-window', (event) => {
+    const win = BrowserWindow.fromWebContents(event.sender);
+    if (win) {
+      // 保存当前窗口状态，以便之后恢复
+      preMiniModeState = saveWindowState(win);
+      console.log('保存正常模式状态用于恢复:', JSON.stringify(preMiniModeState));
+
+      // 获取屏幕工作区尺寸
+      const display = screen.getDisplayMatching(win.getBounds());
+      const { width: screenWidth, x: screenX } = display.workArea;
+
+      // 设置迷你窗口的大小和位置
+      win.unmaximize();
+      win.setMinimumSize(DEFAULT_MINI_WIDTH, DEFAULT_MINI_HEIGHT);
+      win.setMaximumSize(DEFAULT_MINI_WIDTH, DEFAULT_MINI_HEIGHT);
+      win.setSize(DEFAULT_MINI_WIDTH, DEFAULT_MINI_HEIGHT, false); // 禁用动画
+      // 将迷你窗口放在工作区的右上角，留出一些边距
+      win.setPosition(screenX + screenWidth - DEFAULT_MINI_WIDTH - 20, display.workArea.y + 20, false);
+      win.setAlwaysOnTop(true);
+      win.setSkipTaskbar(false);
+      win.setResizable(false);
+
+      // 导航到迷你模式路由
+      win.webContents.send('navigate', '/mini');
+
+      // 发送事件到渲染进程，通知切换到迷你模式
+      win.webContents.send('mini-mode', true);
+
+      // 迷你窗口使用默认的缩放比
+      win.webContents.setZoomFactor(1);
+    }
+  });
+
+  // 恢复窗口
+  ipcMain.on('restore-window', (event) => {
+    const win = BrowserWindow.fromWebContents(event.sender);
+    if (win) {
+      // 恢复窗口的大小调整功能
+      win.setResizable(true);
+      win.setMaximumSize(0, 0); // 取消最大尺寸限制
+
+      console.log('从迷你模式恢复，使用保存的状态:', JSON.stringify(preMiniModeState));
+
+      // 设置适当的最小尺寸
+      win.setMinimumSize(Math.max(DEFAULT_MAIN_WIDTH * 0.5, 600), Math.max(DEFAULT_MAIN_HEIGHT * 0.5, 400));
+
+      // 恢复窗口状态
+      win.setAlwaysOnTop(false);
+      win.setSkipTaskbar(false);
+
+      // 导航回主页面
+      win.webContents.send('navigate', '/');
+
+      // 发送事件到渲染进程，通知退出迷你模式
+      win.webContents.send('mini-mode', false);
+
+      // 应用保存的状态
+      setTimeout(() => {
+        // 如果有保存的位置，则应用
+        if (preMiniModeState.x !== undefined && preMiniModeState.y !== undefined) {
+          win.setPosition(preMiniModeState.x, preMiniModeState.y, false);
+        } else {
+          win.center();
+        }
+
+        // 使用存储的迷你模式前的状态
+        if (preMiniModeState.isMaximized) {
+          win.maximize();
+        } else {
+          // 设置正确的窗口大小
+          win.setSize(preMiniModeState.width, preMiniModeState.height, false);
+        }
+
+        // 应用页面缩放
+        applyContentZoom(win);
+
+        // 确保窗口大小被正确应用
+        setTimeout(() => {
+          if (!win.isDestroyed() && !win.isMaximized() && !win.isMinimized()) {
+            // 再次验证窗口大小
+            const [width, height] = win.getSize();
+            if (Math.abs(width - preMiniModeState.width) > 2 ||
+              Math.abs(height - preMiniModeState.height) > 2) {
+              console.log(`恢复后窗口大小不一致，再次调整: 当前=${width}x${height}, 目标=${preMiniModeState.width}x${preMiniModeState.height}`);
+              win.setSize(preMiniModeState.width, preMiniModeState.height, false);
+            }
+          }
+        }, 150);
+      }, 50);
+    }
+  });
+
+
+  ipcMain.on('update-play-state', (_, playing: boolean) => {
+    isPlaying = playing;
+    if (mainWindowInstance) {
+      setThumbarButtons(mainWindowInstance);
+    }
+  });
+
   // 监听代理设置变化
   store.onDidChange('set.proxyConfig', () => {
     initializeProxy();
   });
+
+  // 初始化窗口大小和缩放相关的IPC处理程序
+  initWindowSizeHandlers(mainWindowInstance);
+  // 监听 macOS 下点击 Dock 图标的事件
+  app.on('activate', () => {
+    // 当应用被激活时，检查主窗口是否存在
+    if (mainWindowInstance && !mainWindowInstance.isDestroyed()) {
+      // 如果窗口存在但被隐藏，则显示窗口
+      if (!mainWindowInstance.isVisible()) {
+        mainWindowInstance.show();
+      }
+    }
+  });
 }
 
 /**
  * 创建主窗口
  */
 export function createMainWindow(icon: Electron.NativeImage): BrowserWindow {
-  const mainWindow = new BrowserWindow({
-    width: 1200,
-    height: 780,
-    show: false,
-    frame: false,
-    autoHideMenuBar: true,
-    icon,
-    webPreferences: {
-      preload: join(__dirname, '../preload/index.js'),
-      sandbox: false,
-      contextIsolation: true
-    }
+  console.log('开始创建主窗口...');
+
+  // 获取窗口创建选项
+  const options = getWindowOptions();
+
+  // 添加图标和预加载脚本
+  options.icon = icon;
+  options.webPreferences = {
+    preload: join(__dirname, '../preload/index.js'),
+    sandbox: false,
+    contextIsolation: true,
+    webSecurity: false
+  };
+
+  console.log(`创建窗口，使用选项: ${JSON.stringify({
+    width: options.width,
+    height: options.height,
+    x: options.x,
+    y: options.y,
+    minWidth: options.minWidth,
+    minHeight: options.minHeight
+  })}`);
+
+  // 创建窗口
+  const mainWindow = new BrowserWindow(options);
+
+  // 移除菜单
+  mainWindow.removeMenu();
+
+  // 应用初始状态 (例如最大化状态)
+  applyInitialState(mainWindow);
+
+  // 更新 preMiniModeState，以便迷你模式可以正确恢复
+  const savedState = getWindowState();
+  if (savedState) {
+    preMiniModeState = { ...savedState };
+  }
+
+  mainWindow.on('show', () => {
+    setThumbarButtons(mainWindow);
   });
 
-  mainWindow.setMinimumSize(1200, 780);
-
   mainWindow.on('ready-to-show', () => {
+    const [width, height] = mainWindow.getSize();
+    console.log(`窗口显示前的大小: ${width}x${height}`);
+
+    // 强制确保窗口使用正确的大小
+    if (savedState && !savedState.isMaximized) {
+      mainWindow.setSize(savedState.width, savedState.height, false);
+    }
+
+    // 显示窗口
     mainWindow.show();
+    // 应用页面内容缩放
+    applyContentZoom(mainWindow);
+
+    // 再次检查窗口大小是否正确应用
+    setTimeout(() => {
+      if (!mainWindow.isDestroyed() && !mainWindow.isMaximized()) {
+        const [currentWidth, currentHeight] = mainWindow.getSize();
+        if (savedState && !savedState.isMaximized) {
+          if (Math.abs(currentWidth - savedState.width) > 2 ||
+            Math.abs(currentHeight - savedState.height) > 2) {
+            console.log(`窗口大小不匹配，再次调整: 当前=${currentWidth}x${currentHeight}, 目标=${savedState.width}x${savedState.height}`);
+            mainWindow.setSize(savedState.width, savedState.height, false);
+          }
+        }
+      }
+    }, 100);
   });
 
   mainWindow.webContents.setWindowOpenHandler((details) => {
@@ -111,9 +333,20 @@ export function createMainWindow(icon: Electron.NativeImage): BrowserWindow {
   if (is.dev && process.env.ELECTRON_RENDERER_URL) {
     mainWindow.webContents.openDevTools({ mode: 'detach' });
     mainWindow.loadURL(process.env.ELECTRON_RENDERER_URL);
+
+    // 注册快捷键 打开开发者工具
+    globalShortcut.register('CommandOrControl+Shift+I', () => {
+      mainWindow.webContents.openDevTools({ mode: 'detach' });
+    });
   } else {
     mainWindow.loadFile(join(__dirname, '../renderer/index.html'));
   }
 
+  initWindowSizeHandlers(mainWindow);
+
+
+  // 保存主窗口引用
+  mainWindowInstance = mainWindow;
+
   return mainWindow;
-} 
+}

src/main/server.ts

@@ -1,24 +1,28 @@
 import { ipcMain } from 'electron';
 import Store from 'electron-store';
 import fs from 'fs';
+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) => {
-  return unblockMusic(id, data);
+// 设置音乐解析的处理程序
+ipcMain.handle('unblock-music', async (_event, id, songData, enabledSources) => {
+  try {
+    const result = await unblockMusic(id, songData, 1, enabledSources as Platform[]);
+    return result;
+  } catch (error) {
+    console.error('音乐解析失败:', error);
+    return { error: (error as Error).message || '未知错误' };
+  }
 });
 
-import server from 'netease-cloud-music-api-alger/server';
-
-
 async function startMusicApi(): Promise<void> {
   console.log('MUSIC API STARTED');
 

src/main/set.json

@@ -14,5 +14,16 @@
   "authorUrl": "https://github.com/algerkong",
   "musicApiPort": 30488,
   "closeAction": "ask",
-  "musicQuality": "higher"
+  "musicQuality": "higher",
+  "fontFamily": "system-ui",
+  "fontScope": "global",
+  "autoPlay": false,
+  "downloadPath": "",
+  "language": "zh-CN",
+  "alwaysShowDownloadButton": false,
+  "unlimitedDownload": false,
+  "enableMusicUnblock": true,
+  "enabledMusicSources": ["migu", "kugou", "pyncmd", "bilibili", "kuwo"],
+  "showTopAction": false,
+  "contentZoomFactor": 1
 }

src/main/unblockMusic.ts

@@ -1,23 +1,86 @@
 import match from '@unblockneteasemusic/server';
 
-const unblockMusic = async (id: any, songData: any): Promise<any> => {
-  return new Promise((resolve, reject) => {
-    match(parseInt(id, 10), ['qq', 'migu', 'kugou', 'joox'], songData)
-      .then((data) => {
-        resolve({
-          data: {
-            data,
-            params: {
-              id,
-              type: 'song'
-            }
+type Platform = 'qq' | 'migu' | 'kugou' | 'pyncmd' | 'joox' | 'kuwo' | 'bilibili';
+
+interface SongData {
+  name: string;
+  artists: Array<{ name: string }>;
+  album?: { name: string };
+  ar?: Array<{ name: string }>;
+  al?: { name: string };
+}
+
+interface ResponseData {
+  url: string;
+  br: number;
+  size: number;
+  md5?: string;
+  platform?: Platform;
+  gain?: number;
+}
+
+interface UnblockResult {
+  data: {
+    data: ResponseData;
+    params: {
+      id: number;
+      type: 'song';
+    };
+  };
+}
+
+// 所有可用平台
+export const ALL_PLATFORMS: Platform[] = ['migu', 'kugou', 'pyncmd', 'kuwo', 'bilibili'];
+
+/**
+ * 音乐解析函数
+ * @param id 歌曲ID
+ * @param songData 歌曲信息
+ * @param retryCount 重试次数
+ * @param enabledPlatforms 启用的平台列表，默认为所有平台
+ * @returns Promise<UnblockResult>
+ */
+const unblockMusic = async (
+  id: number | string,
+  songData: SongData,
+  retryCount = 1,
+  enabledPlatforms?: Platform[]
+): Promise<UnblockResult> => {
+  // 过滤 enabledPlatforms，确保只包含 ALL_PLATFORMS 中存在的平台
+  const filteredPlatforms = enabledPlatforms 
+    ? enabledPlatforms.filter(platform => ALL_PLATFORMS.includes(platform))
+    : ALL_PLATFORMS;
+  
+  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), filteredPlatforms, songData);
+      const result: UnblockResult = {
+        data: {
+          data,
+          params: {
+            id: parseInt(String(id), 10),
+            type: 'song'
           }
-        });
-      })
-      .catch((err) => {
-        reject(err);
-      });
-  });
+        }
+      };
+      return result;
+    } catch (err) {
+      if (attempt < retryCount) {
+        // 延迟重试，每次重试增加延迟时间
+        await new Promise((resolve) => setTimeout(resolve, 100 * attempt));
+        return retry(attempt + 1);
+      }
+
+      // 所有重试都失败后，抛出详细错误
+      throw new Error(
+        `音乐解析失败 (ID: ${id}): ${err instanceof Error ? err.message : '未知错误'}`
+      );
+    }
+  };
+
+  return retry(1);
 };
 
-export { unblockMusic };
+export { type Platform, type ResponseData, type SongData, unblockMusic, type UnblockResult };

src/preload/index.d.ts

@@ -1,19 +1,42 @@
 import { ElectronAPI } from '@electron-toolkit/preload';
 
+interface API {
+  minimize: () => void;
+  maximize: () => void;
+  close: () => void;
+  dragStart: (data: any) => void;
+  miniTray: () => void;
+  miniWindow: () => void;
+  restore: () => void;
+  restart: () => void;
+  resizeWindow: (width: number, height: number) => void;
+  resizeMiniWindow: (showPlaylist: boolean) => void;
+  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;
+  onLanguageChanged: (callback: (locale: string) => void) => void;
+  removeDownloadListeners: () => void;
+  invoke: (channel: string, ...args: any[]) => Promise<any>;
+}
+
+// 自定义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: {
-      sendLyric: (data: string) => void;
-      openLyric: () => void;
-      minimize: () => void;
-      maximize: () => void;
-      close: () => void;
-      dragStart: (data: string) => void;
-      miniTray: () => void;
-      restart: () => void;
-      unblockMusic: (id: number, data: any) => Promise<any>;
-    };
-    $message:any
+    api: API;
+    ipcRenderer: IpcRenderer;
+    $message: any;
   }
 }

src/preload/index.ts

@@ -8,10 +8,79 @@ const api = {
   close: () => ipcRenderer.send('close-window'),
   dragStart: (data) => ipcRenderer.send('drag-start', data),
   miniTray: () => ipcRenderer.send('mini-tray'),
+  miniWindow: () => ipcRenderer.send('mini-window'),
+  restore: () => ipcRenderer.send('restore-window'),
   restart: () => ipcRenderer.send('restart'),
+  resizeWindow: (width, height) => ipcRenderer.send('resize-window', width, height),
+  resizeMiniWindow: (showPlaylist) => ipcRenderer.send('resize-mini-window', showPlaylist),
   openLyric: () => ipcRenderer.send('open-lyric'),
   sendLyric: (data) => ipcRenderer.send('send-lyric', data),
-  unblockMusic: (id) => ipcRenderer.invoke('unblock-music', id)
+  sendSong: (data) => ipcRenderer.send('update-current-song', data),
+  unblockMusic: (id, data, enabledSources) => ipcRenderer.invoke('unblock-music', id, data, enabledSources),
+  // 歌词窗口关闭事件
+  onLyricWindowClosed: (callback: () => void) => {
+    ipcRenderer.on('lyric-window-closed', () => callback());
+  },
+  // 更新相关
+  startDownload: (url: string) => ipcRenderer.send('start-download', url),
+  onDownloadProgress: (callback: (progress: number, status: string) => void) => {
+    ipcRenderer.on('download-progress', (_event, progress, status) => callback(progress, status));
+  },
+  onDownloadComplete: (callback: (success: boolean, filePath: string) => void) => {
+    ipcRenderer.on('download-complete', (_event, success, filePath) => callback(success, filePath));
+  },
+  // 语言相关
+  onLanguageChanged: (callback: (locale: string) => void) => {
+    ipcRenderer.on('language-changed', (_event, locale) => {
+      callback(locale);
+    });
+  },
+  removeDownloadListeners: () => {
+    ipcRenderer.removeAllListeners('download-progress');
+    ipcRenderer.removeAllListeners('download-complete');
+  },
+  // 歌词缓存相关
+  invoke: (channel: string, ...args: any[]) => {
+    const validChannels = [
+      'get-lyrics',
+      'clear-lyrics-cache',
+      'get-system-fonts',
+      'get-cached-lyric',
+      'cache-lyric',
+      'clear-lyric-cache',
+      // 统计相关
+      'record-visit',
+      'record-play',
+      'get-stats-summary'
+    ];
+    if (validChannels.includes(channel)) {
+      return ipcRenderer.invoke(channel, ...args);
+    }
+    return Promise.reject(new Error(`未授权的 IPC 通道: ${channel}`));
+  }
+};
+
+// 创建带类型的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
@@ -21,6 +90,7 @@ if (process.contextIsolated) {
   try {
     contextBridge.exposeInMainWorld('electron', electronAPI);
     contextBridge.exposeInMainWorld('api', api);
+    contextBridge.exposeInMainWorld('ipcRenderer', ipc);
   } catch (error) {
     console.error(error);
   }
@@ -29,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

@@ -11,28 +11,117 @@
 </template>
 
 <script setup lang="ts">
+import { cloneDeep } from 'lodash';
 import { darkTheme, lightTheme } from 'naive-ui';
-import { onMounted } from 'vue';
-import { isElectron } from '@/utils';
+import { computed, nextTick, onMounted, watch } from 'vue';
+import { useI18n } from 'vue-i18n';
+import { useRouter } from 'vue-router';
 
 import homeRouter from '@/router/home';
-import store from '@/store';
+import { useMenuStore } from '@/store/modules/menu';
+import { usePlayerStore } from '@/store/modules/player';
+import { useSettingsStore } from '@/store/modules/settings';
+import { isElectron, isLyricWindow } from '@/utils';
 
+import { initAudioListeners } from './hooks/MusicHook';
 import { isMobile } from './utils';
+import { useAppShortcuts } from './utils/appShortcuts';
+import { audioService } from './services/audioService';
+
+const { locale } = useI18n();
+const settingsStore = useSettingsStore();
+const menuStore = useMenuStore();
+const playerStore = usePlayerStore();
+const router = useRouter();
+
+// 监听语言变化
+watch(
+  () => settingsStore.setData.language,
+  (newLanguage) => {
+    if (newLanguage && newLanguage !== locale.value) {
+      locale.value = newLanguage;
+    }
+  },
+  { immediate: true }
+);
 
 const theme = computed(() => {
-  return store.state.theme;
+  return settingsStore.theme;
 });
 
-onMounted(() => {
-  store.dispatch('initializeSettings');
-  store.dispatch('initializeTheme');
-  if (isMobile.value) {
-    store.commit(
-      'setMenus',
-      homeRouter.filter((item) => item.meta.isMobile)
-    );
+// 监听字体变化并应用
+watch(
+  () => [settingsStore.setData.fontFamily, settingsStore.setData.fontScope],
+  ([newFont, fontScope]) => {
+    const appElement = document.body;
+    if (newFont && fontScope === 'global') {
+      appElement.style.fontFamily = newFont;
+    } else {
+      appElement.style.fontFamily = '';
+    }
   }
+);
+
+const handleSetLanguage = (value: string) => {
+  console.log('应用语言变更:', value);
+  if (value) {
+    locale.value = value;
+  }
+};
+
+if (!isLyricWindow.value) {
+  settingsStore.initializeSettings();
+  settingsStore.initializeTheme();
+  settingsStore.initializeSystemFonts();
+  if (isMobile.value) {
+    menuStore.setMenus(homeRouter.filter((item) => item.meta.isMobile));
+  }
+}
+
+handleSetLanguage(settingsStore.setData.language);
+
+// 监听迷你模式状态
+if (isElectron) {
+  window.api.onLanguageChanged(handleSetLanguage);
+  window.electron.ipcRenderer.on('mini-mode', (_, value) => {
+    settingsStore.setMiniMode(value);
+    if (value) {
+      // 存储当前路由
+      localStorage.setItem('currentRoute', router.currentRoute.value.path);
+      router.push('/mini');
+    } else {
+      // 恢复当前路由
+      const currentRoute = localStorage.getItem('currentRoute');
+      if (currentRoute) {
+        router.push(currentRoute);
+        localStorage.removeItem('currentRoute');
+      } else {
+        router.push('/');
+      }
+    }
+  });
+}
+
+// 使用应用内快捷键
+useAppShortcuts();
+
+onMounted(async () => {
+  if (isLyricWindow.value) {
+    return;
+  }
+  // 先初始化播放状态
+  await playerStore.initializePlayState();
+  // 如果有正在播放的音乐，则初始化音频监听器
+  if (playerStore.playMusic && playerStore.playMusic.id) {
+    // 使用 nextTick 确保 DOM 更新后再初始化
+    await nextTick();
+    initAudioListeners();
+    if (isElectron) {
+      window.api.sendSong(cloneDeep(playerStore.playMusic));
+    }
+  }
+
+  audioService.releaseOperationLock();
 });
 </script>
 

src/renderer/api/artist.ts

@@ -0,0 +1,21 @@
+import request from '@/utils/request';
+
+// 获取歌手详情
+export const getArtistDetail = (id) => {
+  return request.get('/artist/detail', { params: { id } });
+};
+
+// 获取歌手热门歌曲
+export const getArtistTopSongs = (params) => {
+  return request.get('/artist/songs', {
+    params: {
+      ...params,
+      order: 'hot'
+    }
+  });
+};
+
+// 获取歌手专辑
+export const getArtistAlbums = (params) => {
+  return request.get('/artist/album', { params });
+};

src/renderer/api/bilibili.ts

@@ -0,0 +1,183 @@
+import type { IBilibiliPlayUrl, IBilibiliVideoDetail } from '@/types/bilibili';
+import { getSetData, isElectron } from '@/utils';
+import request from '@/utils/request';
+
+interface ISearchParams {
+  keyword: string;
+  page?: number;
+  pagesize?: number;
+  search_type?: string;
+}
+
+/**
+ * 搜索B站视频
+ * @param params 搜索参数
+ */
+export const searchBilibili = (params: ISearchParams) => {
+  console.log('调用B站搜索API，参数:', params);
+  return request.get('/bilibili/search', {
+    params
+  });
+};
+
+interface IBilibiliResponse<T> {
+  code: number;
+  message: string;
+  ttl: number;
+  data: T;
+}
+
+/**
+ * 获取B站视频详情
+ * @param bvid B站视频BV号
+ * @returns 视频详情响应
+ */
+export const getBilibiliVideoDetail = (
+  bvid: string
+): Promise<IBilibiliResponse<IBilibiliVideoDetail>> => {
+  console.log('调用B站视频详情API，bvid:', bvid);
+  return new Promise((resolve, reject) => {
+    request
+      .get('/bilibili/video/detail', {
+        params: { bvid }
+      })
+      .then((response) => {
+        console.log('B站视频详情API响应:', response.status);
+
+        // 检查响应状态和数据格式
+        if (response.status === 200 && response.data && response.data.data) {
+          console.log('B站视频详情API成功，标题:', response.data.data.title);
+          resolve(response.data);
+        } else {
+          console.error('B站视频详情API响应格式不正确:', response.data);
+          reject(new Error('获取视频详情响应格式不正确'));
+        }
+      })
+      .catch((error) => {
+        console.error('B站视频详情API错误:', error);
+        reject(error);
+      });
+  });
+};
+
+/**
+ * 获取B站视频播放地址
+ * @param bvid B站视频BV号
+ * @param cid 视频分P的id
+ * @param qn 视频质量，默认为0
+ * @param fnval 视频格式标志，默认为80
+ * @param fnver 视频格式版本，默认为0
+ * @param fourk 是否允许4K视频，默认为1
+ * @returns 视频播放地址响应
+ */
+export const getBilibiliPlayUrl = (
+  bvid: string,
+  cid: number,
+  qn: number = 0,
+  fnval: number = 80,
+  fnver: number = 0,
+  fourk: number = 1
+): Promise<IBilibiliResponse<IBilibiliPlayUrl>> => {
+  console.log('调用B站视频播放地址API，bvid:', bvid, 'cid:', cid);
+  return new Promise((resolve, reject) => {
+    request
+      .get('/bilibili/playurl', {
+        params: {
+          bvid,
+          cid,
+          qn,
+          fnval,
+          fnver,
+          fourk
+        }
+      })
+      .then((response) => {
+        console.log('B站视频播放地址API响应:', response.status);
+
+        // 检查响应状态和数据格式
+        if (response.status === 200 && response.data && response.data.data) {
+          if (response.data.data.dash?.audio?.length > 0) {
+            console.log(
+              'B站视频播放地址API成功，获取到',
+              response.data.data.dash.audio.length,
+              '个音频地址'
+            );
+          } else if (response.data.data.durl?.length > 0) {
+            console.log(
+              'B站视频播放地址API成功，获取到',
+              response.data.data.durl.length,
+              '个播放地址'
+            );
+          }
+          resolve(response.data);
+        } else {
+          console.error('B站视频播放地址API响应格式不正确:', response.data);
+          reject(new Error('获取视频播放地址响应格式不正确'));
+        }
+      })
+      .catch((error) => {
+        console.error('B站视频播放地址API错误:', error);
+        reject(error);
+      });
+  });
+};
+
+export const getBilibiliProxyUrl = (url: string) => {
+  const setData = getSetData();
+  const baseURL = isElectron
+    ? `http://127.0.0.1:${setData?.musicApiPort}`
+    : import.meta.env.VITE_API;
+  const AUrl = url.startsWith('http') ? url : `https:${url}`;
+  return `${baseURL}/bilibili/stream-proxy?url=${encodeURIComponent(AUrl)}`;
+};
+
+export const getBilibiliAudioUrl = async (bvid: string, cid: number): Promise<string> => {
+  console.log('获取B站音频URL', { bvid, cid });
+  try {
+    const res = await getBilibiliPlayUrl(bvid, cid);
+    const playUrlData = res.data;
+    let url = '';
+
+    if (playUrlData.dash && playUrlData.dash.audio && playUrlData.dash.audio.length > 0) {
+      url = playUrlData.dash.audio[0].baseUrl;
+    } else if (playUrlData.durl && playUrlData.durl.length > 0) {
+      url = playUrlData.durl[0].url;
+    } else {
+      throw new Error('未找到可用的音频地址');
+    }
+
+    return getBilibiliProxyUrl(url);
+  } catch (error) {
+    console.error('获取B站音频URL失败:', error);
+    throw error;
+  }
+};
+
+
+// 根据音乐名称搜索并直接返回音频URL
+export const searchAndGetBilibiliAudioUrl = async (
+  keyword: string
+): Promise<string> => {
+  try {
+    // 搜索B站视频，取第一页第一个结果
+    const res = await searchBilibili({ keyword, page: 1, pagesize: 1 });
+    const result = res.data?.data?.result;
+    if (!result || result.length === 0) {
+      throw new Error('未找到相关B站视频');
+    }
+    const first = result[0];
+    const bvid = first.bvid;
+    // 需要获取视频详情以获得cid
+    const detailRes = await getBilibiliVideoDetail(bvid);
+    const pages = detailRes.data.pages;
+    if (!pages || pages.length === 0) {
+      throw new Error('未找到视频分P信息');
+    }
+    const cid = pages[0].cid;
+    // 获取音频URL
+    return await getBilibiliAudioUrl(bvid, cid);
+  } catch (error) {
+    console.error('根据名称搜索B站音频URL失败:', error);
+    throw error;
+  }
+}

src/renderer/api/donation.ts

@@ -0,0 +1,20 @@
+import axios from 'axios';
+
+export interface Donor {
+  id: number;
+  name: string;
+  amount: number;
+  date: string;
+  message?: string;
+  avatar?: string;
+  badge: string;
+  badgeColor: string;
+}
+
+/**
+ * 获取捐赠列表
+ */
+export const getDonationList = async (): Promise<Donor[]> => {
+  const { data } = await axios.get('http://donate.alger.fun/api/donations');
+  return data;
+};

src/renderer/api/gdmusic.ts

@@ -0,0 +1,187 @@
+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 音质设置
+ * @param timeout 超时时间(毫秒)，默认15000ms
+ * @returns 解析后的音乐URL及相关信息
+ */
+export const parseFromGDMusic = async (
+  id: number, 
+  data: any, 
+  quality: string = '999',
+  timeout: number = 15000
+): Promise<ParsedMusicResult | null> => {
+  // 创建一个超时Promise
+  const timeoutPromise = new Promise<null>((_, reject) => {
+    setTimeout(() => {
+      reject(new Error('GD音乐台解析超时'));
+    }, timeout);
+  });
+
+  try {
+    // 使用Promise.race竞争主解析流程和超时
+    return await Promise.race([
+      (async () => {
+        // 处理不同数据结构
+        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('搜索查询过短');
+        }
+        
+        // 所有可用的音乐源 netease、kuwo、joox、tidal
+        const allSources = [
+          'kuwo', 'joox', 'tidal', 'netease'
+        ] 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;
+      })(),
+      timeoutPromise
+    ]);
+  } catch (error: any) {
+    if (error.message === 'GD音乐台解析超时') {
+      console.error('GD音乐台解析超时(15秒):', error);
+    } else {
+      console.error('GD音乐台解析完全失败:', error);
+    }
+    return null;
+  }
+};
+
+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/list.ts

@@ -40,3 +40,8 @@ export function getListDetail(id: number | string) {
 export function getAlbum(id: number | string) {
   return request.get('/album', { params: { id } });
 }
+
+// 获取排行榜列表
+export function getToplist() {
+  return request.get('/toplist');
+}

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

@@ -1,8 +1,15 @@
-import { ILyric } from '@/type/lyric';
+import { musicDB } from '@/hooks/MusicHook';
+import { useSettingsStore, useUserStore } from '@/store';
+import type { ILyric } from '@/type/lyric';
 import { isElectron } from '@/utils';
 import request from '@/utils/request';
 import requestMusic from '@/utils/request_music';
-import store from '@/store';
+import { cloneDeep } from 'lodash';
+import { parseFromGDMusic } from './gdmusic';
+import type { SongResult } from '@/type/music';
+import { searchAndGetBilibiliAudioUrl } from './bilibili';
+
+const { addData, getData, deleteData } = musicDB;
 
 // 获取音乐音质详情
 export const getMusicQualityDetail = (id: number) => {
@@ -10,23 +17,34 @@ export const getMusicQualityDetail = (id: number) => {
 };
 
 // 根据音乐Id获取音乐播放URl
-export const getMusicUrl = async (id: number) => {
-  const res = await request.get('/song/download/url/v1', { 
-    params: { 
-      id, 
-      level: store.state.setData.musicQuality || 'higher'
-    } 
-  });
+export const getMusicUrl = async (id: number, isDownloaded: boolean = false) => {
+  const userStore = useUserStore();
+  const settingStore = useSettingsStore();
+  // 判断是否登录
+  try {
+    if (userStore.user && isDownloaded && userStore.user.vipType !== 0) {
+      const url = '/song/download/url/v1';
+      const res = await request.get(url, {
+        params: {
+          id,
+          level: settingStore.setData.musicQuality || 'higher',
+          cookie: `${localStorage.getItem('token')} os=pc;`
+        }
+      });
 
-  if (res.data.data.url) {
-    return {data:{  data:[{url:res.data.data.url}]}};
+      if (res.data.data.url) {
+        return { data: { data: [{ ...res.data.data }] } };
+      }
+    }
+  } catch (error) {
+    console.error('error', error);
   }
 
-  return await request.get('/song/url/v1', { 
-    params: { 
-      id, 
-      level: store.state.setData.musicQuality || 'higher'
-    } 
+  return await request.get('/song/url/v1', {
+    params: {
+      id,
+      level: settingStore.setData.musicQuality || 'higher'
+    }
   });
 };
 
@@ -36,14 +54,101 @@ export const getMusicDetail = (ids: Array<number>) => {
 };
 
 // 根据音乐Id获取音乐歌词
-export const getMusicLrc = (id: number) => {
-  return request.get<ILyric>('/lyric', { params: { id } });
+export const getMusicLrc = async (id: number) => {
+  const TEN_DAYS_MS = 10 * 24 * 60 * 60 * 1000; // 10天的毫秒数
+
+  try {
+    // 尝试获取缓存的歌词
+    const cachedLyric = await getData('music_lyric', id);
+    if (cachedLyric?.createTime && Date.now() - cachedLyric.createTime < TEN_DAYS_MS) {
+      return { ...cachedLyric };
+    }
+
+    // 获取新的歌词数据
+    const res = await request.get<ILyric>('/lyric', { params: { id } });
+
+    // 只有在成功获取新数据后才删除旧缓存并添加新缓存
+    if (res?.data) {
+      if (cachedLyric) {
+        await deleteData('music_lyric', id);
+      }
+      addData('music_lyric', { id, data: res.data, createTime: Date.now() });
+    }
+
+    return res;
+  } catch (error) {
+    console.error('获取歌词失败:', error);
+    throw error; // 向上抛出错误，让调用者处理
+  }
 };
 
-export const getParsingMusicUrl = (id: number, data: any) => {
-  if (isElectron) {
-    return window.api.unblockMusic(id, data);
+export const getParsingMusicUrl = async (id: number, data: SongResult) => {
+  const settingStore = useSettingsStore();
+  
+  // 如果禁用了音乐解析功能，则直接返回空结果
+  if (!settingStore.setData.enableMusicUnblock) {
+    return Promise.resolve({ data: { code: 404, message: '音乐解析功能已禁用' } });
   }
+  
+  // 获取音源设置，优先使用歌曲自定义音源
+  const songId = String(id);
+  const savedSource = localStorage.getItem(`song_source_${songId}`);
+  let enabledSources: any[] = [];
+  
+  // 如果有歌曲自定义音源，使用自定义音源
+  if (savedSource) {
+    try {
+      enabledSources = JSON.parse(savedSource);
+      console.log(`使用歌曲 ${id} 自定义音源:`, enabledSources);
+      if(enabledSources.includes('bilibili')){
+        // 构建搜索关键词，依次判断歌曲名称、歌手名称和专辑名称是否存在
+        const songName = data?.name || '';
+        const artistName = Array.isArray(data?.ar) && data.ar.length > 0 && data.ar[0]?.name ? data.ar[0].name : '';
+        const albumName = data?.al && typeof data.al === 'object' && data.al?.name ? data.al.name : '';
+        const name = [songName, artistName, albumName].filter(Boolean).join(' ').trim();
+        console.log('开始搜索bilibili音频', name);
+       return {
+        data: {
+          code: 200,
+          message: 'success',
+          data: {
+            url: await searchAndGetBilibiliAudioUrl(name)
+          }
+        }
+       }
+      }
+    } catch (e) {
+      console.error('e',e)
+      console.error('解析自定义音源失败, 使用全局设置', e);
+      enabledSources = settingStore.setData.enabledMusicSources || [];
+    }
+  } else {
+    // 没有自定义音源，使用全局音源设置
+    enabledSources = settingStore.setData.enabledMusicSources || [];
+  }
+  
+  // 检查是否选择了GD音乐台解析
+  
+  if (enabledSources.includes('gdmusic')) {
+    // 获取音质设置并转换为GD音乐台格式
+    try {
+      const gdResult = await parseFromGDMusic(id, data, '999');
+      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 } });
 };
 
@@ -53,6 +158,72 @@ export const likeSong = (id: number, like: boolean = true) => {
 };
 
 // 获取用户喜欢的音乐列表
-export const getLikedList = () => {
-  return request.get('/likelist');
+export const getLikedList = (uid: number) => {
+  return request.get('/likelist', {
+    params: { uid, noLogin: true }
+  });
 };
+
+// 创建歌单
+export const createPlaylist = (params: { name: string; privacy: number }) => {
+  return request.post('/playlist/create', params);
+};
+
+// 添加或删除歌单歌曲
+export const updatePlaylistTracks = (params: {
+  op: 'add' | 'del';
+  pid: number;
+  tracks: string;
+}) => {
+  return request.post('/playlist/tracks', params);
+};
+
+/**
+ * 根据类型获取列表数据
+ * @param type 列表类型 album/playlist
+ * @param id 列表ID
+ */
+export function getMusicListByType(type: string, id: string) {
+  if (type === 'album') {
+    return getAlbumDetail(id);
+  } else if (type === 'playlist') {
+    return getPlaylistDetail(id);
+  }
+  return Promise.reject(new Error('未知列表类型'));
+}
+
+/**
+ * 获取专辑详情
+ * @param id 专辑ID
+ */
+export function getAlbumDetail(id: string) {
+  return request({
+    url: '/album',
+    method: 'get',
+    params: {
+      id
+    }
+  });
+}
+
+/**
+ * 获取歌单详情
+ * @param id 歌单ID
+ */
+export function getPlaylistDetail(id: string) {
+  return request({
+    url: '/playlist/detail',
+    method: 'get',
+    params: {
+      id
+    }
+  });
+}
+
+export function subscribePlaylist(params: { t: number; id: number }) {
+  return request({
+    url: '/playlist/subscribe',
+    method: 'post',
+    params
+  });
+}

src/renderer/api/playlist.ts

@@ -0,0 +1,27 @@
+import request from '@/utils/request';
+
+/**
+ * 歌单导入 - 元数据/文字/链接导入
+ * @param params 导入参数
+ */
+export function importPlaylist(params: {
+  local?: string;
+  text?: string;
+  link?: string;
+  importStarPlaylist?: boolean;
+  playlistName?: string;
+}) {
+  return request.post('/playlist/import/name/task/create', params);
+}
+
+/**
+ * 歌单导入 - 任务状态
+ * @param id 任务ID
+ */
+export function getImportTaskStatus(id: string | number) {
+  return request({
+    url: '/playlist/import/task/status',
+    method: 'get',
+    params: { id }
+  });
+}

src/renderer/api/search.ts

@@ -3,6 +3,8 @@ import request from '@/utils/request';
 interface IParams {
   keywords: string;
   type: number;
+  limit?: number;
+  offset?: number;
 }
 // 搜索内容
 export const getSearch = (params: IParams) => {

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/api/user.ts

@@ -1,3 +1,4 @@
+import type { IUserDetail, IUserFollow } from '@/type/user';
 import request from '@/utils/request';
 
 // /user/detail
@@ -6,12 +7,69 @@ export function getUserDetail(uid: number) {
 }
 
 // /user/playlist
-export function getUserPlaylist(uid: number) {
-  return request.get('/user/playlist', { params: { uid } });
+export function getUserPlaylist(uid: number, limit: number = 30, offset: number = 0) {
+  return request.get('/user/playlist', { params: { uid, limit, offset } });
 }
 
 // 播放历史
 // /user/record?uid=32953014&type=1
 export function getUserRecord(uid: number, type: number = 0) {
-  return request.get('/user/record', { params: { uid, type } });
+  
+  return request.get('/user/record', {
+    params: { uid, type },
+    noRetry: true
+  } as any);
 }
+
+// 获取用户关注列表
+// /user/follows?uid=32953014
+export function getUserFollows(uid: number, limit: number = 30, offset: number = 0) {
+  return request.get('/user/follows', { params: { uid, limit, offset } });
+}
+
+// 获取用户粉丝列表
+export function getUserFollowers(uid: number, limit: number = 30, offset: number = 0) {
+  return request.post('/user/followeds', { uid, limit, offset });
+}
+
+// 获取用户账号信息
+export const getUserAccount = () => {
+  return request<any>({
+    url: '/user/account',
+    method: 'get'
+  });
+};
+
+// 获取用户详情
+export const getUserDetailInfo = (params: { uid: string | number }) => {
+  return request<IUserDetail>({
+    url: '/user/detail',
+    method: 'get',
+    params
+  });
+};
+
+// 获取用户关注列表
+export const getUserFollowsInfo = (params: {
+  uid: string | number;
+  limit?: number;
+  offset?: number;
+}) => {
+  return request<{
+    follow: IUserFollow[];
+    more: boolean;
+  }>({
+    url: '/user/follows',
+    method: 'get',
+    params
+  });
+};
+
+// 获取用户歌单
+export const getUserPlaylists = (params: { uid: string | number }) => {
+  return request({
+    url: '/user/playlist',
+    method: 'get',
+    params
+  });
+};

src/renderer/assets/css/base.css

@@ -1,7 +1,20 @@
 body {
   /* background-color: #000; */
+  overflow: hidden;
 }
 
 .n-popover:has(.music-play) {
   border-radius: 1.5rem !important;
 }
+.n-popover {
+  border-radius: 0.5rem !important;
+  overflow: hidden !important;
+}
+.n-popover:has(.transparent-popover ) {
+  background-color: transparent !important;
+  padding: 0 !important;
+}
+
+.settings-slider .n-slider-mark {
+  font-size: 10px !important;
+}

src/renderer/auto-imports.d.ts

@@ -1,75 +0,0 @@
-/* eslint-disable */
-/* prettier-ignore */
-// @ts-nocheck
-// noinspection JSUnusedGlobalSymbols
-// Generated by unplugin-auto-import
-// biome-ignore lint: disable
-export {}
-declare global {
-  const EffectScope: typeof import('vue')['EffectScope']
-  const computed: typeof import('vue')['computed']
-  const createApp: typeof import('vue')['createApp']
-  const customRef: typeof import('vue')['customRef']
-  const defineAsyncComponent: typeof import('vue')['defineAsyncComponent']
-  const defineComponent: typeof import('vue')['defineComponent']
-  const effectScope: typeof import('vue')['effectScope']
-  const getCurrentInstance: typeof import('vue')['getCurrentInstance']
-  const getCurrentScope: typeof import('vue')['getCurrentScope']
-  const h: typeof import('vue')['h']
-  const inject: typeof import('vue')['inject']
-  const isProxy: typeof import('vue')['isProxy']
-  const isReactive: typeof import('vue')['isReactive']
-  const isReadonly: typeof import('vue')['isReadonly']
-  const isRef: typeof import('vue')['isRef']
-  const markRaw: typeof import('vue')['markRaw']
-  const nextTick: typeof import('vue')['nextTick']
-  const onActivated: typeof import('vue')['onActivated']
-  const onBeforeMount: typeof import('vue')['onBeforeMount']
-  const onBeforeUnmount: typeof import('vue')['onBeforeUnmount']
-  const onBeforeUpdate: typeof import('vue')['onBeforeUpdate']
-  const onDeactivated: typeof import('vue')['onDeactivated']
-  const onErrorCaptured: typeof import('vue')['onErrorCaptured']
-  const onMounted: typeof import('vue')['onMounted']
-  const onRenderTracked: typeof import('vue')['onRenderTracked']
-  const onRenderTriggered: typeof import('vue')['onRenderTriggered']
-  const onScopeDispose: typeof import('vue')['onScopeDispose']
-  const onServerPrefetch: typeof import('vue')['onServerPrefetch']
-  const onUnmounted: typeof import('vue')['onUnmounted']
-  const onUpdated: typeof import('vue')['onUpdated']
-  const onWatcherCleanup: typeof import('vue')['onWatcherCleanup']
-  const provide: typeof import('vue')['provide']
-  const reactive: typeof import('vue')['reactive']
-  const readonly: typeof import('vue')['readonly']
-  const ref: typeof import('vue')['ref']
-  const resolveComponent: typeof import('vue')['resolveComponent']
-  const shallowReactive: typeof import('vue')['shallowReactive']
-  const shallowReadonly: typeof import('vue')['shallowReadonly']
-  const shallowRef: typeof import('vue')['shallowRef']
-  const toRaw: typeof import('vue')['toRaw']
-  const toRef: typeof import('vue')['toRef']
-  const toRefs: typeof import('vue')['toRefs']
-  const toValue: typeof import('vue')['toValue']
-  const triggerRef: typeof import('vue')['triggerRef']
-  const unref: typeof import('vue')['unref']
-  const useAttrs: typeof import('vue')['useAttrs']
-  const useCssModule: typeof import('vue')['useCssModule']
-  const useCssVars: typeof import('vue')['useCssVars']
-  const useDialog: typeof import('naive-ui')['useDialog']
-  const useId: typeof import('vue')['useId']
-  const useLoadingBar: typeof import('naive-ui')['useLoadingBar']
-  const useMessage: typeof import('naive-ui')['useMessage']
-  const useModel: typeof import('vue')['useModel']
-  const useNotification: typeof import('naive-ui')['useNotification']
-  const useSlots: typeof import('vue')['useSlots']
-  const useTemplateRef: typeof import('vue')['useTemplateRef']
-  const watch: typeof import('vue')['watch']
-  const watchEffect: typeof import('vue')['watchEffect']
-  const watchPostEffect: typeof import('vue')['watchPostEffect']
-  const watchSyncEffect: typeof import('vue')['watchSyncEffect']
-}
-// for type re-export
-declare global {
-  // @ts-ignore
-  export type { Component, ComponentPublicInstance, ComputedRef, DirectiveBinding, ExtractDefaultPropTypes, ExtractPropTypes, ExtractPublicPropTypes, InjectionKey, PropType, Ref, MaybeRef, MaybeRefOrGetter, VNode, WritableComputedRef } from 'vue'
-  import('vue')
-}

src/renderer/components.d.ts

@@ -1,40 +0,0 @@
-/* eslint-disable */
-// @ts-nocheck
-// Generated by unplugin-vue-components
-// Read more: https://github.com/vuejs/core/pull/3399
-export {}
-
-/* prettier-ignore */
-declare module 'vue' {
-  export interface GlobalComponents {
-    NAvatar: typeof import('naive-ui')['NAvatar']
-    NButton: typeof import('naive-ui')['NButton']
-    NButtonGroup: typeof import('naive-ui')['NButtonGroup']
-    NCheckbox: typeof import('naive-ui')['NCheckbox']
-    NConfigProvider: typeof import('naive-ui')['NConfigProvider']
-    NDialogProvider: typeof import('naive-ui')['NDialogProvider']
-    NDrawer: typeof import('naive-ui')['NDrawer']
-    NDropdown: typeof import('naive-ui')['NDropdown']
-    NEllipsis: typeof import('naive-ui')['NEllipsis']
-    NEmpty: typeof import('naive-ui')['NEmpty']
-    NForm: typeof import('naive-ui')['NForm']
-    NFormItem: typeof import('naive-ui')['NFormItem']
-    NImage: typeof import('naive-ui')['NImage']
-    NInput: typeof import('naive-ui')['NInput']
-    NInputNumber: typeof import('naive-ui')['NInputNumber']
-    NLayout: typeof import('naive-ui')['NLayout']
-    NMessageProvider: typeof import('naive-ui')['NMessageProvider']
-    NModal: typeof import('naive-ui')['NModal']
-    NPopover: typeof import('naive-ui')['NPopover']
-    NScrollbar: typeof import('naive-ui')['NScrollbar']
-    NSelect: typeof import('naive-ui')['NSelect']
-    NSlider: typeof import('naive-ui')['NSlider']
-    NSpin: typeof import('naive-ui')['NSpin']
-    NSwitch: typeof import('naive-ui')['NSwitch']
-    NTag: typeof import('naive-ui')['NTag']
-    NTooltip: typeof import('naive-ui')['NTooltip']
-    NVirtualList: typeof import('naive-ui')['NVirtualList']
-    RouterLink: typeof import('vue-router')['RouterLink']
-    RouterView: typeof import('vue-router')['RouterView']
-  }
-}

src/renderer/components/Coffee.vue

@@ -7,7 +7,7 @@
             quaternary
             class="inline-flex items-center gap-2 px-4 py-2 transition-all duration-300 hover:-translate-y-0.5"
           >
-            请我喝咖啡
+            {{ t('comp.coffee.title') }}
           </n-button>
         </slot>
       </template>
@@ -17,20 +17,24 @@
           <div class="flex flex-col items-center gap-2">
             <n-image
               :src="alipayQR"
-              alt="支付宝收款码"
+              :alt="t('comp.coffee.alipayQR')"
               class="w-32 h-32 rounded-lg cursor-none"
               preview-disabled
             />
-            <span class="text-sm text-gray-700 dark:text-gray-200">支付宝</span>
+            <span class="text-sm text-gray-700 dark:text-gray-200">{{
+              t('comp.coffee.alipay')
+            }}</span>
           </div>
           <div class="flex flex-col items-center gap-2">
             <n-image
               :src="wechatQR"
-              alt="微信收款码"
+              :alt="t('comp.coffee.wechatQR')"
               class="w-32 h-32 rounded-lg cursor-none"
               preview-disabled
             />
-            <span class="text-sm text-gray-700 dark:text-gray-200">微信支付</span>
+            <span class="text-sm text-gray-700 dark:text-gray-200">{{
+              t('comp.coffee.wechat')
+            }}</span>
           </div>
         </div>
 
@@ -39,7 +43,16 @@
             class="text-sm text-gray-700 dark:text-gray-200 text-center cursor-pointer hover:text-green-500"
             @click="copyQQ"
           >
-            QQ群：789288579
+            {{ t('comp.coffee.qqGroup') }}
+          </p>
+        </div>
+        <div class="mt-4">
+          <!-- 赞赏列表地址 -->
+          <p
+            class="text-sm text-green-600 dark:text-gray-200 text-center cursor-pointer hover:text-green-500"
+            @click="toDonateList"
+          >
+            {{ t('comp.coffee.donateList') }}
           </p>
         </div>
       </div>
@@ -48,13 +61,22 @@
 </template>
 
 <script setup>
-import { NButton, NImage, NPopover } from 'naive-ui';
+import { NButton, NImage, NPopover, useMessage } from 'naive-ui';
+import { useI18n } from 'vue-i18n';
+
 import alipay from '@/assets/alipay.png';
 import wechat from '@/assets/wechat.png';
+
+const { t } = useI18n();
+
 const message = useMessage();
 const copyQQ = () => {
-  navigator.clipboard.writeText('789288579');
-  message.success('已复制到剪贴板');
+  navigator.clipboard.writeText('algermusic');
+  message.success(t('common.copySuccess'));
+};
+
+const toDonateList = () => {
+  window.open('http://donate.alger.fun/download', '_blank');
 };
 
 defineProps({

src/renderer/components/EQControl.vue

@@ -0,0 +1,359 @@
+<template>
+  <div class="eq-control">
+    <div class="eq-header">
+      <h3>{{ t('player.eq.title') }}
+        <n-tag type="warning" size="small" round v-if="!isElectron">
+          桌面版可用，网页端不支持
+        </n-tag>
+      </h3>
+      <div class="eq-controls">
+        <n-switch v-model:value="isEnabled" @update:value="toggleEQ">
+          <template #checked>{{ t('player.eq.on') }}</template>
+          <template #unchecked>{{ t('player.eq.off') }}</template>
+        </n-switch>
+      </div>
+    </div>
+
+    <div class="eq-presets">
+      <n-scrollbar x-scrollable>
+        <n-space :size="6" :wrap="false">
+          <n-tag
+            v-for="preset in presetOptions"
+            :key="preset.value"
+            :type="currentPreset === preset.value ? 'success' : 'default'"
+            :bordered="false"
+            size="medium"
+            round
+            clickable
+            @click="applyPreset(preset.value)"
+          >
+            {{ preset.label }}
+          </n-tag>
+        </n-space>
+      </n-scrollbar>
+    </div>
+
+    <div class="eq-sliders">
+      <div v-for="freq in frequencies" :key="freq" class="eq-slider">
+        <div class="freq-label">{{ formatFreq(freq) }}</div>
+        <n-slider
+          v-model:value="eqValues[freq.toString()]"
+          :min="-12"
+          :max="12"
+          :step="0.1"
+          vertical
+          :disabled="!isEnabled"
+          @update:value="updateEQ(freq.toString(), $event)"
+        />
+        <div class="gain-value">{{ eqValues[freq.toString()] }}dB</div>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script lang="ts" setup>
+import { onMounted, ref } from 'vue';
+import { useI18n } from 'vue-i18n';
+
+import { audioService } from '@/services/audioService';
+import { isElectron } from '@/utils';
+
+const { t } = useI18n();
+
+const frequencies = [31, 62, 125, 250, 500, 1000, 2000, 4000, 8000, 16000];
+const eqValues = ref<{ [key: string]: number }>({});
+const isEnabled = ref(audioService.isEQEnabled());
+const currentPreset = ref(audioService.getCurrentPreset() || 'flat');
+
+// 预设配置
+const presets = {
+  flat: {
+    label: t('player.eq.presets.flat'),
+    values: Object.fromEntries(frequencies.map((f) => [f, 0]))
+  },
+  pop: {
+    label: t('player.eq.presets.pop'),
+    values: {
+      31: -1.5,
+      62: 3.5,
+      125: 5.5,
+      250: 3.5,
+      500: -0.5,
+      1000: -1.5,
+      2000: 1.5,
+      4000: 2.5,
+      8000: 2.5,
+      16000: 2.5
+    }
+  },
+  rock: {
+    label: t('player.eq.presets.rock'),
+    values: {
+      31: 4.5,
+      62: 3.5,
+      125: 2,
+      250: 0.5,
+      500: -0.5,
+      1000: -1,
+      2000: 0.5,
+      4000: 2,
+      8000: 2.5,
+      16000: 3.5
+    }
+  },
+  classical: {
+    label: t('player.eq.presets.classical'),
+    values: {
+      31: 3.5,
+      62: 3,
+      125: 2.5,
+      250: 1.5,
+      500: -0.5,
+      1000: -1.5,
+      2000: -1.5,
+      4000: 0.5,
+      8000: 2,
+      16000: 3
+    }
+  },
+  jazz: {
+    label: t('player.eq.presets.jazz'),
+    values: {
+      31: 3,
+      62: 2,
+      125: 1.5,
+      250: 2,
+      500: -1,
+      1000: -1.5,
+      2000: -0.5,
+      4000: 1,
+      8000: 2.5,
+      16000: 3
+    }
+  },
+  hiphop: {
+    label: t('player.eq.presets.hiphop'),
+    values: {
+      31: 5,
+      62: 4.5,
+      125: 3,
+      250: 1.5,
+      500: -0.5,
+      1000: -1,
+      2000: 0.5,
+      4000: 1.5,
+      8000: 2,
+      16000: 2.5
+    }
+  },
+  vocal: {
+    label: t('player.eq.presets.vocal'),
+    values: {
+      31: -2,
+      62: -1.5,
+      125: -1,
+      250: 0.5,
+      500: 2,
+      1000: 3.5,
+      2000: 3,
+      4000: 1.5,
+      8000: 0.5,
+      16000: 0
+    }
+  },
+  dance: {
+    label: t('player.eq.presets.dance'),
+    values: {
+      31: 4,
+      62: 3.5,
+      125: 2.5,
+      250: 1,
+      500: 0,
+      1000: -0.5,
+      2000: 1.5,
+      4000: 2.5,
+      8000: 3,
+      16000: 2.5
+    }
+  },
+  acoustic: {
+    label: t('player.eq.presets.acoustic'),
+    values: {
+      31: 2,
+      62: 1.5,
+      125: 1,
+      250: 1.5,
+      500: 2,
+      1000: 1.5,
+      2000: 2,
+      4000: 2.5,
+      8000: 2,
+      16000: 1.5
+    }
+  }
+};
+
+const presetOptions = Object.entries(presets).map(([value, preset]) => ({
+  label: preset.label,
+  value
+}));
+
+const toggleEQ = (enabled: boolean) => {
+  audioService.setEQEnabled(enabled);
+};
+
+const applyPreset = (presetName: string) => {
+  currentPreset.value = presetName;
+  audioService.setCurrentPreset(presetName);
+  const preset = presets[presetName as keyof typeof presets];
+  if (preset) {
+    Object.entries(preset.values).forEach(([freq, gain]) => {
+      updateEQ(freq, gain);
+    });
+  }
+};
+
+onMounted(() => {
+  // 恢复 EQ 设置
+  const settings = audioService.getAllEQSettings();
+  eqValues.value = settings;
+
+  // 如果有保存的预设，应用该预设
+  const savedPreset = audioService.getCurrentPreset();
+  if (savedPreset && presets[savedPreset as keyof typeof presets]) {
+    currentPreset.value = savedPreset;
+  }
+});
+
+const updateEQ = (frequency: string, gain: number) => {
+  audioService.setEQFrequencyGain(frequency, gain);
+  eqValues.value = {
+    ...eqValues.value,
+    [frequency]: gain
+  };
+
+  // 检查当前值是否与任何预设匹配
+  const currentValues = eqValues.value;
+  let matchedPreset: string | null = null;
+
+  // 检查是否与任何预设完全匹配
+  Object.entries(presets).forEach(([presetName, preset]) => {
+    const isMatch = Object.entries(preset.values).every(
+      ([freq, value]) => Math.abs(currentValues[freq] - value) < 0.1
+    );
+    if (isMatch) {
+      matchedPreset = presetName;
+    }
+  });
+
+  // 更新当前预设状态
+  if (matchedPreset !== null) {
+    currentPreset.value = matchedPreset;
+    audioService.setCurrentPreset(matchedPreset);
+  } else if (currentPreset.value !== 'custom') {
+    // 如果与任何预设都不匹配，将状态设置为自定义
+    currentPreset.value = 'custom';
+    audioService.setCurrentPreset('custom');
+  }
+};
+
+const formatFreq = (freq: number) => {
+  if (freq >= 1000) {
+    return `${freq / 1000}kHz`;
+  }
+  return `${freq}Hz`;
+};
+</script>
+
+<style lang="scss" scoped>
+.eq-control {
+  @apply p-6 rounded-lg;
+  @apply bg-light dark:bg-dark;
+  width: 100%;
+  max-width: 700px;
+
+  .eq-header {
+    @apply flex justify-between items-center mb-4;
+
+    h3 {
+      @apply text-xl font-semibold;
+      @apply text-gray-800 dark:text-gray-200;
+    }
+  }
+
+  .eq-presets {
+    @apply mb-2 relative;
+    height: 40px;
+
+    :deep(.n-scrollbar) {
+      @apply -mx-2 px-2;
+    }
+
+    :deep(.n-tag) {
+      @apply cursor-pointer transition-all duration-200;
+      text-align: center;
+
+      &:hover {
+        transform: translateY(-2px);
+      }
+    }
+
+    :deep(.n-space) {
+      flex-wrap: nowrap;
+      padding: 4px 0;
+    }
+  }
+
+  .eq-sliders {
+    @apply flex justify-between items-end;
+    @apply bg-gray-50 dark:bg-gray-800 gap-1;
+    @apply rounded-lg p-2;
+    height: 300px;
+
+    .eq-slider {
+      @apply flex flex-col items-center;
+      width: 45px;
+      height: 100%;
+
+      .n-slider {
+        flex: 1;
+        margin: 12px 0;
+        min-height: 180px;
+      }
+
+      .freq-label {
+        @apply text-xs font-medium text-center;
+        @apply text-gray-600 dark:text-gray-400;
+        white-space: nowrap;
+        margin: 8px 0;
+        height: 20px;
+      }
+
+      .gain-value {
+        @apply text-xs font-medium text-center;
+        @apply text-gray-600 dark:text-gray-400;
+        white-space: nowrap;
+        margin: 4px 0;
+        height: 16px;
+      }
+    }
+  }
+}
+
+:deep(.n-slider) {
+  --n-rail-height: 4px;
+  --n-rail-color: theme('colors.gray.200');
+  --n-rail-color-hover: theme('colors.gray.300');
+  --n-fill-color: theme('colors.green.500');
+  --n-fill-color-hover: theme('colors.green.600');
+  --n-handle-color: theme('colors.green.500');
+  --n-handle-box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+
+  .n-slider-handle {
+    @apply transition-all duration-200;
+    &:hover {
+      transform: scale(1.2);
+    }
+  }
+}
+</style>

src/renderer/components/LanguageSwitcher.vue

@@ -0,0 +1,27 @@
+<script setup lang="ts">
+import { computed } from 'vue';
+import { useI18n } from 'vue-i18n';
+
+import { useSettingsStore } from '@/store/modules/settings';
+
+const settingsStore = useSettingsStore();
+const { locale } = useI18n();
+
+const languages = [
+  { label: '简体中文', value: 'zh-CN' },
+  { label: 'English', value: 'en-US' }
+];
+
+console.log('locale', locale);
+// 使用计算属性来获取当前语言
+const currentLanguage = computed({
+  get: () => locale.value,
+  set: (value) => {
+    settingsStore.setLanguage(value);
+  }
+});
+</script>
+
+<template>
+  <n-select v-model:value="currentLanguage" :options="languages" size="small" />
+</template>