发布0.8.2版本

.github/ISSUE_TEMPLATE/----.md

@@ -0,0 +1,17 @@
+---
+name: 功能请求
+about: 为这个项目提出一个想法
+title: 例如：添加xxx功能、优化xxx功能
+labels: ''
+assignees: ''
+
+---
+
+**描述您想要的解决方案**
+简洁明了地描述您要发生的事情。
+
+**描述您考虑过的替代方案**
+对您考虑过的所有替代解决方案或功能的简洁明了的描述。
+
+**其他内容**
+在此处添加有关功能请求的任何其他上下文或屏幕截图。

.github/ISSUE_TEMPLATE/--bug.md

@@ -0,0 +1,31 @@
+---
+name: 报告Bug
+about: 创建报告以帮助我们改进
+title: 例如：音乐无法播放
+labels: ''
+assignees: ''
+
+---
+
+**描述错误**
+清楚简洁地说明错误是什么。
+
+**重现**
+重现行为的步骤：
+1.转到“ ...”
+2.点击“ ....”
+3.向下滚动到“ ....”
+4.看到错误
+
+**预期行为**
+对您期望发生的事情的简洁明了的描述。
+
+**截图**
+如果适用，请添加屏幕截图以帮助解释您的问题。
+
+**环境：**
+  -操作系统及版本：[例如：Windows 10 64位 18362.156]
+  -软件安装包及版本：[例如：Windows 64位绿色版 1.0.0]
+
+**其他内容**
+在此处添加有关该问题的任何其他上下文。

CHANGELOG.md

@@ -6,6 +6,171 @@ Project versioning adheres to [Semantic Versioning](http://semver.org/).
 Commit convention is based on [Conventional Commits](http://conventionalcommits.org).
 Change log format is based on [Keep a Changelog](http://keepachangelog.com/).
 
+## [0.8.2](https://github.com/lyswhut/lx-music-desktop/compare/v0.8.1...v0.8.2) - 2019-10-20
+
+#### 修复
+
+- 兼容旧版酷我源搜索列表过滤128k音质的bug（注：0.8.1版本仅修复了酷我源的歌曲过滤问题，该修复仅对以后添加的歌曲有效，如果是之前添加的歌曲仍会出现这个问题，现修复对之前旧列表数据的兼容处理）
+
+## [0.8.1](https://github.com/lyswhut/lx-music-desktop/compare/v0.8.0...v0.8.1) - 2019-10-20
+
+#### 修复
+
+- 修复酷我源搜索歌曲结果未添加128k音质导致播放128k音质时显示“该歌曲没有可播放的音频”的问题
+
+## [0.8.0](https://github.com/lyswhut/lx-music-desktop/compare/v0.7.0...v0.8.0) - 2019-10-19
+
+#### 新增
+
+- 新增网易云源歌曲搜索
+- 新增网易云源歌单
+- 新增各平台通过输入歌单链接或歌单ID打开歌单详情列表，目前只适配了**网页版歌单链接**，其他方式的歌单链接可能无法解析，但你可想办法获取歌单ID后输入打开。注：各平台歌单ID均为纯数字，若遇到链接里存在歌单ID但无法解析的歌单链接，可以到GitHub提交issue或发送邮件或加群830125506反馈！
+- 新增音量调整滑动功能，现在支持鼠标左右拖动调整音量了
+
+#### 优化
+
+- 优化搜索框搜索体验
+- 优化音量条交互视觉效果
+- 缓存歌单详情列表数据
+
+#### 修复
+
+- 修复QQ源歌单无法翻页Bug
+- 修复默认列表没有创建时无法显示收藏列表的Bug
+- 修复网易云128k直接试听
+- 修复歌曲音质不存在时仍然播放或下载的Bug
+- 修复调整音量时，调整的位置与鼠标点击的位置不一致的问题
+
+## [0.7.0](https://github.com/lyswhut/lx-music-desktop/compare/v0.6.2...v0.7.0) - 2019-10-07
+
+#### 新增
+
+- 新增“我的收藏”本地播放列表
+- 新增缓存清理功能，可到**设置-其他**查看与清理软件缓存
+- 新增QQ音乐源搜索
+- 新增咪咕源搜索
+- 新增咪咕源歌单
+- 新增咪咕源排行榜
+- 新增我的音乐列表歌曲源显示，默认关闭，可到**设置-列表设置**开启
+
+#### 优化
+
+- 优化选择框动画效果
+- 尝试优化选我的音乐列表内容很多时多选的卡顿问题
+
+#### 修复
+
+- 修复列表延迟显示的Bug
+- 修复QQ音源128k音质试听
+
+## [0.6.2](https://github.com/lyswhut/lx-music-desktop/compare/v0.6.1...v0.6.2) - 2019-10-01
+
+祝贺祖国成立70周年~！
+
+#### 新增
+
+- 新增QQ音乐源歌单
+
+#### 修复
+
+- 修正火影皮肤名字
+- 修复当试听列表为空时，无法切到其他界面的Bug
+- 修复百度源搜索结果为空时的接口处理Bug
+- 恢复**酷狗**其他音质播放
+
+## [0.6.1](https://github.com/lyswhut/lx-music-desktop/compare/v0.6.0...v0.6.1) - 2019-09-28
+
+### 新增
+
+- 新增试听列表**滚动条位置恢复**设置（可自动恢复到上次离开时的列表滚动位置），本功能默认开启，若不需要可到设置-列表设置将其关闭
+- 新增 **《海贼王》** 皮肤，喜欢个性化的可以试试~
+
+### 优化
+
+- 新增DNS解析缓存，加快请求速度
+- 优化代码逻辑，减少软件对系统资源的占用
+- 优化新版本信息检测，尽量减少弹出版本获取失败弹窗弹出的概率
+- 优化下拉列表动画效果
+
+### 修复
+
+- 修复请求超时的逻辑处理Bug，尝试修复请求无法取消导致的正在播放的歌曲与界面显示的信息不一致的问题
+- 修复其他一些小Bug
+
+### 移除
+
+- 移除 `192k` 音质
+- 移除酷我音源 `ape` 音质，无损推荐 `flac` 格式
+
+## [0.6.0](https://github.com/lyswhut/lx-music-desktop/compare/v0.5.5...v0.6.0) - 2019-09-21
+
+### 新增
+
+- 新增音乐**聚合搜索**，目前支持酷我、酷狗、百度源搜索
+- 新增代理功能
+
+### 优化
+
+- 优化从《梦里嫦娥》皮肤切换到其他皮肤时侧栏动画的切换效果
+
+### 修复
+
+- 修复试听列表没有歌曲时会显示列表加载中的Bug
+- 修复切换歌单列表详情时的UI Bug
+
+## [0.5.5](https://github.com/lyswhut/lx-music-desktop/compare/v0.5.4...v0.5.5) - 2019-09-13
+
+### 新增
+
+- 月是故乡明，祝大家中秋快乐🥮~~新增个性皮肤 **《月里嫦娥》**，时间仓促，皮肤还不是很完善，可以试试喜不喜欢~😉
+- 新增 MAC 版本退出快捷键支持
+- 新增点击播放器中的歌曲标题可以复制标题的功能（遇到好听的歌曲方便分享）
+
+### 修复
+
+- 修复 MAC 系统下软件关闭时再次从 dock 打开时报错的Bug
+- 修复下载的歌曲文件名中包含命名规则不允许的符号时下载失败的问题（若歌曲名包含这些符号会自动将其移除）
+- 修复 MAC 版本不能复制粘贴的问题
+
+## [0.5.4](https://github.com/lyswhut/lx-music-desktop/compare/v0.5.3...v0.5.4) - 2019-09-09
+
+### 移除
+
+- 下载的FLAC文件在修改歌曲信息后，软件无法播放，但使用本地播放器可以播放
+- 为了稳妥起见，暂时移除FLAC格式的meta信息修改
+- MP3格式无此问题
+
+## [0.5.3](https://github.com/lyswhut/lx-music-desktop/compare/v0.5.2...v0.5.3) - 2019-09-09
+
+### 优化
+
+- 更新所有依赖包到最新
+
+### 修复
+
+- 修复试听酷狗源的音乐仍然获取320k音质导致获取失败的Bug
+
+## [0.5.2](https://github.com/lyswhut/lx-music-desktop/compare/v0.5.1...v0.5.2) - 2019-09-09
+
+### 新增
+
+- 新增强迫症设置-离开搜索界面时是否清空搜索框
+- 设置-关于板块新增常见问题链接
+- 歌单左上角的分类按钮添加一个**向下图标**，方便识别该按钮为下拉框（该按钮可选择歌单类型，请自行尝试）
+
+### 优化
+
+- 略微优化最小化按钮字符
+- 优化试听列表的加载体验，当歌曲数过多时列表将延迟加载
+
+### 修复
+
+- 修复下载管理的一些Bug
+
+### 移除
+
+- 因接口失效，移除网易云音源，酷狗音源仅支持播放128k音质
+
 ## [0.5.1](https://github.com/lyswhut/lx-music-desktop/compare/v0.5.0...v0.5.1) - 2019-09-05
 
 ### 新增

FAQ.md

@@ -0,0 +1,60 @@
+# lx-music-desktop 常见问题
+
+在阅读本常见问题后，仍然无法解决你的问题，请提交issue或者加企鹅群`830125506`反馈，反馈时请**注明**已阅读常见问题！
+
+## 软件为什么没有桌面歌词与自定义列表功能
+
+洛雪音乐的最初定位不是作为播放器开发的，它主要用于**查找歌曲**，软件的播放功能仅用于试听，不建议用作为常用播放器使用，因此无桌面、界面歌词，不可自定义列表。
+
+## 歌曲无法试听与下载
+
+该问题解决顺序如下：
+
+1. 尝试更新到最新版本
+2. 尝试切换其他歌曲（或直接搜索该歌曲），若全部歌曲都无法试听与下载则进行下一步
+3. 尝试到设置-接口来源切换到其他接口
+4. 尝试切换网络，比如用手机开热点（目前存在某些网络无法访问接口服务器的情况）
+5. 若还不行请到这个链接查看详情：<https://github.com/lyswhut/lx-music-desktop/issues/5>
+6. 若没有在第5条链接中的第一条评论中看到接口无法使用的说明，则应该是你网络无法访问接口服务器的问题，如果接口有问题我会在那里说明。
+
+想要知道是不是自己网络的问题可以看看`https://ts.tempmusic.tk`能不能在浏览器打开，浏览器显示404是正常的，如果不是404那就证明所在网络无法访问接口服务器。
+若网页无法打开或打来不是404，则应该是DNS的问题，可以尝试以下办法：
+
+1. 改成自动获取试试
+2. 手动把DNS改一下，不要用360的DNS，可以把DNS改成`114.114.114.114`、`8.8.8.8`
+3. 软件设置里面的代理不要勾起来
+
+## 软件安装包说明
+
+软件发布页及网盘中有多个类型的安装文件，以下是对这些类型文件的说明：
+
+文件名带 `win_` 的是在Windows系统上运行的版本，<br>
+其中安装版（Setup）可自动更新软件，<br>
+绿色版（green）为免安装版，自动更新功能不可用；
+
+以 **`.dmg`** 结尾的文件为 MAC 版本；
+
+以 **`.AppImage`**、**`.deb`** 结尾的为 Linux 版本。
+
+带有`x64`的为64位的系统版本，带`x86`的为32位的系统版本；若两个都带有的则为集合版，安装时会自动根据系统位数选择对应的版本安装。
+
+## 软件更新
+
+软件启动时若发现新版本时会自动从本仓库下载安装包，下载完毕会弹窗提示更新。<br>
+若下载未完成时软件被关闭，下次启动软件会再次自动下载。<br>
+若还是**更新失败**，可能是无法访问GitHub导致的，这时需要手动更新，即下载最新安装包直接覆盖安装即可。<br>
+注意：**绿色版**的软件自动更新功能**不可用**，建议使用安装版！！<br>
+注意：**Mac版**、**Linux deb**版不支持自动更新！
+
+## Windows 7 下界面异常
+
+当 win7 没有开启**透明效果**时界面将会显示异常，开启方法请自行百度。<br>
+对于一些开启透明效果后仍然无法正常显示界面的系统，我也不知道是什么原因导致的，只能说正常的系统是没有这个问题的，如果你知道原因导致的欢迎反馈！
+
+## 安装版安装失败，提示应用未安装
+
+对于部分电脑出现安装失败的问题我也不懂什么原因，，可以尝试清理下安装文件，或者重启电脑试试。
+
+## 缺少`xxx.dll`
+
+这个是电脑缺少某些dll导致的，正常的系统是没有这个问题的，解决办法需自行百度弹出的错误信息看下别人是怎么解决的。

README.md

@@ -44,24 +44,10 @@
 - Mac OS
 - Linux
 
-注意：win7需要开启**透明效果**软件才可使用
-
 软件变化请查看：[更新日志](https://github.com/lyswhut/lx-music-desktop/blob/master/CHANGELOG.md)<br>
 软件下载请转到：[发布页面](https://github.com/lyswhut/lx-music-desktop/releases)<br>
-或者到网盘下载（网盘内有MAC、windows版）：`https://www.lanzous.com/b906260/` 密码：`glqw`
-
-#### 关于软件更新
-
-软件启动时若发现新版本时会自动从本仓库下载安装包，下载完毕会弹窗提示更新。<br>
-若下载未完成时软件被关闭，下次启动软件会再次自动下载。<br>
-目前暂未添加跳过更新某个版本的功能。<br>
-注意：**绿色版**的软件更新功能**不可用**，为了能及时地获取更新，建议使用安装版！！<br>
-注意：**Mac版**、**Linux deb**版不支持自动更新！
-
-#### TODO
-
-- [ ] 新增拉取各大平台歌单
-- [ ] 新增聚合搜索
+或者到网盘下载（网盘内有MAC、windows版）：`https://www.lanzous.com/b906260/` 密码：`glqw`<br>
+使用常见问题请转至：[常见问题](https://github.com/lyswhut/lx-music-desktop#常见问题)
 
 ### 源码使用方法
 
@@ -83,6 +69,10 @@ npm run pack
 
 <p><a href="https://github.com/lyswhut/lx-music-desktop"><img width="100%" src="https://github.com/lyswhut/lx-music-desktop/blob/master/doc/images/app.png" alt="lx-music UI"></a></p>
 
+### 常见问题
+
+常见问题已移至：<https://github.com/lyswhut/lx-music-desktop/blob/master/FAQ.md>
+
 ### 致谢
 
 感谢 [@messoer](https://github.com/messoer) 曾经提供的部分音乐API！
@@ -91,7 +81,8 @@ npm run pack
 
 本项目**不开发或者破解直接获取音频数据**的功能，所有音频数据均来自**第三方接口**！<br>
 本软件仅用于**测试 `electron 6.x` 在各种系统上的兼容性**及用于**对比各大音乐平台歌单、排行榜等数据列表的差异性**，使用本软件产生的**任何涉及版权相关的数据**请于**24小时内删除**。<br>
-使用本软件所造成的的后果由使用者承担！
+本软件仅用于学习交流使用，禁止用于商业用途，使用本软件所造成的的后果由使用者承担！<br>
+若对此有疑问请 mail to: lyswhut@qq.com
 
 ### 许可证
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "lx-music-desktop",
-  "version": "0.5.1",
+  "version": "0.8.2",
   "description": "一个免费的音乐下载助手",
   "main": "./dist/electron/main.js",
   "productName": "lx-music-desktop",
@@ -57,7 +57,7 @@
   "build": {
     "appId": "cn.toside.music.desktop",
     "directories": {
-      "output": "build"
+      "output": "./build"
     },
     "files": [
       "dist/electron/**/*"
@@ -134,43 +134,43 @@
   },
   "homepage": "https://github.com/lyswhut/lx-music-desktop#readme",
   "devDependencies": {
-    "@babel/core": "^7.5.5",
+    "@babel/core": "^7.6.4",
     "@babel/plugin-syntax-dynamic-import": "^7.2.0",
-    "@babel/polyfill": "^7.4.4",
-    "@babel/preset-env": "^7.5.5",
-    "autoprefixer": "^9.6.1",
-    "babel-eslint": "^10.0.2",
+    "@babel/polyfill": "^7.6.0",
+    "@babel/preset-env": "^7.6.3",
+    "autoprefixer": "^9.6.5",
+    "babel-eslint": "^10.0.3",
     "babel-loader": "^8.0.6",
     "babel-minify-webpack-plugin": "^0.3.1",
-    "babel-preset-minify": "^0.5.0",
-    "cfonts": "^2.4.4",
+    "babel-preset-minify": "^0.5.1",
+    "cfonts": "^2.4.5",
     "chalk": "^2.4.2",
     "changelog-parser": "^2.8.0",
     "copy-webpack-plugin": "^5.0.4",
-    "core-js": "^3.2.1",
-    "cos-nodejs-sdk-v5": "^2.5.11",
-    "cross-env": "^5.2.0",
+    "core-js": "^3.3.2",
+    "cos-nodejs-sdk-v5": "^2.5.12",
+    "cross-env": "^6.0.3",
     "css-loader": "^3.2.0",
-    "del": "^3.0.0",
-    "electron": "^6.0.2",
+    "del": "^5.1.0",
+    "electron": "^6.0.12",
     "electron-builder": "^21.2.0",
     "electron-debug": "^3.0.1",
     "electron-devtools-installer": "^2.2.4",
-    "eslint": "^6.1.0",
-    "eslint-config-standard": "^13.0.1",
+    "eslint": "^6.5.1",
+    "eslint-config-standard": "^14.1.0",
     "eslint-formatter-friendly": "^7.0.0",
-    "eslint-loader": "^2.2.1",
+    "eslint-loader": "^3.0.2",
     "eslint-plugin-html": "^6.0.0",
     "eslint-plugin-import": "^2.18.2",
-    "eslint-plugin-node": "^9.1.0",
+    "eslint-plugin-node": "^10.0.0",
     "eslint-plugin-promise": "^4.2.1",
-    "eslint-plugin-standard": "^4.0.0",
+    "eslint-plugin-standard": "^4.0.1",
     "file-loader": "^4.2.0",
     "friendly-errors-webpack-plugin": "^1.7.0",
     "html-webpack-plugin": "^3.2.0",
-    "less": "^3.9.0",
+    "less": "^3.10.3",
     "less-loader": "^5.0.0",
-    "markdown-it": "^9.1.0",
+    "markdown-it": "^10.0.0",
     "mini-css-extract-plugin": "^0.8.0",
     "multispinner": "^0.2.1",
     "optimize-css-assets-webpack-plugin": "^5.0.3",
@@ -180,34 +180,35 @@
     "pug-plain-loader": "^1.0.0",
     "raw-loader": "^3.1.0",
     "rimraf": "^3.0.0",
-    "stylus": "^0.54.5",
+    "stylus": "^0.54.7",
     "stylus-loader": "^3.0.2",
-    "terser-webpack-plugin": "^1.4.1",
-    "url-loader": "^2.1.0",
+    "terser-webpack-plugin": "^2.1.3",
+    "url-loader": "^2.2.0",
     "vue-loader": "^15.7.1",
     "vue-style-loader": "^4.1.2",
     "vue-template-compiler": "^2.6.10",
-    "webpack": "^4.39.2",
-    "webpack-cli": "^3.3.6",
-    "webpack-dev-server": "^3.8.0",
+    "webpack": "^4.41.2",
+    "webpack-cli": "^3.3.9",
+    "webpack-dev-server": "^3.8.2",
     "webpack-hot-middleware": "^2.25.0",
-    "webpack-merge": "^4.2.1"
+    "webpack-merge": "^4.2.2"
   },
   "dependencies": {
     "axios": "^0.19.0",
     "crypto-js": "^3.1.9-1",
-    "electron-log": "^3.0.7",
-    "electron-store": "^4.0.0",
+    "dnscache": "^1.0.2",
+    "electron-log": "^3.0.8",
+    "electron-store": "^5.0.0",
     "electron-updater": "^4.1.2",
     "flac-metadata": "^0.1.1",
     "js-htmlencode": "^0.3.0",
-    "lrc-file-parser": "^0.1.12",
+    "lrc-file-parser": "^0.1.14",
     "node-downloader-helper": "^1.0.10",
     "node-id3": "^0.1.11",
     "request": "^2.88.0",
     "vue": "^2.6.10",
     "vue-electron": "^1.0.6",
-    "vue-router": "^3.1.2",
+    "vue-router": "^3.1.3",
     "vuex": "^3.1.1",
     "vuex-electron": "^1.0.3",
     "vuex-router-sync": "^5.0.0"

publish/changeLog.md

@@ -1,9 +1,3 @@
-### 新增
+#### 修复
 
-- 新增右上角最小化/关闭按钮鼠标滑过符号
-- 新增下载列表定位文件按钮
-
-### 修复
-
-- 修复百度源歌单全部分类无法加载的问题
-- 修复更新弹窗无法弹出的问题
+- 兼容旧版酷我源搜索列表过滤128k音质的bug（注：0.8.1版本仅修复了酷我源的歌曲过滤问题，该修复仅对以后添加的歌曲有效，如果是之前添加的歌曲仍会出现这个问题，现修复对之前旧列表数据的兼容处理）

publish/version.json

@@ -1,7 +1,51 @@
 {
-  "version": "0.5.1",
-  "desc": "<h3>新增</h3>\n<ul>\n<li>新增右上角最小化/关闭按钮鼠标滑过符号</li>\n<li>新增下载列表定位文件按钮</li>\n</ul>\n<h3>修复</h3>\n<ul>\n<li>修复百度源歌单全部分类无法加载的问题</li>\n<li>修复更新弹窗无法弹出的问题</li>\n</ul>\n",
+  "version": "0.8.2",
+  "desc": "<h4>修复</h4>\n<ul>\n<li>兼容旧版酷我源搜索列表过滤128k音质的bug（注：0.8.1版本仅修复了酷我源的歌曲过滤问题，该修复仅对以后添加的歌曲有效，如果是之前添加的歌曲仍会出现这个问题，现修复对之前旧列表数据的兼容处理）</li>\n</ul>\n",
   "history": [
+    {
+      "version": "0.8.1",
+      "desc": "<h4>修复</h4>\n<ul>\n<li>修复酷我源搜索歌曲结果未添加128k音质导致播放128k音质时显示“该歌曲没有可播放的音频”的问题</li>\n</ul>\n"
+    },
+    {
+      "version": "0.8.0",
+      "desc": "<h4>新增</h4>\n<ul>\n<li>新增网易云源歌曲搜索</li>\n<li>新增网易云源歌单</li>\n<li>新增各平台通过输入歌单链接或歌单ID打开歌单详情列表，目前只适配了<strong>网页版歌单链接</strong>，其他方式的歌单链接可能无法解析，但你可想办法获取歌单ID后输入打开。注：各平台歌单ID均为纯数字，若遇到链接里存在歌单ID但无法解析的歌单链接，可以到GitHub提交issue或发送邮件或加群830125506反馈！</li>\n<li>新增音量调整滑动功能，现在支持鼠标左右拖动调整音量了</li>\n</ul>\n<h4>优化</h4>\n<ul>\n<li>优化搜索框搜索体验</li>\n<li>优化音量条交互视觉效果</li>\n<li>缓存歌单详情列表数据</li>\n</ul>\n<h4>修复</h4>\n<ul>\n<li>修复QQ源歌单无法翻页Bug</li>\n<li>修复默认列表没有创建时无法显示收藏列表的Bug</li>\n<li>修复网易云128k直接试听</li>\n<li>修复歌曲音质不存在时仍然播放或下载的Bug</li>\n<li>修复调整音量时，调整的位置与鼠标点击的位置不一致的问题</li>\n</ul>\n"
+    },
+    {
+      "version": "0.7.0",
+      "desc": "<h4>新增</h4>\n<ul>\n<li>新增“我的收藏”本地播放列表</li>\n<li>新增缓存清理功能，可到<strong>设置-其他</strong>查看与清理软件缓存</li>\n<li>新增QQ音乐源搜索</li>\n<li>新增咪咕源搜索</li>\n<li>新增咪咕源歌单</li>\n<li>新增咪咕源排行榜</li>\n<li>新增我的音乐列表歌曲源显示，默认关闭，可到<strong>设置-列表设置</strong>开启</li>\n</ul>\n<h4>优化</h4>\n<ul>\n<li>优化选择框动画效果</li>\n<li>尝试优化选我的音乐列表内容很多时多选的卡顿问题</li>\n</ul>\n<h4>修复</h4>\n<ul>\n<li>修复列表延迟显示的Bug</li>\n<li>修复QQ音源128k音质试听</li>\n</ul>\n"
+    },
+    {
+      "version": "0.6.2",
+      "desc": "<p>祝贺祖国成立70周年~！</p>\n<h4>新增</h4>\n<ul>\n<li>新增QQ音乐源歌单</li>\n</ul>\n<h4>修复</h4>\n<ul>\n<li>修正火影皮肤名字</li>\n<li>修复当试听列表为空时，无法切到其他界面的Bug</li>\n<li>修复百度源搜索结果为空时的接口处理Bug</li>\n<li>恢复<strong>酷狗</strong>其他音质播放</li>\n</ul>\n"
+    },
+    {
+      "version": "0.6.1",
+      "desc": "<h3>新增</h3>\n<ul>\n<li>新增试听列表<strong>滚动条位置恢复</strong>设置（可自动恢复到上次离开时的列表滚动位置），本功能默认开启，若不需要可到设置-列表设置将其关闭</li>\n<li>新增 <strong>《海贼王》</strong> 皮肤，喜欢个性化的可以试试~</li>\n</ul>\n<h3>优化</h3>\n<ul>\n<li>新增DNS解析缓存，加快请求速度</li>\n<li>优化代码逻辑，减少软件对系统资源的占用</li>\n<li>优化新版本信息检测，尽量减少弹出版本获取失败弹窗弹出的概率</li>\n<li>优化下拉列表动画效果</li>\n</ul>\n<h3>修复</h3>\n<ul>\n<li>修复请求超时的逻辑处理Bug，尝试修复请求无法取消导致的正在播放的歌曲与界面显示的信息不一致的问题</li>\n<li>修复其他一些小Bug</li>\n</ul>\n<h3>移除</h3>\n<ul>\n<li>移除 <code>192k</code> 音质</li>\n<li>移除酷我音源 <code>ape</code> 音质，无损推荐 <code>flac</code> 格式</li>\n</ul>\n"
+    },
+    {
+      "version": "0.6.0",
+      "desc": "<h3>新增</h3>\n<ul>\n<li>新增音乐<strong>聚合搜索</strong>，目前支持酷我、酷狗、百度源搜索</li>\n<li>新增代理功能</li>\n</ul>\n<h3>优化</h3>\n<ul>\n<li>优化从《梦里嫦娥》皮肤切换到其他皮肤时侧栏动画的切换效果</li>\n</ul>\n<h3>修复</h3>\n<ul>\n<li>修复试听列表没有歌曲时会显示列表加载中的Bug</li>\n<li>修复切换歌单列表详情时的UI Bug</li>\n</ul>\n"
+    },
+    {
+      "version": "0.5.5",
+      "desc": "<h3>新增</h3>\n<ul>\n<li>月是故乡明，祝大家中秋快乐🥮~~新增个性皮肤**《月里嫦娥》**，时间仓促，皮肤还不是很完善，可以试试喜不喜欢~😉</li>\n<li>新增 MAC 版本退出快捷键支持</li>\n<li>新增点击播放器中的歌曲标题可以复制标题的功能（遇到好听的歌曲方便分享）</li>\n</ul>\n<h3>修复</h3>\n<ul>\n<li>修复 MAC 系统下软件关闭时再次从 dock 打开时报错的Bug</li>\n<li>修复下载的歌曲文件名中包含命名规则不允许的符号时下载失败的问题（若歌曲名包含这些符号会自动将其移除）</li>\n<li>修复 MAC 版本不能复制粘贴的问题</li>\n</ul>\n"
+    },
+    {
+      "version": "0.5.4",
+      "desc": "<h3>移除</h3>\n<ul>\n<li>下载的FLAC文件在修改歌曲信息后，软件无法播放，但使用本地播放器可以播放</li>\n<li>为了稳妥起见，暂时移除FLAC格式的meta信息修改</li>\n<li>MP3格式无此问题</li>\n</ul>\n"
+    },
+    {
+      "version": "0.5.3",
+      "desc": "<h3>优化</h3>\n<ul>\n<li>更新所有依赖包到最新</li>\n</ul>\n<h3>修复</h3>\n<ul>\n<li>修复试听酷狗源的音乐仍然获取320k音质导致获取失败的Bug</li>\n</ul>\n"
+    },
+    {
+      "version": "0.5.2",
+      "desc": "<h3>新增</h3>\n<ul>\n<li>新增强迫症设置-离开搜索界面时是否清空搜索框</li>\n<li>设置-关于板块新增常见问题链接</li>\n<li>歌单左上角的分类按钮添加一个<strong>向下图标</strong>，方便识别该按钮为下拉框（该按钮可选择歌单类型，请自行尝试）</li>\n</ul>\n<h3>优化</h3>\n<ul>\n<li>略微优化最小化按钮字符</li>\n<li>优化试听列表的加载体验，当歌曲数过多时列表将延迟加载</li>\n</ul>\n<h3>修复</h3>\n<ul>\n<li>修复下载管理的一些Bug</li>\n</ul>\n<h3>移除</h3>\n<ul>\n<li>因接口失效，移除网易云音源，酷狗音源仅支持播放128k音质</li>\n</ul>\n"
+    },
+    {
+      "version": "0.5.1",
+      "desc": "<h3>新增</h3>\n<ul>\n<li>新增右上角最小化/关闭按钮鼠标滑过符号</li>\n<li>新增下载列表定位文件按钮</li>\n</ul>\n<h3>修复</h3>\n<ul>\n<li>修复百度源歌单全部分类无法加载的问题</li>\n<li>修复更新弹窗无法弹出的问题</li>\n</ul>\n"
+    },
     {
       "version": "0.5.0",
       "desc": "<h3>新增</h3>\n<ul>\n<li>新增<strong>封面嵌入</strong>（默认开启，可到设置-下载设置关闭）</li>\n<li>新增<strong>歌词下载</strong>（默认关闭，可到设置-下载设置开启）</li>\n<li>新增单例应用功能（实现软件单开功能，禁止软件多开）</li>\n</ul>\n<h3>优化</h3>\n<ul>\n<li>优化歌单列表动画</li>\n</ul>\n<h3>修复</h3>\n<ul>\n<li>修复歌单无法翻页的问题</li>\n<li>修复在某些情况下，添加下载歌曲导致下载列表崩溃的问题</li>\n<li>修复版本更新弹窗Bug</li>\n<li>修复酷狗歌单推荐歌单出现在其他分类中的Bug</li>\n</ul>\n"

src/common/utils.js

@@ -1,4 +1,8 @@
-export const isLinux = process.platform == 'linux'
-export const isWin = process.platform == 'win32'
-export const isMac = process.platform == 'darwin'
+const log = require('electron-log')
 
+exports.isLinux = process.platform == 'linux'
+exports.isWin = process.platform == 'win32'
+exports.isMac = process.platform == 'darwin'
+
+
+exports.log = log

src/index.pug

@@ -10,6 +10,6 @@ html(lang="cn")
     //- if htmlWebpackPlugin.options.isProd
     //-   script.
     //-     window.__static = '!{require('path').join(htmlWebpackPlugin.options.__dirname, '/static').replace(/\\/g, '\\\\')}'
-    if !htmlWebpackPlugin.options.browser && htmlWebpackPlugin.options.isProd
+    //- if !htmlWebpackPlugin.options.browser && htmlWebpackPlugin.options.isProd
       script.
-        window.__static = require('path').join(__dirname, '/static').replace(/\\/g, '\\\\')
+        window.__static = require('path').join(__dirname, '/resources').replace(/\\/g, '\\\\')

src/main/events/index.js

@@ -1,5 +1,6 @@
 
 require('./request')
 // require('./appName')
+require('./progressBar')
+require('./trafficLight')
 require('./musicMeta')
-

src/main/events/progressBar.js

@@ -1,11 +1,10 @@
 const { mainOn } = require('../../common/icp')
 
-module.exports = win => {
-  mainOn('progress', (event, params) => {
-    // console.log(params)
-    win.setProgressBar(params.status, {
-      mode: params.mode || 'normal',
-    })
-  })
-}
+
+mainOn('progress', (event, params) => {
+  // console.log(params)
+  global.mainWindow && global.mainWindow.setProgressBar(params.status, {
+    mode: params.mode || 'normal',
+  })
+})
 

src/main/events/request.js

@@ -7,7 +7,7 @@ const tasks = []
 mainOn('request', (event, options) => {
   // console.log(args)
   if (!options) return
-  let index = fatchData(options, (err, resp) => {
+  let index = fetchData(options, (err, resp) => {
     tasks[index] = null
     if (err) {
       console.log(err)
@@ -27,7 +27,7 @@ mainOn('cancelRequest', (event, index) => {
   tasks[index] = null
 })
 
-const fatchData = (options, callback) => pushTask(tasks, request(options.url, {
+const fetchData = (options, callback) => pushTask(tasks, request(options.url, {
   method: options.method,
   headers: options.headers,
   Origin: options.origin,

src/main/events/trafficLight.js

@@ -1,20 +1,22 @@
+// const { app } = require('electron')
 const { mainOn } = require('../../common/icp')
 
-module.exports = win => {
-  mainOn('min', event => {
-    if (win) {
-      win.minimize()
-    }
-  })
-  // mainOn('max', event => {
-  //   if (win) {
-  //     win.maximize()
-  //   }
-  // })
-  mainOn('close', event => {
-    if (win) {
-      // window.destroy()
-      win.close()
-    }
-  })
-}
+
+mainOn('min', event => {
+  if (global.mainWindow) {
+    global.mainWindow.minimize()
+  }
+})
+// mainOn('max', event => {
+//   if (global.mainWindow) {
+//     global.mainWindow.maximize()
+//   }
+// })
+mainOn('close', event => {
+  if (global.mainWindow) {
+    // global.mainWindowdow.destroy()
+    // console.log('close')
+    // app.quit()
+    global.mainWindow.close()
+  }
+})

src/main/index.js

@@ -16,8 +16,6 @@ app.on('second-instance', (event, argv, cwd) => {
 })
 
 require('./events')
-const progressBar = require('./events/progressBar')
-const trafficLight = require('./events/trafficLight')
 const autoUpdate = require('./utils/autoUpdate')
 const { isLinux, isMac } = require('../common/utils')
 
@@ -30,10 +28,11 @@ const isDev = process.env.NODE_ENV !== 'production'
 
 let mainWindow
 let winURL
+let isFirstCheckedUpdate = true
 
 if (isDev) {
   global.__static = path.join(__dirname, '../static')
-  winURL = `http://localhost:9080`
+  winURL = 'http://localhost:9080'
 } else {
   global.__static = path.join(__dirname, '/static')
   winURL = `file://${__dirname}/index.html`
@@ -43,7 +42,7 @@ function createWindow() {
   /**
    * Initial window options
    */
-  mainWindow = new BrowserWindow({
+  mainWindow = global.mainWindow = new BrowserWindow({
     height: 590,
     useContentSize: true,
     width: 920,
@@ -62,27 +61,54 @@ function createWindow() {
 
   mainWindow.loadURL(winURL)
 
+  mainWindow.on('close', () => {
+    mainWindow.setProgressBar(-1)
+  })
   mainWindow.on('closed', () => {
-    mainWindow = null
+    mainWindow = global.mainWindow = null
   })
 
   // mainWindow.webContents.openDevTools()
 
-  trafficLight(mainWindow)
-  progressBar(mainWindow)
-  if (!isDev) autoUpdate(mainWindow)
+  if (!isDev) {
+    autoUpdate(isFirstCheckedUpdate)
+    isFirstCheckedUpdate = false
+  }
 }
 
 if (isMac) {
   const template = [
     {
       label: app.getName(),
-      submenu: [{ label: '关于洛雪音乐', role: 'about' }, { type: 'separator' }, { label: '隐藏', role: 'hide' }, { label: '显示其他', role: 'hideothers' }, { label: '显示全部', role: 'unhide' }, { type: 'separator' }, { label: '退出', click: () => app.quit() }],
+      submenu: [
+        { label: '关于洛雪音乐', role: 'about' },
+        { type: 'separator' },
+        { label: '隐藏', role: 'hide' },
+        { label: '显示其他', role: 'hideothers' },
+        { label: '显示全部', role: 'unhide' },
+        { type: 'separator' },
+        { label: '退出', accelerator: 'Command+Q', click: () => app.quit() },
+      ],
     },
     {
       label: '窗口',
       role: 'window',
-      submenu: [{ label: '最小化', role: 'minimize' }, { label: '关闭', role: 'close' }],
+      submenu: [
+        { label: '最小化', role: 'minimize' },
+        { label: '关闭', role: 'close' },
+      ],
+    },
+    {
+      label: '编辑',
+      submenu: [
+        { label: '撤销', accelerator: 'CmdOrCtrl+Z', role: 'undo' },
+        { label: '恢复', accelerator: 'Shift+CmdOrCtrl+Z', role: 'redo' },
+        { type: 'separator' },
+        { label: '剪切', accelerator: 'CmdOrCtrl+X', role: 'cut' },
+        { label: '复制', accelerator: 'CmdOrCtrl+C', role: 'copy' },
+        { label: '粘贴', accelerator: 'CmdOrCtrl+V', role: 'paste' },
+        { label: '选择全部', accelerator: 'CmdOrCtrl+A', role: 'selectAll' },
+      ],
     },
   ]
 
@@ -94,9 +120,7 @@ if (isMac) {
 app.on('ready', createWindow)
 
 app.on('window-all-closed', () => {
-  if (process.platform !== 'darwin') {
-    app.quit()
-  }
+  if (!isMac) app.quit()
 })
 
 app.on('activate', () => {

src/main/utils/autoUpdate.js

@@ -1,4 +1,4 @@
-const log = require('electron-log')
+const { log } = require('../../common/utils')
 const { autoUpdater } = require('electron-updater')
 const { mainOn } = require('../../common/icp')
 
@@ -21,7 +21,7 @@ log.info('App starting...')
 
 function sendStatusToWindow(text) {
   log.info(text)
-  // win.webContents.send('message', text)
+  // global.mainWindow.webContents.send('message', text)
 }
 
 
@@ -56,35 +56,50 @@ function sendStatusToWindow(text) {
 
 // })
 
+let waitEvent = []
+const handleSendEvent = action => {
+  if (global.mainWindow) {
+    setTimeout(() => { // 延迟发送事件，过早发送可能渲染进程还没启动完成
+      global.mainWindow.webContents.send(action.type, action.info)
+    }, 2000)
+  } else {
+    waitEvent.push(action)
+  }
+}
 
-module.exports = win => {
+module.exports = isFirstCheckedUpdate => {
+  if (!isFirstCheckedUpdate) {
+    if (waitEvent.length) {
+      waitEvent.forEach((event, index) => {
+        setTimeout(() => { // 延迟发送事件，过早发送可能渲染进程还没启动完成
+          global.mainWindow.webContents.send(event.type, event.info)
+        }, 2000 * (index + 1))
+      })
+      waitEvent = []
+    }
+    return
+  }
   autoUpdater.on('checking-for-update', () => {
     sendStatusToWindow('Checking for update...')
   })
   autoUpdater.on('update-available', info => {
     sendStatusToWindow('Update available.')
-    win.webContents.send('update-available', info)
+    handleSendEvent({ type: 'update-available', info })
   })
   autoUpdater.on('update-not-available', info => {
     sendStatusToWindow('Update not available.')
-    setTimeout(() => { // 延迟发送事件，过早发送可能渲染进程还启动完成
-      win.webContents.send('update-not-available')
-    }, 5000)
+    handleSendEvent({ type: 'update-not-available' })
   })
   autoUpdater.on('error', () => {
     sendStatusToWindow('Error in auto-updater.')
-    setTimeout(() => { // 延迟发送事件，过早发送可能渲染进程还启动完成
-      win.webContents.send('update-error')
-    }, 6000)
+    handleSendEvent({ type: 'update-error' })
   })
   autoUpdater.on('download-progress', progressObj => {
     sendStatusToWindow('Download progress...')
   })
   autoUpdater.on('update-downloaded', info => {
     sendStatusToWindow('Update downloaded.')
-    setTimeout(() => { // 延迟发送事件，过早发送可能渲染进程还启动完成
-      win.webContents.send('update-downloaded')
-    }, 2000)
+    handleSendEvent({ type: 'update-downloaded' })
   })
   mainOn('quit-update', () => {
     setTimeout(() => {

src/main/utils/mp3Meta.js

@@ -6,7 +6,7 @@ const extReg = /^(\.(?:jpe?g|png)).*$/
 
 module.exports = (filePath, meta) => {
   if (!meta.APIC) return NodeID3.write(meta, filePath)
-  let picPath = path.join(path.dirname(filePath), `${meta.title}-${meta.artist}${path.extname(meta.APIC).replace(extReg, '$1')}`)
+  let picPath = filePath.replace(/\.mp3$/, '') + path.extname(meta.APIC).replace(extReg, '$1')
   request(meta.APIC).pipe(fs.createWriteStream(picPath)).on('finish', () => {
     meta.APIC = picPath
     NodeID3.write(meta, filePath)

src/renderer/App.vue

@@ -18,10 +18,16 @@
 </template>
 
 <script>
+import dnscache from 'dnscache'
 import { mapMutations, mapGetters, mapActions } from 'vuex'
 import { rendererOn } from '../common/icp'
 import { isLinux } from '../common/utils'
 window.ELECTRON_DISABLE_SECURITY_WARNINGS = process.env.ELECTRON_DISABLE_SECURITY_WARNINGS
+dnscache({
+  enable: true,
+  ttl: 21600,
+  cachesize: 1000,
+})
 let win
 let body
 if (!isLinux) {
@@ -35,14 +41,15 @@ export default {
       isProd: process.env.NODE_ENV === 'production',
       isLinux,
       globalObj: {
-        apiSource: 'messoer',
+        apiSource: 'test',
+        proxy: {},
       },
       updateTimeout: null,
     }
   },
   computed: {
     ...mapGetters(['electronStore', 'setting', 'theme', 'version']),
-    ...mapGetters('list', ['defaultList']),
+    ...mapGetters('list', ['defaultList', 'loveList']),
     ...mapGetters('download', {
       downloadList: 'list',
       downloadStatus: 'downloadStatus',
@@ -66,6 +73,13 @@ export default {
       },
       deep: true,
     },
+    loveList: {
+      handler(n) {
+        // console.log(n)
+        this.electronStore.set('list.loveList', n)
+      },
+      deep: true,
+    },
     downloadList: {
       handler(n) {
         this.electronStore.set('download.list', n)
@@ -83,7 +97,7 @@ export default {
   methods: {
     ...mapActions(['getVersionInfo']),
     ...mapMutations(['setNewVersion', 'setVersionModalVisible']),
-    ...mapMutations('list', ['initDefaultList']),
+    ...mapMutations('list', ['initList']),
     ...mapMutations('download', ['updateDownloadList']),
     ...mapMutations(['setSetting']),
     init() {
@@ -107,6 +121,7 @@ export default {
       })
       rendererOn('update-downloaded', () => {
         this.clearUpdateTimeout()
+        this.setVersionModalVisible({ isError: false })
         this.showUpdateModal()
       })
       rendererOn('update-not-available', () => {
@@ -128,6 +143,7 @@ export default {
 
       this.initData()
       this.globalObj.apiSource = this.setting.apiSource
+      this.globalObj.proxy = Object.assign({}, this.setting.network.proxy)
       window.globalObj = this.globalObj
     },
     enableIgnoreMouseEvents() {
@@ -147,13 +163,8 @@ export default {
     },
     initPlayList() {
       let defaultList = this.electronStore.get('list.defaultList')
-      // console.log(defaultList)
-      if (defaultList) {
-        // defaultList.list.forEach(m => {
-        //   m.typeUrl = {}
-        // })
-        this.initDefaultList(defaultList)
-      }
+      let loveList = this.electronStore.get('list.loveList')
+      this.initList({ defaultList, loveList })
     },
     initDownloadList() {
       let downloadList = this.electronStore.get('download.list')
@@ -224,6 +235,10 @@ body {
   display: flex;
   height: 100%;
   overflow: hidden;
+  background: @color-theme-bgimg @color-theme-bgposition no-repeat;
+  background-size: @color-theme-bgsize;
+  transition: background-color @transition-theme;
+  background-color: @color-theme;
 }
 
 #left {
@@ -234,6 +249,8 @@ body {
   flex: auto;
   display: flex;
   flex-flow: column nowrap;
+  transition: background-color @transition-theme;
+  background-color: @color-theme_2;
 }
 #toolbar, #player {
   flex: none;
@@ -242,5 +259,17 @@ body {
   flex: auto;
   height: 0;
 }
+
+each(@themes, {
+  #container.@{value} {
+    background-color: ~'@{color-@{value}-theme}';
+    background-image: ~'@{color-@{value}-theme-bgimg}';
+    background-size: ~'@{color-@{value}-theme-bgsize}';
+    background-position: ~'@{color-@{value}-theme-bgposition}';
+    #right {
+      background-color: ~'@{color-@{value}-theme_2}';
+    }
+  }
+})
 </style>
 

src/renderer/assets/styles/index.less

@@ -36,11 +36,11 @@ table {
   }
   tbody {
     tr {
-      border-top: 1px solid #e0e0e0;
+      border-top: 1px solid @color-theme_2-line;
       // border-top: 1px solid rgba(0, 0, 0, 0.12);
       transition: background-color 0.2s ease;
       &:hover {
-        background-color: #eee;
+        background-color: @color-theme_2-hover;
       }
       &:first-child {
         border-top: none;
@@ -103,6 +103,10 @@ strong {
   font-weight: bold;
 }
 
+.underline {
+  text-decoration: underline;
+}
+
 svg {
   transition: @transition-theme;
   transition-property: fill;
@@ -168,5 +172,15 @@ each(@themes, {
         background-color: ~'@{color-@{value}-scrollbar-thumb-hover}';
       }
     }
+    table {
+      tbody {
+        tr {
+          border-top-color: ~'@{color-@{value}-theme_2-line}';
+          &:hover {
+            background-color: ~'@{color-@{value}-theme_2-hover}';
+          }
+        }
+      }
+    }
   }
 })

src/renderer/assets/styles/variables.less

@@ -1,21 +1,28 @@
 @import './colors.less';
 
-@themes: green, yellow, blue, red, purple, orange, grey;
+@themes: green, yellow, blue, red, purple, orange, grey, midAutumn, dhHyrz;
 
 
 // Colors
 // @color-theme: #03a678;
 @color-theme: #4daf7c;
+@color-theme-bgimg: none;
+@color-theme-bgposition: center center;
+@color-theme-bgsize: auto auto;
 @color-theme-hover: fadeout(lighten(@color-theme, 10%), 30%);
 @color-theme-active: fadeout(darken(@color-theme, 20%), 60%);
 @color-theme-font: #fff;
 @color-theme-font-label: lighten(@color-theme, 35%);
 
-@color-theme_2: #fff;
+@color-theme_2: rgba(255, 255, 255, .9);
+@color-theme_2-background_1: #fff;
+@color-theme_2-background_2: fadeout(@color-theme_2-background_1, 2%);
 @color-theme_2-hover: fadeout(lighten(@color-theme, 10%), 70%);
 @color-theme_2-active: fadeout(darken(@color-theme, 5%), 70%);
 @color-theme_2-font: darken(@color-theme_2, 70%);
-@color-theme_2-font-label: lighten(@color-theme, 40%);
+@color-theme_2-font-label: fadeout(@color-theme_2-font, 50%);
+@color-theme_2-line: lighten(@color-theme, 35%);
+@color-theme-sidebar: @color-theme;
 @color-btn: fadeout(darken(@color-theme, 5%), 15%);
 @color-btn-background: fadeout(lighten(@color-theme, 35%), 70%);
 
@@ -41,6 +48,7 @@
 @color-player-status-text: lighten(@color-theme_2-font, 10%);
 
 @color-tab-btn-background: fadeout(lighten(@color-theme, 10%), 80%);
+@color-tab-btn-background-hover: @color-theme_2-hover;
 @color-tab-border-top: fadeout(lighten(@color-theme, 5%), 50%);
 @color-tab-border-bottom: lighten(@color-theme, 5%);
 
@@ -50,15 +58,22 @@
 
 
 @color-green-theme: #4daf7c;
+@color-green-theme-bgimg: none;
+@color-green-theme-bgposition: center center;
+@color-green-theme-bgsize: auto auto;
 @color-green-theme-hover: fadeout(lighten(@color-green-theme, 10%), 30%);
 @color-green-theme-active: fadeout(darken(@color-green-theme, 20%), 60%);
 @color-green-theme-font: #fff;
 @color-green-theme-font-label: lighten(@color-green-theme, 35%);
 @color-green-theme_2: #fff;
+@color-green-theme_2-background_1: #fff;
+@color-green-theme_2-background_2: fadeout(@color-green-theme_2-background_1, 2%);
 @color-green-theme_2-hover: fadeout(lighten(@color-green-theme, 10%), 70%);
 @color-green-theme_2-active: fadeout(darken(@color-green-theme, 5%), 70%);
 @color-green-theme_2-font: darken(@color-green-theme_2, 70%);
-@color-green-theme_2-font-label: lighten(@color-green-theme, 40%);
+@color-green-theme_2-font-label: fadeout(@color-green-theme_2-font, 50%);
+@color-green-theme_2-line: lighten(@color-green-theme, 35%);
+@color-green-theme-sidebar: @color-green-theme;
 @color-green-btn: fadeout(darken(@color-green-theme, 5%), 15%);
 @color-green-btn-background: fadeout(lighten(@color-green-theme, 35%), 70%);
 @color-green-pagination-background: fadeout(lighten(@color-green-theme, 45%), 30%);
@@ -77,20 +92,28 @@
 @color-green-player-progress-bar2: lighten(@color-green-theme, 12%);
 @color-green-player-status-text: lighten(@color-green-theme_2-font, 10%);
 @color-green-tab-btn-background: fadeout(lighten(@color-green-theme, 10%), 80%);
+@color-green-tab-btn-background-hover: @color-green-theme_2-hover;
 @color-green-tab-border-top: fadeout(lighten(@color-green-theme, 5%), 50%);
 @color-green-tab-border-bottom: lighten(@color-green-theme, 5%);
 
 
 @color-yellow-theme: #f2d35b;
+@color-yellow-theme-bgimg: none;
+@color-yellow-theme-bgposition: center center;
+@color-yellow-theme-bgsize: auto auto;
 @color-yellow-theme-hover: fadeout(lighten(@color-yellow-theme, 10%), 30%);
 @color-yellow-theme-active: fadeout(darken(@color-yellow-theme, 20%), 60%);
 @color-yellow-theme-font: #fff;
 @color-yellow-theme-font-label: lighten(@color-yellow-theme, 35%);
 @color-yellow-theme_2: #fff;
+@color-yellow-theme_2-background_1: #fff;
+@color-yellow-theme_2-background_2: fadeout(@color-yellow-theme_2-background_1, 2%);
 @color-yellow-theme_2-hover: fadeout(lighten(@color-yellow-theme, 10%), 70%);
 @color-yellow-theme_2-active: fadeout(darken(@color-yellow-theme, 5%), 70%);
 @color-yellow-theme_2-font: darken(@color-yellow-theme_2, 70%);
-@color-yellow-theme_2-font-label: lighten(@color-yellow-theme, 40%);
+@color-yellow-theme_2-font-label: fadeout(@color-yellow-theme_2-font, 50%);
+@color-yellow-theme_2-line: lighten(@color-yellow-theme, 35%);
+@color-yellow-theme-sidebar: @color-yellow-theme;
 @color-yellow-btn: fadeout(darken(@color-yellow-theme, 5%), 15%);
 @color-yellow-btn-background: fadeout(lighten(@color-yellow-theme, 25%), 70%);
 @color-yellow-pagination-background: fadeout(lighten(@color-yellow-theme, 30%), 30%);
@@ -109,19 +132,27 @@
 @color-yellow-player-progress-bar2: lighten(@color-yellow-theme, 12%);
 @color-yellow-player-status-text: lighten(@color-yellow-theme_2-font, 10%);
 @color-yellow-tab-btn-background: fadeout(lighten(@color-yellow-theme, 10%), 80%);
+@color-yellow-tab-btn-background-hover: @color-yellow-theme_2-hover;
 @color-yellow-tab-border-top: fadeout(lighten(@color-yellow-theme, 5%), 50%);
 @color-yellow-tab-border-bottom: lighten(@color-yellow-theme, 5%);
 
 @color-orange-theme: #f5ab35;
+@color-orange-theme-bgimg: none;
+@color-orange-theme-bgposition: center center;
+@color-orange-theme-bgsize: auto auto;
 @color-orange-theme-hover: fadeout(lighten(@color-orange-theme, 10%), 30%);
 @color-orange-theme-active: fadeout(darken(@color-orange-theme, 20%), 60%);
 @color-orange-theme-font: #fff;
 @color-orange-theme-font-label: lighten(@color-orange-theme, 35%);
 @color-orange-theme_2: #fff;
+@color-orange-theme_2-background_1: #fff;
+@color-orange-theme_2-background_2: fadeout(@color-orange-theme_2-background_1, 2%);
 @color-orange-theme_2-hover: fadeout(lighten(@color-orange-theme, 10%), 70%);
 @color-orange-theme_2-active: fadeout(darken(@color-orange-theme, 5%), 70%);
 @color-orange-theme_2-font: darken(@color-orange-theme_2, 70%);
-@color-orange-theme_2-font-label: lighten(@color-orange-theme, 40%);
+@color-orange-theme_2-font-label: fadeout(@color-orange-theme_2-font, 50%);
+@color-orange-theme_2-line: lighten(@color-orange-theme, 35%);
+@color-orange-theme-sidebar: @color-orange-theme;
 @color-orange-btn: fadeout(darken(@color-orange-theme, 5%), 15%);
 @color-orange-btn-background: fadeout(lighten(@color-orange-theme, 35%), 70%);
 @color-orange-pagination-background: fadeout(lighten(@color-orange-theme, 35%), 30%);
@@ -140,19 +171,27 @@
 @color-orange-player-progress-bar2: lighten(@color-orange-theme, 12%);
 @color-orange-player-status-text: lighten(@color-orange-theme_2-font, 10%);
 @color-orange-tab-btn-background: fadeout(lighten(@color-orange-theme, 10%), 80%);
+@color-orange-tab-btn-background-hover: @color-orange-theme_2-hover;
 @color-orange-tab-border-top: fadeout(lighten(@color-orange-theme, 5%), 50%);
 @color-orange-tab-border-bottom: lighten(@color-orange-theme, 5%);
 
 @color-blue-theme: #3498db;
+@color-blue-theme-bgimg: none;
+@color-blue-theme-bgposition: center center;
+@color-blue-theme-bgsize: auto auto;
 @color-blue-theme-hover: fadeout(lighten(@color-blue-theme, 10%), 30%);
 @color-blue-theme-active: fadeout(darken(@color-blue-theme, 20%), 60%);
 @color-blue-theme-font: #fff;
 @color-blue-theme-font-label: lighten(@color-blue-theme, 35%);
 @color-blue-theme_2: #fff;
+@color-blue-theme_2-background_1: #fff;
+@color-blue-theme_2-background_2: fadeout(@color-blue-theme_2-background_1, 2%);
 @color-blue-theme_2-hover: fadeout(lighten(@color-blue-theme, 10%), 70%);
 @color-blue-theme_2-active: fadeout(darken(@color-blue-theme, 5%), 70%);
 @color-blue-theme_2-font: darken(@color-blue-theme_2, 70%);
-@color-blue-theme_2-font-label: lighten(@color-blue-theme, 40%);
+@color-blue-theme_2-font-label: fadeout(@color-blue-theme_2-font, 50%);
+@color-blue-theme_2-line: lighten(@color-blue-theme, 35%);
+@color-blue-theme-sidebar: @color-blue-theme;
 @color-blue-btn: fadeout(darken(@color-blue-theme, 5%), 15%);
 @color-blue-btn-background: fadeout(lighten(@color-blue-theme, 35%), 70%);
 @color-blue-pagination-background: fadeout(lighten(@color-blue-theme, 40%), 30%);
@@ -171,10 +210,14 @@
 @color-blue-player-progress-bar2: lighten(@color-blue-theme, 12%);
 @color-blue-player-status-text: lighten(@color-blue-theme_2-font, 10%);
 @color-blue-tab-btn-background: fadeout(lighten(@color-blue-theme, 10%), 80%);
+@color-blue-tab-btn-background-hover: @color-blue-theme_2-hover;
 @color-blue-tab-border-top: fadeout(lighten(@color-blue-theme, 5%), 50%);
 @color-blue-tab-border-bottom: lighten(@color-blue-theme, 5%);
 
 @color-red-theme: #d64541;
+@color-red-theme-bgimg: none;
+@color-red-theme-bgposition: center center;
+@color-red-theme-bgsize: auto auto;
 @color-red-theme-hover: fadeout(lighten(@color-red-theme, 10%), 30%);
 @color-red-theme-active: fadeout(darken(@color-red-theme, 20%), 60%);
 @color-red-theme-font: #fff;
@@ -182,8 +225,12 @@
 @color-red-theme_2: #fff;
 @color-red-theme_2-hover: fadeout(lighten(@color-red-theme, 10%), 70%);
 @color-red-theme_2-active: fadeout(darken(@color-red-theme, 5%), 70%);
+@color-red-theme_2-background_1: #fff;
+@color-red-theme_2-background_2: fadeout(@color-red-theme_2-background_1, 2%);
 @color-red-theme_2-font: darken(@color-red-theme_2, 70%);
-@color-red-theme_2-font-label: lighten(@color-red-theme, 40%);
+@color-red-theme_2-font-label: fadeout(@color-red-theme_2-font, 50%);
+@color-red-theme_2-line: lighten(@color-red-theme, 35%);
+@color-red-theme-sidebar: @color-red-theme;
 @color-red-btn: fadeout(darken(@color-red-theme, 5%), 15%);
 @color-red-btn-background: fadeout(lighten(@color-red-theme, 35%), 70%);
 @color-red-pagination-background: fadeout(lighten(@color-red-theme, 40%), 30%);
@@ -204,19 +251,27 @@
 @color-red-tab-border-top: fadeout(lighten(@color-red-theme, 25%), 70%);
 @color-red-tab-border-bottom: lighten(@color-red-theme, 35%);
 @color-red-tab-btn-background: fadeout(lighten(@color-red-theme, 10%), 80%);
+@color-red-tab-btn-background-hover: @color-red-theme_2-hover;
 @color-red-tab-border-top: fadeout(lighten(@color-red-theme, 5%), 50%);
 @color-red-tab-border-bottom: lighten(@color-red-theme, 5%);
 
 @color-purple-theme: #9b59b6;
+@color-purple-theme-bgimg: none;
+@color-purple-theme-bgposition: center center;
+@color-purple-theme-bgsize: auto auto;
 @color-purple-theme-hover: fadeout(lighten(@color-purple-theme, 10%), 30%);
 @color-purple-theme-active: fadeout(darken(@color-purple-theme, 20%), 60%);
 @color-purple-theme-font: #fff;
 @color-purple-theme-font-label: lighten(@color-purple-theme, 35%);
 @color-purple-theme_2: #fff;
+@color-purple-theme_2-background_1: #fff;
+@color-purple-theme_2-background_2: fadeout(@color-purple-theme_2-background_1, 2%);
 @color-purple-theme_2-hover: fadeout(lighten(@color-purple-theme, 10%), 70%);
 @color-purple-theme_2-active: fadeout(darken(@color-purple-theme, 5%), 70%);
 @color-purple-theme_2-font: darken(@color-purple-theme_2, 70%);
-@color-purple-theme_2-font-label: lighten(@color-purple-theme, 40%);
+@color-purple-theme_2-font-label: fadeout(@color-purple-theme_2-font, 50%);
+@color-purple-theme_2-line: lighten(@color-purple-theme, 35%);
+@color-purple-theme-sidebar: @color-purple-theme;
 @color-purple-btn: fadeout(darken(@color-purple-theme, 5%), 15%);
 @color-purple-btn-background: fadeout(lighten(@color-purple-theme, 35%), 70%);
 @color-purple-pagination-background: fadeout(lighten(@color-purple-theme, 40%), 30%);
@@ -235,19 +290,27 @@
 @color-purple-player-progress-bar2: lighten(@color-purple-theme, 12%);
 @color-purple-player-status-text: lighten(@color-purple-theme_2-font, 10%);
 @color-purple-tab-btn-background: fadeout(lighten(@color-purple-theme, 10%), 80%);
+@color-purple-tab-btn-background-hover: @color-purple-theme_2-hover;
 @color-purple-tab-border-top: fadeout(lighten(@color-purple-theme, 5%), 50%);
 @color-purple-tab-border-bottom: lighten(@color-purple-theme, 5%);
 
 @color-grey-theme: #6c7a89;
+@color-grey-theme-bgimg: none;
+@color-grey-theme-bgposition: center center;
+@color-grey-theme-bgsize: auto auto;
 @color-grey-theme-hover: fadeout(lighten(@color-grey-theme, 10%), 30%);
 @color-grey-theme-active: fadeout(darken(@color-grey-theme, 20%), 60%);
 @color-grey-theme-font: #fff;
 @color-grey-theme-font-label: lighten(@color-grey-theme, 35%);
 @color-grey-theme_2: #fff;
+@color-grey-theme_2-background_1: #fff;
+@color-grey-theme_2-background_2: fadeout(@color-grey-theme_2-background_1, 2%);
 @color-grey-theme_2-hover: fadeout(lighten(@color-grey-theme, 10%), 70%);
 @color-grey-theme_2-active: fadeout(darken(@color-grey-theme, 5%), 70%);
 @color-grey-theme_2-font: darken(@color-grey-theme_2, 70%);
-@color-grey-theme_2-font-label: lighten(@color-grey-theme, 40%);
+@color-grey-theme_2-font-label: fadeout(@color-grey-theme_2-font, 50%);
+@color-grey-theme_2-line: lighten(@color-grey-theme, 35%);
+@color-grey-theme-sidebar: @color-grey-theme;
 @color-grey-btn: fadeout(darken(@color-grey-theme, 5%), 15%);
 @color-grey-btn-background: fadeout(lighten(@color-grey-theme, 35%), 70%);
 @color-grey-pagination-background: fadeout(lighten(@color-grey-theme, 45%), 30%);
@@ -266,9 +329,88 @@
 @color-grey-player-progress-bar2: lighten(@color-grey-theme, 12%);
 @color-grey-player-status-text: lighten(@color-grey-theme_2-font, 10%);
 @color-grey-tab-btn-background: fadeout(lighten(@color-grey-theme, 10%), 80%);
+@color-grey-tab-btn-background-hover: @color-grey-theme_2-hover;
 @color-grey-tab-border-top: fadeout(lighten(@color-grey-theme, 5%), 50%);
 @color-grey-tab-border-bottom: lighten(@color-grey-theme, 5%);
 
+@color-midAutumn-theme: rgba(74, 55, 82, 1);
+@color-midAutumn-theme-bgimg: url(../images/jqbg.jpg);
+@color-midAutumn-theme-bgposition: center center;
+@color-midAutumn-theme-bgsize: auto 100%;
+@color-midAutumn-theme-hover: fadeout(lighten(@color-midAutumn-theme, 10%), 30%);
+@color-midAutumn-theme-active: fadeout(lighten(@color-midAutumn-theme, 15%), 60%);
+@color-midAutumn-theme-font: rgba(246, 233, 255, 0.9);
+@color-midAutumn-theme-font-label: fadeout(lighten(@color-midAutumn-theme, 20%), 20%);
+@color-midAutumn-theme_2: rgba(255, 255, 255, .93);
+@color-midAutumn-theme_2-background_1: #eeedef;
+@color-midAutumn-theme_2-background_2: fadeout(@color-midAutumn-theme_2-background_1, 2%);
+@color-midAutumn-theme_2-hover: fadeout(lighten(@color-midAutumn-theme, 10%), 65%);
+@color-midAutumn-theme_2-active: fadeout(darken(@color-midAutumn-theme, 5%), 70%);
+@color-midAutumn-theme_2-font: darken(@color-midAutumn-theme_2, 70%);
+@color-midAutumn-theme_2-font-label: lighten(@color-midAutumn-theme, 40%);
+@color-midAutumn-theme_2-line: lighten(@color-midAutumn-theme, 54%);
+@color-midAutumn-theme-sidebar: rgba(255, 255, 255, 0);
+@color-midAutumn-btn: fadeout(darken(@color-midAutumn-theme, 5%), 15%);
+@color-midAutumn-btn-background: fadeout(lighten(@color-midAutumn-theme, 35%), 70%);
+@color-midAutumn-pagination-background: fadeout(lighten(@color-midAutumn-theme, 45%), 50%);
+@color-midAutumn-pagination-hover: fadeout(lighten(@color-midAutumn-theme, 10%), 70%);
+@color-midAutumn-pagination-active: fadeout(darken(@color-midAutumn-theme, 10%), 70%);
+@color-midAutumn-pagination-select: fadeout(lighten(@color-midAutumn-theme, 10%), 55%);
+@color-midAutumn-search-form-background: fadeout(lighten(@color-midAutumn-theme, 50%), 10%);
+@color-midAutumn-search-list-hover: fadeout(darken(@color-midAutumn-theme, 10%), 70%);
+@color-midAutumn-scrollbar-track: fadeout(@color-midAutumn-theme, 80%);
+@color-midAutumn-scrollbar-thumb: fadeout(@color-midAutumn-theme, 60%);
+@color-midAutumn-scrollbar-thumb-hover: fadeout(@color-midAutumn-theme, 40%);
+@color-midAutumn-player-pic-c1: fadeout(@color-midAutumn-theme_2, 50%);
+@color-midAutumn-player-pic-c2: darken(@color-midAutumn-theme_2, 30%);
+@color-midAutumn-player-progress: darken(@color-midAutumn-theme_2, 6%);
+@color-midAutumn-player-progress-bar1: darken(@color-midAutumn-theme_2, 12%);
+@color-midAutumn-player-progress-bar2: lighten(@color-midAutumn-theme, 12%);
+@color-midAutumn-player-status-text: lighten(@color-midAutumn-theme_2-font, 10%);
+@color-midAutumn-tab-btn-background: fadeout(lighten(@color-midAutumn-theme, 10%), 80%);
+@color-midAutumn-tab-btn-background-hover: @color-midAutumn-theme_2-hover;
+@color-midAutumn-tab-border-top: fadeout(lighten(@color-midAutumn-theme, 5%), 50%);
+@color-midAutumn-tab-border-bottom: lighten(@color-midAutumn-theme, 5%);
+
+@color-dhHyrz-theme: rgb(87, 144, 167);
+@color-dhHyrz-theme-bgimg: url(../images/hzwbg.jpeg);
+@color-dhHyrz-theme-bgposition: center center;
+@color-dhHyrz-theme-bgsize: auto 100%;
+@color-dhHyrz-theme-hover: fadeout(lighten(@color-dhHyrz-theme, 10%), 45%);
+@color-dhHyrz-theme-active: fadeout(lighten(@color-dhHyrz-theme, 15%), 60%);
+@color-dhHyrz-theme-font: rgba(67, 118, 148, 0.9);
+@color-dhHyrz-theme-font-label: fadeout(darken(@color-dhHyrz-theme, 20%), 20%);
+@color-dhHyrz-theme_2: rgba(255, 255, 255, 0.8);
+@color-dhHyrz-theme_2-background_1: #e9faff;
+@color-dhHyrz-theme_2-background_2: fadeout(@color-dhHyrz-theme_2-background_1, 2%);
+@color-dhHyrz-theme_2-hover: fadeout(lighten(@color-dhHyrz-theme, 10%), 65%);
+@color-dhHyrz-theme_2-active: fadeout(darken(@color-dhHyrz-theme, 5%), 70%);
+@color-dhHyrz-theme_2-font: darken(@color-dhHyrz-theme_2, 80%);
+@color-dhHyrz-theme_2-font-label: lighten(@color-dhHyrz-theme, 10%);
+@color-dhHyrz-theme_2-line: lighten(@color-dhHyrz-theme, 36%);
+@color-dhHyrz-theme-sidebar: rgba(255, 255, 255, .3);
+@color-dhHyrz-btn: fadeout(darken(@color-dhHyrz-theme, 5%), 15%);
+@color-dhHyrz-btn-background: fadeout(lighten(@color-dhHyrz-theme, 35%), 70%);
+@color-dhHyrz-pagination-background: fadeout(lighten(@color-dhHyrz-theme, 45%), 50%);
+@color-dhHyrz-pagination-hover: fadeout(lighten(@color-dhHyrz-theme, 10%), 70%);
+@color-dhHyrz-pagination-active: fadeout(darken(@color-dhHyrz-theme, 10%), 70%);
+@color-dhHyrz-pagination-select: fadeout(lighten(@color-dhHyrz-theme, 10%), 55%);
+@color-dhHyrz-search-form-background: fadeout(lighten(@color-dhHyrz-theme, 30%), 20%);
+@color-dhHyrz-search-list-hover: fadeout(darken(@color-dhHyrz-theme, 10%), 50%);
+@color-dhHyrz-scrollbar-track: fadeout(@color-dhHyrz-theme, 80%);
+@color-dhHyrz-scrollbar-thumb: fadeout(@color-dhHyrz-theme, 60%);
+@color-dhHyrz-scrollbar-thumb-hover: fadeout(@color-dhHyrz-theme, 40%);
+@color-dhHyrz-player-pic-c1: fadeout(@color-dhHyrz-theme_2, 50%);
+@color-dhHyrz-player-pic-c2: darken(@color-dhHyrz-theme_2, 30%);
+@color-dhHyrz-player-progress: darken(@color-dhHyrz-theme_2, 6%);
+@color-dhHyrz-player-progress-bar1: darken(@color-dhHyrz-theme_2, 12%);
+@color-dhHyrz-player-progress-bar2: lighten(@color-dhHyrz-theme, 12%);
+@color-dhHyrz-player-status-text: lighten(@color-dhHyrz-theme_2-font, 10%);
+@color-dhHyrz-tab-btn-background: fadeout(lighten(@color-dhHyrz-theme, 10%), 80%);
+@color-dhHyrz-tab-btn-background-hover: @color-dhHyrz-theme_2-hover;
+@color-dhHyrz-tab-border-top: fadeout(lighten(@color-dhHyrz-theme, 5%), 50%);
+@color-dhHyrz-tab-border-bottom: lighten(@color-dhHyrz-theme, 5%);
+
 
 // Width
 @width-app-left: 180px;

src/renderer/components/core/Aside.vue

@@ -16,8 +16,9 @@ div(:class="$style.aside")
     dl
       dt 我的音乐
       dd
-        router-link(:active-class="$style.active" to="list") {{defaultList.name}}
-        router-link(:active-class="$style.active" v-for="item in userList" :to="`list?id=${item._id}`" :key="item._id") {{item.name}}
+        router-link(:active-class="($route.query.id === defaultList.id || $route.query.id == '') ? $style.active : ''" :to="`list?id=${defaultList.id || ''}`") {{defaultList.name}}
+        router-link(:active-class="$route.query.id === loveList.id ? $style.active : ''" :to="`list?id=${loveList.id}`") {{loveList.name}}
+        router-link(:active-class="$route.query.id === item.id ? $style.active : ''" v-for="item in userList" :to="`list?id=${item._id}`" :key="item._id") {{item.name}}
     dl
       dt 其他
       dd
@@ -43,7 +44,7 @@ export default {
     }
   },
   computed: {
-    ...mapGetters('list', ['defaultList', 'userList']),
+    ...mapGetters('list', ['defaultList', 'loveList', 'userList']),
   },
   methods: {},
 }
@@ -57,7 +58,7 @@ export default {
   // box-shadow: 0 0 5px rgba(0, 0, 0, .3);
   transition: @transition-theme;
   transition-property: background-color;
-  background-color: @color-theme;
+  background-color: @color-theme-sidebar;
   // background-color: @color-aside-background;
   // border-right: 2px solid @color-theme;
   -webkit-app-region: drag;
@@ -122,7 +123,7 @@ export default {
 each(@themes, {
   :global(#container.@{value}) {
     .aside {
-      background-color: ~'@{color-@{value}-theme}';
+      background-color: ~'@{color-@{value}-theme-sidebar}';
     }
     .logo {
       color: ~'@{color-@{value}-theme-font}';

src/renderer/components/core/Icons.vue

@@ -66,5 +66,8 @@ svg(version='1.1' xmlns='http://www.w3.org/2000/svg' xlink='http://www.w3.org/19
       path(fill='currentColor' d='m240 346.5c0 8.269531 6.730469 15 15 15s15-6.730469 15-15v-15.25h-15c-7.960938 0-15 6.324219-15 15.25zm0 0')
       path(fill='currentColor' d='m295 150.5c-30.328125 0-55-24.746094-55-55.167969v-95.332031h-185c-30.328125 0-55 24.746094-55 55.167969v401.667969c0 30.417968 24.671875 55.164062 55 55.164062h280c30.328125 0 55-24.746094 55-55.167969v-306.332031zm5 196c0 24.8125-20.1875 45-45 45s-45-20.1875-45-45c0-25.507812 20.53125-45.25 45-45.25h15v-56.144531l-90 22.59375v108.925781c0 24.8125-20.1875 45-45 45s-45-20.1875-45-45c0-25.507812 20.53125-45.25 45-45.25h15v-75.375c0-6.878906 4.675781-12.875 11.347656-14.546875l120-30.125c9.46875-2.382813 18.652344 4.796875 18.652344 14.546875zm0 0')
       path(fill='currentColor' d='m120 376.625c0 8.269531 6.730469 15 15 15s15-6.730469 15-15v-15.25h-15c-7.960938 0-15 6.324219-15 15.25zm0 0')
+    g#icon-down
+      // 0 0 451.847 451.847
+      path(fill='currentColor' d='M225.923,354.706c-8.098,0-16.195-3.092-22.369-9.263L9.27,151.157c-12.359-12.359-12.359-32.397,0-44.751c12.354-12.354,32.388-12.354,44.748,0l171.905,171.915l171.906-171.909c12.359-12.354,32.391-12.354,44.744,0c12.365,12.354,12.365,32.392,0,44.751L248.292,345.449C242.115,351.621,234.018,354.706,225.923,354.706z')
 </template>
 

src/renderer/components/core/Player.vue

@@ -7,10 +7,11 @@ div(:class="$style.player")
   div(:class="$style.right")
     div(:class="$style.column1")
       div(:class="$style.container")
-        div(:class="$style.title") {{title}}
+        div(:class="$style.title" @click="handleCopy(title)" :title="title + '（点击复制）'") {{title}}
         div(:class="$style.volumeContent")
-          div(:class="$style.volume" @click.stop='handleChangeVolume' :title="`当前音量：${volumeStr}%`")
-            div(:class="$style.volumeBar" :style="{ width: volumeStr + '%' }")
+          div(:class="$style.volume")
+            div(:class="$style.volumeBar" :style="{ transform: `scaleX(${volume || 0})` }")
+          div(:class="$style.volumeMask" @mousedown="handleVolumeMsDown" ref="dom_volumeMask" :title="`当前音量：${parseInt(volume * 100)}%`")
 
         //- div(:class="$style.playBtn" @click='handleNext' title="音量")
           svg(version='1.1' xmlns='http://www.w3.org/2000/svg' xlink='http://www.w3.org/1999/xlink' height='100%' viewBox='0 0 291.063 291.064' space='preserve')
@@ -23,11 +24,11 @@ div(:class="$style.player")
             use(xlink:href='#icon-pause')
           svg(v-else version='1.1' xmlns='http://www.w3.org/2000/svg' xlink='http://www.w3.org/1999/xlink' height='100%' viewBox='0 0 170 170' space='preserve')
             use(xlink:href='#icon-play')
-    div(:class="$style.column2" @click='setProgess' ref="dom_progress")
+    div(:class="$style.column2")
       div(:class="$style.progress")
-        //- div(:class="[$style.progressBar, $style.progressBar1]" :style="{ width: progress + '%' }")
-        div(:class="[$style.progressBar, $style.progressBar2]" :style="{ width: (progress * 100 || 0) + '%' }")
-
+        //- div(:class="[$style.progressBar, $style.progressBar1]" :style="{ transform: `scaleX(${progress || 0})` }")
+        div(:class="[$style.progressBar, $style.progressBar2]" :style="{ transform: `scaleX(${progress || 0})` }")
+      div(:class="$style.progressMask" @click='setProgess' ref="dom_progress")
     div(:class="$style.column3")
       span {{nowPlayTimeStr}}
       span(:class="$style.statusText") {{status}}
@@ -48,9 +49,10 @@ div(:class="$style.player")
 <script>
 import Lyric from 'lrc-file-parser'
 import { rendererSend } from '../../../common/icp'
-import { formatPlayTime2, getRandom, checkPath, setTitle } from '../../utils'
+import { formatPlayTime2, getRandom, checkPath, setTitle, clipboardWriteText, debounce } from '../../utils'
 import { mapGetters, mapActions, mapMutations } from 'vuex'
 import { requestMsg } from '../../utils/message'
+import { isMac } from '../../../common/utils'
 
 export default {
   data() {
@@ -80,6 +82,14 @@ export default {
       delayNextTimeout: null,
       audioErrorTime: 0,
       retryNum: 0,
+      isMac,
+      volumeEvent: {
+        isMsDown: false,
+        msDownX: 0,
+        msDownVolume: 0,
+      },
+      handleVolumeMsMoveFn: null,
+      handleVolumeMsUpFn: null,
     }
   },
   computed: {
@@ -100,21 +110,27 @@ export default {
       return this.maxPlayTime ? formatPlayTime2(this.maxPlayTime) : '00:00'
     },
     progress() {
-      // return 50
       return this.nowPlayTime / this.maxPlayTime || 0
     },
     isAPITemp() {
       return this.setting.apiSource == 'temp'
     },
-    volumeStr() {
-      return parseInt(this.volume * 100)
-    },
   },
   mounted() {
     this.init()
     this.$nextTick(() => {
       this.setProgessWidth()
     })
+    this.handleSaveVolume = debounce(volume => {
+      this.setVolume(volume)
+    }, 300)
+
+    document.addEventListener('mousemove', this.handleVolumeMsMoveFn = this.handleVolumeMsMove.bind(this))
+    document.addEventListener('mouseup', this.handleVolumeMsUpFn = this.handleVolumeMsUp.bind(this))
+  },
+  beforeDestroy() {
+    document.removeEventListener('mousemove', this.handleVolumeMsMoveFn)
+    document.removeEventListener('mouseup', this.handleVolumeMsUpFn)
   },
   watch: {
     changePlay(n) {
@@ -195,7 +211,7 @@ export default {
         if (!this.musicInfo.songmid) return
         console.log('出错')
         this.stopPlay()
-        if (this.audio.error.code !== 1 && this.retryNum < 3) { // 若音频URL无效则尝试刷新3次URL
+        if (this.listId != 'download' && this.audio.error.code !== 1 && this.retryNum < 3) { // 若音频URL无效则尝试刷新3次URL
           // console.log(this.retryNum)
           this.audioErrorTime = this.audio.currentTime // 记录出错的播放时间
           this.retryNum++
@@ -214,7 +230,7 @@ export default {
           this.audio.currentTime = this.audioErrorTime
           this.audioErrorTime = 0
         }
-        if (!this.targetSong.interval && this.listId != 'download') this.updateMusicInfo({ index: this.playIndex, data: { interval: formatPlayTime2(this.maxPlayTime) } })
+        if (!this.targetSong.interval && this.listId != 'download') this.updateMusicInfo({ id: 'default', index: this.playIndex, data: { interval: formatPlayTime2(this.maxPlayTime) } })
         this.status = '音乐加载中...'
       })
       this.audio.addEventListener('loadstart', () => {
@@ -263,6 +279,7 @@ export default {
       this.audioErrorTime = 0
 
       if (this.listId == 'download') {
+        console.log(targetSong.filePath)
         if (!checkPath(targetSong.filePath) || !targetSong.isComplate || /\.ape$/.test(targetSong.filePath)) {
           return this.list.length == 1 ? null : this.handleNext()
         }
@@ -370,10 +387,11 @@ export default {
     getPlayType(highQuality, songInfo) {
       switch (songInfo.source) {
         case 'wy':
+        case 'tx':
         // case 'kg':
           return '128k'
       }
-      let type = songInfo._types['192k'] ? '192k' : '128k'
+      let type = '128k'
       if (highQuality && songInfo._types['320k']) type = '320k'
       return type
     },
@@ -444,16 +462,32 @@ export default {
     clearAppTitle() {
       setTitle()
     },
-    handleChangeVolume(e) {
+    handleVolumeMsDown(e) {
+      this.volumeEvent.isMsDown = true
+      this.volumeEvent.isMsMoved = false
+      this.volumeEvent.msDownX = e.clientX
+
       let val = e.offsetX / 70
       if (val < 0) val = 0
       if (val > 1) val = 1
-      if (val > 0.97) val = 1
+
       this.volume = val
+      this.volumeEvent.msDownVolume = val
+      // console.log(val)
       if (this.audio) this.audio.volume = this.volume
     },
-    handleSaveVolume(volume) {
-      this.setVolume(volume)
+    handleVolumeMsUp(e) {
+      this.volumeEvent.isMsDown = false
+    },
+    handleVolumeMsMove(e) {
+      if (!this.volumeEvent.isMsDown) return
+      let val = this.volumeEvent.msDownVolume + (e.clientX - this.volumeEvent.msDownX) / 70
+      this.volume = val < 0 ? 0 : val > 1 ? 1 : val
+      if (this.audio) this.audio.volume = this.volume
+      // console.log(val)
+    },
+    handleCopy(text) {
+      clipboardWriteText(text)
     },
   },
 }
@@ -467,8 +501,7 @@ export default {
   height: @height-player;
   // background-color: rgb(245, 245, 245);
   transition: @transition-theme;
-  transition-property: background-color, border-color;
-  background-color: @color-theme_2;
+  transition-property: border-color;
   border-top: 2px solid @color-theme;
   box-sizing: border-box;
   display: flex;
@@ -483,6 +516,7 @@ export default {
   transition: @transition-theme;
   transition-property: color;
   flex: none;
+  padding: 2px;
 
   svg {
     fill: currentColor;
@@ -492,7 +526,7 @@ export default {
     max-height: 100%;
     transition: @transition-theme;
     transition-property: border-color;
-    border: 2px solid @color-theme_2;
+    // border: 2px solid @color-theme_2-background_1;
   }
 }
 .right {
@@ -527,14 +561,20 @@ export default {
 }
 
 .volume-content {
+  position: relative;
   width: 100px;
   display: flex;
   align-items: center;
   padding: 0 15px;
+  opacity: .5;
+  transition: opacity @transition-theme;
+  &:hover {
+    opacity: 1;
+  }
 }
 
 .volume {
-  cursor: pointer;
+  // cursor: pointer;
   width: 100%;
   height: 0.25em;
   border-radius: 10px;
@@ -551,13 +591,26 @@ export default {
   position: absolute;
   left: 0;
   top: 0;
-  width: 0;
+  transform: scaleX(0);
+  transform-origin: 0;
+  transition-property: transform;
+  transition-timing-function: ease;
+  width: 100%;
   height: 100%;
   border-radius: @radius-progress-border;
   transition-duration: 0.2s;
   background-color: @color-theme;
   box-shadow: 0 0 2px rgba(0, 0, 0, 0.2);
-  opacity: .5;
+}
+
+.volume-mask {
+  position: absolute;
+  left: 15px;
+  right: 15px;
+  top: 0;
+  width: 70%;
+  height: 100%;
+  cursor: pointer;
 }
 
 .play-btn {
@@ -572,7 +625,7 @@ export default {
   transition: @transition-theme;
   transition-property: color;
   color: @color-theme;
-  transition: opacity 0.2s ease;
+  transition: opacity 0.1s ease;
   opacity: 1;
   cursor: pointer;
 
@@ -588,7 +641,7 @@ export default {
 .column2 {
   flex: none;
   padding: 3px 0;
-  cursor: pointer;
+  position: relative;
 }
 
 .progress {
@@ -603,12 +656,23 @@ export default {
   position: relative;
   border-radius: @radius-progress-border;
 }
+.progress-mask {
+  position: absolute;
+  left: 0;
+  top: 0;
+  width: 100%;
+  height: 100%;
+  cursor: pointer;
+}
 .progress-bar {
   position: absolute;
   left: 0;
   top: 0;
-  width: 0;
+  width: 100%;
   height: 100%;
+  transform-origin: 0;
+  transition-property: transform;
+  transition-timing-function: ease-out;
   border-radius: @radius-progress-border;
 }
 .progress-bar1 {
@@ -665,14 +729,13 @@ export default {
 each(@themes, {
   :global(#container.@{value}) {
     .player {
-      background-color: ~'@{color-@{value}-theme_2}';
       border-top-color: ~'@{color-@{value}-theme}';
     }
     .left {
       color: ~'@{color-@{value}-theme}';
-      img {
-        border-color: ~'@{color-@{value}-theme_2}';
-      }
+      // img {
+      //   border-color: ~'@{color-@{value}-theme_2-background_1}';
+      // }
     }
     .play-btn {
       color: ~'@{color-@{value}-theme}';

src/renderer/components/core/Toolbar.vue

@@ -2,7 +2,9 @@
   div(:class="$style.toolbar")
     //- img(v-if="icon")
     //- h1 {{title}}
-    material-search-input(:class="$style.input")
+    material-search-input(:class="$style.input"
+      @event="handleEvent" :list="tipList" :visibleList="visibleList"
+      v-model="searchText")
     div(:class="$style.control")
       button(type="button" :class="$style.min" title="最小化" @click="min")
       //- button(type="button" :class="$style.max" @click="max")
@@ -11,22 +13,93 @@
 
 <script>
 import { rendererSend } from 'common/icp'
-// import { mapGetters } from 'vuex'
+import { mapGetters } from 'vuex'
+import music from '../../utils/music'
+import { debounce } from '../../utils'
 export default {
-  // props: {
-  //   color: {
-  //     type: String,
-  //     default: color,
-  //   },
-  //   icon: {
-  //     type: Boolean,
-  //     default: false,
-  //   },
-  // },
+  data() {
+    return {
+      searchText: '',
+      visibleList: false,
+      tipList: [],
+      tipSearch: null,
+    }
+  },
   computed: {
-    // ...mapGetters(['theme']),
+    ...mapGetters(['route', 'setting']),
+    ...mapGetters('search', {
+      storeSearchText: 'searchText',
+    }),
+    source() {
+      return this.setting.search.tempSearchSource
+    },
+    isAutoClearInput() {
+      return this.setting.odc.isAutoClearSearchInput
+    },
+  },
+  watch: {
+    route(n) {
+      if (this.isAutoClearInput && n.name != 'search' && this.searchText) this.searchText = ''
+    },
+    'storeSearchText'(n) {
+      if (n !== this.searchText) this.searchText = n
+    },
+    searchText(n) {
+      this.handleTipSearch()
+    },
+  },
+  mounted() {
+    this.tipSearch = debounce(() => {
+      if (this.searchText === '') {
+        this.tipList.splice(0, this.tipList.length)
+        music[this.source].tempSearch.cancelTempSearch()
+        return
+      }
+      music[this.source].tempSearch.search(this.searchText).then(list => {
+        this.tipList = list
+      }).catch(() => {})
+    }, 50)
   },
   methods: {
+    handleEvent({ action, data }) {
+      switch (action) {
+        case 'focus':
+          if (!this.visibleList) this.visibleList = true
+          if (this.searchText) this.handleTipSearch()
+          break
+        case 'blur':
+          setTimeout(() => {
+            if (this.visibleList) this.visibleList = false
+          }, 50)
+          break
+        case 'submit':
+          this.handleSearch()
+          break
+        case 'listClick':
+          this.searchText = this.tipList[data]
+          this.$nextTick(() => {
+            this.handleSearch()
+          })
+      }
+    },
+
+    handleTipSearch() {
+      if (!this.visibleList) this.visibleList = true
+      this.tipSearch()
+    },
+
+    handleSearch() {
+      if (this.visibleList) this.visibleList = false
+      setTimeout(() => {
+        this.$router.push({
+          path: 'search',
+          query: {
+            text: this.searchText,
+          },
+        }).catch(_ => _)
+      }, 200)
+    },
+
     min() {
       rendererSend('min')
     },
@@ -48,7 +121,6 @@ export default {
   display: flex;
   height: @height-toolbar;
   justify-content: flex-end;
-  background-color: @color-theme_2;
   align-items: center;
   padding-left: 15px;
   -webkit-app-region: drag;
@@ -57,14 +129,10 @@ export default {
 }
 .input {
   -webkit-app-region: no-drag;
+  position: absolute;
+  left: 15px;
+  top: 13px;
 }
-each(@themes, {
-  :global(#container.@{value}) {
-    .toolbar {
-      background-color: ~'@{color-@{value}-theme_2}';
-    }
-  }
-})
 
 // img {
 //   flex: none;
@@ -88,7 +156,7 @@ each(@themes, {
       opacity: 1;
     }
   }
-  
+
   button {
     position: relative;
     width: @height-toolbar;
@@ -105,20 +173,14 @@ each(@themes, {
       content: ' ';
       display: block;
       border-radius: 50%;
-      width: 13px;
-      height: 13px;
+      width: 14px;
+      height: 14px;
       transition: background-color 0.2s ease-in-out;
     }
 
     &:before {
       display: block;
       position: absolute;
-      left: 50%;
-      top: 50%;
-      transform: translate(-50%, -50%);
-      font-size: 14px;
-      line-height: 1;
-      color: #fff;
       opacity: 0;
       transition: opacity @transition-theme;
     }
@@ -147,13 +209,23 @@ each(@themes, {
 }
 .min {
   &:before {
-    content: '－';
-    font-size: 15px;
+    content: ' ';
+    width: 8px;
+    height: 2px;
+    left: @height-toolbar / 2 - 4;
+    top: @height-toolbar / 2 - 1;
+    background-color: #fff;
   }
 }
 .close {
   &:before {
     content: '×';
+    left: 50%;
+    top: 50%;
+    transform: translate(-50%, -50%);
+    font-size: 14px;
+    line-height: 1;
+    color: #fff;
   }
 }
 </style>

src/renderer/components/core/View.vue

@@ -13,7 +13,6 @@ div(:class="$style.view")
 
 .view {
   position: relative;
-  background-color: @color-theme_2;
   > * {
     position: absolute;
     width: 100%;
@@ -22,12 +21,4 @@ div(:class="$style.view")
   // overflow: hidden;
 }
 
-each(@themes, {
-  :global(#container.@{value}) {
-    .view {
-      background-color: ~'@{color-@{value}-theme_2}';
-    }
-  }
-})
-
 </style>

src/renderer/components/material/Checkbox.vue

@@ -1,16 +1,16 @@
 <template lang="pug">
 div(:class="$style.checkbox")
-  input(:type="need ? 'radio' : 'checkbox'" :id="id" :disabled="disabled" :value="value" :name="name" @change="change" v-model="bool")
+  input(:type="need ? 'radio' : 'checkbox'" :class="$style.input" :id="id" :disabled="disabled" :value="value" :name="name" @change="change" v-model="bool")
   label(:for="id" :class="$style.content")
-    div(v-if="indeterminate")
-      svg(v-show="indeterminate" version='1.1' xmlns='http://www.w3.org/2000/svg' xlink='http://www.w3.org/1999/xlink' height='100%' width="100%" viewBox='0 32 448 448' space='preserve')
+    div(v-if="indeterminate" :class="$style.container")
+      svg(v-show="indeterminate" :class="$style.icon" version='1.1' xmlns='http://www.w3.org/2000/svg' xlink='http://www.w3.org/1999/xlink' height='100%' width="100%" viewBox='0 32 448 448' space='preserve')
         use(xlink:href='#icon-check-indeterminate')
-      svg(v-show="!indeterminate" version='1.1' xmlns='http://www.w3.org/2000/svg' xlink='http://www.w3.org/1999/xlink' height='100%' width="100%" viewBox='0 0 448 512' space='preserve')
+      svg(v-show="!indeterminate" :class="$style.icon" version='1.1' xmlns='http://www.w3.org/2000/svg' xlink='http://www.w3.org/1999/xlink' height='100%' width="100%" viewBox='0 0 448 512' space='preserve')
         use(xlink:href='#icon-check-true')
-    div(v-else)
-      svg(version='1.1' xmlns='http://www.w3.org/2000/svg' xlink='http://www.w3.org/1999/xlink' height='100%' width="100%" viewBox='0 32 448 448' space='preserve')
+    div(v-else :class="$style.container")
+      svg(version='1.1' :class="$style.icon" xmlns='http://www.w3.org/2000/svg' xlink='http://www.w3.org/1999/xlink' height='100%' width="100%" viewBox='0 32 448 448' space='preserve')
         use(xlink:href='#icon-check-true')
-    span(v-if="label != null" v-html="label")
+    span(v-if="label != null" v-html="label" :class="$style.label")
 </template>
 
 <script>
@@ -73,9 +73,9 @@ export default {
         let bool = this.bool
         if (this.indeterminate) {
           bool = true
-          this.$nextTick(() => {
-            this.bool = true
-          })
+          // this.$nextTick(() => {
+          this.bool = true
+          // })
         }
         checked = bool
       }
@@ -113,25 +113,25 @@ export default {
   display: inline-block;
   // font-size: 56px;
 
-  > input {
-    display: none;
-    &[disabled] {
-      + .content {
-        opacity: .5;
-      }
+}
+.input {
+  display: none;
+  &[disabled] {
+    + .content {
+      opacity: .5;
     }
-    &:checked {
-      + .content {
-        > div {
-          &:after {
-            border-color: @color-theme;
-          }
-          svg {
-            transform: scale(1);
-            opacity: 1;
-          }
+  }
+  &:checked {
+    + .content {
+      .container {
+        &:after {
+          border-color: @color-theme;
         }
       }
+      .icon {
+        transform: scale(1);
+        // opacity: 1;
+      }
     }
   }
 }
@@ -139,41 +139,41 @@ export default {
   display: flex;
   justify-content: center;
 
-  > div {
-    flex: none;
-    position: relative;
-    display: inline-block;
-    width: 1em;
-    height: 1em;
-    cursor: pointer;
-    display: flex;
-    color: @color-theme;
-    // border: 1px solid #ccc;
-    &:after {
-      position: absolute;
-      content: ' ';
-      top: 0;
-      bottom: 0;
-      left: 0;
-      right: 0;
-      border: 1px solid #ccc;
-      transition: border-color 0.2s ease;
-      border-radius: 15%;
-    }
-    svg {
-      transition: 0.2s ease;
-      transition-property: transform, opacity;
-      transform: scale(0.5);
-      opacity: 0;
-    }
+}
+.container {
+  flex: none;
+  position: relative;
+  display: inline-block;
+  width: 1em;
+  height: 1em;
+  cursor: pointer;
+  display: flex;
+  color: @color-theme;
+  // border: 1px solid #ccc;
+  &:after {
+    position: absolute;
+    content: ' ';
+    top: 0;
+    bottom: 0;
+    left: 0;
+    right: 0;
+    border: 1px solid @color-theme_2-font-label;
+    transition: border-color 0.2s ease;
+    border-radius: 15%;
   }
+}
+.icon {
+  transition: 0.3s ease;
+  transition-property: transform;
+  transform: scale(0);
+  // opacity: 0;
+}
 
-  > span {
-    flex: auto;
-    line-height: 1;
-    margin-left: 5px;
-    cursor: pointer;
-  }
+.label {
+  flex: auto;
+  line-height: 1;
+  margin-left: 5px;
+  cursor: pointer;
 }
 
 each(@themes, {
@@ -182,7 +182,7 @@ each(@themes, {
       > input {
         &:checked {
           + .content {
-            > div {
+            .container {
               &:after {
                 border-color: ~'@{color-@{value}-theme}';
               }
@@ -192,11 +192,11 @@ each(@themes, {
       }
     }
     .content {
-      > div {
+      .container {
         color: ~'@{color-@{value}-theme}';
         // border: 1px solid #ccc;
         &:after {
-          border-color: #ccc;
+          border-color: ~'@{color-@{value}-theme_2-font-label}';
         }
       }
     }

src/renderer/components/material/DownloadModal.vue

@@ -5,7 +5,7 @@ material-modal(:show="show" :bg-close="bgClose" @close="handleClose")
       | {{ info.name }}
       br
       | {{ info.singer }}
-    material-btn(:class="$style.btn" :title="!checkSource(type.type) && '目前网易云音源仅支持下载128k音质'" :disabled="!checkSource(type.type)" :key="type.type" @click="handleClick(type.type)" v-for="type in info.types") {{getTypeName(type.type)}} {{ type.type.toUpperCase() }}{{ type.size && ` - ${type.size.toUpperCase()}` }}
+    material-btn(:class="$style.btn" :title="!checkSource(type.type) && '腾讯、网易音源仅支持下载128k音质'" :disabled="!checkSource(type.type)" :key="type.type" @click="handleClick(type.type)" v-for="type in info.types") {{getTypeName(type.type)}} {{ type.type.toUpperCase() }}{{ type.size && ` - ${type.size.toUpperCase()}` }}
 
 </template>
 
@@ -52,7 +52,7 @@ export default {
     checkSource(type) {
       switch (this.musicInfo.source) {
         case 'wy':
-        // case 'kg':
+        case 'tx':
           return type == '128k'
 
         default:

src/renderer/components/material/DownloadMultipleModal.vue

@@ -7,7 +7,7 @@ material-modal(:show="show" :bg-close="bgClose" @close="handleClose")
       | 请选择要优先下载的音质
     material-btn(:class="$style.btn" @click="handleClick('128k')") 普通音质 - 128K
     material-btn(:class="$style.btn" @click="handleClick('320k')") 高品音质 - 320K
-    material-btn(:class="$style.btn" @click="handleClick('ape')") 无损音质 - APE
+    //- material-btn(:class="$style.btn" @click="handleClick('ape')") 无损音质 - APE
     material-btn(:class="$style.btn" @click="handleClick('flac')") 无损音质 - FLAC
 </template>
 

src/renderer/components/material/Input.vue

@@ -0,0 +1,90 @@
+<template lang="pug">
+  input(:class="$style.input" :type="type" :placeholder="placeholder" v-model.trim="text" :disabled="disabled"
+    @focus="$emit('focus', $event)" @blur="$emit('blur', $event)" @input="$emit('input', text)" @change="$emit('change', text)"
+    @keyup.enter="submit")
+</template>
+
+<script>
+export default {
+  props: {
+    placeholder: {
+      type: String,
+      default: '',
+    },
+    disabled: {
+      type: Boolean,
+      default: false,
+    },
+    value: {
+      type: String,
+      default: '',
+    },
+    type: {
+      type: String,
+      default: 'text',
+    },
+  },
+  data() {
+    return {
+      text: '',
+    }
+  },
+  watch: {
+    value(n) {
+      this.text = n
+    },
+  },
+  methods: {
+    handleInput() {
+
+    },
+  },
+}
+</script>
+
+
+<style lang="less" module>
+@import '../../assets/styles/layout.less';
+
+.input {
+  display: inline-block;
+  border: none;
+  border-radius: 3px;
+  padding: 7px 8px;
+  color: @color-btn;
+  outline: none;
+  transition: background-color 0.2s ease;
+  background-color: @color-btn-background;
+  &[disabled] {
+    opacity: .4;
+  }
+
+  &:hover, &:focus {
+    background-color: @color-theme_2-hover;
+  }
+  &:active {
+    background-color: @color-theme_2-active;
+  }
+}
+
+.min {
+  padding: 3px 8px;
+  font-size: 12px;
+}
+
+each(@themes, {
+  :global(#container.@{value}) {
+    .input {
+      color: ~'@{color-@{value}-btn}';
+      background-color: ~'@{color-@{value}-btn-background}';
+      &:hover, &:focus {
+        background-color: ~'@{color-@{value}-theme_2-hover}';
+      }
+      &:active {
+        background-color: ~'@{color-@{value}-theme_2-active}';
+      }
+    }
+  }
+})
+
+</style>

src/renderer/components/material/ListButtons.vue

@@ -3,6 +3,9 @@ div(:class="$style.btns")
   button(type="button" v-if="playBtn" title="播放" @click.stop="handleClick('play')")
     svg(version='1.1' xmlns='http://www.w3.org/2000/svg' xlink='http://www.w3.org/1999/xlink' height='100%' viewBox='0 0 287.386 287.386' space='preserve')
       use(xlink:href='#icon-testPlay')
+  button(type="button" v-if="listAddBtn" title="添加到..." @click.stop="handleClick('listAdd')")
+    svg(version='1.1' xmlns='http://www.w3.org/2000/svg' xlink='http://www.w3.org/1999/xlink' height='100%' viewBox='0 0 42 42' space='preserve')
+      use(xlink:href='#icon-addTo')
   button(type="button" v-if="downloadBtn" title="下载" @click.stop="handleClick('download')")
     svg(version='1.1' xmlns='http://www.w3.org/2000/svg' xlink='http://www.w3.org/1999/xlink' height='100%' viewBox='0 0 475.078 475.077' space='preserve')
       use(xlink:href='#icon-download')
@@ -56,6 +59,10 @@ export default {
       type: Boolean,
       default: true,
     },
+    listAddBtn: {
+      type: Boolean,
+      default: true,
+    },
     searchBtn: {
       type: Boolean,
       default: false,

src/renderer/components/material/Modal.vue

@@ -134,7 +134,7 @@ export default {
   flex-flow: column nowrap;
 
   > * {
-    background-color: @color-theme_2;
+    background-color: @color-theme_2-background_2;
   }
 }
 
@@ -176,7 +176,7 @@ each(@themes, {
     .content {
       box-shadow: 0 0 3px rgba(0, 0, 0, .3);
       > * {
-        background-color: ~'@{color-@{value}-theme_2}';
+        background-color: ~'@{color-@{value}-theme_2-background_2}';
       }
     }
 

src/renderer/components/material/SearchInput.vue

@@ -1,31 +1,54 @@
 <template lang="pug">
-div(:class="[$style.search, focus ? $style.active : '']")
+div(:class="[$style.search, focus ? $style.active : '', big ? $style.big : '', small ? $style.small : '']")
   div(:class="$style.form")
-    input(placeholder="Search for something..." v-model.trim="text"
-          @focus="handleFocus" @blur="handleBlur" @input="handleInput"
+    input(:placeholder="placeholder" v-model.trim="text"
+          @focus="handleFocus" @blur="handleBlur" @input="$emit('input', text)"
+          @change="sendEvent('change')"
           @keyup.enter="handleSearch")
     button(type="button" @click="handleSearch")
-      svg(version='1.1' xmlns='http://www.w3.org/2000/svg' xlink='http://www.w3.org/1999/xlink' height='100%' viewBox='0 0 30.239 30.239' space='preserve')
-        use(xlink:href='#icon-search')
+      slot
+        svg(version='1.1' xmlns='http://www.w3.org/2000/svg' xlink='http://www.w3.org/1999/xlink' height='100%' viewBox='0 0 30.239 30.239' space='preserve')
+          use(xlink:href='#icon-search')
   //- transition(name="custom-classes-transition"
   //-             enter-active-class="animated flipInX"
   //-             leave-active-class="animated flipOutX")
-  div(:class="$style.list" :style="listStyle")
+  div(v-if="list" :class="$style.list" :style="listStyle")
     ul(ref="dom_list")
       li(v-for="(item, index) in list" :key="item" @click="handleTemplistClick(index)")
         span {{item}}
 </template>
 
 <script>
-import { mapGetters } from 'vuex'
-import music from '../../utils/music'
-
 export default {
+  props: {
+    placeholder: {
+      type: String,
+      default: 'Search for something...',
+    },
+    list: {
+      type: Array,
+    },
+    visibleList: {
+      type: Boolean,
+      default: false,
+    },
+    value: {
+      type: String,
+      default: '',
+    },
+    big: {
+      type: Boolean,
+      default: false,
+    },
+    small: {
+      type: Boolean,
+      default: false,
+    },
+  },
   data() {
     return {
       isShow: false,
       text: '',
-      list: [],
       index: null,
       focus: false,
       listStyle: {
@@ -33,55 +56,35 @@ export default {
       },
     }
   },
-  computed: {
-    ...mapGetters(['source']),
-    ...mapGetters('search', ['info']),
-  },
   watch: {
     list(n) {
+      if (!this.visibleList) return
       this.$nextTick(() => {
         this.listStyle.height = this.$refs.dom_list.scrollHeight + 'px'
       })
     },
-    'info.text'(n) {
-      if (n !== this.text) this.text = n
+    value(n) {
+      this.text = n
+    },
+    visibleList(n) {
+      n ? this.showList() : this.hideList()
     },
   },
   methods: {
     handleTemplistClick(index) {
-      this.text = this.list[index]
-      this.handleSearch()
+      this.sendEvent('listClick', index)
     },
     handleFocus() {
       this.focus = true
-      if (this.text) this.handleInput()
-      this.showList()
+      this.sendEvent('focus')
     },
     handleBlur() {
-      setTimeout(() => {
-        this.focus = false
-        this.hideList()
-      }, 200)
+      this.focus = false
+      this.sendEvent('blur')
     },
     handleSearch() {
       this.hideList()
-      this.$router.push({
-        path: 'search',
-        query: {
-          text: this.text,
-        },
-      })
-    },
-    handleInput() {
-      if (this.text === '') {
-        this.list.splice(0, this.list.length)
-        music[this.source.id].tempSearch.cancelTempSearch()
-        return
-      }
-      if (!this.isShow) this.showList()
-      music[this.source.id].tempSearch.search(this.text).then(list => {
-        this.list = list
-      }).catch(() => {})
+      this.sendEvent('submit')
     },
     showList() {
       this.isShow = true
@@ -91,6 +94,12 @@ export default {
       this.isShow = false
       this.listStyle.height = 0
     },
+    sendEvent(action, data) {
+      this.$emit('event', {
+        action,
+        data,
+      })
+    },
   },
 }
 </script>
@@ -100,9 +109,6 @@ export default {
 @import '../../assets/styles/layout.less';
 
 .search {
-  position: absolute;
-  left: 15px;
-  top: 13px;
   border-radius: 3px;
   transition: box-shadow .4s ease, background-color @transition-theme;
   display: flex;
@@ -192,6 +198,19 @@ export default {
   }
 }
 
+.big {
+  width: 500px;
+  // input {
+  //   line-height: 30px;
+  // }
+  .form {
+    height: 30px;
+    button {
+      padding: 6px 10px;
+    }
+  }
+}
+
 each(@themes, {
   :global(#container.@{value}) {
 

src/renderer/components/material/Select.vue

@@ -1,7 +1,7 @@
 <template lang="pug">
-  div(:class="$style.select")
+  div(:class="[$style.select, show ? $style.active : '']")
     div(:class="$style.label" ref="dom_btn" @click="handleShow") {{value ? itemName ? list.find(l => l.id == value).name : value : ''}}
-    ul(:class="$style.list" ref="dom_list" :style="listStyle")
+    ul(:class="$style.list")
       li(v-for="item in list" @click="handleClick(itemKey ? item[itemKey] : item)") {{itemName ? item[itemName] : item}}
 </template>
 
@@ -28,25 +28,8 @@ export default {
   data() {
     return {
       show: false,
-      listStyle: {
-        height: 0,
-        opacity: 0,
-      },
     }
   },
-  watch: {
-    show(n) {
-      this.$nextTick(() => {
-        if (n) {
-          this.listStyle.height = this.$refs.dom_list.scrollHeight + 'px'
-          this.listStyle.opacity = 1
-        } else {
-          this.listStyle.height = 0
-          this.listStyle.opacity = 0
-        }
-      })
-    },
-  },
   mounted() {
     document.addEventListener('click', this.handleHide)
   },
@@ -80,6 +63,13 @@ export default {
 .select {
   font-size: 12px;
   position: relative;
+
+  &.active {
+    .list {
+      transform: scaleY(1);
+      opacity: 1;
+    }
+  }
 }
 
 .label {
@@ -90,7 +80,7 @@ export default {
   border-left: 2px solid @color-tab-border-bottom;
   box-sizing: border-box;
   text-align: center;
-  border-top-left-radius: 3px;
+  border-top-left-radius: 4px;
   color: @color-btn;
   cursor: pointer;
 
@@ -108,12 +98,13 @@ export default {
   left: 0;
   border-bottom: 2px solid @color-tab-border-bottom;
   border-left: 2px solid @color-tab-border-bottom;
-  border-bottom-left-radius: 3px;
-  background-color: @color-theme_2;
-  overflow: hidden;
+  border-bottom-left-radius: 4px;
+  background-color: @color-theme_2-background_2;
   opacity: 0;
+  transform: scaleY(0);
+  transform-origin: 0 0 0;
   transition: .25s ease;
-  transition-property: height, opacity;
+  transition-property: transform, opacity;
   z-index: 10;
 
   li {
@@ -153,6 +144,7 @@ each(@themes, {
     .list {
       border-bottom-color: ~'@{color-@{value}-tab-border-bottom}';
       border-left-color: ~'@{color-@{value}-tab-border-bottom}';
+      background-color: ~'@{color-@{value}-theme_2-background_2}';
       li {
         // color: ~'@{color-@{value}-btn}';
         background-color: ~'@{color-@{value}-btn-background}';

src/renderer/components/material/SongList.vue

@@ -11,8 +11,8 @@ div(:class="$style.songList")
                   :indeterminate="isIndeterminate" :title="isSelectAll && !isIndeterminate ? '全不选' : '全选'")
               th.nobreak(style="width: 25%;") 歌曲名
               th.nobreak(style="width: 20%;") 歌手
-              th.nobreak(style="width: 22%;") 专辑
-              th.nobreak(style="width: 18%;") 操作
+              th.nobreak(style="width: 20%;") 专辑
+              th.nobreak(style="width: 20%;") 操作
               th.nobreak(style="width: 10%;") 时长
       div.scroll(:class="$style.tbody" ref="dom_scrollContent")
         table
@@ -25,9 +25,13 @@ div(:class="$style.songList")
                 span.badge.badge-info(v-if="item._types['320k']") 高品质
                 span.badge.badge-success(v-if="item._types.ape || item._types.flac") 无损
               td.break(style="width: 20%;") {{item.singer}}
-              td.break(style="width: 22%;") {{item.albumName}}
-              td(style="width: 18%;")
-                material-list-buttons(:index="index" :search-btn="true" :play-btn="item.source == 'kw' || (!isAPITemp && item.source != 'tx')" :download-btn="item.source == 'kw' || (!isAPITemp && item.source != 'tx')" :remove-btn="false" @btn-click="handleListBtnClick")
+              td.break(style="width: 20%;") {{item.albumName}}
+              td(style="width: 20%; padding-left: 0; padding-right: 0;")
+                material-list-buttons(:index="index" :search-btn="true"
+                  :remove-btn="false" @btn-click="handleListBtnClick"
+                  :listAdd-btn="item.source == 'kw' || (!isAPITemp)"
+                  :play-btn="item.source == 'kw' || (!isAPITemp)"
+                  :download-btn="item.source == 'kw' || (!isAPITemp)")
                 //- button.btn-info(type='button' v-if="item._types['128k'] || item._types['192k'] || item._types['320k'] || item._types.flac" @click.stop='openDownloadModal(index)') 下载
                 //- button.btn-secondary(type='button' v-if="item._types['128k'] || item._types['192k'] || item._types['320k']" @click.stop='testPlay(index)') 试听
                 //- button.btn-success(type='button' v-if="(item._types['128k'] || item._types['192k'] || item._types['320k']) && userInfo" @click.stop='showListModal(index)') ＋
@@ -136,7 +140,7 @@ export default {
         this.clickIndex = index
         return
       }
-      this.emitEvent((this.source == 'kw' || (!this.isAPITemp && this.list[index].source != 'tx')) ? 'testPlay' : 'search', index)
+      this.emitEvent((this.source == 'kw' || !this.isAPITemp) ? 'testPlay' : 'search', index)
       this.clickTime = 0
       this.clickIndex = -1
     },
@@ -175,7 +179,6 @@ export default {
   height: 100%;
   display: flex;
   flex-flow: column nowrap;
-  background-color: @color-theme_2;
 }
 
 .list {
@@ -220,16 +223,17 @@ export default {
 
   p {
     font-size: 24px;
-    color: #ccc;
+    color: @color-theme_2-font-label;
   }
 }
 
 each(@themes, {
   :global(#container.@{value}) {
-    .thead {
-      background-color: ~'@color-@{value}-theme_2';
+    .noitem {
+      p {
+        color: ~'@{color-@{value}-theme_2-font-label}';
+      }
     }
   }
 })
-
 </style>

src/renderer/components/material/Tab.vue

@@ -95,15 +95,15 @@ export default {
         margin-left: 0;
         button {
           border-top-left-radius: 3px;
-          // border-bottom-left-radius: 3px;
+          // border-bottom-left-radius: 4px;
         }
       }
       &:last-child {
         border-right: 2px solid @color-tab-border-top;
-        border-top-right-radius: 3px;
+        border-top-right-radius: 4px;
         button {
           border-top-right-radius: 3px;
-          // border-bottom-right-radius: 3px;
+          // border-bottom-right-radius: 4px;
         }
       }
       button {
@@ -122,7 +122,7 @@ export default {
         // border-left-color: @color-theme_2-hover;
         // border-right-color: @color-theme_2-hover;
         button {
-          background-color: @color-theme_2-hover;
+          background-color: @color-tab-btn-background-hover;
         }
       }
       &:active {
@@ -133,7 +133,7 @@ export default {
         }
       }
       &.active {
-        border-bottom-color: @color-theme_2;
+        border-bottom-color: @color-theme_2-background_1;
         border-top-color: @color-tab-border-bottom;
         border-left-color: @color-tab-border-bottom;
         border-right-color: @color-tab-border-bottom;
@@ -144,7 +144,7 @@ export default {
           width: 0;
         }
         button {
-          background-color: @color-theme_2;
+          background-color: @color-theme_2-background_1;
         }
       }
     }
@@ -193,7 +193,7 @@ each(@themes, {
             // border-left-color: ~'@{color-@{value}-theme_2-hover}';
             // border-right-color: ~'@{color-@{value}-theme_2-hover}';
             button {
-              background-color: ~'@{color-@{value}-theme_2-hover}';
+              background-color: ~'@{color-@{value}-tab-btn-background-hover}';
             }
           }
           &:active {
@@ -209,7 +209,7 @@ each(@themes, {
             border-left-color: ~'@{color-@{value}-tab-border-bottom}';
             border-right-color: ~'@{color-@{value}-tab-border-bottom}';
             button {
-              background-color: ~'@{color-@{value}-theme_2}';
+              background-color: ~'@{color-@{value}-theme_2-background_1}';
             }
           }
         }

src/renderer/components/material/TagList.vue

@@ -1,7 +1,11 @@
 <template lang="pug">
-  div(:class="$style.tagList")
-    div(:class="$style.label" ref="dom_btn" @click="handleShow") {{value.name}}
-    div.scroll(:class="$style.list" @click.stop ref="dom_list" :style="listStyle")
+  div(:class="[$style.tagList, show ? $style.active : '']")
+    div(:class="$style.label" ref="dom_btn" @click="handleShow")
+      span {{value.name}}
+      div(:class="$style.icon")
+        svg(version='1.1' xmlns='http://www.w3.org/2000/svg' xlink='http://www.w3.org/1999/xlink' height='100%' viewBox='0 0 451.847 451.847' space='preserve')
+          use(xlink:href='#icon-down')
+    div.scroll(:class="$style.list" @click.stop ref="dom_list")
       div(:class="$style.tag" @click="handleClick(null)") 默认
       dl(v-for="type in list")
         dt(:class="$style.type") {{type.name}}
@@ -9,7 +13,7 @@
 </template>
 
 <script>
-// import { isChildren } from '../../utils'
+import { isChildren } from '../../utils'
 export default {
   props: {
     list: {
@@ -25,30 +29,8 @@ export default {
   data() {
     return {
       show: false,
-      listStyle: {
-        height: 0,
-        opacity: 0,
-      },
     }
   },
-  watch: {
-    show(n) {
-      this.$nextTick(() => {
-        if (n) {
-          let sh = this.$refs.dom_list.scrollHeight
-          this.listStyle.height = (sh > 250 ? 250 : sh) + 'px'
-          this.listStyle.opacity = 1
-          this.listStyle.overflow = 'auto'
-        } else {
-          this.listStyle.height = 0
-          this.listStyle.opacity = 0
-        }
-      })
-    },
-    list() {
-      this.$refs.dom_list.scrollTop = 0
-    },
-  },
   mounted() {
     document.addEventListener('click', this.handleHide)
   },
@@ -58,7 +40,7 @@ export default {
   methods: {
     handleHide(e) {
       // if (e && e.target.parentNode != this.$refs.dom_list && this.show) return this.show = false
-      if (e && e.target == this.$refs.dom_btn) return
+      if (e && (e.target == this.$refs.dom_btn || isChildren(this.$refs.dom_btn, e.target))) return
       setTimeout(() => {
         this.show = false
       }, 50)
@@ -89,6 +71,20 @@ export default {
 .tag-list {
   font-size: 12px;
   position: relative;
+
+  &.active {
+    .label {
+      .icon {
+        svg{
+          transform: rotate(180deg);
+        }
+      }
+    }
+    .list {
+      opacity: 1;
+      transform: scaleY(1);
+    }
+  }
 }
 
 .label {
@@ -103,6 +99,22 @@ export default {
   color: @color-btn;
   cursor: pointer;
 
+  display: flex;
+
+  span {
+    flex: auto;
+  }
+  .icon {
+    flex: none;
+    margin-left: 7px;
+    line-height: 0;
+    svg {
+      width: 1em;
+      transition: transform .2s ease;
+      transform: rotate(0);
+    }
+  }
+
   &:hover {
     background-color: @color-theme_2-hover;
   }
@@ -119,11 +131,14 @@ export default {
   border-bottom: 2px solid @color-tab-border-bottom;
   border-right: 2px solid @color-tab-border-bottom;
   border-bottom-right-radius: 5px;
-  background-color: @color-theme_2;
-  overflow: hidden;
+  background-color: @color-theme_2-background_2;
   opacity: 0;
+  transform: scaleY(0);
+  overflow-y: auto;
+  transform-origin: 0 0 0;
+  max-height: 250px;
   transition: .25s ease;
-  transition-property: height, opacity;
+  transition-property: transform, opacity;
   z-index: 10;
   padding: 10px;
   box-sizing: border-box;
@@ -187,6 +202,7 @@ each(@themes, {
     .list {
       border-bottom-color: ~'@{color-@{value}-tab-border-bottom}';
       border-right-color: ~'@{color-@{value}-tab-border-bottom}';
+      background-color: ~'@{color-@{value}-theme_2-background_2}';
       // border-left-color: ~'@{color-@{value}-tab-border-bottom}';
       li {
         // color: ~'@{color-@{value}-btn}';

src/renderer/components/material/VersionModal.vue

@@ -17,17 +17,19 @@ material-modal(:show="version.showModal" @close="handleClose")
 
     div(:class="$style.footer" v-if="version.isError")
       div(:class="$style.desc" v-if="!isUnknow")
-        p 发现有新版本啦，但是自动更新功能出问题了
-        p
-          | 如果你所用的软件是
-          strong 安装版
-          | ，可以到QQ群：830125506 反馈哦
+        p 发现有新版本啦，但是自动更新功能出问题了，
         p
           | 你现在可以选择继续使用当前版本或
           strong 去发布页下载新版本
+          | ，
+        p
+          | 国内Windows/MAC用户推荐到
+          strong.hover.underline(@click="handleOpenUrl('https://www.lanzous.com/b906260/')") 网盘(点击打开)
+          | 下载，密码：
+          strong.hover(@click="handleCopy('glqw')" title="点击复制") glqw
       div(:class="$style.btns")
         material-btn(:class="$style.btn" @click.onec="handleIgnoreClick") 忽略该版本
-        material-btn(:class="$style.btn" @click.onec="handleOpenPageClick") 去下载新版本
+        material-btn(:class="$style.btn" @click.onec="handleOpenUrl('https://github.com/lyswhut/lx-music-desktop#readme')") 去软件发布页
     div(:class="$style.footer" v-else)
       div(:class="$style.desc")
         p 新版本已下载完毕，
@@ -44,7 +46,7 @@ material-modal(:show="version.showModal" @close="handleClose")
 <script>
 import { mapGetters, mapMutations } from 'vuex'
 import { rendererSend } from '../../../common/icp'
-import { checkVersion, openUrl } from '../../utils'
+import { checkVersion, openUrl, clipboardWriteText } from '../../utils'
 
 export default {
   computed: {
@@ -75,14 +77,17 @@ export default {
       // event.target.disabled = true
       this.setSetting(Object.assign({}, this.setting, { ignoreVersion: this.version.newVersion.version }))
     },
-    handleOpenPageClick() {
-      openUrl('https://github.com/lyswhut/lx-music-desktop')
+    handleOpenUrl(url) {
+      openUrl(url)
     },
     handleRestartClick(event) {
       this.handleClose()
       event.target.disabled = true
       rendererSend('quit-update')
     },
+    handleCopy(text) {
+      clipboardWriteText(text)
+    },
   },
 }
 </script>
@@ -124,6 +129,7 @@ export default {
   line-height: 1.5;
   overflow-y: auto;
   height: 100%;
+  padding-right: 5px;
 }
 .current {
   > p {
@@ -170,12 +176,9 @@ export default {
   flex: 0 0 none;
   .desc {
     font-size: 12px;
-    padding: 10px 0;
+    padding-top: 10px;
     color: @color-theme;
     line-height: 1.2;
-    strong {
-      text-decoration: underline;
-    }
   }
 }
 .btn {
@@ -184,6 +187,7 @@ export default {
 }
 .btns {
   display: grid;
+  padding-top: 10px;
   grid-template-columns: 1fr 1fr;
   grid-gap: 0 10px;
 }

src/renderer/components/material/listAddModal.vue

@@ -0,0 +1,103 @@
+<template lang="pug">
+material-modal(:show="show" :bg-close="bgClose" @close="handleClose")
+  main(:class="$style.main")
+    h2
+      | 添加&nbsp;
+      span(:class="$style.name") {{this.musicInfo && `${musicInfo.name}`}}
+      | &nbsp;到...
+    material-btn(:class="$style.btn" :title="`把该歌曲添加到 ${item.name}`" :key="item.id" @click="handleClick(index)" v-for="(item, index) in lists") {{item.name}}
+</template>
+
+<script>
+import { mapGetters, mapMutations } from 'vuex'
+export default {
+  props: {
+    show: {
+      type: Boolean,
+      default: false,
+    },
+    musicInfo: {
+      type: Object,
+    },
+    bgClose: {
+      type: Boolean,
+      default: true,
+    },
+    excludeListId: {
+      type: Array,
+      default() {
+        return []
+      },
+    },
+  },
+  computed: {
+    ...mapGetters('list', ['defaultList', 'loveList', 'userList']),
+    lists() {
+      return [
+        this.defaultList,
+        this.loveList,
+        ...this.userList,
+      ].filter(l => !this.excludeListId.includes(l.id))
+    },
+  },
+  methods: {
+    ...mapMutations('list', ['listAdd']),
+    handleClick(index) {
+      this.listAdd({ id: this.lists[index].id, musicInfo: this.musicInfo })
+      this.$nextTick(() => {
+        this.handleClose()
+      })
+    },
+    handleClose() {
+      this.$emit('close')
+    },
+  },
+}
+</script>
+
+
+<style lang="less" module>
+@import '../../assets/styles/layout.less';
+
+.main {
+  padding: 15px;
+  max-width: 300px;
+  min-width: 200px;
+  display: flex;
+  flex-flow: column nowrap;
+  justify-content: center;
+  h2 {
+    font-size: 13px;
+    color: @color-theme_2-font;
+    line-height: 1.3;
+    text-align: center;
+    margin-bottom: 15px;
+  }
+}
+
+.name {
+  color: @color-theme;
+}
+
+.btn {
+  display: block;
+  margin-bottom: 15px;
+  &:last-child {
+    margin-bottom: 0;
+  }
+}
+
+each(@themes, {
+  :global(#container.@{value}) {
+    .main {
+      h2 {
+        color: ~'@{color-@{value}-theme_2-font}';
+      }
+    }
+    .name {
+      color: ~'@{color-@{value}-theme}';
+    }
+  }
+})
+
+</style>

src/renderer/components/material/listAddMultipleModal.vue

@@ -0,0 +1,97 @@
+<template lang="pug">
+material-modal(:show="show" :bg-close="bgClose" @close="handleClose")
+  main(:class="$style.main")
+    h2 添加已选的 {{musicList.length}} 首歌曲到...
+    material-btn(:class="$style.btn" :title="`把该歌曲添加到 ${item.name}`" :key="item.id" @click="handleClick(index)" v-for="(item, index) in lists") {{item.name}}
+</template>
+
+<script>
+import { mapGetters, mapMutations } from 'vuex'
+export default {
+  props: {
+    show: {
+      type: Boolean,
+      default: false,
+    },
+    musicList: {
+      type: Array,
+      default() {
+        return []
+      },
+    },
+    bgClose: {
+      type: Boolean,
+      default: true,
+    },
+    excludeListId: {
+      type: Array,
+      default() {
+        return []
+      },
+    },
+  },
+  computed: {
+    ...mapGetters('list', ['defaultList', 'loveList', 'userList']),
+
+    lists() {
+      return [
+        this.defaultList,
+        this.loveList,
+        ...this.userList,
+      ].filter(l => !this.excludeListId.includes(l.id))
+    },
+  },
+  methods: {
+    ...mapMutations('list', ['listAddMultiple']),
+    handleClick(index) {
+      this.listAddMultiple({ id: this.lists[index].id, list: this.musicList })
+      this.$nextTick(() => {
+        this.handleClose(true)
+      })
+    },
+    handleClose(isSelect = false) {
+      this.$emit('close', isSelect)
+    },
+  },
+}
+</script>
+
+
+<style lang="less" module>
+@import '../../assets/styles/layout.less';
+
+.main {
+  padding: 15px;
+  max-width: 300px;
+  min-width: 200px;
+  display: flex;
+  flex-flow: column nowrap;
+  justify-content: center;
+  h2 {
+    font-size: 13px;
+    color: @color-theme_2-font;
+    line-height: 1.3;
+    text-align: center;
+    margin-bottom: 15px;
+  }
+}
+
+.btn {
+  display: block;
+  margin-bottom: 15px;
+  &:last-child {
+    margin-bottom: 0;
+  }
+}
+
+each(@themes, {
+  :global(#container.@{value}) {
+    .main {
+      h2 {
+        color: ~'@{color-@{value}-theme_2-font}';
+      }
+    }
+  }
+})
+
+</style>

src/renderer/main.js

@@ -1,5 +1,5 @@
 import Vue from 'vue'
-// import { sync } from 'vuex-router-sync'
+import { sync } from 'vuex-router-sync'
 
 // Components
 import './components'
@@ -11,7 +11,7 @@ import App from './App'
 import router from './route'
 import store from './store'
 
-// sync(store, router)
+sync(store, router)
 
 if (!process.env.IS_WEB) {
 

src/renderer/store/actions.js

@@ -3,15 +3,17 @@ import { httpGet } from '../utils/request'
 import { author, name } from '../../../package.json'
 
 export default {
-  getVersionInfo() {
+  getVersionInfo(state, retryNum = 0) {
     return new Promise((resolve, reject) => {
-      httpGet(`https://raw.githubusercontent.com/${author.name}/${name}/master/publish/version.json`, (err, resp, body) => {
+      httpGet(`https://raw.githubusercontent.com/${author.name}/${name}/master/publish/version.json`, {
+        timeout: 20000,
+      }, (err, resp, body) => {
         if (err) {
-          return resolve({
+          return ++retryNum > 3 ? resolve({
             version: '0.0.0',
             desc: '<h3>版本信息获取失败</h3><ul><li>更新信息获取失败，可能是无法访问Github导致的，请手动检查更新！</li><li>检查方法：去设置-关于洛雪音乐打开<strong>开源地址</strong>或<strong>网盘地址</strong>查看<strong>版本号</strong>与当前版本对比是否最新</li></ul>',
             history: [],
-          })
+          }) : this.dispatch('getVersionInfo', retryNum).then(ver => resolve(ver))
         }
         resolve(body)
       })

src/renderer/store/getters.js

@@ -31,4 +31,7 @@ export default {
   version(state) {
     return state.version
   },
+  route(state) {
+    return state.route
+  },
 }

src/renderer/store/modules/download.js

@@ -22,6 +22,8 @@ const state = {
 const dls = {}
 const tryNum = {}
 
+const filterFileName = /[\\/:*?#"<>|]/g
+
 // getters
 const getters = {
   list: state => state.list || [],
@@ -73,6 +75,12 @@ const addTask = (list, type, store) => {
 
 const getUrl = (downloadInfo, isRefresh) => {
   const url = downloadInfo.musicInfo.typeUrl[downloadInfo.type]
+  if (!downloadInfo.musicInfo._types[downloadInfo.type]) {
+    // 兼容旧版酷我源搜索列表过滤128k音质的bug
+    if (!(downloadInfo.musicInfo.source == 'kw' && downloadInfo.type == '128k')) return Promise.reject(new Error('该歌曲没有可下载的音频'))
+
+    // return Promise.reject(new Error('该歌曲没有可下载的音频'))
+  }
   return url && !isRefresh ? Promise.resolve({ url }) : music[downloadInfo.musicInfo.source].getMusicUrl(downloadInfo.musicInfo, downloadInfo.type).promise
 }
 
@@ -83,7 +91,7 @@ const getUrl = (downloadInfo, isRefresh) => {
  * @param {*} isEmbedPic
  */
 const saveMeta = (downloadInfo, filePath, isEmbedPic) => {
-  if (downloadInfo.type === 'ape') return
+  if (downloadInfo.type === 'ape' || downloadInfo.type === 'flac') return
   const promise = isEmbedPic
     ? downloadInfo.musicInfo.img
       ? Promise.resolve(downloadInfo.musicInfo.img)
@@ -125,7 +133,7 @@ const actions = {
       url: null,
       fileName: `${rootState.setting.download.fileName
         .replace('歌名', musicInfo.name)
-        .replace('歌手', musicInfo.singer)}.${ext}`,
+        .replace('歌手', musicInfo.singer)}.${ext}`.replace(filterFileName, ''),
       progress: {
         downloaded: 0,
         total: 0,

src/renderer/store/modules/list.js

@@ -1,15 +1,22 @@
 // state
 const state = {
   defaultList: {
+    id: 'default',
     name: '试听列表',
     list: [],
   },
+  loveList: {
+    id: 'love',
+    name: '我的收藏',
+    list: [],
+  },
   userList: [],
 }
 
 // getters
 const getters = {
   defaultList: state => state.defaultList || {},
+  loveList: state => state.loveList || {},
   userList: state => state.userList,
 }
 
@@ -18,39 +25,72 @@ const actions = {
 
 }
 
+const getList = (state, id) => {
+  let targetList
+  switch (id) {
+    case 'default':
+      targetList = state.defaultList
+      break
+    case 'love':
+      targetList = state.loveList
+      break
+    default:
+      targetList = state.userList.find(l => l.id === id)
+      break
+  }
+  return targetList
+}
+
 // mitations
 const mutations = {
-  initDefaultList(state, data) {
-    state.defaultList = data
+  initList(state, { defaultList, loveList }) {
+    if (defaultList !== undefined) state.defaultList.list = defaultList.list
+    if (loveList !== undefined) state.loveList.list = loveList.list
   },
-  setDefaultList(state, list) {
-    state.defaultList.list = list
+  setList(state, { id, list }) {
+    const targetList = getList(state, id)
+    if (!targetList) return
+    targetList.list = list
   },
-  defaultListAdd(state, musicInfo) {
-    if (state.defaultList.list.some(s => s.songmid === musicInfo.songmid)) return
-    state.defaultList.list.push(musicInfo)
+  listAdd(state, { id, musicInfo }) {
+    const targetList = getList(state, id)
+    if (!targetList) return
+    if (targetList.list.some(s => s.songmid === musicInfo.songmid)) return
+    targetList.list.push(musicInfo)
   },
-  defaultListAddMultiple(state, list) {
+  listAddMultiple(state, { id, list }) {
+    let targetList = getList(state, id)
+    if (!targetList) return
+    targetList = targetList.list
     list.forEach(musicInfo => {
-      if (state.defaultList.list.some(s => s.songmid === musicInfo.songmid)) return
-      state.defaultList.list.push(musicInfo)
+      if (targetList.some(s => s.songmid === musicInfo.songmid)) return
+      targetList.push(musicInfo)
     })
   },
-  defaultListRemove(state, index) {
-    state.defaultList.list.splice(index, 1)
+  listRemove(state, { id, index }) {
+    let targetList = getList(state, id)
+    if (!targetList) return
+    targetList.list.splice(index, 1)
   },
-  updateMusicInfo(state, { index, data }) {
-    Object.assign(state.defaultList.list[index], data)
-  },
-  defaultListRemoveMultiple(state, list) {
+  listRemoveMultiple(state, { id, list }) {
+    let targetList = getList(state, id)
+    if (!targetList) return
+    targetList = targetList.list
     list.forEach(musicInfo => {
-      let index = state.defaultList.list.indexOf(musicInfo)
+      let index = targetList.indexOf(musicInfo)
       if (index < 0) return
-      state.defaultList.list.splice(index, 1)
+      targetList.splice(index, 1)
     })
   },
-  defaultListClear(state) {
-    state.defaultList.list.length = 0
+  listClear(state, id) {
+    let targetList = getList(state, id)
+    if (!targetList) return
+    targetList.list.length = 0
+  },
+  updateMusicInfo(state, { id, index, data }) {
+    let targetList = getList(state, id)
+    if (!targetList) return
+    Object.assign(targetList.list[index], data)
   },
 }
 

src/renderer/store/modules/player.js

@@ -23,6 +23,12 @@ const getters = {
 // actions
 const actions = {
   getUrl({ commit, state }, { musicInfo, type, isRefresh }) {
+    if (!musicInfo._types[type]) {
+      // 兼容旧版酷我源搜索列表过滤128k音质的bug
+      if (!(musicInfo.source == 'kw' && type == '128k')) return Promise.reject(new Error('该歌曲没有可播放的音频'))
+
+      // return Promise.reject(new Error('该歌曲没有可播放的音频'))
+    }
     if (urlRequest && urlRequest.cancelHttp) urlRequest.cancelHttp()
     if (musicInfo.typeUrl[type] && !isRefresh) return Promise.resolve()
     urlRequest = music[musicInfo.source].getMusicUrl(musicInfo, type)

src/renderer/store/modules/search.js

@@ -1,41 +1,103 @@
 import music from '../../utils/music'
+const sources = []
+const sourceList = {}
+const sourceMaxPage = {}
+for (const source of music.sources) {
+  const musicSearch = music[source.id].musicSearch
+  if (!musicSearch) continue
+  sources.push(source)
+  sourceList[source.id] = {
+    page: 1,
+    allPage: 0,
+    limit: 30,
+    total: 0,
+    list: [],
+  }
+  sourceMaxPage[source.id] = 0
+}
+
+sources.push({
+  id: 'all',
+  name: '聚合搜索',
+})
 
 // state
 const state = {
+  sourceList,
   list: [],
   text: '',
   page: 1,
   limit: 30,
   allPage: 1,
   total: 0,
+  sourceMaxPage,
 }
 
 // getters
 const getters = {
-  list: state => state.list || [],
-  limit: state => state.limit,
-  info: state => ({ page: state.page, text: state.text }),
-  listInfo: state => ({ allPage: state.allPage, total: state.total }),
+  sources: () => sources,
+  sourceList: state => state.sourceList || [],
+  searchText: state => state.text,
+  allList: state => ({ list: state.list, allPage: state.allPage, page: state.page, total: state.total, limit: state.limit, sourceMaxPage: state.sourceMaxPage }),
 }
 
 // actions
 const actions = {
   search({ commit, rootState }, { text, page, limit }) {
-    return music[rootState.setting.sourceId].musicSearch.search(text, page, limit)
-      .then(data => commit('setList', { list: data.list, allPage: data.allPage, total: data.total, text, page }))
+    if (rootState.setting.search.searchSource == 'all') {
+      let task = []
+      for (const source of sources) {
+        if (source.id == 'all') continue
+        task.push(music[source.id].musicSearch.search(text, page))
+      }
+      Promise.all(task).then(results => commit('setLists', { results, text, page }))
+    } else {
+      return music[rootState.setting.search.searchSource].musicSearch.search(text, page, limit)
+        .then(data => commit('setList', { text, page, ...data }))
+    }
   },
 }
 
 // mitations
 const mutations = {
   setList(state, datas) {
-    state.list = datas.list
-    state.total = datas.total
-    state.allPage = datas.allPage
-    state.page = datas.page
+    let source = state.sourceList[datas.source]
+    source.list = datas.list
+    source.total = datas.total
+    source.allPage = datas.allPage
+    source.page = datas.page
+    source.limit = datas.limit
     state.text = datas.text
   },
+  setLists(state, { results, text, page }) {
+    let pages = []
+    let total = 0
+    let limit = 0
+    let list = []
+    for (const source of results) {
+      state.sourceMaxPage[source.source] = source.allPage
+      if (source.allPage < page) continue
+      list.push(...source.list)
+      pages.push(source.allPage)
+      total += source.total
+      limit += source.limit
+    }
+    list.sort((a, b) => b.name.charCodeAt(0) - a.name.charCodeAt(0))
+    state.allPage = Math.max(...pages)
+    state.total = total
+    state.limit = limit
+    state.page = page
+    state.text = text
+    state.list = list
+  },
   clearList(state) {
+    for (const source of Object.keys(state.sourceList)) {
+      state.sourceList[source].list.length = 0
+      state.sourceList[source].page = 0
+      state.sourceList[source].allPage = 0
+      state.sourceList[source].total = 0
+      state.sourceMaxPage[source] = 0
+    }
     state.list.length = 0
     state.page = 0
     state.allPage = 0

src/renderer/store/modules/songList.js

@@ -1,6 +1,7 @@
 import music from '../../utils/music'
 const sortList = {}
 const sources = []
+const cache = new Map()
 for (const source of music.sources) {
   const songList = music[source.id].songList
   if (!songList) continue
@@ -20,10 +21,12 @@ const state = {
   },
   listDetail: {
     list: [],
+    desc: null,
     total: 0,
     page: 1,
     limit: 30,
     key: null,
+    info: {},
   },
   selectListInfo: {},
   isVisibleListDetail: false,
@@ -59,16 +62,45 @@ const actions = {
     let tabId = rootState.setting.songList.tagInfo.id
     let sortId = rootState.setting.songList.sortId
     // console.log(sortId)
-    let key = `${source}${sortId}${tabId}${page}`
-    if (state.list.list.length && state.list.key == key) return true
-    return music[source].songList.getList(sortId, tabId, page).then(result => commit('setList', { result, key, page }))
+    let key = `slist__${source}__${sortId}__${tabId}__${page}`
+    if (state.list.list.length && state.list.key == key) return
+    return (cache.has(key) ? Promise.resolve(cache.get(key)) : music[source].songList.getList(sortId, tabId, page)).then(result => commit('setList', { result, key, page }))
   },
   getListDetail({ state, rootState, commit }, { id, page }) {
     let source = rootState.setting.songList.source
-    let key = `${source}${id}${page}`
+    let key = `sdetail__${source}__${id}__${page}`
     if (state.listDetail.list.length && state.listDetail.key == key) return true
-    return music[source].songList.getListDetail(id, page).then(result => commit('setListDetail', { result, key, page }))
+    return (cache.has(key) ? Promise.resolve(cache.get(key)) : music[source].songList.getListDetail(id, page)).then(result => commit('setListDetail', { result, key, page }))
   },
+/*   getListDetailAll({ state, rootState }, id) {
+    let source = rootState.setting.songList.source
+    let key = `sdetail__${source}__${id}__all`
+    if (cache.has(key)) return Promise.resolve(cache.get(key))
+    music[source].songList.getListDetail(id, 1).then(result => {
+      let data = { list: result.list, id }
+      if (result.total <= result.limit) {
+        data = { list: result.list, id }
+        cache.set(key, data)
+        return data
+      }
+
+      let maxPage = Math.ceil(result.total / result.limit)
+      const loadDetail = (loadPage = 1) => {
+        let task = []
+        let loadNum = 0
+        while (loadPage <= maxPage && loadNum < 3) {
+          task.push(music[source].songList.getListDetail(id, ++loadPage))
+          loadNum++
+        }
+        return loadPage == maxPage
+          ? Promise.all(task)
+          : Promise.all(task).then(result => loadDetail(loadPage).then(result2 => [...result, ...result2]))
+      }
+      return loadDetail().then(result2 => {
+        console.log(result2)
+      })
+    })
+  }, */
 }
 
 // mitations
@@ -82,6 +114,7 @@ const mutations = {
     state.list.limit = result.limit
     state.list.page = page
     state.list.key = key
+    cache.set(key, result)
   },
   setListDetail(state, { result, key, page }) {
     state.listDetail.list = result.list
@@ -89,8 +122,11 @@ const mutations = {
     state.listDetail.limit = result.limit
     state.listDetail.page = page
     state.listDetail.key = key
+    state.listDetail.info = result.info || {}
+    cache.set(key, result)
   },
   setVisibleListDetail(state, bool) {
+    if (!bool) state.listDetail.list = []
     state.isVisibleListDetail = bool
   },
   setSelectListInfo(state, info) {

src/renderer/store/mutations.js

@@ -2,8 +2,9 @@ export default {
   setTheme(state, val) {
     state.setting.themeId = val
   },
-  setSource(state, val) {
-    state.setting.sourceId = val
+  setSearchSource(state, { searchSource, tempSearchSource }) {
+    if (searchSource != null) state.setting.search.searchSource = searchSource
+    if (tempSearchSource != null) state.setting.search.tempSearchSource = tempSearchSource
   },
   setSetting(state, val) {
     state.setting = val
@@ -17,6 +18,9 @@ export default {
     if (sortId != null) state.setting.songList.sortId = sortId
     if (source != null) state.setting.songList.source = source
   },
+  setListScroll(state, { id, location }) {
+    state.setting.list.scroll.locations[id] = location
+  },
   setNewVersion(state, val) {
     // val.history.forEach(ver => {
     //   ver.desc = ver.desc.replace(/\n/g, '<br>')

src/renderer/store/state.js

@@ -6,6 +6,7 @@ import { version } from '../../../package.json'
 let electronStore = new Store()
 const setting = updateSetting(electronStore.get('setting'))
 electronStore.set('setting', setting)
+process.versions.app = version
 
 export default {
   themes: [
@@ -44,6 +45,16 @@ export default {
       name: '灰常美丽',
       class: 'grey',
     },
+    {
+      id: 7,
+      name: '月里嫦娥',
+      class: 'midAutumn',
+    },
+    {
+      id: 8,
+      name: '木叶之村',
+      class: 'dhHyrz',
+    },
   ],
   version: {
     version,

src/renderer/utils/index.js

@@ -15,8 +15,8 @@ export const getRandom = (min, max) => Math.floor(Math.random() * (max - min)) +
 
 export const sizeFormate = size => {
   // https://gist.github.com/thomseddon/3511330
-  if (!size) return '0 b'
-  let units = ['b', 'kB', 'MB', 'GB', 'TB']
+  if (!size) return '0 B'
+  let units = ['B', 'KB', 'MB', 'GB', 'TB']
   let number = Math.floor(Math.log(size) / Math.log(1024))
   return `${(size / Math.pow(1024, Math.floor(number))).toFixed(2)} ${units[number]}`
 }
@@ -43,7 +43,8 @@ export const b64DecodeUnicode = str => {
 export const decodeName = str => str.replace(/'/g, '\'')
 
 export const scrollTo = (element, to, duration = 300, fn = function() {}) => {
-  const start = element.scrollTop || element.scrollY
+  if (!element) return
+  const start = element.scrollTop || element.scrollY || 0
   const change = to - start
   const increment = 10
   if (!change) {
@@ -163,7 +164,7 @@ export const isChildren = (parent, children) => {
  * @param {*} setting
  */
 export const updateSetting = setting => {
-  const defaultVersion = '1.0.6'
+  const defaultVersion = '1.0.12'
   const defaultSetting = {
     version: defaultVersion,
     player: {
@@ -174,6 +175,11 @@ export const updateSetting = setting => {
     },
     list: {
       isShowAlbumName: true,
+      isShowSource: false,
+      scroll: {
+        enable: true,
+        locations: {},
+      },
     },
     download: {
       savePath: path.join(os.homedir(), 'Desktop'),
@@ -194,6 +200,22 @@ export const updateSetting = setting => {
         id: null,
       },
     },
+    odc: {
+      isAutoClearSearchInput: false,
+    },
+    search: {
+      searchSource: 'kw',
+      tempSearchSource: 'kw',
+    },
+    network: {
+      proxy: {
+        enable: false,
+        host: '',
+        port: '',
+        username: '',
+        password: '',
+      },
+    },
     themeId: 0,
     sourceId: 'kw',
     apiSource: 'test',
@@ -202,7 +224,6 @@ export const updateSetting = setting => {
   }
   const overwriteSetting = {
     version: defaultVersion,
-    sourceId: 'kw',
   }
 
 
@@ -265,3 +286,86 @@ export const saveLrc = (filePath, lrc) => {
     if (err) console.log(err)
   })
 }
+
+/**
+ * 生成节流函数
+ * @param {*} fn
+ * @param {*} delay
+ */
+export const throttle = (fn, delay = 100) => {
+  let timer = null
+  let _args = null
+  return function(...args) {
+    _args = args
+    if (timer) return
+    timer = setTimeout(() => {
+      timer = null
+      fn.apply(this, _args)
+    }, delay)
+  }
+}
+
+/**
+ * 生成防抖函数
+ * @param {*} fn
+ * @param {*} delay
+ */
+export const debounce = (fn, delay = 100) => {
+  let timer = null
+  let _args = null
+  return function(...args) {
+    _args = args
+    if (timer) clearTimeout(timer)
+    timer = setTimeout(() => {
+      timer = null
+      fn.apply(this, _args)
+    }, delay)
+  }
+}
+
+const async_removeItem = (arr, num, callback) => window.requestAnimationFrame(() => {
+  let len = arr.length
+  if (len > num) {
+    arr.splice(0, num)
+    return async_removeItem(arr, num, callback)
+  } else {
+    arr.splice(0, len)
+    return callback()
+  }
+})
+const async_addItem = (arr, newArr, num, callback) => window.requestAnimationFrame(() => {
+  let len = newArr.length
+  if (len > num) {
+    arr.push(...newArr.splice(0, num))
+    return async_addItem(arr, newArr, num, callback)
+  } else {
+    arr.push(...newArr.splice(0, len))
+    return callback()
+  }
+})
+/**
+ * 异步设置数组
+ * @param {*} from 原数组
+ * @param {*} to 设置后的数组内容
+ * @param {*} num 每次设置的个数
+ */
+export const asyncSetArray = (from, to, num = 100) => new Promise(resolve => {
+  async_removeItem(from, num, () => {
+    async_addItem(from, Array.from(to), num, () => {
+      resolve()
+    })
+  })
+})
+
+
+/**
+ * 获取缓存大小
+ * @param {*} win
+ */
+export const getCacheSize = () => remote.getCurrentWindow().webContents.session.getCacheSize()
+
+/**
+ * 清除缓存
+ * @param {*} win
+ */
+export const clearCache = () => remote.getCurrentWindow().webContents.session.clearCache()

src/renderer/utils/music/api-source.js

@@ -1,9 +1,10 @@
 import kw_api_temp from './kw/api-temp'
 import kw_api_test from './kw/api-test'
-// import tx_api_messoer from './tx/api-messoer'
+import tx_api_test from './tx/api-test'
 import kg_api_test from './kg/api-test'
 import wy_api_test from './wy/api-test'
 import bd_api_test from './bd/api-test'
+import mg_api_test from './mg/api-test'
 // import kw_api_internal from './kw/api-internal'
 // import tx_api_internal from './tx/api-internal'
 // import kg_api_internal from './kg/api-internal'
@@ -12,10 +13,11 @@ import bd_api_test from './bd/api-test'
 
 const apis = {
   kw_api_test,
-  // tx_api_messoer,
+  tx_api_test,
   kg_api_test,
   wy_api_test,
   bd_api_test,
+  mg_api_test,
   // kw_api_internal,
   // tx_api_internal,
   // kg_api_internal,
@@ -46,6 +48,8 @@ export default source => {
       return getAPI('wy')
     case 'bd':
       return getAPI('bd')
+    case 'mg':
+      return getAPI('mg')
     default:
       return getAPI('kw')
   }

src/renderer/utils/music/bd/api-test.js

@@ -1,41 +1,20 @@
-import { httpFatch } from '../../request'
+import { httpFetch } from '../../request'
 import { requestMsg } from '../../message'
 import { headers, timeout } from '../options'
 
 const api_test = {
   getMusicUrl(songInfo, type) {
-    const requestObj = httpFatch(`http://test.tempmusic.tk/url/bd/${songInfo.songmid}/${type}`, {
+    const requestObj = httpFetch(`http://ts.tempmusic.tk/url/bd/${songInfo.songmid}/${type}`, {
       method: 'get',
       timeout,
       headers,
+      family: 4,
     })
     requestObj.promise = requestObj.promise.then(({ body }) => {
       return body.code === 0 ? Promise.resolve({ type, url: body.data }) : Promise.reject(new Error(requestMsg.fail))
     })
     return requestObj
   },
-  getPic(songInfo, size = '500') {
-    const requestObj = httpFatch(`http://test.tempmusic.tk/pic/bd/${songInfo.songmid}/${size}`, {
-      method: 'get',
-      timeout,
-      headers,
-    })
-    requestObj.promise = requestObj.promise.then(({ body }) => {
-      return body.code === 0 ? Promise.resolve(body.data) : Promise.reject(new Error(requestMsg.fail))
-    })
-    return requestObj
-  },
-  getLyric(songInfo) {
-    const requestObj = httpFatch(`http://test.tempmusic.tk/lrc/bd/${songInfo.songmid}`, {
-      method: 'get',
-      timeout,
-      headers,
-    })
-    requestObj.promise = requestObj.promise.then(({ body }) => {
-      return body.code === 0 ? Promise.resolve(body.data) : Promise.reject(new Error(requestMsg.fail))
-    })
-    return requestObj
-  },
 }
 
 export default api_test

src/renderer/utils/music/bd/index.js

@@ -2,19 +2,32 @@ import leaderboard from './leaderboard'
 import api_source from '../api-source'
 import musicInfo from './musicInfo'
 import songList from './songList'
+import { httpFetch } from '../../request'
+import musicSearch from './musicSearch'
 
 const bd = {
   leaderboard,
   songList,
+  musicSearch,
   getMusicUrl(songInfo, type) {
     return api_source('bd').getMusicUrl(songInfo, type)
   },
-  getLyric(songInfo) {
-    return api_source('bd').getLyric(songInfo)
-  },
   getPic(songInfo) {
-    return api_source('bd').getPic(songInfo)
+    const requestObj = this.getMusicInfo(songInfo)
+    requestObj.promise = requestObj.promise.then(info => info.pic_premium)
+    return requestObj
   },
+  getLyric(songInfo) {
+    const requestObj = this.getMusicInfo(songInfo)
+    requestObj.promise = requestObj.promise.then(info => httpFetch(info.lrclink).promise.then(resp => resp.body))
+    return requestObj
+  },
+  // getLyric(songInfo) {
+  //   return api_source('bd').getLyric(songInfo)
+  // },
+  // getPic(songInfo) {
+  //   return api_source('bd').getPic(songInfo)
+  // },
   getMusicInfo(songInfo) {
     return musicInfo.getMusicInfo(songInfo.songmid)
   },

src/renderer/utils/music/bd/leaderboard.js

@@ -1,4 +1,4 @@
-import { httpFatch } from '../../request'
+import { httpFetch } from '../../request'
 // import { formatPlayTime } from '../../index'
 // import jshtmlencode from 'js-htmlencode'
 
@@ -66,7 +66,7 @@ export default {
   requestObj: null,
   getData(url) {
     if (this.requestObj) this.requestObj.cancelHttp()
-    this.requestObj = httpFatch(url)
+    this.requestObj = httpFetch(url)
     return this.requestObj.promise
   },
   filterData(rawList) {
@@ -85,7 +85,7 @@ export default {
           size,
         }
         types.push({ type: 'flac', size })
-        _types['flac'] = {
+        _types.flac = {
           size,
         }
       }
@@ -126,6 +126,7 @@ export default {
         list,
         limit: this.limit,
         page: parseInt(info[3]),
+        source: 'bd',
       }
     })
   },

src/renderer/utils/music/bd/musicInfo.js

@@ -1,10 +1,19 @@
-import { httpFatch } from '../../request'
+import { httpFetch } from '../../request'
 
 export default {
+  cache: {},
   getMusicInfo(songmid) {
-    const requestObj = httpFatch(`https://musicapi.qianqian.com/v1/restserver/ting?method=baidu.ting.song.getSongLink&format=json&from=bmpc&version=1.0.0&version_d=11.1.6.0&songid=${songmid}&type=1&res=1&s_protocol=1&aac=2&project=tpass`)
+    if (this.cache[songmid]) {
+      return { promise: Promise.resolve(this.cache[songmid]) }
+    }
+    const requestObj = httpFetch(`https://musicapi.qianqian.com/v1/restserver/ting?method=baidu.ting.song.getSongLink&format=json&from=bmpc&version=1.0.0&version_d=11.1.6.0&songid=${songmid}&type=1&res=1&s_protocol=1&aac=2&project=tpass`)
     requestObj.promise = requestObj.promise.then(({ body }) => {
-      return body.error_code == 22000 ? body.reqult.songinfo : Promise.reject(new Error('获取音乐信息失败'))
+      // console.log(body)
+      if (body.error_code == 22000) {
+        this.cache[songmid] = body.result.songinfo
+        return body.result.songinfo
+      }
+      return Promise.reject(new Error('获取音乐信息失败'))
     })
     return requestObj
   },

src/renderer/utils/music/bd/musicSearch.js

@@ -0,0 +1,89 @@
+// import '../../polyfill/array.find'
+// import jshtmlencode from 'js-htmlencode'
+import { httpFetch } from '../../request'
+import { formatPlayTime } from '../../index'
+// import { debug } from '../../utils/env'
+// import { formatSinger } from './util'
+
+let searchRequest
+export default {
+  limit: 30,
+  total: 0,
+  page: 0,
+  allPage: 1,
+  musicSearch(str, page) {
+    if (searchRequest && searchRequest.cancelHttp) searchRequest.cancelHttp()
+    searchRequest = httpFetch(`http://tingapi.ting.baidu.com/v1/restserver/ting?from=android&version=5.6.5.6&method=baidu.ting.search.merge&format=json&query=${encodeURIComponent(str)}&page_no=${page}&page_size=${this.limit}&type=0&data_source=0&use_cluster=1`)
+    return searchRequest.promise.then(({ body }) => body)
+  },
+  handleResult(rawData) {
+    let ids = new Set()
+    const list = []
+    if (!rawData) return list
+    rawData.forEach(item => {
+      if (ids.has(item.song_id)) return
+      ids.add(item.song_id)
+      const types = []
+      const _types = {}
+      let size = null
+      let itemTypes = item.all_rate.split(',')
+      if (itemTypes.includes('128')) {
+        types.push({ type: '128k', size })
+        _types['128k'] = {
+          size,
+        }
+      }
+      if (itemTypes.includes('320')) {
+        types.push({ type: '320k', size })
+        _types['320k'] = {
+          size,
+        }
+      }
+      if (itemTypes.includes('flac')) {
+        types.push({ type: 'flac', size })
+        _types.flac = {
+          size,
+        }
+      }
+      // types.reverse()
+
+      list.push({
+        singer: item.author.replace(',', '、'),
+        name: item.title,
+        albumName: item.album_title,
+        albumId: item.album_id,
+        source: 'bd',
+        interval: formatPlayTime(parseInt(item.file_duration)),
+        songmid: item.song_id,
+        img: null,
+        lrc: null,
+        types,
+        _types,
+        typeUrl: {},
+      })
+    })
+    return list
+  },
+  search(str, page = 1, { limit } = {}) {
+    if (limit != null) this.limit = limit
+
+    return this.musicSearch(str, page).then(result => {
+      if (!result || result.error_code !== 22000) return this.search(str, page, { limit })
+      let list = this.handleResult(result.result.song_info.song_list)
+
+      if (list == null) return this.search(str, page, { limit })
+
+      this.total = result.result.song_info.total
+      this.page = page
+      this.allPage = Math.ceil(this.total / this.limit)
+
+      return Promise.resolve({
+        list,
+        allPage: this.allPage,
+        limit: this.limit,
+        total: this.total,
+        source: 'bd',
+      })
+    })
+  },
+}

src/renderer/utils/music/bd/songList.js

@@ -1,4 +1,4 @@
-import { httpFatch } from '../../request'
+import { httpFetch } from '../../request'
 import { formatPlayTime, toMD5 } from '../../index'
 import CryptoJS from 'crypto-js'
 
@@ -8,7 +8,7 @@ export default {
   _requestObj_listRecommend: null,
   _requestObj_listDetail: null,
   limit_list: 20,
-  limit_song: 25,
+  limit_song: 1000,
   successCode: 22000,
   sortList: [
     {
@@ -108,14 +108,16 @@ export default {
   },
 
   // 获取标签
-  getTags() {
+  getTags(tryNum = 0) {
     if (this._requestObj_tags) this._requestObj_tags.cancelHttp()
-    this._requestObj_tags = httpFatch(this.getTagsUrl())
+    if (tryNum > 2) return Promise.reject(new Error('try max num'))
+    this._requestObj_tags = httpFetch(this.getTagsUrl())
     return this._requestObj_tags.promise.then(({ body }) => {
-      if (body.error_code !== this.successCode) return this.getTags()
+      if (body.error_code !== this.successCode) return this.getTags(++tryNum)
       return {
         hotTag: this.filterInfoHotTag(body.result.hot),
         tags: this.filterTagInfo(body.result.tags),
+        source: 'bd',
       }
     })
   },
@@ -123,6 +125,7 @@ export default {
     return rawList.map(item => ({
       name: item,
       id: item,
+      source: 'bd',
     }))
   },
   filterTagInfo(rawList) {
@@ -133,23 +136,26 @@ export default {
         parent_name: type.first,
         id: item,
         name: item,
+        source: 'bd',
       })),
     }))
   },
 
   // 获取列表数据
-  getList(sortId, tagId, page) {
+  getList(sortId, tagId, page, tryNum = 0) {
     if (this._requestObj_list) this._requestObj_list.cancelHttp()
-    this._requestObj_list = httpFatch(
+    if (tryNum > 2) return Promise.reject(new Error('try max num'))
+    this._requestObj_list = httpFetch(
       this.getListUrl(sortId, tagId, page)
     )
     return this._requestObj_list.promise.then(({ body }) => {
-      // if (body.error_code !== this.successCode) return this.getList(sortId, tagId, page)
+      if (body.error_code !== this.successCode) return this.getList(sortId, tagId, page, ++tryNum)
       return {
         list: this.filterList(body.diyInfo),
         total: body.nums,
         page,
         limit: this.limit_list,
+        source: 'bd',
       }
     })
   },
@@ -174,23 +180,33 @@ export default {
       img: item.list_pic_large || item.list_pic,
       grade: item.grade,
       desc: item.desc || item.tag,
+      source: 'bd',
     }))
   },
 
   // 获取歌曲列表内的音乐
-  getListDetail(id, page) {
+  getListDetail(id, page, tryNum = 0) {
     if (this._requestObj_listDetail) {
       this._requestObj_listDetail.cancelHttp()
     }
-    this._requestObj_listDetail = httpFatch(this.getListDetailUrl(id, page))
+    if (tryNum > 2) return Promise.reject(new Error('try max num'))
+    this._requestObj_listDetail = httpFetch(this.getListDetailUrl(id, page))
     return this._requestObj_listDetail.promise.then(({ body }) => {
-      if (body.error_code !== this.successCode) return this.getListDetail(id, page)
+      if (body.error_code !== this.successCode) return this.getListDetail(id, page, ++tryNum)
       let listData = this.filterData(body.result.songlist)
       return {
         list: listData,
         page,
         limit: this.limit_song,
         total: body.result.song_num,
+        source: 'bd',
+        info: {
+          name: body.result.info.list_title,
+          img: body.result.info.list_pic,
+          desc: body.result.info.list_desc,
+          author: body.result.info.userinfo.username,
+          play_count: this.formatPlayCount(body.result.listen_num),
+        },
       }
     })
   },
@@ -215,7 +231,7 @@ export default {
       }
       if (itemTypes.includes('flac')) {
         types.push({ type: 'flac', size })
-        _types['flac'] = {
+        _types.flac = {
           size,
         }
       }

src/renderer/utils/music/index.js

@@ -2,6 +2,7 @@ import kw from './kw'
 import kg from './kg'
 import tx from './tx'
 import wy from './wy'
+import mg from './mg'
 import bd from './bd'
 export default {
   sources: [
@@ -21,6 +22,10 @@ export default {
       name: '网易音乐',
       id: 'wy',
     },
+    {
+      name: '咪咕音乐',
+      id: 'mg',
+    },
     {
       name: '百度音乐',
       id: 'bd',
@@ -30,5 +35,6 @@ export default {
   kg,
   tx,
   wy,
+  mg,
   bd,
 }

src/renderer/utils/music/kg/api-test.js

@@ -1,13 +1,14 @@
-import { httpFatch } from '../../request'
+import { httpFetch } from '../../request'
 import { requestMsg } from '../../message'
 import { headers, timeout } from '../options'
 
 const api_test = {
   getMusicUrl(songInfo, type) {
-    const requestObj = httpFatch(`http://test.tempmusic.tk/url/kg/${songInfo._types[type].hash}/${type}`, {
+    const requestObj = httpFetch(`http://ts.tempmusic.tk/url/kg/${songInfo._types[type].hash}/${type}`, {
       method: 'get',
       timeout,
       headers,
+      family: 4,
     })
     requestObj.promise = requestObj.promise.then(({ body }) => {
       return body.code === 0 ? Promise.resolve({ type, url: body.data }) : Promise.reject(new Error(requestMsg.fail))
@@ -15,10 +16,11 @@ const api_test = {
     return requestObj
   },
   getPic(songInfo) {
-    const requestObj = httpFatch(`http://test.tempmusic.tk/pic/kg/${songInfo.hash}`, {
+    const requestObj = httpFetch(`http://ts.tempmusic.tk/pic/kg/${songInfo.hash}`, {
       method: 'get',
       timeout,
       headers,
+      family: 4,
     })
     requestObj.promise = requestObj.promise.then(({ body }) => {
       return body.code === 0 ? Promise.resolve(body.data) : Promise.reject(new Error(requestMsg.fail))
@@ -26,10 +28,11 @@ const api_test = {
     return requestObj
   },
   getLyric(songInfo) {
-    const requestObj = httpFatch(`http://test.tempmusic.tk/lrc/kg/${songInfo.hash}`, {
+    const requestObj = httpFetch(`http://ts.tempmusic.tk/lrc/kg/${songInfo.hash}`, {
       method: 'get',
       timeout,
       headers,
+      family: 4,
     })
     requestObj.promise = requestObj.promise.then(({ body }) => {
       return body.code === 0 ? Promise.resolve(body.data) : Promise.reject(new Error(requestMsg.fail))

src/renderer/utils/music/kg/index.js

@@ -1,19 +1,29 @@
 import leaderboard from './leaderboard'
 import api_source from '../api-source'
 import songList from './songList'
+import musicSearch from './musicSearch'
+import pic from './pic'
+import lyric from './lyric'
 
 const kg = {
   leaderboard,
   songList,
+  musicSearch,
   getMusicUrl(songInfo, type) {
     return api_source('kg').getMusicUrl(songInfo, type)
   },
   getLyric(songInfo) {
-    return api_source('kg').getLyric(songInfo)
+    return lyric.getLyric(songInfo)
   },
+  // getLyric(songInfo) {
+  //   return api_source('kg').getLyric(songInfo)
+  // },
   getPic(songInfo) {
-    return api_source('kg').getPic(songInfo)
+    return pic.getPic(songInfo)
   },
+  // getPic(songInfo) {
+  //   return api_source('kg').getPic(songInfo)
+  // },
 }
 
 export default kg

src/renderer/utils/music/kg/leaderboard.js

@@ -159,6 +159,7 @@ export default {
         list: listData,
         limit,
         page,
+        source: 'kg',
       }
     })
   },

src/renderer/utils/music/kg/lyric.js

@@ -0,0 +1,33 @@
+import { httpFetch } from '../../request'
+
+export default {
+  getIntv(interval) {
+    let intvArr = interval.split(':')
+    let intv = 0
+    let unit = 1
+    while (intvArr.length) {
+      intv += (intvArr.pop()) * unit
+      unit *= 60
+    }
+    return parseInt(intv)
+  },
+  getLyric(songInfo, tryNum = 0) {
+    let requestObj = httpFetch(`http://m.kugou.com/app/i/krc.php?cmd=100&keyword=${encodeURIComponent(songInfo.name)}&hash=${songInfo.hash}&timelength=${songInfo._interval || this.getIntv(songInfo.interval)}&d=0.38664927426725626`, {
+      headers: {
+        'KG-RC': 1,
+        'KG-THash': 'expand_search_manager.cpp:852736169:451',
+        'User-Agent': 'KuGou2012-9020-ExpandSearchManager',
+      },
+    })
+    requestObj.promise = requestObj.promise.then(({ body, statusCode }) => {
+      if (statusCode !== 200) {
+        if (tryNum > 5) return Promise.reject('歌词获取失败')
+        let tryRequestObj = this.getLyric(songInfo, ++tryNum)
+        requestObj.cancelHttp = tryRequestObj.cancelHttp.bind(tryRequestObj)
+        return tryRequestObj.promise
+      }
+      return body
+    })
+    return requestObj
+  },
+}

src/renderer/utils/music/kg/musicSearch.js

@@ -0,0 +1,93 @@
+// import '../../polyfill/array.find'
+// import jshtmlencode from 'js-htmlencode'
+import { httpFetch } from '../../request'
+import { formatPlayTime, sizeFormate } from '../../index'
+// import { debug } from '../../utils/env'
+// import { formatSinger } from './util'
+
+let searchRequest
+export default {
+  limit: 30,
+  total: 0,
+  page: 0,
+  allPage: 1,
+  musicSearch(str, page) {
+    if (searchRequest && searchRequest.cancelHttp) searchRequest.cancelHttp()
+    searchRequest = httpFetch(`http://ioscdn.kugou.com/api/v3/search/song?keyword=${encodeURIComponent(str)}&page=${page}&pagesize=${this.limit}&showtype=10&plat=2&version=7910&tag=1&correct=1&privilege=1&sver=5`)
+    return searchRequest.promise.then(({ body }) => body)
+  },
+  handleResult(rawData) {
+    // console.log(rawData)
+    let ids = new Set()
+    const list = []
+    rawData.forEach(item => {
+      if (ids.has(item.audio_id)) return
+      ids.add(item.audio_id)
+      const types = []
+      const _types = {}
+      if (item.filesize !== 0) {
+        let size = sizeFormate(item.filesize)
+        types.push({ type: '128k', size, hash: item.hash })
+        _types['128k'] = {
+          size,
+          hash: item.hash,
+        }
+      }
+      if (item['320filesize'] !== 0) {
+        let size = sizeFormate(item['320filesize'])
+        types.push({ type: '320k', size, hash: item['320hash'] })
+        _types['320k'] = {
+          size,
+          hash: item['320hash'],
+        }
+      }
+      if (item.sqfilesize !== 0) {
+        let size = sizeFormate(item.sqfilesize)
+        types.push({ type: 'flac', size, hash: item.sqhash })
+        _types.flac = {
+          size,
+          hash: item.sqhash,
+        }
+      }
+      list.push({
+        singer: item.singername,
+        name: item.songname,
+        albumName: item.album_name,
+        albumId: item.album_id,
+        songmid: item.audio_id,
+        source: 'kg',
+        interval: formatPlayTime(item.duration),
+        _interval: item.duration,
+        img: null,
+        lrc: null,
+        hash: item.hash,
+        types,
+        _types,
+        typeUrl: {},
+      })
+    })
+    return list
+  },
+  search(str, page = 1, { limit } = {}) {
+    if (limit != null) this.limit = limit
+    // http://newlyric.kuwo.cn/newlyric.lrc?62355680
+    return this.musicSearch(str, page).then(result => {
+      if (!result || result.errcode !== 0) return this.search(str, page, { limit })
+      let list = this.handleResult(result.data.info)
+
+      if (list == null) return this.search(str, page, { limit })
+
+      this.total = result.data.total
+      this.page = page
+      this.allPage = Math.ceil(this.total / this.limit)
+
+      return Promise.resolve({
+        list,
+        allPage: this.allPage,
+        limit: this.limit,
+        total: this.total,
+        source: 'kg',
+      })
+    })
+  },
+}

src/renderer/utils/music/kg/pic.js

@@ -0,0 +1,44 @@
+import { httpFetch } from '../../request'
+
+export default {
+  getPic(songInfo) {
+    const requestObj = httpFetch(
+      'http://media.store.kugou.com/v1/get_res_privilege',
+      {
+        method: 'POST',
+        headers: {
+          'KG-RC': 1,
+          'KG-THash': 'expand_search_manager.cpp:852736169:451',
+          'User-Agent': 'KuGou2012-9020-ExpandSearchManager',
+        },
+        body: {
+          appid: 1001,
+          area_code: '1',
+          behavior: 'play',
+          clientver: '9020',
+          need_hash_offset: 1,
+          relate: 1,
+          resource: [
+            {
+              album_audio_id: songInfo.songmid,
+              album_id: songInfo.albumId,
+              hash: songInfo.hash,
+              id: 0,
+              name: `${songInfo.singer} - ${songInfo.name}.mp3`,
+              type: 'audio',
+            },
+          ],
+          token: '',
+          userid: 2626431536,
+          vip: 1,
+        },
+      }
+    )
+    requestObj.promise = requestObj.promise.then(({ body }) => {
+      if (body.error_code !== 0) return Promise.reject('图片获取失败')
+      let info = body.data[0].info
+      return info.imgsize ? info.image.replace('{size}', info.imgsize[0]) : info.image
+    })
+    return requestObj
+  },
+}

src/renderer/utils/music/kg/songList.js

@@ -1,4 +1,4 @@
-import { httpFatch } from '../../request'
+import { httpFetch } from '../../request'
 import { formatPlayTime, sizeFormate } from '../../index'
 
 export default {
@@ -35,11 +35,12 @@ export default {
   ],
   regExps: {
     listData: /global\.data = (\[.+\]);/,
+    listInfo: /global = {[\s\S]+?name: "(.+)"[\s\S]+?pic: "(.+)"[\s\S]+?};/,
   },
   getInfoUrl(tagId) {
     return tagId
       ? `http://www2.kugou.kugou.com/yueku/v9/special/getSpecial?is_smarty=1&cdn=cdn&t=5&c=${tagId}`
-      : `http://www2.kugou.kugou.com/yueku/v9/special/getSpecial?is_smarty=1&`
+      : 'http://www2.kugou.kugou.com/yueku/v9/special/getSpecial?is_smarty=1&'
   },
   getSongListUrl(sortId, tagId, page) {
     if (tagId == null) tagId = ''
@@ -80,25 +81,28 @@ export default {
           parent_name: tag.pname,
           id: tag.id,
           name: tag.name,
+          source: 'kg',
         })),
       })
     }
     return result
   },
 
-  getSongList(sortId, tagId, page) {
+  getSongList(sortId, tagId, page, tryNum = 0) {
     if (this._requestObj_list) this._requestObj_list.cancelHttp()
-    this._requestObj_list = httpFatch(
+    if (tryNum > 2) return Promise.reject(new Error('try max num'))
+    this._requestObj_list = httpFetch(
       this.getSongListUrl(sortId, tagId, page)
     )
     return this._requestObj_list.promise.then(({ body }) => {
-      if (body.status !== 1) return this.getSongList(sortId, tagId, page)
+      if (body.status !== 1) return this.getSongList(sortId, tagId, page, ++tryNum)
       return this.filterList(body.special_db)
     })
   },
-  getSongListRecommend() {
+  getSongListRecommend(tryNum = 0) {
     if (this._requestObj_listRecommend) this._requestObj_listRecommend.cancelHttp()
-    this._requestObj_listRecommend = httpFatch(
+    if (tryNum > 2) return Promise.reject(new Error('try max num'))
+    this._requestObj_listRecommend = httpFetch(
       'http://everydayrec.service.kugou.com/guess_special_recommend',
       {
         method: 'post',
@@ -119,7 +123,7 @@ export default {
       }
     )
     return this._requestObj_listRecommend.promise.then(({ body }) => {
-      if (body.status !== 1) return this.getSongListRecommend()
+      if (body.status !== 1) return this.getSongListRecommend(++tryNum)
       return this.filterList(body.data.special_list)
     })
   },
@@ -133,20 +137,38 @@ export default {
       img: item.img || item.imgurl,
       grade: item.grade,
       desc: item.intro,
+      source: 'kg',
     }))
   },
 
-  getListDetail(id, page) { // 获取歌曲列表内的音乐
+  getListDetail(id, page, tryNum = 0) { // 获取歌曲列表内的音乐
     if (this._requestObj_listDetail) this._requestObj_listDetail.cancelHttp()
-    this._requestObj_listDetail = httpFatch(this.getSongListDetailUrl(id))
+    if (tryNum > 2) return Promise.reject(new Error('try max num'))
+    this._requestObj_listDetail = httpFetch(this.getSongListDetailUrl(id))
     return this._requestObj_listDetail.promise.then(({ body }) => {
       let listData = body.match(this.regExps.listData)
-      if (listData) listData = this.filterData(JSON.parse(RegExp.$1))
+      let listInfo = body.match(this.regExps.listInfo)
+      if (!listData) return this.getListDetail(id, page, ++tryNum)
+      listData = this.filterData(JSON.parse(listData[1]))
+      let name
+      let pic
+      if (listInfo) {
+        name = listInfo[1]
+        pic = listInfo[2]
+      }
       return {
         list: listData,
         page: 1,
         limit: 10000,
         total: listData.length,
+        source: 'kg',
+        info: {
+          name,
+          img: pic,
+          // desc: body.result.info.list_desc,
+          // author: body.result.info.userinfo.username,
+          // play_count: this.formatPlayCount(body.result.listen_num),
+        },
       }
     })
   },
@@ -206,15 +228,17 @@ export default {
   },
 
   // 获取列表信息
-  getListInfo(tagId) {
+  getListInfo(tagId, tryNum = 0) {
     if (this._requestObj_listInfo) this._requestObj_listInfo.cancelHttp()
-    this._requestObj_listInfo = httpFatch(this.getInfoUrl(tagId))
+    if (tryNum > 2) return Promise.reject(new Error('try max num'))
+    this._requestObj_listInfo = httpFetch(this.getInfoUrl(tagId))
     return this._requestObj_listInfo.promise.then(({ body }) => {
-      if (body.status !== 1) return this.getListInfo(tagId)
+      if (body.status !== 1) return this.getListInfo(tagId, ++tryNum)
       return {
         limit: body.data.params.pagesize,
         page: body.data.params.p,
         total: body.data.params.total,
+        source: 'kg',
       }
     })
   },
@@ -242,14 +266,16 @@ export default {
   },
 
   // 获取标签
-  getTags() {
+  getTags(tryNum = 0) {
     if (this._requestObj_tags) this._requestObj_tags.cancelHttp()
-    this._requestObj_tags = httpFatch(this.getInfoUrl())
+    if (tryNum > 2) return Promise.reject(new Error('try max num'))
+    this._requestObj_tags = httpFetch(this.getInfoUrl())
     return this._requestObj_tags.promise.then(({ body }) => {
-      if (body.status !== 1) return this.getTags()
+      if (body.status !== 1) return this.getTags(++tryNum)
       return {
         hotTag: this.filterInfoHotTag(body.data.hotTag),
         tags: this.filterTagInfo(body.data.tagids),
+        source: 'kg',
       }
     })
   },

src/renderer/utils/music/kw/api-temp.js

@@ -1,12 +1,13 @@
-import { httpFatch } from '../../request'
+import { httpFetch } from '../../request'
 import { headers, timeout } from '../options'
 
 const api_temp = {
   getMusicUrl(songInfo, type) {
-    const requestObj = httpFatch(`http://temp.tempmusic.tk/url/kw/${songInfo.songmid}/${type}`, {
+    const requestObj = httpFetch(`http://tm.tempmusic.tk/url/kw/${songInfo.songmid}/${type}`, {
       method: 'get',
       headers,
       timeout,
+      family: 4,
     })
     requestObj.promise = requestObj.promise.then(({ body }) => {
       return body.code === 0 ? Promise.resolve({ type, url: body.data }) : Promise.reject(new Error(body.msg))

src/renderer/utils/music/kw/api-test.js

@@ -1,10 +1,10 @@
-import { httpFatch } from '../../request'
+import { httpFetch } from '../../request'
 import { requestMsg } from '../../message'
 import { headers, timeout } from '../options'
 
 const api_test = {
   // getMusicUrl(songInfo, type) {
-  //   const requestObj = httpFatch(`http://45.32.53.128:3002/m/kw/u/${songInfo.songmid}/${type}`, {
+  //   const requestObj = httpFetch(`http://45.32.53.128:3002/m/kw/u/${songInfo.songmid}/${type}`, {
   //     method: 'get',
   //     headers,
   //     timeout,
@@ -15,10 +15,11 @@ const api_test = {
   //   return requestObj
   // },
   getMusicUrl(songInfo, type) {
-    const requestObj = httpFatch(`http://test.tempmusic.tk/url/kw/${songInfo.songmid}/${type}`, {
+    const requestObj = httpFetch(`http://ts.tempmusic.tk/url/kw/${songInfo.songmid}/${type}`, {
       method: 'get',
       timeout,
       headers,
+      family: 4,
     })
     requestObj.promise = requestObj.promise.then(({ body }) => {
       return body.code === 0 ? Promise.resolve({ type, url: body.data }) : Promise.reject(new Error(requestMsg.fail))

src/renderer/utils/music/kw/leaderboard.js

@@ -119,27 +119,27 @@ export default {
           size: null,
         }
       }
-      if (formats.indexOf('MP3192')) {
-        types.push({ type: '192k', size: null })
-        _types['192k'] = {
-          size: null,
-        }
-      }
+      // if (formats.indexOf('MP3192')) {
+      //   types.push({ type: '192k', size: null })
+      //   _types['192k'] = {
+      //     size: null,
+      //   }
+      // }
       if (formats.indexOf('MP3H')) {
         types.push({ type: '320k', size: null })
         _types['320k'] = {
           size: null,
         }
       }
-      if (formats.indexOf('AL')) {
-        types.push({ type: 'ape', size: null })
-        _types['ape'] = {
-          size: null,
-        }
-      }
+      // if (formats.indexOf('AL')) {
+      //   types.push({ type: 'ape', size: null })
+      //   _types.ape = {
+      //     size: null,
+      //   }
+      // }
       if (formats.indexOf('ALFLAC')) {
         types.push({ type: 'flac', size: null })
-        _types['flac'] = {
+        _types.flac = {
           size: null,
         }
       }
@@ -187,6 +187,7 @@ export default {
         list,
         limit: this.limit,
         page,
+        source: 'kw',
       }
     })
   },

src/renderer/utils/music/kw/lyric.js

@@ -1,4 +1,4 @@
-import { httpFatch } from '../../request'
+import { httpFetch } from '../../request'
 
 export default {
   formatTime(time) {
@@ -10,7 +10,7 @@ export default {
     return `[ti:${songinfo.songName}]\n[ar:${songinfo.artist}]\n[al:${songinfo.album}]\n[by:]\n[offset:0]\n${lrclist ? lrclist.map(l => `[${this.formatTime(l.time)}]${l.lineLyric}\n`).join('') : '暂无歌词'}`
   },
   getLyric(songId) {
-    const requestObj = httpFatch(`http://m.kuwo.cn/newh5/singles/songinfoandlrc?musicId=${songId}`)
+    const requestObj = httpFetch(`http://m.kuwo.cn/newh5/singles/songinfoandlrc?musicId=${songId}`)
     requestObj.promise = requestObj.promise.then(({ body }) => {
       return this.transformLrc(body.data)
     })

src/renderer/utils/music/kw/musicSearch.js

@@ -66,12 +66,12 @@ export default {
                 size: info[3].toLocaleUpperCase(),
               }
               break
-            case 'ape':
-              types.push({ type: 'ape', size: info[3] })
-              _types.ape = {
-                size: info[3].toLocaleUpperCase(),
-              }
-              break
+            // case 'ape':
+            //   types.push({ type: 'ape', size: info[3] })
+            //   _types.ape = {
+            //     size: info[3].toLocaleUpperCase(),
+            //   }
+            //   break
             case 'mp3':
               switch (info[1]) {
                 case '320':
@@ -81,11 +81,11 @@ export default {
                   }
                   break
                 case '192':
-                  types.push({ type: '192k', size: info[3] })
-                  _types['192k'] = {
-                    size: info[3].toLocaleUpperCase(),
-                  }
-                  break
+                //   types.push({ type: '192k', size: info[3] })
+                //   _types['192k'] = {
+                //     size: info[3].toLocaleUpperCase(),
+                //   }
+                //   break
                 case '128':
                   types.push({ type: '128k', size: info[3] })
                   _types['128k'] = {
@@ -121,7 +121,7 @@ export default {
     }
     return result
   },
-  search(str, page = 1, { limit }) {
+  search(str, page = 1, { limit } = {}) {
     if (limit != null) this.limit = limit
     // http://newlyric.kuwo.cn/newlyric.lrc?62355680
     return this.musicSearch(str, page).then(result => {
@@ -138,6 +138,8 @@ export default {
         list,
         allPage: this.allPage,
         total: this.total,
+        limit: this.limit,
+        source: 'kw',
       })
     })
   },

src/renderer/utils/music/kw/pic.js

@@ -1,8 +1,8 @@
-import { httpFatch } from '../../request'
+import { httpFetch } from '../../request'
 
 export default {
   getPic({ songmid }) {
-    const requestObj = httpFatch(`http://artistpicserver.kuwo.cn/pic.web?corp=kuwo&type=rid_pic&pictype=500&size=500&rid=${songmid}`)
+    const requestObj = httpFetch(`http://artistpicserver.kuwo.cn/pic.web?corp=kuwo&type=rid_pic&pictype=500&size=500&rid=${songmid}`)
     requestObj.promise = requestObj.promise.then(({ body }) => body)
     return requestObj
   },

src/renderer/utils/music/kw/songList.js

@@ -1,4 +1,4 @@
-import { httpFatch } from '../../request'
+import { httpFetch } from '../../request'
 import { formatPlayTime, decodeName } from '../../index'
 import { formatSinger } from './util'
 
@@ -8,7 +8,7 @@ export default {
   _requestObj_list: null,
   _requestObj_listDetail: null,
   limit_list: 25,
-  limit_song: 100,
+  limit_song: 1000,
   successCode: 200,
   sortList: [
     {
@@ -38,20 +38,22 @@ export default {
 
   // http://nplserver.kuwo.cn/pl.svc?op=getlistinfo&pid=2849349915&pn=0&rn=100&encode=utf8&keyset=pl2012&identity=kuwo&pcmp4=1&vipver=MUSIC_9.0.5.0_W1&newver=1
   // 获取标签
-  getTag() {
+  getTag(tryNum = 0) {
     if (this._requestObj_tags) this._requestObj_tags.cancelHttp()
-    this._requestObj_tags = httpFatch(this.tagsUrl)
+    if (tryNum > 2) return Promise.reject(new Error('try max num'))
+    this._requestObj_tags = httpFetch(this.tagsUrl)
     return this._requestObj_tags.promise.then(({ body }) => {
-      if (body.code !== this.successCode) return this.getTag()
+      if (body.code !== this.successCode) return this.getTag(++tryNum)
       return this.filterTagInfo(body.data)
     })
   },
   // 获取标签
-  getHotTag() {
+  getHotTag(tryNum = 0) {
     if (this._requestObj_hotTags) this._requestObj_hotTags.cancelHttp()
-    this._requestObj_hotTags = httpFatch(this.hotTagUrl)
+    if (tryNum > 2) return Promise.reject(new Error('try max num'))
+    this._requestObj_hotTags = httpFetch(this.hotTagUrl)
     return this._requestObj_hotTags.promise.then(({ body }) => {
-      if (body.code !== this.successCode) return this.getHotTag()
+      if (body.code !== this.successCode) return this.getHotTag(++tryNum)
       return this.filterInfoHotTag(body.data[0].data)
     })
   },
@@ -59,6 +61,7 @@ export default {
     return rawList.map(item => ({
       id: `${item.id}-${item.digest}`,
       name: item.name,
+      source: 'kw',
     }))
   },
   filterTagInfo(rawList) {
@@ -69,13 +72,15 @@ export default {
         parent_name: type.name,
         id: `${item.id}-${item.digest}`,
         name: item.name,
+        source: 'kw',
       })),
     }))
   },
 
   // 获取列表数据
-  getList(sortId, tagId, page) {
+  getList(sortId, tagId, page, tryNum = 0) {
     if (this._requestObj_list) this._requestObj_list.cancelHttp()
+    if (tryNum > 2) return Promise.reject(new Error('try max num'))
     let id
     let type
     if (tagId) {
@@ -85,24 +90,26 @@ export default {
     } else {
       id = null
     }
-    this._requestObj_list = httpFatch(this.getListUrl({ sortId, id, type, page }))
+    this._requestObj_list = httpFetch(this.getListUrl({ sortId, id, type, page }))
     return this._requestObj_list.promise.then(({ body }) => {
       if (!id || type == '10000') {
-        if (body.code !== this.successCode) return this.getListUrl({ sortId, id, type, page })
+        if (body.code !== this.successCode) return this.getList(sortId, id, type, page, ++tryNum)
         return {
           list: this.filterList(body.data.data),
           total: body.data.total,
           page: body.data.pn,
           limit: body.data.rn,
+          source: 'kw',
         }
       } else if (!body.length) {
-        return this.getListUrl({ sortId, id, type, page })
+        return this.getList(sortId, id, type, page, ++tryNum)
       }
       return {
         list: this.filterList2(body),
         total: 1000,
         page,
         limit: 1000,
+        source: 'kw',
       }
     })
   },
@@ -127,6 +134,7 @@ export default {
       img: item.img,
       grade: item.favorcnt / 10,
       desc: item.desc,
+      source: 'kw',
     }))
   },
   filterList2(rawData) {
@@ -148,18 +156,27 @@ export default {
   },
 
   // 获取歌曲列表内的音乐
-  getListDetail(id, page) {
+  getListDetail(id, page, tryNum = 0) {
     if (this._requestObj_listDetail) {
       this._requestObj_listDetail.cancelHttp()
     }
-    this._requestObj_listDetail = httpFatch(this.getListDetailUrl(id, page))
+    if (tryNum > 2) return Promise.reject(new Error('try max num'))
+    this._requestObj_listDetail = httpFetch(this.getListDetailUrl(id, page))
     return this._requestObj_listDetail.promise.then(({ body }) => {
-      if (body.result !== 'ok') return this.getListDetail(id, page)
+      if (body.result !== 'ok') return this.getListDetail(id, page, ++tryNum)
       return {
         list: this.filterListDetail(body.musiclist),
         page,
         limit: body.rn,
         total: body.total,
+        source: 'kw',
+        info: {
+          name: body.title,
+          img: body.pic,
+          desc: body.info,
+          author: body.uname,
+          play_count: this.formatPlayCount(body.playnum),
+        },
       }
     })
   },
@@ -183,7 +200,7 @@ export default {
       }
       if (formats.indexOf('ALFLAC')) {
         types.push({ type: 'flac', size: null })
-        _types['flac'] = {
+        _types.flac = {
           size: null,
         }
       }
@@ -205,7 +222,7 @@ export default {
     })
   },
   getTags() {
-    return Promise.all([this.getTag(), this.getHotTag()]).then(([tags, hotTag]) => ({ tags, hotTag }))
+    return Promise.all([this.getTag(), this.getHotTag()]).then(([tags, hotTag]) => ({ tags, hotTag, source: 'kw' }))
   },
 }
 

src/renderer/utils/music/kw/tempSearch.js

@@ -8,10 +8,7 @@ export default {
   _musicTempSearchRequestObj: null,
   _musicTempSearchPromiseCancelFn: null,
   tempSearch(str) {
-    if (this._musicTempSearchRequestObj != null) {
-      cancelHttp(this._musicTempSearchRequestObj)
-      this._musicTempSearchPromiseCancelFn(new Error('取消http请求'))
-    }
+    this.cancelTempSearch()
     return new Promise((resolve, reject) => {
       this._musicTempSearchPromiseCancelFn = reject
       this._musicTempSearchRequestObj = httpGet(`http://www.kuwo.cn/api/www/search/searchKey?key=${encodeURIComponent(str)}`, (err, resp, body) => {

src/renderer/utils/music/mg/api-test.js

@@ -0,0 +1,20 @@
+import { httpFetch } from '../../request'
+import { requestMsg } from '../../message'
+import { headers, timeout } from '../options'
+
+const api_test = {
+  getMusicUrl(songInfo, type) {
+    const requestObj = httpFetch(`http://ts.tempmusic.tk/url/mg/${songInfo.copyrightId}/${type}`, {
+      method: 'get',
+      timeout,
+      headers,
+      family: 4,
+    })
+    requestObj.promise = requestObj.promise.then(({ body }) => {
+      return body.code === 0 ? Promise.resolve({ type, url: encodeURI(body.data) }) : Promise.reject(new Error(requestMsg.fail))
+    })
+    return requestObj
+  },
+}
+
+export default api_test

src/renderer/utils/music/mg/index.js

@@ -0,0 +1,23 @@
+import api_source from '../api-source'
+import leaderboard from './leaderboard'
+import songList from './songList'
+import musicSearch from './musicSearch'
+import pic from './pic'
+import lyric from './lyric'
+
+const mg = {
+  songList,
+  musicSearch,
+  leaderboard,
+  getMusicUrl(songInfo, type) {
+    return api_source('mg').getMusicUrl(songInfo, type)
+  },
+  getLyric(songInfo) {
+    return lyric.getLyric(songInfo)
+  },
+  getPic(songInfo) {
+    return pic.getPic(songInfo)
+  },
+}
+
+export default mg

src/renderer/utils/music/mg/leaderboard.js

@@ -0,0 +1,130 @@
+import { httpFetch } from '../../request'
+// import { formatPlayTime } from '../../index'
+// import jshtmlencode from 'js-htmlencode'
+
+export default {
+  limit: 200,
+  list: [
+    {
+      id: 'mgyyb',
+      name: '音乐榜',
+      bangid: '23603703',
+    },
+    {
+      id: 'mgysb',
+      name: '影视榜',
+      bangid: '23603721',
+    },
+    {
+      id: 'mghybnd',
+      name: '华语内地榜',
+      bangid: '23603926',
+    },
+    {
+      id: 'mghyjqbgt',
+      name: '华语港台榜',
+      bangid: '23603954',
+    },
+    {
+      id: 'mgomb',
+      name: '欧美榜',
+      bangid: '23603974',
+    },
+    {
+      id: 'mgrhb',
+      name: '日韩榜',
+      bangid: '23603982',
+    },
+    {
+      id: 'mgwlb',
+      name: '网络榜',
+      bangid: '23604058',
+    },
+    {
+      id: 'mgclb',
+      name: '彩铃榜',
+      bangid: '23604023',
+    },
+    {
+      id: 'mgktvb',
+      name: 'KTV榜',
+      bangid: '23604040',
+    },
+    {
+      id: 'mgrcb',
+      name: '原创榜',
+      bangid: '23604032',
+    },
+  ],
+  getUrl(id, page) {
+    return `http://m.music.migu.cn/migu/remoting/cms_list_tag?nid=${id}&pageSize=${this.limit}&pageNo=${page - 1}`
+  },
+  requestObj: null,
+  getData(url) {
+    if (this.requestObj) this.requestObj.cancelHttp()
+    this.requestObj = httpFetch(url)
+    return this.requestObj.promise
+  },
+  filterData(rawList) {
+    // console.log(rawList)
+    const list = []
+    rawList.forEach(({ songData }) => {
+      if (!songData) return
+
+      const types = []
+      const _types = {}
+      let size = null
+      types.push({ type: '128k', size })
+      _types['128k'] = {
+        size,
+      }
+
+      if (songData.hasHQqq === '1') {
+        types.push({ type: '320k', size })
+        _types['320k'] = {
+          size,
+        }
+      }
+      if (songData.hasSQqq === '1') {
+        types.push({ type: 'flac', size })
+        _types.flac = {
+          size,
+        }
+      }
+      // types.reverse()
+
+      list.push({
+        singer: songData.singerName.join('、'),
+        name: songData.songName,
+        // albumName: songData.album_title,
+        // albumId: songData.album_id,
+        source: 'mg',
+        interval: null,
+        songmid: songData.songId,
+        copyrightId: songData.copyrightId,
+        img: songData.picL || songData.M || songData.picS,
+        lrc: null,
+        types,
+        _types,
+        typeUrl: {},
+      })
+    })
+
+    return list
+  },
+  getList(id, page) {
+    let type = this.list.find(s => s.id === id)
+    if (!type) return Promise.reject()
+    return this.getData(this.getUrl(type.bangid, page)).then(({ statusCode, body }) => {
+      if (statusCode !== 200) return Promise.reject(new Error('获取列表失败'))
+      const list = this.filterData(body.result.results)
+      return {
+        total: body.result.totalCount,
+        list,
+        limit: body.result.pageSize,
+        page,
+        source: 'mg',
+      }
+    })
+  },
+}

src/renderer/utils/music/mg/lyric.js

@@ -0,0 +1,36 @@
+import { httpFetch } from '../../request'
+
+export default {
+  getLyric(songInfo, tryNum = 0) {
+    console.log(songInfo.copyrightId)
+    if (songInfo.lrcUrl) {
+      let requestObj = httpFetch(songInfo.lrcUrl)
+      requestObj.promise = requestObj.promise.then(({ body, statusCode }) => {
+        if (statusCode !== 200) {
+          if (tryNum > 5) return Promise.reject('歌词获取失败')
+          let tryRequestObj = this.getLyric(songInfo, ++tryNum)
+          requestObj.cancelHttp = tryRequestObj.cancelHttp.bind(tryRequestObj)
+          return tryRequestObj.promise
+        }
+        return body
+      })
+      return requestObj
+    } else {
+      let requestObj = httpFetch(`http://music.migu.cn/v3/api/music/audioPlayer/getLyric?copyrightId=${songInfo.copyrightId}`, {
+        headers: {
+          Referer: 'http://music.migu.cn/v3/music/player/audio?from=migu',
+        },
+      })
+      requestObj.promise = requestObj.promise.then(({ body }) => {
+        if (body.returnCode !== '000000') {
+          if (tryNum > 5) return Promise.reject('歌词获取失败')
+          let tryRequestObj = this.getLyric(songInfo, ++tryNum)
+          requestObj.cancelHttp = tryRequestObj.cancelHttp.bind(tryRequestObj)
+          return tryRequestObj.promise
+        }
+        return body.lyric
+      })
+      return requestObj
+    }
+  },
+}

src/renderer/utils/music/mg/musicSearch.js

@@ -0,0 +1,108 @@
+// import '../../polyfill/array.find'
+// import jshtmlencode from 'js-htmlencode'
+import { httpFetch } from '../../request'
+import { sizeFormate } from '../../index'
+// import { debug } from '../../utils/env'
+// import { formatSinger } from './util'
+
+let searchRequest
+export default {
+  limit: 30,
+  total: 0,
+  page: 0,
+  allPage: 1,
+  musicSearch(str, page) {
+    if (searchRequest && searchRequest.cancelHttp) searchRequest.cancelHttp()
+    searchRequest = httpFetch(`https://app.c.nf.migu.cn/MIGUM2.0/v1.0/content/search_all.do?isCopyright=1&isCorrect=1&pageNo=${page}&pageSize=${this.limit}&searchSwitch={%22song%22:1,%22album%22:0,%22singer%22:0,%22tagSong%22:0,%22mvSong%22:0,%22songlist%22:0,%22bestShow%22:0}&sort=0&text=${encodeURIComponent(str)}`)
+    return searchRequest.promise.then(({ body }) => body)
+  },
+  getSinger(singers) {
+    let arr = []
+    singers.forEach(singer => {
+      arr.push(singer.name)
+    })
+    return arr.join('、')
+  },
+  handleResult(rawData) {
+    // console.log(rawData)
+    let ids = new Set()
+    const list = []
+    rawData.forEach(item => {
+      if (ids.has(item.id)) return
+      ids.add(item.id)
+      const types = []
+      const _types = {}
+      item.rateFormats && item.rateFormats.forEach(type => {
+        let size
+        switch (type.formatType) {
+          case 'PQ':
+            size = sizeFormate(type.size)
+            types.push({ type: '128k', size })
+            _types['128k'] = {
+              size,
+            }
+            break
+          case 'HQ':
+            size = sizeFormate(type.size)
+            types.push({ type: '320k', size })
+            _types['320k'] = {
+              size,
+            }
+            break
+          case 'SQ':
+            size = sizeFormate(type.size)
+            types.push({ type: 'flac', size })
+            _types.flac = {
+              size,
+            }
+            break
+        }
+      })
+
+      const albumNInfo = item.albums && item.albums.length ? {
+        id: item.albums[0].id,
+        name: item.albums[0].name,
+      } : {}
+
+      list.push({
+        singer: this.getSinger(item.singers),
+        name: item.name,
+        albumName: albumNInfo.name,
+        albumId: albumNInfo.id,
+        songmid: item.id,
+        copyrightId: item.copyrightId,
+        source: 'mg',
+        interval: null,
+        img: item.imgItems && item.imgItems.length ? item.imgItems[0].img : null,
+        lrc: null,
+        lrcUrl: item.lyricUrl,
+        types,
+        _types,
+        typeUrl: {},
+      })
+    })
+    return list
+  },
+  search(str, page = 1, { limit } = {}) {
+    if (limit != null) this.limit = limit
+    // http://newlyric.kuwo.cn/newlyric.lrc?62355680
+    return this.musicSearch(str, page).then(result => {
+      if (!result || result.code !== '000000') return this.search(str, page, { limit })
+      let list = this.handleResult(result.songResultData.resultList.flat())
+
+      if (list == null) return this.search(str, page, { limit })
+
+      this.total = parseInt(result.songResultData.totalCount)
+      this.page = page
+      this.allPage = Math.ceil(this.total / this.limit)
+
+      return Promise.resolve({
+        list,
+        allPage: this.allPage,
+        limit: this.limit,
+        total: this.total,
+        source: 'mg',
+      })
+    })
+  },
+}

src/renderer/utils/music/mg/pic.js

@@ -0,0 +1,21 @@
+import { httpFetch } from '../../request'
+
+export default {
+  getPic(songInfo, tryNum = 0) {
+    let requestObj = httpFetch(`http://music.migu.cn/v3/api/music/audioPlayer/getSongPic?songId=${songInfo.songmid}`, {
+      headers: {
+        Referer: 'http://music.migu.cn/v3/music/player/audio?from=migu',
+      },
+    })
+    requestObj.promise = requestObj.promise.then(({ body }) => {
+      if (body.returnCode !== '000000') {
+        if (tryNum > 5) return Promise.reject('图片获取失败')
+        let tryRequestObj = this.getPic(songInfo, ++tryNum)
+        requestObj.cancelHttp = tryRequestObj.cancelHttp.bind(tryRequestObj)
+        return tryRequestObj.promise
+      }
+      return body.largePic || body.mediumPic || body.smallPic
+    })
+    return requestObj
+  },
+}

src/renderer/utils/music/mg/songList.js

@@ -0,0 +1,224 @@
+import { httpFetch } from '../../request'
+import { sizeFormate } from '../../index'
+
+export default {
+  _requestObj_tags: null,
+  _requestObj_list: null,
+  _requestObj_listDetail: null,
+  limit_list: 10,
+  limit_song: 1000,
+  successCode: '000000',
+  sortList: [
+    {
+      name: '推荐',
+      id: '15127315',
+    },
+    {
+      name: '最新',
+      id: '15127272',
+    },
+  ],
+  regExps: {
+    list: /<li><div class="thumb">.+?<\/li>/g,
+    listInfo: /.+data-original="(.+?)".*data-id="(\d+)".*<div class="song-list-name"><a\s.*?>(.+?)<\/a>.+<i class="iconfont cf-bofangliang"><\/i>(.+?)<\/div>/,
+  },
+  tagsUrl: 'https://app.c.nf.migu.cn/MIGUM2.0/v1.0/content/indexTagPage.do?needAll=0',
+  getSongListUrl(sortId, tagId, page) {
+    // if (tagId == null) {
+    //   return sortId == 'recommend'
+    //     ? `http://music.migu.cn/v3/music/playlist?page=${page}&from=migu`
+    //     : `http://music.migu.cn/v3/music/playlist?sort=${sortId}&page=${page}&from=migu`
+    // }
+    // return `http://music.migu.cn/v3/music/playlist?tagId=${tagId}&page=${page}&from=migu`
+    if (tagId == null) {
+      return `http://m.music.migu.cn/migu/remoting/playlist_bycolumnid_tag?playListType=2&type=1&columnId=${sortId}&startIndex=${(page - 1) * 10}`
+    }
+    return `http://m.music.migu.cn/migu/remoting/playlist_bycolumnid_tag?playListType=2&type=1&tagId=${tagId}&startIndex=${(page - 1) * 10}`
+  },
+  getSongListDetailUrl(id, page) {
+    return `https://app.c.nf.migu.cn/MIGUM2.0/v1.0/user/queryMusicListSongs.do?musicListId=${id}&pageNo=${page}&pageSize=${this.limit_song}`
+  },
+  defaultHeaders: {
+    language: 'Chinese',
+    ua: 'Android_migu',
+    mode: 'android',
+    version: '6.8.5',
+  },
+
+  /**
+   * 格式化播放数量
+   * @param {*} num
+   */
+  formatPlayCount(num) {
+    if (num > 100000000) return parseInt(num / 10000000) / 10 + '亿'
+    if (num > 10000) return parseInt(num / 1000) / 10 + '万'
+    return num
+  },
+
+  getListDetail(id, page, tryNum = 0) { // 获取歌曲列表内的音乐
+    if (this._requestObj_listDetail) this._requestObj_listDetail.cancelHttp()
+    if (tryNum > 2) return Promise.reject(new Error('try max num'))
+    this._requestObj_listDetail = httpFetch(this.getSongListDetailUrl(id, page), { headers: this.defaultHeaders })
+    return this._requestObj_listDetail.promise.then(({ body }) => {
+      if (body.code !== this.successCode) return this.getListDetail(id, page, ++tryNum)
+      // console.log(JSON.stringify(body))
+      return {
+        list: this.filterListDetail(body.list),
+        page,
+        limit: this.limit_song,
+        total: body.totalCount,
+        source: 'mg',
+        info: {
+          // name: body.result.info.list_title,
+          // img: body.result.info.list_pic,
+          // desc: body.result.info.list_desc,
+          // author: body.result.info.userinfo.username,
+          // play_count: this.formatPlayCount(body.result.listen_num),
+        },
+      }
+    })
+  },
+  filterListDetail(rawList) {
+    // console.log(rawList)
+    let ids = new Set()
+    const list = []
+    rawList.forEach(item => {
+      if (ids.has(item.songId)) return
+      ids.add(item.songId)
+      const types = []
+      const _types = {}
+      item.rateFormats && item.rateFormats.forEach(type => {
+        let size
+        switch (type.formatType) {
+          case 'PQ':
+            size = sizeFormate(type.size)
+            types.push({ type: '128k', size })
+            _types['128k'] = {
+              size,
+            }
+            break
+          case 'HQ':
+            size = sizeFormate(type.size)
+            types.push({ type: '320k', size })
+            _types['320k'] = {
+              size,
+            }
+            break
+          case 'SQ':
+            size = sizeFormate(type.size)
+            types.push({ type: 'flac', size })
+            _types.flac = {
+              size,
+            }
+            break
+        }
+      })
+
+
+      list.push({
+        singer: item.singer,
+        name: item.songName,
+        albumName: item.album,
+        albumId: item.albumId,
+        songmid: item.songId,
+        copyrightId: item.copyrightId,
+        source: 'mg',
+        interval: null,
+        img: item.albumImgs && item.albumImgs.length ? item.albumImgs[0].img : null,
+        lrc: null,
+        lrcUrl: item.lrcUrl,
+        types,
+        _types,
+        typeUrl: {},
+      })
+    })
+    return list
+  },
+
+  // 获取列表数据
+  getList(sortId, tagId, page, tryNum = 0) {
+    if (this._requestObj_list) this._requestObj_list.cancelHttp()
+    if (tryNum > 2) return Promise.reject(new Error('try max num'))
+    this._requestObj_list = httpFetch(this.getSongListUrl(sortId, tagId, page))
+    // return this._requestObj_list.promise.then(({ statusCode, body }) => {
+    //   if (statusCode !== 200) return this.getList(sortId, tagId, page)
+    //   let list = body.replace(/[\r\n]/g, '').match(this.regExps.list)
+    //   if (!list) return Promise.reject('获取列表失败')
+    //   return list.map(item => {
+    //     let info = item.match(this.regExps.listInfo)
+    //     return {
+    //       play_count: info[4],
+    //       id: info[2],
+    //       author: '',
+    //       name: info[3],
+    //       time: '',
+    //       img: info[1],
+    //       grade: 0,
+    //       desc: '',
+    //       source: 'mg',
+    //     }
+    //   })
+    // })
+    return this._requestObj_list.promise.then(({ body }) => {
+      if (body.retCode !== '100000' || body.retMsg.code !== this.successCode) return this.getList(sortId, tagId, page, ++tryNum)
+      return {
+        list: this.filterList(body.retMsg.playlist),
+        total: parseInt(body.retMsg.countSize),
+        page,
+        limit: this.limit_list,
+        source: 'mg',
+      }
+    })
+  },
+  filterList(rawData) {
+    return rawData.map(item => ({
+      play_count: this.formatPlayCount(item.playCount),
+      id: item.playListId,
+      author: item.createName,
+      name: item.playListName,
+      time: item.createTime,
+      img: item.image,
+      grade: item.grade,
+      desc: item.summary,
+      source: 'mg',
+    }))
+  },
+
+  // 获取标签
+  getTag(tryNum = 0) {
+    if (this._requestObj_tags) this._requestObj_tags.cancelHttp()
+    if (tryNum > 2) return Promise.reject(new Error('try max num'))
+    this._requestObj_tags = httpFetch(this.tagsUrl, { headers: this.defaultHeaders })
+    return this._requestObj_tags.promise.then(({ body }) => {
+      if (body.code !== this.successCode) return this.getTag(++tryNum)
+      return this.filterTagInfo(body.columnInfo.contents)
+    })
+  },
+  filterTagInfo(rawList) {
+    return {
+      hotTag: rawList[0].objectInfo.contents.map(item => ({
+        id: item.objectInfo.tagId,
+        name: item.objectInfo.tagName,
+        source: 'mg',
+      })),
+      tags: rawList.slice(1).map(({ objectInfo }) => ({
+        name: objectInfo.columnTitle,
+        list: objectInfo.contents.map(item => ({
+          parent_id: objectInfo.columnId,
+          parent_name: objectInfo.columnTitle,
+          id: item.objectInfo.tagId,
+          name: item.objectInfo.tagName,
+          source: 'mg',
+        })),
+      })),
+      source: 'mg',
+    }
+  },
+  getTags() {
+    return this.getTag()
+  },
+}
+
+// getList
+// getTags
+// getListDetail

src/renderer/utils/music/tx/api-test.js

@@ -1,16 +1,17 @@
-import { httpFatch } from '../../request'
+import { httpFetch } from '../../request'
 import { requestMsg } from '../../message'
-import { headers, timeout } from '../messoer'
+import { headers, timeout } from '../options'
 
 const api_messoer = {
   getMusicUrl(songInfo, type) {
-    const requestObj = httpFatch(`https://v1.itooi.cn/tencent/url?id=${songInfo.strMediaMid}&quality=${type.replace(/k$/, '')}`, {
+    const requestObj = httpFetch(`http://ts.tempmusic.tk/url/tx/${songInfo.strMediaMid}/${type}`, {
       method: 'get',
       timeout,
       headers,
+      family: 4,
     })
     requestObj.promise = requestObj.promise.then(({ body }) => {
-      return body.code === 200 ? Promise.resolve({ type, url: body.data }) : Promise.reject(new Error(requestMsg.fail))
+      return body.code === 0 ? Promise.resolve({ type, url: body.data }) : Promise.reject(new Error(requestMsg.fail))
     })
     return requestObj
   },

src/renderer/utils/music/tx/index.js

@@ -1,9 +1,13 @@
 import leaderboard from './leaderboard'
 import lyric from './lyric'
+import songList from './songList'
+import musicSearch from './musicSearch'
 import api_source from '../api-source'
 
 const tx = {
   leaderboard,
+  songList,
+  musicSearch,
 
   getMusicUrl(songInfo, type) {
     return api_source('tx').getMusicUrl(songInfo, type)

src/renderer/utils/music/tx/leaderboard.js

@@ -196,6 +196,7 @@ export default {
           list: this.filterData(data.toplist.data.songInfoList),
           limit: this.limit,
           page: 1,
+          source: 'tx',
         }
       })
     })

src/renderer/utils/music/tx/lyric.js

@@ -1,4 +1,4 @@
-import { httpFatch } from '../../request'
+import { httpFetch } from '../../request'
 import { b64DecodeUnicode } from '../../index'
 
 export default {
@@ -6,7 +6,7 @@ export default {
     matchLrc: /.+"lyric":"([\w=+/]*)".+/,
   },
   getLyric(songmid) {
-    const requestObj = httpFatch(`https://c.y.qq.com/lyric/fcgi-bin/fcg_query_lyric_new.fcg?songmid=${songmid}&g_tk=2001461048&loginUin=0&hostUin=0&format=jsonp&inCharset=utf8&outCharset=utf-8&platform=yqq`, {
+    const requestObj = httpFetch(`https://c.y.qq.com/lyric/fcgi-bin/fcg_query_lyric_new.fcg?songmid=${songmid}&g_tk=2001461048&loginUin=0&hostUin=0&format=jsonp&inCharset=utf8&outCharset=utf-8&platform=yqq`, {
       headers: {
         Referer: 'https://y.qq.com/portal/player.html',
       },

src/renderer/utils/music/tx/musicSearch.js

@@ -0,0 +1,106 @@
+// import '../../polyfill/array.find'
+// import jshtmlencode from 'js-htmlencode'
+import { httpFetch } from '../../request'
+import { formatPlayTime, sizeFormate } from '../../index'
+// import { debug } from '../../utils/env'
+// import { formatSinger } from './util'
+
+let searchRequest
+export default {
+  limit: 30,
+  total: 0,
+  page: 0,
+  allPage: 1,
+  successCode: 0,
+  musicSearch(str, page, retryNum = 0) {
+    if (searchRequest && searchRequest.cancelHttp) searchRequest.cancelHttp()
+    if (retryNum > 5) return Promise.reject(new Error('搜索失败'))
+    searchRequest = httpFetch(`https://c.y.qq.com/soso/fcgi-bin/client_search_cp?ct=24&qqmusic_ver=1298&new_json=1&remoteplace=sizer.yqq.song_next&searchid=49252838123499591&t=0&aggr=1&cr=1&catZhida=1&lossless=0&flag_qc=0&p=${page}&n=${this.limit}&w=${encodeURIComponent(str)}&loginUin=0&hostUin=0&format=json&inCharset=utf8&outCharset=utf-8&notice=0&platform=yqq&needNewCode=0`)
+    // searchRequest = httpFetch(`http://ioscdn.kugou.com/api/v3/search/song?keyword=${encodeURIComponent(str)}&page=${page}&pagesize=${this.limit}&showtype=10&plat=2&version=7910&tag=1&correct=1&privilege=1&sver=5`)
+    return searchRequest.promise.then(({ body }) => {
+      if (body.code !== this.successCode) return this.musicSearch(str, page, ++retryNum)
+      return body.data
+    })
+  },
+  getSinger(singers) {
+    let arr = []
+    singers.forEach(singer => {
+      arr.push(singer.name)
+    })
+    return arr.join('、')
+  },
+  handleResult(rawList) {
+    // console.log(rawData)
+    return rawList.map(item => {
+      let types = []
+      let _types = {}
+      if (item.file.size_128mp3 !== 0) {
+        let size = sizeFormate(item.file.size_128mp3)
+        types.push({ type: '128k', size })
+        _types['128k'] = {
+          size,
+        }
+      }
+      if (item.file.size_320mp3 !== 0) {
+        let size = sizeFormate(item.file.size_320mp3)
+        types.push({ type: '320k', size })
+        _types['320k'] = {
+          size,
+        }
+      }
+      if (item.file.size_ape !== 0) {
+        let size = sizeFormate(item.file.size_ape)
+        types.push({ type: 'ape', size })
+        _types.ape = {
+          size,
+        }
+      }
+      if (item.file.size_flac !== 0) {
+        let size = sizeFormate(item.file.size_flac)
+        types.push({ type: 'flac', size })
+        _types.flac = {
+          size,
+        }
+      }
+      // types.reverse()
+      return {
+        singer: this.getSinger(item.singer),
+        name: item.title,
+        albumName: item.album.title,
+        albumId: item.album.mid,
+        source: 'tx',
+        interval: formatPlayTime(item.interval),
+        songId: item.id,
+        albumMid: item.album.mid,
+        strMediaMid: item.file.strMediaMid,
+        songmid: item.mid,
+        img: (item.album.name === '' || item.album.name === '空')
+          ? `https://y.gtimg.cn/music/photo_new/T001R500x500M000${item.singer[0].mid}.jpg`
+          : `https://y.gtimg.cn/music/photo_new/T002R500x500M000${item.album.mid}.jpg`,
+        lrc: null,
+        types,
+        _types,
+        typeUrl: {},
+      }
+    })
+  },
+  search(str, page = 1, { limit } = {}) {
+    if (limit != null) this.limit = limit
+    // http://newlyric.kuwo.cn/newlyric.lrc?62355680
+    return this.musicSearch(str, page).then(({ song }) => {
+      let list = this.handleResult(song.list)
+
+      this.total = song.totalnum
+      this.page = page
+      this.allPage = Math.ceil(this.total / this.limit)
+
+      return Promise.resolve({
+        list,
+        allPage: this.allPage,
+        limit: this.limit,
+        total: this.total,
+        source: 'tx',
+      })
+    })
+  },
+}

src/renderer/utils/music/tx/songList.js

@@ -0,0 +1,270 @@
+import { httpFetch } from '../../request'
+import { formatPlayTime, sizeFormate } from '../../index'
+import jshtmlencode from 'js-htmlencode'
+
+export default {
+  _requestObj_tags: null,
+  _requestObj_hotTags: null,
+  _requestObj_list: null,
+  _requestObj_listDetail: null,
+  limit_list: 36,
+  limit_song: 10000000,
+  successCode: 0,
+  sortList: [
+    {
+      name: '最热',
+      id: 5,
+    },
+    {
+      name: '最新',
+      id: 2,
+    },
+  ],
+  regexps: {
+    hotTagHtml: /class="c_bg_link js_tag_item" data-id="\w+">.+?<\/a>/g,
+    hotTag: /data-id="(\w+)">(.+?)<\/a>/,
+  },
+  tagsUrl: 'https://u.y.qq.com/cgi-bin/musicu.fcg?loginUin=0&hostUin=0&format=json&inCharset=utf-8&outCharset=utf-8&notice=0&platform=wk_v15.json&needNewCode=0&data=%7B%22tags%22%3A%7B%22method%22%3A%22get_all_categories%22%2C%22param%22%3A%7B%22qq%22%3A%22%22%7D%2C%22module%22%3A%22playlist.PlaylistAllCategoriesServer%22%7D%7D',
+  hotTagUrl: 'https://c.y.qq.com/node/pc/wk_v15/category_playlist.html',
+  getListUrl(sortId, id, page) {
+    return id ? `https://u.y.qq.com/cgi-bin/musicu.fcg?loginUin=0&hostUin=0&format=json&inCharset=utf-8&outCharset=utf-8&notice=0&platform=wk_v15.json&needNewCode=0&data=${encodeURIComponent(JSON.stringify({
+      comm: { cv: 1602, ct: 20 },
+      playlist: {
+        method: 'get_category_content',
+        param: {
+          titleid: id,
+          caller: '0',
+          category_id: id,
+          size: this.limit_list,
+          page: page - 1,
+          use_page: 1,
+        },
+        module: 'playlist.PlayListCategoryServer',
+      },
+      }))}` : `https://u.y.qq.com/cgi-bin/musicu.fcg?loginUin=0&hostUin=0&format=json&inCharset=utf-8&outCharset=utf-8&notice=0&platform=wk_v15.json&needNewCode=0&data=${encodeURIComponent(JSON.stringify({
+          comm: { cv: 1602, ct: 20 },
+          playlist: {
+            method: 'get_playlist_by_tag',
+            param: { id: 10000000, sin: this.limit_list * (page - 1), size: this.limit_list, order: sortId, cur_page: page },
+            module: 'playlist.PlayListPlazaServer',
+          },
+      }))}`
+  },
+  getListDetailUrl(id) {
+    return `https://c.y.qq.com/qzone/fcg-bin/fcg_ucc_getcdinfo_byids_cp.fcg?type=1&json=1&utf8=1&onlysong=0&new_format=1&disstid=${id}&loginUin=0&hostUin=0&format=json&inCharset=utf8&outCharset=utf-8&notice=0&platform=yqq.json&needNewCode=0`
+  },
+
+  // http://nplserver.kuwo.cn/pl.svc?op=getlistinfo&pid=2849349915&pn=0&rn=100&encode=utf8&keyset=pl2012&identity=kuwo&pcmp4=1&vipver=MUSIC_9.0.5.0_W1&newver=1
+  // 获取标签
+  getTag(tryNum = 0) {
+    if (this._requestObj_tags) this._requestObj_tags.cancelHttp()
+    if (tryNum > 2) return Promise.reject(new Error('try max num'))
+    this._requestObj_tags = httpFetch(this.tagsUrl)
+    return this._requestObj_tags.promise.then(({ body }) => {
+      if (body.code !== this.successCode) return this.getTag(++tryNum)
+      return this.filterTagInfo(body.tags.data.v_group)
+    })
+  },
+  // 获取标签
+  getHotTag(tryNum = 0) {
+    if (this._requestObj_hotTags) this._requestObj_hotTags.cancelHttp()
+    if (tryNum > 2) return Promise.reject(new Error('try max num'))
+    this._requestObj_hotTags = httpFetch(this.hotTagUrl)
+    return this._requestObj_hotTags.promise.then(({ statusCode, body }) => {
+      if (statusCode !== 200) return this.getHotTag(++tryNum)
+      return this.filterInfoHotTag(body)
+    })
+  },
+  filterInfoHotTag(html) {
+    let hotTag = html.match(this.regexps.hotTagHtml)
+    const hotTags = []
+    if (!hotTag) return hotTags
+
+    hotTag.forEach(tagHtml => {
+      let result = tagHtml.match(this.regexps.hotTag)
+      if (!result) return
+      hotTags.push({
+        id: result[1],
+        name: result[2],
+        source: 'tx',
+      })
+    })
+    return hotTags
+  },
+  filterTagInfo(rawList) {
+    return rawList.map(type => ({
+      name: type.group_name,
+      list: type.v_item.map(item => ({
+        parent_id: type.group_id,
+        parent_name: type.group_name,
+        id: item.id,
+        name: item.name,
+        source: 'tx',
+      })),
+    }))
+  },
+
+  // 获取列表数据
+  getList(sortId, tagId, page, tryNum = 0) {
+    if (this._requestObj_list) this._requestObj_list.cancelHttp()
+    if (tryNum > 2) return Promise.reject(new Error('try max num'))
+    this._requestObj_list = httpFetch(
+      this.getListUrl(sortId, tagId, page)
+    )
+    return this._requestObj_list.promise.then(({ body }) => {
+      if (body.code !== this.successCode) return this.getList(sortId, tagId, page, ++tryNum)
+      return tagId ? this.filterList2(body.playlist.data, page) : this.filterList(body.playlist.data, page)
+    })
+  },
+
+
+  /**
+   * 格式化播放数量
+   * @param {*} num
+   */
+  formatPlayCount(num) {
+    if (num > 100000000) return parseInt(num / 10000000) / 10 + '亿'
+    if (num > 10000) return parseInt(num / 1000) / 10 + '万'
+    return num
+  },
+  filterList(data, page) {
+    return {
+      list: data.v_playlist.map(item => ({
+        play_count: this.formatPlayCount(item.access_num),
+        id: item.tid,
+        author: item.creator_info.nick,
+        name: item.title,
+        // time: item.publish_time,
+        img: item.cover_url_medium,
+        // grade: item.favorcnt / 10,
+        desc: item.desc,
+        source: 'tx',
+      })),
+      total: data.total,
+      page,
+      limit: this.limit_list,
+      source: 'tx',
+    }
+  },
+  filterList2({ content }, page) {
+    // console.log(content.v_item)
+    return {
+      list: content.v_item.map(({ basic }) => ({
+        play_count: this.formatPlayCount(basic.play_cnt),
+        id: basic.tid,
+        author: basic.creator.nick,
+        name: basic.title,
+        // time: basic.publish_time,
+        img: basic.cover.medium_url || basic.cover.default_url,
+        // grade: basic.favorcnt / 10,
+        desc: jshtmlencode.htmlDecode(basic.desc).replace(/<br>/g, '\n'),
+        source: 'tx',
+      })),
+      total: content.total_cnt,
+      page,
+      limit: this.limit_list,
+      source: 'tx',
+    }
+  },
+
+  // 获取歌曲列表内的音乐
+  getListDetail(id, tryNum = 0) {
+    if (this._requestObj_listDetail) {
+      this._requestObj_listDetail.cancelHttp()
+    }
+    if (tryNum > 2) return Promise.reject(new Error('try max num'))
+    this._requestObj_listDetail = httpFetch(this.getListDetailUrl(id), {
+      headers: {
+        Origin: 'https://y.qq.com',
+        Referer: `https://y.qq.com/n/yqq/playsquare/${id}.html`,
+      },
+    })
+    return this._requestObj_listDetail.promise.then(({ body }) => {
+      if (body.code !== this.successCode) return this.getListDetail(id, ++tryNum)
+      const cdlist = body.cdlist[0]
+      return {
+        list: this.filterListDetail(cdlist.songlist),
+        page: 1,
+        limit: cdlist.songlist.length + 1,
+        total: cdlist.songlist.length,
+        source: 'tx',
+        info: {
+          name: cdlist.dissname,
+          img: cdlist.logo,
+          desc: jshtmlencode.htmlDecode(cdlist.desc).replace(/<br>/g, '\n'),
+          author: cdlist.nickname,
+          play_count: this.formatPlayCount(cdlist.visitnum),
+        },
+      }
+    })
+  },
+  getSinger(singers) {
+    let arr = []
+    singers.forEach(singer => {
+      arr.push(singer.name)
+    })
+    return arr.join('、')
+  },
+  filterListDetail(rawList) {
+    // console.log(rawList)
+    return rawList.map(item => {
+      let types = []
+      let _types = {}
+      if (item.file.size_128mp3 !== 0) {
+        let size = sizeFormate(item.file.size_128mp3)
+        types.push({ type: '128k', size })
+        _types['128k'] = {
+          size,
+        }
+      }
+      if (item.file.size_320mp3 !== 0) {
+        let size = sizeFormate(item.file.size_320mp3)
+        types.push({ type: '320k', size })
+        _types['320k'] = {
+          size,
+        }
+      }
+      if (item.file.size_ape !== 0) {
+        let size = sizeFormate(item.file.size_ape)
+        types.push({ type: 'ape', size })
+        _types.ape = {
+          size,
+        }
+      }
+      if (item.file.size_flac !== 0) {
+        let size = sizeFormate(item.file.size_flac)
+        types.push({ type: 'flac', size })
+        _types.flac = {
+          size,
+        }
+      }
+      // types.reverse()
+      return {
+        singer: this.getSinger(item.singer),
+        name: item.title,
+        albumName: item.album.title,
+        albumId: item.album.mid,
+        source: 'tx',
+        interval: formatPlayTime(item.interval),
+        songId: item.id,
+        albumMid: item.album.mid,
+        strMediaMid: item.file.media_mid,
+        songmid: item.mid,
+        img: (item.album.name === '' || item.album.name === '空')
+          ? `https://y.gtimg.cn/music/photo_new/T001R500x500M000${item.singer[0].mid}.jpg`
+          : `https://y.gtimg.cn/music/photo_new/T002R500x500M000${item.album.mid}.jpg`,
+        lrc: null,
+        types,
+        _types,
+        typeUrl: {},
+      }
+    })
+  },
+  getTags() {
+    return Promise.all([this.getTag(), this.getHotTag()]).then(([tags, hotTag]) => ({ tags, hotTag }))
+  },
+}
+
+// getList
+// getTags
+// getListDetail

src/renderer/utils/music/utils.js

@@ -6,9 +6,10 @@
 
 const types = ['flac', 'ape', '320k', '192k', '128k']
 export const getMusicType = (info, type) => {
-  switch (window.globalObj.apiSource) {
+  switch (info.source) {
     // case 'kg':
     case 'wy':
+    case 'tx':
       return '128k'
   }
   const rangeType = types.slice(types.indexOf(type))

src/renderer/utils/music/wy/api-internal.js

@@ -1,41 +0,0 @@
-import { httpFatch } from '../../request'
-import { requestMsg } from '../../message'
-import { headers, timeout } from '../options'
-
-const api_messoer = {
-  getMusicUrl(songInfo, type) {
-    const requestObj = httpFatch(`https://v1.itooi.cn/netease/url?id=${songInfo.songmid}&quality=${type.replace(/k$/, '')}&isRedirect=0`, {
-      method: 'get',
-      timeout,
-      headers,
-    })
-    requestObj.promise = requestObj.promise.then(({ body }) => {
-      return body.code === 200 ? Promise.resolve({ type, url: body.data }) : Promise.reject(new Error(requestMsg.fail))
-    })
-    return requestObj
-  },
-  getPic(songInfo) {
-    const requestObj = httpFatch(`https://v1.itooi.cn/netease/pic?id=${songInfo.songmid}&isRedirect=0`, {
-      method: 'get',
-      timeout,
-      headers,
-    })
-    requestObj.promise = requestObj.promise.then(({ body }) => {
-      return body.code === 200 ? Promise.resolve(body.data) : Promise.reject(new Error(requestMsg.fail))
-    })
-    return requestObj
-  },
-  getLyric(songInfo) {
-    const requestObj = httpFatch(`https://v1.itooi.cn/netease/lrc?id=${songInfo.songmid}&isRedirect=0`, {
-      method: 'get',
-      timeout,
-      headers,
-    })
-    requestObj.promise = requestObj.promise.then(({ body }) => {
-      return body ? Promise.resolve(body) : Promise.reject(new Error(requestMsg.fail))
-    })
-    return requestObj
-  },
-}
-
-export default api_messoer

src/renderer/utils/music/wy/api-test.js

@@ -1,24 +1,26 @@
-import { httpFatch } from '../../request'
+import { httpFetch } from '../../request'
 import { requestMsg } from '../../message'
 import { headers, timeout } from '../options'
 
 const api_test = {
   getMusicUrl(songInfo, type) {
-    const requestObj = httpFatch(`http://test.tempmusic.tk/url/wy/${songInfo.songmid}/${type}`, {
+    const requestObj = httpFetch(`http://ts.tempmusic.tk/url/wy/${songInfo.songmid}/${type}`, {
       method: 'get',
       timeout,
       headers,
+      family: 4,
     })
     requestObj.promise = requestObj.promise.then(({ body }) => {
       return body.code === 0 ? Promise.resolve({ type, url: body.data }) : Promise.reject(new Error(requestMsg.fail))
     })
     return requestObj
   },
-  getPic(songInfo) {
-    const requestObj = httpFatch(`http://test.tempmusic.tk/pic/wy/${songInfo.songmid}`, {
+/*   getPic(songInfo) {
+    const requestObj = httpFetch(`http://localhost:3100/pic/wy/${songInfo.songmid}`, {
       method: 'get',
       timeout,
       headers,
+      family: 4,
     })
     requestObj.promise = requestObj.promise.then(({ body }) => {
       return body.code === 0 ? Promise.resolve(body.data) : Promise.reject(new Error(requestMsg.fail))
@@ -26,16 +28,17 @@ const api_test = {
     return requestObj
   },
   getLyric(songInfo) {
-    const requestObj = httpFatch(`http://test.tempmusic.tk/lrc/wy/${songInfo.songmid}`, {
+    const requestObj = httpFetch(`http://localhost:3100/lrc/wy/${songInfo.songmid}`, {
       method: 'get',
       timeout,
       headers,
+      family: 4,
     })
     requestObj.promise = requestObj.promise.then(({ body }) => {
       return body.code === 0 ? Promise.resolve(body.data) : Promise.reject(new Error(requestMsg.fail))
     })
     return requestObj
-  },
+  }, */
 }
 
 export default api_test

src/renderer/utils/music/wy/index.js

@@ -1,16 +1,22 @@
 import leaderboard from './leaderboard'
 import api_source from '../api-source'
+import getLyric from './lyric'
+import getMusicInfo from './musicInfo'
+import musicSearch from './musicSearch'
+import songList from './songList'
 
 const wy = {
   leaderboard,
+  musicSearch,
+  songList,
   getMusicUrl(songInfo, type) {
     return api_source('wy').getMusicUrl(songInfo, type)
   },
   getLyric(songInfo) {
-    return api_source('wy').getLyric(songInfo)
+    return getLyric(songInfo.songmid)
   },
   getPic(songInfo) {
-    return api_source('wy').getPic(songInfo)
+    return getMusicInfo(songInfo.songmid).then(info => info.al.picUrl)
   },
 }
 

src/renderer/utils/music/wy/leaderboard.js

@@ -98,7 +98,7 @@ export default {
         case 999000:
           size = null
           types.push({ type: 'flac', size })
-          _types['flac'] = {
+          _types.flac = {
             size,
           }
         case 320000:
@@ -107,13 +107,13 @@ export default {
           _types['320k'] = {
             size,
           }
-        case 192000:
-        case 190000:
-          size = null
-          types.push({ type: '192k', size })
-          _types['192k'] = {
-            size,
-          }
+          // case 192000:
+          // case 190000:
+          //   size = null
+          //   types.push({ type: '192k', size })
+          //   _types['192k'] = {
+          //     size,
+          //   }
           // case '160000':
 
         default:
@@ -155,6 +155,7 @@ export default {
         list,
         limit: this.limit,
         page,
+        source: 'tx',
       }
     })
   },

src/renderer/utils/music/wy/lyric.js

@@ -0,0 +1,21 @@
+import { httpFetch } from '../../request'
+import { weapi } from './utils/crypto'
+
+export default songmid => {
+  const requestObj = httpFetch('http://music.163.com/weapi/song/lyric?csrf_token=', {
+    method: 'post',
+    headers: {
+      'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.90 Safari/537.36',
+      Referer: 'https://music.163.com/song?id=' + songmid,
+      origin: 'https://music.163.com',
+    },
+    form: weapi({ id: songmid, lv: -1, tv: -1, csrf_token: '' }),
+  })
+  requestObj.promise = requestObj.promise.then(({ body }) => {
+    // console.log(body)
+    if (body.code !== 200) return Promise.reject('获取歌词失败')
+    return body.lrc.lyric
+  })
+  return requestObj
+}
+

src/renderer/utils/music/wy/musicInfo.js

@@ -0,0 +1,25 @@
+// https://github.com/Binaryify/NeteaseCloudMusicApi/blob/master/module/song_detail.js
+import { httpFetch } from '../../request'
+import { weapi } from './utils/crypto'
+
+export default songmid => {
+  const requestObj = httpFetch('https://music.163.com/weapi/v3/song/detail', {
+    method: 'post',
+    headers: {
+      'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.90 Safari/537.36',
+      Referer: 'https://music.163.com/song?id=' + songmid,
+      origin: 'https://music.163.com',
+    },
+    form: weapi({
+      c: `[{"id":${songmid}}]`,
+      ids: `[${songmid}]`,
+    }),
+  })
+  requestObj.promise = requestObj.promise.then(({ body }) => {
+    // console.log(body)
+    if (body.code !== 200 || !body.songs.length) return Promise.reject('获取歌曲信息失败')
+    return body.songs[0]
+  })
+  return requestObj
+}
+

src/renderer/utils/music/wy/musicSearch.js

@@ -0,0 +1,102 @@
+import { httpFetch } from '../../request'
+import { weapi } from './utils/crypto'
+import { sizeFormate, formatPlayTime } from '../../index'
+
+let searchRequest
+export default {
+  limit: 30,
+  total: 0,
+  page: 0,
+  allPage: 1,
+  musicSearch(str, page) {
+    if (searchRequest && searchRequest.cancelHttp) searchRequest.cancelHttp()
+    searchRequest = httpFetch('http://music.163.com/weapi/cloudsearch/get/web?csrf_token=', {
+      method: 'post',
+      form: weapi({
+        s: str,
+        type: 1, // 1: 单曲, 10: 专辑, 100: 歌手, 1000: 歌单, 1002: 用户, 1004: MV, 1006: 歌词, 1009: 电台, 1014: 视频
+        limit: this.limit,
+        offset: this.limit * (page - 1),
+      }),
+    })
+    return searchRequest.promise.then(({ body }) => body)
+  },
+  getSinger(singers) {
+    let arr = []
+    singers.forEach(singer => {
+      arr.push(singer.name)
+    })
+    return arr.join('、')
+  },
+  handleResult(rawList) {
+    // console.log(rawList)
+    return rawList.map(item => {
+      const types = []
+      const _types = {}
+      let size
+      switch (item.privilege.maxbr) {
+        case 999000:
+          size = null
+          types.push({ type: 'flac', size })
+          _types.flac = {
+            size,
+          }
+        case 320000:
+          if (item.h) {
+            size = sizeFormate(item.h.size)
+            types.push({ type: '320k', size })
+            _types['320k'] = {
+              size,
+            }
+          }
+        case 128000:
+          if (item.l) {
+            size = sizeFormate(item.l.size)
+            types.push({ type: '128k', size })
+            _types['128k'] = {
+              size,
+            }
+          }
+      }
+
+      types.reverse()
+
+      return {
+        singer: this.getSinger(item.ar),
+        name: item.name,
+        albumName: item.al.name,
+        albumId: item.al.id,
+        source: 'wy',
+        interval: formatPlayTime(item.dt / 1000),
+        songmid: item.id,
+        img: item.al.picUrl,
+        lrc: null,
+        types,
+        _types,
+        typeUrl: {},
+      }
+    })
+  },
+  search(str, page = 1, { limit } = {}) {
+    if (limit != null) this.limit = limit
+    return this.musicSearch(str, page).then(result => {
+      // console.log(JSON.stringify(result))
+      if (!result || result.code !== 200) return this.search(str, page, { limit })
+      let list = this.handleResult(result.result.songs)
+
+      if (list == null) return this.search(str, page, { limit })
+
+      this.total = result.result.songCount
+      this.page = page
+      this.allPage = Math.ceil(this.total / this.limit)
+
+      return Promise.resolve({
+        list,
+        allPage: this.allPage,
+        limit: this.limit,
+        total: this.total,
+        source: 'wy',
+      })
+    })
+  },
+}

src/renderer/utils/music/wy/songList.js

@@ -0,0 +1,242 @@
+// https://github.com/Binaryify/NeteaseCloudMusicApi/blob/master/module/playlist_catlist.js
+// https://github.com/Binaryify/NeteaseCloudMusicApi/blob/master/module/playlist_hot.js
+// https://github.com/Binaryify/NeteaseCloudMusicApi/blob/master/module/top_playlist.js
+// https://github.com/Binaryify/NeteaseCloudMusicApi/blob/master/module/playlist_detail.js
+
+import { weapi, linuxapi } from './utils/crypto'
+import { httpFetch } from '../../request'
+import { formatPlayTime, sizeFormate } from '../../index'
+
+export default {
+  _requestObj_tags: null,
+  _requestObj_hotTags: null,
+  _requestObj_list: null,
+  _requestObj_listDetail: null,
+  limit_list: 30,
+  limit_song: 100000,
+  successCode: 200,
+  sortList: [
+    {
+      name: '最热',
+      id: 'hot',
+    },
+    {
+      name: '最新',
+      id: 'new',
+    },
+  ],
+  /**
+   * 格式化播放数量
+   * @param {*} num
+   */
+  formatPlayCount(num) {
+    if (num > 100000000) return parseInt(num / 10000000) / 10 + '亿'
+    if (num > 10000) return parseInt(num / 1000) / 10 + '万'
+    return num
+  },
+  getSinger(singers) {
+    let arr = []
+    singers.forEach(singer => {
+      arr.push(singer.name)
+    })
+    return arr.join('、')
+  },
+
+  getListDetail(id, page, tryNum = 0) { // 获取歌曲列表内的音乐
+    if (this._requestObj_listDetail) this._requestObj_listDetail.cancelHttp()
+    if (tryNum > 2) return Promise.reject(new Error('try max num'))
+    this._requestObj_listDetail = httpFetch('https://music.163.com/api/linux/forward', {
+      method: 'post',
+      'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.90 Safari/537.36',
+      form: linuxapi({
+        method: 'POST',
+        url: 'https://music.163.com/api/v3/playlist/detail',
+        params: {
+          id,
+          n: this.limit_song,
+          s: 8,
+        },
+      }),
+    })
+    return this._requestObj_listDetail.promise.then(({ body }) => {
+      if (body.code !== this.successCode) return this.getListDetail(id, page, ++tryNum)
+      return {
+        list: this.filterListDetail(body),
+        page,
+        limit: this.limit_song,
+        total: body.playlist.tracks.length,
+        source: 'wy',
+        info: {
+          play_count: this.formatPlayCount(body.playlist.playCount),
+          name: body.playlist.name,
+          img: body.playlist.coverImgUrl,
+          desc: body.playlist.description,
+          author: body.playlist.creator.nickname,
+        },
+      }
+    })
+  },
+  filterListDetail({ playlist: { tracks }, privileges }) {
+    // console.log(tracks, privileges)
+    const list = []
+    tracks.forEach((item, index) => {
+      const types = []
+      const _types = {}
+      let size
+      let privilege = privileges[index]
+      if (privilege.id !== item.id) privilege = privileges.find(p => p.id === item.id)
+      if (!privilege) return
+
+      switch (privilege.maxbr) {
+        case 999000:
+          size = null
+          types.push({ type: 'flac', size })
+          _types.flac = {
+            size,
+          }
+        case 320000:
+          if (item.h) {
+            size = sizeFormate(item.h.size)
+            types.push({ type: '320k', size })
+            _types['320k'] = {
+              size,
+            }
+          }
+        case 128000:
+          if (item.l) {
+            size = sizeFormate(item.l.size)
+            types.push({ type: '128k', size })
+            _types['128k'] = {
+              size,
+            }
+          }
+      }
+
+      types.reverse()
+
+      list.push({
+        singer: this.getSinger(item.ar),
+        name: item.name,
+        albumName: item.al.name,
+        albumId: item.al.id,
+        source: 'wy',
+        interval: formatPlayTime(item.dt / 1000),
+        songmid: item.id,
+        img: item.al.picUrl,
+        lrc: null,
+        types,
+        _types,
+        typeUrl: {},
+      })
+    })
+    return list
+  },
+
+  // 获取列表数据
+  getList(sortId, tagId, page, tryNum = 0) {
+    if (tryNum > 2) return Promise.reject(new Error('try max num'))
+    if (this._requestObj_list) this._requestObj_list.cancelHttp()
+    this._requestObj_list = httpFetch('https://music.163.com/weapi/playlist/list', {
+      method: 'post',
+      form: weapi({
+        cat: tagId || '全部', // 全部,华语,欧美,日语,韩语,粤语,小语种,流行,摇滚,民谣,电子,舞曲,说唱,轻音乐,爵士,乡村,R&B/Soul,古典,民族,英伦,金属,朋克,蓝调,雷鬼,世界音乐,拉丁,另类/独立,New Age,古风,后摇,Bossa Nova,清晨,夜晚,学习,工作,午休,下午茶,地铁,驾车,运动,旅行,散步,酒吧,怀旧,清新,浪漫,性感,伤感,治愈,放松,孤独,感动,兴奋,快乐,安静,思念,影视原声,ACG,儿童,校园,游戏,70后,80后,90后,网络歌曲,KTV,经典,翻唱,吉他,钢琴,器乐,榜单,00后
+        order: sortId, // hot,new
+        limit: this.limit_list,
+        offset: this.limit_list * (page - 1),
+        total: true,
+      }),
+    })
+    return this._requestObj_list.promise.then(({ body }) => {
+      // console.log(JSON.stringify(body))
+      if (body.code !== this.successCode) return this.getList(sortId, tagId, page, ++tryNum)
+      return {
+        list: this.filterList(body.playlists),
+        total: parseInt(body.total),
+        page,
+        limit: this.limit_list,
+        source: 'wy',
+      }
+    })
+  },
+  filterList(rawData) {
+    return rawData.map(item => ({
+      play_count: this.formatPlayCount(item.playCount),
+      id: item.id,
+      author: item.creator.nickname,
+      name: item.name,
+      time: item.createTime,
+      img: item.coverImgUrl,
+      grade: item.grade,
+      desc: item.description,
+      source: 'wy',
+    }))
+  },
+
+  // 获取标签
+  getTag(tryNum = 0) {
+    if (this._requestObj_tags) this._requestObj_tags.cancelHttp()
+    if (tryNum > 2) return Promise.reject(new Error('try max num'))
+    this._requestObj_tags = httpFetch('https://music.163.com/weapi/playlist/catalogue', {
+      method: 'post',
+      form: weapi({}),
+    })
+    return this._requestObj_tags.promise.then(({ body }) => {
+      // console.log(JSON.stringify(body))
+      if (body.code !== this.successCode) return this.getTag(++tryNum)
+      return this.filterTagInfo(body)
+    })
+  },
+  filterTagInfo({ sub, categories }) {
+    const subList = {}
+    for (const item of sub) {
+      if (!subList[item.category]) subList[item.category] = []
+      subList[item.category].push({
+        parent_id: categories[item.category],
+        parent_name: categories[item.category],
+        id: item.name,
+        name: item.name,
+        source: 'wy',
+      })
+    }
+
+    const list = []
+    for (const key of Object.keys(categories)) {
+      list.push({
+        name: categories[key],
+        list: subList[key],
+        source: 'wy',
+      })
+    }
+    return list
+  },
+
+  // 获取热门标签
+  getHotTag(tryNum = 0) {
+    if (this._requestObj_hotTags) this._requestObj_hotTags.cancelHttp()
+    if (tryNum > 2) return Promise.reject(new Error('try max num'))
+    this._requestObj_hotTags = httpFetch('https://music.163.com/weapi/playlist/hottags', {
+      method: 'post',
+      form: weapi({}),
+    })
+    return this._requestObj_hotTags.promise.then(({ body }) => {
+      // console.log(JSON.stringify(body))
+      if (body.code !== this.successCode) return this.getTag(++tryNum)
+      return this.filterHotTagInfo(body.tags)
+    })
+  },
+  filterHotTagInfo(rawList) {
+    return rawList.map(item => ({
+      id: item.playlistTag.name,
+      name: item.playlistTag.name,
+      source: 'wy',
+    }))
+  },
+
+  getTags() {
+    return Promise.all([this.getTag(), this.getHotTag()]).then(([tags, hotTag]) => ({ tags, hotTag, source: 'wy' }))
+  },
+}
+
+// getList
+// getTags
+// getListDetail

src/renderer/utils/music/wy/utils/crypto.js

@@ -0,0 +1,33 @@
+// https://github.com/Binaryify/NeteaseCloudMusicApi/blob/master/util/crypto.js
+import { createCipheriv, publicEncrypt, constants, randomBytes } from 'crypto'
+const iv = Buffer.from('0102030405060708')
+const presetKey = Buffer.from('0CoJUm6Qyw8W8jud')
+const linuxapiKey = Buffer.from('rFgB&h#%2?^eDg:Q')
+const base62 = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
+const publicKey = '-----BEGIN PUBLIC KEY-----\nMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDgtQn2JZ34ZC28NWYpAUd98iZ37BUrX/aKzmFbt7clFSs6sXqHauqKWqdtLkF2KexO40H1YTX8z2lSgBBOAxLsvaklV8k4cBFK9snQXE9/DDaFt6Rr7iVZMldczhC0JNgTz+SHXT6CBHuX3e9SdB1Ua44oncaTWz7OBGLbCiK45wIDAQAB\n-----END PUBLIC KEY-----'
+
+const aesEncrypt = (buffer, mode, key, iv) => {
+  const cipher = createCipheriv('aes-128-' + mode, key, iv)
+  return Buffer.concat([cipher.update(buffer), cipher.final()])
+}
+
+const rsaEncrypt = (buffer, key) => {
+  buffer = Buffer.concat([Buffer.alloc(128 - buffer.length), buffer])
+  return publicEncrypt({ key: key, padding: constants.RSA_NO_PADDING }, buffer)
+}
+
+export const weapi = object => {
+  const text = JSON.stringify(object)
+  const secretKey = randomBytes(16).map(n => (base62.charAt(n % 62).charCodeAt()))
+  return {
+    params: aesEncrypt(Buffer.from(aesEncrypt(Buffer.from(text), 'cbc', presetKey, iv).toString('base64')), 'cbc', secretKey, iv).toString('base64'),
+    encSecKey: rsaEncrypt(secretKey.reverse(), publicKey).toString('hex'),
+  }
+}
+
+export const linuxapi = object => {
+  const text = JSON.stringify(object)
+  return {
+    eparams: aesEncrypt(Buffer.from(text), 'ecb', linuxapiKey, '').toString('hex').toUpperCase(),
+  }
+}

src/renderer/utils/request.js

@@ -3,11 +3,14 @@ import request from 'request'
 import { debugRequest } from './env'
 import { requestMsg } from './message'
 import { bHh } from './music/options'
+import { deflateRawSync } from 'zlib'
 // import fs from 'fs'
 
-const headers = {
+const defaultHeaders = {
   'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.100 Safari/537.36',
 }
+// var proxyUrl = "http://" + user + ":" + password + "@" + host + ":" + port;
+// var proxiedRequest = request.defaults({'proxy': proxyUrl});
 
 /**
  * promise 形式的请求方法
@@ -17,21 +20,22 @@ const headers = {
 const buildHttpPromose = (url, options) => {
   let requestObj
   let cancelFn
-  const p = new Promise((resolve, reject) => {
+  let p = new Promise((resolve, reject) => {
     cancelFn = reject
     debugRequest && console.log(`\n---send request------${url}------------`)
-    requestObj = fatchData(url, options.method, options, (err, resp, body) => {
+    requestObj = fetchData(url, options.method, options, (err, resp, body) => {
     // options.isShowProgress && window.api.hideProgress()
       debugRequest && console.log(`\n---response------${url}------------`)
       debugRequest && console.log(JSON.stringify(body))
       requestObj = null
       cancelFn = null
       if (err) {
-        console.log(err.code)
+        // console.log('出错', err.code)
         if (err.code === 'ETIMEDOUT' || err.code == 'ESOCKETTIMEDOUT') {
-          const { promise, cancelHttp } = httpFatch(url, options)
+          const { promise, cancelHttp } = httpFetch(url, options)
           obj.cancelHttp = cancelHttp
-          promise.then()
+          promise.then(resp => resolve(resp)).catch(err => reject(err))
+          return
         }
         return reject(err)
       }
@@ -42,11 +46,11 @@ const buildHttpPromose = (url, options) => {
     promise: p,
     cancelHttp() {
       if (!requestObj) return
-      console.log('cancel')
-      cancelHttp(requestObj)
       cancelFn(new Error(requestMsg.cancelRequest))
+      cancelHttp(requestObj)
       requestObj = null
       cancelFn = null
+      p = null
     },
   }
   return obj
@@ -57,11 +61,11 @@ const buildHttpPromose = (url, options) => {
  * @param {*} url
  * @param {*} options
  */
-export const httpFatch = (url, options = { method: 'get' }) => {
+export const httpFetch = (url, options = { method: 'get' }) => {
   const requestObj = buildHttpPromose(url, options)
   requestObj.promise = requestObj.promise.catch(err => {
     if (err.code === 'ETIMEDOUT' || err.code == 'ESOCKETTIMEDOUT') {
-      const { promise, cancelHttp } = httpFatch(url, options)
+      const { promise, cancelHttp } = httpFetch(url, options)
       requestObj.cancelHttp()
       requestObj.cancelHttp = cancelHttp
       return promise
@@ -104,7 +108,7 @@ export const http = (url, options, cb) => {
   if (options.method == null) options.method = 'get'
 
   debugRequest && console.log(`\n---send request------${url}------------`)
-  return fatchData(url, options.method, options, (err, resp, body) => {
+  return fetchData(url, options.method, options, (err, resp, body) => {
     // options.isShowProgress && window.api.hideProgress()
     debugRequest && console.log(`\n---response------${url}------------`)
     debugRequest && console.log(JSON.stringify(body))
@@ -133,7 +137,7 @@ export const httpGet = (url, options, callback) => {
   // })
 
   debugRequest && console.log(`\n---send request-------${url}------------`)
-  return fatchData(url, 'get', options, function(err, resp, body) {
+  return fetchData(url, 'get', options, function(err, resp, body) {
     // options.isShowProgress && window.api.hideProgress()
     debugRequest && console.log(`\n---response------${url}------------`)
     debugRequest && console.log(JSON.stringify(body))
@@ -164,7 +168,7 @@ export const httpPost = (url, data, options, callback) => {
   options.data = data
 
   debugRequest && console.log(`\n---send request-------${url}------------`)
-  return fatchData(url, 'post', options, function(err, resp, body) {
+  return fetchData(url, 'post', options, function(err, resp, body) {
     // options.isShowProgress && window.api.hideProgress()
     debugRequest && console.log(`\n---response------${url}------------`)
     debugRequest && console.log(JSON.stringify(body))
@@ -201,7 +205,7 @@ export const http_jsonp = (url, options, callback) => {
   // })
 
   debugRequest && console.log(`\n---send request-------${url}------------`)
-  return fatchData(url, 'get', options, function(err, resp, body) {
+  return fetchData(url, 'get', options, function(err, resp, body) {
     // options.isShowProgress && window.api.hideProgress()
     debugRequest && console.log(`\n---response------${url}------------`)
     debugRequest && console.log(JSON.stringify(body))
@@ -215,25 +219,36 @@ export const http_jsonp = (url, options, callback) => {
   })
 }
 
-const fatchData = (url, method, options, callback) => {
+const getProxyInfo = () => window.globalObj.proxy.enable
+  ? `http://${window.globalObj.proxy.username}:${window.globalObj.proxy.password}@${window.globalObj.proxy.host}:${window.globalObj.proxy.port};`
+  : undefined
+
+const regx = /(?:\d\w)+/g
+
+const fetchData = (url, method, {
+  headers = {},
+  format = 'json',
+  timeout = 15000,
+  ...options
+}, callback) => {
   // console.log(url, options)
   console.log('---start---', url)
-  if (options.headers && options.headers[bHh]) {
+  headers = Object.assign({}, headers)
+  if (headers[bHh]) {
     let s = Buffer.from(bHh, 'hex').toString()
     s = s.replace(s.substr(-1), '')
     s = Buffer.from(s, 'base64').toString()
-    options.headers[s] = !!s
-    delete options.headers[bHh]
+    let v = process.versions.app.split('.').map(n => n.length < 3 ? n.padStart(3, '0') : n).join('')
+    headers[s] = !s || `${deflateRawSync(Buffer.from(JSON.stringify(`${url}${v}`.match(regx), null, 1).concat(v)).toString('base64')).toString('hex')}&${parseInt(v)}`
+    delete headers[bHh]
   }
   return request(url, {
+    ...options,
     method,
-    headers: Object.assign({}, headers, options.headers || {}),
-    Origin: options.origin,
-    body: options.body,
-    form: options.form,
-    formData: options.formData,
-    timeout: options.timeout || 10000,
-    json: options.format === undefined || options.format === 'json',
+    headers: Object.assign({}, defaultHeaders, headers),
+    timeout,
+    proxy: getProxyInfo(),
+    json: format === 'json',
   }, (err, resp, body) => {
     if (err) return callback(err, null)
     callback(null, resp, body)