diff --git a/.gitignore b/.gitignore index ddcb065e..e1ee3d0c 100644 --- a/.gitignore +++ b/.gitignore @@ -164,3 +164,4 @@ main/manager-api/.vscode # Ignore webpack cache directory main/manager-web/.webpack_cache/ main/xiaozhi-server/mysql +uploadfile diff --git a/Dockerfile-web b/Dockerfile-web index 0c4001f1..9e5da678 100644 --- a/Dockerfile-web +++ b/Dockerfile-web @@ -23,7 +23,7 @@ RUN apt-get update && \ rm -rf /var/lib/apt/lists/* # 配置Nginx -COPY docs/docker/nginx.conf /etc/nginx/conf.d/default.conf +COPY docs/docker/nginx.conf /etc/nginx/nginx.conf # 复制前端构建产物 COPY --from=web-builder /app/dist /usr/share/nginx/html diff --git a/README.md b/README.md index 5479d020..4f762d97 100644 --- a/README.md +++ b/README.md @@ -6,7 +6,7 @@

本项目为开源智能硬件项目 xiaozhi-esp32提供后端服务
-根据小智通信协议使用Python实现
+根据小智通信协议使用Python、Java、Vue实现
帮助您快速搭建小智服务器

@@ -15,7 +15,8 @@ · 简体中文 · 更新日志 · 部署文档 -· 反馈问题 +· 反馈问题 +· 常见问题

@@ -147,14 +148,16 @@ server: ## 部署文档 +![Banners](docs/images/banner2.png) + 本项目提供两种部署方式，请根据您的具体需求选择： #### 🚀 部署方式选择 | 部署方式 | 特点 | 适用场景 | Docker部署文档 | 源码部署文档 | |---------|------|---------|---------|---------| -| **最简化安装** | 智能对话、IOT功能，数据存储在配置文件 | 低配置环境，无需数据库 | [Docker只运行Server](./docs/Deployment.md#%E6%96%B9%E5%BC%8F%E4%B8%80docker%E5%8F%AA%E8%BF%90%E8%A1%8Cserver) | [本地源码只运行Server](./docs/Deployment.md#%E6%96%B9%E5%BC%8F%E4%BA%8C%E6%9C%AC%E5%9C%B0%E6%BA%90%E7%A0%81%E5%8F%AA%E8%BF%90%E8%A1%8Cserver)| -| **全模块安装** | 智能对话、IOT、OTA、智控台，数据存储在数据库 | 完整功能体验 |[Docker运行全模块](./docs/Deployment_all.md#%E6%96%B9%E5%BC%8F%E4%B8%80docker%E8%BF%90%E8%A1%8C%E5%85%A8%E6%A8%A1%E5%9D%97) | [本地源码运行全模块](./docs/Deployment_all.md#%E6%96%B9%E5%BC%8F%E4%BA%8C%E6%9C%AC%E5%9C%B0%E6%BA%90%E7%A0%81%E8%BF%90%E8%A1%8C%E5%85%A8%E6%A8%A1%E5%9D%97) | +| **最简化安装** | 智能对话、IOT功能，数据存储在配置文件 | 低配置环境，无需数据库，仅支持虾哥1.6.0及以下固件版本 | [Docker只运行Server](./docs/Deployment.md#%E6%96%B9%E5%BC%8F%E4%B8%80docker%E5%8F%AA%E8%BF%90%E8%A1%8Cserver) | [本地源码只运行Server](./docs/Deployment.md#%E6%96%B9%E5%BC%8F%E4%BA%8C%E6%9C%AC%E5%9C%B0%E6%BA%90%E7%A0%81%E5%8F%AA%E8%BF%90%E8%A1%8Cserver)| +| **全模块安装** | 智能对话、IOT、OTA、智控台，数据存储在数据库 | 完整功能体验，支持虾哥最新固件 |[Docker运行全模块](./docs/Deployment_all.md#%E6%96%B9%E5%BC%8F%E4%B8%80docker%E8%BF%90%E8%A1%8C%E5%85%A8%E6%A8%A1%E5%9D%97) | [本地源码运行全模块](./docs/Deployment_all.md#%E6%96%B9%E5%BC%8F%E4%BA%8C%E6%9C%AC%E5%9C%B0%E6%BA%90%E7%A0%81%E8%BF%90%E8%A1%8C%E5%85%A8%E6%A8%A1%E5%9D%97) | > 💡 提示：以下是按最新代码部署后的测试平台，有需要可烧录测试，并发为6个，每天会清空数据 diff --git a/docs/Deployment.md b/docs/Deployment.md index 097aea59..508fa754 100644 --- a/docs/Deployment.md +++ b/docs/Deployment.md @@ -290,7 +290,7 @@ LLM: 这个信息很有用的，后面`编译esp32固件`需要用到。 -接下来，你就可以开始 [编译esp32固件](firmware-build.md)了。 +接下来，你就可以开始 [编译1.6.0版本esp32固件](firmware-build.md)了。 以下是一些常见问题，供参考： diff --git a/docs/Deployment_all.md b/docs/Deployment_all.md index 8c6048c5..a0bb2f16 100644 --- a/docs/Deployment_all.md +++ b/docs/Deployment_all.md @@ -182,7 +182,11 @@ Websocket接口： ws://你电脑局域网的ip:8000/xiaozhi/v1/ ``` -接下来，你就可以开始 [编译esp32固件](firmware-build.md)了。 +接下来，你就可以开始操作你的esp32设备了，你可以`自行编译esp32固件`也可以配置使用`虾哥编译好的1.6.1以上版本的固件`。两个任选一个 + +1、 [编译自己的esp32固件](firmware-build.md)了。 + +2、 [基于虾哥编译好的固件配置自定义服务器](firmware-setting.md)了。 # 方式二：本地源码运行全模块 @@ -349,7 +353,7 @@ pip install -r requirements.txt ## 8.配置项目文件 -使用超级管理员账号，登录智控台 http://127.0.0.1:8001 ，在顶部菜单找到`参数管理`，找到列表中第三条数据，参数编码是`server.secret`，复制它到`参数值`。 +使用超级管理员账号，登录智控台 http://127.0.0.1:8002 ，在顶部菜单找到`参数管理`，找到列表中第三条数据，参数编码是`server.secret`，复制它到`参数值`。 `server.secret`需要说明一下，这个`参数值`很重要，作用是让我们的`Server`端连接`manager-api`。`server.secret`是每次从零部署manager模块时，会自动随机生成的密钥。 @@ -402,7 +406,11 @@ Websocket接口： ws://你电脑局域网的ip:8000/xiaozhi/v1/ ``` -接下来，你就可以开始 [编译esp32固件](firmware-build.md)了。 +接下来，你就可以开始操作你的esp32设备了，你可以`自行编译esp32固件`也可以配置使用`虾哥编译好的1.6.1以上版本的固件`。两个任选一个 + +1、 [编译自己的esp32固件](firmware-build.md)了。 + +2、 [基于虾哥编译好的固件配置自定义服务器](firmware-setting.md)了。 # 常见问题 diff --git a/docs/FAQ.md b/docs/FAQ.md index 9be27089..c859498a 100644 --- a/docs/FAQ.md +++ b/docs/FAQ.md @@ -102,41 +102,7 @@ VAD: ### 7、我想通过小智控制电灯、空调、远程开关机等操作 💡 -本项目，支持以工具调用的方式控制HomeAssistant设备 - -1、首先选择一款支持function call支持的LLM，例如`ChatGLMLLM`。 - -2、在配置文件中，将 `selected_module.Intent` 设置为 `function_call`。 - -3、登录`HomeAssistant`，点击`左下角个人`，切换`安全`导航栏，划到底部`长期访问令牌`生成api_key。 - -在配置文件中，配置好你的home assistant的`devices`（被控制的设备）和`api_key`和`base_url`等信息。例如： - -``` yaml -plugins - home_assistant: - devices: - - 客厅,玩具灯,switch.cuco_cn_460494544_cp1_on_p_2_1 - - 卧室,台灯,switch.iot_cn_831898993_socn1_on_p_2_1 - base_url: http://你的homeassistant地址:8123 - api_key: 你的home assistant api访问令牌 -``` - -最后，允许function_call 插件在配置文件中启用`hass_get_state`(必须)、`hass_set_state`(必须)、`hass_play_music`(不想用ha听音乐可以不启动)，例如： - -``` yaml -Intent: - ... - function_call: - type: nointent - functions: - - change_role - - get_weather - - get_news - - hass_get_state - - hass_set_state - - hass_play_music -``` +参考教程[ESP32设备与HomeAssistant集成指南](./homeassistant-integration.md) ### 8、更多问题，可联系我们反馈 💬 diff --git a/docs/docker/nginx.conf b/docs/docker/nginx.conf index 6a746260..9b9c3889 100644 --- a/docs/docker/nginx.conf +++ b/docs/docker/nginx.conf @@ -1,26 +1,53 @@ -server { - listen 8002; - server_name localhost; +user root; +worker_processes 4; - # 静态资源服务（Vue项目） - location / { - root /usr/share/nginx/html; - try_files $uri $uri/ /index.html; - } +events { + worker_connections 1024; +} - # API反向代理（Java项目） - location /xiaozhi/ { - proxy_pass http://127.0.0.1:8003; - proxy_set_header Host $host; - proxy_cookie_path /api/ /; - proxy_set_header Referer $http_referer; - proxy_set_header Cookie $http_cookie; +http { + include mime.types; + default_type application/octet-stream; + sendfile on; + keepalive_timeout 300; + client_header_timeout 180s; + client_body_timeout 180s; + client_max_body_size 1024M; - proxy_connect_timeout 10; - proxy_send_timeout 10; - proxy_read_timeout 10; + gzip on; + gzip_buffers 32 4K; + gzip_comp_level 6; + gzip_min_length 100; + gzip_types application/javascript text/css text/xml image/jpeg image/gif image/png; + gzip_disable "MSIE [1-6]\."; + gzip_vary on; - proxy_set_header X-Real-IP $remote_addr; - proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + server { + # 无域名访问，就用localhost + server_name localhost; + # 80端口 + listen 8002; + + # 转发到编译后到web目录 + location / { + root /usr/share/nginx/html; + try_files $uri $uri/ /index.html; + } + + # 转发到manager-api + location /xiaozhi/ { + proxy_pass http://127.0.0.1:8003; + proxy_set_header Host $host; + proxy_cookie_path /manager/ /; + proxy_set_header Referer $http_referer; + proxy_set_header Cookie $http_cookie; + + proxy_connect_timeout 10; + proxy_send_timeout 10; + proxy_read_timeout 10; + + proxy_set_header X-Real-IP $remote_addr; + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + } } } \ No newline at end of file diff --git a/docs/firmware-build-1.6.0.md b/docs/firmware-build-1.6.0.md new file mode 100644 index 00000000..5e37d59e --- /dev/null +++ b/docs/firmware-build-1.6.0.md @@ -0,0 +1,124 @@ +# 编译1.6.0版本esp32固件 + +## 第1步 配置环境 +先按照这个教程配置项目环境[《Windows搭建 ESP IDF 5.3.2开发环境以及编译小智》](https://icnynnzcwou8.feishu.cn/wiki/JEYDwTTALi5s2zkGlFGcDiRknXf) + +## 第2步 打开配置文件 +配置好编译环境后，下载虾哥iaozhi-esp32项目源码， + + +从这里下载虾哥[xiaozhi-esp32项目1.6.0版本源码](https://github.com/78/xiaozhi-esp32/archive/refs/tags/v1.6.0.zip)。 + +从这里下载虾哥[xiaozhi-esp32项目1.6.0版本源码](https://github.com/78/xiaozhi-esp32/archive/refs/tags/v1.6.0.zip)。 + +从这里下载虾哥[xiaozhi-esp32项目1.6.0版本源码](https://github.com/78/xiaozhi-esp32/archive/refs/tags/v1.6.0.zip)。 + +下载后，解压缩包，打开`xiaozhi-esp32/main/Kconfig.projbuild`文件。 + + +## 第3步 修改WEBSOCKET地址 +找到`WEBSOCKET_URL`的`default`的内容，把`wss://api.tenclass.net/xiaozhi/v1/` + 改成你自己的地址，例如，我的接口地址是`ws://192.168.1.25:8000/xiaozhi/v1/`，就把内容改成这个。 + +修改前： + +``` +config WEBSOCKET_URL + depends on CONNECTION_TYPE_WEBSOCKET + string "Websocket URL" + default "wss://api.tenclass.net/xiaozhi/v1/" + help + Communication with the server through websocket after wake up. +``` + +修改后(示例)： + +``` +config WEBSOCKET_URL + depends on CONNECTION_TYPE_WEBSOCKET + string "Websocket URL" + default "ws://192.168.1.25:8000/xiaozhi/v1/" + help + Communication with the server through websocket after wake up. +``` + +注意：你的地址是`ws://`开头，不是`wss://`开头，一定不要写错了。 + +注意：你的地址是`ws://`开头，不是`wss://`开头，一定不要写错了。 + +注意：你的地址是`ws://`开头，不是`wss://`开头，一定不要写错了。 + +## 第4步 设置编译参数 + +设置编译参数 + +``` +# 终端命令行进入xiaozhi-esp32的根目录 +cd xiaozhi-esp32 +# 例如我使用的板子是esp32s3，所以设置编译目标为esp32s3，如果你的板子是其他型号，请替换成对应的型号 +idf.py set-target esp32s3 +# 进入菜单配置 +idf.py menuconfig +``` + +![图片](images/build_setting01.png) + +进入菜单配置后，再进入`Xiaozhi Assistant`，将`CONNECTION_TYPE`设置为`Websocket` +回退到主菜单，再进入`Xiaozhi Assistant`，将`BOARD_TYPE`设置你板子的具体型号 +保存退出，回到终端命令行。 + +![图片](images/build_setting02.png) + +## 第5步 编译固件 + +``` +idf.py build +``` + +如果是vscode安装的idf可以使用`F1`或者`ctrl+shift+p`,输入idf然后直接选择进行编译 + +还可以直接进行烧录不用接下来的操作 + + + +## 第6步 打包bin固件 + +``` +cd scripts +python release.py +``` + +编译成功后，会在项目根目录下的`build`目录下生成固件文件`merged-binary.bin`。 +这个`merged-binary.bin`就是要烧录到硬件上的固件文件。 + +注意：如果执行到第二命令后，报了“zip”相关的错误，请忽略这个错误，只要`build`目录下生成固件文件`merged-binary.bin` +，对你没有太大影响，请继续。 + +## 第7步 烧录固件 + 将esp32设备连接电脑，使用chrome浏览器，打开以下网址 + +``` +https://espressif.github.io/esp-launchpad/ +``` + +打开这个教程，[Flash工具/Web端烧录固件（无IDF开发环境）](https://ccnphfhqs21z.feishu.cn/wiki/Zpz4wXBtdimBrLk25WdcXzxcnNS)。 +翻到：`方式二：ESP-Launchpad 浏览器WEB端烧录`，从`3. 烧录固件/下载到开发板`开始，按照教程操作。 + +烧录成功且联网成功后，通过唤醒词唤醒小智，留意server端输出的控制台信息。 + +## 常见问题 +以下是一些常见问题，供参考： + +[1、为什么我说的话，小智识别出来很多韩文、日文、英文](./FAQ.md) + +[2、为什么会出现“TTS 任务出错 文件不存在”？](./FAQ.md) + +[3、TTS 经常失败，经常超时](./FAQ.md) + +[4、使用Wifi能连接自建服务器，但是4G模式却接不上](./FAQ.md) + +[5、如何提高小智对话响应速度？](./FAQ.md) + +[6、我说话很慢，停顿时小智老是抢话](./FAQ.md) + +[7、我想通过小智控制电灯、空调、远程开关机等操作](./FAQ.md) diff --git a/docs/firmware-build.md b/docs/firmware-build.md index c3c3347a..ebb7413b 100644 --- a/docs/firmware-build.md +++ b/docs/firmware-build.md @@ -1,54 +1,40 @@ -# 编译esp32固件 +# esp32固件编译 -## 第1步 配置环境 +## 第1步 准备你的ota地址 +如果你按照教程使用的是全模块部署，就应该会有ota地址。 + +此刻，请你用浏览器打开你的ota地址，例如我的ota地址 +``` +http://192.168.1.25:8002/xiaozhi/ota/ +``` + +如果显示“OTA接口运行正常，websocket集群数量：X”。那就往下。 + +如果显示“OTA接口运行不正常”，大概是你还没在`智控台`配置`Websocket`地址。那就： + +- 1、使用超级管理员登录智控台 + +- 2、顶部菜单点击`参数管理` + +- 3、在列表中找到`server.websocket`项目，输入你的`Websocket`地址。例如我的就是 + +``` +ws://192.168.1.25:8000/xiaozhi/v1/ +``` + +配置完后，再使用浏览器刷新你的ota接口地址，看看是不是正常了。如果还不正常就，就再次确认一下Websocket是否正常启动，是否配置了Websocket地址。 + +## 第2步 配置环境 先按照这个教程配置项目环境[《Windows搭建 ESP IDF 5.3.2开发环境以及编译小智》](https://icnynnzcwou8.feishu.cn/wiki/JEYDwTTALi5s2zkGlFGcDiRknXf) -## 第2步 打开配置文件 +## 第3步 打开配置文件 配置好编译环境后，下载虾哥iaozhi-esp32项目源码， -从这里下载虾哥[xiaozhi-esp32项目源码](https://github.com/78/xiaozhi-esp32/archive/refs/tags/v1.6.0.zip)。 +从这里下载虾哥[xiaozhi-esp32项目源码](https://github.com/78/xiaozhi-esp32)。 -从这里下载虾哥[xiaozhi-esp32项目源码](https://github.com/78/xiaozhi-esp32/archive/refs/tags/v1.6.0.zip)。 - -从这里下载虾哥[xiaozhi-esp32项目源码](https://github.com/78/xiaozhi-esp32/archive/refs/tags/v1.6.0.zip)。 - -下载后，解压缩包，打开`xiaozhi-esp32/main/Kconfig.projbuild`文件。 - - -## 第3步 修改WEBSOCKET地址 -找到`WEBSOCKET_URL`的`default`的内容，把`wss://api.tenclass.net/xiaozhi/v1/` - 改成你自己的地址，例如，我的接口地址是`ws://192.168.1.25:8000/xiaozhi/v1/`，就把内容改成这个。 - -修改前： - -``` -config WEBSOCKET_URL - depends on CONNECTION_TYPE_WEBSOCKET - string "Websocket URL" - default "wss://api.tenclass.net/xiaozhi/v1/" - help - Communication with the server through websocket after wake up. -``` - -修改后(示例)： - -``` -config WEBSOCKET_URL - depends on CONNECTION_TYPE_WEBSOCKET - string "Websocket URL" - default "ws://192.168.1.25:8000/xiaozhi/v1/" - help - Communication with the server through websocket after wake up. -``` - -注意：你的地址是`ws://`开头，不是`wss://`开头，一定不要写错了。 - -注意：你的地址是`ws://`开头，不是`wss://`开头，一定不要写错了。 - -注意：你的地址是`ws://`开头，不是`wss://`开头，一定不要写错了。 +下载后，打开`xiaozhi-esp32/main/Kconfig.projbuild`文件。 ## 第4步 修改OTA地址 -如果你是全模块部署本项目，就修改OTA接口，如果你只是部署了8000端口的xiaozhi-server，可以继续沿用虾哥团队的OTA接口。如果你不修改OTA接口，请直接忽略本第4步，直接看第5步 找到`OTA_VERSION_URL`的`default`的内容，把`https://api.tenclass.net/xiaozhi/ota/` 改成你自己的地址，例如，我的接口地址是`http://192.168.1.25:8002/xiaozhi/ota/`，就把内容改成这个。 @@ -70,7 +56,7 @@ config OTA_VERSION_URL The application will access this URL to check for updates. ``` -## 第5步 设置编译参数 +## 第4步 设置编译参数 设置编译参数 @@ -91,7 +77,7 @@ idf.py menuconfig ![图片](images/build_setting02.png) -## 第6步 编译固件 +## 第5步 编译固件 ``` idf.py build @@ -103,7 +89,7 @@ idf.py build -## 第7步 打包bin固件 +## 第6步 打包bin固件 ``` cd scripts @@ -116,7 +102,7 @@ python release.py 注意：如果执行到第二命令后，报了“zip”相关的错误，请忽略这个错误，只要`build`目录下生成固件文件`merged-binary.bin` ，对你没有太大影响，请继续。 -## 第8步 烧录固件 +## 第7步 烧录固件 将esp32设备连接电脑，使用chrome浏览器，打开以下网址 ``` diff --git a/docs/firmware-setting.md b/docs/firmware-setting.md new file mode 100644 index 00000000..ae66b6e9 --- /dev/null +++ b/docs/firmware-setting.md @@ -0,0 +1,53 @@ +# 基于虾哥编译好的固件配置自定义服务器 + +## 第1步 确认版本 +烧录虾哥已经编译好的1.6.1版本固件 + +## 第2步 准备你的ota地址 +如果你按照教程使用的是全模块部署，就应该会有ota地址。 + +此刻，请你用浏览器打开你的ota地址，例如我的ota地址 +``` +https://2662r3426b.vicp.fun/xiaozhi/ota/ +``` + +如果显示“OTA接口运行正常，websocket集群数量：X”。那就往下。 + +如果显示“OTA接口运行不正常”，大概是你还没在`智控台`配置`Websocket`地址。那就： + +- 1、使用超级管理员登录智控台 + +- 2、顶部菜单点击`参数管理` + +- 3、在列表中找到`server.websocket`项目，输入你的`Websocket`地址。例如我的就是 + +``` +wss://2662r3426b.vicp.fun/xiaozhi/v1/ +``` + +配置完后，再使用浏览器刷新你的ota接口地址，看看是不是正常了。如果还不正常就，就再次确认一下Websocket是否正常启动，是否配置了Websocket地址。 + +## 第3步 进入配网模式 +进入机器的配网模式，在页面顶部，点击“高级选项”，在里面输入你服务器的`ota`地址，点击保存。重启设备 + +## 第4步 唤醒小智，查看日志输出 + +唤醒小智，看看日志是不是正常输出。 + + +## 常见问题 +以下是一些常见问题，供参考： + +[1、为什么我说的话，小智识别出来很多韩文、日文、英文](./FAQ.md) + +[2、为什么会出现“TTS 任务出错 文件不存在”？](./FAQ.md) + +[3、TTS 经常失败，经常超时](./FAQ.md) + +[4、使用Wifi能连接自建服务器，但是4G模式却接不上](./FAQ.md) + +[5、如何提高小智对话响应速度？](./FAQ.md) + +[6、我说话很慢，停顿时小智老是抢话](./FAQ.md) + +[7、我想通过小智控制电灯、空调、远程开关机等操作](./FAQ.md) diff --git a/docs/homeassistant-integration.md b/docs/homeassistant-integration.md new file mode 100644 index 00000000..d2dc4f9d --- /dev/null +++ b/docs/homeassistant-integration.md @@ -0,0 +1,111 @@ +# ESP32设备与HomeAssistant集成指南 + +## 简介 + +本文档将指导您如何将ESP32设备与HomeAssistant进行集成。 + +## 前提条件 + +- 已安装并配置好`HomeAssistant` +- 已经在HomeAssistant中集成`Xiaomi Home`，并将米家的设备导入进`HomeAssistant` +- `xiaozhi-esp32-server智控台`能正常使用 +- 本次我选择的模型是：免费的ChatGLM，它支持functioncall函数调用 + +## 网络环境 + +1、我的`HomeAssistant`部署在下面，版本是`2025.3.4` +``` +http://192.168.4.7:8123 +``` + +2、我的`xiaozhi-esp32-server智控台`和`HomeAssistant`部署在同一台机器的另一个端口，版本是`0.3.10` +``` +http://192.168.4.7:8002 +``` + + +## 配置步骤 + +### 1. 登录`HomeAssistant`整理需要控制的设备清单 + +登录`HomeAssistant`，点击`左下角的设置`，然后进入`设备与服务`，再点击顶部的`实体`。 + +然后在实体中搜索你相关控制的开关，结果出来后，在列表中，点击其中一个结果，这是会出现一个开关的界面。 + +在开关的界面，我们尝试点击开关，看看是开发会随着我们的点击开/关。如果能操作，说明是正常联网的。 + +接着在开关面板找到设置按钮，点击后，可以查看这个开关的`实体标识符`。 + +我们打开一个记事本，按照这样格式整理一条数据： + +位置+英文逗号+设备名称+英文逗号+`实体标识符`+英文分号 + +例如，我在公司，我有一个玩具灯，他的标识符是switch.cuco_cn_460494544_cp1_on_p_2_1，那么就这个写这一条数据 + +``` +公司,玩具灯,switch.cuco_cn_460494544_cp1_on_p_2_1; +``` + +当然最后我可能要操作两个灯，我的最终的结果是： + +``` +公司,玩具灯,switch.cuco_cn_460494544_cp1_on_p_2_1; +公司,台灯,switch.iot_cn_831898993_socn1_on_p_2_1; +``` + +这段字符，我们成为“设备清单字符”需要保存好，等一下有用。 + + +### 2. 登录`HomeAssistant`拿到开发密钥 + +登录`HomeAssistant`，点击`左下角个人`，切换`安全`导航栏，划到底部`长期访问令牌`生成api_key。 + + +### 3. 登录`智控台` + +使用管理员账号，登录`智控台`。点击顶部菜单`参数管理`，搜索`plugins.home_assistant.`，会有三条结果出来 + +编辑`plugins.home_assistant.devices`，把刚才整理的设备清单字符粘贴进去。 + + +编辑`plugins.home_assistant.base_url`，把你部署的`HomeAssistant`接口地址粘贴进去，我粘贴进去的地址是这样的 + +``` +http://192.168.4.7:8123 +``` + +编辑`plugins.home_assistant.api_key`，把你从`HomeAssistant`复制过来的密钥，粘贴进去 + + +### 4. 设置`意图识别`函数 + +在智控台，点击顶部菜单“模型配置”，在左侧栏，找到“意图识别”，找到id为`Intent_function_call`的意图，点击编辑 + +然后在弹框中，在原来的基础上追加两个函数：“hass_get_state”和“hass_set_state” + +修改前 +``` +change_role;get_weather;get_news;play_music +``` + +修改后 + +``` +change_role;get_weather;get_news;play_music;hass_get_state;hass_set_state +``` + +### 6. 手动重启xiaozhi-server + +重启xiaozhi-server程序 + + +### 5. 确认角色配置是否设置了函数意图识别 + +在智控台，点击顶部菜单“智能体管理”，找到设备所在的智能体，点击“配置角色” + +确认意图识别(Intent)，是否选择“函数调用意图识别” + + +### 6. 唤醒设别进行控制 + +尝试和esp32说，“打开XXX灯” \ No newline at end of file diff --git a/main/manager-api/src/main/java/xiaozhi/common/constant/Constant.java b/main/manager-api/src/main/java/xiaozhi/common/constant/Constant.java index 6f9dca2f..47d45e7e 100644 --- a/main/manager-api/src/main/java/xiaozhi/common/constant/Constant.java +++ b/main/manager-api/src/main/java/xiaozhi/common/constant/Constant.java @@ -84,6 +84,11 @@ public interface Constant { */ String SERVER_SECRET = "server.secret"; + /** + * websocket地址 + */ + String SERVER_WEBSOCKET = "server.websocket"; + /** * 是否允许用户注册 */ @@ -167,5 +172,5 @@ public interface Constant { /** * 版本号 */ - public static final String VERSION = "0.3.9"; + public static final String VERSION = "0.3.11"; } \ No newline at end of file diff --git a/main/manager-api/src/main/java/xiaozhi/common/redis/RedisKeys.java b/main/manager-api/src/main/java/xiaozhi/common/redis/RedisKeys.java index 8c266ce4..5d3b4f32 100644 --- a/main/manager-api/src/main/java/xiaozhi/common/redis/RedisKeys.java +++ b/main/manager-api/src/main/java/xiaozhi/common/redis/RedisKeys.java @@ -80,6 +80,20 @@ public class RedisKeys { * 获取版本号Key */ public static String getVersionKey() { - return "system:version"; + return "sys:version"; + } + + /** + * OTA固件ID的Key + */ + public static String getOtaIdKey(String uuid) { + return "ota:id:" + uuid; + } + + /** + * OTA固件下载次数的Key + */ + public static String getOtaDownloadCountKey(String uuid) { + return "ota:download:count:" + uuid; } } diff --git a/main/manager-api/src/main/java/xiaozhi/modules/device/controller/OTAController.java b/main/manager-api/src/main/java/xiaozhi/modules/device/controller/OTAController.java index e18439a1..eb108eae 100644 --- a/main/manager-api/src/main/java/xiaozhi/modules/device/controller/OTAController.java +++ b/main/manager-api/src/main/java/xiaozhi/modules/device/controller/OTAController.java @@ -23,11 +23,13 @@ import io.swagger.v3.oas.annotations.tags.Tag; import lombok.RequiredArgsConstructor; import lombok.SneakyThrows; import lombok.extern.slf4j.Slf4j; +import xiaozhi.common.constant.Constant; import xiaozhi.modules.device.dto.DeviceReportReqDTO; import xiaozhi.modules.device.dto.DeviceReportRespDTO; import xiaozhi.modules.device.entity.DeviceEntity; import xiaozhi.modules.device.service.DeviceService; import xiaozhi.modules.device.utils.NetworkUtil; +import xiaozhi.modules.sys.service.SysParamsService; @Tag(name = "设备管理", description = "OTA 相关接口") @Slf4j @@ -36,6 +38,7 @@ import xiaozhi.modules.device.utils.NetworkUtil; @RequestMapping("/ota/") public class OTAController { private final DeviceService deviceService; + private final SysParamsService sysParamsService; @Operation(summary = "OTA版本和设备激活状态检查") @PostMapping @@ -76,7 +79,11 @@ public class OTAController { @GetMapping @Hidden public ResponseEntity getOTA() { - return ResponseEntity.ok("OTA接口运行正常"); + String wsUrl = sysParamsService.getValue(Constant.SERVER_WEBSOCKET, true); + if (StringUtils.isBlank(wsUrl) || wsUrl.equals("null")) { + return ResponseEntity.ok("OTA接口不正常，缺少websocket地址"); + } + return ResponseEntity.ok("OTA接口运行正常，websocket集群数量：" + wsUrl.split(";").length); } @SneakyThrows diff --git a/main/manager-api/src/main/java/xiaozhi/modules/device/controller/OTAMagController.java b/main/manager-api/src/main/java/xiaozhi/modules/device/controller/OTAMagController.java new file mode 100644 index 00000000..bbe0c66a --- /dev/null +++ b/main/manager-api/src/main/java/xiaozhi/modules/device/controller/OTAMagController.java @@ -0,0 +1,291 @@ +package xiaozhi.modules.device.controller; + +import java.io.File; +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.security.MessageDigest; +import java.security.NoSuchAlgorithmException; +import java.util.Map; +import java.util.UUID; + +import org.apache.commons.lang3.StringUtils; +import org.apache.shiro.authz.annotation.RequiresPermissions; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpStatus; +import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.DeleteMapping; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.PathVariable; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.PutMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestParam; +import org.springframework.web.bind.annotation.RestController; +import org.springframework.web.multipart.MultipartFile; + +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.Parameter; +import io.swagger.v3.oas.annotations.Parameters; +import io.swagger.v3.oas.annotations.tags.Tag; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import xiaozhi.common.constant.Constant; +import xiaozhi.common.page.PageData; +import xiaozhi.common.redis.RedisKeys; +import xiaozhi.common.redis.RedisUtils; +import xiaozhi.common.utils.Result; +import xiaozhi.common.validator.ValidatorUtils; +import xiaozhi.modules.device.entity.OtaEntity; +import xiaozhi.modules.device.service.OtaService; + +@Tag(name = "设备管理", description = "OTA 相关接口") +@Slf4j +@RestController +@RequiredArgsConstructor +@RequestMapping("/otaMag") +public class OTAMagController { + private static final Logger logger = LoggerFactory.getLogger(OTAController.class); + private final OtaService otaService; + private final RedisUtils redisUtils; + + @GetMapping + @Operation(summary = "分页查询 OTA 固件信息") + @Parameters({ + @Parameter(name = Constant.PAGE, description = "当前页码，从1开始", required = true), + @Parameter(name = Constant.LIMIT, description = "每页显示记录数", required = true) + }) + @RequiresPermissions("sys:role:superAdmin") + public Result> page(@Parameter(hidden = true) @RequestParam Map params) { + ValidatorUtils.validateEntity(params); + PageData page = otaService.page(params); + return new Result>().ok(page); + } + + @GetMapping("{id}") + @Operation(summary = "信息 OTA 固件信息") + @RequiresPermissions("sys:role:superAdmin") + public Result get(@PathVariable("id") String id) { + OtaEntity data = otaService.selectById(id); + return new Result().ok(data); + } + + @PostMapping + @Operation(summary = "保存 OTA 固件信息") + @RequiresPermissions("sys:role:superAdmin") + public Result save(@RequestBody OtaEntity entity) { + if (entity == null) { + return new Result().error("固件信息不能为空"); + } + if (StringUtils.isBlank(entity.getFirmwareName())) { + return new Result().error("固件名称不能为空"); + } + if (StringUtils.isBlank(entity.getType())) { + return new Result().error("固件类型不能为空"); + } + if (StringUtils.isBlank(entity.getVersion())) { + return new Result().error("版本号不能为空"); + } + try { + otaService.save(entity); + return new Result(); + } catch (RuntimeException e) { + return new Result().error(e.getMessage()); + } + } + + @DeleteMapping("/{id}") + @Operation(summary = "OTA 删除") + @RequiresPermissions("sys:role:superAdmin") + public Result delete(@PathVariable("id") String[] ids) { + if (ids == null || ids.length == 0) { + return new Result().error("删除的固件ID不能为空"); + } + otaService.delete(ids); + return new Result(); + } + + @PutMapping("/{id}") + @Operation(summary = "修改 OTA 固件信息") + @RequiresPermissions("sys:role:superAdmin") + public Result update(@PathVariable("id") String id, @RequestBody OtaEntity entity) { + if (entity == null) { + return new Result<>().error("固件信息不能为空"); + } + entity.setId(id); + try { + otaService.update(entity); + return new Result<>(); + } catch (RuntimeException e) { + return new Result<>().error(e.getMessage()); + } + } + + @GetMapping("/getDownloadUrl/{id}") + @Operation(summary = "获取 OTA 固件下载链接") + @RequiresPermissions("sys:role:superAdmin") + public Result getDownloadUrl(@PathVariable("id") String id) { + String uuid = UUID.randomUUID().toString(); + redisUtils.set(RedisKeys.getOtaIdKey(uuid), id); + return new Result().ok(uuid); + } + + @GetMapping("/download/{uuid}") + @Operation(summary = "下载固件文件") + public ResponseEntity downloadFirmware(@PathVariable("uuid") String uuid) { + String id = (String) redisUtils.get(RedisKeys.getOtaIdKey(uuid)); + if (StringUtils.isBlank(id)) { + return ResponseEntity.notFound().build(); + } + + // 检查下载次数 + String downloadCountKey = RedisKeys.getOtaDownloadCountKey(uuid); + Integer downloadCount = (Integer) redisUtils.get(downloadCountKey); + if (downloadCount == null) { + downloadCount = 0; + } + + // 如果下载次数超过3次，返回404 + if (downloadCount >= 3) { + redisUtils.delete(downloadCountKey); + redisUtils.delete(RedisKeys.getOtaIdKey(uuid)); + logger.warn("Download limit exceeded for UUID: {}", uuid); + return ResponseEntity.notFound().build(); + } + + redisUtils.set(downloadCountKey, downloadCount + 1); + + try { + // 获取固件信息 + OtaEntity otaEntity = otaService.selectById(id); + if (otaEntity == null || StringUtils.isBlank(otaEntity.getFirmwarePath())) { + logger.warn("Firmware not found or path is empty for ID: {}", id); + return ResponseEntity.notFound().build(); + } + + // 获取文件路径 - 确保路径是绝对路径或正确的相对路径 + String firmwarePath = otaEntity.getFirmwarePath(); + Path path; + + // 检查是否是绝对路径 + if (Paths.get(firmwarePath).isAbsolute()) { + path = Paths.get(firmwarePath); + } else { + // 如果是相对路径，则从当前工作目录解析 + path = Paths.get(System.getProperty("user.dir"), firmwarePath); + } + + logger.info("Attempting to download firmware for ID: {}, DB path: {}, resolved path: {}", + id, firmwarePath, path.toAbsolutePath()); + + if (!Files.exists(path) || !Files.isRegularFile(path)) { + // 尝试直接从firmware目录下查找文件名 + String fileName = new File(firmwarePath).getName(); + Path altPath = Paths.get(System.getProperty("user.dir"), "firmware", fileName); + + logger.info("File not found at primary path, trying alternative path: {}", altPath.toAbsolutePath()); + + if (Files.exists(altPath) && Files.isRegularFile(altPath)) { + path = altPath; + } else { + logger.error("Firmware file not found at either path: {} or {}", + path.toAbsolutePath(), altPath.toAbsolutePath()); + return ResponseEntity.notFound().build(); + } + } + + // 读取文件内容 + byte[] fileContent = Files.readAllBytes(path); + + // 设置响应头 + String originalFilename = otaEntity.getType() + "_" + otaEntity.getVersion(); + if (firmwarePath.contains(".")) { + String extension = firmwarePath.substring(firmwarePath.lastIndexOf(".")); + originalFilename += extension; + } + + // 清理文件名，移除不安全字符 + String safeFilename = originalFilename.replaceAll("[^a-zA-Z0-9._-]", "_"); + + logger.info("Providing download for firmware ID: {}, filename: {}, size: {} bytes", + id, safeFilename, fileContent.length); + + return ResponseEntity.ok() + .contentType(MediaType.APPLICATION_OCTET_STREAM) + .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + safeFilename + "\"") + .body(fileContent); + } catch (IOException e) { + logger.error("Error reading firmware file for ID: {}", id, e); + return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build(); + } catch (Exception e) { + logger.error("Unexpected error during firmware download for ID: {}", id, e); + return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build(); + } + } + + @PostMapping("/upload") + @Operation(summary = "上传固件文件") + @RequiresPermissions("sys:role:superAdmin") + public Result uploadFirmware(@RequestParam("file") MultipartFile file) { + if (file.isEmpty()) { + return new Result().error("上传文件不能为空"); + } + + // 检查文件扩展名 + String originalFilename = file.getOriginalFilename(); + if (originalFilename == null) { + return new Result().error("文件名不能为空"); + } + + String extension = originalFilename.substring(originalFilename.lastIndexOf(".")).toLowerCase(); + if (!extension.equals(".bin") && !extension.equals(".apk")) { + return new Result().error("只允许上传.bin和.apk格式的文件"); + } + + try { + // 计算文件的MD5值 + String md5 = calculateMD5(file); + + // 设置存储路径 + String uploadDir = "uploadfile"; + Path uploadPath = Paths.get(uploadDir); + + // 如果目录不存在，创建目录 + if (!Files.exists(uploadPath)) { + Files.createDirectories(uploadPath); + } + + // 使用MD5作为文件名，固定使用.bin扩展名 + String uniqueFileName = md5 + extension; + Path filePath = uploadPath.resolve(uniqueFileName); + + // 检查文件是否已存在 + if (Files.exists(filePath)) { + return new Result().ok(filePath.toString()); + } + + // 保存文件 + Files.copy(file.getInputStream(), filePath); + + // 返回文件路径 + return new Result().ok(filePath.toString()); + } catch (IOException | NoSuchAlgorithmException e) { + return new Result().error("文件上传失败：" + e.getMessage()); + } + } + + private String calculateMD5(MultipartFile file) throws IOException, NoSuchAlgorithmException { + MessageDigest md = MessageDigest.getInstance("MD5"); + byte[] digest = md.digest(file.getBytes()); + StringBuilder sb = new StringBuilder(); + for (byte b : digest) { + sb.append(String.format("%02x", b)); + } + return sb.toString(); + } +} diff --git a/main/manager-api/src/main/java/xiaozhi/modules/device/dao/OtaDao.java b/main/manager-api/src/main/java/xiaozhi/modules/device/dao/OtaDao.java new file mode 100644 index 00000000..975f69be --- /dev/null +++ b/main/manager-api/src/main/java/xiaozhi/modules/device/dao/OtaDao.java @@ -0,0 +1,15 @@ +package xiaozhi.modules.device.dao; + +import org.apache.ibatis.annotations.Mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; + +import xiaozhi.modules.device.entity.OtaEntity; + +/** + * OTA固件管理 + */ +@Mapper +public interface OtaDao extends BaseMapper { + +} \ No newline at end of file diff --git a/main/manager-api/src/main/java/xiaozhi/modules/device/dto/DeviceReportRespDTO.java b/main/manager-api/src/main/java/xiaozhi/modules/device/dto/DeviceReportRespDTO.java index d7e10792..f938001e 100644 --- a/main/manager-api/src/main/java/xiaozhi/modules/device/dto/DeviceReportRespDTO.java +++ b/main/manager-api/src/main/java/xiaozhi/modules/device/dto/DeviceReportRespDTO.java @@ -19,6 +19,9 @@ public class DeviceReportRespDTO { @Schema(description = "固件版本信息") private Firmware firmware; + + @Schema(description = "WebSocket配置") + private Websocket websocket; @Getter @Setter @@ -60,4 +63,11 @@ public class DeviceReportRespDTO { @Schema(description = "时区偏移量，单位为分钟") private Integer timezone_offset; } + + @Getter + @Setter + public static class Websocket { + @Schema(description = "WebSocket服务器地址") + private String url; + } } diff --git a/main/manager-api/src/main/java/xiaozhi/modules/device/entity/OtaEntity.java b/main/manager-api/src/main/java/xiaozhi/modules/device/entity/OtaEntity.java new file mode 100644 index 00000000..b93c608b --- /dev/null +++ b/main/manager-api/src/main/java/xiaozhi/modules/device/entity/OtaEntity.java @@ -0,0 +1,61 @@ +package xiaozhi.modules.device.entity; + +import java.util.Date; + +import com.baomidou.mybatisplus.annotation.FieldFill; +import com.baomidou.mybatisplus.annotation.IdType; +import com.baomidou.mybatisplus.annotation.TableField; +import com.baomidou.mybatisplus.annotation.TableId; +import com.baomidou.mybatisplus.annotation.TableName; + +import io.swagger.v3.oas.annotations.media.Schema; +import lombok.Data; +import lombok.EqualsAndHashCode; + +@Data +@EqualsAndHashCode(callSuper = false) +@TableName("ai_ota") +@Schema(description = "固件信息") +public class OtaEntity { + + @TableId(type = IdType.ASSIGN_UUID) + @Schema(description = "ID") + private String id; + + @Schema(description = "固件名称") + private String firmwareName; + + @Schema(description = "固件类型") + private String type; + + @Schema(description = "版本号") + private String version; + + @Schema(description = "文件大小(字节)") + private Long size; + + @Schema(description = "备注/说明") + private String remark; + + @Schema(description = "固件路径") + private String firmwarePath; + + @Schema(description = "排序") + private Integer sort; + + @Schema(description = "更新者") + @TableField(fill = FieldFill.UPDATE) + private Long updater; + + @Schema(description = "更新时间") + @TableField(fill = FieldFill.UPDATE) + private Date updateDate; + + @Schema(description = "创建者") + @TableField(fill = FieldFill.INSERT) + private Long creator; + + @Schema(description = "创建时间") + @TableField(fill = FieldFill.INSERT) + private Date createDate; +} \ No newline at end of file diff --git a/main/manager-api/src/main/java/xiaozhi/modules/device/service/OtaService.java b/main/manager-api/src/main/java/xiaozhi/modules/device/service/OtaService.java new file mode 100644 index 00000000..0f50a582 --- /dev/null +++ b/main/manager-api/src/main/java/xiaozhi/modules/device/service/OtaService.java @@ -0,0 +1,20 @@ +package xiaozhi.modules.device.service; + +import java.util.Map; + +import xiaozhi.common.page.PageData; +import xiaozhi.common.service.BaseService; +import xiaozhi.modules.device.entity.OtaEntity; + +/** + * OTA固件管理 + */ +public interface OtaService extends BaseService { + PageData page(Map params); + + boolean save(OtaEntity entity); + + void update(OtaEntity entity); + + void delete(String[] ids); +} \ No newline at end of file diff --git a/main/manager-api/src/main/java/xiaozhi/modules/device/service/impl/DeviceServiceImpl.java b/main/manager-api/src/main/java/xiaozhi/modules/device/service/impl/DeviceServiceImpl.java index aef15749..2006791b 100644 --- a/main/manager-api/src/main/java/xiaozhi/modules/device/service/impl/DeviceServiceImpl.java +++ b/main/manager-api/src/main/java/xiaozhi/modules/device/service/impl/DeviceServiceImpl.java @@ -18,6 +18,7 @@ import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper; import com.baomidou.mybatisplus.core.metadata.IPage; import cn.hutool.core.util.RandomUtil; +import lombok.extern.slf4j.Slf4j; import xiaozhi.common.constant.Constant; import xiaozhi.common.exception.RenException; import xiaozhi.common.page.PageData; @@ -36,6 +37,7 @@ import xiaozhi.modules.security.user.SecurityUser; import xiaozhi.modules.sys.service.SysParamsService; import xiaozhi.modules.sys.service.SysUserUtilService; +@Slf4j @Service public class DeviceServiceImpl extends BaseServiceImpl implements DeviceService { @@ -43,18 +45,18 @@ public class DeviceServiceImpl extends BaseServiceImpl private final SysUserUtilService sysUserUtilService; - private final String frontedUrl; - private final RedisTemplate redisTemplate; + private final SysParamsService sysParamsService; + // 添加构造函数来初始化 deviceMapper public DeviceServiceImpl(DeviceDao deviceDao, SysUserUtilService sysUserUtilService, SysParamsService sysParamsService, RedisTemplate redisTemplate) { this.deviceDao = deviceDao; this.sysUserUtilService = sysUserUtilService; - this.frontedUrl = sysParamsService.getValue(Constant.SERVER_FRONTED_URL, true); this.redisTemplate = redisTemplate; + this.sysParamsService = sysParamsService; } @Override @@ -132,6 +134,27 @@ public class DeviceServiceImpl extends BaseServiceImpl firmware.setUrl("http://localhost:8002/xiaozhi/ota/download"); response.setFirmware(firmware); + // 添加WebSocket配置 + DeviceReportRespDTO.Websocket websocket = new DeviceReportRespDTO.Websocket(); + // 从系统参数获取WebSocket URL，如果未配置则使用默认值 + String wsUrl = sysParamsService.getValue(Constant.SERVER_WEBSOCKET, true); + if (StringUtils.isBlank(wsUrl) || wsUrl.equals("null")) { + log.error("WebSocket URL is not configured"); + wsUrl = "ws://xiaozhi.server.com:8000/xiaozhi/v1/"; + websocket.setUrl(wsUrl); + } else { + String[] wsUrls = wsUrl.split("\\;"); + if (wsUrls.length > 0) { + // 随机选择一个WebSocket URL + websocket.setUrl(wsUrls[RandomUtil.randomInt(0, wsUrls.length)]); + } else { + log.error("WebSocket URL list is empty"); + websocket.setUrl("ws://xiaozhi.server.com:8000/xiaozhi/v1/"); + } + } + + response.setWebsocket(websocket); + DeviceEntity deviceById = getDeviceById(macAddress); if (deviceById != null) { // 如果设备存在，则更新上次连接时间 deviceById.setLastConnectedAt(new Date()); @@ -250,11 +273,13 @@ public class DeviceServiceImpl extends BaseServiceImpl if (StringUtils.isNotBlank(cachedCode)) { code.setCode(cachedCode); + String frontedUrl = sysParamsService.getValue(Constant.SERVER_FRONTED_URL, true); code.setMessage(frontedUrl + "\n" + cachedCode); code.setChallenge(deviceId); } else { String newCode = RandomUtil.randomNumbers(6); code.setCode(newCode); + String frontedUrl = sysParamsService.getValue(Constant.SERVER_FRONTED_URL, true); code.setMessage(frontedUrl + "\n" + newCode); code.setChallenge(deviceId); diff --git a/main/manager-api/src/main/java/xiaozhi/modules/device/service/impl/OtaServiceImpl.java b/main/manager-api/src/main/java/xiaozhi/modules/device/service/impl/OtaServiceImpl.java new file mode 100644 index 00000000..aca69b9c --- /dev/null +++ b/main/manager-api/src/main/java/xiaozhi/modules/device/service/impl/OtaServiceImpl.java @@ -0,0 +1,74 @@ +package xiaozhi.modules.device.service.impl; + +import java.util.Arrays; +import java.util.Map; + +import org.springframework.stereotype.Service; + +import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; +import com.baomidou.mybatisplus.core.metadata.IPage; + +import io.micrometer.common.util.StringUtils; +import xiaozhi.common.page.PageData; +import xiaozhi.common.service.impl.BaseServiceImpl; +import xiaozhi.modules.device.dao.OtaDao; +import xiaozhi.modules.device.entity.OtaEntity; +import xiaozhi.modules.device.service.OtaService; + +@Service +public class OtaServiceImpl extends BaseServiceImpl implements OtaService { + + @Override + public PageData page(Map params) { + IPage page = baseDao.selectPage( + getPage(params, "update_date", true), + getWrapper(params)); + + return new PageData<>(page.getRecords(), page.getTotal()); + } + + private QueryWrapper getWrapper(Map params) { + String firmwareName = (String) params.get("firmwareName"); + + QueryWrapper wrapper = new QueryWrapper<>(); + wrapper.like(StringUtils.isNotBlank(firmwareName), "firmware_name", firmwareName); + + return wrapper; + } + + @Override + public void update(OtaEntity entity) { + // 检查是否存在相同名称、类型和版本的固件（排除当前记录） + QueryWrapper queryWrapper = new QueryWrapper() + .eq("firmware_name", entity.getFirmwareName()) + .eq("type", entity.getType()) + .eq("version", entity.getVersion()) + .ne("id", entity.getId()); // 排除当前记录 + + if (baseDao.selectCount(queryWrapper) > 0) { + throw new RuntimeException("已存在相同名称、类型和版本的固件，请修改后重试"); + } + + baseDao.updateById(entity); + } + + @Override + public void delete(String[] ids) { + baseDao.deleteBatchIds(Arrays.asList(ids)); + } + + @Override + public boolean save(OtaEntity entity) { + // 检查是否存在相同名称、类型和版本的固件 + QueryWrapper queryWrapper = new QueryWrapper() + .eq("firmware_name", entity.getFirmwareName()) + .eq("type", entity.getType()) + .eq("version", entity.getVersion()); + + if (baseDao.selectCount(queryWrapper) > 0) { + throw new RuntimeException("已存在相同名称、类型和版本的固件，请勿重复添加"); + } + + return baseDao.insert(entity) > 0; + } +} \ No newline at end of file diff --git a/main/manager-api/src/main/java/xiaozhi/modules/security/config/ShiroConfig.java b/main/manager-api/src/main/java/xiaozhi/modules/security/config/ShiroConfig.java index fdcb62b2..6e68ce06 100644 --- a/main/manager-api/src/main/java/xiaozhi/modules/security/config/ShiroConfig.java +++ b/main/manager-api/src/main/java/xiaozhi/modules/security/config/ShiroConfig.java @@ -69,6 +69,7 @@ public class ShiroConfig { */ Map filterMap = new LinkedHashMap<>(); filterMap.put("/ota/**", "anon"); + filterMap.put("/otaMag/download/**", "anon"); filterMap.put("/webjars/**", "anon"); filterMap.put("/druid/**", "anon"); filterMap.put("/v3/api-docs/**", "anon"); diff --git a/main/manager-api/src/main/java/xiaozhi/modules/sys/controller/SysParamsController.java b/main/manager-api/src/main/java/xiaozhi/modules/sys/controller/SysParamsController.java index 1951333f..157eb94e 100644 --- a/main/manager-api/src/main/java/xiaozhi/modules/sys/controller/SysParamsController.java +++ b/main/manager-api/src/main/java/xiaozhi/modules/sys/controller/SysParamsController.java @@ -2,6 +2,7 @@ package xiaozhi.modules.sys.controller; import java.util.Map; +import org.apache.commons.lang3.StringUtils; import org.apache.shiro.authz.annotation.RequiresPermissions; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; @@ -20,6 +21,7 @@ import io.swagger.v3.oas.annotations.tags.Tag; import lombok.AllArgsConstructor; import xiaozhi.common.annotation.LogOperation; import xiaozhi.common.constant.Constant; +import xiaozhi.common.exception.RenException; import xiaozhi.common.page.PageData; import xiaozhi.common.utils.Result; import xiaozhi.common.validator.AssertUtils; @@ -30,6 +32,7 @@ import xiaozhi.common.validator.group.UpdateGroup; import xiaozhi.modules.config.service.ConfigService; import xiaozhi.modules.sys.dto.SysParamsDTO; import xiaozhi.modules.sys.service.SysParamsService; +import xiaozhi.modules.sys.utils.WebSocketValidator; /** * 参数管理 @@ -91,11 +94,43 @@ public class SysParamsController { // 效验数据 ValidatorUtils.validateEntity(dto, UpdateGroup.class, DefaultGroup.class); + // 验证WebSocket地址列表 + validateWebSocketUrls(dto.getParamCode(), dto.getParamValue()); + sysParamsService.update(dto); configService.getConfig(false); return new Result(); } + /** + * 验证WebSocket地址列表 + * + * @param urls WebSocket地址列表，以分号分隔 + * @return 验证结果 + */ + private void validateWebSocketUrls(String paramCode, String urls) { + if (!paramCode.equals(Constant.SERVER_WEBSOCKET)) { + return; + } + String[] wsUrls = urls.split("\\;"); + if (wsUrls.length == 0) { + throw new RenException("WebSocket地址列表不能为空"); + } + for (String url : wsUrls) { + if (StringUtils.isNotBlank(url)) { + // 验证WebSocket地址格式 + if (!WebSocketValidator.validateUrlFormat(url)) { + throw new RenException("WebSocket地址格式不正确: " + url); + } + + // 测试WebSocket连接 + if (!WebSocketValidator.testConnection(url)) { + throw new RenException("WebSocket连接测试失败: " + url); + } + } + } + } + @PostMapping("/delete") @Operation(summary = "删除") @LogOperation("删除") diff --git a/main/manager-api/src/main/java/xiaozhi/modules/sys/utils/WebSocketTestHandler.java b/main/manager-api/src/main/java/xiaozhi/modules/sys/utils/WebSocketTestHandler.java new file mode 100644 index 00000000..d9563c29 --- /dev/null +++ b/main/manager-api/src/main/java/xiaozhi/modules/sys/utils/WebSocketTestHandler.java @@ -0,0 +1,46 @@ +package xiaozhi.modules.sys.utils; + +import java.util.concurrent.CompletableFuture; + +import org.springframework.web.socket.CloseStatus; +import org.springframework.web.socket.WebSocketHandler; +import org.springframework.web.socket.WebSocketMessage; +import org.springframework.web.socket.WebSocketSession; + +public class WebSocketTestHandler implements WebSocketHandler { + private final CompletableFuture future; + + public WebSocketTestHandler(CompletableFuture future) { + this.future = future; + } + + @Override + public void afterConnectionEstablished(WebSocketSession session) { + future.complete(true); + try { + session.close(); + } catch (Exception e) { + // 忽略关闭异常 + } + } + + @Override + public void handleMessage(WebSocketSession session, WebSocketMessage message) { + // 不需要处理消息 + } + + @Override + public void handleTransportError(WebSocketSession session, Throwable exception) { + future.complete(false); + } + + @Override + public void afterConnectionClosed(WebSocketSession session, CloseStatus closeStatus) { + // 连接关闭时不做任何处理 + } + + @Override + public boolean supportsPartialMessages() { + return false; + } +} \ No newline at end of file diff --git a/main/manager-api/src/main/java/xiaozhi/modules/sys/utils/WebSocketValidator.java b/main/manager-api/src/main/java/xiaozhi/modules/sys/utils/WebSocketValidator.java new file mode 100644 index 00000000..d9ff280b --- /dev/null +++ b/main/manager-api/src/main/java/xiaozhi/modules/sys/utils/WebSocketValidator.java @@ -0,0 +1,58 @@ +package xiaozhi.modules.sys.utils; + +import java.net.URI; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.TimeUnit; +import java.util.regex.Pattern; + +import org.apache.commons.lang3.StringUtils; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.web.socket.client.WebSocketClient; +import org.springframework.web.socket.client.standard.StandardWebSocketClient; + +public class WebSocketValidator { + private static final Logger logger = LoggerFactory.getLogger(WebSocketValidator.class); + + // WebSocket URL正则表达式 + private static final Pattern WS_URL_PATTERN = Pattern + .compile("^wss?://[\\w.-]+(?:\\.[\\w.-]+)*(?::\\d+)?(?:/[\\w.-]*)*$"); + + /** + * 验证WebSocket地址格式 + * + * @param url WebSocket地址 + * @return 是否有效 + */ + public static boolean validateUrlFormat(String url) { + if (StringUtils.isBlank(url)) { + return false; + } + return WS_URL_PATTERN.matcher(url.trim()).matches(); + } + + /** + * 测试WebSocket连接 + * + * @param url WebSocket地址 + * @return 是否可连接 + */ + public static boolean testConnection(String url) { + if (!validateUrlFormat(url)) { + return false; + } + + try { + WebSocketClient client = new StandardWebSocketClient(); + CompletableFuture future = new CompletableFuture<>(); + + client.doHandshake(new WebSocketTestHandler(future), null, URI.create(url)); + + // 等待最多5秒获取连接结果 + return future.get(5, TimeUnit.SECONDS); + } catch (Exception e) { + logger.error("WebSocket连接测试失败: {}", url, e); + return false; + } + } +} \ No newline at end of file diff --git a/main/manager-api/src/main/java/xiaozhi/modules/timbre/dto/TimbreDataDTO.java b/main/manager-api/src/main/java/xiaozhi/modules/timbre/dto/TimbreDataDTO.java index ed737db9..030e2b4a 100644 --- a/main/manager-api/src/main/java/xiaozhi/modules/timbre/dto/TimbreDataDTO.java +++ b/main/manager-api/src/main/java/xiaozhi/modules/timbre/dto/TimbreDataDTO.java @@ -24,7 +24,6 @@ public class TimbreDataDTO { private String name; @Schema(description = "备注") - @NotBlank(message = "{timbre.remark.require}") private String remark; @Schema(description = "排序") @@ -40,6 +39,5 @@ public class TimbreDataDTO { private String ttsVoice; @Schema(description = "音频播放地址") - @NotBlank(message = "{timbre.voiceDemo.require}") private String voiceDemo; } \ No newline at end of file diff --git a/main/manager-api/src/main/resources/db/changelog/202504131542.sql b/main/manager-api/src/main/resources/db/changelog/202504131542.sql deleted file mode 100644 index 383ba187..00000000 --- a/main/manager-api/src/main/resources/db/changelog/202504131542.sql +++ /dev/null @@ -1,3 +0,0 @@ --- 对0.3.0版本之前的参数进行修改 -update `sys_params` set param_value = '.mp3;.wav;.p3' where param_code = 'plugins.play_music.music_ext'; -update `ai_model_config` set config_json = '{\"type\": \"intent_llm\", \"llm\": \"LLM_ChatGLMLLM\"}' where id = 'Intent_intent_llm'; diff --git a/main/manager-api/src/main/resources/db/changelog/202504180758.sql b/main/manager-api/src/main/resources/db/changelog/202504180758.sql new file mode 100644 index 00000000..160a5f25 --- /dev/null +++ b/main/manager-api/src/main/resources/db/changelog/202504180758.sql @@ -0,0 +1,19 @@ +-- 本文件用于初始化固件信息表，无需手动执行，在项目启动时会自动执行 +-- ------------------------------------------------------- +-- 初始化固件信息表 +drop table if exists `ai_ota`; +CREATE TABLE `ai_ota` ( + `id` varchar(32) NOT NULL COMMENT 'ID', + `firmware_name` varchar(100) DEFAULT NULL COMMENT '固件名称', + `type` varchar(50) DEFAULT NULL COMMENT '固件类型', + `version` varchar(50) DEFAULT NULL COMMENT '版本号', + `size` bigint DEFAULT NULL COMMENT '文件大小(字节)', + `remark` varchar(500) DEFAULT NULL COMMENT '备注/说明', + `firmware_path` varchar(255) DEFAULT NULL COMMENT '固件路径', + `sort` int unsigned DEFAULT '0' COMMENT '排序', + `updater` bigint DEFAULT NULL COMMENT '更新者', + `update_date` datetime DEFAULT NULL COMMENT '更新时间', + `creator` bigint DEFAULT NULL COMMENT '创建者', + `create_date` datetime DEFAULT NULL COMMENT '创建时间', + PRIMARY KEY (`id`) +) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='固件信息表'; diff --git a/main/manager-api/src/main/resources/db/changelog/202504181534.sql b/main/manager-api/src/main/resources/db/changelog/202504181534.sql deleted file mode 100644 index dcf7d336..00000000 --- a/main/manager-api/src/main/resources/db/changelog/202504181534.sql +++ /dev/null @@ -1,2 +0,0 @@ -delete from `ai_model_config` where id = 'Intent_function_call'; -INSERT INTO `ai_model_config` VALUES ('Intent_function_call', 'Intent', 'function_call', '函数调用意图识别', 0, 1, '{\"type\": \"function_call\", \"functions\": \"change_role;get_weather;get_news;play_music\"}', NULL, NULL, 3, NULL, NULL, NULL, NULL); diff --git a/main/manager-api/src/main/resources/db/changelog/202504211118.sql b/main/manager-api/src/main/resources/db/changelog/202504211118.sql deleted file mode 100644 index 6bbdc183..00000000 --- a/main/manager-api/src/main/resources/db/changelog/202504211118.sql +++ /dev/null @@ -1,19 +0,0 @@ --- 删除无用模型供应器 -delete from `ai_model_provider` where id = 'SYSTEM_LLM_doubao'; -delete from `ai_model_provider` where id = 'SYSTEM_LLM_chatglm'; -delete from `ai_model_provider` where id = 'SYSTEM_TTS_302ai'; -delete from `ai_model_provider` where id = 'SYSTEM_TTS_gizwits'; - --- 添加模型供应器 -delete from `ai_model_provider` where id = 'SYSTEM_ASR_TencentASR'; -INSERT INTO `ai_model_provider` (`id`, `model_type`, `provider_code`, `name`, `fields`, `sort`, `creator`, `create_date`, `updater`, `update_date`) VALUES -('SYSTEM_ASR_TencentASR', 'ASR', 'tencent', '腾讯语音识别', '[{"key":"appid","label":"应用ID","type":"string"},{"key":"secret_id","label":"Secret ID","type":"string"},{"key":"secret_key","label":"Secret Key","type":"string"},{"key":"output_dir","label":"输出目录","type":"string"}]', 4, 1, NOW(), 1, NOW()); - --- 添加腾讯语音合成模型供应器 -delete from `ai_model_provider` where id = 'SYSTEM_TTS_TencentTTS'; -INSERT INTO `ai_model_provider` (`id`, `model_type`, `provider_code`, `name`, `fields`, `sort`, `creator`, `create_date`, `updater`, `update_date`) VALUES -('SYSTEM_TTS_TencentTTS', 'TTS', 'tencent', '腾讯语音合成', '[{"key":"appid","label":"应用ID","type":"string"},{"key":"secret_id","label":"Secret ID","type":"string"},{"key":"secret_key","label":"Secret Key","type":"string"},{"key":"output_dir","label":"输出目录","type":"string"},{"key":"region","label":"区域","type":"string"},{"key":"voice","label":"音色ID","type":"string"}]', 5, 1, NOW(), 1, NOW()); - --- 添加腾讯语音合成音色 -delete from `ai_tts_voice` where id = 'TTS_TencentTTS0001'; -INSERT INTO `ai_tts_voice` VALUES ('TTS_TencentTTS0001', 'TTS_TencentTTS', '智瑜', '101001', '中文', NULL, NULL, 1, NULL, NULL, NULL, NULL); diff --git a/main/manager-api/src/main/resources/db/changelog/202504221135.sql b/main/manager-api/src/main/resources/db/changelog/202504221135.sql new file mode 100644 index 00000000..79c80446 --- /dev/null +++ b/main/manager-api/src/main/resources/db/changelog/202504221135.sql @@ -0,0 +1,88 @@ +-- 删除无用模型供应器 +delete from `ai_model_provider` where id = 'SYSTEM_LLM_doubao'; +delete from `ai_model_provider` where id = 'SYSTEM_LLM_chatglm'; +delete from `ai_model_provider` where id = 'SYSTEM_TTS_302ai'; +delete from `ai_model_provider` where id = 'SYSTEM_TTS_gizwits'; + +-- 添加模型供应器 +delete from `ai_model_provider` where id = 'SYSTEM_ASR_TencentASR'; +INSERT INTO `ai_model_provider` (`id`, `model_type`, `provider_code`, `name`, `fields`, `sort`, `creator`, `create_date`, `updater`, `update_date`) VALUES +('SYSTEM_ASR_TencentASR', 'ASR', 'tencent', '腾讯语音识别', '[{"key":"appid","label":"应用ID","type":"string"},{"key":"secret_id","label":"Secret ID","type":"string"},{"key":"secret_key","label":"Secret Key","type":"string"},{"key":"output_dir","label":"输出目录","type":"string"}]', 4, 1, NOW(), 1, NOW()); + +-- 添加腾讯语音合成模型供应器 +delete from `ai_model_provider` where id = 'SYSTEM_TTS_TencentTTS'; +INSERT INTO `ai_model_provider` (`id`, `model_type`, `provider_code`, `name`, `fields`, `sort`, `creator`, `create_date`, `updater`, `update_date`) VALUES +('SYSTEM_TTS_TencentTTS', 'TTS', 'tencent', '腾讯语音合成', '[{"key":"appid","label":"应用ID","type":"string"},{"key":"secret_id","label":"Secret ID","type":"string"},{"key":"secret_key","label":"Secret Key","type":"string"},{"key":"output_dir","label":"输出目录","type":"string"},{"key":"region","label":"区域","type":"string"},{"key":"voice","label":"音色ID","type":"string"}]', 5, 1, NOW(), 1, NOW()); + + +-- 添加edge音色 +delete from `ai_tts_voice` where id in ('TTS_EdgeTTS0001', 'TTS_EdgeTTS0002', 'TTS_EdgeTTS0003', 'TTS_EdgeTTS0004', 'TTS_EdgeTTS0005', 'TTS_EdgeTTS0006', 'TTS_EdgeTTS0007', 'TTS_EdgeTTS0008', 'TTS_EdgeTTS0009', 'TTS_EdgeTTS0010', 'TTS_EdgeTTS0011'); +INSERT INTO `ai_tts_voice` VALUES +('TTS_EdgeTTS0001', 'TTS_EdgeTTS', 'EdgeTTS女声-晓晓', 'zh-CN-XiaoxiaoNeural', '普通话', NULL, NULL, 1, NULL, NULL, NULL, NULL), +('TTS_EdgeTTS0002', 'TTS_EdgeTTS', 'EdgeTTS男声-云扬', 'zh-CN-YunyangNeural', '普通话', NULL, NULL, 1, NULL, NULL, NULL, NULL), +('TTS_EdgeTTS0003', 'TTS_EdgeTTS', 'EdgeTTS女声-晓伊', 'zh-CN-XiaoyiNeural', '普通话', NULL, NULL, 1, NULL, NULL, NULL, NULL), +('TTS_EdgeTTS0004', 'TTS_EdgeTTS', 'EdgeTTS男声-云健', 'zh-CN-YunjianNeural', '普通话', NULL, NULL, 1, NULL, NULL, NULL, NULL), +('TTS_EdgeTTS0005', 'TTS_EdgeTTS', 'EdgeTTS男声-云希', 'zh-CN-YunxiNeural', '普通话', NULL, NULL, 1, NULL, NULL, NULL, NULL), +('TTS_EdgeTTS0006', 'TTS_EdgeTTS', 'EdgeTTS男声-云夏', 'zh-CN-YunxiaNeural', '普通话', NULL, NULL, 1, NULL, NULL, NULL, NULL), +('TTS_EdgeTTS0007', 'TTS_EdgeTTS', 'EdgeTTS女声-辽宁小贝', 'zh-CN-liaoning-XiaobeiNeural', '辽宁', NULL, NULL, 1, NULL, NULL, NULL, NULL), +('TTS_EdgeTTS0008', 'TTS_EdgeTTS', 'EdgeTTS女声-陕西小妮', 'zh-CN-shaanxi-XiaoniNeural', '陕西', NULL, NULL, 1, NULL, NULL, NULL, NULL), +('TTS_EdgeTTS0009', 'TTS_EdgeTTS', 'EdgeTTS女声-香港海佳', 'zh-HK-HiuGaaiNeural', '粤语', 'General', 'Friendly, Positive', 1, NULL, NULL, NULL, NULL), +('TTS_EdgeTTS0010', 'TTS_EdgeTTS', 'EdgeTTS女声-香港海曼', 'zh-HK-HiuMaanNeural', '粤语', 'General', 'Friendly, Positive', 1, NULL, NULL, NULL, NULL), +('TTS_EdgeTTS0011', 'TTS_EdgeTTS', 'EdgeTTS男声-香港万龙', 'zh-HK-WanLungNeural', '粤语', 'General', 'Friendly, Positive', 1, NULL, NULL, NULL, NULL); + +-- DoubaoTTS音色 +delete from `ai_tts_voice` where id in ('TTS_DoubaoTTS0001', 'TTS_DoubaoTTS0002', 'TTS_DoubaoTTS0003', 'TTS_DoubaoTTS0004', 'TTS_DoubaoTTS0005'); +INSERT INTO `ai_tts_voice` VALUES ('TTS_DoubaoTTS0001', 'TTS_DoubaoTTS', '通用女声', 'BV001_streaming', '普通话', 'https://lf3-speech.bytetos.com/obj/speech-tts-external/portal/Portal_Demo_BV001.mp3', NULL, 3, NULL, NULL, NULL, NULL); +INSERT INTO `ai_tts_voice` VALUES ('TTS_DoubaoTTS0002', 'TTS_DoubaoTTS', '通用男声', 'BV002_streaming', '普通话', 'https://lf3-speech.bytetos.com/obj/speech-tts-external/portal/Portal_Demo_BV002.mp3', NULL, 2, NULL, NULL, NULL, NULL); +INSERT INTO `ai_tts_voice` VALUES ('TTS_DoubaoTTS0003', 'TTS_DoubaoTTS', '阳光男生', 'BV056_streaming', '普通话', 'https://lf3-speech.bytetos.com/obj/speech-tts-external/portal/Portal_Demo_BV056.mp3', NULL, 4, NULL, NULL, NULL, NULL); +INSERT INTO `ai_tts_voice` VALUES ('TTS_DoubaoTTS0004', 'TTS_DoubaoTTS', '奶气萌娃', 'BV051_streaming', '普通话', 'https://lf3-speech.bytetos.com/obj/speech-tts-external/portal/Portal_Demo_BV051.mp3', NULL, 5, NULL, NULL, NULL, NULL); +INSERT INTO `ai_tts_voice` VALUES ('TTS_DoubaoTTS0005', 'TTS_DoubaoTTS', '湾湾小何', 'zh_female_wanwanxiaohe_moon_bigtts', '普通话', 'https://lf3-static.bytednsdoc.com/obj/eden-cn/lm_hz_ihsph/ljhwZthlaukjlkulzlp/portal/bigtts/%E6%B9%BE%E6%B9%BE%E5%B0%8F%E4%BD%95.mp3', NULL, 6, NULL, NULL, NULL, NULL); + +-- 修正CosyVoiceSiliconflow音色 +delete from `ai_tts_voice` where id in ('TTS_CosyVoiceSiliconflow0001', 'TTS_CosyVoiceSiliconflow0002'); +INSERT INTO `ai_tts_voice` VALUES ('TTS_CosyVoiceSiliconflow0001', 'TTS_CosyVoiceSiliconflow', 'CosyVoice男声', 'FunAudioLLM/CosyVoice2-0.5B:alex', '中文', NULL, NULL, 6, NULL, NULL, NULL, NULL); +INSERT INTO `ai_tts_voice` VALUES ('TTS_CosyVoiceSiliconflow0002', 'TTS_CosyVoiceSiliconflow', 'CosyVoice女声', 'FunAudioLLM/CosyVoice2-0.5B:bella', '中文', NULL, NULL, 6, NULL, NULL, NULL, NULL); + +-- CozeCnTTS音色 +delete from `ai_tts_voice` where id = 'TTS_CozeCnTTS0001'; +INSERT INTO `ai_tts_voice` VALUES ('TTS_CozeCnTTS0001', 'TTS_CozeCnTTS', 'CozeCn音色', '7426720361733046281', '中文', NULL, NULL, 7, NULL, NULL, NULL, NULL); + +-- MinimaxTTS音色 +delete from `ai_tts_voice` where id = 'TTS_MinimaxTTS0001'; +INSERT INTO `ai_tts_voice` VALUES ('TTS_MinimaxTTS0001', 'TTS_MinimaxTTS', 'Minimax少女音', 'female-shaonv', '中文', NULL, NULL, 8, NULL, NULL, NULL, NULL); + +-- AliyunTTS音色 +delete from `ai_tts_voice` where id = 'TTS_AliyunTTS0001'; +INSERT INTO `ai_tts_voice` VALUES ('TTS_AliyunTTS0001', 'TTS_AliyunTTS', '阿里云小云', 'xiaoyun', '中文', NULL, NULL, 9, NULL, NULL, NULL, NULL); + +-- TTS302AI音色 +delete from `ai_tts_voice` where id = 'TTS_TTS302AI0001'; +INSERT INTO `ai_tts_voice` VALUES ('TTS_TTS302AI0001', 'TTS_TTS302AI', '湾湾小何', 'zh_female_wanwanxiaohe_moon_bigtts', '中文', 'https://lf3-static.bytednsdoc.com/obj/eden-cn/lm_hz_ihsph/ljhwZthlaukjlkulzlp/portal/bigtts/%E6%B9%BE%E6%B9%BE%E5%B0%8F%E4%BD%95.mp3', NULL, 10, NULL, NULL, NULL, NULL); + +-- GizwitsTTS音色 +delete from `ai_tts_voice` where id = 'TTS_GizwitsTTS0001'; +INSERT INTO `ai_tts_voice` VALUES ('TTS_GizwitsTTS0001', 'TTS_GizwitsTTS', '机智云湾湾', 'zh_female_wanwanxiaohe_moon_bigtts', '中文', 'https://lf3-static.bytednsdoc.com/obj/eden-cn/lm_hz_ihsph/ljhwZthlaukjlkulzlp/portal/bigtts/%E6%B9%BE%E6%B9%BE%E5%B0%8F%E4%BD%95.mp3', NULL, 11, NULL, NULL, NULL, NULL); + +-- ACGNTTS音色 +delete from `ai_tts_voice` where id = 'TTS_ACGNTTS0001'; +INSERT INTO `ai_tts_voice` VALUES ('TTS_ACGNTTS0001', 'TTS_ACGNTTS', 'ACG音色', '1695', '中文', NULL, NULL, 12, NULL, NULL, NULL, NULL); + +-- OpenAITTS音色 +delete from `ai_tts_voice` where id = 'TTS_OpenAITTS0001'; +INSERT INTO `ai_tts_voice` VALUES ('TTS_OpenAITTS0001', 'TTS_OpenAITTS', 'OpenAI男声', 'onyx', '中文', NULL, NULL, 13, NULL, NULL, NULL, NULL); + +-- 添加腾讯语音合成音色 +delete from `ai_tts_voice` where id = 'TTS_TencentTTS0001'; +INSERT INTO `ai_tts_voice` VALUES ('TTS_TencentTTS0001', 'TTS_TencentTTS', '智瑜', '101001', '中文', NULL, NULL, 1, NULL, NULL, NULL, NULL); + +-- 其他音色 +delete from `ai_tts_voice` where id = 'TTS_FishSpeech0000'; +INSERT INTO `ai_tts_voice` VALUES ('TTS_FishSpeech0000', 'TTS_FishSpeech', '', '', '中文', '', NULL, 8, NULL, NULL, NULL, NULL); + +delete from `ai_tts_voice` where id = 'TTS_GPT_SOVITS_V20000'; +INSERT INTO `ai_tts_voice` VALUES ('TTS_GPT_SOVITS_V20000', 'TTS_GPT_SOVITS_V2', '', '', '中文', '', NULL, 8, NULL, NULL, NULL, NULL); + +delete from `ai_tts_voice` where id in ('TTS_GPT_SOVITS_V30000', 'TTS_CustomTTS0000'); +INSERT INTO `ai_tts_voice` VALUES ('TTS_GPT_SOVITS_V30000', 'TTS_GPT_SOVITS_V3', '', '', '中文', '', NULL, 8, NULL, NULL, NULL, NULL); +INSERT INTO `ai_tts_voice` VALUES ('TTS_CustomTTS0000', 'TTS_CustomTTS', '', '', '中文', '', NULL, 8, NULL, NULL, NULL, NULL); + diff --git a/main/manager-api/src/main/resources/db/changelog/202504221646.sql b/main/manager-api/src/main/resources/db/changelog/202504221646.sql new file mode 100644 index 00000000..5905f672 --- /dev/null +++ b/main/manager-api/src/main/resources/db/changelog/202504221646.sql @@ -0,0 +1,6 @@ +-- 删除server.ip和server.port，改成在xiaozhi-server中配置，方便运行多个websocket +delete from `sys_params` where id = 100; +delete from `sys_params` where id = 101; + +INSERT INTO `sys_params` (id, param_code, param_value, value_type, param_type, remark) VALUES (106, 'server.websocket', 'null', 'string', 1, 'websocket地址，多个用;分隔'); + diff --git a/main/manager-api/src/main/resources/db/changelog/2025_tts_voive.sql b/main/manager-api/src/main/resources/db/changelog/2025_tts_voive.sql deleted file mode 100644 index bea47d7a..00000000 --- a/main/manager-api/src/main/resources/db/changelog/2025_tts_voive.sql +++ /dev/null @@ -1,44 +0,0 @@ --- 本文件用于初始化音色数据，无需手动执行，在项目启动时会自动执行 --- ---------------------------------------------------- - --- 初始化音色数据 -DELETE FROM `ai_tts_voice`; - --- EdgeTTS音色 -INSERT INTO `ai_tts_voice` VALUES ('TTS_EdgeTTS0001', 'TTS_EdgeTTS', 'EdgeTTS女声', 'zh-CN-XiaoxiaoNeural', '中文', 'https://lf3-static.bytednsdoc.com/obj/eden-cn/lm_hz_ihsph/ljhwZthlaukjlkulzlp/portal/bigtts/EdgeTTS.mp3', NULL, 1, NULL, NULL, NULL, NULL); - --- DoubaoTTS音色 -INSERT INTO `ai_tts_voice` VALUES ('TTS_DoubaoTTS0001', 'TTS_DoubaoTTS', '通用女声', 'BV001_streaming', '中文', 'https://lf3-speech.bytetos.com/obj/speech-tts-external/portal/Portal_Demo_BV001.mp3', NULL, 3, NULL, NULL, NULL, NULL); -INSERT INTO `ai_tts_voice` VALUES ('TTS_DoubaoTTS0002', 'TTS_DoubaoTTS', '通用男声', 'BV002_streaming', '中文', 'https://lf3-speech.bytetos.com/obj/speech-tts-external/portal/Portal_Demo_BV002.mp3', NULL, 2, NULL, NULL, NULL, NULL); -INSERT INTO `ai_tts_voice` VALUES ('TTS_DoubaoTTS0003', 'TTS_DoubaoTTS', '阳光男生', 'BV056_streaming', '中文', 'https://lf3-speech.bytetos.com/obj/speech-tts-external/portal/Portal_Demo_BV056.mp3', NULL, 4, NULL, NULL, NULL, NULL); -INSERT INTO `ai_tts_voice` VALUES ('TTS_DoubaoTTS0004', 'TTS_DoubaoTTS', '奶气萌娃', 'BV051_streaming', '中文', 'https://lf3-speech.bytetos.com/obj/speech-tts-external/portal/Portal_Demo_BV051.mp3', NULL, 5, NULL, NULL, NULL, NULL); - --- CosyVoiceSiliconflow音色 -INSERT INTO `ai_tts_voice` VALUES ('TTS_CosyVoiceSiliconflow0001', 'TTS_CosyVoiceSiliconflow', 'CosyVoice男声', 'alex', '中文', 'https://example.com/cosyvoice/alex.mp3', NULL, 6, NULL, NULL, NULL, NULL); - --- CozeCnTTS音色 -INSERT INTO `ai_tts_voice` VALUES ('TTS_CozeCnTTS0001', 'TTS_CozeCnTTS', 'CozeCn音色', '7426720361733046281', '中文', 'https://example.com/cozecn/voice.mp3', NULL, 7, NULL, NULL, NULL, NULL); - --- MinimaxTTS音色 -INSERT INTO `ai_tts_voice` VALUES ('TTS_MinimaxTTS0001', 'TTS_MinimaxTTS', 'Minimax少女音', 'female-shaonv', '中文', 'https://example.com/minimax/female-shaonv.mp3', NULL, 8, NULL, NULL, NULL, NULL); - --- AliyunTTS音色 -INSERT INTO `ai_tts_voice` VALUES ('TTS_AliyunTTS0001', 'TTS_AliyunTTS', '阿里云小云', 'xiaoyun', '中文', 'https://example.com/aliyun/xiaoyun.mp3', NULL, 9, NULL, NULL, NULL, NULL); - --- TTS302AI音色 -INSERT INTO `ai_tts_voice` VALUES ('TTS_TTS302AI0001', 'TTS_TTS302AI', '湾湾小何', 'zh_female_wanwanxiaohe_moon_bigtts', '中文', 'https://example.com/302ai/wanwanxiaohe.mp3', NULL, 10, NULL, NULL, NULL, NULL); - --- GizwitsTTS音色 -INSERT INTO `ai_tts_voice` VALUES ('TTS_GizwitsTTS0001', 'TTS_GizwitsTTS', '机智云湾湾', 'zh_female_wanwanxiaohe_moon_bigtts', '中文', 'https://example.com/gizwits/wanwanxiaohe.mp3', NULL, 11, NULL, NULL, NULL, NULL); - --- ACGNTTS音色 -INSERT INTO `ai_tts_voice` VALUES ('TTS_ACGNTTS0001', 'TTS_ACGNTTS', 'ACG音色', '1695', '中文', 'https://example.com/acgn/voice.mp3', NULL, 12, NULL, NULL, NULL, NULL); - --- OpenAITTS音色 -INSERT INTO `ai_tts_voice` VALUES ('TTS_OpenAITTS0001', 'TTS_OpenAITTS', 'OpenAI男声', 'onyx', '中文', 'https://example.com/openai/onyx.mp3', NULL, 13, NULL, NULL, NULL, NULL); - --- 其他音色 -INSERT INTO `ai_tts_voice` VALUES ('TTS_FishSpeech0000', 'TTS_FishSpeech', '', '', '中文', '', NULL, 8, NULL, NULL, NULL, NULL); -INSERT INTO `ai_tts_voice` VALUES ('TTS_GPT_SOVITS_V20000', 'TTS_GPT_SOVITS_V2', '', '', '中文', '', NULL, 8, NULL, NULL, NULL, NULL); -INSERT INTO `ai_tts_voice` VALUES ('TTS_GPT_SOVITS_V30000', 'TTS_GPT_SOVITS_V3', '', '', '中文', '', NULL, 8, NULL, NULL, NULL, NULL); -INSERT INTO `ai_tts_voice` VALUES ('TTS_CustomTTS0000', 'TTS_CustomTTS', '', '', '中文', '', NULL, 8, NULL, NULL, NULL, NULL); \ No newline at end of file diff --git a/main/manager-api/src/main/resources/db/changelog/db.changelog-master.yaml b/main/manager-api/src/main/resources/db/changelog/db.changelog-master.yaml index 60fd0280..7186e013 100755 --- a/main/manager-api/src/main/resources/db/changelog/db.changelog-master.yaml +++ b/main/manager-api/src/main/resources/db/changelog/db.changelog-master.yaml @@ -16,13 +16,6 @@ databaseChangeLog: - sqlFile: encoding: utf8 path: classpath:db/changelog/202503141346.sql - - changeSet: - id: 2025_tts_voive - author: John - changes: - - sqlFile: - encoding: utf8 - path: classpath:db/changelog/2025_tts_voive.sql - changeSet: id: 202504082211 author: John @@ -66,16 +59,30 @@ databaseChangeLog: encoding: utf8 path: classpath:db/changelog/202504181536.sql - changeSet: - id: 202504211118 + id: 202504180758 + author: jiangkunyin + changes: + - sqlFile: + encoding: utf8 + path: classpath:db/changelog/202504180758.sql + - changeSet: + id: 202504221135 author: John changes: - sqlFile: encoding: utf8 - path: classpath:db/changelog/202504211118.sql + path: classpath:db/changelog/202504221135.sql + - changeSet: + id: 202504221646 + author: John + changes: + - sqlFile: + encoding: utf8 + path: classpath:db/changelog/202504221646.sql - changeSet: id: 202504221555 author: John changes: - sqlFile: encoding: utf8 - path: classpath:db/changelog/202504221555.sql \ No newline at end of file + path: classpath:db/changelog/202504221555.sql diff --git a/main/manager-api/src/main/resources/i18n/validation.properties b/main/manager-api/src/main/resources/i18n/validation.properties index 652ae269..3a10bf23 100644 --- a/main/manager-api/src/main/resources/i18n/validation.properties +++ b/main/manager-api/src/main/resources/i18n/validation.properties @@ -28,10 +28,8 @@ sysuser.uuid.require=\u552F\u4E00\u6807\u8BC6\u4E0D\u80FD\u4E3A\u7A7A timbre.languages.require=\u97F3\u8272\u7684\u8BED\u8A00\u4E0D\u53EF\u4EE5\u4E3A\u7A7A timbre.name.require=\u97F3\u8272\u7684\u540D\u79F0\u4E0D\u53EF\u4EE5\u4E3A\u7A7A -timbre.remark.require=\u97F3\u8272\u7684\u5907\u6CE8\u4E0D\u53EF\u4EE5\u4E3A\u7A7A timbre.ttsModelId.require=\u97F3\u8272\u7684tts\u4E3B\u952E\u4E0D\u53EF\u4EE5\u4E3A\u7A7A timbre.ttsVoice.require=\u97F3\u8272\u7684\u7F16\u7801\u4E0D\u53EF\u4EE5\u4E3A\u7A7A -timbre.voiceDemo.require=\u97F3\u8272\u7684\u64AD\u653EDemo\u4E0D\u53EF\u4EE5\u4E3A\u7A7A ota.device.not.found=\u8BBE\u5907\u672A\u627E\u5230 ota.device.need.bind={0} diff --git a/main/manager-api/src/main/resources/i18n/validation_en_US.properties b/main/manager-api/src/main/resources/i18n/validation_en_US.properties index fb6f3828..342cada3 100644 --- a/main/manager-api/src/main/resources/i18n/validation_en_US.properties +++ b/main/manager-api/src/main/resources/i18n/validation_en_US.properties @@ -27,10 +27,8 @@ sysuser.uuid.require=The unique identifier cannot be empty timbre.languages.require=The language of the timbre cannot be empty timbre.name.require=The name of the timbre cannot be empty -timbre.remark.require=The remark of the timbre cannot be empty timbre.ttsModelId.require=The TTS model ID of the timbre cannot be empty timbre.ttsVoice.require=The TTS voice of the timbre cannot be empty -timbre.voiceDemo.require=The voice demo of the timbre cannot be empty ota.device.not.found=Device not found ota.device.need.bind={0} \ No newline at end of file diff --git a/main/manager-api/src/main/resources/i18n/validation_zh_CN.properties b/main/manager-api/src/main/resources/i18n/validation_zh_CN.properties index 1ff8a3ba..eaa50eb7 100644 --- a/main/manager-api/src/main/resources/i18n/validation_zh_CN.properties +++ b/main/manager-api/src/main/resources/i18n/validation_zh_CN.properties @@ -27,10 +27,8 @@ sysuser.uuid.require=\u552F\u4E00\u6807\u8BC6\u4E0D\u80FD\u4E3A\u7A7A timbre.languages.require=\u97F3\u8272\u7684\u8A9E\u8A00\u4E0D\u53EF\u4EE5\u70BA\u7A7A timbre.name.require=\u97F3\u8272\u7684\u540D\u7A31\u4E0D\u53EF\u4EE5\u70BA\u7A7A -timbre.remark.require=\u97F3\u8272\u7684\u5099\u6CE8\u4E0D\u53EF\u4EE5\u70BA\u7A7A timbre.ttsModelId.require=\u97F3\u8272\u7684tts\u4E3B\u9375\u4E0D\u53EF\u4EE5\u70BA\u7A7A timbre.ttsVoice.require=\u97F3\u8272\u7684\u7DE8\u78BC\u4E0D\u53EF\u4EE5\u70BA\u7A7A -timbre.voiceDemo.require=\u97F3\u8272\u7684\u64AD\u653E\u5730\u5740\u4E0D\u53EF\u4EE5\u70BA\u7A7A ota.device.not.found=\u8A2D\u5099\u672A\u627E\u5230 ota.device.need.bind={0} \ No newline at end of file diff --git a/main/manager-api/src/main/resources/i18n/validation_zh_TW.properties b/main/manager-api/src/main/resources/i18n/validation_zh_TW.properties index dd6eab90..4e3a271a 100644 --- a/main/manager-api/src/main/resources/i18n/validation_zh_TW.properties +++ b/main/manager-api/src/main/resources/i18n/validation_zh_TW.properties @@ -27,10 +27,8 @@ sysuser.uuid.require=\u552F\u4E00\u6807\u8BC6\u4E0D\u80FD\u4E3A\u7A7A timbre.languages.require=\u97F3\u8272\u7684\u8BED\u8A00\u4E0D\u53EF\u4EE5\u4E3A\u7A7A timbre.name.require=\u97F3\u8272\u7684\u540D\u79F0\u4E0D\u53EF\u4EE5\u4E3A\u7A7A -timbre.remark.require=\u97F3\u8272\u7684\u5907\u6CE8\u4E0D\u53EF\u4EE5\u4E3A\u7A7A timbre.ttsModelId.require=\u97F3\u8272\u7684tts\u4E3B\u952E\u4E0D\u53EF\u4EE5\u4E3A\u7A7A timbre.ttsVoice.require=\u97F3\u8272\u7684\u7F16\u7801\u4E0D\u53EF\u4EE5\u4E3A\u7A7A -timbre.voiceDemo.require=\u97F3\u8272\u7684\u64AD\u653EDemo\u4E0D\u53EF\u4EE5\u4E3A\u7A7A ota.device.not.found=\u8A2D\u5099\u672A\u627E\u5230 ota.device.need.bind={0} \ No newline at end of file diff --git a/main/manager-web/.env.production b/main/manager-web/.env.production index d61ca06f..351d791a 100644 --- a/main/manager-web/.env.production +++ b/main/manager-web/.env.production @@ -1,3 +1,4 @@ VUE_APP_API_BASE_URL=/xiaozhi +VUE_APP_PUBLIC_PATH=/ # 是否开启CDN VUE_APP_USE_CDN=false \ No newline at end of file diff --git a/main/manager-web/package.json b/main/manager-web/package.json index a308147b..55e275d9 100644 --- a/main/manager-web/package.json +++ b/main/manager-web/package.json @@ -10,6 +10,7 @@ "dependencies": { "core-js": "^3.41.0", "cross-env": "^7.0.3", + "dotenv": "^16.5.0", "element-ui": "^2.15.14", "flyio": "^0.6.14", "normalize.css": "^8.0.1", diff --git a/main/manager-web/public/encoderWorker.min.js b/main/manager-web/public/encoderWorker.min.js deleted file mode 100644 index e53ae167..00000000 --- a/main/manager-web/public/encoderWorker.min.js +++ /dev/null @@ -1 +0,0 @@ -var Module=typeof Module!=="undefined"?Module:{};var moduleOverrides={};var key;for(key in Module){if(Module.hasOwnProperty(key)){moduleOverrides[key]=Module[key]}}var arguments_=[];var thisProgram="./this.program";var quit_=function(status,toThrow){throw toThrow};var ENVIRONMENT_IS_WEB=typeof window==="object";var ENVIRONMENT_IS_WORKER=typeof importScripts==="function";var ENVIRONMENT_IS_NODE=typeof process==="object"&&typeof process.versions==="object"&&typeof process.versions.node==="string";var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}var read_,readAsync,readBinary,setWindowTitle;function logExceptionOnExit(e){if(e instanceof ExitStatus)return;var toLog=e;err("exiting due to exception: "+toLog)}var nodeFS;var nodePath;if(ENVIRONMENT_IS_NODE){if(ENVIRONMENT_IS_WORKER){scriptDirectory=require("path").dirname(scriptDirectory)+"/"}else{scriptDirectory=__dirname+"/"}read_=function shell_read(filename,binary){var ret=tryParseAsDataURI(filename);if(ret){return binary?ret:ret.toString()}if(!nodeFS)nodeFS=require("fs");if(!nodePath)nodePath=require("path");filename=nodePath["normalize"](filename);return nodeFS["readFileSync"](filename,binary?null:"utf8")};readBinary=function readBinary(filename){var ret=read_(filename,true);if(!ret.buffer){ret=new Uint8Array(ret)}assert(ret.buffer);return ret};readAsync=function readAsync(filename,onload,onerror){var ret=tryParseAsDataURI(filename);if(ret){onload(ret)}if(!nodeFS)nodeFS=require("fs");if(!nodePath)nodePath=require("path");filename=nodePath["normalize"](filename);nodeFS["readFile"](filename,function(err,data){if(err)onerror(err);else onload(data.buffer)})};if(process["argv"].length>1){thisProgram=process["argv"][1].replace(/\\/g,"/")}arguments_=process["argv"].slice(2);if(typeof module!=="undefined"){module["exports"]=Module}process["on"]("uncaughtException",function(ex){if(!(ex instanceof ExitStatus)){throw ex}});process["on"]("unhandledRejection",function(reason){throw reason});quit_=function(status,toThrow){if(keepRuntimeAlive()){process["exitCode"]=status;throw toThrow}logExceptionOnExit(toThrow);process["exit"](status)};Module["inspect"]=function(){return"[Emscripten Module object]"}}else if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){if(ENVIRONMENT_IS_WORKER){scriptDirectory=self.location.href}else if(typeof document!=="undefined"&&document.currentScript){scriptDirectory=document.currentScript.src}if(scriptDirectory.indexOf("blob:")!==0){scriptDirectory=scriptDirectory.substr(0,scriptDirectory.replace(/[?#].*/,"").lastIndexOf("/")+1)}else{scriptDirectory=""}{read_=function(url){try{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.send(null);return xhr.responseText}catch(err){var data=tryParseAsDataURI(url);if(data){return intArrayToString(data)}throw err}};if(ENVIRONMENT_IS_WORKER){readBinary=function(url){try{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.responseType="arraybuffer";xhr.send(null);return new Uint8Array(xhr.response)}catch(err){var data=tryParseAsDataURI(url);if(data){return data}throw err}}}readAsync=function(url,onload,onerror){var xhr=new XMLHttpRequest;xhr.open("GET",url,true);xhr.responseType="arraybuffer";xhr.onload=function(){if(xhr.status==200||xhr.status==0&&xhr.response){onload(xhr.response);return}var data=tryParseAsDataURI(url);if(data){onload(data.buffer);return}onerror()};xhr.onerror=onerror;xhr.send(null)}}setWindowTitle=function(title){document.title=title}}else{}var out=Module["print"]||console.log.bind(console);var err=Module["printErr"]||console.warn.bind(console);for(key in moduleOverrides){if(moduleOverrides.hasOwnProperty(key)){Module[key]=moduleOverrides[key]}}moduleOverrides=null;if(Module["arguments"])arguments_=Module["arguments"];if(Module["thisProgram"])thisProgram=Module["thisProgram"];if(Module["quit"])quit_=Module["quit"];var wasmBinary;if(Module["wasmBinary"])wasmBinary=Module["wasmBinary"];var noExitRuntime=Module["noExitRuntime"]||true;if(typeof WebAssembly!=="object"){abort("no native wasm support detected")}var wasmMemory;var ABORT=false;var EXITSTATUS;function assert(condition,text){if(!condition){abort("Assertion failed: "+text)}}var UTF8Decoder=typeof TextDecoder!=="undefined"?new TextDecoder("utf8"):undefined;function UTF8ArrayToString(heap,idx,maxBytesToRead){var endIdx=idx+maxBytesToRead;var endPtr=idx;while(heap[endPtr]&&!(endPtr>=endIdx))++endPtr;if(endPtr-idx>16&&heap.subarray&&UTF8Decoder){return UTF8Decoder.decode(heap.subarray(idx,endPtr))}else{var str="";while(idx>10,56320|ch&1023)}}}return str}function UTF8ToString(ptr,maxBytesToRead){return ptr?UTF8ArrayToString(HEAPU8,ptr,maxBytesToRead):""}var buffer,HEAP8,HEAPU8,HEAP16,HEAPU16,HEAP32,HEAPU32,HEAPF32,HEAPF64;function updateGlobalBufferAndViews(buf){buffer=buf;Module["HEAP8"]=HEAP8=new Int8Array(buf);Module["HEAP16"]=HEAP16=new Int16Array(buf);Module["HEAP32"]=HEAP32=new Int32Array(buf);Module["HEAPU8"]=HEAPU8=new Uint8Array(buf);Module["HEAPU16"]=HEAPU16=new Uint16Array(buf);Module["HEAPU32"]=HEAPU32=new Uint32Array(buf);Module["HEAPF32"]=HEAPF32=new Float32Array(buf);Module["HEAPF64"]=HEAPF64=new Float64Array(buf)}var INITIAL_MEMORY=Module["INITIAL_MEMORY"]||16777216;var wasmTable;var __ATPRERUN__=[];var __ATINIT__=[];var __ATPOSTRUN__=[];var runtimeInitialized=false;var runtimeKeepaliveCounter=0;function keepRuntimeAlive(){return noExitRuntime||runtimeKeepaliveCounter>0}function preRun(){if(Module["preRun"]){if(typeof Module["preRun"]=="function")Module["preRun"]=[Module["preRun"]];while(Module["preRun"].length){addOnPreRun(Module["preRun"].shift())}}callRuntimeCallbacks(__ATPRERUN__)}function initRuntime(){runtimeInitialized=true;callRuntimeCallbacks(__ATINIT__)}function postRun(){if(Module["postRun"]){if(typeof Module["postRun"]=="function")Module["postRun"]=[Module["postRun"]];while(Module["postRun"].length){addOnPostRun(Module["postRun"].shift())}}callRuntimeCallbacks(__ATPOSTRUN__)}function addOnPreRun(cb){__ATPRERUN__.unshift(cb)}function addOnInit(cb){__ATINIT__.unshift(cb)}function addOnPostRun(cb){__ATPOSTRUN__.unshift(cb)}var runDependencies=0;var runDependencyWatcher=null;var dependenciesFulfilled=null;function addRunDependency(id){runDependencies++;if(Module["monitorRunDependencies"]){Module["monitorRunDependencies"](runDependencies)}}function removeRunDependency(id){runDependencies--;if(Module["monitorRunDependencies"]){Module["monitorRunDependencies"](runDependencies)}if(runDependencies==0){if(runDependencyWatcher!==null){clearInterval(runDependencyWatcher);runDependencyWatcher=null}if(dependenciesFulfilled){var callback=dependenciesFulfilled;dependenciesFulfilled=null;callback()}}}Module["preloadedImages"]={};Module["preloadedAudios"]={};function abort(what){{if(Module["onAbort"]){Module["onAbort"](what)}}what="Aborted("+what+")";err(what);ABORT=true;EXITSTATUS=1;what+=". Build with -s ASSERTIONS=1 for more info.";var e=new WebAssembly.RuntimeError(what);throw e}var dataURIPrefix="data:application/octet-stream;base64,";function isDataURI(filename){return filename.startsWith(dataURIPrefix)}var wasmBinaryFile;wasmBinaryFile="data:application/octet-stream;base64,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";if(!isDataURI(wasmBinaryFile)){wasmBinaryFile=locateFile(wasmBinaryFile)}function getBinary(file){try{if(file==wasmBinaryFile&&wasmBinary){return new Uint8Array(wasmBinary)}var binary=tryParseAsDataURI(file);if(binary){return binary}if(readBinary){return readBinary(file)}else{throw"sync fetching of the wasm failed: you can preload it to Module['wasmBinary'] manually, or emcc.py will do that for you when generating HTML (but not JS)"}}catch(err){abort(err)}}function instantiateSync(file,info){var instance;var module;var binary;try{binary=getBinary(file);module=new WebAssembly.Module(binary);instance=new WebAssembly.Instance(module,info)}catch(e){var str=e.toString();err("failed to compile wasm module: "+str);if(str.includes("imported Memory")||str.includes("memory import")){err("Memory size incompatibility issues may be due to changing INITIAL_MEMORY at runtime to something too large. Use ALLOW_MEMORY_GROWTH to allow any size memory (and also make sure not to set INITIAL_MEMORY at runtime to something smaller than it was at compile time).")}throw e}return[instance,module]}function createWasm(){var info={"a":asmLibraryArg};function receiveInstance(instance,module){var exports=instance.exports;Module["asm"]=exports;wasmMemory=Module["asm"]["g"];updateGlobalBufferAndViews(wasmMemory.buffer);wasmTable=Module["asm"]["r"];addOnInit(Module["asm"]["h"]);removeRunDependency("wasm-instantiate")}addRunDependency("wasm-instantiate");if(Module["instantiateWasm"]){try{var exports=Module["instantiateWasm"](info,receiveInstance);return exports}catch(e){err("Module.instantiateWasm callback failed with error: "+e);return false}}var result=instantiateSync(wasmBinaryFile,info);receiveInstance(result[0]);return Module["asm"]}function callRuntimeCallbacks(callbacks){while(callbacks.length>0){var callback=callbacks.shift();if(typeof callback=="function"){callback(Module);continue}var func=callback.func;if(typeof func==="number"){if(callback.arg===undefined){wasmTable.get(func)()}else{wasmTable.get(func)(callback.arg)}}else{func(callback.arg===undefined?null:callback.arg)}}}function _abort(){abort("")}function _emscripten_memcpy_big(dest,src,num){HEAPU8.copyWithin(dest,src,src+num)}function abortOnCannotGrowMemory(requestedSize){abort("OOM")}function _emscripten_resize_heap(requestedSize){var oldSize=HEAPU8.length;requestedSize=requestedSize>>>0;abortOnCannotGrowMemory(requestedSize)}var SYSCALLS={mappings:{},buffers:[null,[],[]],printChar:function(stream,curr){var buffer=SYSCALLS.buffers[stream];if(curr===0||curr===10){(stream===1?out:err)(UTF8ArrayToString(buffer,0));buffer.length=0}else{buffer.push(curr)}},varargs:undefined,get:function(){SYSCALLS.varargs+=4;var ret=HEAP32[SYSCALLS.varargs-4>>2];return ret},getStr:function(ptr){var ret=UTF8ToString(ptr);return ret},get64:function(low,high){return low}};function _fd_close(fd){return 0}function _fd_seek(fd,offset_low,offset_high,whence,newOffset){}function _fd_write(fd,iov,iovcnt,pnum){var num=0;for(var i=0;i>2];var len=HEAP32[iov+(i*8+4)>>2];for(var j=0;j>2]=num;return 0}var ASSERTIONS=false;function intArrayToString(array){var ret=[];for(var i=0;i255){if(ASSERTIONS){assert(false,"Character code "+chr+" ("+String.fromCharCode(chr)+") at offset "+i+" not in 0x00-0xFF.")}chr&=255}ret.push(String.fromCharCode(chr))}return ret.join("")}var decodeBase64=typeof atob==="function"?atob:function(input){var keyStr="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";var output="";var chr1,chr2,chr3;var enc1,enc2,enc3,enc4;var i=0;input=input.replace(/[^A-Za-z0-9\+\/\=]/g,"");do{enc1=keyStr.indexOf(input.charAt(i++));enc2=keyStr.indexOf(input.charAt(i++));enc3=keyStr.indexOf(input.charAt(i++));enc4=keyStr.indexOf(input.charAt(i++));chr1=enc1<<2|enc2>>4;chr2=(enc2&15)<<4|enc3>>2;chr3=(enc3&3)<<6|enc4;output=output+String.fromCharCode(chr1);if(enc3!==64){output=output+String.fromCharCode(chr2)}if(enc4!==64){output=output+String.fromCharCode(chr3)}}while(i0){return}preRun();if(runDependencies>0){return}function doRun(){if(calledRun)return;calledRun=true;Module["calledRun"]=true;if(ABORT)return;initRuntime();if(Module["onRuntimeInitialized"])Module["onRuntimeInitialized"]();postRun()}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(function(){setTimeout(function(){Module["setStatus"]("")},1);doRun()},1)}else{doRun()}}Module["run"]=run;if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].pop()()}}run();null;const OggOpusEncoder=function(config,Module){if(!Module){throw new Error("Module with exports required to initialize an encoder instance")}this.config=Object.assign({encoderApplication:2049,encoderFrameSize:20,encoderSampleRate:48e3,maxFramesPerPage:40,numberOfChannels:1,originalSampleRate:44100,resampleQuality:3,serial:Math.floor(Math.random()*4294967296)},config);this._opus_encoder_create=Module._opus_encoder_create;this._opus_encoder_destroy=Module._opus_encoder_destroy;this._opus_encoder_ctl=Module._opus_encoder_ctl;this._speex_resampler_process_interleaved_float=Module._speex_resampler_process_interleaved_float;this._speex_resampler_init=Module._speex_resampler_init;this._speex_resampler_destroy=Module._speex_resampler_destroy;this._opus_encode_float=Module._opus_encode_float;this._free=Module._free;this._malloc=Module._malloc;this.HEAPU8=Module.HEAPU8;this.HEAP32=Module.HEAP32;this.HEAPF32=Module.HEAPF32;this.pageIndex=0;this.granulePosition=0;this.segmentData=new Uint8Array(65025);this.segmentDataIndex=0;this.segmentTable=new Uint8Array(255);this.segmentTableIndex=0;this.framesInPage=0;this.initChecksumTable();this.initCodec();this.initResampler();if(this.config.numberOfChannels===1){this.interleave=function(buffers){return buffers[0]}}};OggOpusEncoder.prototype.encode=function(buffers){if(!this.bufferLength){this.bufferLength=buffers[0].length;this.interleavedBuffers=new Float32Array(this.bufferLength*this.config.numberOfChannels)}var samples=this.interleave(buffers);var sampleIndex=0;var exportPages=[];while(sampleIndex=this.config.maxFramesPerPage){exportPages.push(this.generatePage())}}}return exportPages};OggOpusEncoder.prototype.destroy=function(){if(this.encoder){this._free(this.encoderSamplesPerChannelPointer);delete this.encoderSamplesPerChannelPointer;this._free(this.encoderBufferPointer);delete this.encoderBufferPointer;this._free(this.encoderOutputPointer);delete this.encoderOutputPointer;this._free(this.resampleSamplesPerChannelPointer);delete this.resampleSamplesPerChannelPointer;this._free(this.resampleBufferPointer);delete this.resampleBufferPointer;this._speex_resampler_destroy(this.resampler);delete this.resampler;this._opus_encoder_destroy(this.encoder);delete this.encoder}};OggOpusEncoder.prototype.flush=function(){var exportPage;if(this.framesInPage){exportPage=this.generatePage()}this.resampleBufferIndex=0;return exportPage};OggOpusEncoder.prototype.encodeFinalFrame=function(){var exportPages=[];if(this.resampleBufferIndex>0){const dataToFill=(this.resampleBufferLength-this.resampleBufferIndex)/this.config.numberOfChannels;const numBuffers=Math.ceil(dataToFill/this.bufferLength);for(var i=0;i>>24&255^data[i]]}return checksum>>>0};OggOpusEncoder.prototype.generateCommentPage=function(){var segmentDataView=new DataView(this.segmentData.buffer);segmentDataView.setUint32(0,1937076303,true);segmentDataView.setUint32(4,1936154964,true);segmentDataView.setUint32(8,10,true);segmentDataView.setUint32(12,1868784978,true);segmentDataView.setUint32(16,1919247474,true);segmentDataView.setUint16(20,21322,true);segmentDataView.setUint32(22,0,true);this.segmentTableIndex=1;this.segmentDataIndex=this.segmentTable[0]=26;this.headerType=0;return this.generatePage()};OggOpusEncoder.prototype.generateIdPage=function(){var segmentDataView=new DataView(this.segmentData.buffer);segmentDataView.setUint32(0,1937076303,true);segmentDataView.setUint32(4,1684104520,true);segmentDataView.setUint8(8,1,true);segmentDataView.setUint8(9,this.config.numberOfChannels,true);segmentDataView.setUint16(10,3840,true);segmentDataView.setUint32(12,this.config.originalSampleRateOverride||this.config.originalSampleRate,true);segmentDataView.setUint16(16,0,true);segmentDataView.setUint8(18,0,true);this.segmentTableIndex=1;this.segmentDataIndex=this.segmentTable[0]=19;this.headerType=2;return this.generatePage()};OggOpusEncoder.prototype.generatePage=function(){var granulePosition=this.lastPositiveGranulePosition===this.granulePosition?-1:this.granulePosition;var pageBuffer=new ArrayBuffer(27+this.segmentTableIndex+this.segmentDataIndex);var pageBufferView=new DataView(pageBuffer);var page=new Uint8Array(pageBuffer);pageBufferView.setUint32(0,1399285583,true);pageBufferView.setUint8(4,0,true);pageBufferView.setUint8(5,this.headerType,true);pageBufferView.setUint32(6,granulePosition,true);if(granulePosition<0){pageBufferView.setInt32(10,Math.ceil(granulePosition/4294967297)-1,true)}else{pageBufferView.setInt32(10,Math.floor(granulePosition/4294967296),true)}pageBufferView.setUint32(14,this.config.serial,true);pageBufferView.setUint32(18,this.pageIndex++,true);pageBufferView.setUint8(26,this.segmentTableIndex,true);page.set(this.segmentTable.subarray(0,this.segmentTableIndex),27);page.set(this.segmentData.subarray(0,this.segmentDataIndex),27+this.segmentTableIndex);pageBufferView.setUint32(22,this.getChecksum(page),true);var exportPage={message:"page",page:page,samplePosition:this.granulePosition};this.segmentTableIndex=0;this.segmentDataIndex=0;this.framesInPage=0;if(granulePosition>0){this.lastPositiveGranulePosition=granulePosition}return exportPage};OggOpusEncoder.prototype.initChecksumTable=function(){this.checksumTable=[];for(var i=0;i<256;i++){var r=i<<24;for(var j=0;j<8;j++){r=(r&2147483648)!=0?r<<1^79764919:r<<1}this.checksumTable[i]=r&4294967295}};OggOpusEncoder.prototype.setOpusControl=function(control,value){var location=this._malloc(4);this.HEAP32[location>>2]=value;this._opus_encoder_ctl(this.encoder,control,location);this._free(location)};OggOpusEncoder.prototype.initCodec=function(){var errLocation=this._malloc(4);this.encoder=this._opus_encoder_create(this.config.encoderSampleRate,this.config.numberOfChannels,this.config.encoderApplication,errLocation);this._free(errLocation);if(this.config.encoderBitRate){this.setOpusControl(4002,this.config.encoderBitRate)}if(this.config.encoderComplexity){this.setOpusControl(4010,this.config.encoderComplexity)}this.encoderSamplesPerChannel=this.config.encoderSampleRate*this.config.encoderFrameSize/1e3;this.encoderSamplesPerChannelPointer=this._malloc(4);this.HEAP32[this.encoderSamplesPerChannelPointer>>2]=this.encoderSamplesPerChannel;this.encoderBufferLength=this.encoderSamplesPerChannel*this.config.numberOfChannels;this.encoderBufferPointer=this._malloc(this.encoderBufferLength*4);this.encoderBuffer=this.HEAPF32.subarray(this.encoderBufferPointer>>2,(this.encoderBufferPointer>>2)+this.encoderBufferLength);this.encoderOutputMaxLength=4e3;this.encoderOutputPointer=this._malloc(this.encoderOutputMaxLength);this.encoderOutputBuffer=this.HEAPU8.subarray(this.encoderOutputPointer,this.encoderOutputPointer+this.encoderOutputMaxLength)};OggOpusEncoder.prototype.initResampler=function(){var errLocation=this._malloc(4);this.resampler=this._speex_resampler_init(this.config.numberOfChannels,this.config.originalSampleRate,this.config.encoderSampleRate,this.config.resampleQuality,errLocation);this._free(errLocation);this.resampleBufferIndex=0;this.resampleSamplesPerChannel=this.config.originalSampleRate*this.config.encoderFrameSize/1e3;this.resampleSamplesPerChannelPointer=this._malloc(4);this.HEAP32[this.resampleSamplesPerChannelPointer>>2]=this.resampleSamplesPerChannel;this.resampleBufferLength=this.resampleSamplesPerChannel*this.config.numberOfChannels;this.resampleBufferPointer=this._malloc(this.resampleBufferLength*4);this.resampleBuffer=this.HEAPF32.subarray(this.resampleBufferPointer>>2,(this.resampleBufferPointer>>2)+this.resampleBufferLength)};OggOpusEncoder.prototype.interleave=function(buffers){for(var i=0;i=0){if(this.segmentTableIndex===255){exportPages.push(this.generatePage());this.headerType=1}var segmentLength=Math.min(packetLength,255);this.segmentTable[this.segmentTableIndex++]=segmentLength;this.segmentData.set(this.encoderOutputBuffer.subarray(packetIndex,packetIndex+segmentLength),this.segmentDataIndex);this.segmentDataIndex+=segmentLength;packetIndex+=segmentLength;packetLength-=255}this.granulePosition+=48*this.config.encoderFrameSize;if(this.segmentTableIndex===255){exportPages.push(this.generatePage());this.headerType=0}return exportPages};if(typeof registerProcessor==="function"){class EncoderWorklet extends AudioWorkletProcessor{constructor(){super();this.continueProcess=true;this.port.onmessage=(({data:data})=>{if(this.encoder){switch(data["command"]){case"getHeaderPages":this.postPage(this.encoder.generateIdPage());this.postPage(this.encoder.generateCommentPage());break;case"done":this.encoder.encodeFinalFrame().forEach(pageData=>this.postPage(pageData));this.encoder.destroy();delete this.encoder;this.port.postMessage({message:"done"});break;case"flush":this.postPage(this.encoder.flush());this.port.postMessage({message:"flushed"});break;default:}}switch(data["command"]){case"close":this.continueProcess=false;break;case"init":this.encoder=new OggOpusEncoder(data,Module);this.port.postMessage({message:"ready"});break;default:}})}process(inputs){if(this.encoder&&inputs[0]&&inputs[0].length&&inputs[0][0]&&inputs[0][0].length){this.encoder.encode(inputs[0]).forEach(pageData=>this.postPage(pageData))}return this.continueProcess}postPage(pageData){if(pageData){this.port.postMessage(pageData,[pageData.page.buffer])}}}registerProcessor("encoder-worklet",EncoderWorklet)}else{var encoder;var postPageGlobal=pageData=>{if(pageData){postMessage(pageData,[pageData.page.buffer])}};onmessage=(({data:data})=>{if(encoder){switch(data["command"]){case"encode":encoder.encode(data["buffers"]).forEach(pageData=>postPageGlobal(pageData));break;case"getHeaderPages":postPageGlobal(encoder.generateIdPage());postPageGlobal(encoder.generateCommentPage());break;case"done":encoder.encodeFinalFrame().forEach(pageData=>postPageGlobal(pageData));encoder.destroy();encoder=null;postMessage({message:"done"});break;case"flush":postPageGlobal(encoder.flush());postMessage({message:"flushed"});break;default:}}switch(data["command"]){case"close":close();break;case"init":encoder=new OggOpusEncoder(data,Module);postMessage({message:"ready"});break;default:}})}var module=module||{};module.exports={Module:Module,OggOpusEncoder:OggOpusEncoder}; diff --git a/main/manager-web/src/apis/api.js b/main/manager-web/src/apis/api.js index 63977008..1b9f0a9e 100755 --- a/main/manager-web/src/apis/api.js +++ b/main/manager-web/src/apis/api.js @@ -5,6 +5,7 @@ import device from './module/device.js' import model from './module/model.js' import timbre from "./module/timbre.js" import user from './module/user.js' +import ota from './module/ota.js' /** * 接口地址 @@ -31,4 +32,5 @@ export default { device, model, timbre, + ota } diff --git a/main/manager-web/src/apis/module/ota.js b/main/manager-web/src/apis/module/ota.js new file mode 100644 index 00000000..438aa3d8 --- /dev/null +++ b/main/manager-web/src/apis/module/ota.js @@ -0,0 +1,123 @@ +import { getServiceUrl } from '../api'; +import RequestService from '../httpRequest'; + +export default { + // 分页查询OTA固件信息 + getOtaList(params, callback) { + RequestService.sendRequest() + .url(`${getServiceUrl()}/otaMag`) + .method('GET') + .data(params) + .success((res) => { + RequestService.clearRequestTime(); + callback(res); + }) + .fail((err) => { + console.error('获取OTA固件列表失败:', err); + RequestService.reAjaxFun(() => { + this.getOtaList(params, callback); + }); + }).send(); + }, + // 获取单个OTA固件信息 + getOtaInfo(id, callback) { + RequestService.sendRequest() + .url(`${getServiceUrl()}/otaMag/${id}`) + .method('GET') + .success((res) => { + RequestService.clearRequestTime(); + callback(res); + }) + .fail((err) => { + console.error('获取OTA固件信息失败:', err); + RequestService.reAjaxFun(() => { + this.getOtaInfo(id, callback); + }); + }).send(); + }, + // 保存OTA固件信息 + saveOta(entity, callback) { + RequestService.sendRequest() + .url(`${getServiceUrl()}/otaMag`) + .method('POST') + .data(entity) + .success((res) => { + RequestService.clearRequestTime(); + callback(res); + }) + .fail((err) => { + console.error('保存OTA固件信息失败:', err); + RequestService.reAjaxFun(() => { + this.saveOta(entity, callback); + }); + }).send(); + }, + // 更新OTA固件信息 + updateOta(id, entity, callback) { + RequestService.sendRequest() + .url(`${getServiceUrl()}/otaMag/${id}`) + .method('PUT') + .data(entity) + .success((res) => { + RequestService.clearRequestTime(); + callback(res); + }) + .fail((err) => { + console.error('更新OTA固件信息失败:', err); + RequestService.reAjaxFun(() => { + this.updateOta(id, entity, callback); + }); + }).send(); + }, + // 删除OTA固件 + deleteOta(id, callback) { + RequestService.sendRequest() + .url(`${getServiceUrl()}/otaMag/${id}`) + .method('DELETE') + .success((res) => { + RequestService.clearRequestTime(); + callback(res); + }) + .fail((err) => { + console.error('删除OTA固件失败:', err); + RequestService.reAjaxFun(() => { + this.deleteOta(id, callback); + }); + }).send(); + }, + // 上传固件文件 + uploadFirmware(file, callback) { + const formData = new FormData(); + formData.append('file', file); + RequestService.sendRequest() + .url(`${getServiceUrl()}/otaMag/upload`) + .method('POST') + .data(formData) + .success((res) => { + RequestService.clearRequestTime(); + callback(res); + }) + .fail((err) => { + console.error('上传固件文件失败:', err); + RequestService.reAjaxFun(() => { + this.uploadFirmware(file, callback); + }); + }).send(); + }, + // 获取固件下载链接 + getDownloadUrl(id, callback) { + RequestService.sendRequest() + .url(`${getServiceUrl()}/otaMag/getDownloadUrl/${id}`) + .method('GET') + .success((res) => { + RequestService.clearRequestTime(); + callback(res); + }) + .fail((err) => { + console.error('获取下载链接失败:', err); + RequestService.reAjaxFun(() => { + this.getDownloadUrl(id, callback); + }); + }).send(); + } +} \ No newline at end of file diff --git a/main/manager-web/src/assets/header/firmware_update.png b/main/manager-web/src/assets/header/firmware_update.png new file mode 100644 index 00000000..bd3d7396 Binary files /dev/null and b/main/manager-web/src/assets/header/firmware_update.png differ diff --git a/main/manager-web/src/components/FirmwareDialog.vue b/main/manager-web/src/components/FirmwareDialog.vue new file mode 100644 index 00000000..2cbf83a1 --- /dev/null +++ b/main/manager-web/src/components/FirmwareDialog.vue @@ -0,0 +1,198 @@ + + + + + \ No newline at end of file diff --git a/main/manager-web/src/components/HeaderBar.vue b/main/manager-web/src/components/HeaderBar.vue index c67362ea..2d0b3c3b 100644 --- a/main/manager-web/src/components/HeaderBar.vue +++ b/main/manager-web/src/components/HeaderBar.vue @@ -32,6 +32,12 @@ :style="{ filter: $route.path === '/params-management' ? 'brightness(0) invert(1)' : 'None' }" /> 参数管理 +

+ + OTA管理 +
@@ -105,6 +111,9 @@ export default { goParamManagement() { this.$router.push('/params-management') }, + goOtaManagement() { + this.$router.push('/ota-management') + }, // 获取用户信息 fetchUserInfo() { userApi.getUserInfo(({ data }) => { diff --git a/main/manager-web/src/router/index.js b/main/manager-web/src/router/index.js index 9a06b07b..472a4df2 100644 --- a/main/manager-web/src/router/index.js +++ b/main/manager-web/src/router/index.js @@ -62,13 +62,6 @@ const routes = [ return import('../views/ModelConfig.vue') } }, - { - path: '/test', - name: 'TestServer', - component: function () { - return import('../views/test.vue') - } - }, { path: '/params-management', name: 'ParamsManagement', @@ -80,6 +73,17 @@ const routes = [ title: '参数管理' } }, + { + path: '/ota-management', + name: 'OtaManagement', + component: function () { + return import('../views/OtaManagement.vue') + }, + meta: { + requiresAuth: true, + title: 'OTA管理' + } + }, ] const router = new VueRouter({ diff --git a/main/manager-web/src/utils/format.js b/main/manager-web/src/utils/format.js new file mode 100644 index 00000000..97f20f03 --- /dev/null +++ b/main/manager-web/src/utils/format.js @@ -0,0 +1,21 @@ +// 日期格式化函数 +export function formatDate(date) { + if (!date) return ''; + const d = new Date(date); + const year = d.getFullYear(); + const month = String(d.getMonth() + 1).padStart(2, '0'); + const day = String(d.getDate()).padStart(2, '0'); + const hour = String(d.getHours()).padStart(2, '0'); + const minute = String(d.getMinutes()).padStart(2, '0'); + const second = String(d.getSeconds()).padStart(2, '0'); + return `${year}-${month}-${day} ${hour}:${minute}:${second}`; +} + +// 文件大小格式化函数 +export function formatFileSize(bytes) { + if (!bytes || bytes === 0) return '0 B'; + const units = ['B', 'KB', 'MB', 'GB', 'TB']; + const k = 1024; + const i = Math.floor(Math.log(bytes) / Math.log(k)); + return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + units[i]; +} \ No newline at end of file diff --git a/main/manager-web/src/utils/index.js b/main/manager-web/src/utils/index.js index 8a5a960e..bac4b18a 100755 --- a/main/manager-web/src/utils/index.js +++ b/main/manager-web/src/utils/index.js @@ -136,3 +136,63 @@ export function getUUID() { }) } +/** + * 固件类型选项 + */ +export const FIRMWARE_TYPES = [ + { "key": "bread-compact-wifi", "name": "面包板新版接线（WiFi）" }, + { "key": "bread-compact-wifi-lcd", "name": "面包板新版接线（WiFi）+ LCD" }, + { "key": "bread-compact-ml307", "name": "面包板新版接线（ML307 AT）" }, + { "key": "bread-compact-esp32", "name": "面包板（WiFi） ESP32 DevKit" }, + { "key": "bread-compact-esp32-lcd", "name": "面包板（WiFi+ LCD） ESP32 DevKit" }, + { "key": "df-k10", "name": "DFRobot 行空板 k10" }, + { "key": "esp32-cgc", "name": "ESP32 CGC" }, + { "key": "esp-box-3", "name": "ESP BOX 3" }, + { "key": "esp-box", "name": "ESP BOX" }, + { "key": "esp-box-lite", "name": "ESP BOX Lite" }, + { "key": "kevin-box-1", "name": "Kevin Box 1" }, + { "key": "kevin-box-2", "name": "Kevin Box 2" }, + { "key": "kevin-c3", "name": "Kevin C3" }, + { "key": "kevin-sp-v3-dev", "name": "Kevin SP V3开发板" }, + { "key": "kevin-sp-v4-dev", "name": "Kevin SP V4开发板" }, + { "key": "kevin-yuying-313lcd", "name": "鱼鹰科技3.13LCD开发板" }, + { "key": "lichuang-dev", "name": "立创·实战派ESP32-S3开发板" }, + { "key": "lichuang-c3-dev", "name": "立创·实战派ESP32-C3开发板" }, + { "key": "magiclick-2p4", "name": "神奇按钮 Magiclick_2.4" }, + { "key": "magiclick-2p5", "name": "神奇按钮 Magiclick_2.5" }, + { "key": "magiclick-c3", "name": "神奇按钮 Magiclick_C3" }, + { "key": "magiclick-c3-v2", "name": "神奇按钮 Magiclick_C3_v2" }, + { "key": "m5stack-core-s3", "name": "M5Stack CoreS3" }, + { "key": "atoms3-echo-base", "name": "AtomS3 + Echo Base" }, + { "key": "atoms3r-echo-base", "name": "AtomS3R + Echo Base" }, + { "key": "atoms3r-cam-m12-echo-base", "name": "AtomS3R CAM/M12 + Echo Base" }, + { "key": "atommatrix-echo-base", "name": "AtomMatrix + Echo Base" }, + { "key": "xmini-c3", "name": "虾哥 Mini C3" }, + { "key": "esp32s3-korvo2-v3", "name": "ESP32S3_KORVO2_V3开发板" }, + { "key": "esp-sparkbot", "name": "ESP-SparkBot开发板" }, + { "key": "esp-spot-s3", "name": "ESP-Spot-S3" }, + { "key": "esp32-s3-touch-amoled-1.8", "name": "Waveshare ESP32-S3-Touch-AMOLED-1.8" }, + { "key": "esp32-s3-touch-lcd-1.85c", "name": "Waveshare ESP32-S3-Touch-LCD-1.85C" }, + { "key": "esp32-s3-touch-lcd-1.85", "name": "Waveshare ESP32-S3-Touch-LCD-1.85" }, + { "key": "esp32-s3-touch-lcd-1.46", "name": "Waveshare ESP32-S3-Touch-LCD-1.46" }, + { "key": "esp32-s3-touch-lcd-3.5", "name": "Waveshare ESP32-S3-Touch-LCD-3.5" }, + { "key": "tudouzi", "name": "土豆子" }, + { "key": "lilygo-t-circle-s3", "name": "LILYGO T-Circle-S3" }, + { "key": "lilygo-t-cameraplus-s3", "name": "LILYGO T-CameraPlus-S3" }, + { "key": "movecall-moji-esp32s3", "name": "Movecall Moji 小智AI衍生版" }, + { "key": "movecall-cuican-esp32s3", "name": "Movecall CuiCan 璀璨·AI吊坠" }, + { "key": "atk-dnesp32s3", "name": "正点原子DNESP32S3开发板" }, + { "key": "atk-dnesp32s3-box", "name": "正点原子DNESP32S3-BOX" }, + { "key": "du-chatx", "name": "嘟嘟开发板CHATX(wifi)" }, + { "key": "taiji-pi-s3", "name": "太极小派esp32s3" }, + { "key": "xingzhi-cube-0.85tft-wifi", "name": "无名科技星智0.85(WIFI)" }, + { "key": "xingzhi-cube-0.85tft-ml307", "name": "无名科技星智0.85(ML307)" }, + { "key": "xingzhi-cube-0.96oled-wifi", "name": "无名科技星智0.96(WIFI)" }, + { "key": "xingzhi-cube-0.96oled-ml307", "name": "无名科技星智0.96(ML307)" }, + { "key": "xingzhi-cube-1.54tft-wifi", "name": "无名科技星智1.54(WIFI)" }, + { "key": "xingzhi-cube-1.54tft-ml307", "name": "无名科技星智1.54(ML307)" }, + { "key": "sensecap-watcher", "name": "SenseCAP Watcher" }, + { "key": "doit-s3-aibox", "name": "四博智联AI陪伴盒子" }, + { "key": "mixgo-nova", "name": "元控·青春" } +] + diff --git a/main/manager-web/src/views/DeviceManagement.vue b/main/manager-web/src/views/DeviceManagement.vue index 98ba8104..662287a3 100644 --- a/main/manager-web/src/views/DeviceManagement.vue +++ b/main/manager-web/src/views/DeviceManagement.vue @@ -5,8 +5,8 @@

设备管理

- + 搜索
@@ -29,7 +29,11 @@ - + + + @@ -39,7 +43,8 @@ - + {{ scope.row.remark }} @@ -69,26 +74,17 @@ 新增 - 解绑 + 解绑
- - + + - @@ -110,6 +106,7 @@ import Api from '@/apis/api'; import AddDeviceDialog from "@/components/AddDeviceDialog.vue"; import HeaderBar from "@/components/HeaderBar.vue"; +import { FIRMWARE_TYPES } from "@/utils"; export default { components: { HeaderBar, AddDeviceDialog }, @@ -311,7 +308,7 @@ export default { rawBindTime: new Date(device.createDate).getTime() }; }) - .sort((a, b) => a.rawBindTime - b.rawBindTime); + .sort((a, b) => a.rawBindTime - b.rawBindTime); this.activeSearchKeyword = ""; this.searchKeyword = ""; } else { @@ -319,12 +316,16 @@ export default { } }); }, - headerCellClassName({columnIndex}) { + headerCellClassName({ columnIndex }) { if (columnIndex === 0) { return "custom-selection-header"; } return ""; - } + }, + getFirmwareTypeName(type) { + const firmwareType = FIRMWARE_TYPES.find(item => item.key === type); + return firmwareType ? firmwareType.name : type; + }, } }; @@ -393,12 +394,12 @@ export default { transition: border-color 0.2s; } -::v-deep .page-size-select{ +::v-deep .page-size-select { width: 100px; margin-right: 8px; } -::v-deep .page-size-select .el-input__inner{ +::v-deep .page-size-select .el-input__inner { height: 32px; line-height: 32px; border-radius: 4px; @@ -407,7 +408,8 @@ export default { color: #606266; font-size: 14px; } -::v-deep .page-size-select .el-input__suffix{ + +::v-deep .page-size-select .el-input__suffix { right: 6px; width: 15px; height: 20px; @@ -418,13 +420,14 @@ export default { border-radius: 4px; } -::v-deep .page-size-select .el-input__suffix-inner{ +::v-deep .page-size-select .el-input__suffix-inner { display: flex; align-items: center; justify-content: center; width: 100%; } -::v-deep .page-size-select .el-icon-arrow-up:before{ + +::v-deep .page-size-select .el-icon-arrow-up:before { content: ""; display: inline-block; border-left: 6px solid transparent; diff --git a/main/manager-web/src/views/ModelConfig.vue b/main/manager-web/src/views/ModelConfig.vue index 8add3398..aa788f2f 100644 --- a/main/manager-web/src/views/ModelConfig.vue +++ b/main/manager-web/src/views/ModelConfig.vue @@ -44,19 +44,11 @@
- + @@ -136,6 +128,9 @@
+ + +
@@ -145,9 +140,9 @@ import AddModelDialog from "@/components/AddModelDialog.vue"; import HeaderBar from "@/components/HeaderBar.vue"; import ModelEditDialog from "@/components/ModelEditDialog.vue"; import TtsModel from "@/components/TtsModel.vue"; - +import VersionFooter from "@/components/VersionFooter.vue"; export default { - components: { HeaderBar, ModelEditDialog, TtsModel, AddModelDialog }, + components: { HeaderBar, ModelEditDialog, TtsModel, AddModelDialog, VersionFooter }, data() { return { addDialogVisible: false, @@ -520,8 +515,9 @@ export default { .nav-panel .el-menu-item { height: 50px; + background: #e9f0ff; line-height: 50px; - border-radius: 4px; + border-radius: 4px 0 0 4px !important; transition: all 0.3s; display: flex !important; justify-content: flex-end; @@ -532,8 +528,7 @@ export default { } .nav-panel .el-menu-item.is-active { - background: #e9f0ff; - color: #0ba6f4 !important; + background: #5778ff; position: relative; padding-left: 40px !important; } @@ -546,7 +541,7 @@ export default { transform: translateY(-50%); width: 13px; height: 13px; - background: #409EFF; + background: #fff; border-radius: 50%; box-shadow: 0 0 4px rgba(64, 158, 255, 0.5); } @@ -758,7 +753,7 @@ export default { } ::v-deep .nav-panel .el-menu-item.is-active .menu-text { - color: #409EFF !important; + color: #fff !important; } ::v-deep .data-table { @@ -929,17 +924,19 @@ export default { background-color: rgba(255, 255, 255, 0.6) !important; backdrop-filter: blur(2px); } + ::v-deep .el-loading-spinner .circular { width: 28px; height: 28px; } + ::v-deep .el-loading-spinner .path { stroke: #6b8cff; } + ::v-deep .el-loading-text { color: #6b8cff !important; font-size: 14px; margin-top: 8px; } - diff --git a/main/manager-web/src/views/OtaManagement.vue b/main/manager-web/src/views/OtaManagement.vue new file mode 100644 index 00000000..76bbeeec --- /dev/null +++ b/main/manager-web/src/views/OtaManagement.vue @@ -0,0 +1,646 @@ + + + + + diff --git a/main/manager-web/src/views/ParamsManagement.vue b/main/manager-web/src/views/ParamsManagement.vue index 8bca20f1..3301bbb5 100644 --- a/main/manager-web/src/views/ParamsManagement.vue +++ b/main/manager-web/src/views/ParamsManagement.vue @@ -15,15 +15,10 @@
- + @@ -91,9 +85,9 @@ import Api from "@/apis/api"; import HeaderBar from "@/components/HeaderBar.vue"; import ParamDialog from "@/components/ParamDialog.vue"; - +import VersionFooter from "@/components/VersionFooter.vue"; export default { - components: { HeaderBar, ParamDialog }, + components: { HeaderBar, ParamDialog, VersionFooter }, data() { return { searchCode: "", @@ -146,29 +140,29 @@ export default { this.fetchParams(); }, fetchParams() { - this.loading = true; - Api.admin.getParamsList( - { - page: this.currentPage, - limit: this.pageSize, - paramCode: this.searchCode, - }, - ({ data }) => { - this.loading = false; - if (data.code === 0) { - this.paramsList = data.data.list.map(item => ({ - ...item, - selected: false - })); - this.total = data.data.total; - } else { - this.$message.error({ - message: data.msg || '获取参数列表失败', - showClose: true - }); - } - } - ); + this.loading = true; + Api.admin.getParamsList( + { + page: this.currentPage, + limit: this.pageSize, + paramCode: this.searchCode, + }, + ({ data }) => { + this.loading = false; + if (data.code === 0) { + this.paramsList = data.data.list.map(item => ({ + ...item, + selected: false + })); + this.total = data.data.total; + } else { + this.$message.error({ + message: data.msg || '获取参数列表失败', + showClose: true + }); + } + } + ); }, handleSearch() { this.currentPage = 1; @@ -197,33 +191,33 @@ export default { }, handleSubmit({ form, done }) { - if (form.id) { - // 编辑 - Api.admin.updateParam(form, ({ data }) => { - if (data.code === 0) { - this.$message.success({ - message:"修改成功", - showClose:true + if (form.id) { + // 编辑 + Api.admin.updateParam(form, ({ data }) => { + if (data.code === 0) { + this.$message.success({ + message: "修改成功", + showClose: true + }); + this.dialogVisible = false; + this.fetchParams(); + } + done && done(); }); - this.dialogVisible = false; - this.fetchParams(); - } - done && done(); - }); - } else { - // 新增 - Api.admin.addParam(form, ({ data }) => { - if (data.code === 0) { - this.$message.success({ - message:"新增成功", - showClose:true + } else { + // 新增 + Api.admin.addParam(form, ({ data }) => { + if (data.code === 0) { + this.$message.success({ + message: "新增成功", + showClose: true + }); + this.dialogVisible = false; + this.fetchParams(); + } + done && done(); }); - this.dialogVisible = false; - this.fetchParams(); - } - done && done(); - }); - } + } }, deleteSelectedParams() { @@ -243,8 +237,8 @@ export default { if (Array.isArray(row) && row.length === 0) { this.$message.warning({ - message:"请先选择需要删除的参数", - showClose:true + message: "请先选择需要删除的参数", + showClose: true }); return; } @@ -259,8 +253,8 @@ export default { const ids = params.map(param => param.id); if (ids.some(id => isNaN(id))) { this.$message.error({ - message:'存在无效的参数ID', - showClose: true + message: '存在无效的参数ID', + showClose: true }); return; } @@ -341,16 +335,16 @@ export default { } .main-wrapper { - margin: 5px 22px; - border-radius: 15px; - min-height: calc(100vh - 24vh); - height: auto; - max-height: 80vh; - box-shadow: 0 2px 12px rgba(0, 0, 0, 0.1); - position: relative; - background: rgba(237, 242, 255, 0.5); - display: flex; - flex-direction: column; + margin: 5px 22px; + border-radius: 15px; + min-height: calc(100vh - 24vh); + height: auto; + max-height: 80vh; + box-shadow: 0 2px 12px rgba(0, 0, 0, 0.1); + position: relative; + background: rgba(237, 242, 255, 0.5); + display: flex; + flex-direction: column; } .operation-bar { @@ -402,21 +396,21 @@ export default { } .params-card { - background: white; - flex: 1; - display: flex; - flex-direction: column; - border: none; - box-shadow: none; - overflow: hidden; - - ::v-deep .el-card__body { - padding: 15px; + background: white; + flex: 1; display: flex; flex-direction: column; - flex: 1; + border: none; + box-shadow: none; overflow: hidden; - } + + ::v-deep .el-card__body { + padding: 15px; + display: flex; + flex-direction: column; + flex: 1; + overflow: hidden; + } } .table_bottom { @@ -467,7 +461,7 @@ export default { gap: 10px; .el-select { - margin-right: 8px; + margin-right: 8px; } .pagination-btn:first-child, @@ -535,15 +529,17 @@ export default { width: 100%; display: flex; flex-direction: column; + .el-table__body-wrapper { - flex: 1; - overflow-y: auto; - max-height: none !important; + flex: 1; + overflow-y: auto; + max-height: none !important; } .el-table__header-wrapper { - flex-shrink: 0; + flex-shrink: 0; } + .el-table__header th { background: white !important; color: black; @@ -670,32 +666,31 @@ export default { } .el-table { - --table-max-height: calc(100vh - 40vh); - max-height: var(--table-max-height); + --table-max-height: calc(100vh - 40vh); + max-height: var(--table-max-height); - .el-table__body-wrapper { - max-height: calc(var(--table-max-height) - 40px); - } + .el-table__body-wrapper { + max-height: calc(var(--table-max-height) - 40px); + } } :deep(.el-loading-mask) { - background-color: rgba(255, 255, 255, 0.6) !important; - backdrop-filter: blur(2px); + background-color: rgba(255, 255, 255, 0.6) !important; + backdrop-filter: blur(2px); } :deep(.el-loading-spinner .circular) { - width: 28px; - height: 28px; + width: 28px; + height: 28px; } :deep(.el-loading-spinner .path) { - stroke: #6b8cff; + stroke: #6b8cff; } :deep(.el-loading-text) { - color: #6b8cff !important; - font-size: 14px; - margin-top: 8px; + color: #6b8cff !important; + font-size: 14px; + margin-top: 8px; } - diff --git a/main/manager-web/src/views/UserManagement.vue b/main/manager-web/src/views/UserManagement.vue index 1ca70422..eb43a959 100644 --- a/main/manager-web/src/views/UserManagement.vue +++ b/main/manager-web/src/views/UserManagement.vue @@ -15,18 +15,13 @@
- + - + @@ -61,11 +56,7 @@
- + @@ -90,16 +81,19 @@
+ + +
- - \ No newline at end of file diff --git a/main/manager-web/vue.config.js b/main/manager-web/vue.config.js index e61c0628..1c2e6b04 100644 --- a/main/manager-web/vue.config.js +++ b/main/manager-web/vue.config.js @@ -39,7 +39,7 @@ const cdnResources = { const useCDN = process.env.VUE_APP_USE_CDN === 'true'; module.exports = defineConfig({ - productionSourceMap: process.env.NODE_ENV === 'production' ? false : true, // 生产环境不生成 source map + productionSourceMap: process.env.NODE_ENV !=='production', // 生产环境不生成 source map devServer: { port: 8001, // 指定端口为 8001 proxy: { @@ -52,6 +52,7 @@ module.exports = defineConfig({ overlay: false, // 不显示 webpack 错误覆盖层 }, }, + publicPath: process.env.VUE_APP_PUBLIC_PATH || "", chainWebpack: config => { // 修改 HTML 插件配置，动态插入 CDN 链接 diff --git a/main/xiaozhi-server/config/config_loader.py b/main/xiaozhi-server/config/config_loader.py index 49a66558..849a2a8a 100644 --- a/main/xiaozhi-server/config/config_loader.py +++ b/main/xiaozhi-server/config/config_loader.py @@ -69,6 +69,11 @@ def get_config_from_api(config): "url": config["manager-api"].get("url", ""), "secret": config["manager-api"].get("secret", ""), } + if config.get("server"): + config_data["server"] = { + "ip": config["server"].get("ip", ""), + "port": config["server"].get("port", ""), + } return config_data diff --git a/main/xiaozhi-server/config/logger.py b/main/xiaozhi-server/config/logger.py index 5e933584..705b244c 100644 --- a/main/xiaozhi-server/config/logger.py +++ b/main/xiaozhi-server/config/logger.py @@ -3,7 +3,7 @@ import sys from loguru import logger from config.config_loader import load_config -SERVER_VERSION = "0.3.9" +SERVER_VERSION = "0.3.11" def get_module_abbreviation(module_name, module_dict): diff --git a/main/xiaozhi-server/config_from_api.yaml b/main/xiaozhi-server/config_from_api.yaml index d5fd69bc..15962bb6 100644 --- a/main/xiaozhi-server/config_from_api.yaml +++ b/main/xiaozhi-server/config_from_api.yaml @@ -5,6 +5,9 @@ # 先启动manager-api和manager-web，注册一个账号，第一个注册的账号为管理员 # 使用管理员，进入【参数管理】页面，找到【server.secret】，复制它到参数值，注意每次从零部署，server.secret都会变化 # 打开本data目录下的.config.yaml文件，修改manager-api.secret为刚才复制出来的server.secret +server: + ip: 0.0.0.0 + port: 8000 manager-api: # 你的manager-api的地址，最好使用局域网ip url: http://127.0.0.1:8002/xiaozhi diff --git a/main/xiaozhi-server/core/connection.py b/main/xiaozhi-server/core/connection.py index 5bf7540b..8fa09318 100644 --- a/main/xiaozhi-server/core/connection.py +++ b/main/xiaozhi-server/core/connection.py @@ -226,12 +226,12 @@ class ConnectionHandler: """加载意图识别""" self._initialize_intent() """加载位置信息""" - self.client_ip_info = get_ip_info(self.client_ip, self.logger) - if self.client_ip_info is not None and "city" in self.client_ip_info: - self.logger.bind(tag=TAG).info(f"Client ip info: {self.client_ip_info}") - self.prompt = self.prompt + f"\nuser location:{self.client_ip_info}" - - self.dialogue.update_system_message(self.prompt) + # self.client_ip_info = get_ip_info(self.client_ip, self.logger) + # if self.client_ip_info is not None and "city" in self.client_ip_info: + # self.logger.bind(tag=TAG).info(f"Client ip info: {self.client_ip_info}") + # self.prompt = self.prompt + f"\nuser location:{self.client_ip_info}" + # + # self.dialogue.update_system_message(self.prompt) def _initialize_private_config(self): read_config_from_api = self.config.get("read_config_from_api", False) diff --git a/main/xiaozhi-server/core/providers/llm/AliBL/AliBL.py b/main/xiaozhi-server/core/providers/llm/AliBL/AliBL.py index 51efdc06..769f3117 100644 --- a/main/xiaozhi-server/core/providers/llm/AliBL/AliBL.py +++ b/main/xiaozhi-server/core/providers/llm/AliBL/AliBL.py @@ -6,6 +6,7 @@ from core.providers.llm.base import LLMProviderBase TAG = __name__ logger = setup_logging() + class LLMProvider(LLMProviderBase): def __init__(self, config): self.api_key = config["api_key"] @@ -19,21 +20,25 @@ class LLMProvider(LLMProviderBase): # 处理dialogue if self.is_No_prompt: dialogue.pop(0) - logger.bind(tag=TAG).debug(f"【阿里百练API服务】处理后的dialogue: {dialogue}") + logger.bind(tag=TAG).debug( + f"【阿里百练API服务】处理后的dialogue: {dialogue}" + ) # 构造调用参数 call_params = { "api_key": self.api_key, "app_id": self.app_id, "session_id": session_id, - "messages": dialogue + "messages": dialogue, } if self.memory_id != False: # 百练memory需要prompt参数 prompt = dialogue[-1].get("content") call_params["memory_id"] = self.memory_id call_params["prompt"] = prompt - logger.bind(tag=TAG).debug(f"【阿里百练API服务】处理后的prompt: {prompt}") + logger.bind(tag=TAG).debug( + f"【阿里百练API服务】处理后的prompt: {prompt}" + ) responses = Application.call(**call_params) if responses.status_code != HTTPStatus.OK: @@ -44,9 +49,15 @@ class LLMProvider(LLMProviderBase): ) yield "【阿里百练API服务响应异常】" else: - logger.bind(tag=TAG).debug(f"【阿里百练API服务】构造参数: {call_params}") + logger.bind(tag=TAG).debug( + f"【阿里百练API服务】构造参数: {call_params}" + ) yield responses.output.text except Exception as e: logger.bind(tag=TAG).error(f"【阿里百练API服务】响应异常: {e}") yield "【LLM服务响应异常】" + + def response_with_functions(self, session_id, dialogue, functions=None): + logger.bind(tag=TAG).info(f"阿里百练暂未实现完整的工具调用（function call）") + return self.response(session_id, dialogue) diff --git a/main/xiaozhi-server/core/providers/llm/fastgpt/fastgpt.py b/main/xiaozhi-server/core/providers/llm/fastgpt/fastgpt.py index 38f9a2c9..e0e6ccc7 100644 --- a/main/xiaozhi-server/core/providers/llm/fastgpt/fastgpt.py +++ b/main/xiaozhi-server/core/providers/llm/fastgpt/fastgpt.py @@ -21,37 +21,36 @@ class LLMProvider(LLMProviderBase): # 发起流式请求 with requests.post( - f"{self.base_url}/chat/completions", - headers={"Authorization": f"Bearer {self.api_key}"}, - json={ - "stream": True, - "chatId": session_id, - "detail": self.detail, - "variables": self.variables, - "messages": [ - { - "role": "user", - "content": last_msg["content"] - } - ] - }, - stream=True + f"{self.base_url}/chat/completions", + headers={"Authorization": f"Bearer {self.api_key}"}, + json={ + "stream": True, + "chatId": session_id, + "detail": self.detail, + "variables": self.variables, + "messages": [{"role": "user", "content": last_msg["content"]}], + }, + stream=True, ) as r: for line in r.iter_lines(): if line: try: - if line.startswith(b'data: '): - if line[6:].decode('utf-8') == '[DONE]': + if line.startswith(b"data: "): + if line[6:].decode("utf-8") == "[DONE]": break data = json.loads(line[6:]) - if 'choices' in data and len(data['choices']) > 0: - delta = data['choices'][0].get('delta', {}) - if delta and 'content' in delta and delta['content'] is not None: - content = delta['content'] - if '' in content: + if "choices" in data and len(data["choices"]) > 0: + delta = data["choices"][0].get("delta", {}) + if ( + delta + and "content" in delta + and delta["content"] is not None + ): + content = delta["content"] + if "" in content: continue - if '' in content: + if "" in content: continue yield content @@ -62,4 +61,8 @@ class LLMProvider(LLMProviderBase): except Exception as e: logger.bind(tag=TAG).error(f"Error in response generation: {e}") - yield "【服务响应异常】" \ No newline at end of file + yield "【服务响应异常】" + + def response_with_functions(self, session_id, dialogue, functions=None): + logger.bind(tag=TAG).info(f"fastgpt暂未实现完整的工具调用（function call）") + return self.response(session_id, dialogue) diff --git a/main/xiaozhi-server/core/providers/llm/gemini/gemini.py b/main/xiaozhi-server/core/providers/llm/gemini/gemini.py index ca78caa9..a91a6bf0 100644 --- a/main/xiaozhi-server/core/providers/llm/gemini/gemini.py +++ b/main/xiaozhi-server/core/providers/llm/gemini/gemini.py @@ -134,3 +134,7 @@ class LLMProvider(LLMProviderBase): yield f"JSON解码错误：{e}" except Exception as e: yield f"发生错误：{e}" + + def response_with_functions(self, session_id, dialogue, functions=None): + logger.bind(tag=TAG).info(f"gemini暂未实现完整的工具调用（function call）") + return self.response(session_id, dialogue) diff --git a/main/xiaozhi-server/core/providers/tts/base.py b/main/xiaozhi-server/core/providers/tts/base.py index e39ca65c..b83f6f06 100644 --- a/main/xiaozhi-server/core/providers/tts/base.py +++ b/main/xiaozhi-server/core/providers/tts/base.py @@ -26,13 +26,19 @@ class TTSProviderBase(ABC): max_repeat_time = 5 text = MarkdownCleaner.clean_markdown(text) while not os.path.exists(tmp_file) and max_repeat_time > 0: - asyncio.run(self.text_to_speak(text, tmp_file)) + try: + asyncio.run(self.text_to_speak(text, tmp_file)) + except Exception as e: + logger.bind(tag=TAG).error(f"语音生成失败: {text}，错误: {e}") if not os.path.exists(tmp_file): - max_repeat_time = max_repeat_time - 1 - logger.bind(tag=TAG).error(f"语音生成失败: {text}:{tmp_file}，再试{max_repeat_time}次") + max_repeat_time -= 1 + if max_repeat_time > 0: + logger.bind(tag=TAG).error(f"再试{max_repeat_time}次") if max_repeat_time > 0: - logger.bind(tag=TAG).info(f"语音生成成功: {text}:{tmp_file}，重试{5 - max_repeat_time}次") + logger.bind(tag=TAG).info( + f"语音生成成功: {text}:{tmp_file}，重试{5 - max_repeat_time}次" + ) return tmp_file except Exception as e: @@ -48,9 +54,11 @@ class TTSProviderBase(ABC): # 获取文件后缀名 file_type = os.path.splitext(audio_file_path)[1] if file_type: - file_type = file_type.lstrip('.') + file_type = file_type.lstrip(".") # 读取音频文件，-nostdin 参数：不要从标准输入读取数据，否则FFmpeg会阻塞 - audio = AudioSegment.from_file(audio_file_path, format=file_type, parameters=["-nostdin"]) + audio = AudioSegment.from_file( + audio_file_path, format=file_type, parameters=["-nostdin"] + ) # 转换为单声道/16kHz采样率/16位小端编码（确保与编码器匹配） audio = audio.set_channels(1).set_frame_rate(16000).set_sample_width(2) @@ -72,11 +80,11 @@ class TTSProviderBase(ABC): # 按帧处理所有音频数据（包括最后一帧可能补零） for i in range(0, len(raw_data), frame_size * 2): # 16bit=2bytes/sample # 获取当前帧的二进制数据 - chunk = raw_data[i:i + frame_size * 2] + chunk = raw_data[i : i + frame_size * 2] # 如果最后一帧不足，补零 if len(chunk) < frame_size * 2: - chunk += b'\x00' * (frame_size * 2 - len(chunk)) + chunk += b"\x00" * (frame_size * 2 - len(chunk)) # 转换为numpy数组处理 np_frame = np.frombuffer(chunk, dtype=np.int16) diff --git a/main/xiaozhi-server/core/websocket_server.py b/main/xiaozhi-server/core/websocket_server.py index cb4dee08..d5fb69db 100644 --- a/main/xiaozhi-server/core/websocket_server.py +++ b/main/xiaozhi-server/core/websocket_server.py @@ -24,7 +24,7 @@ class WebSocketServer: async def start(self): server_config = self.config["server"] - host = server_config["ip"] + host = server_config.get("ip", "0.0.0.0") port = int(server_config.get("port", 8000)) self.logger.bind(tag=TAG).info( diff --git a/main/xiaozhi-server/docker-compose_all.yml b/main/xiaozhi-server/docker-compose_all.yml index 51bb4e68..91910120 100644 --- a/main/xiaozhi-server/docker-compose_all.yml +++ b/main/xiaozhi-server/docker-compose_all.yml @@ -47,6 +47,10 @@ services: - SPRING_DATASOURCE_DRUID_PASSWORD=123456 - SPRING_DATA_REDIS_HOST=xiaozhi-esp32-server-redis - SPRING_DATA_REDIS_PORT=6379 + volumes: + # 配置文件目录 + - ./uploadfile:/app/uploadfile + xiaozhi-esp32-server-db: image: mysql:latest container_name: xiaozhi-esp32-server-db @@ -59,7 +63,7 @@ services: networks: - default expose: - - "3306" + - 3306 volumes: - ./mysql/data:/var/lib/mysql environment: diff --git a/main/xiaozhi-server/plugins_func/functions/get_weather.py b/main/xiaozhi-server/plugins_func/functions/get_weather.py index 060274d9..3764401e 100644 --- a/main/xiaozhi-server/plugins_func/functions/get_weather.py +++ b/main/xiaozhi-server/plugins_func/functions/get_weather.py @@ -2,6 +2,7 @@ import requests from bs4 import BeautifulSoup from config.logger import setup_logging from plugins_func.register import register_function, ToolType, ActionResponse, Action +from core.utils.util import get_ip_info TAG = __name__ logger = setup_logging() @@ -11,9 +12,12 @@ GET_WEATHER_FUNCTION_DESC = { "function": { "name": "get_weather", "description": ( - "获取某个地点的天气，用户应提供一个位置，比如用户说杭州天气，参数为：杭州。" + "获取某个地点的天气信息。当用户询问与天气相关的问题（例如'今天的天气怎么样？'、'明天会下雨吗？'、'广州天气如何？'等），" + "或对话中包含'天气'字眼时，调用此功能。用户可以提供具体位置（如城市名），" + "如果未提供位置，则自动获取用户当前位置查询天气。" "如果用户说的是省份，默认用省会城市。如果用户说的不是省份或城市而是一个地名，" "默认用该地所在省份的省会城市。" + "当IP解析失败会使用默认地址" ), "parameters": { "type": "object", @@ -57,6 +61,7 @@ WEATHER_CODE_MAP = { "900": "热", "901": "冷", "999": "未知" } + def fetch_city_info(location, api_key): url = f"https://geoapi.qweather.com/v2/city/lookup?key={api_key}&location={location}&lang=zh" response = requests.get(url, headers=HEADERS).json() @@ -97,27 +102,47 @@ def parse_weather_info(soup): def get_weather(conn, location: str = None, lang: str = "zh_CN"): api_key = conn.config["plugins"]["get_weather"]["api_key"] default_location = conn.config["plugins"]["get_weather"]["default_location"] - location = location or conn.client_ip_info.get("city") or default_location - logger.bind(tag=TAG).debug(f"获取天气: {location}") + print("用户设置的default_location为:", default_location) + client_ip = conn.client_ip + print("用户提供的location为:", location) + # 优先使用用户提供的location参数 + if not location: + # 通过客户端IP解析城市 + if client_ip: + # 动态解析IP对应的城市信息 + ip_info = get_ip_info(client_ip, logger) + print("解析用户IP后的城市为：", ip_info) + location = ip_info.get("city") if ip_info and "city" in ip_info else None + else: + # 若IP解析失败或无IP，使用默认位置 + location = default_location + print("解析失败，将使用默认地址", location) city_info = fetch_city_info(location, api_key) if not city_info: return ActionResponse(Action.REQLLM, f"未找到相关的城市: {location}，请确认地点是否正确", None) - soup = fetch_weather_page(city_info['fxLink']) if not soup: return ActionResponse(Action.REQLLM, None, "请求失败") - city_name, current_abstract, current_basic, temps_list = parse_weather_info(soup) - weather_report = f"根据下列数据，用{lang}回应用户的查询天气请求：\n{city_name}未来7天天气:\n" - for i, (date, weather, high, low) in enumerate(temps_list): - if high and low: - weather_report += f"{date}: {low}到{high}, {weather}\n" - weather_report += ( - f"当前天气: {current_abstract}\n" - f"当前天气参数: {current_basic}\n" - f"(确保只报告指定单日的天气情况，除非未来会出现异常天气；或者用户明确要求想要了解多日天气，如果未指定，默认报告今天的天气。" - "参数为0的值不需要报告给用户，每次都报告体感温度，根据语境选择合适的参数内容告知用户，并对参数给出相应评价)" - ) - return ActionResponse(Action.REQLLM, weather_report, None) \ No newline at end of file + print(f"当前查询的城市名称是: {city_name}") + + weather_report = f"您查询的位置是：{city_name}\n\n当前天气: {current_abstract}\n" + + # 添加有效的当前天气参数 + if current_basic: + weather_report += "详细参数：\n" + for key, value in current_basic.items(): + if value != "0": # 过滤无效值 + weather_report += f" · {key}: {value}\n" + + # 添加7天预报 + weather_report += "\n未来7天预报：\n" + for date, weather, high, low in temps_list: + weather_report += f"{date}: {weather}，气温 {low}~{high}\n" + + # 提示语 + weather_report += "\n（如需某一天的具体天气，请告诉我日期）" + + return ActionResponse(Action.REQLLM, weather_report, None) diff --git a/main/xiaozhi-server/plugins_func/functions/hass_init.py b/main/xiaozhi-server/plugins_func/functions/hass_init.py index 4bd2f2ec..06d7c8bc 100644 --- a/main/xiaozhi-server/plugins_func/functions/hass_init.py +++ b/main/xiaozhi-server/plugins_func/functions/hass_init.py @@ -13,7 +13,7 @@ def append_devices_to_prompt(conn): "functions", [] ) if "hass_get_state" in funcs or "hass_set_state" in funcs: - prompt = "下面是我家智能设备，可以通过homeassistant控制\n" + prompt = "\n下面是我家智能设备列表（位置，设备名，entity_id），可以通过homeassistant控制\n" devices = conn.config["plugins"]["home_assistant"].get("devices", []) if len(devices) == 0: return