aunix/wvp-GB28181-pro
1
0
Fork 0
mirror of https://gitee.com/pan648540858/wvp-GB28181-pro.git synced 2026-05-25 06:27:50 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

通用通道支持云台控制

Browse Source
This commit is contained in:
lin 2025-07-31 18:49:53 +08:00
parent edeb8d6b3f
commit 19b873ba5c
49 changed files with 941 additions and 381 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
src/main/java/com/genersoft/iot/vmp/common/enums/ChannelDataType.java
View File

@ -1,8 +1,5 @@
package com.genersoft.iot.vmp.common.enums; package com.genersoft.iot.vmp.common.enums;
import java.util.HashMap;
import java.util.Map;
/** /**
* 支持的通道数据类型 * 支持的通道数据类型
*/ */
@ -13,12 +10,11 @@ public class ChannelDataType {
public final static int STREAM_PUSH = 2; public final static int STREAM_PUSH = 2;
public final static int STREAM_PROXY = 3; public final static int STREAM_PROXY = 3;
public static Map<String, Integer> getDescMap() { public final static String PLAY_SERVICE = "sourceChannelPlayService";
Map<String, Integer> map = new HashMap<>(); public final static String PLAYBACK_SERVICE = "sourceChannelPlaybackService";
map.put("国标28181", ChannelDataType.GB28181); public final static String DOWNLOAD_SERVICE = "sourceChannelDownloadService";
map.put("推流设备", ChannelDataType.STREAM_PUSH); public final static String PTZ_SERVICE = "sourceChannelPTZService";
map.put("拉流代理", ChannelDataType.STREAM_PROXY);
return map;
}
} }

4
src/main/java/com/genersoft/iot/vmp/gb28181/bean/DeviceChannel.java
View File

@ -195,7 +195,7 @@ public class DeviceChannel extends CommonGBChannel {
@Schema(description = "通道类型， 默认0, 0： 普通通道，1 行政区划 2 业务分组/虚拟组织") @Schema(description = "通道类型， 默认0, 0： 普通通道，1 行政区划 2 业务分组/虚拟组织")
private int channelType; private int channelType;
private Integer dataType = ChannelDataType.GB28181.value; private Integer dataType = ChannelDataType.GB28181;
public void setPtzType(int ptzType) { public void setPtzType(int ptzType) {
this.ptzType = ptzType; this.ptzType = ptzType;
@ -255,7 +255,7 @@ public class DeviceChannel extends CommonGBChannel {
commonGBChannel.setGbId(id); commonGBChannel.setGbId(id);
commonGBChannel.setGbDeviceId(deviceId); commonGBChannel.setGbDeviceId(deviceId);
commonGBChannel.setGbName(name); commonGBChannel.setGbName(name);
commonGBChannel.setDataType(ChannelDataType.GB28181.value); commonGBChannel.setDataType(ChannelDataType.GB28181);
commonGBChannel.setDataDeviceId(getDataDeviceId()); commonGBChannel.setDataDeviceId(getDataDeviceId());
return commonGBChannel; return commonGBChannel;
} }

6
src/main/java/com/genersoft/iot/vmp/gb28181/controller/PlaybackController.java
View File

@ -165,10 +165,10 @@ public class PlaybackController {
@Operation(summary = "回放暂停", security = @SecurityRequirement(name = JwtUtils.HEADER)) @Operation(summary = "回放暂停", security = @SecurityRequirement(name = JwtUtils.HEADER))
@Parameter(name = "streamId", description = "回放流ID", required = true) @Parameter(name = "streamId", description = "回放流ID", required = true)
@GetMapping("/pause/{streamId}") @GetMapping("/pause/{streamId}")
public void playPause(@PathVariable String streamId) { public void playbackPause(@PathVariable String streamId) {
log.info("[回放暂停] streamId: {}", streamId); log.info("[回放暂停] streamId: {}", streamId);
try { try {
playService.pauseRtp(streamId); playService.playbackPause(streamId);
} catch (ServiceException e) { } catch (ServiceException e) {
throw new ControllerException(ErrorCode.ERROR400.getCode(), e.getMessage()); throw new ControllerException(ErrorCode.ERROR400.getCode(), e.getMessage());
} catch (InvalidArgumentException | ParseException | SipException e) { } catch (InvalidArgumentException | ParseException | SipException e) {
@ -183,7 +183,7 @@ public class PlaybackController {
public void playResume(@PathVariable String streamId) { public void playResume(@PathVariable String streamId) {
log.info("playResume: "+streamId); log.info("playResume: "+streamId);
try { try {
playService.resumeRtp(streamId); playService.playbackResume(streamId);
} catch (ServiceException e) { } catch (ServiceException e) {
throw new ControllerException(ErrorCode.ERROR400.getCode(), e.getMessage()); throw new ControllerException(ErrorCode.ERROR400.getCode(), e.getMessage());
} catch (InvalidArgumentException | ParseException | SipException e) { } catch (InvalidArgumentException | ParseException | SipException e) {

14
src/main/java/com/genersoft/iot/vmp/gb28181/dao/provider/DeviceChannelProvider.java
View File

@ -64,7 +64,7 @@ public class DeviceChannelProvider {
public String queryChannels(Map<String, Object> params ){ public String queryChannels(Map<String, Object> params ){
StringBuilder sqlBuild = new StringBuilder(); StringBuilder sqlBuild = new StringBuilder();
sqlBuild.append(getBaseSelectSql()); sqlBuild.append(getBaseSelectSql());
sqlBuild.append(" where data_type = " + ChannelDataType.GB28181.value); sqlBuild.append(" where data_type = " + ChannelDataType.GB28181);
if (params.get("dataDeviceId") != null) { if (params.get("dataDeviceId") != null) {
sqlBuild.append(" AND dc.data_device_id = #{dataDeviceId} "); sqlBuild.append(" AND dc.data_device_id = #{dataDeviceId} ");
} }
@ -122,14 +122,14 @@ public class DeviceChannelProvider {
public String queryChannelsByDeviceDbId(Map<String, Object> params ){ public String queryChannelsByDeviceDbId(Map<String, Object> params ){
StringBuilder sqlBuild = new StringBuilder(); StringBuilder sqlBuild = new StringBuilder();
sqlBuild.append(getBaseSelectSql()); sqlBuild.append(getBaseSelectSql());
sqlBuild.append(" where data_type = " + ChannelDataType.GB28181.value + " and dc.data_device_id = #{dataDeviceId}"); sqlBuild.append(" where data_type = " + ChannelDataType.GB28181 + " and dc.data_device_id = #{dataDeviceId}");
return sqlBuild.toString(); return sqlBuild.toString();
} }
public String queryAllChannels(Map<String, Object> params ){ public String queryAllChannels(Map<String, Object> params ){
StringBuilder sqlBuild = new StringBuilder(); StringBuilder sqlBuild = new StringBuilder();
sqlBuild.append(getBaseSelectSql()); sqlBuild.append(getBaseSelectSql());
sqlBuild.append(" where data_type = " + ChannelDataType.GB28181.value + " and dc.data_device_id = #{dataDeviceId}"); sqlBuild.append(" where data_type = " + ChannelDataType.GB28181 + " and dc.data_device_id = #{dataDeviceId}");
return sqlBuild.toString(); return sqlBuild.toString();
} }
@ -143,25 +143,25 @@ public class DeviceChannelProvider {
public String getOneByDeviceId(Map<String, Object> params ){ public String getOneByDeviceId(Map<String, Object> params ){
StringBuilder sqlBuild = new StringBuilder(); StringBuilder sqlBuild = new StringBuilder();
sqlBuild.append(getBaseSelectSql()); sqlBuild.append(getBaseSelectSql());
sqlBuild.append(" where data_type = " + ChannelDataType.GB28181.value + " and dc.data_device_id=#{dataDeviceId} and coalesce(dc.gb_device_id, dc.device_id) = #{channelId}"); sqlBuild.append(" where data_type = " + ChannelDataType.GB28181 + " and dc.data_device_id=#{dataDeviceId} and coalesce(dc.gb_device_id, dc.device_id) = #{channelId}");
return sqlBuild.toString(); return sqlBuild.toString();
} }
public String queryByDeviceId(Map<String, Object> params ){ public String queryByDeviceId(Map<String, Object> params ){
return getBaseSelectSql() + " where data_type = " + ChannelDataType.GB28181.value + " and channel_type = 0 and coalesce(gb_device_id, device_id) = #{gbDeviceId}"; return getBaseSelectSql() + " where data_type = " + ChannelDataType.GB28181 + " and channel_type = 0 and coalesce(gb_device_id, device_id) = #{gbDeviceId}";
} }
public String queryById(Map<String, Object> params ){ public String queryById(Map<String, Object> params ){
return getBaseSelectSql() + " where data_type = " + ChannelDataType.GB28181.value + " and channel_type = 0 and id = #{gbId}"; return getBaseSelectSql() + " where data_type = " + ChannelDataType.GB28181 + " and channel_type = 0 and id = #{gbId}";
} }
public String queryList(Map<String, Object> params ){ public String queryList(Map<String, Object> params ){
StringBuilder sqlBuild = new StringBuilder(); StringBuilder sqlBuild = new StringBuilder();
sqlBuild.append(getBaseSelectSql()); sqlBuild.append(getBaseSelectSql());
sqlBuild.append(" where channel_type = 0 and data_type = " + ChannelDataType.GB28181.value); sqlBuild.append(" where channel_type = 0 and data_type = " + ChannelDataType.GB28181);
if (params.get("query") != null) { if (params.get("query") != null) {
sqlBuild.append(" AND (coalesce(gb_device_id, device_id) LIKE concat('%',#{query},'%')" + sqlBuild.append(" AND (coalesce(gb_device_id, device_id) LIKE concat('%',#{query},'%')" +
" OR coalesce(gb_name, name) LIKE concat('%',#{query},'%') )") " OR coalesce(gb_name, name) LIKE concat('%',#{query},'%') )")

3
src/main/java/com/genersoft/iot/vmp/gb28181/service/IDeviceService.java
View File

@ -200,5 +200,6 @@ public interface IDeviceService {
void deviceInfo(Device device, ErrorCallback<Object> callback); void deviceInfo(Device device, ErrorCallback<Object> callback);
void queryPreset(Device device, String channelId, ErrorCallback<Object> callback); void queryPreset(Device device, String channelId, ErrorCallback<List<Preset>> callback);
} }

2
src/main/java/com/genersoft/iot/vmp/gb28181/service/IGbChannelControlService.java
View File

@ -11,11 +11,9 @@ public interface IGbChannelControlService {
void ptz(CommonGBChannel channel, FrontEndControlCodeForPTZ frontEndControlCode, ErrorCallback<String> callback); void ptz(CommonGBChannel channel, FrontEndControlCodeForPTZ frontEndControlCode, ErrorCallback<String> callback);
void fi(CommonGBChannel channel, FrontEndControlCodeForFI frontEndControlCode, ErrorCallback<String> callback); void fi(CommonGBChannel channel, FrontEndControlCodeForFI frontEndControlCode, ErrorCallback<String> callback);
void preset(CommonGBChannel channel, FrontEndControlCodeForPreset frontEndControlCode, ErrorCallback<String> callback); void preset(CommonGBChannel channel, FrontEndControlCodeForPreset frontEndControlCode, ErrorCallback<String> callback);
void queryPreset(CommonGBChannel channel, FrontEndControlCodeForPreset frontEndControlCode, ErrorCallback<String> callback);
void tour(CommonGBChannel channel, FrontEndControlCodeForTour frontEndControlCode, ErrorCallback<String> callback); void tour(CommonGBChannel channel, FrontEndControlCodeForTour frontEndControlCode, ErrorCallback<String> callback);
void scan(CommonGBChannel channel, FrontEndControlCodeForScan frontEndControlCode, ErrorCallback<String> callback); void scan(CommonGBChannel channel, FrontEndControlCodeForScan frontEndControlCode, ErrorCallback<String> callback);
void wiper(CommonGBChannel channel, FrontEndControlCodeForWiper controlCode, ErrorCallback<String> callback); void wiper(CommonGBChannel channel, FrontEndControlCodeForWiper controlCode, ErrorCallback<String> callback);
void auxiliary(CommonGBChannel channel, FrontEndControlCodeForAuxiliary frontEndControlCode, ErrorCallback<String> callback); void auxiliary(CommonGBChannel channel, FrontEndControlCodeForAuxiliary frontEndControlCode, ErrorCallback<String> callback);
void queryPreset(CommonGBChannel channel, ErrorCallback<List<Preset>> callback); void queryPreset(CommonGBChannel channel, ErrorCallback<List<Preset>> callback);
} }

27
src/main/java/com/genersoft/iot/vmp/gb28181/service/IGbChannelPlayService.java
View File

@ -9,25 +9,24 @@ import com.genersoft.iot.vmp.service.bean.ErrorCallback;
public interface IGbChannelPlayService { public interface IGbChannelPlayService {
void start(CommonGBChannel channel, InviteMessageInfo inviteInfo, Platform platform, ErrorCallback<StreamInfo> callback); void startInvite(CommonGBChannel channel, InviteMessageInfo inviteInfo, Platform platform, ErrorCallback<StreamInfo> callback);
void stopPlay(InviteSessionType type, CommonGBChannel channel, String stream); void stopInvite(InviteSessionType type, CommonGBChannel channel, String stream);
void playback(CommonGBChannel channel, Long startTime, Long stopTime, ErrorCallback<StreamInfo> callback);
void download(CommonGBChannel channel, Long startTime, Long stopTime, Integer downloadSpeed,
ErrorCallback<StreamInfo> callback);
void stopPlay(CommonGBChannel channel, String stream);
void play(CommonGBChannel channel, Platform platform, Boolean record, ErrorCallback<StreamInfo> callback); void play(CommonGBChannel channel, Platform platform, Boolean record, ErrorCallback<StreamInfo> callback);
void playGbDeviceChannel(CommonGBChannel channel, Boolean record, ErrorCallback<StreamInfo> callback); void stopPlayback(CommonGBChannel channel, String stream);
void stopPlayDeviceChannel(InviteSessionType type, CommonGBChannel channel, String stream); void stopDownload(CommonGBChannel channel, String stream);
void playProxy(CommonGBChannel channel, Boolean record, ErrorCallback<StreamInfo> callback); void playbackPause(CommonGBChannel channel, String streamId);
void stopPlayProxy(CommonGBChannel channel); void playbackResume(CommonGBChannel channel, String streamId);
void playPush(CommonGBChannel channel, String platformDeviceId, String platformName, ErrorCallback<StreamInfo> callback);
void stopPlayPush(CommonGBChannel channel);
void pauseRtp(String streamId);
void resumeRtp(String streamId);
} }

11
src/main/java/com/genersoft/iot/vmp/gb28181/service/IPTZService.java
View File

@ -4,21 +4,18 @@ package com.genersoft.iot.vmp.gb28181.service;
import com.genersoft.iot.vmp.gb28181.bean.CommonGBChannel; import com.genersoft.iot.vmp.gb28181.bean.CommonGBChannel;
import com.genersoft.iot.vmp.gb28181.bean.Device; import com.genersoft.iot.vmp.gb28181.bean.Device;
import com.genersoft.iot.vmp.gb28181.bean.Preset; import com.genersoft.iot.vmp.gb28181.bean.Preset;
import com.genersoft.iot.vmp.service.bean.ErrorCallback;
import java.util.List; import java.util.List;
public interface IPTZService { public interface IPTZService {
List<Preset> queryPresetList(String deviceId, String channelDeviceId);
void addPreset(Preset preset);
void deletePreset(Integer qq);
void ptz(Device device, String channelId, int cmdCode, int horizonSpeed, int verticalSpeed, int zoomSpeed); void ptz(Device device, String channelId, int cmdCode, int horizonSpeed, int verticalSpeed, int zoomSpeed);
void frontEndCommand(Device device, String channelId, int cmdCode, int parameter1, int parameter2, int combindCode2); void frontEndCommand(Device device, String channelId, int cmdCode, int parameter1, int parameter2, int combindCode2);
void frontEndCommand(CommonGBChannel channel, Integer cmdCode, Integer parameter1, Integer parameter2, Integer combindCode2); void frontEndCommand(CommonGBChannel channel, Integer cmdCode, Integer parameter1, Integer parameter2, Integer combindCode2);
void queryPresetList(CommonGBChannel channel, ErrorCallback<List<Preset>> callback);
} }

4
src/main/java/com/genersoft/iot/vmp/gb28181/service/IPlayService.java
View File

@ -48,9 +48,9 @@ public interface IPlayService {
void stopAudioBroadcast(Device device, DeviceChannel channel); void stopAudioBroadcast(Device device, DeviceChannel channel);
void pauseRtp(String streamId) throws ServiceException, InvalidArgumentException, ParseException, SipException; void playbackPause(String streamId) throws ServiceException, InvalidArgumentException, ParseException, SipException;
void resumeRtp(String streamId) throws ServiceException, InvalidArgumentException, ParseException, SipException; void playbackResume(String streamId) throws ServiceException, InvalidArgumentException, ParseException, SipException;
void startPushStream(SendRtpInfo sendRtpItem, DeviceChannel channel, SIPResponse sipResponse, Platform platform, CallIdHeader callIdHeader); void startPushStream(SendRtpInfo sendRtpItem, DeviceChannel channel, SIPResponse sipResponse, Platform platform, CallIdHeader callIdHeader);

15
src/main/java/com/genersoft/iot/vmp/gb28181/service/ISourceDownloadService.java Normal file
View File

@ -0,0 +1,15 @@
package com.genersoft.iot.vmp.gb28181.service;
import com.genersoft.iot.vmp.common.StreamInfo;
import com.genersoft.iot.vmp.gb28181.bean.CommonGBChannel;
import com.genersoft.iot.vmp.service.bean.ErrorCallback;
/**
* 资源能力接入-录像下载
*/
public interface ISourceDownloadService {
void download(CommonGBChannel channel, Long startTime, Long stopTime, Integer downloadSpeed, ErrorCallback<StreamInfo> callback);
void stopDownload(CommonGBChannel channel, String stream);
}

28
src/main/java/com/genersoft/iot/vmp/gb28181/service/ISourcePTZService.java Normal file
View File

@ -0,0 +1,28 @@
package com.genersoft.iot.vmp.gb28181.service;
import com.genersoft.iot.vmp.gb28181.bean.*;
import com.genersoft.iot.vmp.service.bean.ErrorCallback;
import java.util.List;
/**
* 资源能力接入-云台控制
*/
public interface ISourcePTZService {
void ptz(CommonGBChannel channel, FrontEndControlCodeForPTZ frontEndControlCode, ErrorCallback<String> callback);
void preset(CommonGBChannel channel, FrontEndControlCodeForPreset frontEndControlCode, ErrorCallback<String> callback);
void fi(CommonGBChannel channel, FrontEndControlCodeForFI frontEndControlCode, ErrorCallback<String> callback);
void tour(CommonGBChannel channel, FrontEndControlCodeForTour frontEndControlCode, ErrorCallback<String> callback);
void scan(CommonGBChannel channel, FrontEndControlCodeForScan frontEndControlCode, ErrorCallback<String> callback);
void auxiliary(CommonGBChannel channel, FrontEndControlCodeForAuxiliary frontEndControlCode, ErrorCallback<String> callback);
void wiper(CommonGBChannel channel, FrontEndControlCodeForWiper frontEndControlCode, ErrorCallback<String> callback);
void queryPreset(CommonGBChannel channel, ErrorCallback<List<Preset>> callback);
}

6
src/main/java/com/genersoft/iot/vmp/gb28181/service/ISourcePlayService.java
View File

@ -2,11 +2,15 @@ package com.genersoft.iot.vmp.gb28181.service;
import com.genersoft.iot.vmp.common.StreamInfo; import com.genersoft.iot.vmp.common.StreamInfo;
import com.genersoft.iot.vmp.gb28181.bean.CommonGBChannel; import com.genersoft.iot.vmp.gb28181.bean.CommonGBChannel;
import com.genersoft.iot.vmp.gb28181.bean.Platform;
import com.genersoft.iot.vmp.service.bean.ErrorCallback; import com.genersoft.iot.vmp.service.bean.ErrorCallback;
/**
* 资源能力接入-实时录像
*/
public interface ISourcePlayService { public interface ISourcePlayService {
void play(CommonGBChannel channel, Boolean record, ErrorCallback<StreamInfo> callback); void play(CommonGBChannel channel, Platform platform, Boolean record, ErrorCallback<StreamInfo> callback);
void stopPlay(CommonGBChannel channel, String stream); void stopPlay(CommonGBChannel channel, String stream);

17
src/main/java/com/genersoft/iot/vmp/gb28181/service/ISourcePlaybackService.java Normal file
View File

@ -0,0 +1,17 @@
package com.genersoft.iot.vmp.gb28181.service;
import com.genersoft.iot.vmp.common.StreamInfo;
import com.genersoft.iot.vmp.gb28181.bean.CommonGBChannel;
import com.genersoft.iot.vmp.service.bean.ErrorCallback;
/**
* 资源能力接入-录像回放
*/
public interface ISourcePlaybackService {
void playback(CommonGBChannel channel, Long startTime, Long stopTime, ErrorCallback<StreamInfo> callback);
void stopPlayback(CommonGBChannel channel, String stream);
void playbackPause(CommonGBChannel channel, String stream);
}

4
src/main/java/com/genersoft/iot/vmp/gb28181/service/impl/DeviceChannelServiceImpl.java
View File

@ -780,7 +780,7 @@ public class DeviceChannelServiceImpl implements IDeviceChannelService {
@Override @Override
public void addChannel(DeviceChannel channel) { public void addChannel(DeviceChannel channel) {
channel.setDataType(ChannelDataType.GB28181.value); channel.setDataType(ChannelDataType.GB28181);
channel.setDataDeviceId(channel.getDataDeviceId()); channel.setDataDeviceId(channel.getDataDeviceId());
channelMapper.add(channel); channelMapper.add(channel);
} }
@ -826,7 +826,7 @@ public class DeviceChannelServiceImpl implements IDeviceChannelService {
@Override @Override
public void queryRecordInfo(CommonGBChannel channel, String startTime, String endTime, ErrorCallback<RecordInfo> callback) { public void queryRecordInfo(CommonGBChannel channel, String startTime, String endTime, ErrorCallback<RecordInfo> callback) {
if (channel.getDataType() != ChannelDataType.GB28181.value){ if (channel.getDataType() != ChannelDataType.GB28181){
// 只支持国标的语音喊话 // 只支持国标的语音喊话
log.warn("[INFO 消息] 非国标设备， 通道ID： {}", channel.getGbId()); log.warn("[INFO 消息] 非国标设备， 通道ID： {}", channel.getGbId());
callback.run(ErrorCode.ERROR100.getCode(), "非国标设备", null); callback.run(ErrorCode.ERROR100.getCode(), "非国标设备", null);

14
src/main/java/com/genersoft/iot/vmp/gb28181/service/impl/DeviceServiceImpl.java
View File

@ -691,7 +691,7 @@ public class DeviceServiceImpl implements IDeviceService, CommandLineRunner {
@Override @Override
public List<Device> getAllByStatus(Boolean status) { public List<Device> getAllByStatus(Boolean status) {
return deviceMapper.getDevices(ChannelDataType.GB28181.value, status); return deviceMapper.getDevices(ChannelDataType.GB28181, status);
} }
@Override @Override
@ -852,7 +852,7 @@ public class DeviceServiceImpl implements IDeviceService, CommandLineRunner {
.replaceAll("%", "/%") .replaceAll("%", "/%")
.replaceAll("_", "/_"); .replaceAll("_", "/_");
} }
List<Device> all = deviceMapper.getDeviceList(ChannelDataType.GB28181.value, query, status); List<Device> all = deviceMapper.getDeviceList(ChannelDataType.GB28181, query, status);
return new PageInfo<>(all); return new PageInfo<>(all);
} }
@ -863,12 +863,12 @@ public class DeviceServiceImpl implements IDeviceService, CommandLineRunner {
@Override @Override
public Device getDeviceByChannelId(Integer channelId) { public Device getDeviceByChannelId(Integer channelId) {
return deviceMapper.queryByChannelId(ChannelDataType.GB28181.value,channelId); return deviceMapper.queryByChannelId(ChannelDataType.GB28181,channelId);
} }
@Override @Override
public Device getDeviceBySourceChannelDeviceId(String channelId) { public Device getDeviceBySourceChannelDeviceId(String channelId) {
return deviceMapper.getDeviceBySourceChannelDeviceId(ChannelDataType.GB28181.value,channelId); return deviceMapper.getDeviceBySourceChannelDeviceId(ChannelDataType.GB28181,channelId);
} }
@Override @Override
@ -1252,9 +1252,9 @@ public class DeviceServiceImpl implements IDeviceService, CommandLineRunner {
} }
@Override @Override
public void queryPreset(Device device, String channelId, ErrorCallback<Object> callback) { public void queryPreset(Device device, String channelId, ErrorCallback<List<Preset>> callback) {
if (!userSetting.getServerId().equals(device.getServerId())) { if (!userSetting.getServerId().equals(device.getServerId())) {
WVPResult<Object> result = redisRpcService.queryPreset(device.getServerId(), device, channelId); WVPResult<List<Preset>> result = redisRpcService.queryPreset(device.getServerId(), device, channelId);
callback.run(result.getCode(), result.getMsg(), result.getData()); callback.run(result.getCode(), result.getMsg(), result.getData());
return; return;
} }
@ -1267,4 +1267,6 @@ public class DeviceServiceImpl implements IDeviceService, CommandLineRunner {
throw new ControllerException(ErrorCode.ERROR100.getCode(), "命令发送失败: " + e.getMessage()); throw new ControllerException(ErrorCode.ERROR100.getCode(), "命令发送失败: " + e.getMessage());
} }
} }
} }

97
src/main/java/com/genersoft/iot/vmp/gb28181/service/impl/GbChannelControlServiceImpl.java
View File

@ -1,14 +1,17 @@
package com.genersoft.iot.vmp.gb28181.service.impl; package com.genersoft.iot.vmp.gb28181.service.impl;
import com.genersoft.iot.vmp.common.enums.ChannelDataType;
import com.genersoft.iot.vmp.gb28181.bean.*; import com.genersoft.iot.vmp.gb28181.bean.*;
import com.genersoft.iot.vmp.gb28181.service.IDeviceChannelService;
import com.genersoft.iot.vmp.gb28181.service.IGbChannelControlService; import com.genersoft.iot.vmp.gb28181.service.IGbChannelControlService;
import com.genersoft.iot.vmp.gb28181.service.ISourcePTZService;
import com.genersoft.iot.vmp.service.bean.ErrorCallback; import com.genersoft.iot.vmp.service.bean.ErrorCallback;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import javax.sip.message.Response;
import java.util.List; import java.util.List;
import java.util.Map;
@Service @Service
@Slf4j @Slf4j
@ -16,54 +19,110 @@ public class GbChannelControlServiceImpl implements IGbChannelControlService {
@Autowired @Autowired
private IDeviceChannelService deviceChannelService; private Map<String, ISourcePTZService> sourcePTZServiceMap;
@Override @Override
public void ptz(CommonGBChannel channel, FrontEndControlCodeForPTZ frontEndControlCode, ErrorCallback<String> callback) { public void ptz(CommonGBChannel channel, FrontEndControlCodeForPTZ frontEndControlCode, ErrorCallback<String> callback) {
// log.info("[通用通道] 云台控制， 通道： {}", channel.getGbDeviceId()); log.info("[通用通道] 云台控制， 类型： {}， 编号：{}", channel.getDataType(), channel.getGbDeviceId());
// if (channel.getDataType() == ChannelDataType.GB28181.value) { Integer dataType = channel.getDataType();
// ISourcePTZService sourcePTZService = sourcePTZServiceMap.get(ChannelDataType.PTZ_SERVICE + dataType);
// }else if() if (sourcePTZService == null) {
// 通道数据异常
log.error("[点播通用通道] 类型： {} 不支持云台控制", dataType);
throw new PlayException(Response.BUSY_HERE, "channel not support");
}
sourcePTZService.ptz(channel, frontEndControlCode, callback);
} }
@Override @Override
public void preset(CommonGBChannel channel, FrontEndControlCodeForPreset frontEndControlCode, ErrorCallback<String> callback) { public void preset(CommonGBChannel channel, FrontEndControlCodeForPreset frontEndControlCode, ErrorCallback<String> callback) {
log.info("[通用通道] 预置位， 通道： {}", channel.getGbDeviceId()); log.info("[通用通道] 预置位控制， 类型： {}， 编号：{}", channel.getDataType(), channel.getGbDeviceId());
Integer dataType = channel.getDataType();
ISourcePTZService sourcePTZService = sourcePTZServiceMap.get(ChannelDataType.PTZ_SERVICE + dataType);
if (sourcePTZService == null) {
// 通道数据异常
log.error("[点播通用通道] 类型： {} 不支持预置位控制", dataType);
throw new PlayException(Response.BUSY_HERE, "channel not support");
}
sourcePTZService.preset(channel, frontEndControlCode, callback);
} }
@Override @Override
public void fi(CommonGBChannel channel, FrontEndControlCodeForFI frontEndControlCode, ErrorCallback<String> callback) { public void fi(CommonGBChannel channel, FrontEndControlCodeForFI frontEndControlCode, ErrorCallback<String> callback) {
log.info("[通用通道] FI指令， 通道： {}", channel.getGbDeviceId()); log.info("[通用通道] FI指令， 类型： {}， 编号：{}", channel.getDataType(), channel.getGbDeviceId());
Integer dataType = channel.getDataType();
ISourcePTZService sourcePTZService = sourcePTZServiceMap.get(ChannelDataType.PTZ_SERVICE + dataType);
if (sourcePTZService == null) {
// 通道数据异常
log.error("[点播通用通道] 类型： {} 不支持FI指令", dataType);
throw new PlayException(Response.BUSY_HERE, "channel not support");
}
sourcePTZService.fi(channel, frontEndControlCode, callback);
} }
@Override @Override
public void tour(CommonGBChannel channel, FrontEndControlCodeForTour frontEndControlCode, ErrorCallback<String> callback) { public void tour(CommonGBChannel channel, FrontEndControlCodeForTour frontEndControlCode, ErrorCallback<String> callback) {
log.info("[通用通道] 巡航指令， 类型： {}， 编号：{}", channel.getDataType(), channel.getGbDeviceId());
Integer dataType = channel.getDataType();
ISourcePTZService sourcePTZService = sourcePTZServiceMap.get(ChannelDataType.PTZ_SERVICE + dataType);
if (sourcePTZService == null) {
// 通道数据异常
log.error("[点播通用通道] 类型： {} 不支持巡航指令", dataType);
throw new PlayException(Response.BUSY_HERE, "channel not support");
}
sourcePTZService.tour(channel, frontEndControlCode, callback);
} }
@Override @Override
public void scan(CommonGBChannel channel, FrontEndControlCodeForScan frontEndControlCode, ErrorCallback<String> callback) { public void scan(CommonGBChannel channel, FrontEndControlCodeForScan frontEndControlCode, ErrorCallback<String> callback) {
log.info("[通用通道] 扫描指令， 类型： {}， 编号：{}", channel.getDataType(), channel.getGbDeviceId());
Integer dataType = channel.getDataType();
ISourcePTZService sourcePTZService = sourcePTZServiceMap.get(ChannelDataType.PTZ_SERVICE + dataType);
if (sourcePTZService == null) {
// 通道数据异常
log.error("[点播通用通道] 类型： {} 不支持扫描指令", dataType);
throw new PlayException(Response.BUSY_HERE, "channel not support");
}
sourcePTZService.scan(channel, frontEndControlCode, callback);
} }
@Override @Override
public void auxiliary(CommonGBChannel channel, FrontEndControlCodeForAuxiliary frontEndControlCode, ErrorCallback<String> callback) { public void auxiliary(CommonGBChannel channel, FrontEndControlCodeForAuxiliary frontEndControlCode, ErrorCallback<String> callback) {
log.info("[通用通道] 辅助开关控制指令， 类型： {}， 编号：{}", channel.getDataType(), channel.getGbDeviceId());
Integer dataType = channel.getDataType();
ISourcePTZService sourcePTZService = sourcePTZServiceMap.get(ChannelDataType.PTZ_SERVICE + dataType);
if (sourcePTZService == null) {
// 通道数据异常
log.error("[点播通用通道] 类型： {} 不支持辅助开关控制指令", dataType);
throw new PlayException(Response.BUSY_HERE, "channel not support");
}
sourcePTZService.auxiliary(channel, frontEndControlCode, callback);
} }
@Override @Override
public void queryPreset(CommonGBChannel channel, FrontEndControlCodeForPreset frontEndControlCode, ErrorCallback<String> callback) { public void wiper(CommonGBChannel channel, FrontEndControlCodeForWiper frontEndControlCode, ErrorCallback<String> callback) {
log.info("[通用通道] 雨刷控制， 类型： {}， 编号：{}", channel.getDataType(), channel.getGbDeviceId());
} Integer dataType = channel.getDataType();
ISourcePTZService sourcePTZService = sourcePTZServiceMap.get(ChannelDataType.PTZ_SERVICE + dataType);
@Override if (sourcePTZService == null) {
public void wiper(CommonGBChannel channel, FrontEndControlCodeForWiper controlCode, ErrorCallback<String> callback) { // 通道数据异常
log.error("[点播通用通道] 类型： {} 不支持雨刷控制", dataType);
throw new PlayException(Response.BUSY_HERE, "channel not support");
}
sourcePTZService.wiper(channel, frontEndControlCode, callback);
} }
@Override @Override
public void queryPreset(CommonGBChannel channel, ErrorCallback<List<Preset>> callback) { public void queryPreset(CommonGBChannel channel, ErrorCallback<List<Preset>> callback) {
log.info("[通用通道] 预置位查询， 类型： {}， 编号：{}", channel.getDataType(), channel.getGbDeviceId());
Integer dataType = channel.getDataType();
ISourcePTZService sourcePTZService = sourcePTZServiceMap.get(ChannelDataType.PTZ_SERVICE + dataType);
if (sourcePTZService == null) {
// 通道数据异常
log.error("[点播通用通道] 类型： {} 不支持预置位查询", dataType);
throw new PlayException(Response.BUSY_HERE, "channel not support");
}
sourcePTZService.queryPreset(channel, callback);
} }
} }

270
src/main/java/com/genersoft/iot/vmp/gb28181/service/impl/GbChannelPlayServiceImpl.java
View File

@ -4,50 +4,38 @@ import com.genersoft.iot.vmp.common.InviteSessionType;
import com.genersoft.iot.vmp.common.StreamInfo; import com.genersoft.iot.vmp.common.StreamInfo;
import com.genersoft.iot.vmp.common.enums.ChannelDataType; import com.genersoft.iot.vmp.common.enums.ChannelDataType;
import com.genersoft.iot.vmp.conf.UserSetting; import com.genersoft.iot.vmp.conf.UserSetting;
import com.genersoft.iot.vmp.conf.exception.ControllerException;
import com.genersoft.iot.vmp.conf.exception.ServiceException;
import com.genersoft.iot.vmp.gb28181.bean.CommonGBChannel; import com.genersoft.iot.vmp.gb28181.bean.CommonGBChannel;
import com.genersoft.iot.vmp.gb28181.bean.InviteMessageInfo; import com.genersoft.iot.vmp.gb28181.bean.InviteMessageInfo;
import com.genersoft.iot.vmp.gb28181.bean.Platform; import com.genersoft.iot.vmp.gb28181.bean.Platform;
import com.genersoft.iot.vmp.gb28181.bean.PlayException; import com.genersoft.iot.vmp.gb28181.bean.PlayException;
import com.genersoft.iot.vmp.gb28181.service.IGbChannelPlayService; import com.genersoft.iot.vmp.gb28181.service.*;
import com.genersoft.iot.vmp.gb28181.service.IPlayService;
import com.genersoft.iot.vmp.gb28181.service.ISourcePlayService;
import com.genersoft.iot.vmp.service.bean.ErrorCallback; import com.genersoft.iot.vmp.service.bean.ErrorCallback;
import com.genersoft.iot.vmp.streamProxy.service.IStreamProxyPlayService;
import com.genersoft.iot.vmp.streamPush.service.IStreamPushPlayService;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import javax.sip.InvalidArgumentException;
import javax.sip.SipException;
import javax.sip.message.Response; import javax.sip.message.Response;
import java.text.ParseException;
import java.util.Map; import java.util.Map;
@Slf4j @Slf4j
@Service @Service
public class GbChannelPlayServiceImpl implements IGbChannelPlayService { public class GbChannelPlayServiceImpl implements IGbChannelPlayService {
@Autowired
private IPlayService deviceChannelPlayService;
@Autowired
private IStreamProxyPlayService streamProxyPlayService;
@Autowired
private IStreamPushPlayService streamPushPlayService;
@Autowired @Autowired
private UserSetting userSetting; private UserSetting userSetting;
@Autowired @Autowired
private Map<String, ISourcePlayService> sourcePlayServiceMap; private Map<String, ISourcePlayService> sourcePlayServiceMap;
@Autowired
private Map<String, ISourcePlaybackService> sourcePlaybackServiceMap;
@Autowired
private Map<String, ISourceDownloadService> sourceDownloadServiceMap;
@Override @Override
public void start(CommonGBChannel channel, InviteMessageInfo inviteInfo, Platform platform, ErrorCallback<StreamInfo> callback) { public void startInvite(CommonGBChannel channel, InviteMessageInfo inviteInfo, Platform platform, ErrorCallback<StreamInfo> callback) {
if (channel == null || inviteInfo == null || callback == null || channel.getDataType() == null) { if (channel == null || inviteInfo == null || callback == null || channel.getDataType() == null) {
log.warn("[通用通道点播] 参数异常, channel: {}, inviteInfo: {}, callback: {}", channel != null, inviteInfo != null, callback != null); log.warn("[通用通道点播] 参数异常, channel: {}, inviteInfo: {}, callback: {}", channel != null, inviteInfo != null, callback != null);
throw new PlayException(Response.SERVER_INTERNAL_ERROR, "server internal error"); throw new PlayException(Response.SERVER_INTERNAL_ERROR, "server internal error");
@ -57,46 +45,11 @@ public class GbChannelPlayServiceImpl implements IGbChannelPlayService {
if ("Play".equalsIgnoreCase(inviteInfo.getSessionName())) { if ("Play".equalsIgnoreCase(inviteInfo.getSessionName())) {
play(channel, platform, userSetting.getRecordSip(), callback); play(channel, platform, userSetting.getRecordSip(), callback);
}else if ("Playback".equals(inviteInfo.getSessionName())) { }else if ("Playback".equals(inviteInfo.getSessionName())) {
if (channel.getDataType() == ChannelDataType.GB28181.value) { playback(channel, inviteInfo.getStartTime(), inviteInfo.getStopTime(), callback);
// 国标通道
playbackGbDeviceChannel(channel, inviteInfo.getStartTime(), inviteInfo.getStopTime(), callback);
} else if (channel.getDataType() == ChannelDataType.STREAM_PROXY.value) {
// 拉流代理
log.warn("[回放通用通道] 不支持回放拉流代理的录像： {}({})", channel.getGbName(), channel.getGbDeviceId());
throw new PlayException(Response.FORBIDDEN, "forbidden");
} else if (channel.getDataType() == ChannelDataType.STREAM_PUSH.value) {
// 推流
log.warn("[回放通用通道] 不支持回放推流的录像： {}({})", channel.getGbName(), channel.getGbDeviceId());
throw new PlayException(Response.FORBIDDEN, "forbidden");
} else {
// 通道数据异常
log.error("[回放通用通道] 通道数据异常，无法识别通道来源： {}({})", channel.getGbName(), channel.getGbDeviceId());
throw new PlayException(Response.SERVER_INTERNAL_ERROR, "server internal error");
}
}else if ("Download".equals(inviteInfo.getSessionName())) { }else if ("Download".equals(inviteInfo.getSessionName())) {
if (channel.getDataType() == ChannelDataType.GB28181.value) { Integer downloadSpeed = Integer.parseInt(inviteInfo.getDownloadSpeed());
int downloadSpeed = 4; // 国标通道
try { download(channel, inviteInfo.getStartTime(), inviteInfo.getStopTime(), downloadSpeed, callback);
if (inviteInfo.getDownloadSpeed() != null){
downloadSpeed = Integer.parseInt(inviteInfo.getDownloadSpeed());
}
}catch (Exception ignored) {}
// 国标通道
downloadGbDeviceChannel(channel, inviteInfo.getStartTime(), inviteInfo.getStopTime(), downloadSpeed, callback);
} else if (channel.getDataType() == ChannelDataType.STREAM_PROXY.value) {
// 拉流代理
log.warn("[下载通用通道录像] 不支持下载拉流代理的录像： {}({})", channel.getGbName(), channel.getGbDeviceId());
throw new PlayException(Response.FORBIDDEN, "forbidden");
} else if (channel.getDataType() == ChannelDataType.STREAM_PUSH.value) {
// 推流
log.warn("[下载通用通道录像] 不支持下载推流的录像： {}({})", channel.getGbName(), channel.getGbDeviceId());
throw new PlayException(Response.FORBIDDEN, "forbidden");
} else {
// 通道数据异常
log.error("[回放通用通道] 通道数据异常，无法识别通道来源： {}({})", channel.getGbName(), channel.getGbDeviceId());
throw new PlayException(Response.SERVER_INTERNAL_ERROR, "server internal error");
}
}else { }else {
// 不支持的点播方式 // 不支持的点播方式
log.error("[点播通用通道] 不支持的点播方式：{}， {}({})", inviteInfo.getSessionName(), channel.getGbName(), channel.getGbDeviceId()); log.error("[点播通用通道] 不支持的点播方式：{}， {}({})", inviteInfo.getSessionName(), channel.getGbName(), channel.getGbDeviceId());
@ -105,20 +58,21 @@ public class GbChannelPlayServiceImpl implements IGbChannelPlayService {
} }
@Override @Override
public void stopPlay(InviteSessionType type, CommonGBChannel channel, String stream) { public void stopInvite(InviteSessionType type, CommonGBChannel channel, String stream) {
if (channel.getDataType() == ChannelDataType.GB28181.value) { switch (type) {
// 国标通道 case PLAY:
stopPlayDeviceChannel(type, channel, stream); stopPlay(channel, stream);
} else if (channel.getDataType() == ChannelDataType.STREAM_PROXY.value) { break;
// 拉流代理 case PLAYBACK:
stopPlayProxy(channel); stopPlayback(channel, stream);
} else if (channel.getDataType() == ChannelDataType.STREAM_PUSH.value) { break;
// 推流 case DOWNLOAD:
stopPlayPush(channel); stopDownload(channel, stream);
} else { break;
// 通道数据异常 default:
log.error("[点播通用通道] 通道数据异常，无法识别通道来源： {}({})", channel.getGbName(), channel.getGbDeviceId()); // 通道数据异常
throw new PlayException(Response.SERVER_INTERNAL_ERROR, "server internal error"); log.error("[点播通用通道] 类型编号： {} 不支持此类型请求", type);
throw new PlayException(Response.BUSY_HERE, "channel not support");
} }
} }
@ -126,140 +80,102 @@ public class GbChannelPlayServiceImpl implements IGbChannelPlayService {
public void play(CommonGBChannel channel, Platform platform, Boolean record, ErrorCallback<StreamInfo> callback) { public void play(CommonGBChannel channel, Platform platform, Boolean record, ErrorCallback<StreamInfo> callback) {
log.info("[通用通道] 播放， 类型： {}， 编号：{}", channel.getDataType(), channel.getGbDeviceId()); log.info("[通用通道] 播放， 类型： {}， 编号：{}", channel.getDataType(), channel.getGbDeviceId());
Integer dataType = channel.getDataType(); Integer dataType = channel.getDataType();
ISourcePlayService sourceChannelPlayService = sourcePlayServiceMap.get("SourceChannelPlayService" + dataType); ISourcePlayService sourceChannelPlayService = sourcePlayServiceMap.get(ChannelDataType.PLAY_SERVICE + dataType);
if (sourceChannelPlayService == null) { if (sourceChannelPlayService == null) {
// 通道数据异常 // 通道数据异常
log.error("[点播通用通道] 类型编号： {} 不支持实时流预览", dataType); log.error("[点播通用通道] 类型编号： {} 不支持实时流预览", dataType);
throw new PlayException(Response.BUSY_HERE, "channel not support"); throw new PlayException(Response.BUSY_HERE, "channel not support");
} }
sourceChannelPlayService.play(channel, record, callback); sourceChannelPlayService.play(channel, platform, record, callback);
}
@Override
public void playback(CommonGBChannel channel, Long startTime, Long stopTime, ErrorCallback<StreamInfo> callback) {
if (channel.getDataType() == ChannelDataType.GB28181.value) { log.info("[通用通道] 回放， 类型： {}， 编号：{}", channel.getDataType(), channel.getGbDeviceId());
// 国标通道 Integer dataType = channel.getDataType();
playGbDeviceChannel(channel, record, callback); ISourcePlaybackService playbackService = sourcePlaybackServiceMap.get(ChannelDataType.PLAYBACK_SERVICE + dataType);
} else if (channel.getDataType() == ChannelDataType.STREAM_PROXY.value) { if (playbackService == null) {
// 拉流代理
playProxy(channel, record, callback);
} else if (channel.getDataType() == ChannelDataType.STREAM_PUSH.value) {
if (platform != null) {
// 推流
playPush(channel, platform.getServerGBId(), platform.getName(), callback);
}else {
// 推流
playPush(channel, null, null, callback);
}
} else {
// 通道数据异常 // 通道数据异常
log.error("[点播通用通道] 通道数据异常，无法识别通道来源： {}({})", channel.getGbName(), channel.getGbDeviceId()); log.error("[点播通用通道] 类型编号： {} 不支持回放", dataType);
throw new PlayException(Response.SERVER_INTERNAL_ERROR, "server internal error"); throw new PlayException(Response.BUSY_HERE, "channel not support");
} }
playbackService.playback(channel, startTime, stopTime, callback);
} }
@Override @Override
public void playGbDeviceChannel(CommonGBChannel channel, Boolean record, ErrorCallback<StreamInfo> callback){ public void download(CommonGBChannel channel, Long startTime, Long stopTime, Integer downloadSpeed,
// 国标通道 ErrorCallback<StreamInfo> callback){
try { log.info("[通用通道] 录像下载， 类型： {}， 编号：{}", channel.getDataType(), channel.getGbDeviceId());
deviceChannelPlayService.play(channel, record, callback); Integer dataType = channel.getDataType();
} catch (PlayException e) { ISourceDownloadService downloadService = sourceDownloadServiceMap.get(ChannelDataType.DOWNLOAD_SERVICE + dataType);
callback.run(e.getCode(), e.getMsg(), null); if (downloadService == null) {
} catch (ControllerException e) { // 通道数据异常
log.error("[点播失败] {}({}), {}", channel.getGbName(), channel.getGbDeviceId(), e.getMsg()); log.error("[点播通用通道] 类型编号： {} 不支持录像下载", dataType);
callback.run(Response.BUSY_HERE, "busy here", null); throw new PlayException(Response.BUSY_HERE, "channel not support");
} catch (Exception e) {
log.error("[点播失败] {}({})", channel.getGbName(), channel.getGbDeviceId(), e);
callback.run(Response.BUSY_HERE, "busy here", null);
} }
downloadService.download(channel, startTime, stopTime, downloadSpeed, callback);
} }
@Override @Override
public void stopPlayDeviceChannel(InviteSessionType type, CommonGBChannel channel, String stream) { public void stopPlay(CommonGBChannel channel, String stream) {
// 国标通道 Integer dataType = channel.getDataType();
try { ISourcePlayService sourceChannelPlayService = sourcePlayServiceMap.get(ChannelDataType.PLAY_SERVICE + dataType);
deviceChannelPlayService.stop(type, channel, stream); if (sourceChannelPlayService == null) {
} catch (Exception e) { // 通道数据异常
log.error("[停止点播失败] {}({})", channel.getGbName(), channel.getGbDeviceId(), e); log.error("[点播通用通道] 类型编号： {} 不支持停止实时流", dataType);
throw new PlayException(Response.BUSY_HERE, "channel not support");
} }
sourceChannelPlayService.stopPlay(channel, stream);
} }
@Override @Override
public void playProxy(CommonGBChannel channel, Boolean record, ErrorCallback<StreamInfo> callback){ public void stopPlayback(CommonGBChannel channel, String stream) {
// 拉流代理通道 log.info("[通用通道] 停止回放， 类型： {}， 编号：{}", channel.getDataType(), channel.getGbDeviceId());
try { Integer dataType = channel.getDataType();
streamProxyPlayService.start(channel.getDataDeviceId(), record, callback); ISourcePlaybackService playbackService = sourcePlaybackServiceMap.get(ChannelDataType.PLAYBACK_SERVICE + dataType);
}catch (Exception e) { if (playbackService == null) {
callback.run(Response.BUSY_HERE, "busy here", null); // 通道数据异常
log.error("[点播通用通道] 类型编号： {} 不支持回放", dataType);
throw new PlayException(Response.BUSY_HERE, "channel not support");
} }
playbackService.stopPlayback(channel, stream);
} }
@Override @Override
public void stopPlayProxy(CommonGBChannel channel) { public void stopDownload(CommonGBChannel channel, String stream) {
// 拉流代理通道 log.info("[通用通道] 停止录像下载， 类型： {}， 编号：{} stream: {}", channel.getDataType(), channel.getGbDeviceId(), stream);
try { Integer dataType = channel.getDataType();
streamProxyPlayService.stop(channel.getDataDeviceId()); ISourceDownloadService downloadService = sourceDownloadServiceMap.get(ChannelDataType.DOWNLOAD_SERVICE + dataType);
}catch (Exception e) { if (downloadService == null) {
log.error("[停止点播失败] {}({})", channel.getGbName(), channel.getGbDeviceId(), e); // 通道数据异常
log.error("[点播通用通道] 类型编号： {} 不支持录像下载", dataType);
throw new PlayException(Response.BUSY_HERE, "channel not support");
} }
downloadService.stopDownload(channel, stream);
} }
@Override @Override
public void playPush(CommonGBChannel channel, String platformDeviceId, String platformName, ErrorCallback<StreamInfo> callback){ public void playbackPause(CommonGBChannel channel, String stream) {
// 推流 log.info("[通用通道] 回放暂停， 类型： {}， 编号：{} stream：{}", channel.getDataType(), channel.getGbDeviceId(), stream);
try { Integer dataType = channel.getDataType();
streamPushPlayService.start(channel.getDataDeviceId(), callback, platformDeviceId, platformName); ISourcePlaybackService playbackService = sourcePlaybackServiceMap.get(ChannelDataType.PLAYBACK_SERVICE + dataType);
}catch (PlayException e) { if (playbackService == null) {
callback.run(e.getCode(), e.getMsg(), null); // 通道数据异常
}catch (Exception e) { log.error("[点播通用通道] 类型编号： {} 不支持回放暂停", dataType);
log.error("[点播推流通道失败] 通道： {}({})", channel.getGbName(), channel.getGbDeviceId(), e); throw new PlayException(Response.BUSY_HERE, "channel not support");
callback.run(Response.BUSY_HERE, "busy here", null);
} }
playbackService.playbackPause(channel, stream);
} }
@Override @Override
public void stopPlayPush(CommonGBChannel channel) { public void playbackResume(CommonGBChannel channel, String stream) {
// 推流 log.info("[通用通道] 回放暂停恢复， 类型： {}， 编号：{} stream：{}", channel.getDataType(), channel.getGbDeviceId(), stream);
try { Integer dataType = channel.getDataType();
streamPushPlayService.stop(channel.getDataDeviceId()); ISourcePlaybackService playbackService = sourcePlaybackServiceMap.get(ChannelDataType.PLAYBACK_SERVICE + dataType);
}catch (Exception e) { if (playbackService == null) {
log.error("[停止点播失败] {}({})", channel.getGbName(), channel.getGbDeviceId(), e); // 通道数据异常
log.error("[点播通用通道] 类型编号： {} 不支持回放暂停恢复", dataType);
throw new PlayException(Response.BUSY_HERE, "channel not support");
} }
playbackService.playbackPause(channel, stream);
} }
private void playbackGbDeviceChannel(CommonGBChannel channel, Long startTime, Long stopTime, ErrorCallback<StreamInfo> callback){
try {
deviceChannelPlayService.playBack(channel, startTime, stopTime, callback);
} catch (PlayException e) {
callback.run(e.getCode(), e.getMsg(), null);
} catch (Exception e) {
callback.run(Response.BUSY_HERE, "busy here", null);
}
}
@Override
public void pauseRtp(String streamId) {
try {
deviceChannelPlayService.pauseRtp(streamId);
} catch (ServiceException | InvalidArgumentException | ParseException | SipException ignore) {}
}
@Override
public void resumeRtp(String streamId) {
try {
deviceChannelPlayService.resumeRtp(streamId);
} catch (ServiceException | InvalidArgumentException | ParseException | SipException ignore) {}
}
private void downloadGbDeviceChannel(CommonGBChannel channel, Long startTime, Long stopTime, Integer downloadSpeed,
ErrorCallback<StreamInfo> callback){
try {
deviceChannelPlayService.download(channel, startTime, stopTime, downloadSpeed, callback);
} catch (PlayException e) {
callback.run(e.getCode(), e.getMsg(), null);
} catch (Exception e) {
callback.run(Response.BUSY_HERE, "busy here", null);
}
}
} }

20
src/main/java/com/genersoft/iot/vmp/gb28181/service/impl/GbChannelServiceImpl.java
View File

@ -366,12 +366,12 @@ public class GbChannelServiceImpl implements IGbChannelService {
log.warn("[重置国标通道] 未找到对应Id的通道: id: {}", id); log.warn("[重置国标通道] 未找到对应Id的通道: id: {}", id);
throw new ControllerException(ErrorCode.ERROR400); throw new ControllerException(ErrorCode.ERROR400);
} }
if (channel.getDataType() != ChannelDataType.GB28181.value) { if (channel.getDataType() != ChannelDataType.GB28181) {
log.warn("[重置国标通道] 非国标下级通道无法重置: id: {}", id); log.warn("[重置国标通道] 非国标下级通道无法重置: id: {}", id);
throw new ControllerException(ErrorCode.ERROR100.getCode(), "非国标下级通道无法重置"); throw new ControllerException(ErrorCode.ERROR100.getCode(), "非国标下级通道无法重置");
} }
// 这个多加一个参数,为了防止将非国标的通道通过此方法清空内容,导致意外发生 // 这个多加一个参数,为了防止将非国标的通道通过此方法清空内容,导致意外发生
commonGBChannelMapper.reset(id, ChannelDataType.GB28181.value, channel.getDataDeviceId(), DateUtil.getNow()); commonGBChannelMapper.reset(id, ChannelDataType.GB28181, channel.getDataDeviceId(), DateUtil.getNow());
CommonGBChannel channelNew = getOne(id); CommonGBChannel channelNew = getOne(id);
// 发送通过更新通知 // 发送通过更新通知
try { try {
@ -494,7 +494,7 @@ public class GbChannelServiceImpl implements IGbChannelService {
@Override @Override
public void addChannelToRegionByGbDevice(String civilCode, List<Integer> deviceIds) { public void addChannelToRegionByGbDevice(String civilCode, List<Integer> deviceIds) {
List<CommonGBChannel> channelList = commonGBChannelMapper.queryByGbDeviceIds(ChannelDataType.GB28181.value, deviceIds); List<CommonGBChannel> channelList = commonGBChannelMapper.queryByGbDeviceIds(ChannelDataType.GB28181, deviceIds);
if (channelList.isEmpty()) { if (channelList.isEmpty()) {
throw new ControllerException(ErrorCode.ERROR100.getCode(), "所有通道Id不存在"); throw new ControllerException(ErrorCode.ERROR100.getCode(), "所有通道Id不存在");
} }
@ -515,7 +515,7 @@ public class GbChannelServiceImpl implements IGbChannelService {
@Override @Override
public void deleteChannelToRegionByGbDevice(List<Integer> deviceIds) { public void deleteChannelToRegionByGbDevice(List<Integer> deviceIds) {
List<CommonGBChannel> channelList = commonGBChannelMapper.queryByGbDeviceIds(ChannelDataType.GB28181.value, deviceIds); List<CommonGBChannel> channelList = commonGBChannelMapper.queryByGbDeviceIds(ChannelDataType.GB28181, deviceIds);
if (channelList.isEmpty()) { if (channelList.isEmpty()) {
throw new ControllerException(ErrorCode.ERROR100.getCode(), "所有通道Id不存在"); throw new ControllerException(ErrorCode.ERROR100.getCode(), "所有通道Id不存在");
} }
@ -632,7 +632,7 @@ public class GbChannelServiceImpl implements IGbChannelService {
@Override @Override
@Transactional @Transactional
public void addChannelToGroupByGbDevice(String parentId, String businessGroup, List<Integer> deviceIds) { public void addChannelToGroupByGbDevice(String parentId, String businessGroup, List<Integer> deviceIds) {
List<CommonGBChannel> channelList = commonGBChannelMapper.queryByGbDeviceIds(ChannelDataType.GB28181.value, deviceIds); List<CommonGBChannel> channelList = commonGBChannelMapper.queryByGbDeviceIds(ChannelDataType.GB28181, deviceIds);
if (channelList.isEmpty()) { if (channelList.isEmpty()) {
throw new ControllerException(ErrorCode.ERROR100.getCode(), "所有通道Id不存在"); throw new ControllerException(ErrorCode.ERROR100.getCode(), "所有通道Id不存在");
} }
@ -660,7 +660,7 @@ public class GbChannelServiceImpl implements IGbChannelService {
@Override @Override
public void deleteChannelToGroupByGbDevice(List<Integer> deviceIds) { public void deleteChannelToGroupByGbDevice(List<Integer> deviceIds) {
List<CommonGBChannel> channelList = commonGBChannelMapper.queryByGbDeviceIds(ChannelDataType.GB28181.value, deviceIds); List<CommonGBChannel> channelList = commonGBChannelMapper.queryByGbDeviceIds(ChannelDataType.GB28181, deviceIds);
if (channelList.isEmpty()) { if (channelList.isEmpty()) {
throw new ControllerException(ErrorCode.ERROR100.getCode(), "所有通道Id不存在"); throw new ControllerException(ErrorCode.ERROR100.getCode(), "所有通道Id不存在");
} }
@ -702,7 +702,7 @@ public class GbChannelServiceImpl implements IGbChannelService {
@Override @Override
public List<CommonGBChannel> queryListByStreamPushList(List<StreamPush> streamPushList) { public List<CommonGBChannel> queryListByStreamPushList(List<StreamPush> streamPushList) {
return commonGBChannelMapper.queryListByStreamPushList(ChannelDataType.STREAM_PUSH.value, streamPushList); return commonGBChannelMapper.queryListByStreamPushList(ChannelDataType.STREAM_PUSH, streamPushList);
} }
@Override @Override
@ -719,13 +719,13 @@ public class GbChannelServiceImpl implements IGbChannelService {
@Override @Override
public void queryRecordInfo(CommonGBChannel channel, String startTime, String endTime, ErrorCallback<RecordInfo> callback) { public void queryRecordInfo(CommonGBChannel channel, String startTime, String endTime, ErrorCallback<RecordInfo> callback) {
if (channel.getDataType() == ChannelDataType.GB28181.value) { if (channel.getDataType() == ChannelDataType.GB28181) {
deviceChannelService.queryRecordInfo(channel, startTime, endTime, callback); deviceChannelService.queryRecordInfo(channel, startTime, endTime, callback);
} else if (channel.getDataType() == ChannelDataType.STREAM_PROXY.value) { } else if (channel.getDataType() == ChannelDataType.STREAM_PROXY) {
// 拉流代理 // 拉流代理
log.warn("[下载通用通道录像] 不支持下载拉流代理的录像： {}({})", channel.getGbName(), channel.getGbDeviceId()); log.warn("[下载通用通道录像] 不支持下载拉流代理的录像： {}({})", channel.getGbName(), channel.getGbDeviceId());
throw new PlayException(Response.FORBIDDEN, "forbidden"); throw new PlayException(Response.FORBIDDEN, "forbidden");
} else if (channel.getDataType() == ChannelDataType.STREAM_PUSH.value) { } else if (channel.getDataType() == ChannelDataType.STREAM_PUSH) {
// 推流 // 推流
log.warn("[下载通用通道录像] 不支持下载推流的录像： {}({})", channel.getGbName(), channel.getGbDeviceId()); log.warn("[下载通用通道录像] 不支持下载推流的录像： {}({})", channel.getGbName(), channel.getGbDeviceId());
throw new PlayException(Response.FORBIDDEN, "forbidden"); throw new PlayException(Response.FORBIDDEN, "forbidden");

31
src/main/java/com/genersoft/iot/vmp/gb28181/service/impl/PTZServiceImpl.java
View File

@ -11,6 +11,7 @@ import com.genersoft.iot.vmp.gb28181.service.IDeviceChannelService;
import com.genersoft.iot.vmp.gb28181.service.IDeviceService; import com.genersoft.iot.vmp.gb28181.service.IDeviceService;
import com.genersoft.iot.vmp.gb28181.service.IPTZService; import com.genersoft.iot.vmp.gb28181.service.IPTZService;
import com.genersoft.iot.vmp.gb28181.transmit.cmd.impl.SIPCommander; import com.genersoft.iot.vmp.gb28181.transmit.cmd.impl.SIPCommander;
import com.genersoft.iot.vmp.service.bean.ErrorCallback;
import com.genersoft.iot.vmp.service.redisMsg.IRedisRpcPlayService; import com.genersoft.iot.vmp.service.redisMsg.IRedisRpcPlayService;
import com.genersoft.iot.vmp.vmanager.bean.ErrorCode; import com.genersoft.iot.vmp.vmanager.bean.ErrorCode;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
@ -21,7 +22,6 @@ import org.springframework.util.Assert;
import javax.sip.InvalidArgumentException; import javax.sip.InvalidArgumentException;
import javax.sip.SipException; import javax.sip.SipException;
import java.text.ParseException; import java.text.ParseException;
import java.util.Collections;
import java.util.List; import java.util.List;
@Slf4j @Slf4j
@ -78,7 +78,7 @@ public class PTZServiceImpl implements IPTZService {
@Override @Override
public void frontEndCommand(CommonGBChannel channel, Integer cmdCode, Integer parameter1, Integer parameter2, Integer combindCode2) { public void frontEndCommand(CommonGBChannel channel, Integer cmdCode, Integer parameter1, Integer parameter2, Integer combindCode2) {
if (channel.getDataType() != ChannelDataType.GB28181.value) { if (channel.getDataType() != ChannelDataType.GB28181) {
// 只有国标通道的支持云台控制 // 只有国标通道的支持云台控制
log.warn("[INFO 消息] 只有国标通道的支持云台控制， 通道ID： {}", channel.getGbId()); log.warn("[INFO 消息] 只有国标通道的支持云台控制， 通道ID： {}", channel.getGbId());
throw new ControllerException(ErrorCode.ERROR100.getCode(), "不支持"); throw new ControllerException(ErrorCode.ERROR100.getCode(), "不支持");
@ -92,17 +92,20 @@ public class PTZServiceImpl implements IPTZService {
} }
@Override @Override
public List<Preset> queryPresetList(String deviceId, String channelDeviceId) { public void queryPresetList(CommonGBChannel channel, ErrorCallback<List<Preset>> callback) {
return Collections.emptyList(); if (channel.getDataType() != ChannelDataType.GB28181) {
} // 只有国标通道的支持云台控制
log.warn("[INFO 消息] 只有国标通道的支持云台控制， 通道ID： {}", channel.getGbId());
@Override throw new ControllerException(ErrorCode.ERROR100.getCode(), "不支持");
public void addPreset(Preset preset) { }
Device device = deviceService.getDevice(channel.getDataDeviceId());
} if (device == null) {
throw new ControllerException(ErrorCode.ERROR100.getCode(), "未找到设备");
@Override }
public void deletePreset(Integer qq) { DeviceChannel deviceChannel = deviceChannelService.getOneForSourceById(channel.getGbId());
if (deviceChannel == null) {
throw new ControllerException(ErrorCode.ERROR100.getCode(), "未找到通道");
}
deviceService.queryPreset(device, deviceChannel.getDeviceId(), callback);
} }
} }

4
src/main/java/com/genersoft/iot/vmp/gb28181/service/impl/PlatformChannelServiceImpl.java
View File

@ -296,14 +296,14 @@ public class PlatformChannelServiceImpl implements IPlatformChannelService {
@Override @Override
@Transactional @Transactional
public void addChannelByDevice(Integer platformId, List<Integer> deviceIds) { public void addChannelByDevice(Integer platformId, List<Integer> deviceIds) {
List<Integer> channelList = commonGBChannelMapper.queryByGbDeviceIdsForIds(ChannelDataType.GB28181.value, deviceIds); List<Integer> channelList = commonGBChannelMapper.queryByGbDeviceIdsForIds(ChannelDataType.GB28181, deviceIds);
addChannels(platformId, channelList); addChannels(platformId, channelList);
} }
@Override @Override
@Transactional @Transactional
public void removeChannelByDevice(Integer platformId, List<Integer> deviceIds) { public void removeChannelByDevice(Integer platformId, List<Integer> deviceIds) {
List<Integer> channelList = commonGBChannelMapper.queryByGbDeviceIdsForIds(ChannelDataType.GB28181.value, deviceIds); List<Integer> channelList = commonGBChannelMapper.queryByGbDeviceIdsForIds(ChannelDataType.GB28181, deviceIds);
removeChannels(platformId, channelList); removeChannels(platformId, channelList);
} }

8
src/main/java/com/genersoft/iot/vmp/gb28181/service/impl/PlayServiceImpl.java
View File

@ -1392,7 +1392,7 @@ public class PlayServiceImpl implements IPlayService {
} }
@Override @Override
public void pauseRtp(String streamId) throws ServiceException, InvalidArgumentException, ParseException, SipException { public void playbackPause(String streamId) throws ServiceException, InvalidArgumentException, ParseException, SipException {
InviteInfo inviteInfo = inviteStreamService.getInviteInfoByStream(InviteSessionType.PLAYBACK, streamId); InviteInfo inviteInfo = inviteStreamService.getInviteInfoByStream(InviteSessionType.PLAYBACK, streamId);
if (null == inviteInfo || inviteInfo.getStreamInfo() == null) { if (null == inviteInfo || inviteInfo.getStreamInfo() == null) {
@ -1403,7 +1403,7 @@ public class PlayServiceImpl implements IPlayService {
throw new ControllerException(ErrorCode.ERROR100.getCode(), "设备不存在"); throw new ControllerException(ErrorCode.ERROR100.getCode(), "设备不存在");
} }
if (!userSetting.getServerId().equals(device.getServerId())) { if (!userSetting.getServerId().equals(device.getServerId())) {
redisRpcPlayService.pauseRtp(device.getServerId(), streamId); redisRpcPlayService.playbackPause(device.getServerId(), streamId);
return; return;
} }
@ -1430,7 +1430,7 @@ public class PlayServiceImpl implements IPlayService {
} }
@Override @Override
public void resumeRtp(String streamId) throws ServiceException, InvalidArgumentException, ParseException, SipException { public void playbackResume(String streamId) throws ServiceException, InvalidArgumentException, ParseException, SipException {
InviteInfo inviteInfo = inviteStreamService.getInviteInfoByStream(InviteSessionType.PLAYBACK, streamId); InviteInfo inviteInfo = inviteStreamService.getInviteInfoByStream(InviteSessionType.PLAYBACK, streamId);
if (null == inviteInfo || inviteInfo.getStreamInfo() == null) { if (null == inviteInfo || inviteInfo.getStreamInfo() == null) {
throw new ControllerException(ErrorCode.ERROR100.getCode(), "streamId不存在"); throw new ControllerException(ErrorCode.ERROR100.getCode(), "streamId不存在");
@ -1440,7 +1440,7 @@ public class PlayServiceImpl implements IPlayService {
throw new ControllerException(ErrorCode.ERROR100.getCode(), "设备不存在"); throw new ControllerException(ErrorCode.ERROR100.getCode(), "设备不存在");
} }
if (!userSetting.getServerId().equals(device.getServerId())) { if (!userSetting.getServerId().equals(device.getServerId())) {
redisRpcPlayService.resumeRtp(device.getServerId(), streamId); redisRpcPlayService.playbackResume(device.getServerId(), streamId);
return; return;
} }

35
src/main/java/com/genersoft/iot/vmp/gb28181/service/impl/SourceDownloadServiceForGbImpl.java Normal file
View File

@ -0,0 +1,35 @@
package com.genersoft.iot.vmp.gb28181.service.impl;
import com.genersoft.iot.vmp.common.InviteSessionType;
import com.genersoft.iot.vmp.common.StreamInfo;
import com.genersoft.iot.vmp.common.enums.ChannelDataType;
import com.genersoft.iot.vmp.gb28181.bean.CommonGBChannel;
import com.genersoft.iot.vmp.gb28181.service.IPlayService;
import com.genersoft.iot.vmp.gb28181.service.ISourceDownloadService;
import com.genersoft.iot.vmp.service.bean.ErrorCallback;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Slf4j
@Service(ChannelDataType.DOWNLOAD_SERVICE + ChannelDataType.GB28181)
public class SourceDownloadServiceForGbImpl implements ISourceDownloadService {
@Autowired
private IPlayService deviceChannelPlayService;
@Override
public void download(CommonGBChannel channel, Long startTime, Long stopTime, Integer downloadSpeed, ErrorCallback<StreamInfo> callback) {
}
@Override
public void stopDownload(CommonGBChannel channel, String stream) {
// 国标通道
try {
deviceChannelPlayService.stop(InviteSessionType.DOWNLOAD, channel, stream);
} catch (Exception e) {
log.error("[停止下载失败] {}({})", channel.getGbName(), channel.getGbDeviceId(), e);
}
}
}

297
src/main/java/com/genersoft/iot/vmp/gb28181/service/impl/SourcePTZServiceForGbImpl.java Normal file
View File

@ -0,0 +1,297 @@
package com.genersoft.iot.vmp.gb28181.service.impl;
import com.genersoft.iot.vmp.common.enums.ChannelDataType;
import com.genersoft.iot.vmp.conf.exception.ControllerException;
import com.genersoft.iot.vmp.gb28181.bean.*;
import com.genersoft.iot.vmp.gb28181.service.IPTZService;
import com.genersoft.iot.vmp.gb28181.service.ISourcePTZService;
import com.genersoft.iot.vmp.service.bean.ErrorCallback;
import com.genersoft.iot.vmp.vmanager.bean.ErrorCode;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Slf4j
@Service(ChannelDataType.PTZ_SERVICE + ChannelDataType.GB28181)
public class SourcePTZServiceForGbImpl implements ISourcePTZService {
@Autowired
private IPTZService ptzService;
public void frontEndCommand(CommonGBChannel channel, Integer cmdCode, Integer parameter1, Integer parameter2, Integer combindCode2){
if (parameter1 == null || parameter1 < 0 || parameter1 > 100) {
throw new ControllerException(ErrorCode.ERROR100.getCode(), "parameter1 为 0-255的数字");
}
// 返回转换为国标定义的范围
parameter1 = (int)(parameter1/100D* 255);
if (parameter2 == null || parameter2 < 0 || parameter2 > 100) {
throw new ControllerException(ErrorCode.ERROR100.getCode(), "parameter2 为 0-255的数字");
}
// 返回转换为国标定义的范围
parameter2 = (int)(parameter2/100D* 255);
if (combindCode2 == null || combindCode2 < 0 || combindCode2 > 100) {
throw new ControllerException(ErrorCode.ERROR100.getCode(), "combindCode2 为 0-15的数字");
}
combindCode2 = (int)(combindCode2/100D* 16);
ptzService.frontEndCommand(channel, cmdCode, parameter1, parameter2, combindCode2);
}
@Override
public void ptz(CommonGBChannel channel, FrontEndControlCodeForPTZ frontEndControlCode, ErrorCallback<String> callback) {
try {
int cmdCode = 0;
int panSpeed = 0;
int titleSpeed = 0;
int zoomSpeed = 0;
if (frontEndControlCode != null) {
if (frontEndControlCode.getPan() != null) {
if (frontEndControlCode.getPan() == 0) {
cmdCode = cmdCode | 1 << 1;
} else if (frontEndControlCode.getPan() == 1) {
cmdCode = cmdCode | 1;
}
}
if (frontEndControlCode.getTilt() != null) {
if (frontEndControlCode.getTilt() == 0) {
cmdCode = cmdCode | 1 << 3;
} else if (frontEndControlCode.getTilt() == 1) {
cmdCode = cmdCode | 1 << 2;
}
}
if (frontEndControlCode.getZoom() != null) {
if (frontEndControlCode.getZoom() == 0) {
cmdCode = cmdCode | 1 << 5;
} else if (frontEndControlCode.getZoom() == 1) {
cmdCode = cmdCode | 1 << 4;
}
}
panSpeed = frontEndControlCode.getPanSpeed();
titleSpeed = frontEndControlCode.getTiltSpeed();
zoomSpeed = frontEndControlCode.getZoomSpeed();
}
frontEndCommand(channel, cmdCode, panSpeed, titleSpeed, zoomSpeed);
callback.run(ErrorCode.SUCCESS.getCode(), ErrorCode.SUCCESS.getMsg(), null);
}catch (Exception e) {
log.error("[云台控制失败] ", e);
callback.run(ErrorCode.ERROR100.getCode(), e.getMessage(), null);
}
}
@Override
public void preset(CommonGBChannel channel, FrontEndControlCodeForPreset frontEndControlCode, ErrorCallback<String> callback) {
try {
int cmdCode = 0;
int parameter1 = 0;
int parameter2 = 0;
int parameter3 = 0;
if (frontEndControlCode != null) {
if (frontEndControlCode.getCode() != null) {
if (frontEndControlCode.getCode() == 1) {
cmdCode = 0x81;
} else if (frontEndControlCode.getCode() == 2) {
cmdCode = 0x82;
}else if (frontEndControlCode.getCode() == 3) {
cmdCode = 0x83;
}
}
if (frontEndControlCode.getPresetId() != null) {
parameter2 = frontEndControlCode.getPresetId();
}
}
frontEndCommand(channel, cmdCode, parameter1, parameter2, parameter3);
callback.run(ErrorCode.SUCCESS.getCode(), ErrorCode.SUCCESS.getMsg(), null);
}catch (Exception e) {
log.error("[预置位控制失败] ", e);
callback.run(ErrorCode.ERROR100.getCode(), e.getMessage(), null);
}
}
@Override
public void fi(CommonGBChannel channel, FrontEndControlCodeForFI frontEndControlCode, ErrorCallback<String> callback) {
try {
int cmdCode = 1 << 6;
int focusSpeed = 0;
int irisSpeed = 0;
int parameter3 = 0;
if (frontEndControlCode != null) {
if (frontEndControlCode.getFocus() != null) {
if (frontEndControlCode.getFocus() == 0) {
cmdCode = cmdCode | 1 << 1;
} else if (frontEndControlCode.getFocus() == 1) {
cmdCode = cmdCode | 1;
}else {
log.error("[FI失败] 未知的聚焦指令 {}", frontEndControlCode.getFocus());
callback.run(ErrorCode.ERROR100.getCode(), "未知的指令", null);
}
}
if (frontEndControlCode.getIris() != null) {
if (frontEndControlCode.getIris() == 0) {
cmdCode = cmdCode | 1 << 3;
} else if (frontEndControlCode.getIris() == 1) {
cmdCode = cmdCode | 1 << 2;
}else {
log.error("[FI失败] 未知的光圈指令 {}", frontEndControlCode.getIris());
callback.run(ErrorCode.ERROR100.getCode(), "未知的指令", null);
}
}
if (frontEndControlCode.getFocusSpeed() != null) {
focusSpeed = frontEndControlCode.getFocusSpeed();
}
if (frontEndControlCode.getIrisSpeed() != null) {
irisSpeed = frontEndControlCode.getIrisSpeed();
}
}
frontEndCommand(channel, cmdCode, focusSpeed, irisSpeed, parameter3);
callback.run(ErrorCode.SUCCESS.getCode(), ErrorCode.SUCCESS.getMsg(), null);
}catch (Exception e) {
log.error("[云台控制失败] ", e);
callback.run(ErrorCode.ERROR100.getCode(), e.getMessage(), null);
}
}
@Override
public void tour(CommonGBChannel channel, FrontEndControlCodeForTour frontEndControlCode, ErrorCallback<String> callback) {
try {
int cmdCode = 0;
int parameter1 = 0;
int parameter2 = 0;
int parameter3 = 0;
if (frontEndControlCode != null) {
if (frontEndControlCode.getCode() != null) {
if (frontEndControlCode.getCode() == 1) {
cmdCode = 0x84;
} else if (frontEndControlCode.getCode() == 2) {
cmdCode = 0x85;
}else if (frontEndControlCode.getCode() == 3) {
cmdCode = 0x86;
parameter3 = frontEndControlCode.getTourSpeed();
}else if (frontEndControlCode.getCode() == 4) {
cmdCode = 0x87;
parameter3 = frontEndControlCode.getTourTime();
}else if (frontEndControlCode.getCode() == 5) {
cmdCode = 0x88;
}else {
log.error("[巡航控制失败] 未知的指令 {}", frontEndControlCode.getCode());
callback.run(ErrorCode.ERROR100.getCode(), "未知的指令", null);
}
parameter1 = frontEndControlCode.getTourId();
}
if (frontEndControlCode.getPresetId() != null) {
parameter2 = frontEndControlCode.getPresetId();
}
}
frontEndCommand(channel, cmdCode, parameter1, parameter2, parameter3);
callback.run(ErrorCode.SUCCESS.getCode(), ErrorCode.SUCCESS.getMsg(), null);
}catch (Exception e) {
log.error("[巡航控制失败] ", e);
callback.run(ErrorCode.ERROR100.getCode(), e.getMessage(), null);
}
}
@Override
public void scan(CommonGBChannel channel, FrontEndControlCodeForScan frontEndControlCode, ErrorCallback<String> callback) {
try {
int cmdCode = 0;
int parameter1 = 0;
int parameter2 = 0;
int parameter3 = 0;
if (frontEndControlCode != null) {
if (frontEndControlCode.getCode() != null) {
if (frontEndControlCode.getCode() == 1) {
cmdCode = 0x89;
parameter1 = frontEndControlCode.getScanId();
} else if (frontEndControlCode.getCode() == 2) {
cmdCode = 0x89;
parameter1 = frontEndControlCode.getScanId();
parameter2 = 1;
}else if (frontEndControlCode.getCode() == 3) {
cmdCode = 0x89;
parameter1 = frontEndControlCode.getScanId();
parameter2 = 2;
}else if (frontEndControlCode.getCode() == 4) {
cmdCode = 0x8A;
parameter1 = frontEndControlCode.getScanId();
parameter2 = frontEndControlCode.getScanSpeed();
}else if (frontEndControlCode.getCode() == 5) {
}else {
log.error("[巡航控制失败] 未知的指令 {}", frontEndControlCode.getCode());
callback.run(ErrorCode.ERROR100.getCode(), "未知的指令", null);
}
}
}
frontEndCommand(channel, cmdCode, parameter1, parameter2, parameter3);
callback.run(ErrorCode.SUCCESS.getCode(), ErrorCode.SUCCESS.getMsg(), null);
}catch (Exception e) {
log.error("[巡航控制失败] ", e);
callback.run(ErrorCode.ERROR100.getCode(), e.getMessage(), null);
}
}
@Override
public void auxiliary(CommonGBChannel channel, FrontEndControlCodeForAuxiliary frontEndControlCode, ErrorCallback<String> callback) {
try {
int cmdCode = 0;
int parameter1 = 0;
int parameter2 = 0;
int parameter3 = 0;
if (frontEndControlCode != null) {
if (frontEndControlCode.getCode() != null) {
if (frontEndControlCode.getCode() == 1) {
cmdCode = 0x8C;
parameter1 = frontEndControlCode.getAuxiliaryId();
} else if (frontEndControlCode.getCode() == 2) {
cmdCode = 0x8D;
parameter1 = frontEndControlCode.getAuxiliaryId();
}else {
log.error("[辅助开关失败] 未知的指令 {}", frontEndControlCode.getCode());
callback.run(ErrorCode.ERROR100.getCode(), "未知的指令", null);
}
}
}
frontEndCommand(channel, cmdCode, parameter1, parameter2, parameter3);
callback.run(ErrorCode.SUCCESS.getCode(), ErrorCode.SUCCESS.getMsg(), null);
}catch (Exception e) {
log.error("[辅助开关失败] ", e);
callback.run(ErrorCode.ERROR100.getCode(), e.getMessage(), null);
}
}
@Override
public void wiper(CommonGBChannel channel, FrontEndControlCodeForWiper frontEndControlCode, ErrorCallback<String> callback) {
try {
int cmdCode = 0;
int parameter1 = 1;
int parameter2 = 0;
int parameter3 = 0;
if (frontEndControlCode != null) {
if (frontEndControlCode.getCode() != null) {
if (frontEndControlCode.getCode() == 1) {
cmdCode = 0x8C;
} else if (frontEndControlCode.getCode() == 2) {
cmdCode = 0x8D;
}else {
log.error("[雨刷开关失败] 未知的指令 {}", frontEndControlCode.getCode());
callback.run(ErrorCode.ERROR100.getCode(), "未知的指令", null);
}
}
}
frontEndCommand(channel, cmdCode, parameter1, parameter2, parameter3);
callback.run(ErrorCode.SUCCESS.getCode(), ErrorCode.SUCCESS.getMsg(), null);
}catch (Exception e) {
log.error("[雨刷开关失败] ", e);
callback.run(ErrorCode.ERROR100.getCode(), e.getMessage(), null);
}
}
@Override
public void queryPreset(CommonGBChannel channel, ErrorCallback<List<Preset>> callback) {
ptzService.queryPresetList(channel, callback);
}
}

37
src/main/java/com/genersoft/iot/vmp/gb28181/service/impl/SourcePlayServiceForGbImpl.java
View File

@ -1,22 +1,51 @@
package com.genersoft.iot.vmp.gb28181.service.impl; package com.genersoft.iot.vmp.gb28181.service.impl;
import com.genersoft.iot.vmp.common.InviteSessionType;
import com.genersoft.iot.vmp.common.StreamInfo; import com.genersoft.iot.vmp.common.StreamInfo;
import com.genersoft.iot.vmp.common.enums.ChannelDataType; import com.genersoft.iot.vmp.common.enums.ChannelDataType;
import com.genersoft.iot.vmp.conf.exception.ControllerException;
import com.genersoft.iot.vmp.gb28181.bean.CommonGBChannel; import com.genersoft.iot.vmp.gb28181.bean.CommonGBChannel;
import com.genersoft.iot.vmp.gb28181.bean.Platform;
import com.genersoft.iot.vmp.gb28181.bean.PlayException;
import com.genersoft.iot.vmp.gb28181.service.IPlayService;
import com.genersoft.iot.vmp.gb28181.service.ISourcePlayService; import com.genersoft.iot.vmp.gb28181.service.ISourcePlayService;
import com.genersoft.iot.vmp.service.bean.ErrorCallback; import com.genersoft.iot.vmp.service.bean.ErrorCallback;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
@Service("SourcePlayService" + ChannelDataType.GB28181) import javax.sip.message.Response;
@Slf4j
@Service(ChannelDataType.PLAY_SERVICE + ChannelDataType.GB28181)
public class SourcePlayServiceForGbImpl implements ISourcePlayService { public class SourcePlayServiceForGbImpl implements ISourcePlayService {
@Override @Autowired
public void play(CommonGBChannel channel, Boolean record, ErrorCallback<StreamInfo> callback) { private IPlayService deviceChannelPlayService;
@Override
public void play(CommonGBChannel channel, Platform platform, Boolean record, ErrorCallback<StreamInfo> callback) {
// 国标通道
try {
deviceChannelPlayService.play(channel, record, callback);
} catch (PlayException e) {
callback.run(e.getCode(), e.getMsg(), null);
} catch (ControllerException e) {
log.error("[点播失败] {}({}), {}", channel.getGbName(), channel.getGbDeviceId(), e.getMsg());
callback.run(Response.BUSY_HERE, "busy here", null);
} catch (Exception e) {
log.error("[点播失败] {}({})", channel.getGbName(), channel.getGbDeviceId(), e);
callback.run(Response.BUSY_HERE, "busy here", null);
}
} }
@Override @Override
public void stopPlay(CommonGBChannel channel, String stream) { public void stopPlay(CommonGBChannel channel, String stream) {
// 国标通道
try {
deviceChannelPlayService.stop(InviteSessionType.PLAY, channel, stream);
} catch (Exception e) {
log.error("[停止点播失败] {}({})", channel.getGbName(), channel.getGbDeviceId(), e);
}
} }
} }

49
src/main/java/com/genersoft/iot/vmp/gb28181/service/impl/SourcePlaybackServiceForGbImpl.java Normal file
View File

@ -0,0 +1,49 @@
package com.genersoft.iot.vmp.gb28181.service.impl;
import com.genersoft.iot.vmp.common.InviteSessionType;
import com.genersoft.iot.vmp.common.StreamInfo;
import com.genersoft.iot.vmp.common.enums.ChannelDataType;
import com.genersoft.iot.vmp.gb28181.bean.CommonGBChannel;
import com.genersoft.iot.vmp.gb28181.bean.PlayException;
import com.genersoft.iot.vmp.gb28181.service.IPlayService;
import com.genersoft.iot.vmp.gb28181.service.ISourcePlaybackService;
import com.genersoft.iot.vmp.service.bean.ErrorCallback;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import javax.sip.message.Response;
@Slf4j
@Service(ChannelDataType.PLAYBACK_SERVICE + ChannelDataType.GB28181)
public class SourcePlaybackServiceForGbImpl implements ISourcePlaybackService {
@Autowired
private IPlayService deviceChannelPlayService;
@Override
public void playback(CommonGBChannel channel, Long startTime, Long stopTime, ErrorCallback<StreamInfo> callback) {
try {
deviceChannelPlayService.playBack(channel, startTime, stopTime, callback);
} catch (PlayException e) {
callback.run(e.getCode(), e.getMsg(), null);
} catch (Exception e) {
callback.run(Response.BUSY_HERE, "busy here", null);
}
}
@Override
public void stopPlayback(CommonGBChannel channel, String stream) {
// 国标通道
try {
deviceChannelPlayService.stop(InviteSessionType.PLAYBACK, channel, stream);
} catch (Exception e) {
log.error("[停止点播失败] {}({})", channel.getGbName(), channel.getGbDeviceId(), e);
}
}
@Override
public void playbackPause(CommonGBChannel channel, String stream) {
}
}

3
src/main/java/com/genersoft/iot/vmp/gb28181/transmit/cmd/ISIPCommander.java
View File

@ -16,6 +16,7 @@ import gov.nist.javax.sip.message.SIPRequest;
import javax.sip.InvalidArgumentException; import javax.sip.InvalidArgumentException;
import javax.sip.SipException; import javax.sip.SipException;
import java.text.ParseException; import java.text.ParseException;
import java.util.List;
/** /**
* @description:设备能力接口，用于定义设备的控制、查询能力 * @description:设备能力接口，用于定义设备的控制、查询能力
@ -256,7 +257,7 @@ public interface ISIPCommander {
* *
* @param device 视频设备 * @param device 视频设备
*/ */
void presetQuery(Device device, String channelId, ErrorCallback<Object> callback) throws InvalidArgumentException, SipException, ParseException; void presetQuery(Device device, String channelId, ErrorCallback<List<Preset>> callback) throws InvalidArgumentException, SipException, ParseException;
/** /**
* 查询移动设备位置数据 * 查询移动设备位置数据

5
src/main/java/com/genersoft/iot/vmp/gb28181/transmit/cmd/impl/SIPCommander.java
View File

@ -40,6 +40,7 @@ import javax.sip.SipFactory;
import javax.sip.header.CallIdHeader; import javax.sip.header.CallIdHeader;
import javax.sip.message.Request; import javax.sip.message.Request;
import java.text.ParseException; import java.text.ParseException;
import java.util.List;
/** /**
* @description:设备能力接口，用于定义设备的控制、查询能力 * @description:设备能力接口，用于定义设备的控制、查询能力
@ -1118,7 +1119,7 @@ public class SIPCommander implements ISIPCommander {
* @param device 视频设备 * @param device 视频设备
*/ */
@Override @Override
public void presetQuery(Device device, String channelId, ErrorCallback<Object> callback) throws InvalidArgumentException, SipException, ParseException { public void presetQuery(Device device, String channelId, ErrorCallback<List<Preset>> callback) throws InvalidArgumentException, SipException, ParseException {
String cmdType = "PresetQuery"; String cmdType = "PresetQuery";
int sn = (int) ((Math.random() * 9 + 1) * 100000); int sn = (int) ((Math.random() * 9 + 1) * 100000);
@ -1136,7 +1137,7 @@ public class SIPCommander implements ISIPCommander {
} }
cmdXml.append("</Query>\r\n"); cmdXml.append("</Query>\r\n");
MessageEvent<Object> messageEvent = MessageEvent.getInstance(cmdType, sn + "", channelId, 4000L, callback); MessageEvent<List<Preset>> messageEvent = MessageEvent.getInstance(cmdType, sn + "", channelId, 4000L, callback);
messageSubscribe.addSubscribe(messageEvent); messageSubscribe.addSubscribe(messageEvent);
log.info("[预置位查询] 设备编号： {}， 通道编号： {}， SN： {}", device.getDeviceId(), channelId, sn); log.info("[预置位查询] 设备编号： {}， 通道编号： {}， SN： {}", device.getDeviceId(), channelId, sn);
Request request = headerProvider.createMessageRequest(device, cmdXml.toString(), SipUtils.getNewViaTag(), SipUtils.getNewFromTag(), null,sipSender.getNewCallIdHeader(sipLayer.getLocalIp(device.getLocalIp()),device.getTransport())); Request request = headerProvider.createMessageRequest(device, cmdXml.toString(), SipUtils.getNewViaTag(), SipUtils.getNewFromTag(), null,sipSender.getNewCallIdHeader(sipLayer.getLocalIp(device.getLocalIp()),device.getTransport()));

9
src/main/java/com/genersoft/iot/vmp/gb28181/transmit/event/request/impl/InviteRequestProcessor.java
View File

@ -161,7 +161,7 @@ public class InviteRequestProcessor extends SIPRequestProcessorParent implements
log.error("[命令发送失败] 上级Invite TRYING: {}", e.getMessage()); log.error("[命令发送失败] 上级Invite TRYING: {}", e.getMessage());
} }
channelPlayService.start(channel, inviteInfo, platform, ((code, msg, streamInfo) -> { channelPlayService.startInvite(channel, inviteInfo, platform, ((code, msg, streamInfo) -> {
if (code != InviteErrorCode.SUCCESS.getCode()) { if (code != InviteErrorCode.SUCCESS.getCode()) {
try { try {
responseAck(request, Response.BUSY_HERE , msg); responseAck(request, Response.BUSY_HERE , msg);
@ -247,6 +247,13 @@ public class InviteRequestProcessor extends SIPRequestProcessorParent implements
} catch (SipException | InvalidArgumentException | ParseException sendException) { } catch (SipException | InvalidArgumentException | ParseException sendException) {
log.error("[命令发送失败] invite 点播失败: {}", sendException.getMessage()); log.error("[命令发送失败] invite 点播失败: {}", sendException.getMessage());
} }
}catch (Exception e) {
log.error("[Invite处理异常] ", e);
try {
responseAck(request, Response.SERVER_INTERNAL_ERROR, "");
} catch (SipException | InvalidArgumentException | ParseException sendException) {
log.error("[命令发送失败] invite 点播失败: {}", sendException.getMessage());
}
} }
} }

2
src/main/java/com/genersoft/iot/vmp/gb28181/transmit/event/request/impl/info/InfoRequestProcessor.java
View File

@ -102,7 +102,7 @@ public class InfoRequestProcessor extends SIPRequestProcessorParent implements I
return; return;
} }
// 判断通道类型 // 判断通道类型
if (channel.getDataType() != ChannelDataType.GB28181.value) { if (channel.getDataType() != ChannelDataType.GB28181) {
// 非国标通道不支持录像回放控制 // 非国标通道不支持录像回放控制
log.warn("[INFO 消息] 非国标通道不支持录像回放控制： 通道ID： {}", sendRtpInfo.getChannelId()); log.warn("[INFO 消息] 非国标通道不支持录像回放控制： 通道ID： {}", sendRtpInfo.getChannelId());
responseAck(request, Response.FORBIDDEN, ""); responseAck(request, Response.FORBIDDEN, "");

62
src/main/java/com/genersoft/iot/vmp/gb28181/transmit/event/request/impl/message/control/cmd/DeviceControlQueryMessageHandler.java
View File

@ -140,7 +140,7 @@ public class DeviceControlQueryMessageHandler extends SIPRequestProcessorParent
* 处理云台指令 * 处理云台指令
*/ */
private void handlePtzCmd(CommonGBChannel channel, Element rootElement, SIPRequest request, DeviceControlType type) { private void handlePtzCmd(CommonGBChannel channel, Element rootElement, SIPRequest request, DeviceControlType type) {
if (channel.getDataType() == ChannelDataType.GB28181.value) { if (channel.getDataType() == ChannelDataType.GB28181) {
deviceChannelService.handlePtzCmd(channel.getDataDeviceId(), channel.getGbId(), rootElement, type, ((code, msg, data) -> { deviceChannelService.handlePtzCmd(channel.getDataDeviceId(), channel.getGbId(), rootElement, type, ((code, msg, data) -> {
try { try {
@ -166,7 +166,11 @@ public class DeviceControlQueryMessageHandler extends SIPRequestProcessorParent
case PTZ: case PTZ:
channelControlService.ptz(channel, (FrontEndControlCodeForPTZ)frontEndControlCode, ((code, msg, data) -> { channelControlService.ptz(channel, (FrontEndControlCodeForPTZ)frontEndControlCode, ((code, msg, data) -> {
try { try {
responseAck(request, code, msg); if (code == ErrorCode.SUCCESS.getCode()) {
responseAck(request, Response.OK);
}else {
responseAck(request, Response.FORBIDDEN);
}
} catch (InvalidArgumentException | SipException | ParseException exception) { } catch (InvalidArgumentException | SipException | ParseException exception) {
log.error("[命令发送失败] 云台指令: {}", exception.getMessage()); log.error("[命令发送失败] 云台指令: {}", exception.getMessage());
} }
@ -175,45 +179,65 @@ public class DeviceControlQueryMessageHandler extends SIPRequestProcessorParent
case FI: case FI:
channelControlService.fi(channel, (FrontEndControlCodeForFI) frontEndControlCode, ((code, msg, data) -> { channelControlService.fi(channel, (FrontEndControlCodeForFI) frontEndControlCode, ((code, msg, data) -> {
try { try {
responseAck(request, code, msg); if (code == ErrorCode.SUCCESS.getCode()) {
responseAck(request, Response.OK);
}else {
responseAck(request, Response.FORBIDDEN);
}
} catch (InvalidArgumentException | SipException | ParseException exception) { } catch (InvalidArgumentException | SipException | ParseException exception) {
log.error("[命令发送失败] 云台指令: {}", exception.getMessage()); log.error("[命令发送失败] FI指令: {}", exception.getMessage());
} }
})); }));
break; break;
case PRESET: case PRESET:
channelControlService.preset(channel, (FrontEndControlCodeForPreset) frontEndControlCode, ((code, msg, data) -> { channelControlService.preset(channel, (FrontEndControlCodeForPreset) frontEndControlCode, ((code, msg, data) -> {
try { try {
responseAck(request, code, msg); if (code == ErrorCode.SUCCESS.getCode()) {
responseAck(request, Response.OK);
}else {
responseAck(request, Response.FORBIDDEN);
}
} catch (InvalidArgumentException | SipException | ParseException exception) { } catch (InvalidArgumentException | SipException | ParseException exception) {
log.error("[命令发送失败] 云台指令: {}", exception.getMessage()); log.error("[命令发送失败] 预置位指令: {}", exception.getMessage());
} }
})); }));
break; break;
case TOUR: case TOUR:
channelControlService.tour(channel, (FrontEndControlCodeForTour) frontEndControlCode, ((code, msg, data) -> { channelControlService.tour(channel, (FrontEndControlCodeForTour) frontEndControlCode, ((code, msg, data) -> {
try { try {
responseAck(request, code, msg); if (code == ErrorCode.SUCCESS.getCode()) {
responseAck(request, Response.OK);
}else {
responseAck(request, Response.FORBIDDEN);
}
} catch (InvalidArgumentException | SipException | ParseException exception) { } catch (InvalidArgumentException | SipException | ParseException exception) {
log.error("[命令发送失败] 云台指令: {}", exception.getMessage()); log.error("[命令发送失败] 巡航指令: {}", exception.getMessage());
} }
})); }));
break; break;
case SCAN: case SCAN:
channelControlService.scan(channel, (FrontEndControlCodeForScan) frontEndControlCode, ((code, msg, data) -> { channelControlService.scan(channel, (FrontEndControlCodeForScan) frontEndControlCode, ((code, msg, data) -> {
try { try {
responseAck(request, code, msg); if (code == ErrorCode.SUCCESS.getCode()) {
responseAck(request, Response.OK);
}else {
responseAck(request, Response.FORBIDDEN);
}
} catch (InvalidArgumentException | SipException | ParseException exception) { } catch (InvalidArgumentException | SipException | ParseException exception) {
log.error("[命令发送失败] 云台指令: {}", exception.getMessage()); log.error("[命令发送失败] 扫描指令: {}", exception.getMessage());
} }
})); }));
break; break;
case AUXILIARY: case AUXILIARY:
channelControlService.auxiliary(channel, (FrontEndControlCodeForAuxiliary) frontEndControlCode, ((code, msg, data) -> { channelControlService.auxiliary(channel, (FrontEndControlCodeForAuxiliary) frontEndControlCode, ((code, msg, data) -> {
try { try {
responseAck(request, code, msg); if (code == ErrorCode.SUCCESS.getCode()) {
responseAck(request, Response.OK);
}else {
responseAck(request, Response.FORBIDDEN);
}
} catch (InvalidArgumentException | SipException | ParseException exception) { } catch (InvalidArgumentException | SipException | ParseException exception) {
log.error("[命令发送失败] 云台指令: {}", exception.getMessage()); log.error("[命令发送失败] 辅助开关指令: {}", exception.getMessage());
} }
})); }));
break; break;
@ -232,7 +256,7 @@ public class DeviceControlQueryMessageHandler extends SIPRequestProcessorParent
* 处理强制关键帧 * 处理强制关键帧
*/ */
private void handleIFameCmd(CommonGBChannel channel, SIPRequest request) { private void handleIFameCmd(CommonGBChannel channel, SIPRequest request) {
if (channel.getDataType() != ChannelDataType.GB28181.value) { if (channel.getDataType() != ChannelDataType.GB28181) {
// 只支持国标的云台控制 // 只支持国标的云台控制
log.warn("[INFO 消息] 只支持国标的处理强制关键帧， 通道ID： {}", channel.getGbId()); log.warn("[INFO 消息] 只支持国标的处理强制关键帧， 通道ID： {}", channel.getGbId());
try { try {
@ -280,7 +304,7 @@ public class DeviceControlQueryMessageHandler extends SIPRequestProcessorParent
* 处理重启命令 * 处理重启命令
*/ */
private void handleTeleBootCmd(CommonGBChannel channel, SIPRequest request) { private void handleTeleBootCmd(CommonGBChannel channel, SIPRequest request) {
if (channel.getDataType() != ChannelDataType.GB28181.value) { if (channel.getDataType() != ChannelDataType.GB28181) {
// 只支持国标的云台控制 // 只支持国标的云台控制
log.warn("[INFO 消息] 只支持国标的重启命令， 通道ID： {}", channel.getGbId()); log.warn("[INFO 消息] 只支持国标的重启命令， 通道ID： {}", channel.getGbId());
try { try {
@ -315,7 +339,7 @@ public class DeviceControlQueryMessageHandler extends SIPRequestProcessorParent
* 处理拉框控制 * 处理拉框控制
*/ */
private void handleDragZoom(CommonGBChannel channel, Element rootElement, SIPRequest request, DeviceControlType type) { private void handleDragZoom(CommonGBChannel channel, Element rootElement, SIPRequest request, DeviceControlType type) {
if (channel.getDataType() != ChannelDataType.GB28181.value) { if (channel.getDataType() != ChannelDataType.GB28181) {
// 只支持国标的云台控制 // 只支持国标的云台控制
log.warn("[deviceControl-DragZoom] 只支持国标的拉框控制， 通道ID： {}", channel.getGbId()); log.warn("[deviceControl-DragZoom] 只支持国标的拉框控制， 通道ID： {}", channel.getGbId());
try { try {
@ -380,7 +404,7 @@ public class DeviceControlQueryMessageHandler extends SIPRequestProcessorParent
* 处理看守位命令 * 处理看守位命令
*/ */
private void handleHomePositionCmd(CommonGBChannel channel, Element rootElement, SIPRequest request, DeviceControlType type) { private void handleHomePositionCmd(CommonGBChannel channel, Element rootElement, SIPRequest request, DeviceControlType type) {
if (channel.getDataType() != ChannelDataType.GB28181.value) { if (channel.getDataType() != ChannelDataType.GB28181) {
// 只支持国标的云台控制 // 只支持国标的云台控制
log.warn("[INFO 消息] 只支持国标的看守位命令， 通道ID： {}", channel.getGbId()); log.warn("[INFO 消息] 只支持国标的看守位命令， 通道ID： {}", channel.getGbId());
try { try {
@ -436,7 +460,7 @@ public class DeviceControlQueryMessageHandler extends SIPRequestProcessorParent
* 处理告警消息 * 处理告警消息
*/ */
private void handleAlarmCmd(CommonGBChannel channel, Element rootElement, SIPRequest request) { private void handleAlarmCmd(CommonGBChannel channel, Element rootElement, SIPRequest request) {
if (channel.getDataType() != ChannelDataType.GB28181.value) { if (channel.getDataType() != ChannelDataType.GB28181) {
// 只支持国标的云台控制 // 只支持国标的云台控制
log.warn("[INFO 消息] 只支持国标的告警消息， 通道ID： {}", channel.getGbId()); log.warn("[INFO 消息] 只支持国标的告警消息， 通道ID： {}", channel.getGbId());
try { try {
@ -486,7 +510,7 @@ public class DeviceControlQueryMessageHandler extends SIPRequestProcessorParent
* 处理录像控制 * 处理录像控制
*/ */
private void handleRecordCmd(CommonGBChannel channel, Element rootElement, SIPRequest request, DeviceControlType type) { private void handleRecordCmd(CommonGBChannel channel, Element rootElement, SIPRequest request, DeviceControlType type) {
if (channel.getDataType() != ChannelDataType.GB28181.value) { if (channel.getDataType() != ChannelDataType.GB28181) {
// 只支持国标的云台控制 // 只支持国标的云台控制
log.warn("[INFO 消息] 只支持国标的息录像控制， 通道ID： {}", channel.getGbId()); log.warn("[INFO 消息] 只支持国标的息录像控制， 通道ID： {}", channel.getGbId());
try { try {
@ -542,7 +566,7 @@ public class DeviceControlQueryMessageHandler extends SIPRequestProcessorParent
* 处理报警布防/撤防命令 * 处理报警布防/撤防命令
*/ */
private void handleGuardCmd(CommonGBChannel channel, Element rootElement, SIPRequest request, DeviceControlType type) { private void handleGuardCmd(CommonGBChannel channel, Element rootElement, SIPRequest request, DeviceControlType type) {
if (channel.getDataType() != ChannelDataType.GB28181.value) { if (channel.getDataType() != ChannelDataType.GB28181) {
// 只支持国标的云台控制 // 只支持国标的云台控制
log.warn("[INFO 消息] 只支持国标的报警布防/撤防命令， 通道ID： {}", channel.getGbId()); log.warn("[INFO 消息] 只支持国标的报警布防/撤防命令， 通道ID： {}", channel.getGbId());
try { try {

2
src/main/java/com/genersoft/iot/vmp/gb28181/transmit/event/request/impl/message/notify/cmd/BroadcastNotifyMessageHandler.java
View File

@ -107,7 +107,7 @@ public class BroadcastNotifyMessageHandler extends SIPRequestProcessorParent imp
responseAck(request, Response.NOT_FOUND, "TargetID not found"); responseAck(request, Response.NOT_FOUND, "TargetID not found");
return; return;
} }
if (channel.getDataType() != ChannelDataType.GB28181.value) { if (channel.getDataType() != ChannelDataType.GB28181) {
// 只支持国标的语音喊话 // 只支持国标的语音喊话
log.warn("[INFO 消息] 只支持国标的语音喊话命令， 通道ID： {}", channel.getGbId()); log.warn("[INFO 消息] 只支持国标的语音喊话命令， 通道ID： {}", channel.getGbId());
try { try {

2
src/main/java/com/genersoft/iot/vmp/gb28181/transmit/event/request/impl/message/query/cmd/DeviceInfoQueryMessageHandler.java
View File

@ -94,7 +94,7 @@ public class DeviceInfoQueryMessageHandler extends SIPRequestProcessorParent imp
return; return;
} }
// 判断通道类型 // 判断通道类型
if (channel.getDataType() != ChannelDataType.GB28181.value) { if (channel.getDataType() != ChannelDataType.GB28181) {
// 非国标通道不支持录像回放控制 // 非国标通道不支持录像回放控制
log.warn("[DeviceInfo] 非国标通道不支持录像回放控制： 通道ID： {}", channel.getGbId()); log.warn("[DeviceInfo] 非国标通道不支持录像回放控制： 通道ID： {}", channel.getGbId());
try { try {

2
src/main/java/com/genersoft/iot/vmp/gb28181/transmit/event/request/impl/message/query/cmd/RecordInfoQueryMessageHandler.java
View File

@ -105,7 +105,7 @@ public class RecordInfoQueryMessageHandler extends SIPRequestProcessorParent imp
} }
return; return;
} }
if (channel.getDataType() != ChannelDataType.GB28181.value) { if (channel.getDataType() != ChannelDataType.GB28181) {
log.info("[平台查询录像记录] 只支持查询国标28181的录像数据 {}/{}", platform.getName(), channelId ); log.info("[平台查询录像记录] 只支持查询国标28181的录像数据 {}/{}", platform.getName(), channelId );
try { try {
responseAck(request, Response.NOT_IMPLEMENTED); // 回复未实现 responseAck(request, Response.NOT_IMPLEMENTED); // 回复未实现

4
src/main/java/com/genersoft/iot/vmp/service/redisMsg/IRedisRpcPlayService.java
View File

@ -20,9 +20,9 @@ public interface IRedisRpcPlayService {
void queryRecordInfo(String serverId, Integer channelId, String startTime, String endTime, ErrorCallback<RecordInfo> callback); void queryRecordInfo(String serverId, Integer channelId, String startTime, String endTime, ErrorCallback<RecordInfo> callback);
void pauseRtp(String serverId, String streamId); void playbackPause(String serverId, String streamId);
void resumeRtp(String serverId, String streamId); void playbackResume(String serverId, String streamId);
String frontEndCommand(String serverId, Integer channelId, int cmdCode, int parameter1, int parameter2, int combindCode2); String frontEndCommand(String serverId, Integer channelId, int cmdCode, int parameter1, int parameter2, int combindCode2);

4
src/main/java/com/genersoft/iot/vmp/service/redisMsg/IRedisRpcService.java
View File

@ -6,6 +6,8 @@ import com.genersoft.iot.vmp.gb28181.bean.*;
import com.genersoft.iot.vmp.gb28181.event.subscribe.catalog.CatalogEvent; import com.genersoft.iot.vmp.gb28181.event.subscribe.catalog.CatalogEvent;
import com.genersoft.iot.vmp.vmanager.bean.WVPResult; import com.genersoft.iot.vmp.vmanager.bean.WVPResult;
import java.util.List;
public interface IRedisRpcService { public interface IRedisRpcService {
SendRtpInfo getSendRtpItem(String callId); SendRtpInfo getSendRtpItem(String callId);
@ -63,5 +65,5 @@ public interface IRedisRpcService {
WVPResult<Object> deviceInfo(String serverId, Device device); WVPResult<Object> deviceInfo(String serverId, Device device);
WVPResult<Object> queryPreset(String serverId, Device device, String channelId); WVPResult<List<Preset>> queryPreset(String serverId, Device device, String channelId);
} }

27
src/main/java/com/genersoft/iot/vmp/service/redisMsg/control/RedisRpcChannelPlayController.java
View File

@ -1,6 +1,5 @@
package com.genersoft.iot.vmp.service.redisMsg.control; package com.genersoft.iot.vmp.service.redisMsg.control;
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject; import com.alibaba.fastjson2.JSONObject;
import com.genersoft.iot.vmp.common.InviteSessionType; import com.genersoft.iot.vmp.common.InviteSessionType;
import com.genersoft.iot.vmp.conf.UserSetting; import com.genersoft.iot.vmp.conf.UserSetting;
@ -10,9 +9,7 @@ import com.genersoft.iot.vmp.conf.redis.bean.RedisRpcMessage;
import com.genersoft.iot.vmp.conf.redis.bean.RedisRpcRequest; import com.genersoft.iot.vmp.conf.redis.bean.RedisRpcRequest;
import com.genersoft.iot.vmp.conf.redis.bean.RedisRpcResponse; import com.genersoft.iot.vmp.conf.redis.bean.RedisRpcResponse;
import com.genersoft.iot.vmp.gb28181.bean.CommonGBChannel; import com.genersoft.iot.vmp.gb28181.bean.CommonGBChannel;
import com.genersoft.iot.vmp.gb28181.bean.Device;
import com.genersoft.iot.vmp.gb28181.bean.InviteMessageInfo; import com.genersoft.iot.vmp.gb28181.bean.InviteMessageInfo;
import com.genersoft.iot.vmp.gb28181.bean.SyncStatus;
import com.genersoft.iot.vmp.gb28181.service.IGbChannelPlayService; import com.genersoft.iot.vmp.gb28181.service.IGbChannelPlayService;
import com.genersoft.iot.vmp.gb28181.service.IGbChannelService; import com.genersoft.iot.vmp.gb28181.service.IGbChannelService;
import com.genersoft.iot.vmp.gb28181.service.IPTZService; import com.genersoft.iot.vmp.gb28181.service.IPTZService;
@ -81,7 +78,7 @@ public class RedisRpcChannelPlayController extends RpcController {
InviteMessageInfo inviteInfo = new InviteMessageInfo(); InviteMessageInfo inviteInfo = new InviteMessageInfo();
inviteInfo.setSessionName("Play"); inviteInfo.setSessionName("Play");
channelPlayService.start(channel, inviteInfo, null, (code, msg, data) ->{ channelPlayService.startInvite(channel, inviteInfo, null, (code, msg, data) ->{
if (code == InviteErrorCode.SUCCESS.getCode()) { if (code == InviteErrorCode.SUCCESS.getCode()) {
response.setStatusCode(ErrorCode.SUCCESS.getCode()); response.setStatusCode(ErrorCode.SUCCESS.getCode());
response.setBody(data); response.setBody(data);
@ -118,7 +115,7 @@ public class RedisRpcChannelPlayController extends RpcController {
response.setBody("param error"); response.setBody("param error");
return response; return response;
} }
try { try {
channelService.queryRecordInfo(channel, startTime, endTime, (code, msg, data) ->{ channelService.queryRecordInfo(channel, startTime, endTime, (code, msg, data) ->{
if (code == InviteErrorCode.SUCCESS.getCode()) { if (code == InviteErrorCode.SUCCESS.getCode()) {
@ -134,15 +131,15 @@ public class RedisRpcChannelPlayController extends RpcController {
response.setStatusCode(ErrorCode.ERROR100.getCode()); response.setStatusCode(ErrorCode.ERROR100.getCode());
response.setBody(e.getMessage()); response.setBody(e.getMessage());
} }
return null; return null;
} }
/** /**
* 暂停录像回放 * 暂停录像回放
*/ */
@RedisRpcMapping("pauseRtp") @RedisRpcMapping("playbackPause")
public RedisRpcResponse pauseRtp(RedisRpcRequest request) { public RedisRpcResponse playbackPause(RedisRpcRequest request) {
String streamId = request.getParam().toString(); String streamId = request.getParam().toString();
RedisRpcResponse response = request.getResponse(); RedisRpcResponse response = request.getResponse();
@ -153,7 +150,7 @@ public class RedisRpcChannelPlayController extends RpcController {
} }
try { try {
channelPlayService.pauseRtp(streamId); // channelPlayService.playbackPause(streamId);
response.setStatusCode(ErrorCode.SUCCESS.getCode()); response.setStatusCode(ErrorCode.SUCCESS.getCode());
}catch (ControllerException e) { }catch (ControllerException e) {
response.setStatusCode(ErrorCode.ERROR100.getCode()); response.setStatusCode(ErrorCode.ERROR100.getCode());
@ -166,8 +163,8 @@ public class RedisRpcChannelPlayController extends RpcController {
/** /**
* 恢复录像回放 * 恢复录像回放
*/ */
@RedisRpcMapping("resumeRtp") @RedisRpcMapping("playbackResume")
public RedisRpcResponse resumeRtp(RedisRpcRequest request) { public RedisRpcResponse playbackResume(RedisRpcRequest request) {
String streamId = request.getParam().toString(); String streamId = request.getParam().toString();
RedisRpcResponse response = request.getResponse(); RedisRpcResponse response = request.getResponse();
@ -178,7 +175,7 @@ public class RedisRpcChannelPlayController extends RpcController {
} }
try { try {
channelPlayService.resumeRtp(streamId); // channelPlayService.playbackResume(streamId);
response.setStatusCode(ErrorCode.SUCCESS.getCode()); response.setStatusCode(ErrorCode.SUCCESS.getCode());
}catch (ControllerException e) { }catch (ControllerException e) {
response.setStatusCode(ErrorCode.ERROR100.getCode()); response.setStatusCode(ErrorCode.ERROR100.getCode());
@ -216,7 +213,7 @@ public class RedisRpcChannelPlayController extends RpcController {
return response; return response;
} }
try { try {
channelPlayService.stopPlay(type, channel, stream); channelPlayService.stopInvite(type, channel, stream);
response.setStatusCode(ErrorCode.SUCCESS.getCode()); response.setStatusCode(ErrorCode.SUCCESS.getCode());
}catch (Exception e){ }catch (Exception e){
response.setStatusCode(Response.SERVER_INTERNAL_ERROR); response.setStatusCode(Response.SERVER_INTERNAL_ERROR);
@ -253,7 +250,7 @@ public class RedisRpcChannelPlayController extends RpcController {
inviteInfo.setSessionName("Playback"); inviteInfo.setSessionName("Playback");
inviteInfo.setStartTime(DateUtil.yyyy_MM_dd_HH_mm_ssToTimestamp(startTime)); inviteInfo.setStartTime(DateUtil.yyyy_MM_dd_HH_mm_ssToTimestamp(startTime));
inviteInfo.setStopTime(DateUtil.yyyy_MM_dd_HH_mm_ssToTimestamp(endTime)); inviteInfo.setStopTime(DateUtil.yyyy_MM_dd_HH_mm_ssToTimestamp(endTime));
channelPlayService.start(channel, inviteInfo, null, (code, msg, data) ->{ channelPlayService.startInvite(channel, inviteInfo, null, (code, msg, data) ->{
if (code == InviteErrorCode.SUCCESS.getCode()) { if (code == InviteErrorCode.SUCCESS.getCode()) {
response.setStatusCode(ErrorCode.SUCCESS.getCode()); response.setStatusCode(ErrorCode.SUCCESS.getCode());
response.setBody(data); response.setBody(data);
@ -296,7 +293,7 @@ public class RedisRpcChannelPlayController extends RpcController {
inviteInfo.setStartTime(DateUtil.yyyy_MM_dd_HH_mm_ssToTimestamp(startTime)); inviteInfo.setStartTime(DateUtil.yyyy_MM_dd_HH_mm_ssToTimestamp(startTime));
inviteInfo.setStopTime(DateUtil.yyyy_MM_dd_HH_mm_ssToTimestamp(endTime)); inviteInfo.setStopTime(DateUtil.yyyy_MM_dd_HH_mm_ssToTimestamp(endTime));
inviteInfo.setDownloadSpeed(downloadSpeed + ""); inviteInfo.setDownloadSpeed(downloadSpeed + "");
channelPlayService.start(channel, inviteInfo, null, (code, msg, data) ->{ channelPlayService.startInvite(channel, inviteInfo, null, (code, msg, data) ->{
if (code == InviteErrorCode.SUCCESS.getCode()) { if (code == InviteErrorCode.SUCCESS.getCode()) {
response.setStatusCode(ErrorCode.SUCCESS.getCode()); response.setStatusCode(ErrorCode.SUCCESS.getCode());
response.setBody(data); response.setBody(data);

8
src/main/java/com/genersoft/iot/vmp/service/redisMsg/service/RedisRpcPlayServiceImpl.java
View File

@ -121,8 +121,8 @@ public class RedisRpcPlayServiceImpl implements IRedisRpcPlayService {
} }
@Override @Override
public void pauseRtp(String serverId, String streamId) { public void playbackPause(String serverId, String streamId) {
RedisRpcRequest request = buildRequest("channel/pauseRtp", streamId); RedisRpcRequest request = buildRequest("channel/playbackPause", streamId);
request.setToId(serverId); request.setToId(serverId);
RedisRpcResponse response = redisRpcConfig.request(request, 5, TimeUnit.SECONDS); RedisRpcResponse response = redisRpcConfig.request(request, 5, TimeUnit.SECONDS);
if (response == null) { if (response == null) {
@ -135,8 +135,8 @@ public class RedisRpcPlayServiceImpl implements IRedisRpcPlayService {
} }
@Override @Override
public void resumeRtp(String serverId, String streamId) { public void playbackResume(String serverId, String streamId) {
RedisRpcRequest request = buildRequest("channel/resumeRtp", streamId); RedisRpcRequest request = buildRequest("channel/playbackResume", streamId);
request.setToId(serverId); request.setToId(serverId);
RedisRpcResponse response = redisRpcConfig.request(request, 5, TimeUnit.SECONDS); RedisRpcResponse response = redisRpcConfig.request(request, 5, TimeUnit.SECONDS);
if (response == null) { if (response == null) {

3
src/main/java/com/genersoft/iot/vmp/service/redisMsg/service/RedisRpcServiceImpl.java
View File

@ -25,6 +25,7 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate; import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import java.util.List;
import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeUnit;
@Slf4j @Slf4j
@ -406,7 +407,7 @@ public class RedisRpcServiceImpl implements IRedisRpcService {
} }
@Override @Override
public WVPResult<Object> queryPreset(String serverId, Device device, String channelId) { public WVPResult<List<Preset>> queryPreset(String serverId, Device device, String channelId) {
JSONObject jsonObject = new JSONObject(); JSONObject jsonObject = new JSONObject();
jsonObject.put("device", device.getDeviceId()); jsonObject.put("device", device.getDeviceId());
jsonObject.put("channelId", channelId); jsonObject.put("channelId", channelId);

2
src/main/java/com/genersoft/iot/vmp/streamProxy/bean/StreamProxy.java
View File

@ -79,7 +79,7 @@ public class StreamProxy extends CommonGBChannel {
if (ObjectUtils.isEmpty(this.getGbName())) { if (ObjectUtils.isEmpty(this.getGbName())) {
this.setGbName( app+ "-" +stream); this.setGbName( app+ "-" +stream);
} }
this.setDataType(ChannelDataType.STREAM_PROXY.value); this.setDataType(ChannelDataType.STREAM_PROXY);
this.setDataDeviceId(this.getId()); this.setDataDeviceId(this.getId());
return this; return this;
} }

2
src/main/java/com/genersoft/iot/vmp/streamProxy/dao/provider/StreamProxyProvider.java
View File

@ -9,7 +9,7 @@ public class StreamProxyProvider {
public String getBaseSelectSql(){ public String getBaseSelectSql(){
return "SELECT " + return "SELECT " +
" st.*, " + " st.*, " +
ChannelDataType.STREAM_PROXY.value + " as data_type, " + ChannelDataType.STREAM_PROXY + " as data_type, " +
" st.id as data_device_id, " + " st.id as data_device_id, " +
" wdc.*, " + " wdc.*, " +
" wdc.id as gb_id" + " wdc.id as gb_id" +

42
src/main/java/com/genersoft/iot/vmp/streamProxy/service/impl/SourcePlayServiceForStreamProxyImpl.java Normal file
View File

@ -0,0 +1,42 @@
package com.genersoft.iot.vmp.streamProxy.service.impl;
import com.genersoft.iot.vmp.common.StreamInfo;
import com.genersoft.iot.vmp.common.enums.ChannelDataType;
import com.genersoft.iot.vmp.gb28181.bean.CommonGBChannel;
import com.genersoft.iot.vmp.gb28181.bean.Platform;
import com.genersoft.iot.vmp.gb28181.service.ISourcePlayService;
import com.genersoft.iot.vmp.service.bean.ErrorCallback;
import com.genersoft.iot.vmp.streamProxy.service.IStreamProxyPlayService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import javax.sip.message.Response;
@Slf4j
@Service(ChannelDataType.PLAY_SERVICE + ChannelDataType.STREAM_PROXY)
public class SourcePlayServiceForStreamProxyImpl implements ISourcePlayService {
@Autowired
private IStreamProxyPlayService playService;
@Override
public void play(CommonGBChannel channel, Platform platform, Boolean record, ErrorCallback<StreamInfo> callback) {
// 拉流代理通道
try {
playService.start(channel.getDataDeviceId(), record, callback);
}catch (Exception e) {
callback.run(Response.BUSY_HERE, "busy here", null);
}
}
@Override
public void stopPlay(CommonGBChannel channel, String stream) {
// 拉流代理通道
try {
playService.stop(channel.getDataDeviceId());
}catch (Exception e) {
log.error("[停止点播失败] {}({})", channel.getGbName(), channel.getGbDeviceId(), e);
}
}
}

2
src/main/java/com/genersoft/iot/vmp/streamProxy/service/impl/StreamProxyServiceImpl.java
View File

@ -179,7 +179,7 @@ public class StreamProxyServiceImpl implements IStreamProxyService {
streamProxy.setCreateTime(DateUtil.getNow()); streamProxy.setCreateTime(DateUtil.getNow());
streamProxy.setUpdateTime(DateUtil.getNow()); streamProxy.setUpdateTime(DateUtil.getNow());
streamProxyMapper.add(streamProxy); streamProxyMapper.add(streamProxy);
streamProxy.setDataType(ChannelDataType.STREAM_PROXY.value); streamProxy.setDataType(ChannelDataType.STREAM_PROXY);
streamProxy.setDataDeviceId(streamProxy.getId()); streamProxy.setDataDeviceId(streamProxy.getId());
} }

4
src/main/java/com/genersoft/iot/vmp/streamPush/bean/StreamPush.java
View File

@ -105,7 +105,7 @@ public class StreamPush extends CommonGBChannel implements Comparable<StreamPush
private String uniqueKey; private String uniqueKey;
private Integer dataType = ChannelDataType.STREAM_PUSH.value; private Integer dataType = ChannelDataType.STREAM_PUSH;
@Override @Override
@ -145,7 +145,7 @@ public class StreamPush extends CommonGBChannel implements Comparable<StreamPush
if (ObjectUtils.isEmpty(this.getGbName())) { if (ObjectUtils.isEmpty(this.getGbName())) {
this.setGbName( app+ "-" +stream); this.setGbName( app+ "-" +stream);
} }
this.setDataType(ChannelDataType.STREAM_PUSH.value); this.setDataType(ChannelDataType.STREAM_PUSH);
this.setDataDeviceId(this.getId()); this.setDataDeviceId(this.getId());
return this; return this;
} }

2
src/main/java/com/genersoft/iot/vmp/streamPush/controller/StreamPushController.java
View File

@ -218,7 +218,7 @@ public class StreamPushController {
if (!streamPushService.add(stream)) { if (!streamPushService.add(stream)) {
throw new ControllerException(ErrorCode.ERROR100); throw new ControllerException(ErrorCode.ERROR100);
} }
stream.setDataType(ChannelDataType.STREAM_PUSH.value); stream.setDataType(ChannelDataType.STREAM_PUSH);
stream.setDataDeviceId(stream.getId()); stream.setDataDeviceId(stream.getId());
return stream; return stream;
} }

2
src/main/java/com/genersoft/iot/vmp/streamPush/dao/StreamPushMapper.java
View File

@ -14,7 +14,7 @@ import java.util.Set;
@Repository @Repository
public interface StreamPushMapper { public interface StreamPushMapper {
Integer dataType = ChannelDataType.GB28181.value; Integer dataType = ChannelDataType.GB28181;
@Insert("INSERT INTO wvp_stream_push (app, stream, media_server_id, server_id, push_time, update_time, create_time, pushing, start_offline_push) VALUES" + @Insert("INSERT INTO wvp_stream_push (app, stream, media_server_id, server_id, push_time, update_time, create_time, pushing, start_offline_push) VALUES" +
"(#{app}, #{stream}, #{mediaServerId} , #{serverId} , #{pushTime} ,#{updateTime}, #{createTime}, #{pushing}, #{startOfflinePush})") "(#{app}, #{stream}, #{mediaServerId} , #{serverId} , #{pushTime} ,#{updateTime}, #{createTime}, #{pushing}, #{startOfflinePush})")

53
src/main/java/com/genersoft/iot/vmp/streamPush/service/impl/SourcePlayServiceForStreamPushImpl.java Normal file
View File

@ -0,0 +1,53 @@
package com.genersoft.iot.vmp.streamPush.service.impl;
import com.genersoft.iot.vmp.common.StreamInfo;
import com.genersoft.iot.vmp.common.enums.ChannelDataType;
import com.genersoft.iot.vmp.gb28181.bean.CommonGBChannel;
import com.genersoft.iot.vmp.gb28181.bean.Platform;
import com.genersoft.iot.vmp.gb28181.bean.PlayException;
import com.genersoft.iot.vmp.gb28181.service.ISourcePlayService;
import com.genersoft.iot.vmp.service.bean.ErrorCallback;
import com.genersoft.iot.vmp.streamPush.service.IStreamPushPlayService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import javax.sip.message.Response;
@Slf4j
@Service(ChannelDataType.PLAY_SERVICE + ChannelDataType.STREAM_PUSH)
public class SourcePlayServiceForStreamPushImpl implements ISourcePlayService {
@Autowired
private IStreamPushPlayService playService;
@Override
public void play(CommonGBChannel channel, Platform platform, Boolean record, ErrorCallback<StreamInfo> callback) {
String serverGBId = null;
String platformName = null;
if (platform != null) {
// 推流
serverGBId = platform.getServerGBId();
platformName = platform.getName();
}
// 推流
try {
playService.start(channel.getDataDeviceId(), callback, serverGBId, platformName);
}catch (PlayException e) {
callback.run(e.getCode(), e.getMsg(), null);
}catch (Exception e) {
log.error("[点播推流通道失败] 通道： {}({})", channel.getGbName(), channel.getGbDeviceId(), e);
callback.run(Response.BUSY_HERE, "busy here", null);
}
}
@Override
public void stopPlay(CommonGBChannel channel, String stream) {
// 推流
try {
playService.stop(channel.getDataDeviceId());
}catch (Exception e) {
log.error("[停止点播失败] {}({})", channel.getGbName(), channel.getGbDeviceId(), e);
}
}
}

21
src/main/java/com/genersoft/iot/vmp/vmanager/server/ServerController.java
View File

@ -4,7 +4,6 @@ import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject; import com.alibaba.fastjson2.JSONObject;
import com.genersoft.iot.vmp.common.SystemAllInfo; import com.genersoft.iot.vmp.common.SystemAllInfo;
import com.genersoft.iot.vmp.common.VersionPo; import com.genersoft.iot.vmp.common.VersionPo;
import com.genersoft.iot.vmp.common.enums.ChannelDataType;
import com.genersoft.iot.vmp.conf.SipConfig; import com.genersoft.iot.vmp.conf.SipConfig;
import com.genersoft.iot.vmp.conf.UserSetting; import com.genersoft.iot.vmp.conf.UserSetting;
import com.genersoft.iot.vmp.conf.VersionInfo; import com.genersoft.iot.vmp.conf.VersionInfo;
@ -45,7 +44,10 @@ import oshi.software.os.OperatingSystem;
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
import java.io.File; import java.io.File;
import java.text.DecimalFormat; import java.text.DecimalFormat;
import java.util.*; import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
@SuppressWarnings("rawtypes") @SuppressWarnings("rawtypes")
@Tag(name = "服务控制") @Tag(name = "服务控制")
@ -334,21 +336,6 @@ public class ServerController {
return result; return result;
} }
@GetMapping(value = "/channel/datatype")
@ResponseBody
@Operation(summary = "获取系统接入的数据类型", security = @SecurityRequirement(name = JwtUtils.HEADER))
public List<Map<String, Object>> getDataType() {
List<Map<String, Object>> result = new LinkedList<>();
Map<String, Integer> descMap = ChannelDataType.getDescMap();
for (String key : descMap.keySet()) {
Map<String, Object> map = new LinkedHashMap<>();
map.put("key", key);
map.put("value", descMap.get(key));
result.add(map);
}
return result;
}
/** /**
* 单位转换 * 单位转换
*/ */

6
web/src/api/commonChannel.js
View File

@ -463,15 +463,15 @@ export function wiper({ channelId, command }) {
}) })
} }
export function ptz({ channelId, command, horizonSpeed, verticalSpeed, zoomSpeed }) { export function ptz({ channelId, command, panSpeed, tiltSpeed, zoomSpeed }) {
return request({ return request({
method: 'get', method: 'get',
url: '/api/common/channel/front-end/ptz', url: '/api/common/channel/front-end/ptz',
params: { params: {
channelId: channelId, channelId: channelId,
command: command, command: command,
horizonSpeed: horizonSpeed, panSpeed: panSpeed,
verticalSpeed: verticalSpeed, tiltSpeed: tiltSpeed,
zoomSpeed: zoomSpeed zoomSpeed: zoomSpeed
} }
}) })

34
web/src/views/common/channelPlayer/index.vue
View File

@ -535,29 +535,29 @@ export default {
ptzCamera: function(command) { ptzCamera: function(command) {
console.log('云台控制：' + command) console.log('云台控制：' + command)
this.$store.dispatch('commonChanel/ptz', this.$store.dispatch('commonChanel/ptz',
[ {
this.channelId, channelId: this.channelId,
command, command: command,
parseInt(this.controSpeed * 255 / 100), panSpeed: this.controSpeed,
parseInt(this.controSpeed * 255 / 100), tiltSpeed: this.controSpeed,
parseInt(this.controSpeed * 16 / 100) zoomSpeed: this.controSpeed
]) })
}, },
irisCamera: function(command) { irisCamera: function(command) {
this.$store.dispatch('commonChanel/iris', this.$store.dispatch('commonChanel/iris',
[ {
this.channelId, channelId: this.channelId,
command, command: command,
parseInt(this.controSpeed * 255 / 100) speed: this.controSpeed
]) })
}, },
focusCamera: function(command) { focusCamera: function(command) {
this.$store.dispatch('commonChanel/focus', this.$store.dispatch('commonChanel/focus',
[ {
this.channelId, channelId: this.channelId,
command, command: command,
parseInt(this.controSpeed * 255 / 100) speed: this.controSpeed
]) })
}, },
// ////////////////////播放器事件处理////////////////////////// // ////////////////////播放器事件处理//////////////////////////
videoError: function(e) { videoError: function(e) {