优化

liusuyi

2026-05-18 b5cd784d0cde5b7c82ea78aef4ac0e5a161d8c5d

 ard-modules/ard-modules-work/src/main/java/com/ard/work/sdk/service/CameraSDKService.java

@@ -18,22 +18,15 @@
import com.ard.work.utils.gis.GisUtil;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;


/**
 * @Description: 相机sdk业务
 * @ClassName: CameraSdkServiceImpl
 * @Author: 刘苏义
 * @Date: 2023年10月16日15:21:01
 **/
@Service
@Slf4j
public class CameraSDKService {
@@ -45,7 +38,8 @@
    @Resource
    private IArdNoViewingZoneService ardNoViewingZoneService;

    //登录
    // ========== 基础操作 ==========

    @Async("cameraSdkExecutor")
    public void login(ArdCamera ardCamera) {
        if (ardCamera == null) {
@@ -55,708 +49,212 @@
        sdk.login(ardCamera);
    }

    //注销
    public void logout(String cameraId) {
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cameraId);
        if (ardCamera == null) {
        if (ardCamera == null || ardCamera.getFactory() == null) {
            return;
        }
        if(ardCamera.getFactory()!= null) {
            CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(ardCamera.getFactory());
            cameraSDK.logout(cameraId);
        }
        CameraSDK sdk = cameraSDKFactory.createCameraSDK(ardCamera.getFactory());
        sdk.logout(cameraId);
    }

    // ========== 简单操作（一行搞定） ==========

    //在线检测
    public boolean isOnLine(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cameraId);
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cameraId);
        if (loginId == null) {
            return false;
        }
        cmd.setLoginId(loginId);
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(ardCamera.getFactory());
        return cameraSDK.isOnLine(cmd);
    }

    //云台控制
    @SdkOperate
    public Boolean pTZControl(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        return getSdk(cmd).pTZControl(cmd);
        }

        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }

        cmd.setLoginId(loginId);

        // 调用各厂商 SDK 方法，异常由各自 SDK 实现抛出
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(ardCamera.getFactory());
        return cameraSDK.pTZControl(cmd);
    }

    //设置聚焦值
    public Boolean setFocusPos(CameraCmd cmd) {
        // 1️⃣ 获取相机信息
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        return getSdk(cmd).setFocusPos(cmd);
        }

        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }

        cmd.setLoginId(loginId);

        // 3️⃣ 调用对应厂商 SDK
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.setFocusPos(cmd);
    }

    //获取聚焦值
    public Integer getFocusPos(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        return getSdk(cmd).getFocusPos(cmd);
        }

        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }

        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.getFocusPos(cmd);
    }

    //设置预置位
    public Boolean setPreset(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        return getSdk(cmd).setPreset(cmd);
        }

        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.setPreset(cmd);
    }

    //调用预置位
    public Boolean gotoPreset(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        return getSdk(cmd).gotoPreset(cmd);
        }

        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.gotoPreset(cmd);
    }

    //获取码流压缩参数
    public VideoCompressionCfg getVideoCompressionCfg(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        return getSdk(cmd).getVideoCompressionCfg(cmd);
        }

        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.getVideoCompressionCfg(cmd);
    }

    //透雾开关
    public Boolean controlDefog(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        return getSdk(cmd).controlDefog(cmd);
        }

        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.controlDefog(cmd);
    }

    //查询是否开启透雾
    public Boolean isEnableDefog(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        return getSdk(cmd).isEnableDefog(cmd);
        }

        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.isEnableDefog(cmd);
    }

    //红外开关
    public Boolean controlInfrared(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        return getSdk(cmd).controlInfrared(cmd);
        }

        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.controlInfrared(cmd);

    }

    //查询是否开启红外
    public Boolean isEnableInfrared(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        return getSdk(cmd).isEnableInfrared(cmd);
        }

        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.isEnableInfrared(cmd);
    }

    //手动/自动聚焦
    public Boolean controlFocusMode(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        return getSdk(cmd).controlFocusMode(cmd);
        }

        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.controlFocusMode(cmd);
    }

    //获取聚焦模式
    public Boolean getFocusMode(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        return getSdk(cmd).getFocusMode(cmd);
        }

        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.getFocusMode(cmd);
    }

    //云台加热
    public Boolean controlPTHeater(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        return getSdk(cmd).controlPTHeater(cmd);
        }

        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.controlPTHeater(cmd);
    }

    //镜头加热
    public Boolean controlCameraDeicing(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        return getSdk(cmd).controlCameraDeicing(cmd);
        }

        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.controlCameraDeicing(cmd);
    }

    //获取云台锁定信息
    public Boolean getPTZLockInfo(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        return getSdk(cmd).getPTZLockInfo(cmd);
        }

        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.getPTZLockInfo(cmd);
    }

    //设置云台锁定信息
    public Boolean setPTZLockInfo(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        boolean enable = cmd.isEnable();//0未锁 1锁定
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        return getSdk(cmd).setPTZLockInfo(cmd);
        }

        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.setPTZLockInfo(cmd);
    }

    //本地抓图
    public byte[] localCapture(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        return getSdk(cmd).localCapture(cmd);
        }

        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.localCapture(cmd);
    }

    //抓图
    @SdkOperate
    public String picCutCate(CameraCmd cmd) {
        //从redis中获取摄像头信息
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            return "";
        }
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            return "";
        }
        cmd.setLoginId(loginId);
        //获取摄像头工厂
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.picCutCate(cmd);
    }

    //抓图
    @SdkOperate
    public String picCutCate(CameraCmd cmd, String bucketName, String objectName) {
        String url = "";
        try {
            //从redis中获取摄像头信息
            ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
            if (ardCamera == null) {
                return "";
            }
            Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
            if (loginId == null) {
                return "";
            }
            cmd.setLoginId(loginId);
            //获取摄像头工厂
            String factory = ardCamera.getFactory();
            CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
            url = cameraSDK.picCutCate(cmd, bucketName, objectName);

        } catch (Exception ex) {
            log.error("抓图异常：{}", ex.getMessage());
        }
        return url;
    }

    //获取ptz
    public PtzDto getPtz(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }
        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        String type = ardCamera.getType();
        if ("1".equals(type)) {
            return cameraSDK.getPtzHigh(cmd);
        } else {
            return cameraSDK.getPtz(cmd);
        }
    }

    //获取ptz范围
    public PtzScope getPtzScope(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }
        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.getPtzScope(cmd);
        return getSdk(cmd).getPtzScope(cmd);
    }

    //设置ptz
    public Boolean setZeroPtz(CameraCmd cmd) {
        return getSdk(cmd).setZeroPtz(cmd);
    }

    public Boolean set3DPosition(CameraCmd cmd) {
        return getSdk(cmd).set3DPosition(cmd);
    }

    public PtzParamDTO getGisInfo(CameraCmd cmd) {
        return getSdk(cmd).getGisInfo(cmd);
    }

    public Double correctPitch(CameraCmd cmd) {
        return getSdk(cmd).correctPitch(cmd);
    }

    // ========== 需要判断类型的操作 ==========

    public PtzDto getPtz(CameraCmd cmd) {
        return getSdk(cmd).getPtz(cmd);
    }

    @SdkOperate
    public Boolean setPtz(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }
        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(ardCamera.getFactory());
        String type = ardCamera.getType();
        if ("1".equals(type)) {
            DeviceCFG systemInfo = cameraSDK.getSystemInfo(cmd);
            if (systemInfo != null && "5.5.112".equals(systemInfo.getDwSoftwareVersion())) {
                //大光电新固件使用高精度ptz透传设置
                return cameraSDK.setPtzHighT(cmd);
            } else {
                //使用高精度ptz设置
                return cameraSDK.setPtzHigh(cmd);
        return getSdk(cmd).setPtz(cmd);
            }

        } else {
            return cameraSDK.setPtz(cmd);
        }
    }
    // ========== 抓图（重载方法） ==========

    //设置零方位角
    public Boolean setZeroPtz(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }
        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.setZeroPtz(cmd);
    }

    //引导指向目标
    @SdkOperate
    public Boolean guideTargetPosition(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }
        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        //判断是否超出引导距离
        if (isOutMaxDistance(cameraId, cmd.getTargetPosition())) {
            throw new CameraSDKException(CameraSDKException.ErrorCode.OVER_GUIDANCE_RANGE.getCode(), cameraId,
                    "目标超出最大引导距离");
        }
        //判断是否在不可视域
        if (isInNoViewingZone(cameraId, cmd.getTargetPosition())) {
            throw new CameraSDKException(CameraSDKException.ErrorCode.BEYOND_VISIBILITY_RANGE.getCode(), cameraId
                    , "目标超出最大引导距离");
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        cmd.setBaseYaw(ardCamera.getBaseYaw());
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.guideTargetPosition(cmd);
    public String picCutCate(CameraCmd cmd) {
        return getSdk(cmd).picCutCate(cmd);
    }

    //判断坐标是否超出引导范围
    private Boolean isOutMaxDistance(String cameraId, Point targetPoint) {
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cameraId);
        if (ardCamera == null) {
            log.error("设备不存在");
            return true;
        }
        Point cameraCoordinate = new Point(ardCamera.getLongitude(), ardCamera.getLatitude(), ardCamera.getAltitude());
        double distance = GisUtil.getDistance(cameraCoordinate, targetPoint);
        if (ardCamera.getCamMaxVisibleDistance() == null) {
            throw new CameraSDKException(CameraSDKException.ErrorCode.CAMERA_MAX_VISIBLE_DISTANCE_NULL.getCode(),
                    cameraId, CameraSDKException.ErrorCode.CAMERA_MAX_VISIBLE_DISTANCE_NULL.getMsg());
        }
        double camMaxVisibleDistance = ardCamera.getCamMaxVisibleDistance();
        return distance > camMaxVisibleDistance;
    @SdkOperate
    public String picCutCate(CameraCmd cmd, String bucketName, String objectName) {
        return getSdk(cmd).picCutCate(cmd, bucketName, objectName);
    }

    //判断坐标是否在不可视域
    private Boolean isInNoViewingZone(String cameraId, Point targetPoint) {
        ArdNoViewingZone ardNoViewingZone = new ArdNoViewingZone();
        ardNoViewingZone.setCameraId(cameraId);
        List<ArdNoViewingZone> ardNoViewingZones =
                ardNoViewingZoneService.selectArdNoViewingZoneList(ardNoViewingZone);//获取相机的不可视域列表
        List<Point> pointList = new ArrayList<>();
        if (ardNoViewingZones.isEmpty()) {
            return false;
        }
        ardNoViewingZones.forEach(noViewingZone -> {
            String poi = noViewingZone.getPoi();
            String[] parts = poi.split(",");
            for (int i = 0; i < parts.length; i += 3) {
                Point point = new Point();
                point.setLongitude(Double.valueOf(parts[i]));
                point.setLatitude(Double.valueOf(parts[i + 1]));
                pointList.add(point);
            }
        });
        return GisUtil.isInPolygon(targetPoint, pointList);
    }

    //录像
    // ========== 录像 ==========
    public String record(CameraCmd cmd) {
        String url = "";
        try {
            ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
            if (ardCamera != null) {
                String factory = ardCamera.getFactory();
                CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
                url = cameraSDK.record(cmd);
            }
        } catch (Exception ex) {
            log.error("录像异常：{}", ex.getMessage());
        }
        return url;
        return getSdk(cmd).record(cmd);
    }

    //开始录像
    public Boolean recordStart(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }
        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        Boolean result = cameraSDK.recordStart(cmd);
        CameraSDK sdk = getSdk(cmd);
        Boolean result = sdk.recordStart(cmd);
        if (result != null && result) {
            RecordManager.addRecord(cmd.getCameraId() + "_" + cmd.getChanNo());
        }
        return result;
    }

    //停止录像并存入minio
    public String recordStop(CameraCmd cmd) {
        String url = "";
        try {
            ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
            if (ardCamera == null) {
                return url;
            }
            Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
            if (loginId == null) {
                return url;
            }
            cmd.setLoginId(loginId);
            String factory = ardCamera.getFactory();
            CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
            url = cameraSDK.recordStop(cmd);
        CameraSDK sdk = getSdk(cmd);
        String url = sdk.recordStop(cmd);
            String key = cmd.getCameraId() + "_" + cmd.getChanNo();
            RecordManager.stopRecord(key);
        } catch (Exception ex) {
            log.error("停止录像异常：{}", ex.getMessage());
        }
        return url;
    }

    // ========== 智能引导 ==========

    //获取相机架设参数
    public PtzParamDTO getGisInfo(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
    @SdkOperate
    public Boolean guideTargetPosition(CameraCmd cmd) {
        CameraSDK sdk = getSdk(cmd);
        ArdCamera camera = getCamera(cmd.getCameraId());
        String cameraId = camera.getId();

        // 判断是否超出引导距离
        if (isOutMaxDistance(cameraId, cmd.getTargetPosition())) {
            throw new CameraSDKException(CameraSDKException.ErrorCode.OVER_GUIDANCE_RANGE.getCode(),
                    cameraId, "目标超出最大引导距离");
        }
        // 设备在线检查

        // 判断是否在不可视域
        if (isInNoViewingZone(cameraId, cmd.getTargetPosition())) {
            throw new CameraSDKException(CameraSDKException.ErrorCode.BEYOND_VISIBILITY_RANGE.getCode(),
                    cameraId, "目标在不可视区域内");
        }

        cmd.setBaseYaw(camera.getBaseYaw());
        return sdk.guideTargetPosition(cmd);
    }

    // ========== 在线检测 ==========

    public boolean isOnLine(CameraCmd cmd) {
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
            return false;
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.getGisInfo(cmd);
        CameraSDK sdk = getSdk(cmd);
        return sdk.isOnLine(cmd);
    }

    //获取相机通道信息
    // ========== 通道信息 ==========

    public List<ArdChannel> getChannels(ArdCamera camera) {
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, camera.getId());
        if (loginId == null) {
            return new ArrayList<>();
        }
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(camera.getFactory());
        return cameraSDK.getChannels(camera);
        CameraSDK sdk = cameraSDKFactory.createCameraSDK(camera.getFactory());
        return sdk.getChannels(camera);
    }

    //NET_DVR_PTZSelZoomIn
    public Boolean set3DPosition(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
    // ========== 视频标签 ==========

    public AjaxResult getCameraVideoLable(CameraCmd cmd) {
        CameraSDK sdk = cameraSDKFactory.createCameraSDK("1"); // 硬编码问题建议修复
        try {
            List<Map<String, Object>> result = sdk.getCameraVideoLable(SecurityUtils.getUserId(), cmd);
            return AjaxResult.success(result);
        } catch (ServiceException e) {
            return AjaxResult.error(e.getMessage());
        }
        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.set3DPosition(cmd);
    }

    //录像超时检查
    // ========== 定时任务 ==========

    @Scheduled(fixedRate = 30 * 1000)
    public void checkVideoTimeout() {
        Date now = new Date();
@@ -774,32 +272,69 @@
        });
    }

    //获取相机架设参数
    public Double correctPitch(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }
        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.correctPitch(cmd);
    }
    public AjaxResult getCameraVideoLable(CameraCmd cmd) {
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK("1");
        try {
            List<Map<String, Object>>  r= cameraSDK.getCameraVideoLable(SecurityUtils.getUserId(), cmd);
            return AjaxResult.success(r);
        }catch (ServiceException e){
            return AjaxResult.error(e.getMessage());
        }
    // ========== 私有辅助方法 ==========

    /**
     * 获取SDK实例（会校验参数、相机存在性、在线状态）
     */
    private CameraSDK getSdk(CameraCmd cmd) {
        if (cmd == null || cmd.getCameraId() == null || cmd.getCameraId().isBlank()) {
            throw CameraSDKException.cameraNotExist(null);
    }

        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cmd.getCameraId());
        }
        cmd.setLoginId(loginId);

        ArdCamera camera = getCamera(cmd.getCameraId());
        return cameraSDKFactory.createCameraSDK(camera.getFactory());
    }

    /**
     * 获取相机信息（会校验存在性）
     */
    private ArdCamera getCamera(String cameraId) {
        ArdCamera camera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cameraId);
        if (camera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }
        return camera;
    }

    // 判断坐标是否超出引导范围
    private Boolean isOutMaxDistance(String cameraId, Point targetPoint) {
        ArdCamera camera = getCamera(cameraId);
        Point cameraCoordinate = new Point(camera.getLongitude(), camera.getLatitude(), camera.getAltitude());
        double distance = GisUtil.getDistance(cameraCoordinate, targetPoint);

        if (camera.getCamMaxVisibleDistance() == null) {
            throw new CameraSDKException(CameraSDKException.ErrorCode.CAMERA_MAX_VISIBLE_DISTANCE_NULL.getCode(),
                    cameraId, CameraSDKException.ErrorCode.CAMERA_MAX_VISIBLE_DISTANCE_NULL.getMsg());
        }
        return distance > camera.getCamMaxVisibleDistance();
    }

    // 判断坐标是否在不可视域
    private Boolean isInNoViewingZone(String cameraId, Point targetPoint) {
        ArdNoViewingZone query = new ArdNoViewingZone();
        query.setCameraId(cameraId);
        List<ArdNoViewingZone> zones = ardNoViewingZoneService.selectArdNoViewingZoneList(query);
        if (zones.isEmpty()) {
            return false;
        }

        List<Point> points = new ArrayList<>();
        for (ArdNoViewingZone zone : zones) {
            String[] parts = zone.getPoi().split(",");
            for (int i = 0; i < parts.length; i += 3) {
                Point point = new Point();
                point.setLongitude(Double.valueOf(parts[i]));
                point.setLatitude(Double.valueOf(parts[i + 1]));
                points.add(point);
            }
        }
        return GisUtil.isInPolygon(targetPoint, points);
    }
}