mec/mec-im/src/main/java/com/ym/controller/UserController.java

package com.ym.controller;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.microsvc.toolkit.middleware.live.LivePluginContext;
import com.microsvc.toolkit.middleware.live.LivePluginService;
import com.microsvc.toolkit.middleware.live.impl.TencentCloudLivePlugin;
import com.ym.common.BaseResponse;
import com.ym.mec.biz.dal.dto.TencentData;
import com.ym.mec.biz.dal.dto.TencentImCallbackResult;
import com.ym.mec.biz.dal.enums.ETencentImCallbackCommand;
import com.ym.mec.biz.service.ImLiveBroadcastRoomService;
import com.ym.mec.common.entity.ImUserState;
import com.ym.service.LiveRoomService;
import com.ym.service.UserService;
import io.rong.models.user.UserModel;
import io.swagger.annotations.ApiOperation;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.util.List;

@RestController
@RequestMapping("/user")
public class UserController {
    private static final Logger log = LoggerFactory.getLogger(UserController.class);
    @Autowired
    private UserService userService;
    @Autowired
    private ImLiveBroadcastRoomService imLiveBroadcastRoomService;
    @Autowired
    private LiveRoomService liveRoomService;
  @Autowired
  private LivePluginContext livePluginContext;

    @RequestMapping(value = "/register", method = RequestMethod.POST)
    public Object register(@RequestBody UserModel userModel) throws Exception {
        return userService.register(userModel);
    }

    @RequestMapping(value = "/update", method = RequestMethod.POST)
    public Object update(@RequestBody UserModel userModel) throws Exception {
        return userService.update(userModel);
    }

    /**
     * 监听融云用户状态变更
     *
     * @param userState List<ImUserState>
     */
    @PostMapping(value = "/statusImUser")
    public BaseResponse statusImUser(@RequestBody List<ImUserState> userState) {
        log.info("statusImUser >>>>> : {}", JSONObject.toJSONString(userState));
        imLiveBroadcastRoomService.opsRoom(userState);
        return new BaseResponse<>();
    }


    @ApiOperation("腾讯im 回调接口")
    @PostMapping(value = "/tencentImCallback")
    public TencentImCallbackResult tencentImCallback(@RequestBody String body, HttpServletRequest request) {
        log.info("tencentImCallback body：{}", body);

      LivePluginService pluginService = livePluginContext.getPluginService(TencentCloudLivePlugin.PLUGIN_NAME);
      String appKey = pluginService.getLiveRoomConfig().getAppKey();

      log.info("tencentImCallback request param：{}", JSON.toJSONString(request.getParameterMap()));

      String sdkAppid = request.getParameter("SdkAppid");
      List<String> sdkList = JSON.parseArray(sdkAppid, String.class);
      if (sdkList == null || sdkList.size() == 0) {
        log.error("tencentImCallback sdkAppid is null");
        return new TencentImCallbackResult();
      }
      if (!sdkList.contains(appKey)) {
        log.error("tencentImCallback sdkAppid is not match");
        return new TencentImCallbackResult();
      }

      String clientIP = request.getParameter("ClientIP");
        String optPlatform = request.getParameter("OptPlatform");


        if(request.getParameter("CallbackCommand").equals(ETencentImCallbackCommand.GROUP_CALLBACKONMEMBERSTATECHANGE.name())) {
            TencentData.CallbackOnMemberStateChange callbackOnMemberStateChange = TencentData.CallbackOnMemberStateChange.toObject(
                body);

            log.debug("callbackOnMemberStateChange: {}", callbackOnMemberStateChange);
            callbackOnMemberStateChange.setClientIP(clientIP);
            callbackOnMemberStateChange.setOptPlatform(optPlatform);
            imLiveBroadcastRoomService.callbackOnMemberStateChange(callbackOnMemberStateChange);


        } else if(request.getParameter("CallbackCommand").equals(ETencentImCallbackCommand.GROUP_CALLBACKAFTERMEMBEREXIT.name())) {
            TencentData.CallbackAfterMemberExit callbackAfterMemberExit = TencentData.CallbackAfterMemberExit.toObject(
                body);

            log.debug("callbackAfterMemberExit: {}", callbackAfterMemberExit);
            callbackAfterMemberExit.setClientIP(clientIP);
            callbackAfterMemberExit.setOptPlatform(optPlatform);
            imLiveBroadcastRoomService.callbackAfterMemberExit(callbackAfterMemberExit);
        }  else if(request.getParameter("CallbackCommand").equals(ETencentImCallbackCommand.GROUP_CALLBACKAFTERNEWMEMBERJOIN.name())) {
            TencentData.CallbackAfterNewMemberJoin callbackAfterNewMemberJoin = TencentData.CallbackAfterNewMemberJoin.toObject(
                body);

            log.debug("CallbackAfterNewMemberJoin: {}", callbackAfterNewMemberJoin);
            callbackAfterNewMemberJoin.setClientIP(clientIP);
            callbackAfterNewMemberJoin.setOptPlatform(optPlatform);
            imLiveBroadcastRoomService.callbackAfterNewMemberJoin(callbackAfterNewMemberJoin);
        }


        return new TencentImCallbackResult();
    }


    @ApiOperation("腾讯云直播-推流 回调接口")
    @PostMapping(value = "/tencentStreamEventCallback")
    public TencentData.StreamEventCallbackResult tencentStreamEventCallback(@RequestBody String body) {

        log.info("tencentStreamEventCallback body：{}", body);

        TencentData.CallbackStreamStateEvent event = TencentData.CallbackStreamStateEvent.from(body);

        // 断流事件通知
        if (event.getEventType() == 0) {

            // 更新推流时长
            if (StringUtils.isNotBlank(event.getPushDuration()) && event.getPushDuration().matches("\\d+")) {
                // 更新直播推流时长
                imLiveBroadcastRoomService.updateLiveRoomPushStreamTime(event);
            }

            // 自动关闭录制
            imLiveBroadcastRoomService.closeLive(getRoomUid(event.getStreamId()), getSpeakerId(event.getStreamId()));
        }

        // 推流事件通知
        if (event.getEventType() == 1) {
            // 自动开启录制
            imLiveBroadcastRoomService.startLive(getRoomUid(event.getStreamId()), getSpeakerId(event.getStreamId()), null);
        }

        return TencentData.StreamEventCallbackResult.builder().code(0).build();
    }

    private Integer getSpeakerId(String streamId) {
        return Integer.parseInt(streamId.split("_")[1]);
    }

    private String getRoomUid(String streamId) {
        return streamId.split("_")[0];
    }

    @ApiOperation("腾讯云直播-录制 回调接口")
    @PostMapping(value = "/tencentStreamRecordCallback")
    public TencentData.StreamEventCallbackResult tencentStreamRecordCallback(@RequestBody String body) {

        log.info("tencentStreamRecordCallback body：{}", body);

        TencentData.CallbackSteamRecordEvent event = TencentData.CallbackSteamRecordEvent.from(body);

        log.info("taskId={}, url={}", event.getTaskId(), event.getVideoUrl());

        // 生成直播录制信息
        liveRoomService.createLiveRoomVideoRecord(event);

        return TencentData.StreamEventCallbackResult.builder().code(0).build();
    }

    @ApiOperation("腾讯云直播-推流异常 回调接口")
    @PostMapping(value = "/tencentStreamExceptionCallback")
    public TencentData.StreamEventCallbackResult tencentStreamExceptionCallback(@RequestBody String body) {

        log.info("tencentStreamExceptionCallback body：{}", body);

        return TencentData.StreamEventCallbackResult.builder().code(0).build();
    }

}