feat: 新增gbt28181（支持点播、云台控制）

@@ -92,6 +92,10 @@
         </dependency>
         <dependency>
             <groupId>org.thingsboard.common.transport</groupId>
+            <artifactId>gbt28181</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.thingsboard.common.transport</groupId>
             <artifactId>http</artifactId>
         </dependency>
         <dependency>

@@ -74,7 +74,7 @@ public class ThingsboardSecurityConfiguration extends WebSecurityConfigurerAdapt
 
     //Thingskit function
     public static final String CODE_BASED_LOGIN_ENTRY_POINT = "/api/yt/auth/code/login";
-    public static final String[] YT_NOT_AUTH_API = new String[]{"/api/yt/auth/code/login","/api/yt/third/bind","/api/yt/third/login/*","/api/yt/third/login/id/*", "/api/yt/third/authorize","/api/yt/platform/get","/api/yt/app_design/get", "/api/yt/noauth/**"};
+    public static final String[] YT_NOT_AUTH_API = new String[]{"/api/yt/auth/code/login","/api/yt/third/bind","/api/yt/third/login/*","/api/yt/third/login/id/*", "/api/yt/third/authorize","/api/yt/platform/get","/api/yt/app_design/get", "/api/yt/noauth/**","/api/index/hook/**"};
 
     public static final String PUBLIC_LOGIN_ENTRY_POINT = "/api/auth/login/public";
     public static final String TOKEN_REFRESH_ENTRY_POINT = "/api/auth/token";

@@ -82,7 +82,7 @@ public class ThingsKitExceptionHandler {
       SecurityUser currentUser = getCurrentUser();
 
       Asset entity = new Asset();
-      entity.setName(e.getMessage());
+      entity.setName(e.getClass().getName());
 
       // 请求相关信息
       SysLogOperateDTO additionalInfo = new SysLogOperateDTO();

+package org.thingsboard.server.controller.yunteng;
+
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiParam;
+import lombok.RequiredArgsConstructor;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+import org.thingsboard.server.common.data.StringUtils;
+import org.thingsboard.server.common.data.exception.ThingsboardException;
+import org.thingsboard.server.common.data.yunteng.core.exception.TkDataValidationException;
+import org.thingsboard.server.common.data.yunteng.core.message.ErrorMessage;
+import org.thingsboard.server.common.data.yunteng.dto.DeviceDTO;
+import org.thingsboard.server.common.data.yunteng.dto.sip.VideoChanelDTO;
+import org.thingsboard.server.common.data.yunteng.enums.OrderTypeEnum;
+import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
+import org.thingsboard.server.controller.BaseController;
+import org.thingsboard.server.dao.yunteng.mapper.DeviceMapper;
+import org.thingsboard.server.dao.yunteng.service.TkDeviceService;
+import org.thingsboard.server.dao.yunteng.service.media.TkVideoChannelService;
+
+import java.util.HashMap;
+
+import static org.thingsboard.server.common.data.yunteng.constant.QueryConstant.*;
+import static org.thingsboard.server.common.data.yunteng.constant.QueryConstant.ORDER_TYPE;
+
+@RestController
+@RequestMapping("api/yt/video/channel")
+@Api(tags = {"视频通道"})
+@RequiredArgsConstructor
+public class TkVideoChannelController extends BaseController {
+
+    private final TkVideoChannelService tkVideoChannelService;
+    private final TkDeviceService tkDeviceService;
+    private final DeviceMapper deviceMapper;
+
+  @PreAuthorize("hasAnyAuthority('TENANT_ADMIN', 'CUSTOMER_USER')")
+  @GetMapping(params = {PAGE_SIZE, PAGE})
+  public TkPageData<VideoChanelDTO> pageData(
+      @RequestParam(PAGE_SIZE) int pageSize,
+      @RequestParam(PAGE) int page,
+      @RequestParam(value = ORDER_FILED, required = false) String orderBy,
+      @RequestParam(value = ORDER_TYPE, required = false) OrderTypeEnum orderType,
+      @ApiParam(value = "通道所属设备ID(tbDeviceId)")
+      @RequestParam(value = "tbDeviceId") String tbDeviceId,
+      @ApiParam(value = "视频通道名称")
+      @RequestParam(value = "name", required = false) String name,
+      @ApiParam(value = "国标编号")
+      @RequestParam(value = "cameraCode", required = false) String cameraCode) throws ThingsboardException {
+      HashMap<String, Object> queryMap = new HashMap<>();
+      if(StringUtils.isNotEmpty(name)){
+          queryMap.put("name",name);
+      }
+      if(StringUtils.isNotEmpty(cameraCode)){
+          queryMap.put("cameraCode",cameraCode);
+      }
+      String tenantId = getCurrentUser().getCurrentTenantId();
+      if(StringUtils.isEmpty(tbDeviceId)){
+          throw new TkDataValidationException(ErrorMessage.INVALID_PARAMETER.getMessage());
+      }
+      if(getCurrentUser().isCustomerUser()){
+          DeviceDTO deviceDTO = deviceMapper.findDeviceByTbDeviceIdAndCustomerId(
+                  tenantId,tbDeviceId,getCurrentUser().getCustomerId().toString());
+          if(null == deviceDTO){
+              throw new TkDataValidationException(ErrorMessage.NOT_BELONG_CURRENT_CUSTOMER.getMessage());
+          }
+      }
+      queryMap.put("tbDeviceId",tbDeviceId);
+      queryMap.put(PAGE_SIZE, pageSize);
+      queryMap.put(PAGE, page);
+      queryMap.put(ORDER_FILED, orderBy);
+      if (orderType != null) {
+          queryMap.put(ORDER_TYPE, orderType.name());
+      }
+      return tkVideoChannelService.page(tenantId, queryMap);
+  }
+}

@@ -11,6 +11,7 @@ import org.thingsboard.server.common.data.exception.ThingsboardException;
 import org.thingsboard.server.common.data.yunteng.common.DeleteGroup;
 import org.thingsboard.server.common.data.yunteng.dto.DeleteDTO;
 import org.thingsboard.server.common.data.yunteng.dto.TkVideoDTO;
+import org.thingsboard.server.common.data.yunteng.dto.TkVideoGptDTO;
 import org.thingsboard.server.common.data.yunteng.enums.OrderTypeEnum;
 import org.thingsboard.server.common.data.yunteng.utils.tools.ProtocolType;
 import org.thingsboard.server.common.data.yunteng.utils.tools.ResponseResult;
@@ -68,6 +69,17 @@ public class TkVideoController extends BaseController {
     return videoService.saveOrUpdate(dto);
   }
 
+  @PostMapping("/addGpt")
+  @ApiOperation("新增国标视频")
+  @PreAuthorize(
+          "@check.checkPermissions({'TENANT_ADMIN','CUSTOMER_USER'},{'api:yt:video:post','api:yt:video:update'})")
+  public TkVideoGptDTO saveOrUpdateAlarmProfile(@Validated @RequestBody TkVideoGptDTO dto)
+          throws ThingsboardException {
+    dto.setTenantId(getCurrentUser().getCurrentTenantId());
+    return videoService.saveGpt(dto);
+  }
+
+
   @DeleteMapping
   @ApiOperation("删除")
   @PreAuthorize("@check.checkPermissions({'TENANT_ADMIN','CUSTOMER_USER'},{'api:yt:video:delete'})")

+package org.thingsboard.server.controller.yunteng.media;
+
+import com.google.common.util.concurrent.MoreExecutors;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiParam;
+import io.swagger.v3.oas.annotations.Parameter;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.curator.shaded.com.google.common.util.concurrent.FutureCallback;
+import org.apache.curator.shaded.com.google.common.util.concurrent.Futures;
+import org.apache.curator.shaded.com.google.common.util.concurrent.ListenableFuture;
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.jetbrains.annotations.NotNull;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.context.request.async.DeferredResult;
+import org.thingsboard.server.common.data.StringUtils;
+import org.thingsboard.server.common.data.exception.ThingsboardException;
+import org.thingsboard.server.common.data.yunteng.core.exception.TkDataValidationException;
+import org.thingsboard.server.common.data.yunteng.core.message.ErrorMessage;
+import org.thingsboard.server.common.data.yunteng.dto.DeviceDTO;
+import org.thingsboard.server.common.data.yunteng.dto.sip.StreamContentDTO;
+import org.thingsboard.server.common.data.yunteng.enums.PTZCommandEnum;
+import org.thingsboard.server.common.data.yunteng.utils.tools.ResponseResult;
+import org.thingsboard.server.controller.BaseController;
+import org.thingsboard.server.dao.yunteng.service.TkDeviceService;
+import org.thingsboard.server.service.yunteng.media.TkVideoControlService;
+
+@RestController
+@RequestMapping("api/yt/video/control")
+@Api(tags = {"视频控制管理"})
+@RequiredArgsConstructor
+@Slf4j
+public class TkVideoControlController extends BaseController {
+
+  private final TkVideoControlService tkVideoControlService;
+  private final TkDeviceService tkDeviceService;
+
+  @GetMapping("/start/{deviceId}/{channelId}")
+  @ApiOperation(value = "视频点播/预览")
+  public DeferredResult<ResponseResult<StreamContentDTO>> startPlay(
+      @PathVariable("deviceId") String tbDeviceId, @PathVariable("channelId") String channelId)
+      throws ThingsboardException {
+    if (StringUtils.isEmpty(tbDeviceId) || StringUtils.isEmpty(channelId)) {
+      throw new TkDataValidationException(ErrorMessage.INVALID_PARAMETER.getMessage());
+    }
+    DeferredResult<ResponseResult<StreamContentDTO>> response = new DeferredResult<>();
+    ListenableFuture<StreamContentDTO> future =
+        tkVideoControlService.startPlay(getCurrentUser(),tbDeviceId, channelId, getCurrentUser().getCurrentTenantId());
+    Futures.addCallback(
+        future,
+        new FutureCallback<>() {
+          @Override
+          public void onSuccess(@Nullable StreamContentDTO streamContentDTO) {
+            response.setResult(ResponseResult.success(streamContentDTO));
+          }
+
+          @Override
+          public void onFailure(@NotNull Throwable throwable) {
+            response.setResult(ResponseResult.failed(null));
+          }
+        },
+        MoreExecutors.directExecutor());
+    return response;
+  }
+
+  @ApiOperation(value = "停止点播")
+  @GetMapping("/stop/{deviceId}/{channelId}")
+  public ResponseResult playStop(
+      @ApiParam(value = "设备ID", required = true) @PathVariable("deviceId") String tbDeviceId,
+      @ApiParam(value = "通道ID", required = true) @PathVariable("channelId") String channelId)
+      throws ThingsboardException {
+    if (StringUtils.isEmpty(tbDeviceId) || StringUtils.isEmpty(channelId)) {
+      throw new TkDataValidationException(ErrorMessage.INVALID_PARAMETER.getMessage());
+    }
+    return ResponseResult.success(
+        tkVideoControlService.stopPlay(getCurrentUser(),tbDeviceId, channelId));
+  }
+
+  @ApiOperation(value = "云台控制")
+  @Parameter(name = "tbDeviceId", description = "TB设备ID", required = true)
+  @Parameter(name = "channelId", description = "通道国标编号", required = true)
+  @Parameter(
+      name = "command",
+      description =
+          "控制指令,允许值: LEFT, RIGHT, UP, DOWN, UP_LEFT, UPRIGHT, DOWN_LEFT, DOWN_RIGHT, ZOOM_IN, ZOOM_OUT, STOP",
+      required = true)
+  @Parameter(name = "horizonSpeed", description = "水平速度", required = true)
+  @Parameter(name = "verticalSpeed", description = "垂直速度", required = true)
+  @Parameter(name = "zoomSpeed", description = "缩放速度", required = true)
+  @GetMapping("/control/{tbDeviceId}/{channelId}")
+  public void ptzControl(
+      @PathVariable String tbDeviceId,
+      @PathVariable String channelId,
+      PTZCommandEnum command,
+      int horizonSpeed,
+      int verticalSpeed,
+      int zoomSpeed)
+      throws ThingsboardException {
+    ResponseResult.success(
+            tkVideoControlService.control(getCurrentUser(),tbDeviceId, channelId,command,horizonSpeed,verticalSpeed,zoomSpeed));
+  }
+}

+package org.thingsboard.server.controller.yunteng.media;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.*;
+import org.thingsboard.server.common.data.exception.ThingsboardException;
+import org.thingsboard.server.common.data.yunteng.constant.FastIotConstants;
+import org.thingsboard.server.common.data.yunteng.dto.DeviceDTO;
+import org.thingsboard.server.common.data.yunteng.dto.sip.VideoChanelDTO;
+import org.thingsboard.server.common.data.yunteng.dto.sip.hook.param.*;
+import org.thingsboard.server.controller.BaseController;
+import org.thingsboard.server.dao.yunteng.service.TkDeviceService;
+import org.thingsboard.server.dao.yunteng.service.media.TkMediaServerService;
+import org.thingsboard.server.dao.yunteng.service.media.TkVideoChannelService;
+import org.thingsboard.server.service.yunteng.media.TkVideoControlService;
+
+/** ZLMediaServer的hook事件监听 */
+@RestController
+@RequestMapping("api/index/hook")
+@Api(tags = {"ZLMediaServer的hook事件监听"})
+@RequiredArgsConstructor
+@Slf4j
+public class ZLMediaKitHookController extends BaseController {
+  private final TkMediaServerService tkMediaServerService;
+  private final TkVideoChannelService tkVideoChannelService;
+  private final TkVideoControlService controlService;
+
+  @PostMapping(value = "/on_server_keepalive", produces = "application/json;charset=UTF-8")
+  @ApiOperation(value = "保持流媒体服务器的心跳")
+  public HookResult onServerKeepalive(@RequestBody OnServerKeepaliveHookParam param) {
+    //    log.error("ZLMediaKitHook保持流媒体服务器的心跳【on_server_keepalive】，API参数【{}】",
+    // JacksonUtil.toString(param));
+    return tkMediaServerService.zlmOnServerKeepalive(param);
+  }
+
+  @PostMapping(value = "/on_play", produces = "application/json;charset=UTF-8")
+  @ApiOperation(value = "播放器鉴权事件")
+  public HookResult onPlay(@RequestBody BaseParam param) {
+    return tkMediaServerService.zlmOnPlay(param);
+  }
+
+  @PostMapping(value = "/on_publish", produces = "application/json;charset=UTF-8")
+  @ApiOperation(value = "rtsp/rtmp/rtp推流鉴权事件")
+  public HookResultForOnPublish onPublish(@RequestBody BaseParam param) {
+    return tkMediaServerService.onPublish(param);
+  }
+
+  @PostMapping(value = "/on_stream_changed", produces = "application/json;charset=UTF-8")
+  @ApiOperation(value = "rtsp/rtmp流注册或注销时触发此事件；此事件对回复不敏感")
+  public HookResult onStreamChanged(@RequestBody OnStreamChangedHookParam param) {
+    return tkMediaServerService.zlmOnStreamChanged(param);
+  }
+
+  @ResponseBody
+  @PostMapping(value = "/on_stream_none_reader", produces = "application/json;charset=UTF-8")
+  @ApiOperation(value = "流无人观看时事件，用户可以通过此事件选择是否关闭无人看的流")
+  public JsonNode onStreamNoneReader(@RequestBody OnStreamNoneReaderHookParam param) throws ThingsboardException {
+    JsonNode result = tkMediaServerService.zlmOnStreamNoneReader(param);
+    if(result.has(FastIotConstants.ZLMediaBody.CHANNEL_ID) &&result.has(FastIotConstants.ZLMediaBody.CAMERA_CODE)){
+      String channelId = result.get(FastIotConstants.ZLMediaBody.CHANNEL_ID).asText();
+      String cameraCode = result.get(FastIotConstants.ZLMediaBody.CAMERA_CODE).asText();
+      VideoChanelDTO chanelDTO = tkVideoChannelService.findVideoChannelById(cameraCode,channelId, null);
+      controlService.byeCmdInSsrcTransaction(chanelDTO.getTenantId(),
+              false,
+              chanelDTO.getDeviceId(),
+              cameraCode,channelId,result.get(FastIotConstants.ZLMediaBody.SSRCINFO_STREAM).asText(),
+              fromDeviceRpcResponse->{
+
+              });
+      tkVideoChannelService.updateVideoChannelStreamId(null, cameraCode, channelId);//storager.stopPlay(streamInfo.getDeviceID(), streamInfo.getChannelId());
+    }
+    return result;
+  }
+}

@@ -15,6 +15,9 @@
  */
 package org.thingsboard.server.service.transport;
 
+import static org.thingsboard.server.service.transport.BasicCredentialsValidationResult.PASSWORD_MISMATCH;
+import static org.thingsboard.server.service.transport.BasicCredentialsValidationResult.VALID;
+
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
@@ -23,8 +26,18 @@ import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.MoreExecutors;
 import com.google.protobuf.ByteString;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+import java.util.stream.Collectors;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.zookeeper.Op;
 import org.springframework.stereotype.Service;
 import org.thingsboard.common.util.JacksonUtil;
 import org.thingsboard.server.cache.ota.OtaPackageDataCache;
@@ -60,9 +73,14 @@ import org.thingsboard.server.common.data.page.PageLink;
 import org.thingsboard.server.common.data.relation.EntityRelation;
 import org.thingsboard.server.common.data.security.DeviceCredentials;
 import org.thingsboard.server.common.data.security.DeviceCredentialsType;
+import org.thingsboard.server.common.data.yunteng.common.media.VideoStreamSessionManager;
+import org.thingsboard.server.common.data.yunteng.constant.FastIotConstants;
 import org.thingsboard.server.common.data.yunteng.dto.DeviceDTO;
 import org.thingsboard.server.common.data.yunteng.dto.TkDeviceScriptDTO;
-import org.thingsboard.server.common.data.yunteng.enums.TkScriptFunctionType;
+import org.thingsboard.server.common.data.yunteng.dto.sip.SipDeviceDTO;
+import org.thingsboard.server.common.data.yunteng.dto.sip.SsrcTransactionDTO;
+import org.thingsboard.server.common.data.yunteng.dto.sip.VideoChanelDTO;
+import org.thingsboard.server.common.data.yunteng.enums.VideoCmdEnum;
 import org.thingsboard.server.common.msg.EncryptionUtil;
 import org.thingsboard.server.common.msg.TbMsg;
 import org.thingsboard.server.common.msg.TbMsgDataType;
@@ -79,6 +97,8 @@ import org.thingsboard.server.dao.relation.RelationService;
 import org.thingsboard.server.dao.tenant.TbTenantProfileCache;
 import org.thingsboard.server.dao.yunteng.service.TkDeviceScriptService;
 import org.thingsboard.server.dao.yunteng.service.TkDeviceService;
+import org.thingsboard.server.dao.yunteng.service.media.TkMediaServerNodeService;
+import org.thingsboard.server.dao.yunteng.service.media.TkVideoChannelService;
 import org.thingsboard.server.gen.transport.TransportProtos;
 import org.thingsboard.server.gen.transport.TransportProtos.DeviceInfoProto;
 import org.thingsboard.server.gen.transport.TransportProtos.GetDeviceCredentialsRequestMsg;
@@ -105,19 +125,6 @@ import org.thingsboard.server.service.install.DefaultSystemDataLoaderService;
 import org.thingsboard.server.service.profile.TbDeviceProfileCache;
 import org.thingsboard.server.service.resource.TbResourceService;
 
-import java.util.Arrays;
-import java.util.List;
-import java.util.Optional;
-import java.util.UUID;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-import java.util.concurrent.locks.Lock;
-import java.util.concurrent.locks.ReentrantLock;
-import java.util.stream.Collectors;
-
-import static org.thingsboard.server.service.transport.BasicCredentialsValidationResult.PASSWORD_MISMATCH;
-import static org.thingsboard.server.service.transport.BasicCredentialsValidationResult.VALID;
-
 /**
  * Created by ashvayka on 05.10.18.
  */
@@ -135,6 +142,10 @@ public class DefaultTransportApiService implements TransportApiService {
     private final DeviceService deviceService;
     private final TkDeviceService ytDeviceService;
     private final TkDeviceScriptService scriptService;
+    private final TkVideoChannelService channelService;
+    private final TkMediaServerNodeService mediaServerNodeService;
+    private final VideoStreamSessionManager videoStreamSessionManager;
+
     private final RelationService relationService;
     private final DeviceCredentialsService deviceCredentialsService;
     private final DbCallbackExecutorService dbCallbackExecutorService;
@@ -192,6 +203,9 @@ public class DefaultTransportApiService implements TransportApiService {
         else if (transportApiRequestMsg.hasScript()) {
             result = handle(transportApiRequestMsg.getScript());
         }
+        else if (transportApiRequestMsg.hasGbt28181RequestMsg()) {
+            result = handleGbt(transportApiRequestMsg.getGbt28181RequestMsg());
+        }
 
 
         return Futures.transform(Optional.ofNullable(result).orElseGet(this::getEmptyTransportApiResponseFuture),
@@ -685,20 +699,74 @@ public class DefaultTransportApiService implements TransportApiService {
     private ListenableFuture<TransportApiResponseMsg> handle(TransportProtos.ScriptProto requestMsg) {
         List<TkDeviceScriptDTO> allScriptes = scriptService.getScriptes();
         TransportApiResponseMsg.Builder responseBuilder = TransportApiResponseMsg.newBuilder();
-    allScriptes.forEach(
-        item -> {
-          UUID tenantId = UUID.fromString(item.getTenantId());
-          UUID id = UUID.fromString(item.getId());
-          responseBuilder.addScriptsResponseMsg(
-              TransportProtos.ScriptProto.newBuilder()
-                  .setConvertJs(item.getConvertJs())
-                  .setTenantIdLSB(tenantId.getLeastSignificantBits())
-                  .setTenantIdMSB(tenantId.getMostSignificantBits())
-                  .setScriptIdLSB(id.getLeastSignificantBits())
-                  .setScriptIdMSB(id.getMostSignificantBits())
-                  .setFunctionType(item.getScriptType().name())
-                  .setStatus(item.getStatus()));
-        });
+        allScriptes.forEach(
+                item -> {
+                    UUID tenantId = UUID.fromString(item.getTenantId());
+                    UUID id = UUID.fromString(item.getId());
+                    responseBuilder.addScriptsResponseMsg(
+                            TransportProtos.ScriptProto.newBuilder()
+                                    .setConvertJs(item.getConvertJs())
+                                    .setTenantIdLSB(tenantId.getLeastSignificantBits())
+                                    .setTenantIdMSB(tenantId.getMostSignificantBits())
+                                    .setScriptIdLSB(id.getLeastSignificantBits())
+                                    .setScriptIdMSB(id.getMostSignificantBits())
+                                    .setFunctionType(item.getScriptType().name())
+                                    .setStatus(item.getStatus()));
+                });
         return Futures.immediateFuture(responseBuilder.build());
     }
+    private ListenableFuture<TransportApiResponseMsg> handleGbt(TransportProtos.Gbt28181RequestMsg requestMsg) {
+        TransportProtos.Gbt28181ResponseMsg.Builder responseMsgBuilder =TransportProtos.Gbt28181ResponseMsg.newBuilder();
+        String tenantId = new UUID(requestMsg.getTenantIdMSB(), requestMsg.getTenantIdLSB()).toString();
+        String tbDeviceId = new UUID(requestMsg.getEntityIdMSB(), requestMsg.getEntityIdLSB()).toString();
+        String type = requestMsg.getContextType();
+        switch (VideoCmdEnum.valueOf(type)){
+            case DeviceInfo:
+                Optional<SipDeviceDTO> camera = dataDecodingEncodingService.decode(requestMsg.getContext().toByteArray());
+                camera.ifPresent(sip ->{
+                    ytDeviceService.updateDeviceInfo(tenantId,tbDeviceId, FastIotConstants.DeviceAdditional.SIP,JacksonUtil.valueToTree(sip));
+                });
+
+                break;
+            case Catalog:
+                Optional<List<VideoChanelDTO>> chanel = dataDecodingEncodingService.decode(requestMsg.getContext().toByteArray());
+                chanel.ifPresent(d->{
+                    d.forEach(channelService::saveOrUpdate);
+                });
+                break;
+            default:
+                release(tenantId,tbDeviceId);
+
+        }
+//        byte[] channaelMsgBytes = dataDecodingEncodingService.encode(channelDTO);
+//        responseMsgBuilder.setContext(ByteString.copyFrom(channaelMsgBytes));
+        return Futures.immediateFuture(TransportApiResponseMsg.newBuilder().setGbt28181ResponseMsg(responseMsgBuilder.build()).build());
+    }
+    private void release(String tenantId,String tbDeviceId){
+        DeviceDTO device = ytDeviceService.findDeviceInfoByTbDeviceId(tenantId,tbDeviceId);
+        Optional.ofNullable(device).ifPresent(dev->{
+            JsonNode sip = dev.getDeviceInfo().get(FastIotConstants.DeviceAdditional.SIP);
+            if(!sip.isEmpty() && sip.has(FastIotConstants.ZLMediaBody.CAMERA_CODE)){
+                String cameraCode = sip.get(FastIotConstants.ZLMediaBody.CAMERA_CODE).asText();
+                Optional<Set<String>> ssrcKeys =
+                        videoStreamSessionManager.getSsrcTransactionCamaraKey(cameraCode);
+                ssrcKeys.ifPresent(all ->{
+                    all.forEach(fullKey->{
+                        videoStreamSessionManager.getSsrcTransaction(fullKey).ifPresent(ssrcTransaction -> {
+                            mediaServerNodeService.releaseSsrc(
+                                    ssrcTransaction.getMediaServerId(), ssrcTransaction.getSsrc());
+                            mediaServerNodeService.closeRTPServer(
+                                    ssrcTransaction.getMediaServerId(), ssrcTransaction.getStream());
+                            videoStreamSessionManager.remove(
+                                    cameraCode, ssrcTransaction.getChannelId(),
+                                    ssrcTransaction.getStream());
+                        });
+
+                    });
+                });
+            }
+        });
+
+
+    }
 }

+package org.thingsboard.server.service.yunteng.media;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import org.apache.curator.shaded.com.google.common.util.concurrent.ListenableFuture;
+import org.thingsboard.server.common.data.exception.ThingsboardException;
+import org.thingsboard.server.common.data.yunteng.dto.sip.*;
+import org.thingsboard.server.common.data.yunteng.enums.PTZCommandEnum;
+import org.thingsboard.server.common.msg.rpc.FromDeviceRpcResponse;
+import org.thingsboard.server.service.security.model.SecurityUser;
+
+import java.util.function.Consumer;
+
+public interface TkVideoControlService {
+
+  /**
+   * 视频点播
+   *
+   * @param deviceId 设备ID
+   * @param channelId 通道ID
+   * @param tenantId 租户ID
+   * @return 视频流播放地址内容
+   */
+  ListenableFuture<StreamContentDTO> startPlay(
+      SecurityUser currentUser, String deviceId, String channelId, String tenantId);
+
+  /**
+   * 当点播时的推送处理程序
+   *
+   * @param mediaServerItem 流媒体信息
+   * @param response 响应
+   * @param deviceId 点播设备ID
+   * @param channelId 点播设备通道ID
+   */
+  StreamInfoDTO onPublishHandlerForPlay(
+      MediaServerDTO mediaServerItem, JsonNode response, String deviceId, String channelId);
+
+  /**
+   * 通过设备ID和通道ID暂停播放
+   *
+   * @param tbDeviceId TB设备的ID
+   * @param channelId 通道ID
+   * @return 暂停播放结果 true成功 false失败
+   */
+  boolean stopPlay(SecurityUser currentUser, String tbDeviceId, String channelId) throws ThingsboardException;
+
+  /**
+   * 摄像头控制
+   * @param currentUser 登录用户
+   * @param tbDeviceId 设备ID
+   * @param channelId 设备通道
+   * @param command  控制指令
+   * @param horizonSpeed 水平速度
+   * @param verticalSpeed 垂直速度
+   * @param zoomSpeed 缩放速度
+   * @return
+   */
+  boolean control(SecurityUser currentUser, String tbDeviceId, String channelId, PTZCommandEnum command, int horizonSpeed, int verticalSpeed, int zoomSpeed) throws ThingsboardException;
+
+  StreamInfoDTO play(
+      SecurityUser currentUser,
+      String tbDeviceId,
+      MediaServerDTO mediaServerItem,
+      SsrcInfoDTO ssrcInfo,
+      SipDeviceDTO device,
+      String channelId);
+  public void byeCmdInSsrcTransaction(
+          String tenantId,
+          boolean oneWay,
+          String tbDeviceId,
+          String cameraCode,String channelId,String  streamId,
+          Consumer<FromDeviceRpcResponse> responseConsumer)
+          throws ThingsboardException;
+}

+package org.thingsboard.server.service.yunteng.media;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import java.util.Optional;
+import java.util.UUID;
+import java.util.Vector;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Consumer;
+import javax.sdp.*;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.curator.shaded.com.google.common.util.concurrent.Futures;
+import org.apache.curator.shaded.com.google.common.util.concurrent.ListenableFuture;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+import org.thingsboard.server.common.data.StringUtils;
+import org.thingsboard.server.common.data.exception.ThingsboardErrorCode;
+import org.thingsboard.server.common.data.exception.ThingsboardException;
+import org.thingsboard.server.common.data.id.DeviceId;
+import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.common.data.rpc.ToDeviceRpcRequestBody;
+import org.thingsboard.server.common.data.yunteng.common.media.VideoStreamSessionManager;
+import org.thingsboard.server.common.data.yunteng.common.media.ZlmHttpHookSubscribe;
+import org.thingsboard.server.common.data.yunteng.config.media.UserSetting;
+import org.thingsboard.server.common.data.yunteng.constant.FastIotConstants;
+import org.thingsboard.server.common.data.yunteng.core.exception.TkDataValidationException;
+import org.thingsboard.server.common.data.yunteng.core.message.ErrorMessage;
+import org.thingsboard.server.common.data.yunteng.dto.DeviceDTO;
+import org.thingsboard.server.common.data.yunteng.dto.sip.*;
+import org.thingsboard.server.common.data.yunteng.dto.sip.hook.param.HookSubscribeForStreamChange;
+import org.thingsboard.server.common.data.yunteng.enums.PTZCommandEnum;
+import org.thingsboard.server.common.data.yunteng.enums.SessionTypeEnum;
+import org.thingsboard.server.common.data.yunteng.enums.VideoMethodEnum;
+import org.thingsboard.server.common.data.yunteng.utils.JacksonUtil;
+import org.thingsboard.server.common.data.yunteng.utils.ZLMediaKitRestFulUtils;
+import org.thingsboard.server.common.msg.rpc.FromDeviceRpcResponse;
+import org.thingsboard.server.common.msg.rpc.ToDeviceRpcRequest;
+import org.thingsboard.server.dao.util.yunteng.ZLMediaKitTaskUtils;
+import org.thingsboard.server.dao.yunteng.service.TkDeviceService;
+import org.thingsboard.server.dao.yunteng.service.media.*;
+import org.thingsboard.server.service.rpc.TbCoreDeviceRpcService;
+import org.thingsboard.server.service.security.model.SecurityUser;
+
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class TkVideoControlServiceImpl implements TkVideoControlService {
+
+  private final TkMediaServerService tkMediaServerService;
+  private final TkMediaServerNodeService tkMediaServerNodeService;
+  private final TkDeviceService tkDeviceService;
+  private final TkVideoChannelService tkVideoChannelService;
+  private final TkCacheStorageService tkCacheStorageService;
+  private final ZLMediaKitTaskUtils zlMediaKitTaskUtils;
+  private final UserSetting userSetting;
+  private final ZlmHttpHookSubscribe subscribe;
+  private final VideoStreamSessionManager videoStreamSessionManager;
+  private final ZLMediaKitRestFulUtils zlMediaKitRestFulUtils;
+  private final TbCoreDeviceRpcService deviceRpcService;
+
+  @Override
+  public ListenableFuture<StreamContentDTO> startPlay(
+      SecurityUser currentUser, String deviceId, String channelId, String tenantId) {
+    // 判断设备、通道是否存在
+    DeviceDTO deviceDTO = tkDeviceService.checkDeviceByTenantIdAndId(tenantId, deviceId, true);
+    SipDeviceDTO sipDeviceDTO =
+        JacksonUtil.convertValue(
+            deviceDTO.getDeviceInfo().get(FastIotConstants.DeviceAdditional.SIP),
+            SipDeviceDTO.class);
+    // 获取设备的附加信息
+    if (null == sipDeviceDTO) {
+      throw new TkDataValidationException(ErrorMessage.FOUND_VIDEO_DEVICE_FAILED.getMessage());
+    }
+    VideoChanelDTO videoChanelDTO = tkVideoChannelService.findVideoChannelById(sipDeviceDTO.getCameraCode(), channelId, tenantId);
+    if (null == videoChanelDTO) {
+      throw new TkDataValidationException(ErrorMessage.VIDEO_CHANNEL_NOT_FOUND.getMessage());
+    }
+    // 找到可以使用的流媒体
+    MediaServerDTO mediaServer =
+        tkMediaServerService.getMediaServerForPlay(tenantId, sipDeviceDTO.getMediaServerId());
+    if (null == mediaServer) {
+      throw new TkDataValidationException(
+          ErrorMessage.NOT_FOUND_MEDIA_SERVER_FOR_PLAY.getMessage());
+    }
+    // 根据设备ID和通道ID,找到对应的流信息
+    Optional<StreamInfoDTO> result =
+        tkCacheStorageService.queryPlayStreamByChannel(sipDeviceDTO.getCameraCode(), channelId);
+    if (result.isPresent()) {
+      StreamInfoDTO streamInfoDTO = result.get();
+      String streamId = streamInfoDTO.getStream();
+      if (StringUtils.isNotEmpty(streamId)) {
+        String mediaServerId = streamInfoDTO.getMediaServerId();
+        Optional<MediaServerDTO> mediaServerDTO = tkMediaServerNodeService.getOne(mediaServerId);
+        if (mediaServerDTO.isPresent()) {
+          if (checkRTPServerExist(mediaServerDTO.get(), streamInfoDTO, tenantId)) {
+            log.debug(String.format("缓存的【流媒体播放信息】内容【%s】", streamInfoDTO));
+            return Futures.immediateFuture(new StreamContentDTO(streamInfoDTO));
+          }
+        }
+      }
+    }
+
+    StreamInfoDTO streamInfoDTO =
+        deviceFirstPlay(
+            currentUser, deviceDTO.getTbDeviceId(), mediaServer, sipDeviceDTO, videoChanelDTO);
+    if (Optional.ofNullable(streamInfoDTO).isPresent()) {
+      return Futures.immediateFuture(new StreamContentDTO(streamInfoDTO));
+    } else {
+      return Futures.immediateFuture(new StreamContentDTO(null));
+    }
+  }
+
+  @Override
+  public StreamInfoDTO onPublishHandlerForPlay(
+      MediaServerDTO mediaServerItem, JsonNode response, String deviceCode, String channelId) {
+    StreamInfoDTO streamInfo = onPublishHandler(mediaServerItem, response, deviceCode, channelId);
+    VideoChanelDTO videoChanel =
+        tkVideoChannelService.findVideoChannelById(
+            deviceCode, channelId, mediaServerItem.getTenantId());
+    if (videoChanel != null) {
+      videoChanel.setStreamId(streamInfo.getStream());
+      tkVideoChannelService.updateVideoChannelStreamId(
+          streamInfo.getStream(), deviceCode, channelId);
+    }
+    tkCacheStorageService.cacheStreamInfoByStartPlay(streamInfo);
+    return streamInfo;
+  }
+
+  @Override
+  public boolean stopPlay(SecurityUser currentUser, String tbDeviceId, String channelId) throws ThingsboardException {
+      String tenantId = currentUser.getCurrentTenantId();
+      DeviceDTO deviceDTO = tkDeviceService.findDeviceInfoByTbDeviceId(tenantId, tbDeviceId);
+      if (null == deviceDTO
+          || !deviceDTO.getDeviceInfo().has(FastIotConstants.DeviceAdditional.SIP)) {
+        throw new TkDataValidationException(ErrorMessage.INVALID_PARAMETER.getMessage());
+      }
+      String cameraCode =
+          deviceDTO
+              .getDeviceInfo()
+              .get(FastIotConstants.DeviceAdditional.SIP)
+              .get(FastIotConstants.ZLMediaBody.CAMERA_CODE)
+              .asText();
+
+      Optional<StreamInfoDTO> streamInfoDTO =
+          tkCacheStorageService.queryPlayStreamByChannel(cameraCode, channelId);
+      if (streamInfoDTO.isEmpty()) {
+        throw new TkDataValidationException(
+            ErrorMessage.STREAM_INFO_NOT_FOUND_FOR_PLAY.getMessage());
+      }
+      byeCmdInSsrcTransaction(
+              currentUser.getCurrentTenantId(),
+              false,
+              tbDeviceId,
+              cameraCode,channelId,streamInfoDTO.get().getStream(),
+              fromDeviceRpcResponse->{
+
+              });
+
+      tkCacheStorageService.deleteCacheStreamInfoByStopPlay(streamInfoDTO.get()); //redisCatchStorage.stopPlay(streamInfo);
+      return tkVideoChannelService.updateVideoChannelStreamId(null, cameraCode, channelId);//storager.stopPlay(streamInfo.getDeviceID(), streamInfo.getChannelId());
+  }
+
+  @Override
+  public StreamInfoDTO play(
+      SecurityUser currentUser,
+      String tbDeviceId,
+      MediaServerDTO mediaServerDTO,
+      SsrcInfoDTO ssrcInfoDTO,
+      SipDeviceDTO sipDeviceDTO,
+      String channelId) {
+    HookSubscribeForStreamChange hookSubscribe =
+        new HookSubscribeForStreamChange(
+            "rtp", ssrcInfoDTO.getStream(), true, "rtsp", mediaServerDTO.getMediaServerId());
+    CountDownLatch timeoutLatch = new CountDownLatch(1);
+    // 定时任务超时KEY
+    String timeOutTaskKey = UUID.randomUUID().toString();
+    zlMediaKitTaskUtils.startCronTaskDelay(
+        timeOutTaskKey,
+        () -> {
+          log.debug(
+              "[点播超时] 收流超时 deviceId: {}, channelId: {}，端口：{}, SSRC: {}",
+              sipDeviceDTO.getCameraCode(),
+              channelId,
+              ssrcInfoDTO.getPort(),
+              ssrcInfoDTO.getSsrc());
+          // 点播超时回复BYE 同时释放ssrc以及此次点播的资源
+          try {
+            //        cmder.streamByeCmd(device, channelId, ssrcInfo.getStream(), null);
+            // TODO 回复Bye命令
+          } catch (Exception e) {
+            log.error("[点播超时]， 发送BYE失败 {}", e.getMessage());
+          } finally {
+            //            timeoutCallback.run(1, "收流超时");
+            // 释放SSRC
+            tkMediaServerNodeService.releaseSsrc(
+                mediaServerDTO.getMediaServerId(), ssrcInfoDTO.getSsrc());
+            //        streamSession.remove(device.getDeviceId(), channelId, ssrcInfo.getStream());
+            // 关闭RTP服务
+            tkMediaServerNodeService.closeRTPServer(
+                Optional.of(mediaServerDTO), ssrcInfoDTO.getStream());
+            // 取消订阅消息监听
+            subscribe.removeSubscribe(hookSubscribe);
+          }
+        },
+        userSetting.getPlayTimeout());
+    // 获取端口信息失败,则不发送点播指令
+    if (ssrcInfoDTO.getPort() <= FastIotConstants.MagicNumber.ZERO) {
+      zlMediaKitTaskUtils.stop(timeOutTaskKey);
+      // 释放SSRC
+      tkMediaServerNodeService.releaseSsrc(
+          mediaServerDTO.getMediaServerId(), ssrcInfoDTO.getSsrc());
+      videoStreamSessionManager.remove(
+          sipDeviceDTO.getCameraCode(), channelId, ssrcInfoDTO.getStream());
+      throw new TkDataValidationException(ErrorMessage.GET_PLAY_PORT_FAILED.getMessage());
+    }
+    // 进行命令发送
+    AtomicReference<StreamInfoDTO> result = new AtomicReference<>();
+    try {
+
+      log.debug(
+          String.format(
+              "视频流【%s】的流媒体服务器信息=流媒体服务ID【%s】+流媒体服务端口【%s】+SDP(会话)IP【%s】",
+              ssrcInfoDTO.getStream(),
+              mediaServerDTO.getMediaServerId(),
+              ssrcInfoDTO.getPort(),
+              mediaServerDTO.getSdpIp()));
+      ObjectNode paramJson = JacksonUtil.newObjectNode();
+      paramJson.set(FastIotConstants.ZLMediaBody.MEDIA, JacksonUtil.valueToTree(mediaServerDTO));
+      //
+      // paramJson.put(FastIotConstants.ZLMediaBody.MEDIA_ID,mediaServerDTO.getMediaServerId());
+      //      paramJson.put(FastIotConstants.ZLMediaBody.MEDIA_SDP_IP,mediaServerDTO.getSdpIp());
+      paramJson.put(FastIotConstants.ZLMediaBody.SSRCINFO_STREAM, ssrcInfoDTO.getStream());
+      paramJson.put(FastIotConstants.ZLMediaBody.SSRCINFO_PORT, ssrcInfoDTO.getPort());
+      paramJson.put(FastIotConstants.ZLMediaBody.SSRCINFO_SSRC, ssrcInfoDTO.getSsrc());
+      paramJson.put(FastIotConstants.ZLMediaBody.CHANNEL_ID, channelId);
+      // TODO: 2023/12/28 收到流改变事件后，视频点播的业务逻辑。
+      subscribe.addSubscribe(
+          hookSubscribe,
+          (MediaServerDTO mediaServerItemInUse, JsonNode response) -> {
+            log.debug(
+                "处理订阅消息：主题【{}】流媒体信息【{}】收到的内容【{}】",
+                hookSubscribe.getHookType().name(),
+                mediaServerItemInUse,
+                response);
+            zlMediaKitTaskUtils.stop(timeOutTaskKey);
+
+            subscribe.removeSubscribe(hookSubscribe);
+            result.set(
+                steamImage(
+                    ssrcInfoDTO.getStream(),
+                    sipDeviceDTO.getCameraCode(),
+                    channelId,
+                    mediaServerItemInUse,
+                    response));
+            timeoutLatch.countDown();
+          });
+      cameraCommonCmd(
+          currentUser.getCurrentTenantId(),
+          paramJson,
+          sipDeviceDTO.getCameraCode(),
+          VideoMethodEnum.INVITE,
+          false,
+              tbDeviceId,
+          fromDeviceRpcResponse -> {
+            log.warn("【流媒体SIP】收到【视频点播】结果=异常【{}】+数据【{}】",fromDeviceRpcResponse.getError(), fromDeviceRpcResponse.getResponse());
+            fromDeviceRpcResponse
+                .getResponse()
+                .ifPresent(
+                    jsonStr -> {
+                      JsonNode responseJson = JacksonUtil.toJsonNode(jsonStr);
+                      if (fromDeviceRpcResponse.getError().isEmpty()) {
+                        playSuccess(
+                            currentUser,
+                            tbDeviceId,
+                            mediaServerDTO,
+                            responseJson,
+                            ssrcInfoDTO,
+                            sipDeviceDTO,
+                            channelId,
+                            timeOutTaskKey);
+                      } else {
+                        zlMediaKitTaskUtils.stop(timeOutTaskKey);
+                        tkMediaServerNodeService.closeRTPServer(
+                            mediaServerDTO, ssrcInfoDTO.getStream(), null);
+                        // 释放ssrc
+                        tkMediaServerNodeService.releaseSsrc(
+                            mediaServerDTO.getMediaServerId(), ssrcInfoDTO.getSsrc());
+                        videoStreamSessionManager.remove(
+                            sipDeviceDTO.getCameraCode(), channelId, ssrcInfoDTO.getStream());
+                        //                  errorEvent.response(event);
+                      }
+                    });
+          });
+      timeoutLatch.await(userSetting.getPlayTimeout(), TimeUnit.MILLISECONDS);
+    } catch (Exception e) {
+      zlMediaKitTaskUtils.stop(timeOutTaskKey);
+      tkMediaServerNodeService.closeRTPServer(
+          Optional.ofNullable(mediaServerDTO), ssrcInfoDTO.getStream());
+      // 释放ssrc
+      tkMediaServerNodeService.releaseSsrc(mediaServerDTO.getId(), ssrcInfoDTO.getSsrc());
+
+      videoStreamSessionManager.remove(
+          sipDeviceDTO.getCameraCode(), channelId, ssrcInfoDTO.getStream());
+
+      //      SipSubscribe.EventResult eventResult = new SipSubscribe.EventResult();
+      //      eventResult.type = SipSubscribe.EventResultType.cmdSendFailEvent;
+      //      eventResult.statusCode = -1;
+      //      eventResult.msg = "命令发送失败";
+      //      errorEvent.response(eventResult);
+    }
+    log.debug(String.format("最新的【流媒体播放信息】内容【%s】", result.get()));
+    return result.get();
+  }
+
+  /**
+   * 调用流媒体接口获取视频流封面图，并触发后续业务
+   *
+   * @param ssrcStream
+   * @param cameraCode
+   * @param channelId
+   * @param mediaServerItemInUse
+   * @param response
+   */
+  private StreamInfoDTO steamImage(
+      String ssrcStream,
+      String cameraCode,
+      String channelId,
+      MediaServerDTO mediaServerItemInUse,
+      JsonNode response) {
+    // hook响应
+    StreamInfoDTO streamInfoDTO =
+        onPublishHandlerForPlay(mediaServerItemInUse, response, cameraCode, channelId);
+    String streamUrl;
+    if (mediaServerItemInUse.getRtspPort() != 0) {
+      streamUrl =
+          String.format(
+              "rtsp://127.0.0.1:%s/%s/%s", mediaServerItemInUse.getRtspPort(), "rtp", ssrcStream);
+    } else {
+      streamUrl =
+          String.format(
+              "http://127.0.0.1:%s/%s/%s.live.mp4",
+              mediaServerItemInUse.getHttpPort(), "rtp", ssrcStream);
+    }
+    String path = "snap";
+    String fileName = cameraCode + "_" + channelId + ".jpg";
+    // 请求截图
+    log.debug("[请求截图]: " + fileName);
+    zlMediaKitRestFulUtils.getSnap(mediaServerItemInUse, streamUrl, 15, 1, path, fileName);
+    return streamInfoDTO;
+  }
+
+  /**
+   * 构建视频点播的流媒体信息
+   *
+   * @param mediaServerItem
+   * @param response
+   * @param deviceCode
+   * @param channelId
+   * @return
+   */
+  private StreamInfoDTO onPublishHandler(
+      MediaServerDTO mediaServerItem, JsonNode response, String deviceCode, String channelId) {
+    String streamId = response.get("stream").asText();
+    JsonNode tracks = response.get("tracks");
+    StreamInfoDTO streamInfo =
+        tkMediaServerService.getStreamInfoByAppAndStream(
+            mediaServerItem, "rtp", streamId, tracks, null);
+    streamInfo.setCameraCode(deviceCode);
+    streamInfo.setChannelId(channelId);
+    return streamInfo;
+  }
+
+  private StreamInfoDTO deviceFirstPlay(
+      SecurityUser currentUser,
+      String tbDeviceId,
+      MediaServerDTO mediaServerDTO,
+      SipDeviceDTO sipDeviceDTO,
+      VideoChanelDTO videoChanelDTO) {
+    // 进行点播时，需要的参数包含：schema、vhost、app、stream
+    String streamId = null;
+    // 是否开启了多端口模式
+    if (mediaServerDTO.isRtpEnable()) {
+      streamId =
+          String.format("%s_%s", sipDeviceDTO.getCameraCode(), videoChanelDTO.getChannelId());
+    }
+    // 开启收流服务
+    SsrcInfoDTO ssrcInfoDTO =
+        tkMediaServerNodeService.openRTPServer(
+            mediaServerDTO,
+            streamId,
+            null,
+            sipDeviceDTO.isSsrcCheck(),
+            false,
+            0,
+            false,
+            sipDeviceDTO.getStreamModeForParam());
+    if (null == ssrcInfoDTO) {
+      throw new TkDataValidationException(ErrorMessage.RECEIVE_STREAM_FAILED.getMessage());
+    }
+    // 开始进行点播
+    return play(
+        currentUser,
+        tbDeviceId,
+        mediaServerDTO,
+        ssrcInfoDTO,
+        sipDeviceDTO,
+        videoChanelDTO.getChannelId());
+  }
+
+  private boolean checkRTPServerExist(
+      MediaServerDTO mediaServerDTO, StreamInfoDTO streamInfo, String tenantId) {
+    String streamId = streamInfo.getStream();
+    JsonNode rtpInfo = zlMediaKitRestFulUtils.getRtpInfo(mediaServerDTO, streamId);
+    if (rtpInfo.get("code").asInt() == 0 && rtpInfo.get("exist").asBoolean()) {
+      int localPort = rtpInfo.get("local_port").asInt();
+      if (localPort == 0) {
+        throw new TkDataValidationException("点播已经在进行中，请稍候重试");
+      }
+      return true;
+    } else {
+      String deviceId = streamInfo.getCameraCode();
+      String channelId = streamInfo.getChannelId();
+      tkCacheStorageService.deleteCacheStreamInfoByStopPlay(streamInfo);
+      tkVideoChannelService.updateVideoChannelStreamId(null, deviceId, channelId);
+      return false;
+    }
+  }
+
+  @Value("${server.rest.server_side_rpc.min_timeout:5000}")
+  protected long minTimeout;
+
+  @Value("${server.rest.server_side_rpc.default_timeout:10000}")
+  protected long defaultTimeout;
+
+  /**
+   * 公用的命令下发接口
+   *
+   * @param tenantId
+   * @param paramJson
+   * @param oneWay
+   * @param deviceId TB的设备ID
+   * @param responseConsumer
+   * @throws ThingsboardException
+   */
+  public void cameraCommonCmd(
+      String tenantId,
+      ObjectNode paramJson,
+      String cameraCode,
+      VideoMethodEnum method,
+      boolean oneWay,
+      String deviceId,
+      Consumer<FromDeviceRpcResponse> responseConsumer)
+      throws ThingsboardException {
+    try {
+
+      paramJson.put(FastIotConstants.ZLMediaBody.CAMERA_CODE, cameraCode);
+      paramJson.put(FastIotConstants.ZLMediaBody.METHOD_TYPE, method.name());
+      ToDeviceRpcRequestBody body =
+          new ToDeviceRpcRequestBody("cameraMethod", JacksonUtil.toString(paramJson));
+      long timeout = defaultTimeout;
+      long expTime = System.currentTimeMillis() + Math.max(minTimeout, timeout);
+      UUID rpcRequestUUID = UUID.randomUUID();
+      boolean persisted = false;
+      ToDeviceRpcRequest rpcRequest =
+          new ToDeviceRpcRequest(
+              rpcRequestUUID, new TenantId(UUID.fromString(tenantId)),
+                  new DeviceId(UUID.fromString(deviceId)), oneWay, expTime, body, persisted, null, null);
+      deviceRpcService.processRestApiRpcRequest(rpcRequest, responseConsumer, null);
+    } catch (IllegalArgumentException ioe) {
+      throw new ThingsboardException(
+          "Invalid request body", ioe, ThingsboardErrorCode.BAD_REQUEST_PARAMS);
+    }
+  }
+
+  /**
+   * 点播关闭命令下发
+   *
+   * @param oneWay
+   * @param tbDeviceId TB的设备ID
+   * @param responseConsumer
+   * @throws ThingsboardException
+   */
+  @Override
+  public void byeCmdInSsrcTransaction(
+          String tenantId,
+          boolean oneWay,
+          String tbDeviceId,
+          String cameraCode,String channelId,String  streamId,
+          Consumer<FromDeviceRpcResponse> responseConsumer)
+          throws ThingsboardException {
+    Optional<SsrcTransactionDTO> transactionDTO = videoStreamSessionManager.getSsrcTransaction(cameraCode,channelId,streamId);
+    if (transactionDTO.isEmpty()) {
+      throw new TkDataValidationException(
+              ErrorMessage.STREAM_INFO_NOT_FOUND_FOR_PLAY.getMessage());
+    }
+    SsrcTransactionDTO ssrc = transactionDTO.get();
+    cameraByeCmd(
+            tenantId,ssrc.getSipTransactionInfo(),oneWay,true,tbDeviceId,
+            cameraCode,channelId,streamId,ssrc.getSsrc(),ssrc.getMediaServerId(),
+            responseConsumer);
+  }
+
+  public void byeCmdInSendRtp(
+          SecurityUser currentUser,
+          boolean oneWay,
+          String tbDeviceId,
+          String cameraCode,String channelId,String  streamId,
+          Consumer<FromDeviceRpcResponse> responseConsumer)
+          throws ThingsboardException {
+
+//    SendRtpItemDTO sendRtpItem =null;
+//    SipMessageHeaderDTO sipTransactionInfo =
+//        SipMessageHeaderDTO.builder()
+//            .toTag(sendRtpItem.getToTag())
+//            .fromTag(sendRtpItem.getFromTag())
+//            .callId(sendRtpItem.getCallId())
+//            .build();
+//    MediaServerDTO mediaServer = tkMediaServerService.getMediaServerByMediaServerId(sendRtpItem.getMediaServerId());
+//    cameraByeCmd(
+//            currentUser,ssrc.getSipTransactionInfo(),oneWay,mediaServer != null,tbDeviceId,
+//            cameraCode,sendRtpItem.getChannelId(),streamId,ssrc.getSsrc(),ssrc.getMediaServerId(),
+//            responseConsumer);
+  }
+
+
+  public void cameraByeCmd(
+          String currentUser,SipMessageHeaderDTO messageHeaderDTO,
+          boolean oneWay,boolean mediaOnline,
+          String tbDeviceId,
+          String cameraCode,String channelId,String  streamId,String ssrc,String mediaServerId,
+          Consumer<FromDeviceRpcResponse> responseConsumer) throws ThingsboardException {
+    if(mediaOnline){
+      tkMediaServerNodeService.releaseSsrc(mediaServerId,ssrc);
+      tkMediaServerNodeService.closeRTPServer(mediaServerId,streamId);
+    }
+    videoStreamSessionManager.remove(cameraCode,channelId,streamId);
+    ObjectNode paramJson = JacksonUtil.newObjectNode();
+    paramJson.put(FastIotConstants.ZLMediaBody.CHANNEL_ID, channelId);
+    paramJson.set(FastIotConstants.ZLMediaBody.MSG_HEADER, JacksonUtil.valueToTree(messageHeaderDTO));
+    cameraCommonCmd(
+            currentUser,
+            paramJson,
+            cameraCode,
+            VideoMethodEnum.BYE,
+            oneWay,
+            tbDeviceId,
+            responseConsumer);
+  }
+
+  /**
+   * 点播成功后，流媒体的业务逻辑
+   *
+   * @param currentUser
+   * @param tbDeviceId
+   * @param mediaServerDTO
+   * @param responseJson
+   * @param ssrcInfo
+   * @param sipDeviceDTO
+   * @param channelId
+   * @param timeOutTaskKey
+   */
+  private void playSuccess(
+      SecurityUser currentUser,
+      String tbDeviceId,
+      MediaServerDTO mediaServerDTO,
+      JsonNode responseJson,
+      SsrcInfoDTO ssrcInfo,
+      SipDeviceDTO sipDeviceDTO,
+      String channelId,
+      String timeOutTaskKey) {
+    String cameraCode = sipDeviceDTO.getCameraCode();
+    String callId = responseJson.get(FastIotConstants.ZLMediaBody.CALL_ID).asText();
+    JsonNode msgHeader = responseJson.get(FastIotConstants.ZLMediaBody.MSG_HEADER);
+    SipMessageHeaderDTO sipMessage = JacksonUtil.convertValue(msgHeader, SipMessageHeaderDTO.class);
+    String sessionType = responseJson.get(FastIotConstants.ZLMediaBody.SESSION_TYPE).asText();
+    String streamId = ssrcInfo.getStream();
+    videoStreamSessionManager.put(
+        cameraCode,
+        channelId,
+        callId,
+        streamId,
+        ssrcInfo.getSsrc(),
+        sipMessage,
+        mediaServerDTO.getMediaServerId(),
+        SessionTypeEnum.valueOf(sessionType));
+    // 获取ssrc
+    String contentString = responseJson.get(FastIotConstants.ZLMediaBody.MSG_CONTEXT).asText();
+    int ssrcIndex = contentString.indexOf("y=");
+    // 检查是否有y字段
+    if (ssrcIndex >= 0) {
+      // ssrc规定长度为10字节，不取余下长度以避免后续还有“f=”字段 TODO 后续对不规范的非10位ssrc兼容
+      String ssrcInResponse = contentString.substring(ssrcIndex + 2, ssrcIndex + 12).trim();
+      // 查询到ssrc不一致且开启了ssrc校验则需要针对处理
+      if (ssrcInfo.getSsrc().equals(ssrcInResponse)) {
+        if (sipDeviceDTO.getStreamMode().equalsIgnoreCase("TCP-ACTIVE")) {
+          String substring = contentString.substring(0, contentString.indexOf("y="));
+          try {
+            SessionDescription sdp = SdpFactory.getInstance().createSessionDescription(substring);
+            int port = -1;
+            Vector mediaDescriptions = sdp.getMediaDescriptions(true);
+            for (Object description : mediaDescriptions) {
+              MediaDescription mediaDescription = (MediaDescription) description;
+              Media media = mediaDescription.getMedia();
+
+              Vector mediaFormats = media.getMediaFormats(false);
+              if (mediaFormats.contains("96")) {
+                port = media.getMediaPort();
+                break;
+              }
+            }
+            log.debug(
+                "[点播-TCP主动连接对方] deviceId: {}, channelId: {}, 连接对方的地址：{}:{}, 收流模式：{}, SSRC: {}, SSRC校验：{}",
+                sipDeviceDTO.getCameraCode(),
+                channelId,
+                sdp.getConnection().getAddress(),
+                port,
+                sipDeviceDTO.getStreamMode(),
+                ssrcInfo.getSsrc(),
+                sipDeviceDTO.isSsrcCheck());
+            JsonNode jsonNode =
+                zlMediaKitRestFulUtils.connectRtpServer(
+                    mediaServerDTO, sdp.getConnection().getAddress(), port, streamId);
+            log.debug("[点播-TCP主动连接对方] 结果： {}", jsonNode);
+          } catch (SdpException e) {
+            log.error(
+                "[点播-TCP主动连接对方] deviceId: {}, channelId: {}, 解析200OK的SDP信息失败",
+                sipDeviceDTO.getCameraCode(),
+                channelId,
+                e);
+          }
+        }
+        return;
+      }
+      log.debug("[点播消息] 收到invite 200, 发现下级自定义了ssrc: {}", ssrcInResponse);
+      if (!mediaServerDTO.isRtpEnable() || sipDeviceDTO.isSsrcCheck()) {
+        log.debug("[点播消息] SSRC修正 {}->{}", ssrcInfo.getSsrc(), ssrcInResponse);
+
+        // 释放不被使用的ssrc
+        tkMediaServerNodeService.releaseSsrc(mediaServerDTO.getMediaServerId(), ssrcInfo.getSsrc());
+        // 单端口模式streamId也有变化，需要重新设置监听
+        if (!mediaServerDTO.isRtpEnable()) {
+          // 添加订阅
+          HookSubscribeForStreamChange hookSubscribe =
+              new HookSubscribeForStreamChange(
+                  "rtp", streamId, true, "rtsp", mediaServerDTO.getMediaServerId());
+          subscribe.removeSubscribe(hookSubscribe);
+          hookSubscribe
+              .getContent()
+              .put("stream", String.format("%08x", Integer.parseInt(ssrcInResponse)).toUpperCase());
+          subscribe.addSubscribe(
+              hookSubscribe,
+              (MediaServerDTO mediaServerItemInUse, JsonNode response) -> {
+                log.debug(
+                    "处理订阅消息：主题【{}】流媒体信息【{}】收到的内容【{}】",
+                    hookSubscribe.getHookType().name(),
+                    mediaServerItemInUse,
+                    response);
+                zlMediaKitTaskUtils.stop(timeOutTaskKey);
+                // hook响应
+                onPublishHandlerForPlay(mediaServerItemInUse, response, cameraCode, channelId);
+                //            hookEvent.response(mediaServerItemInUse, response);
+              });
+        }
+
+        // 关闭rtp server
+        tkMediaServerNodeService.closeRTPServer(
+            mediaServerDTO,
+            streamId,
+            result -> {
+              if (result) {
+                // 重新开启ssrc server
+                tkMediaServerNodeService.openRTPServer(
+                    mediaServerDTO,
+                    streamId,
+                    ssrcInResponse,
+                    sipDeviceDTO.isSsrcCheck(),
+                    false,
+                    ssrcInfo.getPort(),
+                    true,
+                    sipDeviceDTO.getStreamModeForParam());
+              } else {
+                try {
+                  log.warn("[停止点播] {}/{}", cameraCode, channelId);
+                  byeCmdInSsrcTransaction(
+                      currentUser.getCurrentTenantId(),
+                      false,
+                          tbDeviceId,
+                      cameraCode,channelId,streamId,
+                          fromDeviceRpcResponse->{
+
+                          });
+                } catch (Exception e) {
+                  log.error("[命令发送失败] 停止点播， 发送BYE: {}", e.getMessage());
+                }
+                zlMediaKitTaskUtils.stop(timeOutTaskKey);
+                videoStreamSessionManager.remove(cameraCode, channelId, streamId);
+                //            event.msg = "下级自定义了ssrc,重新设置收流信息失败";
+                //            event.statusCode = 500;
+                //            errorEvent.response(event);
+              }
+            });
+      }
+    }
+  }
+
+  @Override
+  public boolean control(SecurityUser currentUser, String tbDeviceId, String channelId, PTZCommandEnum command, int horizonSpeed, int verticalSpeed, int zoomSpeed) throws ThingsboardException {
+
+    if (PTZCommandEnum.STOP.equals(command)) {
+      horizonSpeed = 0;
+      verticalSpeed = 0;
+      zoomSpeed = 0;
+    }
+    DeviceDTO deviceDTO = tkDeviceService.checkDeviceByTenantIdAndId(currentUser.getCurrentTenantId(), tbDeviceId, true);
+    if (null == deviceDTO) {
+      throw new TkDataValidationException(ErrorMessage.INVALID_PARAMETER.getMessage());
+    }
+    SipDeviceDTO sipDeviceDTO =
+            JacksonUtil.convertValue(
+                    deviceDTO.getDeviceInfo().get(FastIotConstants.DeviceAdditional.SIP),
+                    SipDeviceDTO.class);
+    if (null == sipDeviceDTO) {
+      throw new TkDataValidationException(ErrorMessage.INVALID_PARAMETER.getMessage());
+    }
+    PTZCmdDTO ptzCmdDTO = new PTZCmdDTO();
+    ptzCmdDTO.setCommand(command);
+    ptzCmdDTO.setHorizonSpeed(horizonSpeed);
+    ptzCmdDTO.setVerticalSpeed(verticalSpeed);
+    ptzCmdDTO.setZoomSpeed(zoomSpeed);
+    ObjectNode requestJson = JacksonUtil.newObjectNode();
+    requestJson.put(FastIotConstants.ZLMediaBody.CHANNEL_ID, channelId);
+    requestJson.set(FastIotConstants.ZLMediaBody.CONTROL_CONTEXT, JacksonUtil.valueToTree(ptzCmdDTO));
+    cameraCommonCmd(
+            currentUser.getCurrentTenantId(),
+            requestJson,
+            sipDeviceDTO.getCameraCode(),
+            VideoMethodEnum.MESSAGE,
+            false,
+            tbDeviceId,
+            fromDeviceRpcResponse->{
+
+            });
+    return false;
+  }
+}

+package org.thingsboard.server.service.yunteng.media;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import lombok.Getter;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.yunteng.config.media.ZLMediaKitServerConfig;
+import org.thingsboard.server.common.data.yunteng.constant.FastIotConstants;
+import org.thingsboard.server.common.data.yunteng.dto.sip.MediaServerDTO;
+import org.thingsboard.server.common.data.yunteng.utils.JacksonUtil;
+import org.thingsboard.server.common.data.yunteng.utils.ZLMediaKitRestFulUtils;
+import org.thingsboard.server.dao.util.yunteng.ZLMediaKitTaskUtils;
+import org.thingsboard.server.dao.yunteng.service.media.TkMediaServerNodeService;
+import org.thingsboard.server.dao.yunteng.service.media.TkMediaServerService;
+import org.thingsboard.server.common.data.yunteng.config.media.MediaConfig;
+import org.thingsboard.server.queue.util.TbCoreComponent;
+
+import javax.annotation.PostConstruct;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+@Component("ZLMediaKitState")
+@TbCoreComponent
+@Slf4j
+public class ZLMediaKitStateRunner {
+  private final ZLMediaKitRestFulUtils zlMediaKitRestFulUtils;
+  private final TkMediaServerNodeService tkMediaServerNodeService;
+  private final TkMediaServerService tkMediaServerService;
+  private final MediaConfig mediaConfig;
+  private final ZLMediaKitTaskUtils zlMediaKitTaskUtils;
+  private final Map<String, Boolean> startGetMedia;
+
+  @Value("${media.defaultStateCheckIntervalInSec}")
+  @Getter
+  private int defaultStateCheckIntervalInSec;
+
+  public ZLMediaKitStateRunner(
+      ZLMediaKitRestFulUtils zlMediaKitRestFulUtils,
+      TkMediaServerNodeService tkMediaServerNodeService,
+      TkMediaServerService tkMediaServerService,
+      MediaConfig mediaConfig,
+      ZLMediaKitTaskUtils zlMediaKitTaskUtils,
+      Map<String, Boolean> startGetMedia) {
+    this.zlMediaKitRestFulUtils = zlMediaKitRestFulUtils;
+    this.tkMediaServerNodeService = tkMediaServerNodeService;
+    this.tkMediaServerService = tkMediaServerService;
+    this.mediaConfig = mediaConfig;
+    this.zlMediaKitTaskUtils = zlMediaKitTaskUtils;
+    this.startGetMedia = startGetMedia;
+  }
+
+  @PostConstruct
+  public void init() {
+    updateDefaultMediaServer();
+    // 从数据库获取所有的流媒体信息
+    List<MediaServerDTO> dtoList = tkMediaServerService.getAllMediaKit();
+
+    Optional.ofNullable(dtoList).ifPresent( all ->{
+      all.forEach(dto ->{
+        String key = dto.getMediaServerId();
+        startGetMedia.put(key, true);
+        zlMediaKitTaskUtils.startCronTask(
+                key,
+                () -> {
+                  ZLMediaKitServerConfig zlMediaKitServerConfig = getMediaServerConfig(dto);
+                  if (null != zlMediaKitServerConfig) {
+                    startGetMedia.remove(dto.getMediaServerId());
+                    zlMediaKitTaskUtils.stop(key);
+                    zlMediaKitServerConfig.setIp(dto.getIp());
+                    zlMediaKitServerConfig.setHttpPort(dto.getHttpPort());
+                    zlMediaKitServerConfig.setTenantId(dto.getTenantId());
+                    // 进行上线操作
+                    tkMediaServerNodeService.zlmServerOnline(zlMediaKitServerConfig);
+                  }
+                },
+                defaultStateCheckIntervalInSec);
+      });
+    });
+  }
+
+  private void updateDefaultMediaServer() {
+    // 默认流媒体服务器
+    MediaServerDTO oldMediaServer = tkMediaServerService.findDefaultMediaServer();
+    MediaServerDTO defaultConfig = mediaConfig.getMediaSerItem();
+    if (oldMediaServer == null) {
+      defaultConfig.setTenantId(EntityId.NULL_UUID.toString());
+    }else{
+      defaultConfig.setId(oldMediaServer.getId());
+      defaultConfig.setTenantId(oldMediaServer.getTenantId());
+    }
+    tkMediaServerService.saveOrUpdateMediaServer(defaultConfig);
+  }
+
+  /**
+   * 调用流媒体API接口获取流媒体配置
+   * @param mediaServerItem
+   * @return
+   */
+  private ZLMediaKitServerConfig getMediaServerConfig(MediaServerDTO mediaServerItem) {
+    log.error("启动流媒体【ZLMedia】验证，流媒体编号【{}】",mediaServerItem.getMediaServerId());
+    if (startGetMedia == null) {
+      return null;
+    }
+    if (!mediaServerItem.isDefaultServer()
+        && tkMediaServerNodeService.getOne(mediaServerItem.getMediaServerId()).isEmpty()) {
+      return null;
+    }
+    if (startGetMedia.get(mediaServerItem.getMediaServerId()) == null
+        || !startGetMedia.get(mediaServerItem.getMediaServerId())) {
+      return null;
+    }
+    JsonNode responseJson = zlMediaKitRestFulUtils.getMediaServerConfig(mediaServerItem);
+    if(responseJson == null){
+      log.error("流媒体【{}】服务地址【{}:{}】无法访问",mediaServerItem.getMediaServerId(),mediaServerItem.getIp(),mediaServerItem.getHttpPort());
+      return null;
+    }
+    JsonNode data = responseJson.get(FastIotConstants.ZLMediaBody.DATA);
+    if (data != null && !data.isEmpty()) {
+      log.error("流媒体【{}:{}】调用成功，响应内容【{}】",mediaServerItem.getIp(),mediaServerItem.getHttpPort(),data);
+      return JacksonUtil.convertValue(data.get(0), ZLMediaKitServerConfig.class);
+    }
+    log.error("流媒体【{}:{}】调用失败，失败原因【{}】",mediaServerItem.getIp(),mediaServerItem.getHttpPort(),responseJson.get(FastIotConstants.ZLMediaBody.MSG));
+    return null;
+  }
+}

@@ -451,6 +451,12 @@ caffeine:
     sceneReact:
       timeToLiveInMinutes: "${CACHE_SPECS_SCENE_TTL:1440}"
       maxSize: "${CACHE_SPECS_SCENE_MAX_SIZE:10000}"
+    tkSipCacheName:
+      timeToLiveInMinutes: "${CACHE_SPECS_TK_SIP_TTL:1440}"
+      maxSize: "${CACHE_SPECS_TK_SIP_MAX_SIZE:10000}"
+    tkMediaServerCacheName:
+      timeToLiveInMinutes: "${CACHE_SPECS_TK_MEDIA_SERVER_TTL:1440}"
+      maxSize: "${CACHE_SPECS_TK_MEDIA_SERVER_MAX_SIZE:10000}"
 redis:
   # standalone or cluster
   connection:
@@ -476,7 +482,7 @@ redis:
   # db index
   db: "${REDIS_DB:0}"
   # db password
-  password: "${REDIS_PASSWORD:}"
+  password: "${REDIS_PASSWORD:redis@6379}"
   # pool config
   pool_config:
     maxTotal: "${REDIS_POOL_CONFIG_MAX_TOTAL:128}"
@@ -712,6 +718,9 @@ transport:
       # Skip certificate validity check for client certificates.
       skip_validity_check_for_client_cert: "${MQTT_SSL_SKIP_VALIDITY_CHECK_FOR_CLIENT_CERT:false}"
   # Local CoAP transport parameters
+  gbt28181:
+    # Enable/disable gbt28181 transport protocol.
+    enabled: "${GBT28181_ENABLED:true}"
   tcp:
     # Enable/disable tcp transport protocol.
     enabled: "${TCP_ENABLED:true}"
@@ -1194,10 +1203,10 @@ file:
     type: ${FILE_STORAGE_TYPE:minio}                         #minio, or other to be implemented
     randomFileName: ${FILE_STORAGE_FILENAME:true}            #是否重命名文件名字，防止冲突
     minio:
-      minioUrl: ${MINIO_URL:http://127.0.0.1:9000}  #minio储存地址
-      minioName: ${MINIO_NAME:xxxxxx}                    #minio账户
-      minioPass: ${MINIO_PWD:xxxxx}              #minio访问密码
-      bucketName: ${MINIO_BUCKET_NAME:yunteng-test}                    #minio储存桶名称
+      minioUrl: ${MINIO_URL:https://demo.thingskit.com:9000} #minio储存地址
+      minioName: ${MINIO_NAME:thingskit} #minio账户
+      minioPass: ${MINIO_PWD:Dzr227+bjsz} #minio访问密码
+      bucketName: yunteng-test                   #minio储存桶名称
       randomFileName: ${file.storage.randomFileName}
 account:
   info:
@@ -1218,3 +1227,45 @@ logging:
 frp:
   server:
     address: ${FRP_SERVER_ADDRESS:http://127.0.0.1}
+sip:
+  # [必须修改] 本机的IP，对应你的网卡，监听什么ip就是使用什么网卡，
+  # 如果要监听多张网卡，可以使用逗号分隔多个IP， 例如： 192.168.1.4,10.0.0.4
+  # 如果不明白，就使用0.0.0.0，大部分情况都是可以的
+  # 请不要使用127.0.0.1，任何包括localhost在内的域名都是不可以的。
+  ip: ${GBT28181_SIP_IP:192.168.1.15}
+  # [可选] 28181服务监听的端口
+  port: ${GBT28181_SIP_PORT:5060}
+  #[可选]
+  id: ${GBT28181_SIP_ID:44010200492000000001}
+  # 根据国标6.1.2中规定，domain宜采用ID统一编码的前十位编码。国标附录D中定义前8位为中心编码（由省级、市级、区级、基层编号组成，参照GB/T 2260-2007）
+  # 后两位为行业编码，定义参照附录D.3
+  # 3701020049标识山东济南历下区 信息行业接入
+  # [可选]
+  domain: ${GBT28181_SIP_DOMAIN:4401020049}
+  #[可选]
+  password: ${GBT28181_SIP_PASSWORD:61332286}
+#zlm 默认服务器配置
+media:
+  id: ${GBT28181_MEDIA_GENERAL_ID:f6GfbO0BGEaROKLP}
+  # [必须修改] zlm服务器的内网IP
+  ip: ${GBT28181_MEDIA_IP:192.168.1.16}
+  # [必须修改] zlm服务器的http.port
+  http-port: ${GBT28181_MEDIA_HTTP_PORT:28080}
+  # [可选] zlm服务器的hook.admin_params=secret
+  secret: ${GBT28181_MEDIA_API_SECRET:5PnbPDCcxQGeK15OowHPPdSgort2Cx9Y}
+  # 启用多端口模式, 多端口模式使用端口区分每路流，兼容性更好。 单端口使用流的ssrc区分， 点播超时建议使用多端口测试
+  rtp:
+    # [可选] 是否启用多端口模式, 开启后会在portRange范围内选择端口用于媒体流传输
+    enable: true
+    # [可选] 在此范围内选择端口用于媒体流传输, 必须提前在zlm上配置该属性，不然自动配置此属性可能不成功
+    port-range: ${GBT28181_MEDIA_RTP_PORT_RANGE:30000,30500} # 端口范围
+    # [可选] 国标级联在此范围内选择端口发送媒体流,
+    send-port-range: ${GBT28181_MEDIA_RTP_PORT_RANGE:30000,30500} # 端口范围
+  # 录像辅助服务， 部署此服务可以实现zlm录像的管理与下载， 0 表示不使用
+  record-assist-port: 0
+  defaultStateCheckIntervalInSec: "${DEFAULT_STATE_CHECK_INTERVAL:10}"
+
+thingskit:
+  release:
+    version: v1.1.1 Release
+    date: 20230630

@@ -8,7 +8,7 @@
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
+ * distributed under the License is distributed on an "AS IS" BASIS,in
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
@@ -130,10 +130,7 @@ message SessionEventMsg {
   SessionEvent event = 2;
 }
 
-//thingskit
-message PostEventMsg {
-  repeated KeyValueProto kv = 1;
-}
+
 message PostTelemetryMsg {
   repeated TsKvListProto tsKvList = 1;
 }
@@ -682,6 +679,7 @@ message TransportApiRequestMsg {
 
   //Thingskit function
   ScriptProto script = 14;
+  Gbt28181RequestMsg gbt28181RequestMsg = 15;
 }
 
 /* Response from ThingsBoard Core Service to Transport Service */
@@ -699,6 +697,7 @@ message TransportApiResponseMsg {
 
   //Thingskit function
   repeated ScriptProto scriptsResponseMsg = 11;
+  Gbt28181ResponseMsg gbt28181ResponseMsg = 12;
 }
 
 /* Messages that are handled by ThingsBoard Core Service */
@@ -795,3 +794,37 @@ message ScriptProto{
   string convertJs = 6;
   int32 status = 7;
 }
+//thingskit function 设备上报的物模型事件
+message PostEventMsg {
+  repeated KeyValueProto kv = 1;
+}
+message Gbt28181RequestMsg{
+  bytes context = 1;
+  string contextType = 2;
+  string callId = 3;
+  string fromTag = 4;
+  string toTag = 5;
+  string viaTag = 6;
+  string viaBranch = 7;
+  int32 sn = 8;
+  int64 tenantIdMSB = 9;
+  int64 tenantIdLSB = 10;
+  int64 entityIdMSB = 11;
+  int64 entityIdLSB = 12;
+}
+message Gbt28181ResponseMsg{
+  bytes context = 1;
+  string contextType = 2;
+  string callId = 3;
+  string fromTag = 4;
+  string toTag = 5;
+  string viaTag = 6;
+  string viaBranch = 7;
+  int32 sn = 8;
+  int64 tenantIdMSB = 9;
+  int64 tenantIdLSB = 10;
+  int64 entityIdMSB = 11;
+  int64 entityIdLSB = 12;
+}
+
+

@@ -48,6 +48,8 @@ public class DataConstants {
     public static final String HTTP_TRANSPORT_NAME = "HTTP";
     public static final String SNMP_TRANSPORT_NAME = "SNMP";
 
+    public static final String GBT_28181 = "GBT28181";
+
 
     public static final String[] allScopes() {
         return new String[]{CLIENT_SCOPE, SHARED_SCOPE, SERVER_SCOPE};

@@ -21,5 +21,6 @@ public enum DeviceTransportType {
     TCP,
     COAP,
     LWM2M,
-    SNMP
+    SNMP,
+    GBT28181
 }

@@ -34,6 +34,7 @@ import java.io.Serializable;
         @JsonSubTypes.Type(value = DefaultDeviceTransportConfiguration.class, name = "DEFAULT"),
         @JsonSubTypes.Type(value = MqttDeviceTransportConfiguration.class, name = "MQTT"),
         @JsonSubTypes.Type(value = TkTcpDeviceTransportConfiguration.class, name = "TCP"),
+        @JsonSubTypes.Type(value = TkGBTDeviceTransportConfiguration.class, name = "GBT28181"),
         @JsonSubTypes.Type(value = CoapDeviceTransportConfiguration.class, name = "COAP"),
         @JsonSubTypes.Type(value = Lwm2mDeviceTransportConfiguration.class, name = "LWM2M"),
         @JsonSubTypes.Type(value = SnmpDeviceTransportConfiguration.class, name = "SNMP")})

+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.common.data.device.data;
+import lombok.Data;
+import org.thingsboard.server.common.data.DeviceTransportType;
+
+@Data
+public class TkGBTDeviceTransportConfiguration implements DeviceTransportConfiguration {
+    @Override
+    public DeviceTransportType getType() {
+        return DeviceTransportType.GBT28181;
+    }
+
+}

@@ -32,6 +32,7 @@ import java.io.Serializable;
         @JsonSubTypes.Type(value = DefaultDeviceProfileTransportConfiguration.class, name = "DEFAULT"),
         @JsonSubTypes.Type(value = MqttDeviceProfileTransportConfiguration.class, name = "MQTT"),
         @JsonSubTypes.Type(value = TkTcpDeviceProfileTransportConfiguration.class, name = "TCP"),
+        @JsonSubTypes.Type(value = TkGBT28181DeviceProfileTransportConfiguration.class, name = "GBT28181"),
         @JsonSubTypes.Type(value = Lwm2mDeviceProfileTransportConfiguration.class, name = "LWM2M"),
         @JsonSubTypes.Type(value = CoapDeviceProfileTransportConfiguration.class, name = "COAP"),
         @JsonSubTypes.Type(value = SnmpDeviceProfileTransportConfiguration.class, name = "SNMP")

+package org.thingsboard.server.common.data.device.profile;
+
+import lombok.Data;
+import org.thingsboard.server.common.data.DeviceTransportType;
+
+@Data
+public class TkGBT28181DeviceProfileTransportConfiguration implements DeviceProfileTransportConfiguration {
+    @Override
+    public DeviceTransportType getType() {
+        return DeviceTransportType.GBT28181;
+    }
+
+
+}

 package org.thingsboard.server.common.data.yunteng.common;
 
 import org.thingsboard.server.common.data.yunteng.dto.SysDictItemDTO;
+import org.thingsboard.server.common.data.yunteng.dto.sip.MediaServerDTO;
 
 public interface TkCommonService {
   /**
@@ -11,6 +12,4 @@ public interface TkCommonService {
    * @return 返回字典Item表
    */
   SysDictItemDTO getDictValueByCodeAndText(String dictCode, String codeValue);
-
-
 }

+package org.thingsboard.server.common.data.yunteng.common.media;
+
+public interface CommonCallback<T>{
+    void run(T t);
+}

+package org.thingsboard.server.common.data.yunteng.common.media;
+
+import java.util.*;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
+import org.springframework.stereotype.Component;
+import org.thingsboard.server.common.data.yunteng.config.media.UserSetting;
+import org.thingsboard.server.common.data.yunteng.constant.FastIotConstants;
+import org.thingsboard.server.common.data.yunteng.core.cache.CacheUtils;
+import org.thingsboard.server.common.data.yunteng.dto.sip.SipMessageHeaderDTO;
+import org.thingsboard.server.common.data.yunteng.dto.sip.SsrcTransactionDTO;
+import org.thingsboard.server.common.data.yunteng.enums.SessionTypeEnum;
+
+/** 视频流session管理器，管理视频预览、预览回放的通信句柄 */
+@Component
+@Slf4j
+@ConditionalOnExpression(
+    "'${service.type:null}'=='tb-transport' || ('${service.type:null}'=='monolith' && '${transport.api_enabled:true}'=='true' && '${transport.gbt28181.enabled}'=='true')")
+public class VideoStreamSessionManager {
+
+  @Autowired private UserSetting userSetting;
+  @Autowired private CacheUtils cacheUtils;
+  private final String cacheName = FastIotConstants.MediaServerKey.MEDIA_SERVER_CACHE_NAME;
+
+  /**
+   * 添加一个点播/回放的事务信息 后续可以通过流Id/callID
+   *
+   * @param cameraCode 设备ID
+   * @param channelId 通道ID
+   * @param callId 一次请求的CallID
+   * @param stream 流名称
+   * @param mediaServerId 所使用的流媒体ID
+   */
+  public void put(
+      String cameraCode,
+      String channelId,
+      String callId,
+      String stream,
+      String ssrc,
+      SipMessageHeaderDTO sipMessage,
+      String mediaServerId,
+      SessionTypeEnum type) {
+
+    SsrcTransactionDTO ssrcTransaction = new SsrcTransactionDTO();
+    ssrcTransaction.setCameraCode(cameraCode);
+    ssrcTransaction.setChannelId(channelId);
+    ssrcTransaction.setStream(stream);
+    ssrcTransaction.setSipTransactionInfo(sipMessage);
+    ssrcTransaction.setCallId(callId);
+    ssrcTransaction.setSsrc(ssrc);
+    ssrcTransaction.setMediaServerId(mediaServerId);
+    ssrcTransaction.setType(type);
+    String fullKey = buildTransactionFullKey(cameraCode, channelId, callId, stream);
+    String channelKey = buildTransactionChannelKey(cameraCode, channelId, stream);
+    String streamKey = buildTransactionStreamKey(stream);
+    String cameraKey = buildTransactionCameraKey(cameraCode);
+
+    freshTransactionKey(cameraKey, fullKey, false);
+    freshTransactionKey(streamKey, fullKey, false);
+    freshTransactionKey(channelKey, fullKey, false);
+    cacheUtils.put(cacheName, fullKey, ssrcTransaction);
+  }
+
+  private void freshTransactionKey(String key, String val, boolean remove) {
+    Optional<Set<String>> cameraDatas = cacheUtils.get(cacheName, key);
+    Set<String> values = new HashSet<>();
+    cameraDatas.ifPresent(values::addAll);
+    if (remove) {
+      values.remove(val);
+    } else {
+      values.add(val);
+    }
+    cacheUtils.put(cacheName, key, values);
+  }
+
+  public Optional<Set<String>> getSsrcTransactionCamaraKey(String cameraCode) {
+    return cacheUtils.get(cacheName, buildTransactionCameraKey(cameraCode));
+  }
+
+  public Optional<Set<String>> getSsrcTransactionStreamKey(String stream) {
+    return cacheUtils.get(cacheName, buildTransactionStreamKey(stream));
+  }
+
+  public Optional<Set<String>> getSsrcTransactionChannelKey(
+      String cameraCode, String channelId, String stream) {
+    return cacheUtils.get(cacheName, buildTransactionChannelKey(cameraCode, channelId, stream));
+  }
+
+  public Optional<SsrcTransactionDTO> getSsrcTransaction(String fullKey) {
+    return cacheUtils.get(cacheName, fullKey);
+  }
+  public Optional<SsrcTransactionDTO> getSsrcTransaction(String cameraCode, String channelId, String stream) {
+    Optional<Set<String>> keys =getSsrcTransactionChannelKey(cameraCode, channelId,stream);
+
+    if(keys.isPresent()){
+      Optional<String> fullKey =keys.get().stream().findFirst();
+      if(fullKey.isPresent()){
+        return getSsrcTransaction(fullKey.get());
+      }
+    }
+    return Optional.empty();
+  }
+
+  public String getMediaServerId(String deviceId, String channelId, String stream) {
+    Optional<Set<String>> channels = getSsrcTransactionChannelKey(deviceId, channelId, stream);
+    if (channels.isPresent()) {
+      for (String fullKey : channels.get()) {
+        Optional<SsrcTransactionDTO> result = getSsrcTransaction(fullKey);
+        if (result.isPresent()) {
+          return result.get().getMediaServerId();
+        }
+      }
+    }
+    return null;
+  }
+
+  public String getSSRC(String deviceId, String channelId, String stream) {
+    Optional<Set<String>> channels = getSsrcTransactionChannelKey(deviceId, channelId, stream);
+
+    if (channels.isPresent()) {
+      for (String fullKey : channels.get()) {
+        Optional<SsrcTransactionDTO> result = getSsrcTransaction(fullKey);
+        if (result.isPresent()) {
+          return result.get().getSsrc();
+        }
+      }
+    }
+    return null;
+  }
+
+  public void remove(String cameraCode, String channelId, String stream) {
+    Optional<Set<String>> channelKeys = getSsrcTransactionChannelKey(cameraCode, channelId, stream);
+    channelKeys.ifPresent(
+        keys -> {
+          keys.forEach(
+              fullKey -> {
+                String streamKey = buildTransactionStreamKey(stream);
+                String cameraKey = buildTransactionCameraKey(cameraCode);
+                String channelKey = buildTransactionChannelKey(cameraCode, channelId, stream);
+                freshTransactionKey(cameraKey, fullKey, true);
+                freshTransactionKey(streamKey, fullKey, true);
+                freshTransactionKey(channelKey, fullKey, true);
+                cacheUtils.invalidate(cacheName, fullKey);
+              });
+        });
+  }
+
+  public String buildTransactionFullKey(
+      String cameraCode, String channelId, String callId, String stream) {
+    return FastIotConstants.MediaServerKey.MEDIA_TRANSACTION_USED_PREFIX
+        + userSetting.getServerId()
+        + "_"
+        + cameraCode
+        + "_"
+        + channelId
+        + "_"
+        + callId
+        + "_"
+        + stream;
+  }
+
+  public String buildTransactionChannelKey(String cameraCode, String channelId, String stream) {
+    return FastIotConstants.MediaServerKey.MEDIA_TRANSACTION_USED_PREFIX
+        + userSetting.getServerId()
+        + "_"
+        + cameraCode
+        + "_"
+        + channelId
+        + "_"
+        + stream;
+  }
+
+  public String buildTransactionStreamKey(String stream) {
+    return FastIotConstants.MediaServerKey.MEDIA_TRANSACTION_USED_PREFIX
+        + userSetting.getServerId()
+        + "_"
+        + stream;
+  }
+
+  public String buildTransactionCameraKey(String cameraCode) {
+    return FastIotConstants.MediaServerKey.MEDIA_TRANSACTION_USED_PREFIX
+        + userSetting.getServerId()
+        + "_"
+        + cameraCode;
+  }
+
+  public String getReceiveRtpKey(String ssrcStream) {
+    return FastIotConstants.CacheSipKey.TK_OTHER_RECEIVE_RTP_INFO
+        + userSetting.getServerId()
+        + "_"
+        + ssrcStream;
+  }
+
+  public String getReceivePsKey(String ssrcStream) {
+    return FastIotConstants.CacheSipKey.TK_OTHER_RECEIVE_PS_INFO
+        + userSetting.getServerId()
+        + "_"
+        + ssrcStream;
+  }
+}

+package org.thingsboard.server.common.data.yunteng.common.media;
+
+import java.time.Instant;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.TimeUnit;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+import org.springframework.util.CollectionUtils;
+import org.thingsboard.server.common.data.yunteng.dto.sip.MediaServerDTO;
+import org.thingsboard.server.common.data.yunteng.dto.sip.hook.IHookSubscribe;
+import org.thingsboard.server.common.data.yunteng.enums.HookTypeEnum;
+
+/**
+ * ZLMediaServer的hook事件订阅
+ *
+ * @author lin
+ */
+@Component
+public class ZlmHttpHookSubscribe {
+
+  @FunctionalInterface
+  public interface Event {
+    void response(MediaServerDTO mediaServerInfo, JsonNode response);
+  }
+
+  private Map<HookTypeEnum, Map<IHookSubscribe, Event>> allSubscribes = new ConcurrentHashMap<>();
+
+  public void addSubscribe(IHookSubscribe hookSubscribe, Event event) {
+    if (hookSubscribe.getExpires() == null) {
+      // 默认5分钟过期
+      Instant expiresInstant = Instant.now().plusSeconds(TimeUnit.MINUTES.toSeconds(5));
+      hookSubscribe.setExpires(LocalDateTime.ofInstant(expiresInstant, ZoneId.systemDefault()));
+    }
+    allSubscribes
+        .computeIfAbsent(hookSubscribe.getHookType(), k -> new ConcurrentHashMap<>())
+        .put(hookSubscribe, event);
+  }
+
+  public Event sendNotify(HookTypeEnum type, JsonNode hookResponse) {
+    Event event = null;
+    Map<IHookSubscribe, Event> eventMap = allSubscribes.get(type);
+    if (eventMap == null) {
+      return null;
+    }
+    for (IHookSubscribe key : eventMap.keySet()) {
+      Boolean result = null;
+      // 使用 fields() 方法获取键值对迭代器
+      Iterator<Map.Entry<String, JsonNode>> fieldsIterator = key.getContent().fields();
+      while (fieldsIterator.hasNext()) {
+        Map.Entry<String, JsonNode> field = fieldsIterator.next();
+        String s = field.getKey();
+        JsonNode value = field.getValue();
+        if (result == null) {
+          result = value.equals(hookResponse.get(s));
+        } else {
+          if (value == null) {
+            continue;
+          }
+          result = result && value.equals(hookResponse.get(s));
+        }
+      }
+      if (null != result && result) {
+        event = eventMap.get(key);
+      }
+    }
+    return event;
+  }
+
+  public void removeSubscribe(IHookSubscribe hookSubscribe) {
+    Map<IHookSubscribe, Event> eventMap = allSubscribes.get(hookSubscribe.getHookType());
+    if (eventMap == null) {
+      return;
+    }
+
+    Set<Map.Entry<IHookSubscribe, Event>> entries = eventMap.entrySet();
+    if (entries.size() > 0) {
+      List<Map.Entry<IHookSubscribe, Event>> entriesToRemove = new ArrayList<>();
+      for (Map.Entry<IHookSubscribe, Event> entry : entries) {
+        ObjectNode content = entry.getKey().getContent();
+        if (content == null || content.size() == 0) {
+          entriesToRemove.add(entry);
+          continue;
+        }
+        Boolean result = null;
+        Iterator<Map.Entry<String, JsonNode>> fieldsIterator = content.fields();
+        while (fieldsIterator.hasNext()) {
+          Map.Entry<String, JsonNode> field = fieldsIterator.next();
+          String s = field.getKey();
+          JsonNode value = field.getValue();
+          if (result == null) {
+            result = value.equals(hookSubscribe.getContent().get(s));
+          } else {
+            if (value == null) {
+              continue;
+            }
+            result = result && value.equals(hookSubscribe.getContent().get(s));
+          }
+        }
+        if (result) {
+          entriesToRemove.add(entry);
+        }
+      }
+
+      if (!CollectionUtils.isEmpty(entriesToRemove)) {
+        for (Map.Entry<IHookSubscribe, Event> entry : entriesToRemove) {
+          entries.remove(entry);
+        }
+      }
+    }
+  }
+
+  /**
+   * 获取某个类型的所有的订阅
+   *
+   * @param type
+   * @return
+   */
+  public List<Event> getSubscribes(HookTypeEnum type) {
+    Map<IHookSubscribe, Event> eventMap = allSubscribes.get(type);
+    if (eventMap == null) {
+      return null;
+    }
+    List<Event> result = new ArrayList<>();
+    for (IHookSubscribe key : eventMap.keySet()) {
+      result.add(eventMap.get(key));
+    }
+    return result;
+  }
+
+  public List<IHookSubscribe> getAll() {
+    ArrayList<IHookSubscribe> result = new ArrayList<>();
+    Collection<Map<IHookSubscribe, Event>> values = allSubscribes.values();
+    for (Map<IHookSubscribe, Event> value : values) {
+      result.addAll(value.keySet());
+    }
+    return result;
+  }
+
+  /** 对订阅数据进行过期清理 */
+  @Scheduled(cron = "0 0/5 * * * ?") // 每5分钟执行一次
+  public void execute() {
+
+    Instant instant = Instant.now().minusMillis(TimeUnit.MINUTES.toMillis(5));
+    LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
+    int total = 0;
+    for (HookTypeEnum hookType : allSubscribes.keySet()) {
+      Map<IHookSubscribe, Event> hookSubscribeEventMap = allSubscribes.get(hookType);
+      if (hookSubscribeEventMap.size() > 0) {
+        for (IHookSubscribe hookSubscribe : hookSubscribeEventMap.keySet()) {
+          if (hookSubscribe.getExpires().isBefore(localDateTime)) {
+            // 过期的
+            hookSubscribeEventMap.remove(hookSubscribe);
+            total++;
+          }
+        }
+      }
+    }
+  }
+}

+package org.thingsboard.server.common.data.yunteng.config.media;
+
+import lombok.Data;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+import org.springframework.util.ObjectUtils;
+import org.thingsboard.server.common.data.yunteng.dto.sip.MediaServerDTO;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.Objects;
+import java.util.regex.Pattern;
+
+/**
+ * 配置文件里面的流媒体配置信息
+ */
+@ConfigurationProperties(prefix = "media")
+@Component
+@Data
+@Slf4j
+public class MediaConfig {
+  @Value("${media.id}")
+  private String mediaServerId;
+
+  @Value("${media.ip}")
+  private String ip;
+
+  @Value("${media.hook-ip:}")
+  private String hookIp;
+
+  @Value("${sip.ip}")
+  private String sipIp;
+
+  @Value("${sip.domain}")
+  private String sipDomain;
+
+  @Value("${media.sdp-ip:${media.ip}}")
+  private String sdpIp;
+
+  @Value("${media.stream-ip:${media.ip}}")
+  private String streamIp;
+
+  @Value("${media.http-port}")
+  private Integer httpPort;
+
+  @Value("${media.http-ssl-port:0}")
+  private Integer httpSslPort = 0;
+
+  @Value("${media.rtmp-port:0}")
+  private Integer rtmpPort = 0;
+
+  @Value("${media.rtmp-ssl-port:0}")
+  private Integer rtmpSslPort = 0;
+
+  @Value("${media.rtp-proxy-port:0}")
+  private Integer rtpProxyPort = 0;
+
+  @Value("${media.rtsp-port:0}")
+  private Integer rtspPort = 0;
+
+  @Value("${media.rtsp-ssl-port:0}")
+  private Integer rtspSslPort = 0;
+
+  @Value("${media.auto-config:true}")
+  private boolean autoConfig = true;
+
+  @Value("${media.secret}")
+  private String secret;
+
+  @Value("${media.rtp.enable}")
+  private boolean rtpEnable;
+
+  @Value("${media.rtp.port-range}")
+  private String rtpPortRange;
+
+  @Value("${media.rtp.send-port-range}")
+  private String rtpSendPortRange;
+
+  @Value("${media.record-assist-port:0}")
+  private Integer recordAssistPort = 0;
+  private boolean status;
+
+  public MediaServerDTO getMediaSerItem() {
+    MediaServerDTO mediaServerItem = new MediaServerDTO();
+    mediaServerItem.setMediaServerId(mediaServerId);
+    mediaServerItem.setIp(ip);
+    mediaServerItem.setDefaultServer(true);
+    mediaServerItem.setHookIp(getHookIp());
+    mediaServerItem.setSdpIp(getSdpIp());
+    mediaServerItem.setStreamIp(getStreamIp());
+    mediaServerItem.setHttpPort(httpPort);
+    mediaServerItem.setHttpSslPort(httpSslPort);
+    mediaServerItem.setRtmpPort(rtmpPort);
+    mediaServerItem.setRtmpSslPort(rtmpSslPort);
+    mediaServerItem.setRtpProxyPort(getRtpProxyPort());
+    mediaServerItem.setRtspPort(rtspPort);
+    mediaServerItem.setRtspSslPort(rtspSslPort);
+    mediaServerItem.setAutoConfig(autoConfig);
+    mediaServerItem.setSecret(secret);
+    mediaServerItem.setRtpEnable(rtpEnable);
+    mediaServerItem.setRtpPortRange(rtpPortRange);
+    mediaServerItem.setSendRtpPortRange(rtpSendPortRange);
+    mediaServerItem.setRecordAssistPort(recordAssistPort);
+    mediaServerItem.setHookAliveInterval(30.00f);
+    mediaServerItem.setStatus(status);
+    return mediaServerItem;
+  }
+
+  public String getHookIp() {
+    if (ObjectUtils.isEmpty(hookIp)) {
+      return sipIp.split(",")[0];
+    } else {
+      return hookIp;
+    }
+  }
+
+  public String getSipIp() {
+    if (sipIp == null) {
+      return this.ip;
+    } else {
+      return sipIp;
+    }
+  }
+
+  public int getRtpProxyPort() {
+    return Objects.requireNonNullElse(rtpProxyPort, 0);
+  }
+
+  public String getSdpIp() {
+    if (ObjectUtils.isEmpty(sdpIp)) {
+      return ip;
+    } else {
+      if (isValidIPAddress(sdpIp)) {
+        return sdpIp;
+      } else {
+        // 按照域名解析
+        String hostAddress = null;
+        try {
+          hostAddress = InetAddress.getByName(sdpIp).getHostAddress();
+        } catch (UnknownHostException e) {
+          log.error("[获取SDP IP]: 域名解析失败");
+        }
+        return hostAddress;
+      }
+    }
+  }
+
+  public String getStreamIp() {
+    if (ObjectUtils.isEmpty(streamIp)) {
+      return ip;
+    } else {
+      return streamIp;
+    }
+  }
+
+  private boolean isValidIPAddress(String ipAddress) {
+    if ((ipAddress != null) && (!ipAddress.isEmpty())) {
+      return Pattern.matches(
+          "^([1-9]|[1-9]\\d|1\\d{2}|2[0-4]\\d|25[0-5])(\\.(\\d|[1-9]\\d|1\\d{2}|2[0-4]\\d|25[0-5])){3}$",
+          ipAddress);
+    }
+    return false;
+  }
+}

+package org.thingsboard.server.common.data.yunteng.config.media;
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+
+@ConfigurationProperties(prefix = "sip")
+@Component
+@Data
+public class SipConfig {
+    private String ip;
+    private String showIp;
+    private Integer port;
+    private String id;
+    private String domain;
+    private String password;
+    Integer ptzSpeed = 50;
+    Integer registerTimeInterval = 120;
+    private boolean alarm;
+
+    public String getShowIp() {
+        if (this.showIp == null) {
+            return this.ip;
+        }
+        return showIp;
+    }
+}

+package org.thingsboard.server.common.data.yunteng.config.media;
+
+import lombok.Data;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+@Component
+@Data
+public class ThingsKitVersionConfig {
+  @Value("${thingskit.release.version}")
+  private String releaseVersion;
+
+  @Value("${thingskit.release.date}")
+  private String releaseDate;
+}

+package org.thingsboard.server.common.data.yunteng.config.media;
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+
+@ConfigurationProperties(prefix = "user-settings")
+@Component
+@Data
+public class UserSetting {
+    private String serverId = "000000";
+    private Boolean seniorSdp = Boolean.FALSE;
+    private Boolean pushAuthority = Boolean.TRUE;
+    private Boolean recordSip = Boolean.TRUE;
+    private Boolean recordPushLive = Boolean.TRUE;
+    private String recordPath = null;
+    private Boolean streamOnDemand = Boolean.TRUE;
+    private Boolean sipUseSourceIpAsRemoteAddress = Boolean.FALSE;
+    private Integer playTimeout = 18000;
+}

+package org.thingsboard.server.common.data.yunteng.config.media;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+
+/** ZLMediaKit流媒体配置文件，具体配置说明可以参考ZLMediaKit的config.ini文件 */
+@Data
+public class ZLMediaKitServerConfig {
+  @JsonProperty(value = "api.apiDebug")
+  private String apiDebug;
+
+  @JsonProperty(value = "api.secret")
+  private String apiSecret;
+
+  @JsonProperty(value = "api.snapRoot")
+  private String apiSnapRoot;
+
+  @JsonProperty(value = "api.defaultSnap")
+  private String apiDefaultSnap;
+
+  @JsonProperty(value = "ffmpeg.bin")
+  private String ffmpegBin;
+
+  @JsonProperty(value = "ffmpeg.cmd")
+  private String ffmpegCmd;
+
+  @JsonProperty(value = "ffmpeg.snap")
+  private String ffmpegSnap;
+
+  @JsonProperty(value = "ffmpeg.log")
+  private String ffmpegLog;
+
+  @JsonProperty(value = "ffmpeg.restart_sec")
+  private String ffmpegRestartSec;
+
+  @JsonProperty(value = "protocol.modify_stamp")
+  private String protocolModifyStamp;
+
+  @JsonProperty(value = "protocol.enable_audio")
+  private String protocolEnableAudio;
+
+  @JsonProperty(value = "protocol.add_mute_audio")
+  private String protocolAddMuteAudio;
+
+  @JsonProperty(value = "protocol.continue_push_ms")
+  private String protocolContinuePushMs;
+
+  @JsonProperty(value = "protocol.enable_hls")
+  private String protocolEnableHls;
+
+  @JsonProperty(value = "protocol.enable_mp4")
+  private String protocolEnableMp4;
+
+  @JsonProperty(value = "protocol.enable_rtsp")
+  private String protocolEnableRtsp;
+
+  @JsonProperty(value = "protocol.enable_rtmp")
+  private String protocolEnableRtmp;
+
+  @JsonProperty(value = "protocol.enable_ts")
+  private String protocolEnableTs;
+
+  @JsonProperty(value = "protocol.enable_fmp4")
+  private String protocolEnableFmp4;
+
+  @JsonProperty(value = "protocol.mp4_as_player")
+  private String protocolMp4AsPlayer;
+
+  @JsonProperty(value = "protocol.mp4_max_second")
+  private String protocolMp4MaxSecond;
+
+  @JsonProperty(value = "protocol.mp4_save_path")
+  private String protocolMp4SavePath;
+
+  @JsonProperty(value = "protocol.hls_save_path")
+  private String protocolHlsSavePath;
+
+  @JsonProperty(value = "protocol.hls_demand")
+  private String protocolHlsDemand;
+
+  @JsonProperty(value = "protocol.rtsp_demand")
+  private String protocolRtspDemand;
+
+  @JsonProperty(value = "protocol.rtmp_demand")
+  private String protocolRtmpDemand;
+
+  @JsonProperty(value = "protocol.ts_demand")
+  private String protocolTsDemand;
+
+  @JsonProperty(value = "protocol.fmp4_demand")
+  private String protocolFmp4Demand;
+
+  @JsonProperty(value = "general.enableVhost")
+  private String generalEnableVhost;
+
+  @JsonProperty(value = "general.flowThreshold")
+  private String generalFlowThreshold;
+
+  @JsonProperty(value = "general.maxStreamWaitMS")
+  private String generalMaxStreamWaitMS;
+
+  @JsonProperty(value = "general.streamNoneReaderDelayMS")
+  private int generalStreamNoneReaderDelayMS;
+
+  @JsonProperty(value = "general.resetWhenRePlay")
+  private String generalResetWhenRePlay;
+
+  @JsonProperty(value = "general.mergeWriteMS")
+  private String generalMergeWriteMS;
+
+  @JsonProperty(value = "general.mediaServerId")
+  private String generalMediaServerId;
+
+  @JsonProperty(value = "general.wait_track_ready_ms")
+  private String generalWaitTrackReadyMs;
+
+  @JsonProperty(value = "general.wait_add_track_ms")
+  private String generalWaitAddTrackMs;
+
+  @JsonProperty(value = "general.unready_frame_cache")
+  private String generalUnreadyFrameCache;
+
+  @JsonProperty(value = "hls.fileBufSize")
+  private String hlsFileBufSize;
+
+  @JsonProperty(value = "hls.filePath")
+  private String hlsFilePath;
+
+  @JsonProperty(value = "hls.segDur")
+  private String hlsSegDur;
+
+  @JsonProperty(value = "hls.segNum")
+  private String hlsSegNum;
+
+  @JsonProperty(value = "hls.segRetain")
+  private String hlsSegRetain;
+
+  @JsonProperty(value = "hls.broadcastRecordTs")
+  private String hlsBroadcastRecordTs;
+
+  @JsonProperty(value = "hls.deleteDelaySec")
+  private String hlsDeleteDelaySec;
+
+  @JsonProperty(value = "hls.segKeep")
+  private String hlsSegKeep;
+
+  @JsonProperty(value = "hook.access_file_except_hls")
+  private String hookAccessFileExceptHLS;
+
+  @JsonProperty(value = "hook.admin_params")
+  private String hookAdminParams;
+
+  @JsonProperty(value = "hook.alive_interval")
+  private Float hookAliveInterval;
+
+  @JsonProperty(value = "hook.enable")
+  private String hookEnable;
+
+  @JsonProperty(value = "hook.on_flow_report")
+  private String hookOnFlowReport;
+
+  @JsonProperty(value = "hook.on_http_access")
+  private String hookOnHttpAccess;
+
+  @JsonProperty(value = "hook.on_play")
+  private String hookOnPlay;
+
+  @JsonProperty(value = "hook.on_publish")
+  private String hookOnPublish;
+
+  @JsonProperty(value = "hook.on_record_mp4")
+  private String hookOnRecordMp4;
+
+  @JsonProperty(value = "hook.on_rtsp_auth")
+  private String hookOnRtspAuth;
+
+  @JsonProperty(value = "hook.on_rtsp_realm")
+  private String hookOnRtspRealm;
+
+  @JsonProperty(value = "hook.on_shell_login")
+  private String hookOnShellLogin;
+
+  @JsonProperty(value = "hook.on_stream_changed")
+  private String hookOnStreamChanged;
+
+  @JsonProperty(value = "hook.on_stream_none_reader")
+  private String hookOnStreamNoneReader;
+
+  @JsonProperty(value = "hook.on_stream_not_found")
+  private String hookOnStreamNotFound;
+
+  @JsonProperty(value = "hook.on_server_started")
+  private String hookOnServerStarted;
+
+  @JsonProperty(value = "hook.on_server_keepalive")
+  private String hookOnServerKeepalive;
+
+  @JsonProperty(value = "hook.on_send_rtp_stopped")
+  private String hookOnSendRtpStopped;
+
+  @JsonProperty(value = "hook.on_rtp_server_timeout")
+  private String hookOnRtpServerTimeout;
+
+  @JsonProperty(value = "hook.timeoutSec")
+  private String hookTimeoutSec;
+
+  @JsonProperty(value = "http.charSet")
+  private String httpCharSet;
+
+  @JsonProperty(value = "http.keepAliveSecond")
+  private String httpKeepAliveSecond;
+
+  @JsonProperty(value = "http.maxReqCount")
+  private String httpMaxReqCount;
+
+  @JsonProperty(value = "http.maxReqSize")
+  private String httpMaxReqSize;
+
+  @JsonProperty(value = "http.notFound")
+  private String httpNotFound;
+
+  @JsonProperty(value = "http.port")
+  private int httpPort;
+
+  @JsonProperty(value = "http.rootPath")
+  private String httpRootPath;
+
+  @JsonProperty(value = "http.sendBufSize")
+  private String httpSendBufSize;
+
+  @JsonProperty(value = "http.sslport")
+  private int httpSslPort;
+
+  @JsonProperty(value = "multicast.addrMax")
+  private String multicastAddrMax;
+
+  @JsonProperty(value = "multicast.addrMin")
+  private String multicastAddrMin;
+
+  @JsonProperty(value = "multicast.udpTTL")
+  private String multicastUdpTTL;
+
+  @JsonProperty(value = "record.appName")
+  private String recordAppName;
+
+  @JsonProperty(value = "record.filePath")
+  private String recordFilePath;
+
+  @JsonProperty(value = "record.fileSecond")
+  private String recordFileSecond;
+
+  @JsonProperty(value = "record.sampleMS")
+  private String recordFileSampleMS;
+
+  @JsonProperty(value = "rtmp.handshakeSecond")
+  private String rtmpHandshakeSecond;
+
+  @JsonProperty(value = "rtmp.keepAliveSecond")
+  private String rtmpKeepAliveSecond;
+
+  @JsonProperty(value = "rtmp.modifyStamp")
+  private String rtmpModifyStamp;
+
+  @JsonProperty(value = "rtmp.port")
+  private int rtmpPort;
+
+  @JsonProperty(value = "rtmp.sslport")
+  private int rtmpSslPort;
+
+  @JsonProperty(value = "rtp.audioMtuSize")
+  private String rtpAudioMtuSize;
+
+  @JsonProperty(value = "rtp.clearCount")
+  private String rtpClearCount;
+
+  @JsonProperty(value = "rtp.cycleMS")
+  private String rtpCycleMS;
+
+  @JsonProperty(value = "rtp.maxRtpCount")
+  private String rtpMaxRtpCount;
+
+  @JsonProperty(value = "rtp.videoMtuSize")
+  private String rtpVideoMtuSize;
+
+  @JsonProperty(value = "rtp_proxy.checkSource")
+  private String rtpProxyCheckSource;
+
+  @JsonProperty(value = "rtp_proxy.dumpDir")
+  private String rtpProxyDumpDir;
+
+  @JsonProperty(value = "rtp_proxy.port")
+  private int rtpProxyPort;
+
+  @JsonProperty(value = "rtp_proxy.port_range")
+  private String portRange;
+
+  @JsonProperty(value = "rtp_proxy.timeoutSec")
+  private String rtpProxyTimeoutSec;
+
+  @JsonProperty(value = "rtsp.authBasic")
+  private String rtspAuthBasic;
+
+  @JsonProperty(value = "rtsp.handshakeSecond")
+  private String rtspHandshakeSecond;
+
+  @JsonProperty(value = "rtsp.keepAliveSecond")
+  private String rtspKeepAliveSecond;
+
+  @JsonProperty(value = "rtsp.port")
+  private int rtspPort;
+
+  @JsonProperty(value = "rtsp.sslport")
+  private int rtspSslPort;
+
+  @JsonProperty(value = "shell.maxReqSize")
+  private String shellMaxReqSize;
+
+  @JsonProperty(value = "shell.port")
+  private String shellPort;
+
+  @JsonProperty(value = "ip")
+  private String ip;
+
+  private String sdpIp;
+
+  private String streamIp;
+
+  private String hookIp;
+  private String tenantId;
+}

@@ -51,7 +51,6 @@ public interface FastIotConstants {
      * 操作功能码类型
      */
     String OPERATION_TYPE = "operationType";
-
     /**
      * 缩放因子
      */
@@ -67,6 +66,146 @@ public interface FastIotConstants {
      */
     String BIT_MASK = "bitMask";
   }
+  interface CacheSipKey {
+    String TK_SIP_CACHE_NAME = "tkSipCacheName";
+    String TK_OTHER_RECEIVE_RTP_INFO = "TK_OTHER_RECEIVE_RTP_INFO_";
+
+    String TK_OTHER_RECEIVE_PS_INFO = "TK_OTHER_RECEIVE_PS_INFO_";
+  }
+
+  interface MediaServerKey {
+
+    String MEDIA_SERVER_CACHE_NAME = "tkMediaServerCacheName";
+    String MEDIA_SERVER_PREFIX = "TK_MEDIA_SERVER_";
+    String MEDIA_TRANSACTION_USED_PREFIX = "TK_MEDIA_TRANSACTION_";
+    String MEDIA_SERVERS_ONLINE_PREFIX = "TK_MEDIA_ONLINE_SERVERS_";
+    String MEDIA_STREAM_AUTHORITY = "TK_MEDIA_STREAM_AUTHORITY_";
+
+    /** 点播信息的缓存键 */
+    String PLAYER_PREFIX = "TK_PLAYER";
+
+    /** 回放信息的缓存键 */
+    String PLAY_BACK_PREFIX = "TK_PLAY_BACK";
+
+    String TK_SERVER_STREAM_PREFIX = "TK_SIGNALLING_STREAM_";
+
+    String PLATFORM_SEND_RTP_INFO_PREFIX = "PLATFORM_SEND_RTP_INFO_";
+  }
+
+  interface ZLMediaKitHttpApi {
+    String BASE_URL = "/index/api";
+
+    /** 获取流列表，可选筛选参数 */
+    String GET_MEDIA_LIST = BASE_URL + "/getMediaList";
+
+    /** 获取rtp代理时的某路ssrc rtp信息 */
+    String GET_RTP_INFO = BASE_URL + "/getRtpInfo";
+
+    /** 获取视频流截图 */
+    String GET_STREAM_SNAP = BASE_URL + "/getSnap";
+
+    /** 通过fork FFmpeg进程的方式拉流代理，支持任意协议 */
+    String ADD_FFMPEG_SOURCE = BASE_URL + "/addFFmpegSource";
+
+    /** 关闭ffmpeg拉流代理(流注册成功后，也可以使用close_streams接口替代) */
+    String DEL_FFMPEG_SOURCE = BASE_URL + "/delFFmpegSource";
+
+    /** 获取服务器配置 */
+    String GET_SERVER_CONFIG = BASE_URL + "/getServerConfig";
+
+    /** 设置服务器配置 */
+    String SET_SERVER_CONFIG = BASE_URL + "/setServerConfig";
+
+    /** 创建GB28181 RTP接收端口，如果该端口接收数据超时，则会自动被回收(不用调用closeRtpServer接口) */
+    String OPEN_RTP_SERVER = BASE_URL + "/openRtpServer";
+
+    /** 关闭GB28181 RTP接收端口 */
+    String CLOSE_RTP_SERVER = BASE_URL + "/closeRtpServer";
+
+    /**
+     * 作为GB28181客户端，启动ps-rtp推流，支持rtp/udp方式；该接口支持rtsp/rtmp等协议转ps-rtp推流。
+     * 第一次推流失败会直接返回错误，成功一次后，后续失败也将无限重试。
+     */
+    String START_SEND_RTP = BASE_URL + "/startSendRtp";
+
+    /** 停止GB28181 ps-rtp推流 */
+    String STOP_SEND_RTP = BASE_URL + "/stopSendRtp";
+
+    /** 重启服务器,只有Daemon方式才能重启，否则是直接关闭！ */
+    String RESTART_SERVER = BASE_URL + "/restartServer";
+  }
+
+  interface ZLMediaBody {
+    /** 表单数据：异常码 */
+    String CODE = "code";
+
+    /** 表单数据：数据 */
+    String DATA = "data";
+
+    /** 表单数据：异常消息 */
+    String MSG = "msg";
+
+    /** 表单数据：流媒体密钥 */
+    String SECRET = "secret";
+
+    /** 流媒体服务器信息 */
+    String MEDIA = "media";
+
+    /** 流媒体服务器信息:ID */
+    String MEDIA_ID = "mediaId";
+
+    /** 流媒体服务器信息:会话描述协议 */
+    String MEDIA_SDP_IP = "sdpIp";
+
+    /** 数据流服务ID */
+    String SSRCINFO_STREAM = "streamId";
+
+    /** 数据流服务的端口 */
+    String SSRCINFO_PORT = "streamPort";
+
+    /** 同步源标识符 */
+    String SSRCINFO_SSRC = "ssrc";
+
+    /** 流媒体通道ID */
+    String CHANNEL_ID = "channelId";
+
+    /** 流媒体通道ID */
+    String CALL_ID = "callId";
+
+    /** 设备国标编号 */
+    String CAMERA_CODE = "cameraCode";
+
+    /** 方法类型 */
+    String METHOD_TYPE = "methodType";
+
+    /** 请求响应事件：头部标签内容 */
+    String MSG_HEADER = "msgHeader";
+
+    /** 请求响应事件：表单内容 */
+    String MSG_CONTEXT = "msgContext";
+
+    /** 设备控制内容 */
+    String CONTROL_CONTEXT = "ptzContext";
+
+    /** 订阅处理结果 */
+    String SESSION_TYPE = "sessionType";
+
+    /** 订阅处理结果 */
+    String SSRC_CHECK = "ssrcCheck";
+  }
+
+  /** 视频流传输模式 */
+  interface StreamMode {
+    /** tcp 被动模式 */
+    String TCP_PASSIVE = "TCP-PASSIVE";
+
+    /** tcp 主动模式 */
+    String TCP_ACTIVE = "TCP-ACTIVE";
+
+    /** udp */
+    String UDP = "UDP";
+  }
+
   interface TBCacheConfig {
     String TB_CACHE_CONFIG_KEY = "TB_CONNECT_CACHE";
     String EXISTING_TENANT = "EXISTING_TENANT";
@@ -248,4 +387,22 @@ public interface FastIotConstants {
     public static String TK_MSG_EVENT_NODE = "org.thingsboard.rule.engine.yunteng.event.TkMsgEventNode";
   }
 
+
+  /** 设备扩展信息内容 */
+  interface DeviceAdditional {
+    /** 摄像头信息 */
+    String SIP = "sip";
+
+    /** 设备图片 */
+    String AVATAR = "avatar";
+
+    /** 设备地理位置 */
+    String ADDRESS = "address";
+
+    /** 地理坐标之经度 */
+    String LONGITUDE = "longitude";
+
+    /** 地理坐标之维度 */
+    String LATITUDE = "latitude";
+  }
 }

@@ -133,6 +133,12 @@ public final class ModelConstants {
 
     /** 产品品类表 */
     public static final String TK_DEVICE_PROFILE_CATEGORY = "tk_device_profile_category";
+
+    /** ZLMediaKit 流媒体表 */
+    public static final String TK_MEDIA_SERVER_NAME = "tk_media_server";
+
+    /** 视频通道表 */
+    public static final String TK_VIDEO_CHANNEL_NAME = "tk_video_channel";
   }
 
   public static class TableFields {

+package org.thingsboard.server.common.data.yunteng.constant;
+
+public class SipRequestMethodConstants {
+    public static final String ACK = "ACK";
+    public static final String BYE = "BYE";
+    public static final String CANCEL = "CANCEL";
+    public static final String INVITE = "INVITE";
+    public static final String OPTIONS = "OPTIONS";
+    public static final String REGISTER = "REGISTER";
+    public static final String NOTIFY = "NOTIFY";
+    public static final String SUBSCRIBE = "SUBSCRIBE";
+    public static final String MESSAGE = "MESSAGE";
+    public static final String REFER = "REFER";
+
+    public static final String INFO = "INFO";
+    public static final String PRACK = "PRACK";
+
+    public static final String UPDATE = "UPDATE";
+
+    public static final String PUBLISH = "PUBLISH";
+}

@@ -120,7 +120,17 @@ public enum ErrorMessage {
   EZVIZ_API_ERROR(400095,"荧石视频获取TokenAPI调用失败【%s】，错误码【%s】"),
   EZVIZ_GET_URL_ERROR(400096,"荧石API调用获取URL失败！！"),
   IMPORT_TCP_ERROR(400097,"TCP产品不能导入INT,DOUBLE,BOOL,TEXT以外的数据类型属性！！"),
-  IMPORT_ERROR(400098,"请使用模板excel重新导入"),
+  SSRC_INFO_NOT_FOUND(400098,"缓存事务信息未找到,设备【%s】 通道【%s】"),
+  VIDEO_CHANNEL_NOT_FOUND(400099,"视频通道不存在"),
+  ONLINE_MEDIA_SERVER_NOT_FOUND(400100,"没有可用的流媒体节点"),
+  FOUND_VIDEO_DEVICE_FAILED(400101,"获取视频设备信息失败"),
+  NOT_FOUND_MEDIA_SERVER_FOR_PLAY(400102,"未找到可用于播放的流媒体"),
+  RECEIVE_STREAM_FAILED(400103,"开启收流失败"),
+  GET_PLAY_PORT_FAILED(400104,"获取点播端口异常"),
+  STREAM_INFO_NOT_FOUND_FOR_PLAY(400105,"点播信息未找到"),
+  SIP_COMMAND_SEND_FAILED(400106,"sip命令下发失败"),
+  NOT_BELONG_CURRENT_CUSTOMER(400107,"该数据不属于当前客户"),
+  IMPORT_ERROR(400108,"请使用模板excel重新导入"),
   HAVE_NO_PERMISSION(500002,"没有修改权限"),
   NOT_ALLOED_ISOLATED_IN_MONOLITH(500003,"【monolith】模式下，不能选择【isolated】类型的租户配置");
 

@@ -26,7 +26,6 @@ public class TkVideoDTO extends TenantDTO {
   private String deviceType;
 
   @ApiModelProperty(value = "摄像头编号/监控点位编号", required = true)
-  @NotEmpty(message = "摄像头编号不能为空或空字符串")
   private String sn;
 
   @ApiModelProperty(value = "组织ID", required = true)
@@ -42,7 +41,7 @@ public class TkVideoDTO extends TenantDTO {
   @ApiModelProperty(value = "摄像头描述")
   private String description;
 
-  @ApiModelProperty(value = "流获取方式：0 手动填写 1平台获取", required = true)
+  @ApiModelProperty(value = "流获取方式：0 手动填写 1平台获取 2 GBT28281", required = true)
   private Integer accessMode;
 
   @ApiModelProperty(value = "平台ID")

+package org.thingsboard.server.common.data.yunteng.dto;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import javax.validation.constraints.NotEmpty;
+import java.util.List;
+
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class TkVideoGptDTO extends TenantDTO {
+
+  @ApiModelProperty(value = "组织ID", required = true)
+  @NotEmpty(message = "组织ID不能为空或空字符串")
+  private String organizationId;
+
+  @ApiModelProperty(value = "流获取方式：0 手动填写 1平台获取 2 GBT28281", required = true)
+  private Integer accessMode;
+
+  @ApiModelProperty(value = "多个设备id与通道号")
+  private List<TkVideoGptDeviceDTO> gptDeviceDTOS;
+
+}
\ No newline at end of file

+package org.thingsboard.server.common.data.yunteng.dto;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import javax.validation.constraints.NotEmpty;
+import java.util.List;
+
+@Data
+public class TkVideoGptDeviceDTO {
+
+    @ApiModelProperty(value = "设备id", required = true)
+    @NotEmpty(message = "设备id不能为空")
+    private String deviceID;
+
+    @ApiModelProperty(value = "设备名称", required = true)
+    @NotEmpty(message = "设备名称不能为空")
+    private String deviceName;
+
+    @ApiModelProperty(value = "通道号集合")
+    @NotEmpty(message = "通道号集合不能为空")
+    private List<String> channelNos;
+
+}
\ No newline at end of file

+package org.thingsboard.server.common.data.yunteng.dto.sip;
+
+import lombok.Data;
+import org.thingsboard.server.common.data.yunteng.enums.CatalogDataStatusEnum;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+@Data
+public class CatalogDataDTO {
+  /** 命令序列号 */
+  private int sn;
+
+  private int total;
+  private List<VideoChanelDTO> channelList;
+  private LocalDateTime lastTime;
+  private SipDeviceDTO device;
+  private String errorMsg;
+  private CatalogDataStatusEnum status;
+}

+package org.thingsboard.server.common.data.yunteng.dto.sip;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.springframework.util.ObjectUtils;
+import org.thingsboard.server.common.data.yunteng.config.media.ZLMediaKitServerConfig;
+import org.thingsboard.server.common.data.yunteng.dto.TenantDTO;
+
+@EqualsAndHashCode(callSuper = true)
+@Data
+public class MediaServerDTO extends TenantDTO {
+  private static final long serialVersionUID = -2499846994830954839L;
+
+  @ApiModelProperty(value = "流媒体的ID,非主键ID")
+  private String mediaServerId;
+
+  @ApiModelProperty(value = "流媒体的IP")
+  private String ip;
+
+  @ApiModelProperty(value = "hook使用的IP")
+  private String hookIp;
+
+  @ApiModelProperty(value = "SDP IP")
+  private String sdpIp;
+
+  @ApiModelProperty(value = "流IP")
+  private String streamIp;
+
+  @ApiModelProperty(value = "HTTP端口")
+  private Integer httpPort;
+
+  @ApiModelProperty(value = "HTTPS端口")
+  private Integer httpSslPort;
+
+  @ApiModelProperty(value = "RTMP端口")
+  private Integer rtmpPort;
+
+  @ApiModelProperty(value = "RTMP安全协议端口")
+  private Integer rtmpSslPort;
+
+  @ApiModelProperty(value = "RTP收流端口（单端口模式有用）")
+  private Integer rtpProxyPort;
+
+  @ApiModelProperty(value = "RTSP端口")
+  private Integer rtspPort;
+
+  @ApiModelProperty(value = "RTSP安全协议端口")
+  private Integer rtspSslPort;
+
+  @ApiModelProperty(value = "是否开启自动配置ZLMediaKit")
+  private boolean autoConfig;
+
+  @ApiModelProperty(value = "ZLMediaKit鉴权参数")
+  private String secret;
+
+  @ApiModelProperty(value = "keepalive hook触发间隔,单位秒")
+  private Float hookAliveInterval;
+
+  @ApiModelProperty(value = "是否使用多端口模式")
+  private boolean rtpEnable;
+
+  @ApiModelProperty(value = "流媒体服务器的状态")
+  private boolean status;
+
+  @ApiModelProperty(value = "多端口RTP收流端口范围")
+  private String rtpPortRange;
+
+  @ApiModelProperty(value = "RTP发流端口范围")
+  private String sendRtpPortRange;
+
+  @ApiModelProperty(value = "assist服务端口")
+  private Integer recordAssistPort;
+
+  @ApiModelProperty(value = "最后一次心跳时间")
+  private String lastKeepaliveTime;
+
+  @ApiModelProperty(value = "是否是默认ZLM")
+  private boolean defaultServer;
+
+  @ApiModelProperty(value = "当前使用到的端口")
+  private Integer currentPort;
+
+  public MediaServerDTO(){
+
+  }
+  public MediaServerDTO(ZLMediaKitServerConfig zlmServerConfig, String sipIp) {
+    setId(zlmServerConfig.getGeneralMediaServerId());
+    ip = zlmServerConfig.getIp();
+    hookIp = ObjectUtils.isEmpty(zlmServerConfig.getHookIp()) ? sipIp : zlmServerConfig.getHookIp();
+    sdpIp =
+        ObjectUtils.isEmpty(zlmServerConfig.getSdpIp())
+            ? zlmServerConfig.getIp()
+            : zlmServerConfig.getSdpIp();
+    streamIp =
+        ObjectUtils.isEmpty(zlmServerConfig.getStreamIp())
+            ? zlmServerConfig.getIp()
+            : zlmServerConfig.getStreamIp();
+    httpPort = zlmServerConfig.getHttpPort();
+    httpSslPort = zlmServerConfig.getHttpSslPort();
+    rtmpPort = zlmServerConfig.getRtmpPort();
+    rtmpSslPort = zlmServerConfig.getRtmpSslPort();
+    rtpProxyPort = zlmServerConfig.getRtpProxyPort();
+    rtspPort = zlmServerConfig.getRtspPort();
+    rtspSslPort = zlmServerConfig.getRtspSslPort();
+    autoConfig = true; // 默认值true;
+    secret = zlmServerConfig.getApiSecret();
+    hookAliveInterval = zlmServerConfig.getHookAliveInterval();
+    rtpEnable = false; // 默认使用单端口;直到用户自己设置开启多端口
+    rtpPortRange = zlmServerConfig.getPortRange().replace("_", ","); // 默认使用30000,30500作为级联时发送流的端口号
+    recordAssistPort = 0; // 默认关闭
+  }
+}

+package org.thingsboard.server.common.data.yunteng.dto.sip;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import org.thingsboard.server.common.data.yunteng.enums.PTZCommandEnum;
+
+import java.io.Serializable;
+
+@Data
+public class PTZCmdDTO implements Serializable {
+
+  @ApiModelProperty(value = "控制指令")
+  private PTZCommandEnum command;
+
+  @ApiModelProperty(value = "水平速度")
+  private int horizonSpeed;
+
+  @ApiModelProperty(value = "垂直速度")
+  private int verticalSpeed;
+
+  @ApiModelProperty(value = "缩放速度")
+  private int zoomSpeed;
+}

+package org.thingsboard.server.common.data.yunteng.dto.sip;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import org.thingsboard.server.common.data.yunteng.enums.InviteStreamTypeEnum;
+
+@Data
+public class SendRtpItemDTO {
+  @ApiModelProperty(value = "推流ip")
+  private String ip;
+
+  @ApiModelProperty(value = "推流端口")
+  private int port;
+
+  @ApiModelProperty(value = "推流标识")
+  private String ssrc;
+
+  @ApiModelProperty(value = "平台id")
+  private String platformId;
+
+  @ApiModelProperty(value = "对应设备id")
+  private String deviceId;
+
+  @ApiModelProperty(value = "直播流的应用名")
+  private String app;
+
+  @ApiModelProperty(value = "通道id")
+  private String channelId;
+
+  @ApiModelProperty(value = "推流状态:0 等待设备推流上来 1 等待上级平台回复ack 2 推流中")
+  private int status = 0;
+
+  @ApiModelProperty(value = "设备推流的streamId")
+  private String streamId;
+
+  @ApiModelProperty(value = "是否为tcp")
+  private boolean tcp;
+
+  @ApiModelProperty(value = "是否为tcp主动模式")
+  private boolean tcpActive;
+
+  @ApiModelProperty(value = "自己推流使用的端口")
+  private int localPort;
+
+  @ApiModelProperty(value = "使用的流媒体")
+  private String mediaServerId;
+
+  @ApiModelProperty(value = "使用的服务的ID")
+  private String serverId;
+
+  @ApiModelProperty(value = "invite 的 callId")
+  private String CallId;
+
+  @ApiModelProperty(value = "invite 的 fromTag")
+  private String fromTag;
+
+  @ApiModelProperty(value = "invite 的 toTag")
+  private String toTag;
+
+  @ApiModelProperty(value = "发送时，rtp的pt（uint8_t）,不传时默认为96")
+  private int pt = 96;
+
+  @ApiModelProperty(value = "发送时，rtp的负载类型。为true时，负载为ps；为false时，为es")
+  private boolean usePs = true;
+
+  @ApiModelProperty(value = "当usePs 为false时，有效。为1时，发送音频；为0时，发送视频；不传时默认为0")
+  private boolean onlyAudio = false;
+
+  @ApiModelProperty(value = "是否开启rtcp保活")
+  private boolean rtcp = false;
+
+  @ApiModelProperty(value = "播放类型")
+  private InviteStreamTypeEnum playType;
+}

+package org.thingsboard.server.common.data.yunteng.dto.sip;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import org.thingsboard.server.common.data.yunteng.constant.FastIotConstants;
+
+import java.io.Serializable;
+
+@Data
+public class SipDeviceDTO implements Serializable {
+  @ApiModelProperty(value = "设备国标编号")
+  private String cameraCode;
+
+  @ApiModelProperty(value = "wan地址")
+  private String hostAddress;
+
+  @ApiModelProperty(value = "设备访问平台的IP")
+  private String localIp;
+
+  @ApiModelProperty(value = "传输协议：UDP/TCP")
+  private String transport;
+
+  @ApiModelProperty(value = "字符集")
+  private String charset;
+
+  @ApiModelProperty(value = "收流IP")
+  private String sdpIp;
+
+  @ApiModelProperty(value = "数据流传输模式:UDP / TCP-ACTIVE：tcp主动模式 / TCP-PASSIVE：tcp被动模式")
+  private String streamMode;
+
+  @ApiModelProperty(value = "通道个数")
+  private Integer channelCount;
+
+  @ApiModelProperty(value = "设备使用的媒体id, 默认为null")
+  private String mediaServerId;
+
+  @ApiModelProperty(value = "是否开启ssrc校验，默认关闭，开启可以防止串流")
+  private boolean ssrcCheck = true;
+  @ApiModelProperty(value = "生产厂商")
+  private String manufacturer;
+
+  @ApiModelProperty(value = "设备名称")
+  private String name;
+
+  @ApiModelProperty(value = "设备型号")
+  private String model;
+
+  @ApiModelProperty(value = "固件版本")
+  private String firmware;
+  public Integer getStreamModeForParam() {
+    if (FastIotConstants.StreamMode.UDP.equalsIgnoreCase(streamMode)) {
+      return 0;
+    }else if (FastIotConstants.StreamMode.TCP_PASSIVE.equalsIgnoreCase(streamMode)) {
+      return 1;
+    }else if (FastIotConstants.StreamMode.TCP_ACTIVE.equalsIgnoreCase(streamMode)) {
+      return 2;
+    }
+    return 0;
+  }
+}

+package org.thingsboard.server.common.data.yunteng.dto.sip;
+
+import lombok.Builder;
+import lombok.Data;
+
+import java.io.Serializable;
+
+@Data
+@Builder
+public class SipMessageHeaderDTO implements Serializable {
+  private String callId;
+  private String viaTag;
+  private String fromTag;
+  private String toTag;
+  private String viaBranch;
+}

+package org.thingsboard.server.common.data.yunteng.dto.sip;
+
+import lombok.Data;
+
+@Data
+public class SsrcInfoDTO {
+  /**数据流服务的端口*/
+  private int port;
+  /**同步源标识符*/
+  private String ssrc;
+  /**数据流服务ID*/
+  private String stream;
+
+  public SsrcInfoDTO(int rtpServerPort, String ssrc, String streamId) {
+    this.port = rtpServerPort;
+    this.ssrc = ssrc;
+    stream = streamId;
+  }
+}

+package org.thingsboard.server.common.data.yunteng.dto.sip;
+
+import lombok.Data;
+import org.thingsboard.server.common.data.yunteng.enums.SessionTypeEnum;
+
+import java.io.Serializable;
+
+/**
+ * 视频流源信息
+ */
+@Data
+public class SsrcTransactionDTO implements Serializable {
+  private String cameraCode;
+  private String channelId;
+  private String callId;
+  private String stream;
+  private String mediaServerId;
+  /**SSRC（Source Synchronization Control）是同步源标识符*/
+  private String ssrc;
+
+  private SipMessageHeaderDTO sipTransactionInfo;
+
+  private SessionTypeEnum type;
+}

+package org.thingsboard.server.common.data.yunteng.dto.sip;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+/**
+ * 视频流播放地址内容
+ */
+@Data
+public class StreamContentDTO {
+  @ApiModelProperty(value = "应用名")
+  private String app;
+
+  @ApiModelProperty(value = "流ID")
+  private String stream;
+
+  @ApiModelProperty(value = "IP")
+  private String ip;
+
+  @ApiModelProperty(value = "HTTP-FLV流地址")
+  private String flv;
+
+  @ApiModelProperty(value = "HTTPS-FLV流地址")
+  private String https_flv;
+
+  @ApiModelProperty(value = "Websocket-FLV流地址")
+  private String ws_flv;
+
+  @ApiModelProperty(value = "Websockets-FLV流地址")
+  private String wss_flv;
+
+  @ApiModelProperty(value = "HTTP-FMP4流地址")
+  private String fmp4;
+
+  @ApiModelProperty(value = "HTTPS-FMP4流地址")
+  private String https_fmp4;
+
+  @ApiModelProperty(value = "Websocket-FMP4流地址")
+  private String ws_fmp4;
+
+  @ApiModelProperty(value = "Websockets-FMP4流地址")
+  private String wss_fmp4;
+
+  @ApiModelProperty(value = "HLS流地址")
+  private String hls;
+
+  @ApiModelProperty(value = "HTTPS-HLS流地址")
+  private String https_hls;
+
+  @ApiModelProperty(value = "Websocket-HLS流地址")
+  private String ws_hls;
+
+  @ApiModelProperty(value = "Websockets-HLS流地址")
+  private String wss_hls;
+
+  @ApiModelProperty(value = "HTTP-TS流地址")
+  private String ts;
+
+  @ApiModelProperty(value = "HTTPS-TS流地址")
+  private String https_ts;
+
+  @ApiModelProperty(value = "Websocket-TS流地址")
+  private String ws_ts;
+
+  @ApiModelProperty(value = "Websockets-TS流地址")
+  private String wss_ts;
+
+  @ApiModelProperty(value = "RTMP流地址")
+  private String rtmp;
+
+  @ApiModelProperty(value = "RTMPS流地址")
+  private String rtmps;
+
+  @ApiModelProperty(value = "RTSP流地址")
+  private String rtsp;
+
+  @ApiModelProperty(value = "RTSPS流地址")
+  private String rtsps;
+
+  @ApiModelProperty(value = "RTC流地址")
+  private String rtc;
+
+  @ApiModelProperty(value = "RTCS流地址")
+  private String rtcs;
+
+  @ApiModelProperty(value = "流媒体ID")
+  private String mediaServerId;
+
+  @ApiModelProperty(value = "流编码信息")
+  private Object tracks;
+
+  @ApiModelProperty(value = "开始时间")
+  private String startTime;
+
+  @ApiModelProperty(value = "结束时间")
+  private String endTime;
+
+  private double progress;
+
+  public StreamContentDTO(StreamInfoDTO streamInfo) {
+    if (streamInfo == null) {
+      return;
+    }
+    this.app = streamInfo.getApp();
+    this.stream = streamInfo.getStream();
+    if (streamInfo.getFlv() != null) {
+      this.flv = streamInfo.getFlv().toString();
+    }
+    if (streamInfo.getHttps_flv() != null) {
+      this.https_flv = streamInfo.getHttps_flv().toString();
+    }
+    if (streamInfo.getWs_flv() != null) {
+      this.ws_flv = streamInfo.getWs_flv().toString();
+    }
+    if (streamInfo.getWss_flv() != null) {
+      this.wss_flv = streamInfo.getWss_flv().toString();
+    }
+    if (streamInfo.getFmp4() != null) {
+      this.fmp4 = streamInfo.getFmp4().toString();
+    }
+    if (streamInfo.getHttps_fmp4() != null) {
+      this.https_fmp4 = streamInfo.getHttps_fmp4().toString();
+    }
+    if (streamInfo.getWs_fmp4() != null) {
+      this.ws_fmp4 = streamInfo.getWs_fmp4().toString();
+    }
+    if (streamInfo.getWss_fmp4() != null) {
+      this.wss_fmp4 = streamInfo.getWss_fmp4().toString();
+    }
+    if (streamInfo.getHls() != null) {
+      this.hls = streamInfo.getHls().toString();
+    }
+    if (streamInfo.getHttps_hls() != null) {
+      this.https_hls = streamInfo.getHttps_hls().toString();
+    }
+    if (streamInfo.getWs_hls() != null) {
+      this.ws_hls = streamInfo.getWs_hls().toString();
+    }
+    if (streamInfo.getWss_hls() != null) {
+      this.wss_hls = streamInfo.getWss_hls().toString();
+    }
+    if (streamInfo.getTs() != null) {
+      this.ts = streamInfo.getTs().toString();
+    }
+    if (streamInfo.getHttps_ts() != null) {
+      this.https_ts = streamInfo.getHttps_ts().toString();
+    }
+    if (streamInfo.getWs_ts() != null) {
+      this.ws_ts = streamInfo.getWs_ts().toString();
+    }
+    if (streamInfo.getRtmp() != null) {
+      this.rtmp = streamInfo.getRtmp().toString();
+    }
+    if (streamInfo.getRtmps() != null) {
+      this.rtmps = streamInfo.getRtmps().toString();
+    }
+    if (streamInfo.getRtsp() != null) {
+      this.rtsp = streamInfo.getRtsp().toString();
+    }
+    if (streamInfo.getRtsps() != null) {
+      this.rtsps = streamInfo.getRtsps().toString();
+    }
+    if (streamInfo.getRtc() != null) {
+      this.rtc = streamInfo.getRtc().toString();
+    }
+    if (streamInfo.getRtcs() != null) {
+      this.rtcs = streamInfo.getRtcs().toString();
+    }
+
+    this.mediaServerId = streamInfo.getMediaServerId();
+    this.tracks = streamInfo.getTracks();
+    this.startTime = streamInfo.getStartTime();
+    this.endTime = streamInfo.getEndTime();
+    this.progress = streamInfo.getProgress();
+  }
+}

+package org.thingsboard.server.common.data.yunteng.dto.sip;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.io.Serializable;
+import java.util.Objects;
+
+/**
+ * 点播的流信息，例如：播放地址
+ */
+@Data
+public class StreamInfoDTO implements Serializable, Cloneable {
+  @ApiModelProperty(value = "应用名")
+  private String app;
+
+  @ApiModelProperty(value = "流ID")
+  private String stream;
+
+  @ApiModelProperty(value = "设备编号")
+  private String cameraCode;
+
+  @ApiModelProperty(value = "通道编号")
+  private String channelId;
+
+  @ApiModelProperty(value = "IP")
+  private String ip;
+
+  @ApiModelProperty(value = "HTTP-FLV流地址")
+  private StreamURLDTO flv;
+
+  @ApiModelProperty(value = "HTTPS-FLV流地址")
+  private StreamURLDTO https_flv;
+
+  @ApiModelProperty(value = "Websocket-FLV流地址")
+  private StreamURLDTO ws_flv;
+
+  @ApiModelProperty(value = "Websockets-FLV流地址")
+  private StreamURLDTO wss_flv;
+
+  @ApiModelProperty(value = "HTTP-FMP4流地址")
+  private StreamURLDTO fmp4;
+
+  @ApiModelProperty(value = "HTTPS-FMP4流地址")
+  private StreamURLDTO https_fmp4;
+
+  @ApiModelProperty(value = "Websocket-FMP4流地址")
+  private StreamURLDTO ws_fmp4;
+
+  @ApiModelProperty(value = "Websockets-FMP4流地址")
+  private StreamURLDTO wss_fmp4;
+
+  @ApiModelProperty(value = "HLS流地址")
+  private StreamURLDTO hls;
+
+  @ApiModelProperty(value = "HTTPS-HLS流地址")
+  private StreamURLDTO https_hls;
+
+  @ApiModelProperty(value = "Websocket-HLS流地址")
+  private StreamURLDTO ws_hls;
+
+  @ApiModelProperty(value = "Websockets-HLS流地址")
+  private StreamURLDTO wss_hls;
+
+  @ApiModelProperty(value = "HTTP-TS流地址")
+  private StreamURLDTO ts;
+
+  @ApiModelProperty(value = "HTTPS-TS流地址")
+  private StreamURLDTO https_ts;
+
+  @ApiModelProperty(value = "Websocket-TS流地址")
+  private StreamURLDTO ws_ts;
+
+  @ApiModelProperty(value = "Websockets-TS流地址")
+  private StreamURLDTO wss_ts;
+
+  @ApiModelProperty(value = "RTMP流地址")
+  private StreamURLDTO rtmp;
+
+  @ApiModelProperty(value = "RTMPS流地址")
+  private StreamURLDTO rtmps;
+
+  @ApiModelProperty(value = "RTSP流地址")
+  private StreamURLDTO rtsp;
+
+  @ApiModelProperty(value = "RTSPS流地址")
+  private StreamURLDTO rtsps;
+
+  @ApiModelProperty(value = "RTC流地址")
+  private StreamURLDTO rtc;
+
+  @ApiModelProperty(value = "RTCS流地址")
+  private StreamURLDTO rtcs;
+
+  @ApiModelProperty(value = "流媒体ID")
+  private String mediaServerId;
+
+  @ApiModelProperty(value = "流编码信息")
+  private Object tracks;
+
+  @ApiModelProperty(value = "开始时间")
+  private String startTime;
+
+  @ApiModelProperty(value = "结束时间")
+  private String endTime;
+
+  @ApiModelProperty(value = "进度（录像下载使用）")
+  private double progress;
+
+  @ApiModelProperty(value = "是否暂停（录像回放使用）")
+  private boolean pause;
+
+  public void setRtmp(String host, int port, int sslPort, String app, String stream, String callIdParam) {
+    String file = String.format("%s/%s%s", app, stream, callIdParam);
+    if (port > 0) {
+      this.rtmp = new StreamURLDTO("rtmp", host, port, file);
+    }
+    if (sslPort > 0) {
+      this.rtmps = new StreamURLDTO("rtmps", host, sslPort, file);
+    }
+  }
+
+  public void setRtsp(String host, int port, int sslPort, String app, String stream, String callIdParam) {
+    String file = String.format("%s/%s%s", app, stream, callIdParam);
+    if (port > 0) {
+      this.rtsp = new StreamURLDTO("rtsp", host, port, file);
+    }
+    if (sslPort > 0) {
+      this.rtsps = new StreamURLDTO("rtsps", host, sslPort, file);
+    }
+  }
+
+  public void setFlv(String host, int port, int sslPort, String app, String stream, String callIdParam) {
+    String file = String.format("%s/%s.live.flv%s", app, stream, callIdParam);
+    if (port > 0) {
+      this.flv = new StreamURLDTO("http", host, port, file);
+    }
+    this.ws_flv = new StreamURLDTO("ws", host, port, file);
+    if (sslPort > 0) {
+      this.https_flv = new StreamURLDTO("https", host, sslPort, file);
+      this.wss_flv = new StreamURLDTO("wss", host, sslPort, file);
+    }
+  }
+
+  public void setFmp4(String host, int port, int sslPort, String app, String stream, String callIdParam) {
+    String file = String.format("%s/%s.live.mp4%s", app, stream, callIdParam);
+    if (port > 0) {
+      this.fmp4 = new StreamURLDTO("http", host, port, file);
+      this.ws_fmp4 = new StreamURLDTO("ws", host, port, file);
+    }
+    if (sslPort > 0) {
+      this.https_fmp4 = new StreamURLDTO("https", host, sslPort, file);
+      this.wss_fmp4 = new StreamURLDTO("wss", host, sslPort, file);
+    }
+  }
+
+  public void setHls(String host, int port, int sslPort, String app, String stream, String callIdParam) {
+    String file = String.format("%s/%s/hls.m3u8%s", app, stream, callIdParam);
+    if (port > 0) {
+      this.hls = new StreamURLDTO("http", host, port, file);
+      this.ws_hls = new StreamURLDTO("ws", host, port, file);
+    }
+    if (sslPort > 0) {
+      this.https_hls = new StreamURLDTO("https", host, sslPort, file);
+      this.wss_hls = new StreamURLDTO("wss", host, sslPort, file);
+    }
+  }
+
+  public void setTs(String host, int port, int sslPort, String app, String stream, String callIdParam) {
+    String file = String.format("%s/%s.live.ts%s", app, stream, callIdParam);
+
+    if (port > 0) {
+      this.ts = new StreamURLDTO("http", host, port, file);
+      this.ws_ts = new StreamURLDTO("ws", host, port, file);
+    }
+    if (sslPort > 0) {
+      this.https_ts = new StreamURLDTO("https", host, sslPort, file);
+      this.wss_ts = new StreamURLDTO("wss", host, sslPort, file);
+    }
+  }
+
+  public void setRtc(String host, int port, int sslPort, String app, String stream, String callIdParam) {
+    if (callIdParam != null) {
+      callIdParam = Objects.equals(callIdParam, "") ? callIdParam : callIdParam.replace("?", "&");
+    }
+    String file = String.format("index/api/webrtc?app=%s&stream=%s&type=play%s", app, stream, callIdParam);
+    if (port > 0) {
+      this.rtc = new StreamURLDTO("http", host, port, file);
+    }
+    if (sslPort > 0) {
+      this.rtcs = new StreamURLDTO("https", host, sslPort, file);
+    }
+  }
+
+    @Override
+    public StreamInfoDTO clone() {
+        try {
+            StreamInfoDTO clone = (StreamInfoDTO) super.clone();
+            // TODO: copy mutable state here, so the clone can't change the internals of the original
+            return clone;
+        } catch (CloneNotSupportedException e) {
+            throw new AssertionError();
+        }
+    }
+}

+package org.thingsboard.server.common.data.yunteng.dto.sip;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.io.Serializable;
+
+@ApiModel(value = "流地址信息")
+@Data
+public class StreamURLDTO implements Serializable {
+  @ApiModelProperty(value = "协议")
+  private String protocol;
+
+  @ApiModelProperty(value = "主机地址")
+  private String host;
+
+  @ApiModelProperty(value = "端口")
+  private int port = -1;
+
+  @ApiModelProperty(value = "定位位置")
+  private String file;
+
+  public StreamURLDTO() {}
+
+  public StreamURLDTO(String protocol, String host, int port, String file) {
+    this.protocol = protocol;
+    this.host = host;
+    this.port = port;
+    this.file = file;
+  }
+
+  @Override
+  public String toString() {
+    if (protocol != null && host != null && port != -1) {
+      return String.format("%s://%s:%s/%s", protocol, host, port, file);
+    } else {
+      return null;
+    }
+  }
+}

+package org.thingsboard.server.common.data.yunteng.dto.sip;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+@ApiModel(value = "摄像机同步状态")
+@Data
+public class SyncStatusDTO {
+  @ApiModelProperty(value = "总数")
+  private int total;
+
+  @ApiModelProperty(value = "当前更新多少")
+  private int current;
+
+  @ApiModelProperty(value = "错误描述")
+  private String errorMsg;
+
+  @ApiModelProperty(value = "是否同步中")
+  private boolean syncIng;
+}

+package org.thingsboard.server.common.data.yunteng.dto.sip;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import java.time.LocalDateTime;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.thingsboard.server.common.data.yunteng.dto.TenantDTO;
+import org.thingsboard.server.common.data.yunteng.enums.StatusEnum;
+
+@EqualsAndHashCode(callSuper = true)
+@ApiModel(value = "视频通道列表")
+@Data
+public class VideoChanelDTO extends TenantDTO {
+  private static final long serialVersionUID = -7234375257329881606L;
+
+  @ApiModelProperty(value = "视频通道名称")
+  private String name;
+
+  @ApiModelProperty(value = "视频通道ID")
+  private String channelId;
+
+  @ApiModelProperty(value = "设备国标编号")
+  private String cameraCode;
+
+  @ApiModelProperty(value = "平台设备主键")
+  private String deviceId;
+
+  @ApiModelProperty(value = "生产厂商")
+  private String manufacturer;
+
+  @ApiModelProperty(value = "型号")
+  private String model;
+
+  @ApiModelProperty(value = "设备归属")
+  private String owner;
+
+  @ApiModelProperty(value = "行政区域")
+  private String civilCode;
+
+  /** 警区 */
+  @ApiModelProperty("警区")
+  private String block;
+
+  /** 安装地址 */
+  @ApiModelProperty("安装地址")
+  private String address;
+
+  @ApiModelProperty(value = "是否有子设备:0没有 1有")
+  private Integer parental;
+
+  @ApiModelProperty(value = "信令安全模式缺省为0; 0:不采用;2:S/MIME 签名方式;3:S/\n" + "MIME加密签名同时采用方式;4:数字摘要方式")
+  private Integer safetyWay;
+
+  @ApiModelProperty(
+      value = "注册方式缺省为1;1:符合IETFRFC3261标准的认证注册模\n" + "式;2:基于口令的双向认证注册模式;3:基于数字证书的双向认证注册模式")
+  private Integer registerWay;
+
+  @ApiModelProperty(value = "证书序列号")
+  private String certNum;
+
+  @ApiModelProperty(value = "证书有效标识(有证书的设备必选)缺省为0;证书有效标识:0:无效 1:有效")
+  private Integer certifiable;
+
+  @ApiModelProperty(value = "无效原因码")
+  private Integer errorCode;
+
+  @ApiModelProperty(value = "证书终止有效期")
+  private LocalDateTime endTime;
+
+  @ApiModelProperty(value = "保密属性缺省为0;0:不涉密,1:涉密")
+  private Integer secrecy;
+
+  @ApiModelProperty(value = "系统IP地址")
+  private String ipAddress;
+
+  @ApiModelProperty(value = "端口")
+  private Integer port;
+
+  @ApiModelProperty(value = "密码")
+  private String password;
+
+  @ApiModelProperty(value = "通道状态")
+  private StatusEnum status;
+
+  @ApiModelProperty(value = "云台类型")
+  private int PTZType;
+
+  @ApiModelProperty(value = "云台类型描述字符串")
+  private String PTZTypeText;
+
+  @ApiModelProperty(value = "经度")
+  private double longitude;
+
+  @ApiModelProperty(value = "纬度")
+  private double latitude;
+
+  @ApiModelProperty(value = "GCJ02坐标系经度")
+  private double longitudeGcj02;
+
+  @ApiModelProperty(value = "GCJ02坐标系纬度")
+  private double latitudeGcj02;
+
+  @ApiModelProperty(value = "WGS84坐标系经度")
+  private double longitudeWgs84;
+
+  @ApiModelProperty(value = "WGS84坐标系纬度")
+  private double latitudeWgs84;
+
+  @ApiModelProperty(value = "子设备数")
+  private int subCount;
+
+  @ApiModelProperty(value = "流唯一编号，存在表示正在直播")
+  private String streamId;
+
+  @ApiModelProperty(value = "是否含有音频")
+  private boolean hasAudio;
+
+  @ApiModelProperty(value = "标记通道的类型，0->国标通道 1->直播流通道 2->业务分组/虚拟组织/行政区划")
+  private int channelType;
+
+  public void setPTZType(int PTZType) {
+    this.PTZType = PTZType;
+    switch (PTZType) {
+      case 0:
+        this.PTZTypeText = "未知";
+        break;
+      case 1:
+        this.PTZTypeText = "球机";
+        break;
+      case 2:
+        this.PTZTypeText = "半球";
+        break;
+      case 3:
+        this.PTZTypeText = "固定枪机";
+        break;
+      case 4:
+        this.PTZTypeText = "遥控枪机";
+        break;
+    }
+  }
+}

+package org.thingsboard.server.common.data.yunteng.dto.sip;
+
+public class ZLMServerConfigDTO {}

+package org.thingsboard.server.common.data.yunteng.dto.sip.cache;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+@Data
+public class CacheMediaServerLoadDTO {
+  @ApiModelProperty(value = "流媒体ID")
+  private String key;
+
+  @ApiModelProperty(value = "流媒体的负载值")
+  private AtomicInteger load;
+}

+package org.thingsboard.server.common.data.yunteng.dto.sip.hook;
+
+import java.text.ParseException;
+public interface ChannelOnlineEvent {
+    void run(String app, String stream, String serverId) throws ParseException;
+}

+package org.thingsboard.server.common.data.yunteng.dto.sip.hook;
+
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import org.thingsboard.server.common.data.yunteng.enums.HookTypeEnum;
+
+import java.time.LocalDateTime;
+
+/**
+ * zlm hook事件的参数
+ * @author lin
+ */
+public interface IHookSubscribe {
+
+    /**
+     * 获取hook类型
+     * @return hook类型
+     */
+    HookTypeEnum getHookType();
+
+    /**
+     * 获取hook的具体内容
+     * @return hook的具体内容
+     */
+    ObjectNode getContent();
+
+    /**
+     * 设置过期时间
+     * @param expiresDateTime 过期时间
+     */
+    void setExpires(LocalDateTime expiresDateTime);
+
+    /**
+     * 获取过期时间
+     * @return 过期时间
+     */
+    LocalDateTime getExpires();
+}

+package org.thingsboard.server.common.data.yunteng.dto.sip.hook;
+
+import lombok.Data;
+
+@Data
+public class OtherPsSendInfo {
+
+  /** 发流IP */
+  private String sendLocalIp;
+
+  /** 发流端口 */
+  private int sendLocalPort;
+
+  /** 收流IP */
+  private String receiveIp;
+
+  /** 收流端口 */
+  private int receivePort;
+
+  /** 会话ID */
+  private String callId;
+
+  /** 流ID */
+  private String stream;
+
+  /** 推流应用名 */
+  private String pushApp;
+
+  /** 推流流ID */
+  private String pushStream;
+
+  /** 推流SSRC */
+  private String pushSSRC;
+
+  @Override
+  public String toString() {
+    return "OtherPsSendInfo{"
+        + "sendLocalIp='"
+        + sendLocalIp
+        + '\''
+        + ", sendLocalPort="
+        + sendLocalPort
+        + ", receiveIp='"
+        + receiveIp
+        + '\''
+        + ", receivePort="
+        + receivePort
+        + ", callId='"
+        + callId
+        + '\''
+        + ", stream='"
+        + stream
+        + '\''
+        + ", pushApp='"
+        + pushApp
+        + '\''
+        + ", pushStream='"
+        + pushStream
+        + '\''
+        + ", pushSSRC='"
+        + pushSSRC
+        + '\''
+        + '}';
+  }
+}

+package org.thingsboard.server.common.data.yunteng.dto.sip.hook;
+
+import lombok.Data;
+
+@Data
+public class OtherRtpSendInfo {
+
+  /** 发流IP */
+  private String sendLocalIp;
+
+  /** 音频发流端口 */
+  private int sendLocalPortForAudio;
+
+  /** 视频发流端口 */
+  private int sendLocalPortForVideo;
+
+  /** 收流IP */
+  private String receiveIp;
+
+  /** 音频收流端口 */
+  private int receivePortForAudio;
+
+  /** 视频收流端口 */
+  private int receivePortForVideo;
+
+  /** 会话ID */
+  private String callId;
+
+  /** 流ID */
+  private String stream;
+
+  /** 推流应用名 */
+  private String pushApp;
+
+  /** 推流流ID */
+  private String pushStream;
+
+  /** 推流SSRC */
+  private String pushSSRC;
+
+  @Override
+  public String toString() {
+    return "OtherRtpSendInfo{"
+        + "sendLocalIp='"
+        + sendLocalIp
+        + '\''
+        + ", sendLocalPortForAudio="
+        + sendLocalPortForAudio
+        + ", sendLocalPortForVideo="
+        + sendLocalPortForVideo
+        + ", receiveIp='"
+        + receiveIp
+        + '\''
+        + ", receivePortForAudio="
+        + receivePortForAudio
+        + ", receivePortForVideo="
+        + receivePortForVideo
+        + ", callId='"
+        + callId
+        + '\''
+        + ", stream='"
+        + stream
+        + '\''
+        + ", pushApp='"
+        + pushApp
+        + '\''
+        + ", pushStream='"
+        + pushStream
+        + '\''
+        + ", pushSSRC='"
+        + pushSSRC
+        + '\''
+        + '}';
+  }
+}

+package org.thingsboard.server.common.data.yunteng.dto.sip.hook;
+
+import lombok.Data;
+import org.thingsboard.server.common.data.yunteng.dto.sip.hook.param.BaseParam;
+import org.thingsboard.server.common.data.yunteng.dto.sip.hook.param.OnStreamChangedHookParam;
+
+/** 流的鉴权信息 */
+@Data
+public class StreamAuthorityInfo {
+
+  private String id;
+  private String app;
+  private String stream;
+
+  /**
+   * 产生源类型， unknown = 0, rtmp_push=1, rtsp_push=2, rtp_push=3, pull=4, ffmpeg_pull=5, mp4_vod=6,
+   * device_chn=7
+   */
+  private int originType;
+
+  /** 产生源类型的字符串描述 */
+  private String originTypeStr;
+
+  /** 推流时自定义的播放鉴权ID */
+  private String callId;
+
+  /** 推流的鉴权签名 */
+  private String sign;
+
+  public static StreamAuthorityInfo getInstanceByHook(BaseParam hookParam) {
+    StreamAuthorityInfo streamAuthorityInfo = new StreamAuthorityInfo();
+    streamAuthorityInfo.setApp(hookParam.getApp());
+    streamAuthorityInfo.setStream(hookParam.getStream());
+    streamAuthorityInfo.setId(hookParam.getId());
+    return streamAuthorityInfo;
+  }
+
+  public static StreamAuthorityInfo getInstanceByHook(
+      OnStreamChangedHookParam onStreamChangedHookParam) {
+    StreamAuthorityInfo streamAuthorityInfo = new StreamAuthorityInfo();
+    streamAuthorityInfo.setApp(onStreamChangedHookParam.getApp());
+    streamAuthorityInfo.setStream(onStreamChangedHookParam.getStream());
+    streamAuthorityInfo.setId(onStreamChangedHookParam.getMediaServerId());
+    streamAuthorityInfo.setOriginType(onStreamChangedHookParam.getOriginType());
+    streamAuthorityInfo.setOriginTypeStr(onStreamChangedHookParam.getOriginTypeStr());
+    return streamAuthorityInfo;
+  }
+}

+package org.thingsboard.server.common.data.yunteng.dto.sip.hook.param;
+
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import lombok.Data;
+import org.thingsboard.server.common.data.yunteng.dto.sip.hook.IHookSubscribe;
+import org.thingsboard.server.common.data.yunteng.enums.HookTypeEnum;
+
+import java.time.LocalDateTime;
+
+@Data
+public class BaseHookSubscribe implements IHookSubscribe {
+  protected HookTypeEnum hookType;
+  protected ObjectNode content;
+  protected LocalDateTime expires;
+}

+package org.thingsboard.server.common.data.yunteng.dto.sip.hook.param;
+
+import lombok.Data;
+
+@Data
+public class BaseParam {
+  /** TCP链接唯一ID */
+  private String id;
+  /** 流应用名 */
+  private String app;
+  /** 流ID */
+  private String stream;
+  /** 播放器ip */
+  private String ip;
+  /** 播放url参数 */
+  private String params;
+  /** 播放器端口号 */
+  private int port;
+  /** 播放的协议: rtsp、rtmp、http */
+  private String schema;
+  /** 流虚拟主机 */
+  private String vhost;
+  /** 服务器id,通过配置文件设置 */
+  private String mediaServerId;
+
+  @Override
+  public String toString() {
+    return String.format("%s://%s:%s/%s/%s?%s", schema, ip, port, app, stream, params);
+  }
+}

+package org.thingsboard.server.common.data.yunteng.dto.sip.hook.param;
+
+import lombok.Data;
+
+/**
+ * zlm hook事件的参数
+ */
+@Data
+public class HookParam {
+    /**
+     * 服务器id,通过配置文件设置
+     */
+    private String mediaServerId;
+}

+package org.thingsboard.server.common.data.yunteng.dto.sip.hook.param;
+
+import lombok.Data;
+import org.thingsboard.server.common.data.StringUtils;
+
+import java.io.Serializable;
+
+@Data
+public class HookResult implements Serializable {
+
+  /** 错误代码，0代表允许播放 */
+  private int code;
+  /** 不允许播放时的错误提示 */
+  private String msg;
+
+  public HookResult() {}
+
+  public HookResult(int code, String msg) {
+    this.code = code;
+    this.msg = msg;
+  }
+
+  public static HookResult SUCCESS() {
+    return new HookResult(0, "success");
+  }
+
+  public static HookResult Fail(int code, String message) {
+    if (StringUtils.isEmpty(message)) {
+      message = "fail";
+    }
+    return new HookResult(code, message);
+  }
+}

+package org.thingsboard.server.common.data.yunteng.dto.sip.hook.param;
+
+import lombok.Data;
+
+@Data
+public class HookResultForOnPublish extends HookResult {
+
+  /** 转协议时是否开启音频 */
+  private boolean enableAudio;
+  /** 是否允许mp4录制 */
+  private boolean enableMp4;
+  /** mp4录制切片大小，单位秒 */
+  private int mp4MaxSecond;
+  /** mp4录制文件保存根目录，置空使用默认 */
+  private String mp4SavePath;
+
+  public static HookResultForOnPublish SUCCESS() {
+    return new HookResultForOnPublish(0, "success");
+  }
+
+  public HookResultForOnPublish(int code, String msg) {
+    setCode(code);
+    setMsg(msg);
+  }
+
+  @Override
+  public String toString() {
+    return "HookResultForOnPublish{"
+        + "enable_audio="
+        + enableAudio
+        + ", enable_mp4="
+        + enableMp4
+        + ", mp4_max_second="
+        + mp4MaxSecond
+        + ", mp4_save_path='"
+        + mp4SavePath
+        + '\''
+        + '}';
+  }
+}

+package org.thingsboard.server.common.data.yunteng.dto.sip.hook.param;
+
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.thingsboard.server.common.data.yunteng.enums.HookTypeEnum;
+import org.thingsboard.server.common.data.yunteng.utils.JacksonUtil;
+
+/** hook订阅-收流超时 */
+@EqualsAndHashCode(callSuper = true)
+@Data
+public class HookSubscribeForRtpServerTimeout extends BaseHookSubscribe {
+  private HookTypeEnum hookType = HookTypeEnum.ON_RTP_SERVER_TIMEOUT;
+  public HookSubscribeForRtpServerTimeout(String stream, String ssrc, String mediaServerId) {
+    ObjectNode param = JacksonUtil.newObjectNode();
+    param.put("stream_id", stream);
+    param.put("ssrc", ssrc);
+    param.put("mediaServerId", mediaServerId);
+    this.content = param;
+  }
+}

+package org.thingsboard.server.common.data.yunteng.dto.sip.hook.param;
+
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.thingsboard.server.common.data.yunteng.enums.HookTypeEnum;
+import org.thingsboard.server.common.data.yunteng.utils.JacksonUtil;
+
+/** hook订阅-流变化 */
+@EqualsAndHashCode(callSuper = true)
+@Data
+public class HookSubscribeForServerStarted extends BaseHookSubscribe {
+  private HookTypeEnum hookType = HookTypeEnum.ON_SERVER_STARTED;
+
+  public HookSubscribeForServerStarted() {
+    this.content = JacksonUtil.newObjectNode();
+  }
+}

+package org.thingsboard.server.common.data.yunteng.dto.sip.hook.param;
+
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.thingsboard.server.common.data.yunteng.enums.HookTypeEnum;
+import org.thingsboard.server.common.data.yunteng.utils.JacksonUtil;
+
+/**
+ * 流改变时
+ */
+@EqualsAndHashCode(callSuper = true)
+@Data
+public class HookSubscribeForStreamChange extends BaseHookSubscribe {
+
+  private HookTypeEnum hookType = HookTypeEnum.ON_STREAM_CHANGED;
+
+  public HookSubscribeForStreamChange(
+      String app, String stream, boolean regist, String schema, String mediaServerId) {
+    ObjectNode objectNode = JacksonUtil.newObjectNode();
+    objectNode.put("app", app);
+    objectNode.put("stream", stream);
+    objectNode.put("regist", regist);
+    if (schema != null) {
+      objectNode.put("schema", schema);
+    }
+    objectNode.put("mediaServerId", mediaServerId);
+    this.content = objectNode;
+  }
+}

+package org.thingsboard.server.common.data.yunteng.dto.sip.hook.param;
+
+import lombok.Data;
+
+/**
+ * 调用openRtpServer 接口，rtp server 长时间未收到数据,执行此web hook,对回复不敏感
+ */
+@Data
+public class OnRtpServerTimeoutHookParam extends HookParam {
+  private int localPort;
+  private String streamId;
+  private int tcpMode;
+  private boolean reUsePort;
+  private String ssrc;
+}

+package org.thingsboard.server.common.data.yunteng.dto.sip.hook.param;
+
+import lombok.Data;
+
+/** zlm hook事件中的on_send_rtp_stopped事件的参数 */
+@Data
+public class OnSendRtpStoppedHookParam extends HookParam {
+  /** 流应用名 */
+  private String app;
+  /** 流ID */
+  private String stream;
+}

+package org.thingsboard.server.common.data.yunteng.dto.sip.hook.param;
+
+/**
+ * zlm hook事件中的on_server_keepalive事件的参数
+ */
+public class OnServerKeepaliveHookParam extends HookParam{
+
+}

+package org.thingsboard.server.common.data.yunteng.dto.sip.hook.param;
+
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.thingsboard.server.common.data.yunteng.dto.sip.StreamContentDTO;
+
+import java.util.List;
+
+/** rtsp/rtmp流注册或注销时触发此事件；此事件对回复不敏感 */
+@EqualsAndHashCode(callSuper = true)
+@Data
+public class OnStreamChangedHookParam extends HookParam {
+
+  /** 注册/注销 */
+  private boolean regist;
+
+  /** 应用名 */
+  private String app;
+
+  /** 流id */
+  private String stream;
+
+  /** 推流鉴权Id */
+  private String callId;
+
+  /** 观看总人数，包括hls/rtsp/rtmp/http-flv/ws-flv */
+  private String totalReaderCount;
+
+  /** 协议 包括hls/rtsp/rtmp/http-flv/ws-flv */
+  private String schema;
+
+  /**
+   * 产生源类型， unknown = 0, rtmp_push=1, rtsp_push=2, rtp_push=3, pull=4, ffmpeg_pull=5, mp4_vod=6,
+   * device_chn=7
+   */
+  private int originType;
+
+  /** 客户端和服务器网络信息，可能为null类型 */
+  private OriginSock originSock;
+
+  /** 产生源类型的字符串描述 */
+  private String originTypeStr;
+
+  /** 产生源的url */
+  private String originUrl;
+
+  /** 服务器id */
+  private String severId;
+
+  /** GMT unix系统时间戳，单位秒 */
+  private Long createStamp;
+
+  /** 存活时间，单位秒 */
+  private Long aliveSecond;
+
+  /** 数据产生速度，单位byte/s */
+  private Long bytesSpeed;
+
+  /** 音视频轨道 */
+  private List<MediaTrack> tracks;
+
+  /** 音视频轨道 */
+  private String vhost;
+
+  /** 是否是docker部署， docker部署不会自动更新zlm使用的端口，需要自己手动修改 */
+  private boolean docker;
+
+  @Data
+  public static class MediaTrack {
+    /** 音频通道数 */
+    private int channels;
+
+    /** H264 = 0, H265 = 1, AAC = 2, G711A = 3, G711U = 4 */
+    private int codecId;
+
+    /** 编码类型名称 CodecAAC CodecH264 */
+    private String codecIdName;
+
+    /** Video = 0, Audio = 1 */
+    private int codecType;
+
+    /** 轨道是否准备就绪 */
+    private boolean ready;
+
+    /** 音频采样位数 */
+    private int sampleBit;
+
+    /** 音频采样率 */
+    private int sampleRate;
+
+    /** 视频fps */
+    private int fps;
+
+    /** 视频高 */
+    private int height;
+
+    /** 视频宽 */
+    private int width;
+  }
+
+  @Data
+  public static class OriginSock {
+    private String identifier;
+    private String local_ip;
+    private int local_port;
+    private String peer_ip;
+    private int peer_port;
+  }
+
+  private StreamContentDTO streamInfo;
+}

+package org.thingsboard.server.common.data.yunteng.dto.sip.hook.param;
+
+import lombok.Data;
+
+@Data
+public class OnStreamNoneReaderHookParam extends HookParam {
+  private String schema;
+  private String app;
+  private String stream;
+  private String vhost;
+}

+package org.thingsboard.server.common.data.yunteng.dto.sip.hook.param;
+
+/**
+ * zlm hook事件中的on_stream_not_found事件的参数
+ * @author lin
+ */
+public class OnStreamNotFoundHookParam extends HookParam{
+    private String id;
+    private String app;
+    private String stream;
+    private String ip;
+    private String params;
+    private int port;
+    private String schema;
+    private String vhost;
+
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    public String getApp() {
+        return app;
+    }
+
+    public void setApp(String app) {
+        this.app = app;
+    }
+
+    public String getStream() {
+        return stream;
+    }
+
+    public void setStream(String stream) {
+        this.stream = stream;
+    }
+
+    public String getIp() {
+        return ip;
+    }
+
+    public void setIp(String ip) {
+        this.ip = ip;
+    }
+
+    public String getParams() {
+        return params;
+    }
+
+    public void setParams(String params) {
+        this.params = params;
+    }
+
+    public int getPort() {
+        return port;
+    }
+
+    public void setPort(int port) {
+        this.port = port;
+    }
+
+    public String getSchema() {
+        return schema;
+    }
+
+    public void setSchema(String schema) {
+        this.schema = schema;
+    }
+
+    public String getVhost() {
+        return vhost;
+    }
+
+    public void setVhost(String vhost) {
+        this.vhost = vhost;
+    }
+
+    @Override
+    public String toString() {
+        return String.format("%s://%s:%s/%s/%s?%s", schema, ip, port, app, stream, params);
+    }
+}

+package org.thingsboard.server.common.data.yunteng.enums;
+
+public enum CatalogDataStatusEnum {
+    READY, RUNING, END
+}

+package org.thingsboard.server.common.data.yunteng.enums;
+
+public enum HookTypeEnum {
+  /** 流量统计事件，播放器或推流器断开时并且耗用流量超过特定阈值时会触发此事件，阈值通过配置文件 */
+  ON_FLOW_REPORT,
+  /** 访问http文件服务器上hls之外的文件时触发 */
+  ON_HTTP_ACCESS,
+  /**
+   * 播放器鉴权事件，rtsp/rtmp/http-flv/ws-flv/hls的播放都将触发此鉴权事件；
+   * 如果流不存在，那么先触发on_play事件然后触发on_stream_not_found事件。
+   * 播放rtsp流时，如果该流启动了rtsp专属鉴权(on_rtsp_realm)那么将不再触发on_play事件
+   */
+  ON_PLAY,
+  /** rtsp/rtmp/rtp推流鉴权事件 */
+  ON_PUBLISH,
+  /** 录制mp4完成后通知事件；此事件对回复不敏感 */
+  ON_RECORD_MP4,
+  /** rtsp专用的鉴权事件，先触发on_rtsp_realm事件然后才会触发on_rtsp_auth事件 */
+  ON_RTSP_AUTH,
+  /**
+   * 该rtsp流是否开启rtsp专用方式的鉴权事件，开启后才会触发on_rtsp_auth事件。
+   *
+   * <p>需要指出的是rtsp也支持url参数鉴权，它支持两种方式鉴权
+   */
+  ON_RTSP_REALM,
+  /**
+   * shell登录鉴权，ZLMediaKit提供简单的telnet调试方式
+   *
+   * <p>使用telnet 127.0.0.1 9000能进入MediaServer进程的shell界面
+   */
+  ON_SHELL_LOGIN,
+  /** rtsp/rtmp流注册或注销时触发此事件；此事件对回复不敏感 */
+  ON_STREAM_CHANGED,
+  /**
+   * 流无人观看时事件，用户可以通过此事件选择是否关闭无人看的流。
+   * 一个直播流注册上线了，如果一直没人观看也会触发一次无人观看事件，触发时的协议schema是随机的，看哪种协议最晚注册(一般为hls)。
+   * 后续从有人观看转为无人观看，触发协议schema为最后一名观看者使用何种协议。
+   * 目前mp4/hls录制不当做观看人数(mp4录制可以通过配置文件mp4_as_player控制，但是rtsp/rtmp/rtp转推算观看人数，也会触发该事件
+   */
+  ON_STREAM_NONE_READER,
+  /** 流未找到事件，用户可以在此事件触发时，立即去拉流，这样可以实现按需拉流；此事件对回复不敏感 */
+  ON_STREAM_NOT_FOUND,
+  /** 服务器启动事件，可以用于监听服务器崩溃重启；此事件对回复不敏感 */
+  ON_SERVER_STARTED,
+  /** 调用openRtpServer 接口，rtp server 长时间未收到数据,执行此web hook,对回复不敏感 */
+  ON_RTP_SERVER_TIMEOUT,
+  /** 服务器定时上报时间，上报间隔可配置，默认10s上报一次 */
+  ON_SERVER_KEEPALIVE,
+  /** 发送rtp(startSendRtp)被动关闭时回调 */
+  ON_SEND_RTP_STOPPED
+}

+package org.thingsboard.server.common.data.yunteng.enums;
+
+public enum InviteStreamTypeEnum {
+  PLAY,
+  PLAYBACK,
+  PUSH,
+  PROXY,
+  CLOUD_RECORD_PUSH,
+  CLOUD_RECORD_PROXY
+}

+package org.thingsboard.server.common.data.yunteng.enums;
+
+public enum OriginTypeEnum {
+    // 不可调整顺序
+    UNKNOWN("UNKNOWN"),
+    RTMP_PUSH("PUSH"),
+    RTSP_PUSH("PUSH"),
+    RTP_PUSH("RTP"),
+    PULL("PULL"),
+    FFMPEG_PULL("PULL"),
+    MP4_VOD("MP4_VOD"),
+    DEVICE_CHN("DEVICE_CHN"),
+    RTC_PUSH("PUSH");
+
+    private final String type;
+    OriginTypeEnum(String type) {
+        this.type = type;
+    }
+
+    public String getType() {
+        return type;
+    }
+}

+package org.thingsboard.server.common.data.yunteng.enums;
+
+import lombok.Getter;
+import lombok.Setter;
+
+/** 云台命令枚举 */
+@Getter
+public enum PTZCommandEnum {
+  LEFT("LEFT", 2),
+  RIGHT("RIGHT", 1),
+  UP("UP", 8),
+  DOWN("DOWN", 4),
+  UP_LEFT("UP_LEFT", 10),
+  UP_RIGHT("UP_RIGHT", 9),
+  DOWN_LEFT("DOWN_LEFT", 6),
+  DOWN_RIGHT("DOWN_RIGHT", 5),
+  ZOOM_IN("ZOOM_IN", 16),
+  ZOOM_OUT("ZOOM_OUT", 32),
+  STOP("STOP", 0);
+
+  private final String command;
+  private final Integer cmdCode;
+
+  PTZCommandEnum(String command, Integer cmdCode) {
+    this.command = command;
+    this.cmdCode = cmdCode;
+  }
+}

+package org.thingsboard.server.common.data.yunteng.enums;
+
+import lombok.Getter;
+import lombok.Setter;
+
+/** 云台类型 */
+public enum PTZTypeEnum {
+  UNKNOWN("未知", 0),
+  BALL("球机", 1),
+  HALFSPHERE("半球", 2),
+  LOCK_GUNLOCK("固定枪机", 3),
+  CONTROLL_GUNLOCK("遥控枪机", 4);
+
+  @Getter @Setter private String name;
+  @Getter @Setter private Integer index;
+
+  PTZTypeEnum(String name, Integer index) {
+    this.name = name;
+    this.index = index;
+  }
+
+  public static PTZTypeEnum getItem(Integer index) {
+    for (PTZTypeEnum item : values()) {
+      if (item.index == index) {
+        return item;
+      }
+    }
+    return UNKNOWN;
+  }
+}

+package org.thingsboard.server.common.data.yunteng.enums;
+
+public enum SessionTypeEnum {
+    PLAY,
+    PLAYBACK,
+    DOWNLOAD
+}

@@ -4,5 +4,6 @@ public enum TransportTypeEnum {
   DEFAULT,
   TCP,
   MQTT,
-  COAP
+  COAP,
+  GBT28181
 }

+package org.thingsboard.server.common.data.yunteng.enums;
+
+/** 视频流媒体平台指令类型:cmdType */
+public enum VideoCmdEnum {
+  Catalog,
+  DeviceControl,
+  Alarm,
+  Keepalive,
+  MediaStatus,
+  MobilePosition,
+  DeviceInfo,
+  DeviceStatus,
+  RecordInfo,
+  Broadcast,
+  ConfigDownload,
+  DeviceConfig,
+  PresetQuery
+}

+package org.thingsboard.server.common.data.yunteng.enums;
+
+/** 视频流媒体平台接口类型 ：method */
+public enum VideoMethodEnum {
+  REGISTER,
+  MESSAGE,
+  BYE,
+  CANCEL,
+  INVITE,
+  NOTIFY,
+  SUBSCRIBE,
+  INFO,
+  ACK
+}

+package org.thingsboard.server.common.data.yunteng.enums;
+
+/** 视频流媒体平台XML数据结构类型：messageType */
+public enum VideoXmlEnum {
+  Control,
+  Response,
+  Notify,
+  Query
+}