Merge pull request #939 from xiaoQQya/wvp-28181-2.0

648540858

2023-07-17 86a20edb0b8b72e22ed617c0def664665b6f7bd4

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

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

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.genersoft.iot.vmp.common.RealVideo;
import com.genersoft.iot.vmp.gb28181.bean.SendRtpItem;
import com.genersoft.iot.vmp.gb28181.session.SsrcUtil;
import com.genersoft.iot.vmp.media.zlm.dto.MediaItem;
import com.genersoft.iot.vmp.conf.UserSetting;
import com.genersoft.iot.vmp.gb28181.bean.GbStream;
import com.genersoft.iot.vmp.media.zlm.dto.*;
import com.genersoft.iot.vmp.media.zlm.dto.hook.OnStreamChangedHookParam;
import com.genersoft.iot.vmp.service.IMediaServerService;
import com.genersoft.iot.vmp.service.IStreamProxyService;
import com.genersoft.iot.vmp.service.IStreamPushService;
import com.genersoft.iot.vmp.storager.IRedisCatchStorage;
import com.genersoft.iot.vmp.storager.impl.RedisCatchStorageImpl;
import com.genersoft.iot.vmp.storager.IVideoManagerStorage;
import com.genersoft.iot.vmp.storager.dao.GbStreamMapper;
import com.genersoft.iot.vmp.storager.dao.PlatformGbStreamMapper;
import com.genersoft.iot.vmp.storager.dao.StreamPushMapper;
import com.genersoft.iot.vmp.utils.DateUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.text.ParseException;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author lin
 */
@Component
public class ZLMMediaListManager {

@@ -29,59 +36,103 @@
    @Autowired
    private IRedisCatchStorage redisCatchStorage;

    @Autowired
    private IVideoManagerStorage storager;

    public void updateMediaList() {
        JSONObject mediaList = zlmresTfulUtils.getMediaList();
        String dataStr = mediaList.getString("data");
    @Autowired
    private GbStreamMapper gbStreamMapper;

        Integer code = mediaList.getInteger("code");
        Map<String, RealVideo> result = new HashMap<>();
        if (code == 0 ) {
            if (dataStr != null) {
                List<MediaItem> mediaItems = JSON.parseObject(dataStr, new TypeReference<List<MediaItem>>() {});
                for (MediaItem item : mediaItems) {
                    if ("rtp".equals(item.getApp())) {
                        continue;
                    }
                    String key = item.getApp() + "_" + item.getStream();
                    RealVideo realVideo = result.get(key);
                    if (realVideo == null) {
                        realVideo = new RealVideo();
                        realVideo.setApp(item.getApp());
                        realVideo.setStream(item.getStream());
                        realVideo.setAliveSecond(item.getAliveSecond());
                        realVideo.setCreateStamp(item.getCreateStamp());
                        realVideo.setOriginSock(item.getOriginSock());
                        realVideo.setTotalReaderCount(item.getTotalReaderCount());
                        realVideo.setOriginType(item.getOriginType());
                        realVideo.setOriginTypeStr(item.getOriginTypeStr());
                        realVideo.setOriginUrl(item.getOriginUrl());
                        realVideo.setCreateStamp(item.getCreateStamp());
                        realVideo.setAliveSecond(item.getAliveSecond());
    @Autowired
    private PlatformGbStreamMapper platformGbStreamMapper;

                        ArrayList<RealVideo.MediaSchema> mediaSchemas = new ArrayList<>();
                        realVideo.setSchemas(mediaSchemas);
                        realVideo.setTracks(item.getTracks());
                        realVideo.setVhost(item.getVhost());
                        result.put(key, realVideo);
                    }
    @Autowired
    private IStreamPushService streamPushService;

                    RealVideo.MediaSchema mediaSchema = new RealVideo.MediaSchema();
                    mediaSchema.setSchema(item.getSchema());
                    mediaSchema.setBytesSpeed(item.getBytesSpeed());
                    realVideo.getSchemas().add(mediaSchema);
                }
    @Autowired
    private IStreamProxyService streamProxyService;

            }
    @Autowired
    private StreamPushMapper streamPushMapper;

    @Autowired
    private ZlmHttpHookSubscribe subscribe;

    @Autowired
    private UserSetting userSetting;

    @Autowired
    private ZLMServerFactory zlmServerFactory;

    @Autowired
    private IMediaServerService mediaServerService;

    private Map<String, ChannelOnlineEvent> channelOnPublishEvents = new ConcurrentHashMap<>();

    public StreamPushItem addPush(OnStreamChangedHookParam onStreamChangedHookParam) {
        StreamPushItem transform = streamPushService.transform(onStreamChangedHookParam);
        StreamPushItem pushInDb = streamPushService.getPush(onStreamChangedHookParam.getApp(), onStreamChangedHookParam.getStream());
        transform.setPushIng(onStreamChangedHookParam.isRegist());
        transform.setUpdateTime(DateUtil.getNow());
        transform.setPushTime(DateUtil.getNow());
        transform.setSelf(userSetting.getServerId().equals(onStreamChangedHookParam.getSeverId()));
        if (pushInDb == null) {
            transform.setCreateTime(DateUtil.getNow());
            streamPushMapper.add(transform);
        }else {
            logger.warn("更新视频流失败，错误code： " + code);
            streamPushMapper.update(transform);
            gbStreamMapper.updateMediaServer(onStreamChangedHookParam.getApp(), onStreamChangedHookParam.getStream(), onStreamChangedHookParam.getMediaServerId());
        }

        List<RealVideo> realVideos = new ArrayList<>(result.values());
        Collections.sort(realVideos);
        redisCatchStorage.updateMediaList(realVideos);
        ChannelOnlineEvent channelOnlineEventLister = getChannelOnlineEventLister(transform.getApp(), transform.getStream());
        if ( channelOnlineEventLister != null)  {
            try {
                channelOnlineEventLister.run(transform.getApp(), transform.getStream(), transform.getServerId());;
            } catch (ParseException e) {
                logger.error("addPush: ", e);
            }
            removedChannelOnlineEventLister(transform.getApp(), transform.getStream());
        }
        return transform;
    }

    public void sendStreamEvent(String app, String stream, String mediaServerId) {
        MediaServerItem mediaServerItem = mediaServerService.getOne(mediaServerId);
        // 查看推流状态
        Boolean streamReady = zlmServerFactory.isStreamReady(mediaServerItem, app, stream);
        if (streamReady != null && streamReady) {
            ChannelOnlineEvent channelOnlineEventLister = getChannelOnlineEventLister(app, stream);
            if (channelOnlineEventLister != null)  {
                try {
                    channelOnlineEventLister.run(app, stream, mediaServerId);
                } catch (ParseException e) {
                    logger.error("sendStreamEvent: ", e);
                }
                removedChannelOnlineEventLister(app, stream);
            }
        }
    }

    public int removeMedia(String app, String streamId) {
        // 查找是否关联了国标， 关联了不删除， 置为离线
        GbStream gbStream = gbStreamMapper.selectOne(app, streamId);
        int result;
        if (gbStream == null) {
            result = storager.removeMedia(app, streamId);
        }else {
            result =storager.mediaOffline(app, streamId);
        }
        return result;
    }

    public void addChannelOnlineEventLister(String app, String stream, ChannelOnlineEvent callback) {
        this.channelOnPublishEvents.put(app + "_" + stream, callback);
    }

    public void removedChannelOnlineEventLister(String app, String stream) {
        this.channelOnPublishEvents.remove(app + "_" + stream);
    }

    public ChannelOnlineEvent getChannelOnlineEventLister(String app, String stream) {
        return this.channelOnPublishEvents.get(app + "_" + stream);
    }

}