InviteRequestProcessor类中，channelid从invite消息的header subject获取，不再从第一行request ...

李防

2022-03-07 335916f1f15eb9d0b34dea38cacee2300eac0606

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

@@ -1,20 +1,32 @@
package com.genersoft.iot.vmp.gb28181.transmit.event.request.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.genersoft.iot.vmp.common.StreamInfo;
import com.genersoft.iot.vmp.gb28181.bean.*;
import com.genersoft.iot.vmp.gb28181.event.SipSubscribe;
import com.genersoft.iot.vmp.gb28181.transmit.SIPProcessorObserver;
import com.genersoft.iot.vmp.gb28181.transmit.callback.RequestMessage;
import com.genersoft.iot.vmp.gb28181.transmit.cmd.ISIPCommander;
import com.genersoft.iot.vmp.gb28181.transmit.cmd.impl.SIPCommander;
import com.genersoft.iot.vmp.gb28181.transmit.cmd.impl.SIPCommanderFroPlatform;
import com.genersoft.iot.vmp.gb28181.transmit.event.request.ISIPRequestProcessor;
import com.genersoft.iot.vmp.gb28181.transmit.event.request.SIPRequestProcessorParent;
import com.genersoft.iot.vmp.gb28181.utils.SipUtils;
import com.genersoft.iot.vmp.media.zlm.ZLMHttpHookSubscribe;
import com.genersoft.iot.vmp.media.zlm.ZLMRTPServerFactory;
import com.genersoft.iot.vmp.media.zlm.dto.MediaServerItem;
import com.genersoft.iot.vmp.service.IMediaServerService;
import com.genersoft.iot.vmp.service.IPlayService;
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.vmanager.gb28181.play.bean.PlayResult;
import gov.nist.javax.sdp.TimeDescriptionImpl;
import gov.nist.javax.sdp.fields.TimeField;
import gov.nist.javax.sip.address.AddressImpl;
import gov.nist.javax.sip.address.SipUri;
import gov.nist.javax.sip.header.Subject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean;
@@ -27,16 +39,19 @@
import javax.sip.ServerTransaction;
import javax.sip.SipException;
import javax.sip.address.SipURI;
import javax.sip.header.CallIdHeader;
import javax.sip.header.FromHeader;
import javax.sip.header.Header;
import javax.sip.message.Request;
import javax.sip.message.Response;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.Vector;

/**    
 * @description:处理INVITE请求
 * @author: panll
 * @date:   2021年1月14日
/**
 * SIP命令类型： INVITE请求
 */
@SuppressWarnings("rawtypes")
@Component
@@ -62,6 +77,9 @@
   private IPlayService playService;

   @Autowired
   private ISIPCommander commander;

   @Autowired
   private ZLMRTPServerFactory zlmrtpServerFactory;

   @Autowired
@@ -69,6 +87,7 @@

   @Autowired
   private SIPProcessorObserver sipProcessorObserver;


   @Override
   public void afterPropertiesSet() throws Exception {
@@ -88,26 +107,26 @@
      try {
         Request request = evt.getRequest();
         SipURI sipURI = (SipURI) request.getRequestURI();
         String channelId = sipURI.getUser();
         String requesterId = null;

         FromHeader fromHeader = (FromHeader)request.getHeader(FromHeader.NAME);
         AddressImpl address = (AddressImpl) fromHeader.getAddress();
         SipUri uri = (SipUri) address.getURI();
         requesterId = uri.getUser();

         //从subject读取channelId,不再从request-line读取。 有些平台request-line是平台国标编码，不是设备国标编码。
         //String channelId = sipURI.getUser();
         String channelId = SipUtils.getChannelIdFromHeader(request);
         String requesterId = SipUtils.getUserIdFromFromHeader(request);
         CallIdHeader callIdHeader = (CallIdHeader)request.getHeader(CallIdHeader.NAME);
         if (requesterId == null || channelId == null) {
            logger.info("无法从FromHeader的Address中获取到平台id，返回400");
            responseAck(evt, Response.BAD_REQUEST); // 参数不全， 发400，请求错误
            return;
         }

         // 查询请求方是否上级平台
         // 查询请求是否来自上级平台\设备
         ParentPlatform platform = storager.queryParentPlatByServerGBId(requesterId);
         if (platform != null) {
         if (platform == null) {
            inviteFromDeviceHandle(evt, requesterId);
         }else {
            // 查询平台下是否有该通道
            DeviceChannel channel = storager.queryChannelInParentPlatform(requesterId, channelId);
            GbStream gbStream = storager.queryStreamInParentPlatform(requesterId, channelId);
            PlatformCatalog catalog = storager.getCatalog(channelId);
            MediaServerItem mediaServerItem = null;
            // 不是通道可能是直播流
            if (channel != null && gbStream == null ) {
@@ -122,7 +141,7 @@
               mediaServerItem = mediaServerService.getOne(mediaServerId);
               if (mediaServerItem == null) {
                  logger.info("[ app={}, stream={} ]找不到zlm {}，返回410",gbStream.getApp(), gbStream.getStream(), mediaServerId);
                  responseAck(evt, Response.GONE, "media server not found");
                  responseAck(evt, Response.GONE);
                  return;
               }
               Boolean streamReady = zlmrtpServerFactory.isStreamReady(mediaServerItem, gbStream.getApp(), gbStream.getStream());
@@ -132,7 +151,10 @@
                  return;
               }
               responseAck(evt, Response.CALL_IS_BEING_FORWARDED); // 通道存在，发181，呼叫转接中
            }else {
            }else if (catalog != null) {
               responseAck(evt, Response.BAD_REQUEST, "catalog channel can not play"); // 目录不支持点播
               return;
            } else {
               logger.info("通道不存在，返回404");
               responseAck(evt, Response.NOT_FOUND); // 通道不存在，发404，资源不存在
               return;
@@ -140,19 +162,41 @@
            // 解析sdp消息, 使用jainsip 自带的sdp解析方式
            String contentString = new String(request.getRawContent());

            // jainSip不支持y=字段， 移除移除以解析。
            // jainSip不支持y=字段， 移除以解析。
            int ssrcIndex = contentString.indexOf("y=");
            //ssrc规定长度为10字节，不取余下长度以避免后续还有“f=”字段
            String ssrc = contentString.substring(ssrcIndex + 2, ssrcIndex + 12);
            String substring = contentString.substring(0, contentString.indexOf("y="));
            SessionDescription sdp = SdpFactory.getInstance().createSessionDescription(substring);
            // 检查是否有y字段
            String ssrcDefault = "0000000000";
            String ssrc;
            SessionDescription sdp;
            if (ssrcIndex >= 0) {
               //ssrc规定长度为10字节，不取余下长度以避免后续还有“f=”字段
               ssrc = contentString.substring(ssrcIndex + 2, ssrcIndex + 12);
               String substring = contentString.substring(0, contentString.indexOf("y="));
               sdp = SdpFactory.getInstance().createSessionDescription(substring);
            }else {
               ssrc = ssrcDefault;
               sdp = SdpFactory.getInstance().createSessionDescription(contentString);
            }
            String sessionName = sdp.getSessionName().getValue();

            Long startTime = null;
            Long stopTime = null;
            Date start = null;
            Date end = null;
            if (sdp.getTimeDescriptions(false) != null && sdp.getTimeDescriptions(false).size() > 0) {
               TimeDescriptionImpl timeDescription = (TimeDescriptionImpl)(sdp.getTimeDescriptions(false).get(0));
               TimeField startTimeFiled = (TimeField)timeDescription.getTime();
               startTime = startTimeFiled.getStartTime();
               stopTime = startTimeFiled.getStopTime();

               start = new Date(startTime*1000);
               end = new Date(stopTime*1000);
            }
            //  获取支持的格式
            Vector mediaDescriptions = sdp.getMediaDescriptions(true);
            // 查看是否支持PS 负载96
            //String ip = null;
            int port = -1;
            //boolean recvonly = false;
            boolean mediaTransmissionTCP = false;
            Boolean tcpActive = null;
            for (Object description : mediaDescriptions) {
@@ -188,7 +232,6 @@
            }
            String username = sdp.getOrigin().getUsername();
            String addressStr = sdp.getOrigin().getAddress();
            //String sessionName = sdp.getSessionName().getValue();
            logger.info("[上级点播]用户：{}， 地址：{}:{}， ssrc：{}", username, addressStr, port, ssrc);
            Device device  = null;
            // 通过 channel 和 gbStream 是否为null 值判断来源是直播流合适国标
@@ -216,23 +259,33 @@
                  responseAck(evt, Response.BUSY_HERE);
                  return;
               }

               sendRtpItem.setCallId(callIdHeader.getCallId());
               sendRtpItem.setPlay("Play".equals(sessionName));
               // 写入redis， 超时时回复
               redisCatchStorage.updateSendRTPSever(sendRtpItem);
               // 通知下级推流，
               PlayResult playResult = playService.play(mediaServerItem,device.getDeviceId(), channelId, (mediaServerItemInUSe, responseJSON)->{
                  // 收到推流， 回复200OK, 等待ack
                  // if (sendRtpItem == null) return;

               Device finalDevice = device;
               MediaServerItem finalMediaServerItem = mediaServerItem;
               Long finalStartTime = startTime;
               Long finalStopTime = stopTime;
               ZLMHttpHookSubscribe.Event hookEvent = (mediaServerItemInUSe, responseJSON)->{
                  logger.info("[上级点播]下级已经开始推流。 回复200OK(SDP)， {}/{}", sendRtpItem.getApp(), sendRtpItem.getStreamId());
                  //     * 0 等待设备推流上来
                  //     * 1 下级已经推流，等待上级平台回复ack
                  //     * 2 推流中
                  sendRtpItem.setStatus(1);
                  redisCatchStorage.updateSendRTPSever(sendRtpItem);
                  // TODO 添加对tcp的支持

                  StringBuffer content = new StringBuffer(200);
                  content.append("v=0\r\n");
                  content.append("o="+ channelId +" 0 0 IN IP4 "+mediaServerItemInUSe.getSdpIp()+"\r\n");
                  content.append("s=Play\r\n");
                  content.append("s=" + sessionName+"\r\n");
                  content.append("c=IN IP4 "+mediaServerItemInUSe.getSdpIp()+"\r\n");
                  content.append("t=0 0\r\n");
                  if ("Playback".equals(sessionName)) {
                     content.append("t=" + finalStartTime + " " + finalStopTime + "\r\n");
                  }else {
                     content.append("t=0 0\r\n");
                  }
                  content.append("m=video "+ sendRtpItem.getLocalPort()+" RTP/AVP 96\r\n");
                  content.append("a=sendonly\r\n");
                  content.append("a=rtpmap:96 PS/90000\r\n");
@@ -240,7 +293,7 @@
                  content.append("f=\r\n");

                  try {
                     responseAck(evt, content.toString());
                     responseSdpAck(evt, content.toString(), platform);
                  } catch (SipException e) {
                     e.printStackTrace();
                  } catch (InvalidArgumentException e) {
@@ -248,7 +301,8 @@
                  } catch (ParseException e) {
                     e.printStackTrace();
                  }
               } ,((event) -> {
               };
               SipSubscribe.Event errorEvent = ((event) -> {
                  // 未知错误。直接转发设备点播的错误
                  Response response = null;
                  try {
@@ -259,11 +313,46 @@
                  } catch (ParseException | SipException | InvalidArgumentException e) {
                     e.printStackTrace();
                  }
               }));
               if (logger.isDebugEnabled()) {
                  logger.debug(playResult.getResult().toString());
               });
               if ("Playback".equals(sessionName)) {
                  sendRtpItem.setPlay(false);
                  sendRtpItem.setStreamId(ssrc);
                  SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                  playService.playBack(device.getDeviceId(), channelId, format.format(start), format.format(end),result -> {
                     if (result.getCode() != 0){
                        logger.warn("录像回放失败");
                        if (result.getEvent() != null) {
                           errorEvent.response(result.getEvent());
                        }
                        try {
                           responseAck(evt, Response.REQUEST_TIMEOUT);
                        } catch (SipException e) {
                           e.printStackTrace();
                        } catch (InvalidArgumentException e) {
                           e.printStackTrace();
                        } catch (ParseException e) {
                           e.printStackTrace();
                        }
                     }else {
                        if (result.getMediaServerItem() != null) {
                           hookEvent.response(result.getMediaServerItem(), result.getResponse());
                        }
                     }
                  });
               }else {
                  sendRtpItem.setPlay(true);
                  StreamInfo streamInfo = redisCatchStorage.queryPlayByDevice(device.getDeviceId(), channelId);
                  if (streamInfo == null) {
                     if (mediaServerItem.isRtpEnable()) {
                        sendRtpItem.setStreamId(String.format("%s_%s", device.getDeviceId(), channelId));
                     }
                     sendRtpItem.setPlay(false);
                     playService.play(mediaServerItem,device.getDeviceId(), channelId, hookEvent,errorEvent);
                  }else {
                     sendRtpItem.setStreamId(streamInfo.getStream());
                     hookEvent.response(mediaServerItem, null);
                  }
               }

            }else if (gbStream != null) {
               SendRtpItem sendRtpItem = zlmrtpServerFactory.createSendRtpItem(mediaServerItem, addressStr, port, ssrc, requesterId,
                     gbStream.getApp(), gbStream.getStream(), channelId,
@@ -279,11 +368,8 @@
               }

               // 写入redis， 超时时回复
               redisCatchStorage.updateSendRTPSever(sendRtpItem);

               sendRtpItem.setStatus(1);
               redisCatchStorage.updateSendRTPSever(sendRtpItem);
               // TODO 添加对tcp的支持
               StringBuffer content = new StringBuffer(200);
               content.append("v=0\r\n");
               content.append("o="+ channelId +" 0 0 IN IP4 "+mediaServerItem.getSdpIp()+"\r\n");
@@ -297,7 +383,7 @@
               content.append("f=\r\n");

               try {
                  responseAck(evt, content.toString());
                  responseSdpAck(evt, content.toString(), platform);
               } catch (SipException e) {
                  e.printStackTrace();
               } catch (InvalidArgumentException e) {
@@ -307,72 +393,6 @@
               }
            }

         } else {
            // 非上级平台请求，查询是否设备请求（通常为接收语音广播的设备）
            Device device = storager.queryVideoDevice(requesterId);
            if (device != null) {
               logger.info("收到设备" + requesterId + "的语音广播Invite请求");
               responseAck(evt, Response.TRYING);

               String contentString = new String(request.getRawContent());
               // jainSip不支持y=字段， 移除移除以解析。
               String substring = contentString;
               String ssrc = "0000000404";
               int ssrcIndex = contentString.indexOf("y=");
               if (ssrcIndex > 0) {
                  substring = contentString.substring(0, ssrcIndex);
                  ssrc = contentString.substring(ssrcIndex + 2, ssrcIndex + 12);
               }
               ssrcIndex = substring.indexOf("f=");
               if (ssrcIndex > 0) {
                  substring = contentString.substring(0, ssrcIndex);
               }
               SessionDescription sdp = SdpFactory.getInstance().createSessionDescription(substring);

               //  获取支持的格式
               Vector mediaDescriptions = sdp.getMediaDescriptions(true);
               // 查看是否支持PS 负载96
               int port = -1;
               //boolean recvonly = false;
               boolean mediaTransmissionTCP = false;
               Boolean tcpActive = null;
               for (int i = 0; i < mediaDescriptions.size(); i++) {
                  MediaDescription mediaDescription = (MediaDescription)mediaDescriptions.get(i);
                  Media media = mediaDescription.getMedia();

                  Vector mediaFormats = media.getMediaFormats(false);
                  if (mediaFormats.contains("8")) {
                     port = media.getMediaPort();
                     String protocol = media.getProtocol();
                     // 区分TCP发流还是udp， 当前默认udp
                     if ("TCP/RTP/AVP".equals(protocol)) {
                        String setup = mediaDescription.getAttribute("setup");
                        if (setup != null) {
                           mediaTransmissionTCP = true;
                           if ("active".equals(setup)) {
                              tcpActive = true;
                           } else if ("passive".equals(setup)) {
                              tcpActive = false;
                           }
                        }
                     }
                     break;
                  }
               }
               if (port == -1) {
                  logger.info("不支持的媒体格式，返回415");
                  // 回复不支持的格式
                  responseAck(evt, Response.UNSUPPORTED_MEDIA_TYPE); // 不支持的格式，发415
                  return;
               }
               String username = sdp.getOrigin().getUsername();
               String addressStr = sdp.getOrigin().getAddress();
               logger.info("设备{}请求语音流，地址：{}:{}，ssrc：{}", username, addressStr, port, ssrc);

            } else {
               logger.warn("来自无效设备/平台的请求");
               responseAck(evt, Response.BAD_REQUEST);
            }
         }

      } catch (SipException | InvalidArgumentException | ParseException e) {
@@ -385,4 +405,74 @@
         e.printStackTrace();
      }
   }

   public void inviteFromDeviceHandle(RequestEvent evt, String requesterId) throws InvalidArgumentException, ParseException, SipException, SdpException {

      // 非上级平台请求，查询是否设备请求（通常为接收语音广播的设备）
      Device device = redisCatchStorage.getDevice(requesterId);
      Request request = evt.getRequest();
      if (device != null) {
         logger.info("收到设备" + requesterId + "的语音广播Invite请求");
         responseAck(evt, Response.TRYING);

         String contentString = new String(request.getRawContent());
         // jainSip不支持y=字段， 移除移除以解析。
         String substring = contentString;
         String ssrc = "0000000404";
         int ssrcIndex = contentString.indexOf("y=");
         if (ssrcIndex > 0) {
            substring = contentString.substring(0, ssrcIndex);
            ssrc = contentString.substring(ssrcIndex + 2, ssrcIndex + 12);
         }
         ssrcIndex = substring.indexOf("f=");
         if (ssrcIndex > 0) {
            substring = contentString.substring(0, ssrcIndex);
         }
         SessionDescription sdp = SdpFactory.getInstance().createSessionDescription(substring);

         //  获取支持的格式
         Vector mediaDescriptions = sdp.getMediaDescriptions(true);
         // 查看是否支持PS 负载96
         int port = -1;
         //boolean recvonly = false;
         boolean mediaTransmissionTCP = false;
         Boolean tcpActive = null;
         for (int i = 0; i < mediaDescriptions.size(); i++) {
            MediaDescription mediaDescription = (MediaDescription)mediaDescriptions.get(i);
            Media media = mediaDescription.getMedia();

            Vector mediaFormats = media.getMediaFormats(false);
            if (mediaFormats.contains("8")) {
               port = media.getMediaPort();
               String protocol = media.getProtocol();
               // 区分TCP发流还是udp， 当前默认udp
               if ("TCP/RTP/AVP".equals(protocol)) {
                  String setup = mediaDescription.getAttribute("setup");
                  if (setup != null) {
                     mediaTransmissionTCP = true;
                     if ("active".equals(setup)) {
                        tcpActive = true;
                     } else if ("passive".equals(setup)) {
                        tcpActive = false;
                     }
                  }
               }
               break;
            }
         }
         if (port == -1) {
            logger.info("不支持的媒体格式，返回415");
            // 回复不支持的格式
            responseAck(evt, Response.UNSUPPORTED_MEDIA_TYPE); // 不支持的格式，发415
            return;
         }
         String username = sdp.getOrigin().getUsername();
         String addressStr = sdp.getOrigin().getAddress();
         logger.info("设备{}请求语音流，地址：{}:{}，ssrc：{}", username, addressStr, port, ssrc);

      } else {
         logger.warn("来自无效设备/平台的请求");
         responseAck(evt, Response.BAD_REQUEST);
      }
   }
}