gb28181版本升级-补充

zhongrj

2023-06-27 2e98b20bea4463e4465e3c19059d0744a09aec06

 src/main/java/com/genersoft/iot/vmp/media/zlm/ZLMHttpHookListener.java

@@ -1,30 +1,28 @@
package com.genersoft.iot.vmp.media.zlm;

import java.util.ArrayList;
import java.text.ParseException;
import java.util.HashMap;
import java.util.List;
import java.util.UUID;
import java.util.Map;

import com.alibaba.fastjson.JSON;
import com.genersoft.iot.vmp.common.StreamInfo;
import com.genersoft.iot.vmp.conf.MediaConfig;
import com.genersoft.iot.vmp.conf.UserSetup;
import com.genersoft.iot.vmp.gb28181.bean.Device;
import com.genersoft.iot.vmp.gb28181.bean.DeviceChannel;
import com.genersoft.iot.vmp.gb28181.bean.GbStream;
import com.genersoft.iot.vmp.gb28181.bean.SsrcTransaction;
import com.genersoft.iot.vmp.conf.UserSetting;
import com.genersoft.iot.vmp.conf.exception.SsrcTransactionNotFoundException;
import com.genersoft.iot.vmp.gb28181.bean.*;
import com.genersoft.iot.vmp.gb28181.event.EventPublisher;
import com.genersoft.iot.vmp.gb28181.event.subscribe.catalog.CatalogEvent;
import com.genersoft.iot.vmp.gb28181.session.VideoStreamSessionManager;
import com.genersoft.iot.vmp.gb28181.transmit.cmd.impl.SIPCommanderFroPlatform;
import com.genersoft.iot.vmp.media.zlm.dto.*;
import com.genersoft.iot.vmp.service.*;
import com.genersoft.iot.vmp.service.bean.SSRCInfo;
import com.genersoft.iot.vmp.storager.IRedisCatchStorage;
import com.genersoft.iot.vmp.storager.IVideoManagerStorager;
import com.genersoft.iot.vmp.storager.IVideoManagerStorage;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.util.ObjectUtils;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
@@ -35,6 +33,8 @@
import com.genersoft.iot.vmp.gb28181.transmit.cmd.impl.SIPCommander;

import javax.servlet.http.HttpServletRequest;
import javax.sip.InvalidArgumentException;
import javax.sip.SipException;

/**    
 * @description:针对 ZLMediaServer的hook事件监听
@@ -51,13 +51,19 @@
   private SIPCommander cmder;

   @Autowired
   private SIPCommanderFroPlatform commanderFroPlatform;

   @Autowired
   private IPlayService playService;

   @Autowired
   private IVideoManagerStorager storager;
   private IVideoManagerStorage storager;

   @Autowired
   private IRedisCatchStorage redisCatchStorage;

   @Autowired
   private IDeviceService deviceService;

   @Autowired
   private IMediaServerService mediaServerService;
@@ -78,13 +84,23 @@
    private ZLMMediaListManager zlmMediaListManager;

   @Autowired
   private ZLMHttpHookSubscribe subscribe;
   private ZlmHttpHookSubscribe subscribe;

   @Autowired
   private UserSetup userSetup;
   private UserSetting userSetting;

   @Autowired
   private IUserService userService;

   @Autowired
   private VideoStreamSessionManager sessionManager;

   @Autowired
   private AssistRESTfulUtils assistRESTfulUtils;

   @Qualifier("taskExecutor")
   @Autowired
   private ThreadPoolTaskExecutor taskExecutor;

   /**
    * 服务器定时上报时间，上报间隔可配置，默认10s上报一次
@@ -92,24 +108,23 @@
    */
   @ResponseBody
   @PostMapping(value = "/on_server_keepalive", produces = "application/json;charset=UTF-8")
   public ResponseEntity<String> onServerKeepalive(@RequestBody JSONObject json){
   public JSONObject onServerKeepalive(@RequestBody JSONObject json){

      if (logger.isDebugEnabled()) {
         logger.debug("[ ZLM HOOK ]on_server_keepalive API调用，参数：" + json.toString());
      }
      logger.info("[ ZLM HOOK ]on_server_keepalive API调用，参数：" + json.toString());
      String mediaServerId = json.getString("mediaServerId");

      List<ZLMHttpHookSubscribe.Event> subscribes = this.subscribe.getSubscribes(ZLMHttpHookSubscribe.HookType.on_server_keepalive);
      List<ZlmHttpHookSubscribe.Event> subscribes = this.subscribe.getSubscribes(HookType.on_server_keepalive);
      if (subscribes != null  && subscribes.size() > 0) {
         for (ZLMHttpHookSubscribe.Event subscribe : subscribes) {
         for (ZlmHttpHookSubscribe.Event subscribe : subscribes) {
            subscribe.response(null, json);
         }
      }
      mediaServerService.updateMediaServerKeepalive(mediaServerId, json.getJSONObject("data"));

      JSONObject ret = new JSONObject();
      ret.put("code", 0);
      ret.put("msg", "success");
      return new ResponseEntity<String>(ret.toString(),HttpStatus.OK);

      return ret;
   }

   /**
@@ -118,16 +133,15 @@
    */
   @ResponseBody
   @PostMapping(value = "/on_flow_report", produces = "application/json;charset=UTF-8")
   public ResponseEntity<String> onFlowReport(@RequestBody JSONObject json){
   public JSONObject onFlowReport(@RequestBody JSONObject json){
      
      if (logger.isDebugEnabled()) {
         logger.debug("[ ZLM HOOK ]on_flow_report API调用，参数：" + json.toString());
      }
      String mediaServerId = json.getString("mediaServerId");
      JSONObject ret = new JSONObject();
      ret.put("code", 0);
      ret.put("msg", "success");
      return new ResponseEntity<String>(ret.toString(),HttpStatus.OK);
      return ret;
   }
   
   /**
@@ -136,7 +150,7 @@
    */
   @ResponseBody
   @PostMapping(value = "/on_http_access", produces = "application/json;charset=UTF-8")
   public ResponseEntity<String> onHttpAccess(@RequestBody JSONObject json){
   public JSONObject onHttpAccess(@RequestBody JSONObject json){
      
      if (logger.isDebugEnabled()) {
         logger.debug("[ ZLM HOOK ]on_http_access API 调用，参数：" + json.toString());
@@ -147,7 +161,7 @@
      ret.put("err", "");
      ret.put("path", "");
      ret.put("second", 600);
      return new ResponseEntity<String>(ret.toString(),HttpStatus.OK);
      return ret;
   }
   
   /**
@@ -156,24 +170,35 @@
    */
   @ResponseBody
   @PostMapping(value = "/on_play", produces = "application/json;charset=UTF-8")
   public ResponseEntity<String> onPlay(@RequestBody JSONObject json){
		
   public JSONObject onPlay(@RequestBody OnPlayHookParam param){

      JSONObject json = (JSONObject)JSON.toJSON(param);

      if (logger.isDebugEnabled()) {
         logger.debug("[ ZLM HOOK ]on_play API调用，参数：" + json.toString());
         logger.debug("[ ZLM HOOK ]on_play API调用，参数：" + JSON.toJSONString(param));
      }
      String mediaServerId = json.getString("mediaServerId");
      ZLMHttpHookSubscribe.Event subscribe = this.subscribe.getSubscribe(ZLMHttpHookSubscribe.HookType.on_play, json);
      String mediaServerId = param.getMediaServerId();
      ZlmHttpHookSubscribe.Event subscribe = this.subscribe.sendNotify(HookType.on_play, json);
      if (subscribe != null ) {
         MediaServerItem mediaInfo = mediaServerService.getOne(mediaServerId);
         if (mediaInfo != null) {
            subscribe.response(mediaInfo, json);
         }

      }
      JSONObject ret = new JSONObject();
      if (!"rtp".equals(param.getApp())) {
         Map<String, String> paramMap = urlParamToMap(param.getParams());
         StreamAuthorityInfo streamAuthorityInfo = redisCatchStorage.getStreamAuthorityInfo(param.getApp(), param.getStream());
         if (streamAuthorityInfo != null && streamAuthorityInfo.getCallId() != null && !streamAuthorityInfo.getCallId().equals(paramMap.get("callId"))) {
            ret.put("code", 401);
            ret.put("msg", "Unauthorized");
            return ret;
         }
      }

      ret.put("code", 0);
      ret.put("msg", "success");
      return new ResponseEntity<String>(ret.toString(),HttpStatus.OK);
      return ret;
   }
   
   /**
@@ -182,17 +207,65 @@
    */
   @ResponseBody
   @PostMapping(value = "/on_publish", produces = "application/json;charset=UTF-8")
   public ResponseEntity<String> onPublish(@RequestBody JSONObject json) {
   public JSONObject onPublish(@RequestBody OnPublishHookParam param) {

      JSONObject json = (JSONObject) JSON.toJSON(param);

      logger.info("[ ZLM HOOK ]on_publish API调用，参数：" + json.toString());
      JSONObject ret = new JSONObject();
      String mediaServerId = json.getString("mediaServerId");
      MediaServerItem mediaInfo = mediaServerService.getOne(mediaServerId);
      if (!"rtp".equals(param.getApp())) {
         // 推流鉴权
         if (param.getParams() == null) {
            logger.info("推流鉴权失败： 缺少不要参数：sign=md5(user表的pushKey)");
            ret.put("code", 401);
            ret.put("msg", "Unauthorized");
            return ret;
         }
         Map<String, String> paramMap = urlParamToMap(param.getParams());
         String sign = paramMap.get("sign");
         if (sign == null) {
            logger.info("推流鉴权失败： 缺少不要参数：sign=md5(user表的pushKey)");
            ret.put("code", 401);
            ret.put("msg", "Unauthorized");
            return ret;
         }
         // 推流自定义播放鉴权码
         String callId = paramMap.get("callId");
         // 鉴权配置
         boolean hasAuthority = userService.checkPushAuthority(callId, sign);
         if (!hasAuthority) {
            logger.info("推流鉴权失败： sign 无权限: callId={}. sign={}", callId, sign);
            ret.put("code", 401);
            ret.put("msg", "Unauthorized");
            return ret;
         }
         StreamAuthorityInfo streamAuthorityInfo = StreamAuthorityInfo.getInstanceByHook(param);
         streamAuthorityInfo.setCallId(callId);
         streamAuthorityInfo.setSign(sign);
         // 鉴权通过
         redisCatchStorage.updateStreamAuthorityInfo(param.getApp(), param.getStream(), streamAuthorityInfo);
         // 通知assist新的callId
         if (mediaInfo != null && mediaInfo.getRecordAssistPort() > 0) {
            taskExecutor.execute(()->{
               assistRESTfulUtils.addStreamCallInfo(mediaInfo, param.getApp(), param.getStream(), callId, null);
            });
         }
      }else {
         zlmMediaListManager.sendStreamEvent(param.getApp(),param.getStream(), param.getMediaServerId());
      }

      ret.put("code", 0);
      ret.put("msg", "success");
      ret.put("enable_hls", true);
      String mediaServerId = json.getString("mediaServerId");
      ZLMHttpHookSubscribe.Event subscribe = this.subscribe.getSubscribe(ZLMHttpHookSubscribe.HookType.on_publish, json);
      if (!"rtp".equals(param.getApp())) {
         ret.put("enable_audio", true);
      }


      ZlmHttpHookSubscribe.Event subscribe = this.subscribe.sendNotify(HookType.on_publish, json);
      if (subscribe != null) {
         MediaServerItem mediaInfo = mediaServerService.getOne(mediaServerId);
         if (mediaInfo != null) {
            subscribe.response(mediaInfo, json);
         }else {
@@ -200,14 +273,13 @@
            ret.put("msg", "zlm not register");
         }
      }
       String app = json.getString("app");
       String stream = json.getString("stream");
      if ("rtp".equals(app)) {
         ret.put("enable_mp4", userSetup.getRecordSip());

      if ("rtp".equals(param.getApp())) {
         ret.put("enable_mp4", userSetting.getRecordSip());
      }else {
         ret.put("enable_mp4", userSetup.isRecordPushLive());
         ret.put("enable_mp4", userSetting.isRecordPushLive());
      }
      List<SsrcTransaction> ssrcTransactionForAll = sessionManager.getSsrcTransactionForAll(null, null, null, stream);
      List<SsrcTransaction> ssrcTransactionForAll = sessionManager.getSsrcTransactionForAll(null, null, null, param.getStream());
      if (ssrcTransactionForAll != null && ssrcTransactionForAll.size() == 1) {
         String deviceId = ssrcTransactionForAll.get(0).getDeviceId();
         String channelId = ssrcTransactionForAll.get(0).getChannelId();
@@ -215,17 +287,26 @@
         if (deviceChannel != null) {
            ret.put("enable_audio", deviceChannel.isHasAudio());
         }
         // 如果是录像下载就设置视频间隔十秒
         if (ssrcTransactionForAll.get(0).getType() == VideoStreamSessionManager.SessionType.download) {
            ret.put("mp4_max_second", 10);
            ret.put("enable_mp4", true);
            ret.put("enable_audio", true);

         }
      }
      return new ResponseEntity<String>(ret.toString(), HttpStatus.OK);
      return ret;
   }
	



   /**
    * 录制mp4完成后通知事件；此事件对回复不敏感。
    *  
    */
   @ResponseBody
   @PostMapping(value = "/on_record_mp4", produces = "application/json;charset=UTF-8")
   public ResponseEntity<String> onRecordMp4(@RequestBody JSONObject json){
   public JSONObject onRecordMp4(@RequestBody JSONObject json){
      
      if (logger.isDebugEnabled()) {
         logger.debug("[ ZLM HOOK ]on_record_mp4 API调用，参数：" + json.toString());
@@ -234,7 +315,24 @@
      JSONObject ret = new JSONObject();
      ret.put("code", 0);
      ret.put("msg", "success");
      return new ResponseEntity<String>(ret.toString(),HttpStatus.OK);
      return ret;
   }
   /**
    * 录制hls完成后通知事件；此事件对回复不敏感。
    *
    */
   @ResponseBody
   @PostMapping(value = "/on_record_ts", produces = "application/json;charset=UTF-8")
   public JSONObject onRecordTs(@RequestBody JSONObject json){

      if (logger.isDebugEnabled()) {
         logger.debug("[ ZLM HOOK ]on_record_ts API调用，参数：" + json.toString());
      }
      String mediaServerId = json.getString("mediaServerId");
      JSONObject ret = new JSONObject();
      ret.put("code", 0);
      ret.put("msg", "success");
      return ret;
   }
   
   /**
@@ -243,7 +341,7 @@
    */
   @ResponseBody
   @PostMapping(value = "/on_rtsp_realm", produces = "application/json;charset=UTF-8")
   public ResponseEntity<String> onRtspRealm(@RequestBody JSONObject json){
   public JSONObject onRtspRealm(@RequestBody JSONObject json){
      
      if (logger.isDebugEnabled()) {
         logger.debug("[ ZLM HOOK ]on_rtsp_realm API调用，参数：" + json.toString());
@@ -252,7 +350,7 @@
      JSONObject ret = new JSONObject();
      ret.put("code", 0);
      ret.put("realm", "");
      return new ResponseEntity<String>(ret.toString(),HttpStatus.OK);
      return ret;
   }
   
   
@@ -262,7 +360,7 @@
    */
   @ResponseBody
   @PostMapping(value = "/on_rtsp_auth", produces = "application/json;charset=UTF-8")
   public ResponseEntity<String> onRtspAuth(@RequestBody JSONObject json){
   public JSONObject onRtspAuth(@RequestBody JSONObject json){
      
      if (logger.isDebugEnabled()) {
         logger.debug("[ ZLM HOOK ]on_rtsp_auth API调用，参数：" + json.toString());
@@ -272,7 +370,7 @@
      ret.put("code", 0);
      ret.put("encrypted", false);
      ret.put("passwd", "test");
      return new ResponseEntity<String>(ret.toString(),HttpStatus.OK);
      return ret;
   }
   
   /**
@@ -281,16 +379,13 @@
    */
   @ResponseBody
   @PostMapping(value = "/on_shell_login", produces = "application/json;charset=UTF-8")
   public ResponseEntity<String> onShellLogin(@RequestBody JSONObject json){
   public JSONObject onShellLogin(@RequestBody JSONObject json){
      
      if (logger.isDebugEnabled()) {
         logger.debug("[ ZLM HOOK ]on_shell_login API调用，参数：" + json.toString());
      }
      // TODO 如果是带有rtpstream则开启按需拉流
      // String app = json.getString("app");
      // String stream = json.getString("stream");
      String mediaServerId = json.getString("mediaServerId");
      ZLMHttpHookSubscribe.Event subscribe = this.subscribe.getSubscribe(ZLMHttpHookSubscribe.HookType.on_shell_login, json);
      ZlmHttpHookSubscribe.Event subscribe = this.subscribe.sendNotify(HookType.on_shell_login, json);
      if (subscribe != null ) {
         MediaServerItem mediaInfo = mediaServerService.getOne(mediaServerId);
         if (mediaInfo != null) {
@@ -302,7 +397,7 @@
      JSONObject ret = new JSONObject();
      ret.put("code", 0);
      ret.put("msg", "success");
      return new ResponseEntity<String>(ret.toString(),HttpStatus.OK);
      return ret;
   }
   
   /**
@@ -311,29 +406,44 @@
    */
   @ResponseBody
   @PostMapping(value = "/on_stream_changed", produces = "application/json;charset=UTF-8")
   public ResponseEntity<String> onStreamChanged(@RequestBody MediaItem item){
   public JSONObject onStreamChanged(@RequestBody MediaItem item){

      if (logger.isDebugEnabled()) {
         logger.debug("[ ZLM HOOK ]on_stream_changed API调用，参数：" + JSONObject.toJSONString(item));
      }
      logger.info("[ ZLM HOOK ]on_stream_changed API调用，参数：" + JSONObject.toJSONString(item));
      String mediaServerId = item.getMediaServerId();
      JSONObject json = (JSONObject) JSON.toJSON(item);
      ZLMHttpHookSubscribe.Event subscribe = this.subscribe.getSubscribe(ZLMHttpHookSubscribe.HookType.on_stream_changed, json);
      ZlmHttpHookSubscribe.Event subscribe = this.subscribe.sendNotify(HookType.on_stream_changed, json);
      if (subscribe != null ) {
         MediaServerItem mediaInfo = mediaServerService.getOne(mediaServerId);
         if (mediaInfo != null) {
            subscribe.response(mediaInfo, json);
         }

      }
      // 流消失移除redis play
      String app = item.getApp();
      String streamId = item.getStream();
      String stream = item.getStream();
      String schema = item.getSchema();
      List<MediaItem.MediaTrack> tracks = item.getTracks();
      boolean regist = item.isRegist();
      if ("rtmp".equals(schema)){
         logger.info("on_stream_changed：注册->{}, app->{}, stream->{}", regist, app, streamId);
      if (regist) {
         if (item.getOriginType() == OriginType.RTMP_PUSH.ordinal()
               || item.getOriginType() == OriginType.RTSP_PUSH.ordinal()
               || item.getOriginType() == OriginType.RTC_PUSH.ordinal()) {

            StreamAuthorityInfo streamAuthorityInfo = redisCatchStorage.getStreamAuthorityInfo(app, stream);
            if (streamAuthorityInfo == null) {
               streamAuthorityInfo = StreamAuthorityInfo.getInstanceByHook(item);
            }else {
               streamAuthorityInfo.setOriginType(item.getOriginType());
               streamAuthorityInfo.setOriginTypeStr(item.getOriginTypeStr());
            }
            redisCatchStorage.updateStreamAuthorityInfo(app, stream, streamAuthorityInfo);
         }
      }else {
         redisCatchStorage.removeStreamAuthorityInfo(app, stream);
      }

      if ("rtsp".equals(schema)){
         logger.info("on_stream_changed：注册->{}, app->{}, stream->{}", regist, app, stream);
         if (regist) {
            mediaServerService.addCount(mediaServerId);
         }else {
@@ -342,20 +452,19 @@
         if (item.getOriginType() == OriginType.PULL.ordinal()
               || item.getOriginType() == OriginType.FFMPEG_PULL.ordinal()) {
            // 设置拉流代理上线/离线
            streamProxyService.updateStatus(regist, app, streamId);
            streamProxyService.updateStatus(regist, app, stream);
         }
         if ("rtp".equals(app) && !regist ) {
            StreamInfo streamInfo = redisCatchStorage.queryPlayByStreamId(streamId);
            StreamInfo streamInfo = redisCatchStorage.queryPlayByStreamId(stream);
            if (streamInfo!=null){
               redisCatchStorage.stopPlay(streamInfo);
               storager.stopPlay(streamInfo.getDeviceID(), streamInfo.getChannelId());
            }else{
               streamInfo = redisCatchStorage.queryPlayback(null, null, streamId, null);
               streamInfo = redisCatchStorage.queryPlayback(null, null, stream, null);
               if (streamInfo != null) {
                  redisCatchStorage.stopPlayback(streamInfo.getDeviceID(), streamInfo.getChannelId(),
                        streamInfo.getStream(), null);
               }

            }
         }else {
            if (!"rtp".equals(app)){
@@ -364,52 +473,65 @@

               if (mediaServerItem != null){
                  if (regist) {
                     StreamPushItem streamPushItem = null;
                     StreamInfo streamInfoByAppAndStream = mediaService.getStreamInfoByAppAndStream(mediaServerItem, app, streamId, tracks);
                     StreamAuthorityInfo streamAuthorityInfo = redisCatchStorage.getStreamAuthorityInfo(app, stream);
                     String callId = null;
                     if (streamAuthorityInfo != null) {
                        callId = streamAuthorityInfo.getCallId();
                     }
                     StreamInfo streamInfoByAppAndStream = mediaService.getStreamInfoByAppAndStream(mediaServerItem,
                           app, stream, tracks, callId);
                     item.setStreamInfo(streamInfoByAppAndStream);

                     redisCatchStorage.addStream(mediaServerItem, type, app, streamId, item);
                     redisCatchStorage.addStream(mediaServerItem, type, app, stream, item);
                     if (item.getOriginType() == OriginType.RTSP_PUSH.ordinal()
                           || item.getOriginType() == OriginType.RTMP_PUSH.ordinal()
                           || item.getOriginType() == OriginType.RTC_PUSH.ordinal() ) {
                        streamPushItem = zlmMediaListManager.addPush(item);
                        item.setSeverId(userSetting.getServerId());
                        zlmMediaListManager.addPush(item);
                     }

                     List<GbStream> gbStreams = new ArrayList<>();
                     if (streamPushItem == null || streamPushItem.getGbId() == null) {
                        GbStream gbStream = storager.getGbStream(app, streamId);
                        gbStreams.add(gbStream);
                     }else {
                        if (streamPushItem.getGbId() != null) {
                           gbStreams.add(streamPushItem);
                        }
                     }
                     if (gbStreams.size() > 0) {
                        eventPublisher.catalogEventPublishForStream(null, gbStreams, CatalogEvent.ON);
                     }

                  }else {
                     // 兼容流注销时类型从redis记录获取
                     MediaItem mediaItem = redisCatchStorage.getStreamInfo(app, streamId, mediaServerId);
                     MediaItem mediaItem = redisCatchStorage.getStreamInfo(app, stream, mediaServerId);
                     if (mediaItem != null) {
                        type = OriginType.values()[mediaItem.getOriginType()].getType();
                        redisCatchStorage.removeStream(mediaServerItem.getId(), type, app, streamId);
                        redisCatchStorage.removeStream(mediaServerItem.getId(), type, app, stream);
                     }
                     GbStream gbStream = storager.getGbStream(app, streamId);
                     GbStream gbStream = storager.getGbStream(app, stream);
                     if (gbStream != null) {
                        eventPublisher.catalogEventPublishForStream(null, gbStream, CatalogEvent.OFF);
//                        eventPublisher.catalogEventPublishForStream(null, gbStream, CatalogEvent.OFF);
                     }
                     zlmMediaListManager.removeMedia(app, streamId);
                     zlmMediaListManager.removeMedia(app, stream);
                  }
                  if (type != null) {
                     // 发送流变化redis消息
                     JSONObject jsonObject = new JSONObject();
                     jsonObject.put("serverId", userSetup.getServerId());
                     jsonObject.put("serverId", userSetting.getServerId());
                     jsonObject.put("app", app);
                     jsonObject.put("stream", streamId);
                     jsonObject.put("stream", stream);
                     jsonObject.put("register", regist);
                     jsonObject.put("mediaServerId", mediaServerId);
                     redisCatchStorage.sendStreamChangeMsg(type, jsonObject);
                  }
               }
            }
         }
         if (!regist) {
            List<SendRtpItem> sendRtpItems = redisCatchStorage.querySendRTPServerByStream(stream);
            if (sendRtpItems.size() > 0) {
               for (SendRtpItem sendRtpItem : sendRtpItems) {
                  if (sendRtpItem.getApp().equals(app)) {
                     String platformId = sendRtpItem.getPlatformId();
                     ParentPlatform platform = storager.queryParentPlatByServerGBId(platformId);
                     Device device = deviceService.getDevice(platformId);

                     try {
                        if (platform != null) {
                           commanderFroPlatform.streamByeCmd(platform, sendRtpItem);
                        }else {
                           cmder.streamByeCmd(device, sendRtpItem.getChannelId(), stream, sendRtpItem.getCallId());
                        }
                     } catch (SipException | InvalidArgumentException | ParseException | SsrcTransactionNotFoundException e) {
                        logger.error("[命令发送失败] 国标级联 发送BYE: {}", e.getMessage());
                     }
                  }
               }
            }
@@ -419,7 +541,7 @@
      JSONObject ret = new JSONObject();
      ret.put("code", 0);
      ret.put("msg", "success");
      return new ResponseEntity<String>(ret.toString(),HttpStatus.OK);
      return ret;
   }
   
   /**
@@ -428,61 +550,108 @@
    */
   @ResponseBody
   @PostMapping(value = "/on_stream_none_reader", produces = "application/json;charset=UTF-8")
   public ResponseEntity<String> onStreamNoneReader(@RequestBody JSONObject json){
		
      if (logger.isDebugEnabled()) {
         logger.debug("[ ZLM HOOK ]on_stream_none_reader API调用，参数：" + json.toString());
      }
   public JSONObject onStreamNoneReader(@RequestBody JSONObject json){

      logger.info("[ ZLM HOOK ]on_stream_none_reader API调用，参数：" + json.toString());
      String mediaServerId = json.getString("mediaServerId");
      String streamId = json.getString("stream");
      String app = json.getString("app");
      JSONObject ret = new JSONObject();
      ret.put("code", 0);
      // 录像下载
      ret.put("close", userSetting.getStreamOnDemand());
      if ("rtp".equals(app)){
         ret.put("close", true);
         // 国标流， 点播/录像回放/录像下载
         StreamInfo streamInfoForPlayCatch = redisCatchStorage.queryPlayByStreamId(streamId);
         // 点播
         if (streamInfoForPlayCatch != null) {
            // 如果在给上级推流，也不停止。
            // 收到无人观看说明流也没有在往上级推送
            if (redisCatchStorage.isChannelSendingRTP(streamInfoForPlayCatch.getChannelId())) {
               ret.put("close", false);
            } else {
               cmder.streamByeCmd(streamInfoForPlayCatch.getDeviceID(), streamInfoForPlayCatch.getChannelId(),
                     streamInfoForPlayCatch.getStream(), null);
               redisCatchStorage.stopPlay(streamInfoForPlayCatch);
               storager.stopPlay(streamInfoForPlayCatch.getDeviceID(), streamInfoForPlayCatch.getChannelId());
            }
         }else{
            StreamInfo streamInfoForPlayBackCatch = redisCatchStorage.queryPlayback(null, null, streamId, null);
            if (streamInfoForPlayBackCatch != null) {
               cmder.streamByeCmd(streamInfoForPlayBackCatch.getDeviceID(),
                     streamInfoForPlayBackCatch.getChannelId(), streamInfoForPlayBackCatch.getStream(), null);
               redisCatchStorage.stopPlayback(streamInfoForPlayBackCatch.getDeviceID(),
                     streamInfoForPlayBackCatch.getChannelId(), streamInfoForPlayBackCatch.getStream(), null);
            }else {
               StreamInfo streamInfoForDownload = redisCatchStorage.queryDownload(null, null, streamId, null);
               // 进行录像下载时无人观看不断流
               if (streamInfoForDownload != null) {
                  ret.put("close", false);
               List<SendRtpItem> sendRtpItems = redisCatchStorage.querySendRTPServerByChnnelId(streamInfoForPlayCatch.getChannelId());
               if (sendRtpItems.size() > 0) {
                  for (SendRtpItem sendRtpItem : sendRtpItems) {
                     ParentPlatform parentPlatform = storager.queryParentPlatByServerGBId(sendRtpItem.getPlatformId());
                     try {
                        commanderFroPlatform.streamByeCmd(parentPlatform, sendRtpItem.getCallId());
                     } catch (SipException | InvalidArgumentException | ParseException e) {
                        logger.error("[命令发送失败] 国标级联 发送BYE: {}", e.getMessage());
                     }
                     redisCatchStorage.deleteSendRTPServer(parentPlatform.getServerGBId(), sendRtpItem.getChannelId(),
                           sendRtpItem.getCallId(), sendRtpItem.getStreamId());
                  }
               }
            }
            Device device = deviceService.getDevice(streamInfoForPlayCatch.getDeviceID());
            if (device != null) {
               try {
                  cmder.streamByeCmd(device, streamInfoForPlayCatch.getChannelId(),
                        streamInfoForPlayCatch.getStream(), null);
               } catch (InvalidArgumentException | ParseException | SipException | SsrcTransactionNotFoundException e) {
                  logger.error("[无人观看]点播， 发送BYE失败 {}", e.getMessage());
               }
            }

            redisCatchStorage.stopPlay(streamInfoForPlayCatch);
            storager.stopPlay(streamInfoForPlayCatch.getDeviceID(), streamInfoForPlayCatch.getChannelId());
            return ret;
         }
         MediaServerItem mediaServerItem = mediaServerService.getOne(mediaServerId);
         if (mediaServerItem != null && mediaServerItem.getStreamNoneReaderDelayMS() == -1) {
         // 录像回放
         StreamInfo streamInfoForPlayBackCatch = redisCatchStorage.queryPlayback(null, null, streamId, null);
         if (streamInfoForPlayBackCatch != null ) {
            if (streamInfoForPlayBackCatch.isPause()) {
               ret.put("close", false);
            }else {
               Device device = deviceService.getDevice(streamInfoForPlayBackCatch.getDeviceID());
               if (device != null) {
                  try {
                     cmder.streamByeCmd(device,streamInfoForPlayBackCatch.getChannelId(),
                           streamInfoForPlayBackCatch.getStream(), null);
                  } catch (InvalidArgumentException | ParseException | SipException |
                         SsrcTransactionNotFoundException e) {
                     logger.error("[无人观看]回放， 发送BYE失败 {}", e.getMessage());
                  }
               }
               redisCatchStorage.stopPlayback(streamInfoForPlayBackCatch.getDeviceID(),
                     streamInfoForPlayBackCatch.getChannelId(), streamInfoForPlayBackCatch.getStream(), null);
            }
            return ret;
         }
         // 录像下载
         StreamInfo streamInfoForDownload = redisCatchStorage.queryDownload(null, null, streamId, null);
         // 进行录像下载时无人观看不断流
         if (streamInfoForDownload != null) {
            ret.put("close", false);
            return ret;
         }
         return new ResponseEntity<String>(ret.toString(),HttpStatus.OK);
      }else {
         // 非国标流 推流/拉流代理
         // 拉流代理
         StreamProxyItem streamProxyItem = streamProxyService.getStreamProxyByAppAndStream(app, streamId);
         if (streamProxyItem != null && streamProxyItem.isEnable_remove_none_reader()) {
            ret.put("close", true);
            streamProxyService.del(app, streamId);
            String url = streamProxyItem.getUrl() != null?streamProxyItem.getUrl():streamProxyItem.getSrc_url();
            logger.info("[{}/{}]<-[{}] 拉流代理无人观看已经移除",  app, streamId, url);
         }else {
            ret.put("close", false);
         if (streamProxyItem != null ) {
            if (streamProxyItem.isEnable_remove_none_reader()) {
               // 无人观看自动移除
               ret.put("close", true);
               streamProxyService.del(app, streamId);
               String url = streamProxyItem.getUrl() != null?streamProxyItem.getUrl():streamProxyItem.getSrc_url();
               logger.info("[{}/{}]<-[{}] 拉流代理无人观看已经移除",  app, streamId, url);
            }else if (streamProxyItem.isEnable_disable_none_reader()) {
               // 无人观看停用
               ret.put("close", true);
               // 修改数据
               streamProxyService.stop(app, streamId);
            }else {
               ret.put("close", false);
            }
            return ret;
         }
         return new ResponseEntity<String>(ret.toString(),HttpStatus.OK);
         // 推流具有主动性，暂时不做处理
//         StreamPushItem streamPushItem = streamPushService.getPush(app, streamId);
//         if (streamPushItem != null) {
//            // TODO 发送停止
//
//         }
      }
      return ret;
   }
   
   /**
@@ -491,24 +660,32 @@
    */
   @ResponseBody
   @PostMapping(value = "/on_stream_not_found", produces = "application/json;charset=UTF-8")
   public ResponseEntity<String> onStreamNotFound(@RequestBody JSONObject json){
   public JSONObject onStreamNotFound(@RequestBody JSONObject json){
      if (logger.isDebugEnabled()) {
         logger.debug("[ ZLM HOOK ]on_stream_not_found API调用，参数：" + json.toString());
      }
      String mediaServerId = json.getString("mediaServerId");
      MediaServerItem mediaInfo = mediaServerService.getOne(mediaServerId);
      if (userSetup.isAutoApplyPlay() && mediaInfo != null && mediaInfo.isRtpEnable()) {
      if (userSetting.isAutoApplyPlay() && mediaInfo != null) {
         String app = json.getString("app");
         String streamId = json.getString("stream");
         if ("rtp".equals(app)) {
            String[] s = streamId.split("_");
            if (s.length == 2) {
               String deviceId = s[0];
               String channelId = s[1];
               Device device = redisCatchStorage.getDevice(deviceId);
               if (device != null) {
                  playService.play(mediaInfo,deviceId, channelId, null, null, null);
            if (mediaInfo.isRtpEnable()) {
               String[] s = streamId.split("_");
               if (s.length == 2) {
                  String deviceId = s[0];
                  String channelId = s[1];
                  Device device = redisCatchStorage.getDevice(deviceId);
                  if (device != null) {
                     playService.play(mediaInfo,deviceId, channelId, null, null, null);
                  }
               }
            }
         }else {
            // 拉流代理
            StreamProxyItem streamProxyByAppAndStream = streamProxyService.getStreamProxyByAppAndStream(app, streamId);
            if (streamProxyByAppAndStream != null && streamProxyByAppAndStream.isEnable_disable_none_reader()) {
               streamProxyService.start(app, streamId);
            }
         }
      }
@@ -516,7 +693,7 @@
      JSONObject ret = new JSONObject();
      ret.put("code", 0);
      ret.put("msg", "success");
      return new ResponseEntity<>(ret.toString(),HttpStatus.OK);
      return ret;
   }
   
   /**
@@ -525,22 +702,82 @@
    */
   @ResponseBody
   @PostMapping(value = "/on_server_started", produces = "application/json;charset=UTF-8")
   public ResponseEntity<String> onServerStarted(HttpServletRequest request, @RequestBody JSONObject jsonObject){
		
   public JSONObject onServerStarted(HttpServletRequest request, @RequestBody JSONObject jsonObject){

      if (logger.isDebugEnabled()) {
         logger.debug("[ ZLM HOOK ]on_server_started API调用，参数：" + jsonObject.toString());
      }
      String remoteAddr = request.getRemoteAddr();
      jsonObject.put("ip", remoteAddr);
      List<ZLMHttpHookSubscribe.Event> subscribes = this.subscribe.getSubscribes(ZLMHttpHookSubscribe.HookType.on_server_started);
      List<ZlmHttpHookSubscribe.Event> subscribes = this.subscribe.getSubscribes(HookType.on_server_started);
      if (subscribes != null  && subscribes.size() > 0) {
         for (ZLMHttpHookSubscribe.Event subscribe : subscribes) {
         for (ZlmHttpHookSubscribe.Event subscribe : subscribes) {
            subscribe.response(null, jsonObject);
         }
      }

      ZLMServerConfig zlmServerConfig = JSONObject.toJavaObject(jsonObject, ZLMServerConfig.class);
      if (zlmServerConfig !=null ) {
         mediaServerService.zlmServerOnline(zlmServerConfig);
      }
      JSONObject ret = new JSONObject();
      ret.put("code", 0);
      ret.put("msg", "success");
      return new ResponseEntity<String>(ret.toString(),HttpStatus.OK);
      return ret;
   }

   /**
    * 发送rtp(startSendRtp)被动关闭时回调
    */
   @ResponseBody
   @PostMapping(value = "/on_send_rtp_stopped", produces = "application/json;charset=UTF-8")
   public JSONObject onSendRtpStopped(HttpServletRequest request, @RequestBody JSONObject jsonObject){

      logger.info("[ ZLM HOOK ]on_send_rtp_stopped API调用，参数：" + jsonObject);

      JSONObject ret = new JSONObject();
      ret.put("code", 0);
      ret.put("msg", "success");

      // 查找对应的上级推流，发送停止
      String app = jsonObject.getString("app");
      if (!"rtp".equals(app)) {
         return ret;
      }
      String stream = jsonObject.getString("stream");
      List<SendRtpItem> sendRtpItems = redisCatchStorage.querySendRTPServerByStream(stream);
      if (sendRtpItems.size() > 0) {
         for (SendRtpItem sendRtpItem : sendRtpItems) {
            ParentPlatform parentPlatform = storager.queryParentPlatByServerGBId(sendRtpItem.getPlatformId());
            try {
               commanderFroPlatform.streamByeCmd(parentPlatform, sendRtpItem.getCallId());
            } catch (SipException | InvalidArgumentException | ParseException e) {
               logger.error("[命令发送失败] 国标级联 发送BYE: {}", e.getMessage());
            }
            redisCatchStorage.deleteSendRTPServer(parentPlatform.getServerGBId(), sendRtpItem.getChannelId(),
                  sendRtpItem.getCallId(), sendRtpItem.getStreamId());
         }
      }


      return ret;
   }

   private Map<String, String> urlParamToMap(String params) {
      HashMap<String, String> map = new HashMap<>();
      if (ObjectUtils.isEmpty(params)) {
         return map;
      }
      String[] paramsArray = params.split("&");
      if (paramsArray.length == 0) {
         return map;
      }
      for (String param : paramsArray) {
         String[] paramArray = param.split("=");
         if (paramArray.length == 2){
            map.put(paramArray[0], paramArray[1]);
         }
      }
      return map;
   }
}