package com.ard.gb28181.service.impl;
|
|
import com.ard.common.core.constant.SecurityConstants;
|
import com.ard.common.core.domain.RtpServerParam;
|
import com.ard.common.core.exception.ServiceException;
|
import com.ard.gb28181.api.bean.ErrorCallback;
|
import com.ard.gb28181.api.bean.Preset;
|
import com.ard.gb28181.api.bean.SipTransactionInfo;
|
import com.ard.gb28181.api.domain.Device;
|
import com.ard.gb28181.api.domain.DeviceChannel;
|
import com.ard.gb28181.api.domain.GbCode;
|
import com.ard.gb28181.api.domain.SsrcTransaction;
|
import com.ard.gb28181.api.utils.DateUtil;
|
import com.ard.gb28181.common.ErrorCode;
|
import com.ard.gb28181.config.UserSetting;
|
import com.ard.gb28181.domain.GbChannel;
|
import com.ard.gb28181.domain.GbDevice;
|
import com.ard.gb28181.service.IDeviceService;
|
import com.ard.gb28181.service.IGbChannelService;
|
import com.ard.gb28181.service.IGbDeviceService;
|
import com.ard.gb28181.service.IRedisCatchStorage;
|
import com.ard.gb28181.service.ISIPCommander;
|
import com.ard.gb28181.session.SipInviteSessionManager;
|
import com.ard.gb28181.task.deviceStatus.DeviceStatusTask;
|
import com.ard.gb28181.task.deviceStatus.DeviceStatusTaskRunner;
|
import com.ard.gb28181.task.deviceSubscribe.deviceSubscribe.SubscribeTaskRunner;
|
import com.ard.gb28181.task.deviceSubscribe.deviceSubscribe.impl.SubscribeTaskForCatalog;
|
import com.ard.gb28181.task.deviceSubscribe.deviceSubscribe.impl.SubscribeTaskForMobilPosition;
|
import com.ard.zlm.api.RemoteZlmService;
|
import jakarta.validation.constraints.NotNull;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.core.annotation.Order;
|
import org.springframework.stereotype.Service;
|
import org.springframework.util.StringUtils;
|
|
import javax.sip.InvalidArgumentException;
|
import javax.sip.SipException;
|
import java.text.ParseException;
|
import java.util.List;
|
import java.util.Objects;
|
import java.util.concurrent.SynchronousQueue;
|
import java.util.concurrent.TimeUnit;
|
|
/**
|
* 设备业务
|
*
|
* @author lin
|
*/
|
@Slf4j
|
@Service
|
@Order(value = 16)
|
public class DeviceServiceImpl implements IDeviceService {
|
|
@Autowired
|
private IRedisCatchStorage redisCatchStorage;
|
|
@Autowired
|
private ISIPCommander commander;
|
|
@Autowired
|
private UserSetting userSetting;
|
|
@Autowired
|
private DeviceStatusTaskRunner deviceStatusTaskRunner;
|
|
@Autowired
|
private SubscribeTaskRunner subscribeTaskRunner;
|
|
@Autowired
|
private SipInviteSessionManager sessionManager;
|
|
@Autowired
|
private RemoteZlmService remoteZlmService;
|
|
@Autowired
|
private IGbDeviceService gbDeviceService;
|
|
@Autowired
|
private IGbChannelService gbChannelService;
|
|
/**
|
* 查询设备信息
|
*
|
* @param deviceId 设备编号
|
* @return 设备信息
|
*/
|
@Override
|
public Device getDeviceByDeviceId(String deviceId) {
|
return redisCatchStorage.getDevice(deviceId);
|
}
|
|
/**
|
* 设备上线
|
*
|
* @param device 设备信息
|
*/
|
@Override
|
public void online(Device device, SipTransactionInfo sipTransactionInfo) {
|
log.info("[设备上线] deviceId：{}->{}:{}", device.getDeviceId(), device.getIp(), device.getPort());
|
Device deviceInRedis = redisCatchStorage.getDevice(device.getDeviceId());
|
|
String now = DateUtil.getNow();
|
|
device.setUpdateTime(now);
|
device.setKeepaliveTime(now);
|
if (device.getHeartBeatCount() == null) {
|
// 读取设备配置， 获取心跳间隔和心跳超时次数， 在次之前暂时设置为默认值
|
device.setHeartBeatCount(3);
|
device.setHeartBeatInterval(60);
|
device.setPositionCapability(0);
|
|
}
|
if (sipTransactionInfo != null) {
|
device.setSipTransactionInfo(sipTransactionInfo);
|
} else {
|
if (deviceInRedis != null) {
|
device.setSipTransactionInfo(deviceInRedis.getSipTransactionInfo());
|
}
|
}
|
|
// 第一次上线 或则设备之前是离线状态--进行通道同步和设备信息查询
|
if (deviceInRedis == null) {
|
device.setOnLine(true);
|
device.setCreateTime(now);
|
device.setUpdateTime(now);
|
log.info("[设备上线,首次注册]: {}，查询设备信息以及通道信息", device.getDeviceId());
|
if (device.getStreamMode() == null) {
|
device.setStreamMode("TCP-PASSIVE");
|
}
|
redisCatchStorage.updateDevice(device);
|
try {
|
commander.deviceInfoQuery(device, null);
|
commander.deviceConfigQuery(device, null, "BasicParam", null);
|
} catch (InvalidArgumentException | SipException | ParseException e) {
|
log.error("[命令发送失败] 查询设备信息: {}", e.getMessage());
|
}
|
log.info("[设备上线]: {}，查询通道信息", device.getDeviceId());
|
sync(device);
|
} else {
|
device.setServerId(userSetting.getServerId());
|
if (!deviceInRedis.isOnLine()) {
|
device.setOnLine(true);
|
device.setCreateTime(now);
|
redisCatchStorage.updateDevice(device);
|
|
if (userSetting.getSyncChannelOnDeviceOnline()) {
|
log.info("[设备上线,离线状态下重新注册]: {}，查询设备信息以及通道信息", device.getDeviceId());
|
try {
|
commander.deviceInfoQuery(device, null);
|
} catch (InvalidArgumentException | SipException | ParseException e) {
|
log.error("[命令发送失败] 查询设备信息: {}", e.getMessage());
|
}
|
log.info("[设备上线]: {}，查询通道信息", device.getDeviceId());
|
sync(device);
|
} else {
|
if (isDevice(device.getDeviceId())) {
|
log.info("[设备上线]: {}，查询通道信息", device.getDeviceId());
|
sync(device);
|
}
|
}
|
} else {
|
redisCatchStorage.updateDevice(device);
|
}
|
}
|
|
long expiresTime = Math.min(device.getExpires(), device.getHeartBeatInterval() * device.getHeartBeatCount()) * 1000L;
|
if (deviceStatusTaskRunner.containsKey(device.getDeviceId())) {
|
if (sipTransactionInfo == null) {
|
deviceStatusTaskRunner.updateDelay(device.getDeviceId(), expiresTime + System.currentTimeMillis());
|
} else {
|
deviceStatusTaskRunner.removeTask(device.getDeviceId());
|
DeviceStatusTask task = DeviceStatusTask.getInstance(device.getDeviceId(), sipTransactionInfo, expiresTime + System.currentTimeMillis(), this::deviceStatusExpire);
|
deviceStatusTaskRunner.addTask(task);
|
}
|
} else {
|
DeviceStatusTask task = DeviceStatusTask.getInstance(device.getDeviceId(), sipTransactionInfo, expiresTime + System.currentTimeMillis(), this::deviceStatusExpire);
|
deviceStatusTaskRunner.addTask(task);
|
}
|
// 设备注册成功时，自动在 ard_gb_device 表中创建设备记录（若不存在）
|
try {
|
GbDevice existingDevice = gbDeviceService.selectGbDeviceByGbDeviceId(device.getDeviceId());
|
if (existingDevice == null) {
|
GbDevice gbDevice = new GbDevice();
|
gbDevice.setGbDeviceId(device.getDeviceId());
|
gbDevice.setDeviceName(StringUtils.hasText(device.getName()) ? device.getName() : device.getDeviceId());
|
gbDevice.setDeviceCode(device.getDeviceId());
|
gbDevice.setIp(device.getIp());
|
gbDevice.setPort(device.getPort());
|
gbDevice.setManufacturer(device.getManufacturer());
|
gbDevice.setModel(device.getModel());
|
gbDevice.setFirmware(device.getFirmware());
|
gbDevice.setOnLine(true);
|
gbDeviceService.insertGbDevice(gbDevice);
|
log.info("[GbDevice自动创建] deviceId: {}, id: {}", device.getDeviceId(), gbDevice.getId());
|
|
// 同时创建默认通道（设备自身）
|
GbChannel gbChannel = new GbChannel();
|
gbChannel.setGbDeviceId(device.getDeviceId());
|
gbChannel.setGbChannelId(device.getDeviceId());
|
gbChannel.setChannelName(StringUtils.hasText(device.getName()) ? device.getName() : device.getDeviceId());
|
gbChannel.setDeviceCode(device.getDeviceId());
|
gbChannel.setStreamMode(device.getStreamMode() != null ? device.getStreamMode() : "TCP-PASSIVE");
|
gbChannel.setEnableMp4("0");
|
gbChannelService.insertGbChannel(gbChannel);
|
log.info("[GbChannel默认创建] deviceId: {}, channelId: {}, id: {}",
|
device.getDeviceId(), device.getDeviceId(), gbChannel.getId());
|
} else {
|
// 设备已存在，更新最新信息（名称、IP、端口、厂商、型号、固件）
|
boolean needUpdate = false;
|
String newName = StringUtils.hasText(device.getName()) ? device.getName() : device.getDeviceId();
|
if (!newName.equals(existingDevice.getDeviceName())) {
|
existingDevice.setDeviceName(newName);
|
needUpdate = true;
|
}
|
if (device.getIp() != null && !device.getIp().equals(existingDevice.getIp())) {
|
existingDevice.setIp(device.getIp());
|
needUpdate = true;
|
}
|
if (device.getPort() > 0 && (existingDevice.getPort() == null || device.getPort() != existingDevice.getPort())) {
|
existingDevice.setPort(device.getPort());
|
needUpdate = true;
|
}
|
if (device.getManufacturer() != null && !device.getManufacturer().equals(existingDevice.getManufacturer())) {
|
existingDevice.setManufacturer(device.getManufacturer());
|
needUpdate = true;
|
}
|
if (device.getModel() != null && !device.getModel().equals(existingDevice.getModel())) {
|
existingDevice.setModel(device.getModel());
|
needUpdate = true;
|
}
|
if (device.getFirmware() != null && !device.getFirmware().equals(existingDevice.getFirmware())) {
|
existingDevice.setFirmware(device.getFirmware());
|
needUpdate = true;
|
}
|
if (existingDevice.getOnLine() == null || !existingDevice.getOnLine()) {
|
existingDevice.setOnLine(true);
|
needUpdate = true;
|
}
|
if (needUpdate) {
|
gbDeviceService.updateGbDevice(existingDevice);
|
log.info("[GbDevice更新] deviceId: {}, name={}, ip={}, port={}, manufacturer={}, model={}, firmware={}",
|
device.getDeviceId(), existingDevice.getDeviceName(),
|
existingDevice.getIp(), existingDevice.getPort(),
|
existingDevice.getManufacturer(), existingDevice.getModel(), existingDevice.getFirmware());
|
}
|
}
|
} catch (Exception e) {
|
log.error("[GbDevice自动创建] 设备上线，自动创建失败：{}", device.getDeviceId(), e);
|
}
|
}
|
|
@Override
|
public void offline(String deviceId, String reason) {
|
Device device = getDeviceByDeviceId(deviceId);
|
if (device == null) {
|
log.warn("[设备不存在] device：{}", deviceId);
|
return;
|
}
|
|
// 主动查询设备状态, 没有 HostAddress 无法发送请求，可能是手动添加的设备
|
if (device.getHostAddress() != null) {
|
Boolean deviceStatus = getDeviceStatus(device);
|
if (deviceStatus != null && deviceStatus) {
|
log.info("[设备离线] 主动探测发现设备在线，暂不处理 device：{}", deviceId);
|
online(device, null);
|
return;
|
}
|
}
|
log.info("[设备离线] {}, device：{}， 心跳间隔： {}，心跳超时次数： {}， 上次心跳时间：{}， 上次注册时间： {}", reason, deviceId,
|
device.getHeartBeatInterval(), device.getHeartBeatCount(), device.getKeepaliveTime(), device.getRegisterTime());
|
device.setOnLine(false);
|
cleanOfflineDevice(device);
|
redisCatchStorage.updateDevice(device);
|
if (isDevice(deviceId)) {
|
channelOfflineByDevice(device);
|
}
|
|
// 同步更新 MySQL 在线状态
|
try {
|
GbDevice gbDevice = gbDeviceService.selectGbDeviceByGbDeviceId(deviceId);
|
if (gbDevice != null) {
|
gbDevice.setOnLine(false);
|
gbDeviceService.updateGbDevice(gbDevice);
|
log.info("[设备离线] 更新MySQL在线状态: {} -> offline", deviceId);
|
}
|
} catch (Exception e) {
|
log.error("[设备离线] 更新MySQL在线状态失败: {}", deviceId, e);
|
}
|
|
// 主动注销时：清理 Redis 中的通道数据，删除 MySQL 中该设备的通道记录
|
if ("主动注销".equals(reason)) {
|
try {
|
redisCatchStorage.cleanChannelsForDevice(deviceId);
|
log.info("[设备离线] 主动注销，已清理Redis通道: {}", deviceId);
|
} catch (Exception e) {
|
log.error("[设备离线] 清理Redis通道失败: {}", deviceId, e);
|
}
|
try {
|
List<GbChannel> channels = gbChannelService.selectGbChannelByGbDeviceId(deviceId);
|
int deletedCount = 0;
|
int skippedCount = 0;
|
for (GbChannel ch : channels) {
|
// 跳过正在推流的通道，避免误删
|
if ("1".equals(ch.getStreamStatus())) {
|
ch.setStreamStatus("0");
|
gbChannelService.updateGbChannelStream(ch);
|
skippedCount++;
|
continue;
|
}
|
gbChannelService.deleteGbChannelById(ch.getId());
|
deletedCount++;
|
}
|
log.info("[设备离线] 主动注销，已清理MySQL通道: {}条删除, {}条跳过", deletedCount, skippedCount);
|
} catch (Exception e) {
|
log.error("[设备离线] 清理MySQL通道失败: {}", deviceId, e);
|
}
|
}
|
}
|
|
/**
|
* 更新设备心跳信息
|
*
|
* @param device
|
*/
|
@Override
|
public void updateDeviceHeartInfo(Device device) {
|
Device deviceInDb = getDeviceByDeviceId(device.getDeviceId());
|
if (deviceInDb == null) {
|
return;
|
}
|
if (!Objects.equals(deviceInDb.getHeartBeatCount(), device.getHeartBeatCount())
|
|| !Objects.equals(deviceInDb.getHeartBeatInterval(), device.getHeartBeatInterval())) {
|
|
deviceInDb.setHeartBeatCount(device.getHeartBeatCount());
|
deviceInDb.setHeartBeatInterval(device.getHeartBeatInterval());
|
deviceInDb.setPositionCapability(device.getPositionCapability());
|
updateDevice(deviceInDb);
|
|
long expiresTime = Math.min(device.getExpires(), device.getHeartBeatInterval() * device.getHeartBeatCount()) * 1000L;
|
if (deviceStatusTaskRunner.containsKey(device.getDeviceId())) {
|
deviceStatusTaskRunner.updateDelay(device.getDeviceId(), expiresTime + System.currentTimeMillis());
|
}
|
}
|
}
|
|
/**
|
* 根据设备id和通道获取设备通道
|
*
|
* @param gbDeviceId
|
* @param gbChannelId
|
* @return
|
*/
|
@Override
|
public DeviceChannel getDeviceChannelByChannelId(String gbDeviceId, String gbChannelId) {
|
List<DeviceChannel> deviceChannels = redisCatchStorage.queryAllChannelsForRefresh(gbDeviceId);
|
if (deviceChannels.isEmpty()) {
|
throw new RuntimeException("设备【" + gbDeviceId + "】没有通道");
|
}
|
|
DeviceChannel deviceChannel = null;
|
for (DeviceChannel channel : deviceChannels) {
|
if (gbChannelId.equals(channel.getDeviceId())) {
|
deviceChannel = channel;
|
}
|
}
|
if (deviceChannel == null) {
|
throw new RuntimeException("设备【" + gbDeviceId + "】找不到【" + gbChannelId + "】通道");
|
}
|
return deviceChannel;
|
}
|
|
private void deviceStatusExpire(String deviceId, SipTransactionInfo transactionInfo) {
|
log.info("[设备状态] 到期， 编号： {}", deviceId);
|
offline(deviceId, "保活到期");
|
}
|
|
public Boolean getDeviceStatus(@NotNull Device device) {
|
SynchronousQueue<String> queue = new SynchronousQueue<>();
|
try {
|
commander.deviceStatusQuery(device, ((code, msg, data) -> {
|
queue.offer(msg);
|
}));
|
String data = queue.poll(10, TimeUnit.SECONDS);
|
if (data != null && "ONLINE".equalsIgnoreCase(data.trim())) {
|
return Boolean.TRUE;
|
} else {
|
return Boolean.FALSE;
|
}
|
|
} catch (InvalidArgumentException | SipException | ParseException | InterruptedException e) {
|
log.error("[命令发送失败] 设备状态查询: {}", e.getMessage());
|
}
|
return null;
|
}
|
|
/**
|
* 批量修改设备
|
*
|
* @param deviceList
|
*/
|
@Override
|
public void updateDeviceList(List<Device> deviceList) {
|
for (Device device : deviceList) {
|
redisCatchStorage.updateDevice(device);
|
}
|
}
|
|
/**
|
* 修改设备
|
*
|
* @param device
|
*/
|
@Override
|
public void updateDevice(Device device) {
|
redisCatchStorage.updateDevice(device);
|
}
|
|
public void sync(Device device) {
|
int sn = (int) ((Math.random() * 9 + 1) * 100000);
|
try {
|
commander.catalogQuery(device, sn, ((code, msg, data) -> {
|
// log.info("[获取通道]失败, deviceId： {}", device.getDeviceId());
|
}));
|
} catch (SipException | InvalidArgumentException | ParseException e) {
|
log.error("[获取通道]失败,信令发送失败, deviceId： {}", device.getDeviceId());
|
}
|
}
|
|
private boolean isDevice(String deviceId) {
|
GbCode decode = GbCode.decode(deviceId);
|
if (decode == null) {
|
return true;
|
}
|
int code = Integer.parseInt(decode.getTypeCode());
|
return code <= 199;
|
}
|
|
private void cleanOfflineDevice(Device device) {
|
if (subscribeTaskRunner.containsKey(SubscribeTaskForCatalog.getKey(device))) {
|
subscribeTaskRunner.removeSubscribe(SubscribeTaskForCatalog.getKey(device));
|
}
|
if (subscribeTaskRunner.containsKey(SubscribeTaskForMobilPosition.getKey(device))) {
|
subscribeTaskRunner.removeSubscribe(SubscribeTaskForMobilPosition.getKey(device));
|
}
|
|
// 清理设备相关的视频流会话
|
List<SsrcTransaction> ssrcTransactions = sessionManager.getSsrcTransactionByDeviceId(device.getDeviceId());
|
if (ssrcTransactions != null && !ssrcTransactions.isEmpty()) {
|
log.info("[设备离线] 清理设备相关的视频流会话, deviceId: {}, 会话数量: {}",
|
device.getDeviceId(), ssrcTransactions.size());
|
for (SsrcTransaction ssrcTransaction : ssrcTransactions) {
|
try {
|
log.info("[BYE 清理资源] deviceId: {}, channelId: {}, app: {}, stream: {}, ssrc: {}",
|
ssrcTransaction.getDeviceId(),
|
ssrcTransaction.getChannelId(),
|
ssrcTransaction.getApp(),
|
ssrcTransaction.getStream(),
|
ssrcTransaction.getSsrc());
|
|
sessionManager.removeByCallId(ssrcTransaction.getCallId());
|
remoteZlmService.releaseSsrc(ssrcTransaction.getMediaServerId(), ssrcTransaction.getSsrc(), SecurityConstants.INNER);
|
|
RtpServerParam rtpServerParam = new RtpServerParam();
|
rtpServerParam.setMediaServerId(ssrcTransaction.getMediaServerId());
|
rtpServerParam.setApp(ssrcTransaction.getApp());
|
rtpServerParam.setStream(ssrcTransaction.getStream());
|
rtpServerParam.setSsrc(ssrcTransaction.getSsrc());
|
rtpServerParam.setGbDeviceId(ssrcTransaction.getDeviceId());
|
rtpServerParam.setGbChannelId(ssrcTransaction.getChannelId());
|
remoteZlmService.closeRTPServer(ssrcTransaction.getMediaServerId(), rtpServerParam, SecurityConstants.INNER);
|
} catch (Exception e) {
|
log.error("[设备离线] 清理视频流会话异常, deviceId: {}, ssrc: {}",
|
device.getDeviceId(), ssrcTransaction.getSsrc(), e);
|
}
|
}
|
}
|
}
|
|
private void channelOfflineByDevice(Device device) {
|
// 进行通道离线
|
List<DeviceChannel> channelList = redisCatchStorage.queryAllChannelsForRefresh(device.getDeviceId());
|
if (channelList.isEmpty()) {
|
return;
|
}
|
for (DeviceChannel deviceChannel : channelList) {
|
deviceChannel.setStatus("OFF");
|
}
|
redisCatchStorage.batchUpdate(device.getDeviceId(), channelList);
|
}
|
|
/**
|
* 获取所有国标设备（从数据库查询，Redis 补充在线状态等运行时信息）
|
*
|
* @return 设备列表
|
*/
|
@Override
|
public List<Device> getAllDevices() {
|
List<Device> result = new java.util.ArrayList<>();
|
List<GbDevice> gbDevices = gbDeviceService.selectGbDeviceList(new GbDevice());
|
for (GbDevice gbDevice : gbDevices) {
|
// 从 Redis 获取运行时信息（在线状态、IP、端口等）
|
Device redisDevice = redisCatchStorage.getDevice(gbDevice.getGbDeviceId());
|
if (redisDevice != null) {
|
// 用数据库的名称/厂商/型号覆盖 Redis 数据
|
if (StringUtils.hasText(gbDevice.getDeviceName())) {
|
redisDevice.setName(gbDevice.getDeviceName());
|
}
|
if (StringUtils.hasText(gbDevice.getManufacturer())) {
|
redisDevice.setManufacturer(gbDevice.getManufacturer());
|
}
|
if (StringUtils.hasText(gbDevice.getModel())) {
|
redisDevice.setModel(gbDevice.getModel());
|
}
|
if (StringUtils.hasText(gbDevice.getFirmware())) {
|
redisDevice.setFirmware(gbDevice.getFirmware());
|
}
|
result.add(redisDevice);
|
} else {
|
// Redis 中没有（设备离线已久），用数据库数据构造基本 Device 对象
|
Device device = new Device();
|
device.setDeviceId(gbDevice.getGbDeviceId());
|
device.setName(StringUtils.hasText(gbDevice.getDeviceName())
|
? gbDevice.getDeviceName() : gbDevice.getGbDeviceId());
|
device.setOnLine(gbDevice.getOnLine() != null && gbDevice.getOnLine());
|
device.setIp(gbDevice.getIp());
|
device.setPort(gbDevice.getPort() != null ? gbDevice.getPort() : 0);
|
device.setManufacturer(gbDevice.getManufacturer());
|
device.setPort(gbDevice.getPort() != null ? gbDevice.getPort() : 0);
|
device.setManufacturer(gbDevice.getManufacturer());
|
device.setModel(gbDevice.getModel());
|
device.setFirmware(gbDevice.getFirmware());
|
result.add(device);
|
}
|
}
|
return result;
|
}
|
|
/**
|
* 获取所有国标设备（直接从 Redis 查询，用于迁移/同步等场景）
|
*
|
* @return 设备列表
|
*/
|
@Override
|
public List<Device> getAllRedisDevices() {
|
return redisCatchStorage.getAllDevices();
|
}
|
|
/**
|
* 根据设备id获取所有通道
|
*
|
* @param gbDeviceId 设备编号
|
* @return 通道列表
|
*/
|
@Override
|
public List<DeviceChannel> getChannelsByDeviceId(String gbDeviceId) {
|
return redisCatchStorage.queryAllChannelsForRefresh(gbDeviceId);
|
}
|
|
/**
|
* 通用前端控制命令(参考国标文档A.3.1指令格式)
|
*
|
* @param device 设备
|
* @param channelId 通道国标编号
|
* @param cmdCode 指令码(对应国标文档指令格式中的字节4)
|
* @param parameter1 数据一(对应国标文档指令格式中的字节5, 范围0-255)
|
* @param parameter2 数据二(对应国标文档指令格式中的字节6, 范围0-255)
|
* @param combindCode2 组合码二(对应国标文档指令格式中的字节7, 范围0-15)
|
*/
|
@Override
|
public void frontEndCommand(Device device, String channelId, Integer cmdCode, Integer parameter1, Integer parameter2, Integer combindCode2) {
|
try {
|
commander.frontEndCmd(device, channelId, cmdCode, parameter1, parameter2, combindCode2);
|
} catch (SipException | InvalidArgumentException | ParseException e) {
|
log.error("[命令发送失败] 前端控制: {}", e.getMessage());
|
throw new ServiceException("命令发送失败: " + e.getMessage());
|
}
|
}
|
|
/**
|
* 查询预置位
|
*
|
* @param device 设备国标编号
|
* @param channelId 通道国标编号
|
* @param callback
|
*/
|
@Override
|
public void queryPreset(Device device, String channelId, ErrorCallback<List<Preset>> callback) {
|
try {
|
commander.presetQuery(device, channelId, callback);
|
} catch (InvalidArgumentException | SipException | ParseException e) {
|
log.error("[命令发送失败] 预制位查询: {}", e.getMessage());
|
callback.run(ErrorCode.ERROR100.getCode(), "命令发送: " + e.getMessage(), null);
|
throw new ServiceException("命令发送失败: " + e.getMessage());
|
}
|
}
|
}
|
