package com.ard.work.device.camera.service;
|
|
import com.ard.work.api.domian.ArdCamera;
|
import com.ard.work.api.domian.ArdChannel;
|
import com.ard.work.api.domian.CameraCmd;
|
import com.ard.work.api.domian.PtzDto;
|
import com.ard.work.device.camera.domain.PtzParamDTO;
|
import com.ard.work.sdk.service.CameraSDKService;
|
import jakarta.annotation.Resource;
|
import lombok.RequiredArgsConstructor;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.scheduling.annotation.Async;
|
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
|
import org.springframework.stereotype.Component;
|
|
import java.util.Arrays;
|
import java.util.HashSet;
|
import java.util.List;
|
import java.util.Set;
|
import java.util.concurrent.CompletableFuture;
|
import java.util.concurrent.TimeUnit;
|
import java.util.concurrent.TimeoutException;
|
|
@Slf4j
|
@Component
|
@RequiredArgsConstructor
|
public class PtzDataCollector {
|
|
private final CameraSDKService cameraSDKService;
|
private final PtzCacheManager ptzCacheManager;
|
|
@Resource(name = "timeoutExecutor")
|
private ThreadPoolTaskExecutor sdkExecutor;
|
|
private static final Set<String> EXCLUDE_FACTORY = new HashSet<>(Arrays.asList("7"));
|
private static final String CAMERA_ENABLE = "1";
|
private static final Set<String> SUPPORT_TYPES = new HashSet<>(Arrays.asList("1", "4"));
|
|
/** 单通道 SDK 调用超时 */
|
private static final long SDK_CALL_TIMEOUT_MS = 2000L;
|
/** 整相机所有通道总采集超时 */
|
private static final long CAMERA_TOTAL_TIMEOUT_MS = 3000L;
|
|
@Async("cameraPTZExecutor")
|
public void collectCamera(ArdCamera camera, Set<String> runningCamera) {
|
String camId = camera.getId();
|
try {
|
if (!isValidCamera(camera)) return;
|
List<ArdChannel> channels = camera.getChannelList();
|
if (channels == null || channels.isEmpty()) return;
|
|
CompletableFuture<?>[] futures = channels.stream()
|
.map(ch -> CompletableFuture.runAsync(
|
() -> collectChannel(camera, ch), sdkExecutor))
|
.toArray(CompletableFuture[]::new);
|
|
try {
|
CompletableFuture.allOf(futures).get(CAMERA_TOTAL_TIMEOUT_MS, TimeUnit.MILLISECONDS);
|
} catch (TimeoutException e) {
|
log.warn("采集相机 {} 整体超时,部分通道数据可能未更新", camId);
|
} catch (Exception e) {
|
log.error("采集相机 {} 异常", camId, e);
|
}
|
} finally {
|
runningCamera.remove(camId);
|
}
|
}
|
|
private void collectChannel(ArdCamera camera, ArdChannel channel) {
|
PtzParamDTO dto = fetchPtzWithTimeout(camera, channel);
|
if (dto != null) {
|
ptzCacheManager.updatePtzData(camera.getId() + "_" + channel.getChanNo(), dto);
|
}
|
}
|
|
/**
|
* 带超时的 SDK 调用,防止 SDK 卡死拖垮线程池
|
*/
|
private PtzParamDTO fetchPtzWithTimeout(ArdCamera camera, ArdChannel channel) {
|
CompletableFuture<PtzParamDTO> future = CompletableFuture.supplyAsync(
|
() -> fetchPtz(camera, channel), sdkExecutor);
|
try {
|
return future.get(SDK_CALL_TIMEOUT_MS, TimeUnit.MILLISECONDS);
|
} catch (TimeoutException e) {
|
log.warn("相机 {} 通道 {} SDK 调用超时", camera.getId(), channel.getChanNo());
|
future.cancel(true);
|
return null;
|
} catch (Exception e) {
|
log.error("相机 {} 通道 {} SDK 调用异常", camera.getId(), channel.getChanNo(), e);
|
return null;
|
}
|
}
|
|
private PtzParamDTO fetchPtz(ArdCamera camera, ArdChannel channel) {
|
CameraCmd cmd = new CameraCmd();
|
cmd.setCameraId(camera.getId());
|
cmd.setChanNo(channel.getChanNo());
|
|
PtzParamDTO dto = cameraSDKService.getGisInfo(cmd);
|
if (dto == null) return null;
|
|
dto.setCameraId(camera.getId());
|
dto.setChanNo(channel.getChanNo());
|
dto.setLongitude(camera.getLongitude());
|
dto.setLatitude(camera.getLatitude());
|
dto.setAltitude(camera.getAltitude());
|
|
PtzDto ptz = cameraSDKService.getPtz(cmd);
|
if (ptz != null) {
|
if ("4".equals(camera.getType())) {
|
ptz.setP((ptz.getP() + camera.getBaseYaw() + 360) % 360);
|
}
|
dto.setP(ptz.getP());
|
dto.setT(ptz.getT());
|
dto.setZ(ptz.getZ());
|
}
|
return dto;
|
}
|
|
private boolean isValidCamera(ArdCamera camera) {
|
return CAMERA_ENABLE.equals(camera.getState())
|
&& !EXCLUDE_FACTORY.contains(camera.getFactory())
|
&& SUPPORT_TYPES.contains(camera.getType());
|
}
|
}
|
