package com.ard.work.inspect.task;
|
|
import com.ard.common.core.constant.SecurityConstants;
|
import com.ard.common.core.domain.R;
|
import com.ard.common.core.utils.SpringUtils;
|
import com.ard.common.core.web.domain.AjaxResult;
|
import com.ard.system.api.RemoteConfigService;
|
import com.ard.work.api.domian.ArdWell;
|
import com.ard.work.api.domian.CameraCmd;
|
import com.ard.work.api.domian.PtzDto;
|
import com.ard.work.device.camera.service.IArdCameraService;
|
import com.ard.work.inspect.domain.ArdVideoInspectRecord;
|
import com.ard.work.inspect.domain.ArdVideoInspectTask;
|
import com.ard.work.inspect.domain.ArdVideoInspectTaskStep;
|
import com.ard.work.inspect.service.IArdVideoInspectRecordService;
|
import com.ard.work.api.domian.ArdWellGuideCamera;
|
import com.ard.work.point.well.service.IArdWellGuideCameraService;
|
import com.ard.work.point.well.service.IArdWellService;
|
import com.ard.work.sdk.service.CameraSDKService;
|
import com.ard.work.api.domian.Point;
|
import lombok.extern.slf4j.Slf4j;
|
|
import java.time.LocalTime;
|
import java.util.Date;
|
import java.util.List;
|
|
@Slf4j
|
public class TaskWrapper implements Runnable {
|
public volatile TaskStatus status = TaskStatus.RUNNING;
|
private final ArdVideoInspectTask task;
|
private ArdVideoInspectTaskStep currentStep;
|
private Date stepStartTime;
|
private final CameraSDKService cameraSDKService = SpringUtils.getBean(CameraSDKService.class);
|
private final IArdCameraService ardCameraService = SpringUtils.getBean(IArdCameraService.class);
|
private final IArdVideoInspectRecordService ardVideoInspectRecordService =
|
SpringUtils.getBean(IArdVideoInspectRecordService.class);
|
private final IArdWellService ardWellService = SpringUtils.getBean(IArdWellService.class);
|
private final IArdWellGuideCameraService ardWellGuideCameraService =
|
SpringUtils.getBean(IArdWellGuideCameraService.class);
|
private final RemoteConfigService remoteConfigService =
|
SpringUtils.getBean(RemoteConfigService.class);
|
public TaskWrapper(ArdVideoInspectTask task) {
|
this.task = task;
|
}
|
|
@Override
|
public void run() {
|
List<ArdVideoInspectTaskStep> steps = task.getArdVideoInspectTaskSteps();
|
if (steps.isEmpty()) return;
|
while (status != TaskStatus.CANCELED) { // 循环直到任务被取消
|
for (ArdVideoInspectTaskStep step : steps) {
|
if (status == TaskStatus.CANCELED) break;
|
|
currentStep = step;
|
stepStartTime = new Date(); // 记录当前步骤的开始时间
|
log.info("开始执行任务【{}】 的巡检步骤【{}】，时间：{}", step.getTaskId(), step.getId(), stepStartTime);
|
// 执行步骤
|
executeStep(step);
|
|
// 等待步骤完成
|
waitForStepCompletion(step);
|
}
|
}
|
log.info("任务被取消或完成");
|
}
|
|
//等待步骤完成
|
private void waitForStepCompletion(ArdVideoInspectTaskStep step) {
|
while (!isStepCompleted()) {
|
if (status == TaskStatus.CANCELED) {
|
handleCancellation(step);
|
return;
|
}
|
|
if (status == TaskStatus.PAUSED) {
|
handlePause(step);
|
}
|
try {
|
Thread.sleep(100); // 每 100 毫秒检查一次
|
} catch (InterruptedException e) {
|
Thread.currentThread().interrupt();
|
log.error("任务线程被中断");
|
return;
|
}
|
}
|
|
log.info("完成任务【{}】的巡检步骤【{}】", task.getId(), step.getId());
|
finalizeStep(step);
|
}
|
|
//处理暂停
|
private void handlePause(ArdVideoInspectTaskStep step) {
|
log.info("任务【{}】暂停，等待恢复...", task.getId());
|
synchronized (this) {
|
while (status == TaskStatus.PAUSED) {
|
try {
|
stopRecording(step);
|
wait(); // 暂停任务
|
} catch (InterruptedException e) {
|
Thread.currentThread().interrupt();
|
log.error("任务线程在暂停时被中断");
|
break;
|
}
|
}
|
}
|
}
|
|
//处理取消
|
private void handleCancellation(ArdVideoInspectTaskStep step) {
|
log.info("任务【{}】被取消，停止执行", task.getId());
|
stopRecording(step);
|
}
|
|
//处理完成
|
private void finalizeStep(ArdVideoInspectTaskStep step) {
|
stopRecording(step);
|
//recordStep(step, ""); // 提供空 URL 或根据需要调整
|
}
|
|
//执行任务
|
private void executeStep(ArdVideoInspectTaskStep step) {
|
log.info("执行任务 {} 的步骤 {}", step.getTaskId(), step.getId());
|
startRecording(step);
|
}
|
|
//步骤是否完成
|
private boolean isStepCompleted() {
|
long elapsedMillis = new Date().getTime() - stepStartTime.getTime();
|
long elapsedSeconds = elapsedMillis / 1000;
|
return elapsedSeconds >= currentStep.getRecordingTime();
|
}
|
|
//暂停
|
public void pause() {
|
this.status = TaskStatus.PAUSED;
|
}
|
|
//恢复
|
public void resume() {
|
this.status = TaskStatus.RUNNING;
|
synchronized (this) {
|
stepStartTime = new Date();
|
log.info("恢复执行任务【{}】 的巡检步骤【{}】，时间：{}", currentStep.getTaskId(), currentStep.getId(), stepStartTime);
|
// 执行步骤
|
executeStep(currentStep);
|
notifyAll(); // 唤醒所有在等待中的线程
|
}
|
}
|
|
//取消
|
public void cancel() {
|
this.status = TaskStatus.CANCELED;
|
synchronized (this) {
|
notifyAll(); // 唤醒所有在等待中的线程以便退出
|
}
|
}
|
|
//是否暂停
|
public boolean isPaused() {
|
return this.status == TaskStatus.PAUSED;
|
}
|
|
//是否取消
|
public boolean isCanceled() {
|
return this.status == TaskStatus.CANCELED;
|
}
|
|
//开始录像
|
private void startRecording(ArdVideoInspectTaskStep step) {
|
log.info("步骤 {} 开始 {} 录像", step.getId(), task.getCameraId() + "_" + task.getChanNo());
|
cameraSDKService.recordStart(new CameraCmd(task.getCameraId(), task.getChanNo()));//录像
|
try {
|
guideWell(step);//引导
|
} catch (Exception e) {
|
log.error("引导井异常,停止录像", e);
|
cameraSDKService.recordStop(new CameraCmd(task.getCameraId(), task.getChanNo(), "inspect"));//录像
|
}
|
}
|
|
//停止录像
|
private void stopRecording(ArdVideoInspectTaskStep step) {
|
log.info("步骤 {} 停止 {} 录像", step.getId(), task.getCameraId() + "_" + task.getChanNo());
|
String url = cameraSDKService.recordStop(new CameraCmd(task.getCameraId(), task.getChanNo(), "inspect"));
|
ArdVideoInspectRecord record = new ArdVideoInspectRecord();
|
record.setTaskId(task.getId());
|
record.setStepId(step.getId());
|
record.setStartTime(stepStartTime);
|
record.setEndTime(new Date());
|
ArdWell ardWell = ardWellService.selectArdWellById(step.getWellId());
|
record.setWellName(ardWell.getWellId());
|
record.setRecordUrl(url);
|
record.setTaskName(task.getTaskName());
|
ardVideoInspectRecordService.insertArdVideoInspectRecord(record);
|
}
|
|
//引导井
|
private void guideWell(ArdVideoInspectTaskStep step) {
|
log.info("控制相机{}通道{}引导井{}", task.getCameraId(), task.getChanNo(), step.getWellId());
|
//根据井id获取井的坐标
|
ArdWell ardWell = ardWellService.selectArdWellById(step.getWellId());
|
if (ardWell == null) {
|
return;
|
}
|
CameraCmd cmd = new CameraCmd();
|
cmd.setCameraId(task.getCameraId());
|
//根据日夜配置切换通道
|
Integer chanNo = switchChanByTime();
|
task.setChanNo(chanNo);
|
cmd.setChanNo(task.getChanNo());
|
cmd.setOperator("sys_patrol_inspect");
|
cmd.setExpired(step.getRecordingTime());
|
ardCameraService.controlLock(cmd);//锁定
|
Boolean res;
|
ArdWellGuideCamera guidePTZInfo = isPtzGuide(task.getCameraId(), task.getChanNo(), ardWell.getId());
|
if (guidePTZInfo != null) {
|
//使用ptz引导
|
cmd.setPtzDto(new PtzDto(guidePTZInfo.getP(), guidePTZInfo.getT(), guidePTZInfo.getZ()));
|
res = cameraSDKService.setPtz(cmd);
|
log.info("引导方式：ptz引导");
|
} else {
|
//使用坐标引导
|
cmd.setTargetPosition(new Point(ardWell.getLongitude(), ardWell.getLatitude(), ardWell.getAltitude()));
|
res = cameraSDKService.guideTargetPosition(cmd);
|
log.info("引导方式：坐标引导");
|
}
|
log.info("控制相机{}通道{}引导井{}结果{}", task.getCameraId(), task.getChanNo(), step.getWellId(), res);
|
}
|
|
//判断是否使用ptz引导
|
private ArdWellGuideCamera isPtzGuide(String cameraId, Integer chanNo, String wellId) {
|
ArdWellGuideCamera ardWellGuideCamera = new ArdWellGuideCamera();
|
ardWellGuideCamera.setWellId(wellId);
|
ardWellGuideCamera.setCameraId(cameraId);
|
ardWellGuideCamera.setChanNo(chanNo);
|
List<ArdWellGuideCamera> ardWellGuideCameras =
|
ardWellGuideCameraService.selectArdWellGuideCameraList(ardWellGuideCamera);
|
if (ardWellGuideCameras.isEmpty()) {
|
return null;
|
}
|
return ardWellGuideCameras.get(0);
|
}
|
|
// 通道日夜切换
|
public Integer switchChanByTime() {
|
R<String> result = remoteConfigService.getConfigKey("dayNight");
|
// 解析时间区间（示例：18:00-06:00）
|
if (result.getCode()==R.SUCCESS) {
|
String timeRange = result.getData();
|
return checkTimeRange(timeRange);
|
}
|
return 1;
|
}
|
|
/**
|
* 判断当前时间是否在时间区间内（支持跨天区间，如 18:00-06:00）
|
*
|
* @param timeRange 时间区间字符串，格式 "HH:mm-HH:mm"
|
* @return 1（在区间内） 或 2（不在区间内）
|
*/
|
public static int checkTimeRange(String timeRange) {
|
if (timeRange == null || !timeRange.matches("\\d{2}:\\d{2}-\\d{2}:\\d{2}")) {
|
throw new IllegalArgumentException("时间区间格式无效，应为 HH:mm-HH:mm");
|
}
|
|
String[] parts = timeRange.split("-");
|
LocalTime start = LocalTime.parse(parts[0]);
|
LocalTime end = LocalTime.parse(parts[1]);
|
LocalTime now = LocalTime.now();
|
|
if (start.isBefore(end)) {
|
// 普通区间（同一天内，如 09:00-18:00）
|
return (now.isAfter(start) && now.isBefore(end)) ? 1 : 2;
|
} else {
|
// 跨天区间（如 18:00-06:00）
|
return (now.isAfter(start) || now.isBefore(end)) ? 1 : 2;
|
}
|
}
|
}
|
