SmartBench/CMVR-IOT
6
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: 边缘系统参数封装；新增单个节点调用接口

Browse Source
This commit is contained in:
stream 2025-11-17 19:01:45 +08:00
parent 8f5097bffb
commit 6c25b37827
21 changed files with 342 additions and 345 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
cmvr-iot-admin/src/main/java/com/cmvr/web/controller/api/EdgeCameraController.java
View File

@ -3,13 +3,13 @@ package com.cmvr.web.controller.api;
import com.alibaba.fastjson2.JSON; import com.alibaba.fastjson2.JSON;
import com.cmvr.common.core.controller.BaseController; import com.cmvr.common.core.controller.BaseController;
import com.cmvr.common.core.domain.AjaxResult; import com.cmvr.common.core.domain.AjaxResult;
import com.cmvr.edge.client.model.EdgeCommonVO;
import com.cmvr.edge.client.service.EdgeCameraService; import com.cmvr.edge.client.service.EdgeCameraService;
import io.swagger.annotations.Api; import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation; import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping; 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.bind.annotation.RestController;
@Api(tags = "边缘--相机") @Api(tags = "边缘--相机")
@ -22,64 +22,43 @@ public class EdgeCameraController extends BaseController {
@ApiOperation("获取相机状态") @ApiOperation("获取相机状态")
@GetMapping("/status") @GetMapping("/status")
public AjaxResult status( public AjaxResult status(EdgeCommonVO edgeCommonVO) {
@RequestParam("deviceId") String deviceId, return success(JSON.toJSONString(edgeCameraService.status(edgeCommonVO)));
@RequestParam("terminalId") String terminalId
) {
return success(JSON.toJSONString(edgeCameraService.status(terminalId, deviceId)));
} }
@ApiOperation("开启相机") @ApiOperation("开启相机")
@GetMapping("/start") @GetMapping("/start")
public AjaxResult start( public AjaxResult start(EdgeCommonVO edgeCommonVO) {
@RequestParam("deviceId") String deviceId, return success(edgeCameraService.start(edgeCommonVO));
@RequestParam("terminalId") String terminalId
) {
return success(edgeCameraService.start(terminalId, deviceId));
} }
@ApiOperation("关闭相机") @ApiOperation("关闭相机")
@GetMapping("/stop") @GetMapping("/stop")
public AjaxResult stop( public AjaxResult stop(EdgeCommonVO edgeCommonVO) {
@RequestParam("deviceId") String deviceId, return success(edgeCameraService.stop(edgeCommonVO));
@RequestParam("terminalId") String terminalId
) {
return success(edgeCameraService.stop(terminalId, deviceId));
} }
@ApiOperation("获取图片") @ApiOperation("获取图片")
@GetMapping("/getRGBImage") @GetMapping("/getRGBImage")
public AjaxResult getRGBImage( public AjaxResult getRGBImage(EdgeCommonVO edgeCommonVO) {
@RequestParam("deviceId") String deviceId, return success(edgeCameraService.getRGBImage(edgeCommonVO));
@RequestParam("terminalId") String terminalId
) {
return success(edgeCameraService.getRGBImage(terminalId, deviceId));
} }
@ApiOperation("开始录制视频") @ApiOperation("开始录制视频")
@GetMapping("/startRecording") @GetMapping("/startRecording")
public AjaxResult startRecording( public AjaxResult startRecording(EdgeCommonVO edgeCommonVO) {
@RequestParam("deviceId") String deviceId, return success(edgeCameraService.startRecording(edgeCommonVO));
@RequestParam("terminalId") String terminalId
) {
return success(edgeCameraService.startRecording(terminalId, deviceId));
} }
@ApiOperation("停止录制视频") @ApiOperation("停止录制视频")
@GetMapping("/stopRecording") @GetMapping("/stopRecording")
public AjaxResult stopRecording( public AjaxResult stopRecording(EdgeCommonVO edgeCommonVO) {
@RequestParam("deviceId") String deviceId, return success(edgeCameraService.stopRecording(edgeCommonVO));
@RequestParam("terminalId") String terminalId
) {
return success(edgeCameraService.stopRecording(terminalId, deviceId));
} }
@ApiOperation("获取图片和视频") @ApiOperation("获取图片和视频")
@GetMapping("/getRGBDImages") @GetMapping("/getRGBDImages")
public AjaxResult getRGBDImages( public AjaxResult getRGBDImages(EdgeCommonVO edgeCommonVO) {
@RequestParam("deviceId") String deviceId, return success(edgeCameraService.getRGBDImages(edgeCommonVO));
@RequestParam("terminalId") String terminalId
) {
return success(edgeCameraService.getRGBDImages(terminalId, deviceId));
} }
} }

97
cmvr-iot-admin/src/main/java/com/cmvr/web/controller/api/EdgeMicrophoneController.java
View File

@ -1,17 +1,17 @@
package com.cmvr.web.controller.api; package com.cmvr.web.controller.api;
import cmvr.api.MicrophoneCommand;
import com.cmvr.edge.client.service.EdgeMicrophoneService;
import com.cmvr.common.core.domain.AjaxResult; import com.cmvr.common.core.domain.AjaxResult;
import com.cmvr.edge.client.model.EdgeCommonVO;
import com.cmvr.edge.client.model.microphone.EdgeMicrophoneVolumeVO;
import com.cmvr.edge.client.service.EdgeMicrophoneService;
import io.swagger.annotations.Api; import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation; import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.springframework.security.access.prepost.PreAuthorize; import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*; import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import java.util.HashMap; import org.springframework.web.bind.annotation.RequestMapping;
import java.util.Map; import org.springframework.web.bind.annotation.RestController;
/** /**
* 麦克风管理 * 麦克风管理
@ -27,107 +27,54 @@ public class EdgeMicrophoneController {
@ApiOperation("获取麦克风状态") @ApiOperation("获取麦克风状态")
@PreAuthorize("@ss.hasPermi('system:microphone:query')") @PreAuthorize("@ss.hasPermi('system:microphone:query')")
@GetMapping("/status") @GetMapping("/status")
public AjaxResult getStatus( public AjaxResult getStatus(EdgeCommonVO edgeCommonVO) {
@ApiParam(value = "终端设备ID", required = true) return AjaxResult.success(microphoneService.getStatus(edgeCommonVO));
@RequestParam String terminalId,
@ApiParam(value = "设备ID", required = true)
@RequestParam String deviceId) {
try {
MicrophoneCommand.GetMicStateCommand.Feedback feedback = microphoneService.getStatus(terminalId, deviceId);
MicrophoneCommand.MicState state = feedback.getState();
Map<String, Object> result = new HashMap<>();
Map<String, Object> header = new HashMap<>();
header.put("deviceId", deviceId);
header.put("timestamp", feedback.getHeader().getTimestamp().getSeconds());
result.put("header", header);
Map<String, Object> stateMap = new HashMap<>();
stateMap.put("isInitialized", state.getIsInitialized());
stateMap.put("isRunning", state.getIsRunning());
stateMap.put("isRecording", state.getIsRecording());
stateMap.put("volume", state.getVolume());
stateMap.put("errorMessage", state.getErrorMessage());
result.put("state", stateMap);
return AjaxResult.success(result);
} catch (Exception e) {
return AjaxResult.error("获取麦克风状态失败：" + e.getMessage());
}
} }
@ApiOperation("开始录音") @ApiOperation("开始录音")
@PreAuthorize("@ss.hasPermi('system:microphone:record')") @PreAuthorize("@ss.hasPermi('system:microphone:record')")
@PostMapping("/start") @PostMapping("/start")
public AjaxResult startRecord( public AjaxResult startRecord(EdgeCommonVO edgeCommonVO) {
@ApiParam(value = "终端设备ID", required = true) String filePath = microphoneService.startRecord(edgeCommonVO);
@RequestParam String terminalId, return AjaxResult.success(filePath);
@ApiParam(value = "设备ID", required = true)
@RequestParam String deviceId,
@ApiParam(value = "录音文件路径", required = true)
@RequestParam String filePath) {
microphoneService.startRecord(terminalId, deviceId, filePath);
return AjaxResult.success();
} }
@ApiOperation("停止录音") @ApiOperation("停止录音")
@PreAuthorize("@ss.hasPermi('system:microphone:stop')") @PreAuthorize("@ss.hasPermi('system:microphone:stop')")
@PostMapping("/stop") @PostMapping("/stop")
public AjaxResult stopRecord( public AjaxResult stopRecord(EdgeCommonVO edgeCommonVO) {
@ApiParam(value = "终端设备ID", required = true) microphoneService.stopRecord(edgeCommonVO);
@RequestParam String terminalId,
@ApiParam(value = "设备ID", required = true)
@RequestParam String deviceId) {
microphoneService.stopRecord(terminalId, deviceId);
return AjaxResult.success(); return AjaxResult.success();
} }
@ApiOperation("暂停录音") @ApiOperation("暂停录音")
@PreAuthorize("@ss.hasPermi('system:microphone:pause')") @PreAuthorize("@ss.hasPermi('system:microphone:pause')")
@PostMapping("/pause") @PostMapping("/pause")
public AjaxResult pauseRecord( public AjaxResult pauseRecord(EdgeCommonVO edgeCommonVO) {
@ApiParam(value = "终端设备ID", required = true) microphoneService.pauseRecord(edgeCommonVO);
@RequestParam String terminalId,
@ApiParam(value = "设备ID", required = true)
@RequestParam String deviceId) {
microphoneService.pauseRecord(terminalId, deviceId);
return AjaxResult.success(); return AjaxResult.success();
} }
@ApiOperation("恢复录音") @ApiOperation("恢复录音")
@PreAuthorize("@ss.hasPermi('system:microphone:resume')") @PreAuthorize("@ss.hasPermi('system:microphone:resume')")
@PostMapping("/resume") @PostMapping("/resume")
public AjaxResult resumeRecord( public AjaxResult resumeRecord(EdgeCommonVO edgeCommonVO) {
@ApiParam(value = "终端设备ID", required = true) microphoneService.resumeRecord(edgeCommonVO);
@RequestParam String terminalId,
@ApiParam(value = "设备ID", required = true)
@RequestParam String deviceId) {
microphoneService.resumeRecord(terminalId, deviceId);
return AjaxResult.success(); return AjaxResult.success();
} }
@ApiOperation("设置音量") @ApiOperation("设置音量")
@PreAuthorize("@ss.hasPermi('system:microphone:volume')") @PreAuthorize("@ss.hasPermi('system:microphone:volume')")
@PostMapping("/volume") @PostMapping("/volume")
public AjaxResult setVolume( public AjaxResult setVolume(EdgeMicrophoneVolumeVO edgeMicrophoneVolumeVO) {
@ApiParam(value = "终端设备ID", required = true) microphoneService.setVolume(edgeMicrophoneVolumeVO);
@RequestParam String terminalId,
@ApiParam(value = "设备ID", required = true)
@RequestParam String deviceId,
@ApiParam(value = "音量大小（0-100）", required = true)
@RequestParam int volume) {
microphoneService.setVolume(terminalId, deviceId, volume);
return AjaxResult.success(); return AjaxResult.success();
} }
@ApiOperation("获取音量") @ApiOperation("获取音量")
@PreAuthorize("@ss.hasPermi('system:microphone:volume')") @PreAuthorize("@ss.hasPermi('system:microphone:volume')")
@GetMapping("/volume") @GetMapping("/volume")
public AjaxResult getVolume( public AjaxResult getVolume(EdgeCommonVO edgeCommonVO) {
@ApiParam(value = "终端设备ID", required = true) return AjaxResult.success(microphoneService.getVolume(edgeCommonVO));
@RequestParam String terminalId,
@ApiParam(value = "设备ID", required = true)
@RequestParam String deviceId) {
return AjaxResult.success(microphoneService.getVolume(terminalId, deviceId));
} }
} }

9
cmvr-iot-admin/src/main/java/com/cmvr/web/controller/test/TeFlowController.java
View File

@ -6,9 +6,11 @@ import com.cmvr.test.flow.context.TaskContextManager;
import com.cmvr.test.flow.control.FlowControlService; import com.cmvr.test.flow.control.FlowControlService;
import com.cmvr.test.flow.runtime.engine.FlowTaskRuntimeService; import com.cmvr.test.flow.runtime.engine.FlowTaskRuntimeService;
import com.cmvr.test.model.domain.TeDetectionItem; import com.cmvr.test.model.domain.TeDetectionItem;
import com.cmvr.test.model.vo.FlowActionRequestVO;
import com.cmvr.test.model.vo.TeFlowViewVO; import com.cmvr.test.model.vo.TeFlowViewVO;
import com.cmvr.test.model.vo.TeTaskExecuteNormalVO; import com.cmvr.test.model.vo.TeTaskExecuteNormalVO;
import com.cmvr.test.model.vo.TeTaskExecuteTrailVO; import com.cmvr.test.model.vo.TeTaskExecuteTrailVO;
import com.cmvr.test.service.FlowActionExecutorService;
import com.cmvr.test.service.ITeDetectionItemService; import com.cmvr.test.service.ITeDetectionItemService;
import com.cmvr.test.service.ITeNodeInstService; import com.cmvr.test.service.ITeNodeInstService;
import io.swagger.annotations.Api; import io.swagger.annotations.Api;
@ -34,6 +36,7 @@ public class TeFlowController extends BaseController {
private final FlowTaskRuntimeService flowTaskRuntimeService; private final FlowTaskRuntimeService flowTaskRuntimeService;
private final TaskContextManager taskContextManager; private final TaskContextManager taskContextManager;
private final FlowControlService flowControlService; private final FlowControlService flowControlService;
private final FlowActionExecutorService flowActionExecutorService;
@ApiOperation("流程发布") @ApiOperation("流程发布")
@PostMapping("/publish") @PostMapping("/publish")
@ -86,4 +89,10 @@ public class TeFlowController extends BaseController {
flowControlService.resume(instId); flowControlService.resume(instId);
return AjaxResult.success(); return AjaxResult.success();
} }
@PostMapping("/action")
@ApiOperation("单个节点执行")
public AjaxResult actionExecute(@RequestBody FlowActionRequestVO flowActionRequestVO) {
return AjaxResult.ok(flowActionExecutorService.actionExecute(flowActionRequestVO));
}
} }

12
cmvr-iot-api/cmvr-iot-edge/cmvr-iot-grpc-client/src/main/java/com/cmvr/edge/client/model/microphone/EdgeMicrophoneVolumeVO.java Normal file
View File

@ -0,0 +1,12 @@
package com.cmvr.edge.client.model.microphone;
import com.cmvr.edge.client.model.EdgeCommonVO;
import lombok.Data;
import java.util.List;
@Data
public class EdgeMicrophoneVolumeVO extends EdgeCommonVO {
/** 音量 */
private int volume;
}

23
cmvr-iot-api/cmvr-iot-edge/cmvr-iot-grpc-client/src/main/java/com/cmvr/edge/client/service/EdgeCameraService.java
View File

@ -1,6 +1,7 @@
package com.cmvr.edge.client.service; package com.cmvr.edge.client.service;
import cmvr.api.CameraCommand; import cmvr.api.CameraCommand;
import com.cmvr.edge.client.model.EdgeCommonVO;
import io.grpc.stub.StreamObserver; import io.grpc.stub.StreamObserver;
/** /**
@ -11,47 +12,47 @@ public interface EdgeCameraService {
/** /**
* 获取相机状态 * 获取相机状态
*/ */
public CameraCommand.CameraState status(String terminalId, String deviceId); public CameraCommand.CameraState status(EdgeCommonVO edgeCommonVO);
/** /**
* 校验相机状态 * 校验相机状态
*/ */
public boolean checkStatus(String terminalId, String deviceId); public boolean checkStatus(EdgeCommonVO edgeCommonVO);
/** /**
* 开始相机服务 * 开始相机服务
*/ */
public String start(String terminalId, String deviceId); public String start(EdgeCommonVO edgeCommonVO);
/** /**
* 结束相机服务 * 结束相机服务
*/ */
public String stop(String terminalId, String deviceId); public String stop(EdgeCommonVO edgeCommonVO);
/** /**
* 获取相机图片 * 获取相机图片
*/ */
public String getRGBImage(String terminalId, String deviceId); public String getRGBImage(EdgeCommonVO edgeCommonVO);
/** /**
* 开始录制视频 * 开始录制视频
*/ */
public String startRecording(String terminalId, String deviceId); public String startRecording(EdgeCommonVO edgeCommonVO);
/** /**
* 停止录制视频 * 停止录制视频
*/ */
public String stopRecording(String terminalId, String deviceId); public String stopRecording(EdgeCommonVO edgeCommonVO);
/** /**
* 获取相机图片组 * 获取相机图片组
*/ */
public String getRGBDImages(String terminalId, String deviceId); public String getRGBDImages(EdgeCommonVO edgeCommonVO);
StreamObserver<CameraCommand.GetRGBImageStreamCommand.Request> getRGBImageStream(String terminalId, String deviceId); StreamObserver<CameraCommand.GetRGBImageStreamCommand.Request> getRGBImageStream(EdgeCommonVO edgeCommonVO);
void getDepthImageStream(String terminalId, String deviceId); void getDepthImageStream(EdgeCommonVO edgeCommonVO);
void getRGBDImagesStream(String terminalId, String deviceId); void getRGBDImagesStream(EdgeCommonVO edgeCommonVO);

55
cmvr-iot-api/cmvr-iot-edge/cmvr-iot-grpc-client/src/main/java/com/cmvr/edge/client/service/EdgeMicrophoneService.java
View File

@ -1,6 +1,8 @@
package com.cmvr.edge.client.service; package com.cmvr.edge.client.service;
import cmvr.api.MicrophoneCommand; import cmvr.api.MicrophoneCommand;
import com.cmvr.edge.client.model.EdgeCommonVO;
import com.cmvr.edge.client.model.microphone.EdgeMicrophoneVolumeVO;
/** /**
* 边缘麦克风服务接口 * 边缘麦克风服务接口
@ -10,75 +12,36 @@ import cmvr.api.MicrophoneCommand;
public interface EdgeMicrophoneService { public interface EdgeMicrophoneService {
/** /**
* 获取麦克风当前状态 * 获取麦克风当前状态
* 通过gRPC调用获取麦克风的运行状态，包括是否正在录音、音量等信息
*
* @param terminalId 终端设备ID
* @param deviceId 设备ID
* @return MicState 返回麦克风的当前状态
* @throws RuntimeException 当gRPC调用失败时抛出异常
*/ */
MicrophoneCommand.GetMicStateCommand.Feedback getStatus(String terminalId, String deviceId); String getStatus(EdgeCommonVO edgeCommonVO);
/** /**
* 开始录音 * 开始录音
* 通过gRPC调用开始录音，将录音保存到指定路径
*
* @param terminalId 终端设备ID
* @param deviceId 设备ID
* @param filePath 录音文件的保存路径
* @throws RuntimeException 当gRPC调用失败时抛出异常
*/ */
void startRecord(String terminalId, String deviceId, String filePath); String startRecord(EdgeCommonVO edgeCommonVO);
/** /**
* 停止录音 * 停止录音
* 通过gRPC调用停止麦克风的当前录音
*
* @param terminalId 终端设备ID
* @param deviceId 设备ID
* @throws RuntimeException 当gRPC调用失败时抛出异常
*/ */
void stopRecord(String terminalId, String deviceId); String stopRecord(EdgeCommonVO edgeCommonVO);
/** /**
* 暂停录音 * 暂停录音
* 通过gRPC调用暂停麦克风的当前录音
*
* @param terminalId 终端设备ID
* @param deviceId 设备ID
* @throws RuntimeException 当gRPC调用失败时抛出异常
*/ */
void pauseRecord(String terminalId, String deviceId); void pauseRecord(EdgeCommonVO edgeCommonVO);
/** /**
* 恢复录音 * 恢复录音
* 通过gRPC调用恢复麦克风之前暂停的录音
*
* @param terminalId 终端设备ID
* @param deviceId 设备ID
* @throws RuntimeException 当gRPC调用失败时抛出异常
*/ */
void resumeRecord(String terminalId, String deviceId); void resumeRecord(EdgeCommonVO edgeCommonVO);
/** /**
* 设置麦克风音量 * 设置麦克风音量
* 通过gRPC调用设置麦克风的音量大小
*
* @param terminalId 终端设备ID
* @param deviceId 设备ID
* @param volume 音量大小（0-100）
* @throws RuntimeException 当gRPC调用失败时抛出异常
*/ */
void setVolume(String terminalId, String deviceId, int volume); void setVolume(EdgeMicrophoneVolumeVO edgeMicrophoneVolumeVO);
/** /**
* 获取当前音量 * 获取当前音量
* 通过gRPC调用获取麦克风的当前音量大小
*
* @param terminalId 终端设备ID
* @param deviceId 设备ID
* @return int 返回当前音量大小（0-100）
* @throws RuntimeException 当gRPC调用失败时抛出异常
*/ */
int getVolume(String terminalId, String deviceId); int getVolume(EdgeCommonVO edgeCommonVO);
} }

2
cmvr-iot-api/cmvr-iot-edge/cmvr-iot-grpc-client/src/main/java/com/cmvr/edge/client/service/EdgeSpeakerService.java
View File

@ -30,7 +30,7 @@ public interface EdgeSpeakerService {
* @param audioPath 音频文件的路径 * @param audioPath 音频文件的路径
* @throws RuntimeException 当gRPC调用失败时抛出异常 * @throws RuntimeException 当gRPC调用失败时抛出异常
*/ */
void playAudio(String terminalId, String deviceId, String audioPath); String playAudio(String terminalId, String deviceId, String audioPath);
/** /**
* 停止当前播放 * 停止当前播放

73
cmvr-iot-api/cmvr-iot-edge/cmvr-iot-grpc-client/src/main/java/com/cmvr/edge/client/service/impl/EdgeCameraServiceImpl.java
View File

@ -10,6 +10,7 @@ import com.cmvr.common.enums.FileType;
import com.cmvr.common.exception.GlobalException; import com.cmvr.common.exception.GlobalException;
import com.cmvr.edge.client.file.ByteArrayMultipartFile; import com.cmvr.edge.client.file.ByteArrayMultipartFile;
import com.cmvr.edge.client.manage.GrpcServiceManager; import com.cmvr.edge.client.manage.GrpcServiceManager;
import com.cmvr.edge.client.model.EdgeCommonVO;
import com.cmvr.edge.client.service.EdgeCameraService; import com.cmvr.edge.client.service.EdgeCameraService;
import com.cmvr.edge.client.service.EdgeStreamService; import com.cmvr.edge.client.service.EdgeStreamService;
import com.cmvr.edge.client.utils.EdgeCommonUtil; import com.cmvr.edge.client.utils.EdgeCommonUtil;
@ -61,17 +62,17 @@ public class EdgeCameraServiceImpl implements EdgeCameraService, EdgeStreamServi
private final MessagePushService messagePushService; private final MessagePushService messagePushService;
@Override @Override
public CameraCommand.CameraState status(String terminalId, String deviceId) { public CameraCommand.CameraState status(EdgeCommonVO edgeCommonVO) {
CameraServiceGrpc.CameraServiceBlockingStub stub = grpcServiceManager.getGrpcClient(terminalId, CameraServiceGrpc.CameraServiceBlockingStub.class); CameraServiceGrpc.CameraServiceBlockingStub stub = grpcServiceManager.getGrpcClient(edgeCommonVO.getTerminalId(), CameraServiceGrpc.CameraServiceBlockingStub.class);
CameraCommand.GetCameraStateCommand.Request request = CameraCommand.GetCameraStateCommand.Request.newBuilder() CameraCommand.GetCameraStateCommand.Request request = CameraCommand.GetCameraStateCommand.Request.newBuilder()
.setHeader(EdgeCommonUtil.buildRequest(deviceId)) .setHeader(EdgeCommonUtil.buildRequest(edgeCommonVO.getDeviceId()))
.build(); .build();
return executeGrpcCall(() -> stub.getStatus(request)).getState(); return executeGrpcCall(() -> stub.getStatus(request)).getState();
} }
@Override @Override
public boolean checkStatus(String terminalId, String deviceId) { public boolean checkStatus(EdgeCommonVO edgeCommonVO) {
CameraCommand.CameraState state = status(terminalId, deviceId); CameraCommand.CameraState state = status(edgeCommonVO);
if (state.getIsError()) { if (state.getIsError()) {
throw new GlobalException("Camera is in error state"); throw new GlobalException("Camera is in error state");
} }
@ -79,34 +80,34 @@ public class EdgeCameraServiceImpl implements EdgeCameraService, EdgeStreamServi
} }
@Override @Override
public String start(String terminalId, String deviceId) { public String start(EdgeCommonVO edgeCommonVO) {
CameraServiceGrpc.CameraServiceBlockingStub stub = grpcServiceManager.getGrpcClient(terminalId, CameraServiceGrpc.CameraServiceBlockingStub.class); CameraServiceGrpc.CameraServiceBlockingStub stub = grpcServiceManager.getGrpcClient(edgeCommonVO.getTerminalId(), CameraServiceGrpc.CameraServiceBlockingStub.class);
CameraCommand.StartCameraCommand.Request request = CameraCommand.StartCameraCommand.Request.newBuilder() CameraCommand.StartCameraCommand.Request request = CameraCommand.StartCameraCommand.Request.newBuilder()
.setHeader(EdgeCommonUtil.buildRequest(deviceId)) .setHeader(EdgeCommonUtil.buildRequest(edgeCommonVO.getDeviceId()))
.build(); .build();
Common.CommandHeader.Feedback header = executeGrpcCall(() -> stub.startCamera(request)).getHeader(); Common.CommandHeader.Feedback header = executeGrpcCall(() -> stub.startCamera(request)).getHeader();
return JSON.toJSONString(header); return JSON.toJSONString(header);
} }
@Override @Override
public String stop(String terminalId, String deviceId) { public String stop(EdgeCommonVO edgeCommonVO) {
CameraServiceGrpc.CameraServiceBlockingStub stub = grpcServiceManager.getGrpcClient(terminalId, CameraServiceGrpc.CameraServiceBlockingStub.class); CameraServiceGrpc.CameraServiceBlockingStub stub = grpcServiceManager.getGrpcClient(edgeCommonVO.getTerminalId(), CameraServiceGrpc.CameraServiceBlockingStub.class);
CameraCommand.StopCameraCommand.Request request = CameraCommand.StopCameraCommand.Request.newBuilder() CameraCommand.StopCameraCommand.Request request = CameraCommand.StopCameraCommand.Request.newBuilder()
.setHeader(EdgeCommonUtil.buildRequest(deviceId)) .setHeader(EdgeCommonUtil.buildRequest(edgeCommonVO.getDeviceId()))
.build(); .build();
Common.CommandHeader.Feedback header = executeGrpcCall(() -> stub.stopCamera(request)).getHeader(); Common.CommandHeader.Feedback header = executeGrpcCall(() -> stub.stopCamera(request)).getHeader();
return JSON.toJSONString(header); return JSON.toJSONString(header);
} }
@Override @Override
public String getRGBImage(String terminalId, String deviceId) { public String getRGBImage(EdgeCommonVO edgeCommonVO) {
if (!checkStatus(terminalId, deviceId)) { if (!checkStatus(edgeCommonVO)) {
start(terminalId, deviceId); start(edgeCommonVO);
} }
CameraServiceGrpc.CameraServiceBlockingStub stub = grpcServiceManager.getGrpcClient(terminalId, CameraServiceGrpc.CameraServiceBlockingStub.class); CameraServiceGrpc.CameraServiceBlockingStub stub = grpcServiceManager.getGrpcClient(edgeCommonVO.getTerminalId(), CameraServiceGrpc.CameraServiceBlockingStub.class);
CameraCommand.GetRGBImageCommand.Request request = CameraCommand.GetRGBImageCommand.Request.newBuilder() CameraCommand.GetRGBImageCommand.Request request = CameraCommand.GetRGBImageCommand.Request.newBuilder()
.setHeader(EdgeCommonUtil.buildRequest(deviceId)) .setHeader(EdgeCommonUtil.buildRequest(edgeCommonVO.getDeviceId()))
.build(); .build();
CameraCommand.GetRGBImageCommand.Feedback feedback = executeGrpcCall(() -> stub.getRGBImage(request)); CameraCommand.GetRGBImageCommand.Feedback feedback = executeGrpcCall(() -> stub.getRGBImage(request));
CameraCommand.FrameData frame = feedback.getColorFrame(); CameraCommand.FrameData frame = feedback.getColorFrame();
@ -127,15 +128,15 @@ public class EdgeCameraServiceImpl implements EdgeCameraService, EdgeStreamServi
} }
@Override @Override
public String startRecording(String terminalId, String deviceId) { public String startRecording(EdgeCommonVO edgeCommonVO) {
if (!checkStatus(terminalId, deviceId)) { if (!checkStatus(edgeCommonVO)) {
start(terminalId, deviceId); start(edgeCommonVO);
} }
CameraServiceGrpc.CameraServiceBlockingStub stub = grpcServiceManager.getGrpcClient(terminalId, CameraServiceGrpc.CameraServiceBlockingStub.class); CameraServiceGrpc.CameraServiceBlockingStub stub = grpcServiceManager.getGrpcClient(edgeCommonVO.getTerminalId(), CameraServiceGrpc.CameraServiceBlockingStub.class);
String videoPath = StrUtil.format("{}/{}_{}.mp4", "/home/share/assets/video", deviceId, System.currentTimeMillis()); String videoPath = StrUtil.format("{}/{}_{}.mp4", "/home/share/assets/video", edgeCommonVO.getDeviceId(), System.currentTimeMillis());
CameraCommand.StartCameraRecordingCommand.Request request = CameraCommand.StartCameraRecordingCommand.Request.newBuilder() CameraCommand.StartCameraRecordingCommand.Request request = CameraCommand.StartCameraRecordingCommand.Request.newBuilder()
.setHeader(EdgeCommonUtil.buildRequest(deviceId)) .setHeader(EdgeCommonUtil.buildRequest(edgeCommonVO.getDeviceId()))
.setVideoPath(videoPath) .setVideoPath(videoPath)
.build(); .build();
executeGrpcCall(() -> stub.startRecording(request)); executeGrpcCall(() -> stub.startRecording(request));
@ -143,24 +144,24 @@ public class EdgeCameraServiceImpl implements EdgeCameraService, EdgeStreamServi
} }
@Override @Override
public String stopRecording(String terminalId, String deviceId) { public String stopRecording(EdgeCommonVO edgeCommonVO) {
CameraServiceGrpc.CameraServiceBlockingStub stub = grpcServiceManager.getGrpcClient(terminalId, CameraServiceGrpc.CameraServiceBlockingStub.class); CameraServiceGrpc.CameraServiceBlockingStub stub = grpcServiceManager.getGrpcClient(edgeCommonVO.getTerminalId(), CameraServiceGrpc.CameraServiceBlockingStub.class);
CameraCommand.StopCameraRecordingCommand.Request request = CameraCommand.StopCameraRecordingCommand.Request.newBuilder() CameraCommand.StopCameraRecordingCommand.Request request = CameraCommand.StopCameraRecordingCommand.Request.newBuilder()
.setHeader(EdgeCommonUtil.buildRequest(deviceId)) .setHeader(EdgeCommonUtil.buildRequest(edgeCommonVO.getDeviceId()))
.build(); .build();
Common.CommandHeader.Feedback header = executeGrpcCall(() -> stub.stopRecording(request)).getHeader(); Common.CommandHeader.Feedback header = executeGrpcCall(() -> stub.stopRecording(request)).getHeader();
return JSON.toJSONString(header); return JSON.toJSONString(header);
} }
@Override @Override
public String getRGBDImages(String terminalId, String deviceId) { public String getRGBDImages(EdgeCommonVO edgeCommonVO) {
if (!checkStatus(terminalId, deviceId)) { if (!checkStatus(edgeCommonVO)) {
start(terminalId, deviceId); start(edgeCommonVO);
} }
CameraServiceGrpc.CameraServiceBlockingStub stub = grpcServiceManager.getGrpcClient(terminalId, CameraServiceGrpc.CameraServiceBlockingStub.class); CameraServiceGrpc.CameraServiceBlockingStub stub = grpcServiceManager.getGrpcClient(edgeCommonVO.getTerminalId(), CameraServiceGrpc.CameraServiceBlockingStub.class);
CameraCommand.GetRGBDImagesCommand.Request request = CameraCommand.GetRGBDImagesCommand.Request.newBuilder() CameraCommand.GetRGBDImagesCommand.Request request = CameraCommand.GetRGBDImagesCommand.Request.newBuilder()
.setHeader(EdgeCommonUtil.buildRequest(deviceId)) .setHeader(EdgeCommonUtil.buildRequest(edgeCommonVO.getDeviceId()))
.build(); .build();
CameraCommand.GetRGBDImagesCommand.Feedback feedback = executeGrpcCall(() -> stub.getRGBDImages(request)); CameraCommand.GetRGBDImagesCommand.Feedback feedback = executeGrpcCall(() -> stub.getRGBDImages(request));
@ -197,10 +198,12 @@ public class EdgeCameraServiceImpl implements EdgeCameraService, EdgeStreamServi
private boolean isCollectingFrames = false; private boolean isCollectingFrames = false;
@Override @Override
public StreamObserver<CameraCommand.GetRGBImageStreamCommand.Request> getRGBImageStream(String terminalId, String deviceId) { public StreamObserver<CameraCommand.GetRGBImageStreamCommand.Request> getRGBImageStream(EdgeCommonVO edgeCommonVO) {
if (!checkStatus(terminalId, deviceId)) { if (!checkStatus(edgeCommonVO)) {
start(terminalId, deviceId); start(edgeCommonVO);
} }
String terminalId = edgeCommonVO.getTerminalId();
String deviceId = edgeCommonVO.getDeviceId();
CameraServiceGrpc.CameraServiceStub stub = grpcServiceManager.getGrpcClient(terminalId, CameraServiceGrpc.CameraServiceStub.class); CameraServiceGrpc.CameraServiceStub stub = grpcServiceManager.getGrpcClient(terminalId, CameraServiceGrpc.CameraServiceStub.class);
// 创建StreamObserver来处理响应 // 创建StreamObserver来处理响应
StreamObserver<CameraCommand.GetRGBImageStreamCommand.Feedback> responseObserver = new StreamObserver<CameraCommand.GetRGBImageStreamCommand.Feedback>() { StreamObserver<CameraCommand.GetRGBImageStreamCommand.Feedback> responseObserver = new StreamObserver<CameraCommand.GetRGBImageStreamCommand.Feedback>() {
@ -262,12 +265,12 @@ public class EdgeCameraServiceImpl implements EdgeCameraService, EdgeStreamServi
} }
@Override @Override
public void getDepthImageStream(String terminalId, String deviceId) { public void getDepthImageStream(EdgeCommonVO edgeCommonVO) {
} }
@Override @Override
public void getRGBDImagesStream(String terminalId, String deviceId) { public void getRGBDImagesStream(EdgeCommonVO edgeCommonVO) {
} }

92
cmvr-iot-api/cmvr-iot-edge/cmvr-iot-grpc-client/src/main/java/com/cmvr/edge/client/service/impl/EdgeMicrophoneServiceImpl.java
View File

@ -1,17 +1,18 @@
package com.cmvr.edge.client.service.impl; package com.cmvr.edge.client.service.impl;
import cmvr.api.Common;
import cmvr.api.MicrophoneCommand;
import cmvr.api.MicPhoneServiceGrpc; import cmvr.api.MicPhoneServiceGrpc;
import cmvr.api.MicrophoneCommand;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson2.JSON;
import com.cmvr.edge.client.manage.GrpcServiceManager; import com.cmvr.edge.client.manage.GrpcServiceManager;
import com.cmvr.edge.client.model.EdgeCommonVO;
import com.cmvr.edge.client.model.microphone.EdgeMicrophoneVolumeVO;
import com.cmvr.edge.client.service.EdgeMicrophoneService; import com.cmvr.edge.client.service.EdgeMicrophoneService;
import com.cmvr.edge.client.utils.EdgeCommonUtil; import com.cmvr.edge.client.utils.EdgeCommonUtil;
import io.grpc.ManagedChannel;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import com.google.protobuf.Timestamp;
/** /**
* 边缘麦克风服务实现类 * 边缘麦克风服务实现类
@ -36,21 +37,17 @@ public class EdgeMicrophoneServiceImpl implements EdgeMicrophoneService {
/** /**
* 获取麦克风当前状态 * 获取麦克风当前状态
* 通过gRPC调用获取麦克风的运行状态，包括是否正在录音、音量等信息 * 通过gRPC调用获取麦克风的运行状态，包括是否正在录音、音量等信息
*
* @param terminalId 终端设备ID
* @param deviceId 设备ID
* @return MicState 返回麦克风的当前状态
* @throws RuntimeException 当gRPC调用失败时抛出异常
*/ */
@Override @Override
public MicrophoneCommand.GetMicStateCommand.Feedback getStatus(String terminalId, String deviceId) { public String getStatus(EdgeCommonVO edgeCommonVO) {
try { try {
MicPhoneServiceGrpc.MicPhoneServiceBlockingStub stub = grpcServiceManager.getGrpcClient(terminalId, MicPhoneServiceGrpc.MicPhoneServiceBlockingStub.class); MicPhoneServiceGrpc.MicPhoneServiceBlockingStub stub = grpcServiceManager.getGrpcClient(edgeCommonVO.getTerminalId(), MicPhoneServiceGrpc.MicPhoneServiceBlockingStub.class);
MicrophoneCommand.GetMicStateCommand.Request request = MicrophoneCommand.GetMicStateCommand.Request.newBuilder() MicrophoneCommand.GetMicStateCommand.Request request = MicrophoneCommand.GetMicStateCommand.Request.newBuilder()
.setHeader(EdgeCommonUtil.buildRequest(deviceId)) .setHeader(EdgeCommonUtil.buildRequest(edgeCommonVO.getDeviceId()))
.build(); .build();
// 直接返回完整的 Feedback // 直接返回完整的 Feedback
return stub.getStatus(request); MicrophoneCommand.GetMicStateCommand.Feedback feedback = stub.getStatus(request);
return JSON.toJSONString(feedback.getState());
} catch (Exception e) { } catch (Exception e) {
logger.error("获取麦克风状态失败", e); logger.error("获取麦克风状态失败", e);
throw new RuntimeException("获取麦克风状态失败", e); throw new RuntimeException("获取麦克风状态失败", e);
@ -60,17 +57,14 @@ public class EdgeMicrophoneServiceImpl implements EdgeMicrophoneService {
/** /**
* 开始录音 * 开始录音
* 通过gRPC调用开始录音，将录音保存到指定路径 * 通过gRPC调用开始录音，将录音保存到指定路径
*
* @param terminalId 终端设备ID
* @param deviceId 设备ID
* @param filePath 录音文件的保存路径
* @throws RuntimeException 当gRPC调用失败时抛出异常
*/ */
@Override @Override
public void startRecord(String terminalId, String deviceId, String filePath) { public String startRecord(EdgeCommonVO edgeCommonVO) {
String deviceId = edgeCommonVO.getDeviceId();
try { try {
// 获取gRPC客户端存根 // 获取gRPC客户端存根
MicPhoneServiceGrpc.MicPhoneServiceBlockingStub stub = grpcServiceManager.getGrpcClient(terminalId, MicPhoneServiceGrpc.MicPhoneServiceBlockingStub.class); MicPhoneServiceGrpc.MicPhoneServiceBlockingStub stub = grpcServiceManager.getGrpcClient(edgeCommonVO.getTerminalId(), MicPhoneServiceGrpc.MicPhoneServiceBlockingStub.class);
String filePath = StrUtil.format("{}/{}_{}.mp4", "/home/share/assets/video", deviceId, System.currentTimeMillis());
// 构建请求消息 // 构建请求消息
MicrophoneCommand.StartMicRecordingCommand.Request request = MicrophoneCommand.StartMicRecordingCommand.Request.newBuilder() MicrophoneCommand.StartMicRecordingCommand.Request request = MicrophoneCommand.StartMicRecordingCommand.Request.newBuilder()
@ -80,6 +74,7 @@ public class EdgeMicrophoneServiceImpl implements EdgeMicrophoneService {
// 发送请求 // 发送请求
stub.startRecord(request); stub.startRecord(request);
return filePath;
} catch (Exception e) { } catch (Exception e) {
logger.error("开始录音失败", e); logger.error("开始录音失败", e);
throw new RuntimeException("开始录音失败", e); throw new RuntimeException("开始录音失败", e);
@ -89,24 +84,21 @@ public class EdgeMicrophoneServiceImpl implements EdgeMicrophoneService {
/** /**
* 停止录音 * 停止录音
* 通过gRPC调用停止麦克风的当前录音 * 通过gRPC调用停止麦克风的当前录音
*
* @param terminalId 终端设备ID
* @param deviceId 设备ID
* @throws RuntimeException 当gRPC调用失败时抛出异常
*/ */
@Override @Override
public void stopRecord(String terminalId, String deviceId) { public String stopRecord(EdgeCommonVO edgeCommonVO) {
try { try {
// 获取gRPC客户端存根 // 获取gRPC客户端存根
MicPhoneServiceGrpc.MicPhoneServiceBlockingStub stub = grpcServiceManager.getGrpcClient(terminalId, MicPhoneServiceGrpc.MicPhoneServiceBlockingStub.class); MicPhoneServiceGrpc.MicPhoneServiceBlockingStub stub = grpcServiceManager.getGrpcClient(edgeCommonVO.getTerminalId(), MicPhoneServiceGrpc.MicPhoneServiceBlockingStub.class);
// 构建请求消息 // 构建请求消息
MicrophoneCommand.StopMicRecordingCommand.Request request = MicrophoneCommand.StopMicRecordingCommand.Request.newBuilder() MicrophoneCommand.StopMicRecordingCommand.Request request = MicrophoneCommand.StopMicRecordingCommand.Request.newBuilder()
.setHeader(EdgeCommonUtil.buildRequest(deviceId)) .setHeader(EdgeCommonUtil.buildRequest(edgeCommonVO.getDeviceId()))
.build(); .build();
// 发送请求 // 发送请求
stub.stopRecord(request); MicrophoneCommand.StopMicRecordingCommand.Feedback feedback = stub.stopRecord(request);
return JSON.toJSONString(feedback.getHeader());
} catch (Exception e) { } catch (Exception e) {
logger.error("停止录音失败", e); logger.error("停止录音失败", e);
throw new RuntimeException("停止录音失败", e); throw new RuntimeException("停止录音失败", e);
@ -116,20 +108,16 @@ public class EdgeMicrophoneServiceImpl implements EdgeMicrophoneService {
/** /**
* 暂停录音 * 暂停录音
* 通过gRPC调用暂停麦克风的当前录音 * 通过gRPC调用暂停麦克风的当前录音
*
* @param terminalId 终端设备ID
* @param deviceId 设备ID
* @throws RuntimeException 当gRPC调用失败时抛出异常
*/ */
@Override @Override
public void pauseRecord(String terminalId, String deviceId) { public void pauseRecord(EdgeCommonVO edgeCommonVO) {
try { try {
// 获取gRPC客户端存根 // 获取gRPC客户端存根
MicPhoneServiceGrpc.MicPhoneServiceBlockingStub stub = grpcServiceManager.getGrpcClient(terminalId, MicPhoneServiceGrpc.MicPhoneServiceBlockingStub.class); MicPhoneServiceGrpc.MicPhoneServiceBlockingStub stub = grpcServiceManager.getGrpcClient(edgeCommonVO.getTerminalId(), MicPhoneServiceGrpc.MicPhoneServiceBlockingStub.class);
// 构建请求消息 // 构建请求消息
MicrophoneCommand.PauseMicRecordingCommand.Request request = MicrophoneCommand.PauseMicRecordingCommand.Request.newBuilder() MicrophoneCommand.PauseMicRecordingCommand.Request request = MicrophoneCommand.PauseMicRecordingCommand.Request.newBuilder()
.setHeader(EdgeCommonUtil.buildRequest(deviceId)) .setHeader(EdgeCommonUtil.buildRequest(edgeCommonVO.getDeviceId()))
.build(); .build();
// 发送请求 // 发送请求
@ -143,20 +131,16 @@ public class EdgeMicrophoneServiceImpl implements EdgeMicrophoneService {
/** /**
* 恢复录音 * 恢复录音
* 通过gRPC调用恢复麦克风之前暂停的录音 * 通过gRPC调用恢复麦克风之前暂停的录音
*
* @param terminalId 终端设备ID
* @param deviceId 设备ID
* @throws RuntimeException 当gRPC调用失败时抛出异常
*/ */
@Override @Override
public void resumeRecord(String terminalId, String deviceId) { public void resumeRecord(EdgeCommonVO edgeCommonVO) {
try { try {
// 获取gRPC客户端存根 // 获取gRPC客户端存根
MicPhoneServiceGrpc.MicPhoneServiceBlockingStub stub = grpcServiceManager.getGrpcClient(terminalId, MicPhoneServiceGrpc.MicPhoneServiceBlockingStub.class); MicPhoneServiceGrpc.MicPhoneServiceBlockingStub stub = grpcServiceManager.getGrpcClient(edgeCommonVO.getTerminalId(), MicPhoneServiceGrpc.MicPhoneServiceBlockingStub.class);
// 构建请求消息 // 构建请求消息
MicrophoneCommand.ResumeMicRecordingCommand.Request request = MicrophoneCommand.ResumeMicRecordingCommand.Request.newBuilder() MicrophoneCommand.ResumeMicRecordingCommand.Request request = MicrophoneCommand.ResumeMicRecordingCommand.Request.newBuilder()
.setHeader(EdgeCommonUtil.buildRequest(deviceId)) .setHeader(EdgeCommonUtil.buildRequest(edgeCommonVO.getDeviceId()))
.build(); .build();
// 发送请求 // 发送请求
@ -170,22 +154,17 @@ public class EdgeMicrophoneServiceImpl implements EdgeMicrophoneService {
/** /**
* 设置麦克风音量 * 设置麦克风音量
* 通过gRPC调用设置麦克风的音量大小 * 通过gRPC调用设置麦克风的音量大小
*
* @param terminalId 终端设备ID
* @param deviceId 设备ID
* @param volume 音量大小（0-100）
* @throws RuntimeException 当gRPC调用失败时抛出异常
*/ */
@Override @Override
public void setVolume(String terminalId, String deviceId, int volume) { public void setVolume(EdgeMicrophoneVolumeVO edgeMicrophoneVolumeVO) {
try { try {
// 获取gRPC客户端存根 // 获取gRPC客户端存根
MicPhoneServiceGrpc.MicPhoneServiceBlockingStub stub = grpcServiceManager.getGrpcClient(terminalId, MicPhoneServiceGrpc.MicPhoneServiceBlockingStub.class); MicPhoneServiceGrpc.MicPhoneServiceBlockingStub stub = grpcServiceManager.getGrpcClient(edgeMicrophoneVolumeVO.getTerminalId(), MicPhoneServiceGrpc.MicPhoneServiceBlockingStub.class);
// 构建请求消息 // 构建请求消息
MicrophoneCommand.SetMicPhoneVolumeCommand.Request request = MicrophoneCommand.SetMicPhoneVolumeCommand.Request.newBuilder() MicrophoneCommand.SetMicPhoneVolumeCommand.Request request = MicrophoneCommand.SetMicPhoneVolumeCommand.Request.newBuilder()
.setHeader(EdgeCommonUtil.buildRequest(deviceId)) .setHeader(EdgeCommonUtil.buildRequest(edgeMicrophoneVolumeVO.getDeviceId()))
.setVolume(volume) .setVolume(edgeMicrophoneVolumeVO.getVolume())
.build(); .build();
// 发送请求 // 发送请求
@ -199,21 +178,16 @@ public class EdgeMicrophoneServiceImpl implements EdgeMicrophoneService {
/** /**
* 获取当前音量 * 获取当前音量
* 通过gRPC调用获取麦克风的当前音量大小 * 通过gRPC调用获取麦克风的当前音量大小
*
* @param terminalId 终端设备ID
* @param deviceId 设备ID
* @return int 返回当前音量大小（0-100）
* @throws RuntimeException 当gRPC调用失败时抛出异常
*/ */
@Override @Override
public int getVolume(String terminalId, String deviceId) { public int getVolume(EdgeCommonVO edgeCommonVO) {
try { try {
// 获取gRPC客户端存根 // 获取gRPC客户端存根
MicPhoneServiceGrpc.MicPhoneServiceBlockingStub stub = grpcServiceManager.getGrpcClient(terminalId, MicPhoneServiceGrpc.MicPhoneServiceBlockingStub.class); MicPhoneServiceGrpc.MicPhoneServiceBlockingStub stub = grpcServiceManager.getGrpcClient(edgeCommonVO.getTerminalId(), MicPhoneServiceGrpc.MicPhoneServiceBlockingStub.class);
// 构建请求消息 // 构建请求消息
MicrophoneCommand.GetMicPhoneVolumeCommand.Request request = MicrophoneCommand.GetMicPhoneVolumeCommand.Request.newBuilder() MicrophoneCommand.GetMicPhoneVolumeCommand.Request request = MicrophoneCommand.GetMicPhoneVolumeCommand.Request.newBuilder()
.setHeader(EdgeCommonUtil.buildRequest(deviceId)) .setHeader(EdgeCommonUtil.buildRequest(edgeCommonVO.getDeviceId()))
.build(); .build();
// 发送请求并获取响应 // 发送请求并获取响应

3
cmvr-iot-api/cmvr-iot-edge/cmvr-iot-grpc-client/src/main/java/com/cmvr/edge/client/service/impl/EdgeSpeakerServiceImpl.java
View File

@ -70,7 +70,7 @@ public class EdgeSpeakerServiceImpl implements EdgeSpeakerService {
* @throws RuntimeException 当gRPC调用失败时抛出异常 * @throws RuntimeException 当gRPC调用失败时抛出异常
*/ */
@Override @Override
public void playAudio(String terminalId, String deviceId, String audioPath) { public String playAudio(String terminalId, String deviceId, String audioPath) {
try { try {
// 获取gRPC客户端存根 // 获取gRPC客户端存根
SpeakerServiceGrpc.SpeakerServiceBlockingStub stub = grpcServiceManager.getGrpcClient(terminalId, SpeakerServiceGrpc.SpeakerServiceBlockingStub.class); SpeakerServiceGrpc.SpeakerServiceBlockingStub stub = grpcServiceManager.getGrpcClient(terminalId, SpeakerServiceGrpc.SpeakerServiceBlockingStub.class);
@ -86,6 +86,7 @@ public class EdgeSpeakerServiceImpl implements EdgeSpeakerService {
if (!feedback.getHeader().getSuccess()) { if (!feedback.getHeader().getSuccess()) {
throw new RuntimeException((feedback.getHeader().getErrorMessage())); throw new RuntimeException((feedback.getHeader().getErrorMessage()));
} }
return JSON.toJSONString(feedback.getHeader());
} catch (Exception e) { } catch (Exception e) {
logger.error("播放音频失败", e); logger.error("播放音频失败", e);
throw new RuntimeException("播放音频失败", e); throw new RuntimeException("播放音频失败", e);

18
cmvr-iot-test/src/main/java/com/cmvr/test/enums/ActionEnum.java
View File

@ -40,8 +40,13 @@ public enum ActionEnum {
MICROPHONE_STOP("EDGE", "MICROPHONE_STOP", "停止麦克风"), MICROPHONE_STOP("EDGE", "MICROPHONE_STOP", "停止麦克风"),
// ---------------扬声器（人工嘴）--------------- // ---------------扬声器（人工嘴）---------------
SPEAKER_PLAYAUDIO("EDGE", "SPEAKER_PLAYAUDIO", "播放音频"), // ---------------语料---------------
CORPUS_PLAY("EDGE", "CORPUS_PLAY", "播放语料"), VI_CORPUS_WAKE("EDGE", "VI_CORPUS_WAKE", "唤醒语料处理"),
VI_CORPUS_SINGLE("EDGE", "VI_CORPUS_SINGLE", "测试语料-单次对话语料处理"),
VI_CORPUS_CONTINUOUS("EDGE", "VI_CORPUS_CONTINUOUS", "测试语料-连续对话语料处理"),
VI_PLAY_CORPUS("EDGE", "VI_PLAY_CORPUS", "播放语料"),
// ---------------方案---------------
VI_SCHEME("EDGE", "VI_SCHEME", "语音交互-方案处理"),
// ---------------机械臂--------------- // ---------------机械臂---------------
TOUCH("EDGE", "TOUCH", "触控"), TOUCH("EDGE", "TOUCH", "触控"),
@ -57,15 +62,6 @@ public enum ActionEnum {
INTENT_RECOGNITION("LLM", "INTENT_RECOGNITION", "意图识别"), INTENT_RECOGNITION("LLM", "INTENT_RECOGNITION", "意图识别"),
GENERATE_ADVANCED_AUDIO("LLM", "GENERATE_ADVANCED_AUDIO", "tts语音合成"), GENERATE_ADVANCED_AUDIO("LLM", "GENERATE_ADVANCED_AUDIO", "tts语音合成"),
// 语音交互
// ---------------语料---------------
VI_CORPUS_WAKE("VI", "VI_CORPUS_WAKE", "唤醒语料处理"),
VI_CORPUS_SINGLE("VI", "VI_CORPUS_SINGLE", "测试语料-单次对话语料处理"),
VI_CORPUS_CONTINUOUS("VI", "VI_CORPUS_CONTINUOUS", "测试语料-连续对话语料处理"),
VI_PLAY_CORPUS("VI", "VI_PLAY_CORPUS", "播放语料"),
// ---------------方案---------------
VI_SCHEME("VI", "VI_SCHEME", "语音交互-方案处理"),
; ;

9
cmvr-iot-test/src/main/java/com/cmvr/test/flow/runtime/operator/edge/EdgeCameraOperateService.java
View File

@ -4,6 +4,7 @@ import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson2.JSONObject; import com.alibaba.fastjson2.JSONObject;
import com.cmvr.common.enums.FileType; import com.cmvr.common.enums.FileType;
import com.cmvr.common.exception.GlobalException; import com.cmvr.common.exception.GlobalException;
import com.cmvr.edge.client.model.EdgeCommonVO;
import com.cmvr.edge.client.service.EdgeCameraService; import com.cmvr.edge.client.service.EdgeCameraService;
import com.cmvr.test.enums.ActionEnum; import com.cmvr.test.enums.ActionEnum;
import com.cmvr.test.flow.context.TaskInstHolder; import com.cmvr.test.flow.context.TaskInstHolder;
@ -41,6 +42,10 @@ public class EdgeCameraOperateService implements EdgeOperateService {
JSONObject output = new JSONObject(); JSONObject output = new JSONObject();
EdgeCommonVO edgeCommonVO = new EdgeCommonVO();
edgeCommonVO.setDeviceId(deviceId);
edgeCommonVO.setTerminalId(terminalId);
switch (action) { switch (action) {
case CAMERA_START: { case CAMERA_START: {
// String result = edgeCameraService.start(terminalId, deviceId); // String result = edgeCameraService.start(terminalId, deviceId);
@ -84,7 +89,7 @@ public class EdgeCameraOperateService implements EdgeOperateService {
} }
case CAMERA_RECORDING_START: { case CAMERA_RECORDING_START: {
String videoUrl = edgeCameraService.startRecording(terminalId, deviceId); String videoUrl = edgeCameraService.startRecording(edgeCommonVO);
videoUrl = StrUtil.format("{}/{}", "http://10.148.108.162/system/video", StrUtil.subAfter(videoUrl, "/", true)); videoUrl = StrUtil.format("{}/{}", "http://10.148.108.162/system/video", StrUtil.subAfter(videoUrl, "/", true));
// String videoUrl = "http://10.148.108.162/system/video/cam4_1752225205349.mp4"; // String videoUrl = "http://10.148.108.162/system/video/cam4_1752225205349.mp4";
// JSONArray videoUrls = new JSONArray(); // JSONArray videoUrls = new JSONArray();
@ -104,7 +109,7 @@ public class EdgeCameraOperateService implements EdgeOperateService {
} }
case CAMERA_RECORDING_STOP: { case CAMERA_RECORDING_STOP: {
edgeCameraService.stopRecording(terminalId, deviceId); edgeCameraService.stopRecording(edgeCommonVO);
// todo 结束录像获取视频路径输出 // todo 结束录像获取视频路径输出
// // 获取视频录制开始节点的id // // 获取视频录制开始节点的id
// FlowNodeWrapper startRecordNode = message.getGraph() // FlowNodeWrapper startRecordNode = message.getGraph()

13
cmvr-iot-test/src/main/java/com/cmvr/test/flow/runtime/operator/edge/EdgeMicrophoneOperateService.java
View File

@ -1,11 +1,10 @@
package com.cmvr.test.flow.runtime.operator.edge; package com.cmvr.test.flow.runtime.operator.edge;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson2.JSONObject; import com.alibaba.fastjson2.JSONObject;
import com.cmvr.common.exception.GlobalException; import com.cmvr.common.exception.GlobalException;
import com.cmvr.edge.client.model.EdgeCommonVO;
import com.cmvr.edge.client.service.EdgeMicrophoneService; import com.cmvr.edge.client.service.EdgeMicrophoneService;
import com.cmvr.test.enums.ActionEnum; import com.cmvr.test.enums.ActionEnum;
import com.cmvr.test.flow.context.TaskInstHolder;
import com.cmvr.test.flow.runtime.message.TaskNodeExecuteMessage; import com.cmvr.test.flow.runtime.message.TaskNodeExecuteMessage;
import com.cmvr.test.flow.runtime.message.TaskNodeExecuteResult; import com.cmvr.test.flow.runtime.message.TaskNodeExecuteResult;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
@ -32,18 +31,18 @@ public class EdgeMicrophoneOperateService implements EdgeOperateService {
String terminalId = message.getTerminalId(); String terminalId = message.getTerminalId();
JSONObject output = new JSONObject(); JSONObject output = new JSONObject();
EdgeCommonVO edgeCommonVO = new EdgeCommonVO();
edgeCommonVO.setDeviceId(deviceId);
edgeCommonVO.setTerminalId(terminalId);
switch (action) { switch (action) {
case MICROPHONE_START: { case MICROPHONE_START: {
String audioPath = String audioPath = edgeMicrophoneService.startRecord(edgeCommonVO);
StrUtil.format("{}/{}_{}", "/home/share/assets/audio", deviceId, System.currentTimeMillis());
edgeMicrophoneService.startRecord(terminalId, deviceId, audioPath);
output.put("audioUrl", audioPath); output.put("audioUrl", audioPath);
break; break;
} }
case MICROPHONE_STOP: { case MICROPHONE_STOP: {
edgeMicrophoneService.stopRecord(terminalId, deviceId); edgeMicrophoneService.stopRecord(edgeCommonVO);
break; break;
} }

31
cmvr-iot-test/src/main/java/com/cmvr/test/flow/runtime/operator/edge/EdgeSpeakerOperateService.java
View File

@ -24,14 +24,14 @@ public class EdgeSpeakerOperateService implements EdgeOperateService {
@Override @Override
public TaskNodeExecuteResult execute(TaskNodeExecuteMessage message) { public TaskNodeExecuteResult execute(TaskNodeExecuteMessage message) {
ActionEnum action = message.getAction(); // ActionEnum action = message.getAction();
JSONObject inputParams = message.getInputParams(); // JSONObject inputParams = message.getInputParams();
String deviceId = inputParams.getString("deviceId"); // String deviceId = inputParams.getString("deviceId");
String terminalId = message.getTerminalId(); // String terminalId = message.getTerminalId();
switch (action) { // switch (action) {
case SPEAKER_PLAYAUDIO: { // case SPEAKER_PLAYAUDIO: {
log.info("speaker play audio"); // log.info("speaker play audio");
// todo 音频暂时随机播放 // // todo 音频暂时随机播放
// List<String> all = edgeSpeakerService.getAll(); // List<String> all = edgeSpeakerService.getAll();
// for (int i = 0; i < 3; i++) { // for (int i = 0; i < 3; i++) {
@ -57,12 +57,13 @@ public class EdgeSpeakerOperateService implements EdgeOperateService {
// throw new RuntimeException(e); // throw new RuntimeException(e);
// } // }
// } // }
break; // break;
} // }
//
default: // default:
throw new GlobalException("不支持的扬声器操作类型: " + action); // throw new GlobalException("不支持的扬声器操作类型: " + action);
} // }
return TaskNodeExecuteResult.success(); // return TaskNodeExecuteResult.success();
return null;
} }
} }

5
cmvr-iot-test/src/main/java/com/cmvr/test/flow/runtime/operator/vi/ViCorpusOperateService.java → cmvr-iot-test/src/main/java/com/cmvr/test/flow/runtime/operator/edge/vi/ViCorpusOperateService.java
View File

@ -1,4 +1,4 @@
package com.cmvr.test.flow.runtime.operator.vi; package com.cmvr.test.flow.runtime.operator.edge.vi;
import com.alibaba.fastjson2.JSONArray; import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject; import com.alibaba.fastjson2.JSONObject;
@ -6,6 +6,7 @@ import com.cmvr.common.exception.GlobalException;
import com.cmvr.test.enums.ActionEnum; import com.cmvr.test.enums.ActionEnum;
import com.cmvr.test.flow.runtime.message.TaskNodeExecuteMessage; import com.cmvr.test.flow.runtime.message.TaskNodeExecuteMessage;
import com.cmvr.test.flow.runtime.message.TaskNodeExecuteResult; import com.cmvr.test.flow.runtime.message.TaskNodeExecuteResult;
import com.cmvr.test.flow.runtime.operator.edge.EdgeOperateService;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
@ -15,7 +16,7 @@ import java.util.List;
@Slf4j @Slf4j
@Service @Service
@RequiredArgsConstructor @RequiredArgsConstructor
public class ViCorpusOperateService implements VIOperateService { public class ViCorpusOperateService implements EdgeOperateService {
@Override @Override
public boolean supports(ActionEnum action) { public boolean supports(ActionEnum action) {

5
cmvr-iot-test/src/main/java/com/cmvr/test/flow/runtime/operator/vi/ViPlayOperateService.java → cmvr-iot-test/src/main/java/com/cmvr/test/flow/runtime/operator/edge/vi/ViPlayOperateService.java
View File

@ -1,4 +1,4 @@
package com.cmvr.test.flow.runtime.operator.vi; package com.cmvr.test.flow.runtime.operator.edge.vi;
import cmvr.api.SpeakerCommand; import cmvr.api.SpeakerCommand;
import com.alibaba.fastjson2.JSONObject; import com.alibaba.fastjson2.JSONObject;
@ -9,6 +9,7 @@ import com.cmvr.edge.client.service.EdgeSpeakerService;
import com.cmvr.test.enums.ActionEnum; import com.cmvr.test.enums.ActionEnum;
import com.cmvr.test.flow.runtime.message.TaskNodeExecuteMessage; import com.cmvr.test.flow.runtime.message.TaskNodeExecuteMessage;
import com.cmvr.test.flow.runtime.message.TaskNodeExecuteResult; import com.cmvr.test.flow.runtime.message.TaskNodeExecuteResult;
import com.cmvr.test.flow.runtime.operator.edge.EdgeOperateService;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
@ -23,7 +24,7 @@ import java.io.File;
@Slf4j @Slf4j
@Service @Service
@RequiredArgsConstructor @RequiredArgsConstructor
public class ViPlayOperateService implements VIOperateService { public class ViPlayOperateService implements EdgeOperateService {
private final EdgeSpeakerService edgeSpeakerService; private final EdgeSpeakerService edgeSpeakerService;
private final EdgeBioHeadService edgeBioHeadService; private final EdgeBioHeadService edgeBioHeadService;

5
cmvr-iot-test/src/main/java/com/cmvr/test/flow/runtime/operator/vi/ViSchemeOperateService.java → cmvr-iot-test/src/main/java/com/cmvr/test/flow/runtime/operator/edge/vi/ViSchemeOperateService.java
View File

@ -1,4 +1,4 @@
package com.cmvr.test.flow.runtime.operator.vi; package com.cmvr.test.flow.runtime.operator.edge.vi;
import cn.hutool.core.collection.CollUtil; import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjUtil; import cn.hutool.core.util.ObjUtil;
@ -9,6 +9,7 @@ import com.cmvr.common.exception.GlobalException;
import com.cmvr.test.enums.ActionEnum; import com.cmvr.test.enums.ActionEnum;
import com.cmvr.test.flow.runtime.message.TaskNodeExecuteMessage; import com.cmvr.test.flow.runtime.message.TaskNodeExecuteMessage;
import com.cmvr.test.flow.runtime.message.TaskNodeExecuteResult; import com.cmvr.test.flow.runtime.message.TaskNodeExecuteResult;
import com.cmvr.test.flow.runtime.operator.edge.EdgeOperateService;
import com.cmvr.test.service.ex.ExViCorpusService; import com.cmvr.test.service.ex.ExViCorpusService;
import com.cmvr.test.service.ex.ExViSchemeService; import com.cmvr.test.service.ex.ExViSchemeService;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
@ -24,7 +25,7 @@ import java.util.stream.Collectors;
@Slf4j @Slf4j
@Service @Service
@RequiredArgsConstructor @RequiredArgsConstructor
public class ViSchemeOperateService implements VIOperateService { public class ViSchemeOperateService implements EdgeOperateService {
private final ExViSchemeService exViSchemeService; private final ExViSchemeService exViSchemeService;
private final ExViCorpusService exViCorpusService; private final ExViCorpusService exViCorpusService;

12
cmvr-iot-test/src/main/java/com/cmvr/test/flow/runtime/operator/vi/VIOperateService.java
View File

@ -1,12 +0,0 @@
package com.cmvr.test.flow.runtime.operator.vi;
import com.cmvr.test.enums.ActionEnum;
import com.cmvr.test.flow.runtime.message.TaskNodeExecuteMessage;
import com.cmvr.test.flow.runtime.message.TaskNodeExecuteResult;
public interface VIOperateService {
boolean supports(ActionEnum action);
TaskNodeExecuteResult execute(TaskNodeExecuteMessage message);
}

28
cmvr-iot-test/src/main/java/com/cmvr/test/flow/runtime/operator/vi/ViNodeOperateHandler.java
View File

@ -1,28 +0,0 @@
package com.cmvr.test.flow.runtime.operator.vi;
import com.cmvr.common.exception.GlobalException;
import com.cmvr.test.flow.runtime.message.TaskNodeExecuteMessage;
import com.cmvr.test.flow.runtime.message.TaskNodeExecuteResult;
import com.cmvr.test.flow.runtime.operator.AbstractNodeOperateHandler;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import java.util.List;
@Slf4j
@Component("VI")
@RequiredArgsConstructor
public class ViNodeOperateHandler extends AbstractNodeOperateHandler {
private final List<VIOperateService> viOperateServices;
@Override
protected TaskNodeExecuteResult doExecute(TaskNodeExecuteMessage message) {
return viOperateServices.stream()
.filter(s -> s.supports(message.getAction()))
.findFirst()
.map(s -> s.execute(message))
.orElseThrow(() -> new GlobalException("不支持的语音交互操作: " + message.getAction()));
}
}

21
cmvr-iot-test/src/main/java/com/cmvr/test/model/vo/FlowActionRequestVO.java Normal file
View File

@ -0,0 +1,21 @@
package com.cmvr.test.model.vo;
import com.alibaba.fastjson2.JSONObject;
import lombok.Data;
/**
* 工作流节点执行请求
*/
@Data
public class FlowActionRequestVO {
/**
* 动作
*/
private String action;
/**
* 执行参数
*/
private JSONObject payload;
}

123
cmvr-iot-test/src/main/java/com/cmvr/test/service/FlowActionExecutorService.java Normal file
View File

@ -0,0 +1,123 @@
package com.cmvr.test.service;
import cn.hutool.core.util.ObjUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson2.JSONObject;
import com.cmvr.common.exception.GlobalException;
import com.cmvr.edge.client.model.EdgeCommonVO;
import com.cmvr.edge.client.model.biohead.EdgeFacialExpressionVO;
import com.cmvr.edge.client.model.humanoid.EdgeMoveJVO;
import com.cmvr.edge.client.service.EdgeBioHeadService;
import com.cmvr.edge.client.service.EdgeCameraService;
import com.cmvr.edge.client.service.EdgeHumanoidRobotService;
import com.cmvr.edge.client.service.EdgeMicrophoneService;
import com.cmvr.edge.client.service.EdgeSpeakerService;
import com.cmvr.test.enums.ActionEnum;
import com.cmvr.test.model.vo.FlowActionRequestVO;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
@Slf4j
@Service
@RequiredArgsConstructor
public class FlowActionExecutorService {
private final EdgeCameraService edgeCameraService;
private final EdgeBioHeadService edgeBioHeadService;
private final EdgeMicrophoneService edgeMicrophoneService;
private final EdgeSpeakerService edgeSpeakerService;
private final EdgeHumanoidRobotService edgeHumanoidRobotService;
public String actionExecute(FlowActionRequestVO req) {
ActionEnum action = ActionEnum.fromAction(req.getAction());
if (ObjUtil.isEmpty(action)) {
throw new GlobalException("不存在此行为!");
}
switch (action.getOperate()) {
case "EDGE":
return executeEdgeAction(action, req);
case "LLM":
return executeLLMAction(action, req);
default:
throw new GlobalException("仅设备和大模型 Action 可调用!");
}
}
private String executeEdgeAction(ActionEnum action, FlowActionRequestVO req) {
JSONObject payload = req.getPayload();
String terminalId = payload.getString("terminalId");
String deviceId = payload.getString("deviceId");
if (StrUtil.isEmpty(terminalId) || StrUtil.isEmpty(deviceId)) {
throw new GlobalException("EDGE 类型动作必须提供 terminalId 和 deviceId");
}
EdgeCommonVO edgeCommonVO = new EdgeCommonVO();
edgeCommonVO.setTerminalId(terminalId);
edgeCommonVO.setDeviceId(deviceId);
switch (action) {
// ==== 相机 ====
case CAMERA_START:
return edgeCameraService.start(edgeCommonVO);
case CAMERA_STOP:
return edgeCameraService.stop(edgeCommonVO);
case CAMERA_GETRGBIMAGE:
return edgeCameraService.getRGBImage(edgeCommonVO);
case CAMERA_RECORDING_START:
return edgeCameraService.startRecording(edgeCommonVO);
case CAMERA_RECORDING_STOP:
return edgeCameraService.stopRecording(edgeCommonVO);
// ==== 麦克风 ====
case MICROPHONE_START:
return edgeMicrophoneService.startRecord(edgeCommonVO);
case MICROPHONE_STOP:
return edgeMicrophoneService.stopRecord(edgeCommonVO);
// ==== 触控 ====
case TOUCH:
EdgeMoveJVO edgeMoveJVO = payload.to(EdgeMoveJVO.class);
return edgeHumanoidRobotService.moveJ(edgeMoveJVO);
// ==== 语料 ====
case VI_PLAY_CORPUS:
String audioPath = payload.getString("audioPath");
return edgeSpeakerService.playAudio(terminalId, deviceId, audioPath);
// ==== 头部 ====
case BIO_HEAD_SPEAK_START:
return edgeBioHeadService.speakStart(edgeCommonVO);
case BIO_HEAD_SPEAK_STOP:
return edgeBioHeadService.speakStop(edgeCommonVO);
case BIO_HEAD_SPECIAL_EXPRESSION:
EdgeFacialExpressionVO edgeFacialExpressionVO = payload.to(EdgeFacialExpressionVO.class);
edgeFacialExpressionVO.setTerminalId(terminalId);
edgeFacialExpressionVO.setDeviceId(deviceId);
return edgeBioHeadService.setExpression(edgeFacialExpressionVO);
default:
throw new UnsupportedOperationException("未实现的 EDGE Action: " + action.name());
}
}
private String executeLLMAction(ActionEnum action, FlowActionRequestVO req) {
log.info("LLM 执行动作: {}", action);
switch (action) {
case TOUCH_COORDINATES:
return "LLM 触控坐标 OK";
case INTENT_RECOGNITION:
return "LLM 意图识别 OK";
case GENERATE_ADVANCED_AUDIO:
return "LLM 高级音频生成 OK";
default:
throw new UnsupportedOperationException("未实现的 LLM Action: " + action);
}
}
}