repo stringclasses 1k
values | file_url stringlengths 96 373 | file_path stringlengths 11 294 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 6
values | commit_sha stringclasses 1k
values | retrieved_at stringdate 2026-01-04 14:45:56 2026-01-04 18:30:23 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/im/handler/MediumLevelHandler.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/im/handler/MediumLevelHandler.java | package cn.bixin.sona.server.im.handler;
import cn.bixin.sona.api.im.enums.PriorityEnum;
import cn.bixin.sona.api.im.request.RoomMessageRequest;
import cn.bixin.sona.common.dto.Response;
import org.springframework.stereotype.Service;
/**
* @author qinwei
*/
@Service
public class MediumLevelHandler extends AbstractChatRoomHandler {
@Override
public Response<Boolean> doHandle(RoomMessageRequest request) {
// 中等级消息直接发kafka
return sendKafka(request);
}
@Override
public boolean support(RoomMessageRequest request) {
return PriorityEnum.MEDIUM == request.getPriority();
}
@Override
public int order() {
return 3;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/im/handler/LowLevelHandler.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/im/handler/LowLevelHandler.java | package cn.bixin.sona.server.im.handler;
import cn.bixin.sona.api.im.enums.PriorityEnum;
import cn.bixin.sona.api.im.request.RoomMessageRequest;
import cn.bixin.sona.common.dto.Response;
import cn.bixin.sona.server.im.flow.FlowStrategy;
import org.springframework.stereotype.Service;
/**
* @author qinwei
*/
@Service
public class LowLevelHandler extends AbstractChatRoomHandler {
@Override
public Response<Boolean> doHandle(RoomMessageRequest request) {
// 低等级消息有频控，通过发kafka ，否则返回失败
// 低等级消息比较多，此时不消耗令牌，只是为了提前拦截
if (FlowStrategy.PASS == getStrategy(request)) {
return sendKafka(request);
}
return Response.fail("9020", "flow control");
}
@Override
public boolean support(RoomMessageRequest request) {
return PriorityEnum.LOW == request.getPriority();
}
@Override
public int order() {
return 4;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/im/handler/ChatRoomHandler.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/im/handler/ChatRoomHandler.java | package cn.bixin.sona.server.im.handler;
import cn.bixin.sona.api.im.request.RoomMessageRequest;
import cn.bixin.sona.common.dto.Response;
/**
* @author qinwei
*/
public interface ChatRoomHandler {
/**
* 处理请求
*/
Response<Boolean> handle(RoomMessageRequest request);
/**
* 是否支持处理
*/
default boolean support(RoomMessageRequest request) {
return true;
}
/**
* 处理顺序
*/
int order();
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/im/listener/ChatRoomMessageListener.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/im/listener/ChatRoomMessageListener.java | package cn.bixin.sona.server.im.listener;
import cn.bixin.sona.api.im.request.RoomMessageRequest;
import cn.bixin.sona.server.im.message.MessageQueueManager;
import cn.bixin.sona.server.im.service.SendService;
import com.alibaba.fastjson.JSON;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
/**
* @author qinwei
*/
@Component
public class ChatRoomMessageListener implements DisposableBean {
@Resource
private SendService sendService;
@KafkaListener(topics = "TOPIC-ROOM-IM-MESSAGE", groupId = "ROOM-IM-MESSAGE_GROUP_ID")
public void processChatroomMessage(ConsumerRecord<String, String> record) {
sendService.sendMessage(JSON.parseObject(record.value(), RoomMessageRequest.class));
}
@Override
public void destroy() throws Exception {
MessageQueueManager.stop();
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/im/listener/AckMessageListener.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/im/listener/AckMessageListener.java | package cn.bixin.sona.server.im.listener;
import cn.bixin.sona.api.im.request.ChatroomMessageRequest;
import cn.bixin.sona.api.im.request.RoomMessageRequest;
import cn.bixin.sona.server.im.ack.AckMessageHandler;
import cn.bixin.sona.server.im.utils.ConvertUtils;
import com.alibaba.fastjson.JSON;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
/**
* @author qinwei
*/
@Component
public class AckMessageListener {
@Resource
private AckMessageHandler ackMessageHandler;
@KafkaListener(topics = "TOPIC_ROOM_ACK_MESSAGE", groupId = "ROOM_ACK_MESSAGE_GROUP_ID")
public void listenAckChatRoomIM(ConsumerRecord<String, String> record) {
ackMessageHandler.handleAckMessage(JSON.parseObject(record.value(), ChatroomMessageRequest.class));
}
@KafkaListener(topics = "TOPIC_CHATROOM_MESSAGE_ACK", groupId = "CHATROOM_MESSAGE_ACK_GROUP_ID")
public void processNeedAckMessage(ConsumerRecord<String, String> record) {
RoomMessageRequest request = JSON.parseObject(record.value(), RoomMessageRequest.class);
ackMessageHandler.handleNeedAckMessage(ConvertUtils.conv2MessageWrap(request));
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/im/listener/MessageListener.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/im/listener/MessageListener.java | package cn.bixin.sona.server.im.listener;
import cn.bixin.sona.api.im.MessageCallbackService;
import cn.bixin.sona.api.im.enums.MsgFormatEnum;
import cn.bixin.sona.api.im.request.ChatroomMessageRequest;
import cn.bixin.sona.server.im.ack.AckMessageHandler;
import com.alibaba.fastjson.JSON;
import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.util.ObjectUtils;
import javax.annotation.Resource;
import java.nio.charset.StandardCharsets;
/**
* @author qinwei
*/
@Component
@RocketMQMessageListener(topic = "TOPIC_ROOM_MESSAGE", consumerGroup = "ROOM_MESSAGE-SONA_GROUP")
public class MessageListener implements RocketMQListener<MessageExt> {
private static final Logger log = LoggerFactory.getLogger(MessageListener.class);
@Resource
private AckMessageHandler ackMessageHandler;
@Resource
private MessageCallbackService messageCallbackService;
@Override
public void onMessage(MessageExt messageExt) {
if (ObjectUtils.isEmpty(messageExt.getBody())) {
log.error("MessageListener.onMessage, msg empty, msg: {}", JSON.toJSONString(messageExt));
return;
}
String message = new String(messageExt.getBody(), StandardCharsets.UTF_8);
try {
String data = JSON.parseObject(message).getString("data");
ChatroomMessageRequest request = JSON.parseObject(data, ChatroomMessageRequest.class);
if (request == null) {
log.error("MessageListener.onMessage, request empty, msg: {}", JSON.toJSONString(messageExt));
return;
}
if (MsgFormatEnum.ACK.getCode() == request.getMsgFormat()) {
ackMessageHandler.handleAckMessage(request);
} else {
messageCallbackService.sendChatroomMessage(request);
}
} catch (Exception e) {
log.error("MessageListener.onMessage fail, msg: {}", message, e);
}
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/im/listener/MessageRecorderListener.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/im/listener/MessageRecorderListener.java | package cn.bixin.sona.server.im.listener;
import cn.bixin.sona.server.im.dto.RoomMessageDTO;
import cn.bixin.sona.server.im.service.MessageRecorderService;
import com.alibaba.fastjson.JSON;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
@Component
public class MessageRecorderListener {
private static final Logger log = LoggerFactory.getLogger(MessageRecorderListener.class);
@Resource
MessageRecorderService messageRecorderService;
@KafkaListener(topics = "TOPIC-ROOM-MESSAGE-RECORDER", groupId = "CHATROOM_MESSAGE_ACK_GROUP_ID")
public void recordRoomMessage(ConsumerRecord<String, String> record) {
try {
RoomMessageDTO request = JSON.parseObject(record.value(), RoomMessageDTO.class);
messageRecorderService.saveRoomMessage(request);
} catch (Exception e){
log.error("recordRoomMessage exception, record:{}", record.value(), e);
}
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/mq/KafkaSender.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/mq/KafkaSender.java | package cn.bixin.sona.server.mq;
import com.alibaba.fastjson.JSON;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Component;
/**
* @author qinwei
*/
@Component
public class KafkaSender {
private static final Logger log = LoggerFactory.getLogger(KafkaSender.class);
@Autowired
private KafkaTemplate<String, String> kafkaTemplate;
public void send(String topic, String key, Object object) {
String json = JSON.toJSONString(object);
kafkaTemplate.send(topic, key, json)
.addCallback(o -> {
}, throwable -> log.error("kafka消息发送失败: topic = {}, key = {} , json = {}", topic, key, json));
}
public void send(String topic, Object object) {
send(topic, null, object);
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/mq/RocketSender.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/mq/RocketSender.java | package cn.bixin.sona.server.mq;
import com.alibaba.fastjson.JSON;
import com.dianping.cat.Cat;
import com.dianping.cat.message.Transaction;
import org.apache.rocketmq.client.producer.SendCallback;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.client.producer.SendStatus;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.stereotype.Service;
/**
* @author qinwei
*/
@Service
public class RocketSender {
private static final Logger log = LoggerFactory.getLogger(RocketSender.class);
@Autowired
private RocketMQTemplate rocketMQTemplate;
public void sendDelay(String topic, String content, int delayLevel) {
Transaction t = Cat.newTransaction("RocketMQ", topic);
try {
SendResult result = rocketMQTemplate.syncSend(topic, MessageBuilder.withPayload(content).build(), 1000, delayLevel);
if (result == null || result.getSendStatus() != SendStatus.SEND_OK) {
log.warn("sendDelay error. {}", JSON.toJSONString(result));
}
} catch (Exception e) {
t.setStatus(e);
} finally {
t.complete();
}
}
public SendResult syncSend(String topic, String content) {
Transaction t = Cat.newTransaction("RocketMQ", topic);
try {
MessageBuilder<?> builder = MessageBuilder.withPayload(content);
return rocketMQTemplate.syncSend(topic, builder.build());
} catch (Exception e) {
t.setStatus(e);
} finally {
t.complete();
}
return null;
}
public void asyncSend(String topic, String content, SendCallback callback) {
Transaction t = Cat.newTransaction("RocketMQ", topic);
try {
MessageBuilder<?> builder = MessageBuilder.withPayload(content);
rocketMQTemplate.asyncSend(topic, builder.build(), new SendCallback() {
@Override
public void onSuccess(SendResult sendResult) {
if (callback != null) {
callback.onSuccess(sendResult);
}
}
@Override
public void onException(Throwable e) {
log.error("send rocketmq failure, topic : {}, content:{}", topic, content, e);
if (callback != null) {
callback.onException(e);
}
}
});
} catch (Exception e) {
t.setStatus(e);
} finally {
t.complete();
}
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/package-info.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/package-info.java | package cn.bixin.sona.server.room; | java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/controller/HotSwitchController.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/controller/HotSwitchController.java | package cn.bixin.sona.server.room.controller;
import cn.bixin.sona.api.room.HotSwitchRemoteService;
import cn.bixin.sona.common.dto.Response;
import cn.bixin.sona.enums.RoomMixedEnum;
import cn.bixin.sona.server.room.manager.AudioSwitchManager;
import com.google.common.collect.Lists;
import org.apache.dubbo.config.annotation.DubboService;
import javax.annotation.Resource;
@DubboService
public class HotSwitchController implements HotSwitchRemoteService {
@Resource
private AudioSwitchManager audioSwitchManager;
@Override
public Response<Boolean> switchAudioSupplierRoom(long roomId, int mixed) {
return Response.success(audioSwitchManager.roomSwitch(Lists.newArrayList(roomId), RoomMixedEnum.getRoomMixedEnum(mixed)));
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/controller/SonaStreamCallbackStreamController.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/controller/SonaStreamCallbackStreamController.java | package cn.bixin.sona.server.room.controller;
import cn.bixin.sona.api.room.SonaStreamCallbackRemoteService;
import cn.bixin.sona.common.dto.Response;
import cn.bixin.sona.common.exception.YppRunTimeException;
import cn.bixin.sona.request.callback.*;
import cn.bixin.sona.server.exception.ExceptionCode;
import cn.bixin.sona.server.room.domain.enums.StreamSupplierEnum;
import cn.bixin.sona.server.room.factory.StreamFactory;
import com.alibaba.fastjson.JSON;
import org.apache.commons.lang3.StringUtils;
import org.apache.dubbo.config.annotation.DubboService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.annotation.Resource;
@DubboService
public class SonaStreamCallbackStreamController implements SonaStreamCallbackRemoteService {
private static final Logger log = LoggerFactory.getLogger(SonaStreamCallbackStreamController.class);
@Resource
private StreamFactory streamFactory;
@Override
public Response<Boolean> handleCreateStreamCallback(CreateStreamCallback callback) {
log.info("handleCreateStreamCallback callback:{}", JSON.toJSONString(callback));
StreamSupplierEnum streamSupplier = StreamSupplierEnum.getByCode(callback.getSource());
if (streamSupplier == null) {
throw new YppRunTimeException(ExceptionCode.STREAM_SUPPLIER_NOT_FOUND);
}
streamFactory.newInstance(streamSupplier).handleCreate(callback);
return Response.success(true);
}
@Override
public Response<Boolean> handleCloseStreamCallback(CloseStreamCallback callback) {
log.info("handleCloseStreamCallback callback:{}", JSON.toJSONString(callback));
StreamSupplierEnum streamSupplier = StreamSupplierEnum.getByCode(callback.getSource());
if (streamSupplier == null) {
throw new YppRunTimeException(ExceptionCode.STREAM_SUPPLIER_NOT_FOUND);
}
if (StringUtils.isBlank(callback.getErrMsg())) {
callback.setErrMsg("none");
}
streamFactory.newInstance(streamSupplier).handleClose(callback);
return Response.success(true);
}
@Override
public Response<Boolean> handleCreateReplayCallback(CreateReplayCallback callback) {
log.info("handleCreateReplayCallback callback:{}", JSON.toJSONString(callback));
StreamSupplierEnum streamSupplier = StreamSupplierEnum.getByCode(callback.getSource());
if (streamSupplier == null) {
throw new YppRunTimeException(ExceptionCode.STREAM_SUPPLIER_NOT_FOUND);
}
streamFactory.newInstance(streamSupplier).handleReplay(callback);
return Response.success(true);
}
@Override
public Response<Boolean> handleMixStreamStartCallback(MixStreamStartCallback callback) {
log.info("handleMixStreamStartCallback callback:{}", JSON.toJSONString(callback));
StreamSupplierEnum streamSupplier = StreamSupplierEnum.getByCode(callback.getSource());
if (streamSupplier == null) {
throw new YppRunTimeException(ExceptionCode.STREAM_SUPPLIER_NOT_FOUND);
}
streamFactory.newInstance(null).handleMixStart(callback);
return Response.success(true);
}
@Override
public Response<Boolean> handleMixStreamEndCallback(MixStreamEndCallback callback) {
log.info("handleMixStreamEndCallback callback:{}", JSON.toJSONString(callback));
StreamSupplierEnum streamSupplier = StreamSupplierEnum.getByCode(callback.getSource());
if (streamSupplier == null) {
throw new YppRunTimeException(ExceptionCode.STREAM_SUPPLIER_NOT_FOUND);
}
streamFactory.newInstance(null).handleMixEnd(callback);
return Response.success(true);
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/controller/SonaRoomQueryController.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/controller/SonaRoomQueryController.java | package cn.bixin.sona.server.room.controller;
import cn.bixin.sona.api.room.SonaRoomQueryRemoteService;
import cn.bixin.sona.common.dto.PageResult;
import cn.bixin.sona.common.dto.Response;
import cn.bixin.sona.common.exception.YppRunTimeException;
import cn.bixin.sona.dto.RoomConfigDTO;
import cn.bixin.sona.dto.RoomDTO;
import cn.bixin.sona.dto.RoomUserDTO;
import cn.bixin.sona.server.exception.ExceptionCode;
import cn.bixin.sona.server.room.manager.RoomManager;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.dubbo.config.annotation.DubboService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
@DubboService
public class SonaRoomQueryController implements SonaRoomQueryRemoteService {
private static final Logger log = LoggerFactory.getLogger(SonaRoomQueryController.class);
@Resource
private RoomManager roomManager;
@Override
public Response<RoomDTO> getRoom(Long roomId) {
return Response.success(roomManager.getRoom(roomId));
}
@Override
public Response<Map<Long, RoomDTO>> getRoomBatch(List<Long> roomIds) {
if (CollectionUtils.isEmpty(roomIds) || roomIds.size() > 50) {
return Response.fail(ExceptionCode.ERROR_PARAM);
}
return Response.success(roomManager.getRoomBatch(roomIds));
}
@Override
public Response<Long> getRoomMemberCount(long roomId) {
try {
return Response.success(roomManager.getRoomMemberCount(roomId));
} catch (YppRunTimeException e) {
return Response.fail(e.getCode().getCode(), e.getCode().getMessage());
} catch (Exception e) {
log.error("getRoomMemberCount error", e);
return Response.fail(ExceptionCode.SERVER_ERROR);
}
}
@Override
public Response<Map<Long, Long>> batchGetRoomMemberCount(List<Long> roomIds) {
if (CollectionUtils.isEmpty(roomIds) || roomIds.size() > 50) {
return Response.fail(ExceptionCode.ERROR_PARAM);
}
try {
return Response.success(roomManager.batchGetRoomMemberCount(roomIds));
} catch (YppRunTimeException e) {
return Response.fail(e.getCode().getCode(), e.getCode().getMessage());
} catch (Exception e) {
log.error("createRoom error", e);
return Response.fail(ExceptionCode.SERVER_ERROR);
}
}
@Override
public Response<PageResult<RoomUserDTO>> getRoomMemberList(long roomId, String anchor, int limit) {
if (limit > 50 || !anchorValid(anchor)) {
return Response.fail(ExceptionCode.ERROR_PARAM);
}
if (StringUtils.isBlank(anchor)) {
anchor = "0";
}
if (limit <= 0) {
limit = 20;
}
try {
return Response.success(roomManager.getRoomMemberList(roomId, anchor, limit));
} catch (YppRunTimeException e) {
return Response.fail(e.getCode().getCode(), e.getCode().getMessage());
} catch (Exception e) {
log.error("createRoom error", e);
return Response.fail(ExceptionCode.SERVER_ERROR);
}
}
private boolean anchorValid(String anchor) {
if (StringUtils.isBlank(anchor)) {
return true;
}
try {
Integer.parseInt(anchor);
return true;
} catch (Exception e) {
return false;
}
}
@Override
public Response<Map<Long, Boolean>> isUserInRoom(long roomId, List<Long> uids) {
if (CollectionUtils.isEmpty(uids)) {
return Response.fail(ExceptionCode.ERROR_PARAM);
}
try {
return Response.success(roomManager.isUserInRoom(roomId, uids));
} catch (YppRunTimeException e) {
return Response.fail(e.getCode().getCode(), e.getCode().getMessage());
} catch (Exception e) {
log.error("createRoom error", e);
return Response.fail(ExceptionCode.SERVER_ERROR);
}
}
@Override
public Response<RoomConfigDTO> getRoomConfig(long roomId) {
try {
return Response.success(roomManager.getRoomConfig(roomId));
} catch (YppRunTimeException e) {
return Response.fail(e.getCode().getCode(), e.getCode().getMessage());
} catch (Exception e) {
log.error("getRoomMemberCount error", e);
return Response.fail(ExceptionCode.SERVER_ERROR);
}
}
@Override
public Response<PageResult<RoomDTO>> getOnlineRoomList(String anchor, int limit) {
if (StringUtils.isBlank(anchor)) {
anchor = "0";
}
if (limit <= 0) {
limit = 20;
}
return Response.success(roomManager.getOnlineRoomList(anchor, limit));
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/controller/SteamRoomController.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/controller/SteamRoomController.java | package cn.bixin.sona.server.room.controller;
import cn.bixin.sona.api.room.StreamRemoteService;
import cn.bixin.sona.common.dto.Code;
import cn.bixin.sona.common.dto.Response;
import cn.bixin.sona.common.enums.PullMode;
import cn.bixin.sona.common.exception.YppRunTimeException;
import cn.bixin.sona.dto.AppInfoDTO;
import cn.bixin.sona.dto.RoomDTO;
import cn.bixin.sona.dto.SupplierConfigDTO;
import cn.bixin.sona.request.ChangeStreamRequest;
import cn.bixin.sona.request.InitStreamRequest;
import cn.bixin.sona.request.MixMVRequest;
import cn.bixin.sona.server.exception.ExceptionCode;
import cn.bixin.sona.server.room.domain.db.ProductConfig;
import cn.bixin.sona.server.room.domain.db.RoomConfig;
import cn.bixin.sona.server.room.domain.enums.StreamSupplierEnum;
import cn.bixin.sona.server.room.manager.StreamManager;
import cn.bixin.sona.server.room.service.ProductConfigService;
import cn.bixin.sona.server.room.service.RoomService;
import cn.bixin.sona.server.room.service.ZegoService;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.dubbo.config.annotation.DubboService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
import java.util.Objects;
@DubboService
public class SteamRoomController implements StreamRemoteService {
private static final Logger log = LoggerFactory.getLogger(SteamRoomController.class);
@Resource
private StreamManager streamManager;
@Resource
private RoomService roomService;
@Resource
private ProductConfigService productConfigService;
@Resource
private ZegoService zegoService;
@Override
public Response<String> initStream(InitStreamRequest request) {
if (request.getUid() <= 0 || request.getRoomId() <= 0) {
return Response.fail(ExceptionCode.ERROR_PARAM);
}
try {
return Response.success(streamManager.initStream(request.getRoomId(), request.getUid()));
} catch (YppRunTimeException e) {
return Response.fail(e.getCode().getCode(), e.getCode().getMessage());
} catch (Exception e) {
log.error("createStream error", e);
return Response.fail(ExceptionCode.SERVER_ERROR);
}
}
@Override
public Response<String> getRoomStreamUrl(long roomId) {
if (roomId <= 0) {
return Response.fail(ExceptionCode.ERROR_PARAM);
}
try {
return Response.success(streamManager.getRoomStreamUrl(roomId));
} catch (YppRunTimeException e) {
return Response.fail(e.getCode().getCode(), e.getCode().getMessage());
} catch (Exception e) {
log.error("getRoomStreamUrl error", e);
return Response.fail(ExceptionCode.SERVER_ERROR);
}
}
@Override
public Response<Map<Long, String>> getRoomStreamUrlBatch(List<Long> roomIds) {
if (CollectionUtils.isEmpty(roomIds) || roomIds.size() > 50) {
return Response.fail(ExceptionCode.ERROR_PARAM);
}
try {
return Response.success(streamManager.batchGetRoomStreamUrls(roomIds));
} catch (YppRunTimeException e) {
return Response.fail(e.getCode().getCode(), e.getCode().getMessage());
} catch (Exception e) {
log.error("getRoomStreamUrlBatch error", e);
return Response.fail(ExceptionCode.SERVER_ERROR);
}
}
@Override
public Response<Boolean> muteStream(long roomId, List<Long> targetUids) {
if (roomId <= 0 || CollectionUtils.isEmpty(targetUids)) {
return Response.fail(ExceptionCode.ERROR_PARAM);
}
try {
return Response.success(streamManager.muteStream(roomId, targetUids, true));
} catch (YppRunTimeException e) {
return Response.fail(e.getCode().getCode(), e.getCode().getMessage());
} catch (Exception e) {
log.error("muteStream error", e);
return Response.fail(ExceptionCode.SERVER_ERROR);
}
}
@Override
public Response<Boolean> cancelMuteStream(long roomId, List<Long> targetUids) {
if (roomId <= 0 || CollectionUtils.isEmpty(targetUids)) {
return Response.fail(ExceptionCode.ERROR_PARAM);
}
try {
return Response.success(streamManager.muteStream(roomId, targetUids, false));
} catch (YppRunTimeException e) {
return Response.fail(e.getCode().getCode(), e.getCode().getMessage());
} catch (Exception e) {
log.error("cancelMuteStream error", e);
return Response.fail(ExceptionCode.SERVER_ERROR);
}
}
@Override
public Response<Boolean> muteRoomStream(long roomId) {
if (roomId <= 0) {
return Response.fail(ExceptionCode.ERROR_PARAM);
}
try {
return Response.success(streamManager.muteRoomStream(roomId));
} catch (YppRunTimeException e) {
return Response.fail(e.getCode().getCode(), e.getCode().getMessage());
} catch (Exception e) {
log.error("muteRoomStream error", e);
return Response.fail(ExceptionCode.SERVER_ERROR);
}
}
@Override
public Response<Boolean> addStream(ChangeStreamRequest request) {
if (request == null || StringUtils.isBlank(request.getStreamId())) {
return Response.fail(ExceptionCode.ERROR_PARAM);
}
try {
return Response.success(streamManager.addStream(request));
} catch (YppRunTimeException e) {
return Response.fail(e.getCode().getCode(), e.getCode().getMessage());
} catch (Exception e) {
log.error("addStream error", e);
return Response.fail(ExceptionCode.SERVER_ERROR);
}
}
@Override
public Response<Boolean> closeStream(ChangeStreamRequest request) {
if (request == null || StringUtils.isBlank(request.getStreamId())) {
return Response.fail(ExceptionCode.ERROR_PARAM);
}
try {
return Response.success(streamManager.closeStream(request));
} catch (YppRunTimeException e) {
return Response.fail(e.getCode().getCode(), e.getCode().getMessage());
} catch (Exception e) {
log.error("closeStream error", e);
return Response.fail(ExceptionCode.SERVER_ERROR);
}
}
@Override
public Response<Boolean> zegoReMix(long roomId) {
log.info("zegoReMix, roomId: {}", roomId);
RoomDTO roomDTO = roomService.getRoomByRoomId(roomId);
if (roomDTO == null) {
return Response.success(false);
}
RoomConfig roomConfig = productConfigService.getRoomConfig(roomId);
String productCode = roomDTO.getProductCode();
ProductConfig productConfig = roomConfig != null ? ProductConfig.convertConfigInfo(roomConfig, productCode) : productConfigService.getConfigInfoByCode(productCode);
if (!StreamSupplierEnum.ZEGO.name().equals(productConfig.getStreamSupplier())) {
return Response.success(false);
}
if (PullMode.MIXED.name().equals(productConfig.getPullMode())) {
return Response.success(false);
}
zegoService.mix(roomId);
return Response.success(true);
}
@Override
public Response<AppInfoDTO> genUserSig(long roomId, long uid) {
return Response.success(streamManager.genUserSig(roomId, uid));
}
@Override
public Response<SupplierConfigDTO> syncRoomConfigByRoomId(long roomId) {
return Response.success(streamManager.syncRoomConfig(roomId));
}
@Override
public Response<Boolean> mixedMV(MixMVRequest request) {
log.info("mixedMV request: {}", request);
//关键参数不能为空
if (Objects.isNull(request) || Objects.isNull(request.getRoomId()) || Objects.isNull(request.getMixStatus())) {
Response.fail(Code.ERROR_PARAM);
}
//开启mv混流时, mv长度和宽度不能为空.
if (Objects.equals(request.getMixStatus(), 1) && (Objects.isNull(request.getWidth()) || Objects.isNull(
request.getHeight()))) {
Response.fail(Code.ERROR_PARAM);
}
return Response.success(streamManager.mixedMV(request));
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/controller/SonaRoomController.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/controller/SonaRoomController.java | package cn.bixin.sona.server.room.controller;
import cn.bixin.sona.api.room.SonaRoomRemoteService;
import cn.bixin.sona.common.dto.Code;
import cn.bixin.sona.common.dto.Response;
import cn.bixin.sona.common.exception.YppRunTimeException;
import cn.bixin.sona.dto.RoomDetailInfoDTO;
import cn.bixin.sona.request.*;
import cn.bixin.sona.server.exception.ExceptionCode;
import cn.bixin.sona.server.room.domain.db.RoomLogRecord;
import cn.bixin.sona.server.room.domain.enums.OperateEnum;
import cn.bixin.sona.server.room.manager.RoomManager;
import com.alibaba.fastjson.JSON;
import com.dianping.cat.Cat;
import com.google.common.base.Joiner;
import org.apache.commons.lang3.StringUtils;
import org.apache.dubbo.config.annotation.DubboService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.annotation.Resource;
@DubboService
public class SonaRoomController implements SonaRoomRemoteService {
private static final Logger log = LoggerFactory.getLogger(SonaRoomController.class);
@Resource
private RoomManager roomManager;
@Override
public Response<RoomDetailInfoDTO> createRoom(CreateRoomRequest request) {
log.debug("createRoom request:{}", JSON.toJSONString(request));
if (request == null || request.getProductCode() == null) {
return Response.fail(ExceptionCode.EMPTY_PARAM);
}
try {
return Response.success(roomManager.createRoom(request));
} catch (YppRunTimeException e) {
return Response.fail(e.getCode().getCode(), e.getCode().getMessage());
} catch (Exception e) {
log.error("createRoom error", e);
return Response.fail(ExceptionCode.SERVER_ERROR);
}
}
@Override
public Response<RoomDetailInfoDTO> openRoom(OpenCloseRoomRequest request) {
log.debug("openRoom request:{}", JSON.toJSONString(request));
if (request == null || request.getRoomId() == 0) {
return Response.fail(ExceptionCode.EMPTY_PARAM);
}
try {
return Response.success(roomManager.openRoom(request));
} catch (YppRunTimeException e) {
return Response.fail(e.getCode().getCode(), e.getCode().getMessage());
} catch (Exception e) {
log.error("openRoom error", e);
return Response.fail(ExceptionCode.SERVER_ERROR);
}
}
@Override
public Response<Boolean> closeRoom(OpenCloseRoomRequest request) {
log.debug("closeRoom request:{}", JSON.toJSONString(request));
if (request == null || request.getRoomId() == 0) {
return Response.fail(ExceptionCode.EMPTY_PARAM);
}
try {
return Response.success(roomManager.closeRoom(request));
} catch (YppRunTimeException e) {
return Response.fail(e.getCode().getCode(), e.getCode().getMessage());
} catch (Exception e) {
log.error("closeRoom error", e);
return Response.fail(ExceptionCode.SERVER_ERROR);
}
}
@Override
public Response<RoomDetailInfoDTO> enterRoom(EnterRoomRequest request) {
log.info("enterRoom request:{}", JSON.toJSONString(request));
if (request == null || request.getRoomId() == 0) {
return Response.fail(ExceptionCode.EMPTY_PARAM);
}
try {
return Response.success(roomManager.enterRoom(request));
} catch (YppRunTimeException e) {
return Response.fail(e.getCode().getCode(), e.getCode().getMessage());
} catch (Exception e) {
log.error("enterRoom error", e);
return Response.fail(ExceptionCode.SERVER_ERROR);
}
}
@Override
public Response<Boolean> leaveRoom(LeaveRoomRequest request) {
log.info("leaveRoom request:{}", JSON.toJSONString(request));
if (request == null || request.getRoomId() == 0) {
return Response.fail(ExceptionCode.EMPTY_PARAM);
}
try {
return Response.success(roomManager.leaveRoom(request));
} catch (YppRunTimeException e) {
return Response.fail(e.getCode().getCode(), e.getCode().getMessage());
} catch (Exception e) {
log.error("leaveRoom error", e);
return Response.fail(ExceptionCode.SERVER_ERROR);
}
}
@Override
public Response<Boolean> updatePassword(UpdatePasswordRequest request) {
log.info("updatePassword request:{}", JSON.toJSONString(request));
if (request == null || request.getRoomId() == 0) {
return Response.fail(ExceptionCode.EMPTY_PARAM);
}
try {
return Response.success(roomManager.updatePassword(request));
} catch (YppRunTimeException e) {
return Response.fail(e.getCode().getCode(), e.getCode().getMessage());
} catch (Exception e) {
log.error("updatePassword error", e);
return Response.fail(ExceptionCode.SERVER_ERROR);
}
}
@Override
public Response<Boolean> muteUser(OperateRequest request) {
log.info("muteUser request:{}", JSON.toJSONString(request));
if (request == null || request.getRoomId() == 0 || request.getOperatorUid() == 0 || request.getTargetUid() == 0) {
return Response.fail(ExceptionCode.EMPTY_PARAM);
}
request.setOperate(OperateEnum.SET.getCode());
try {
return Response.success(roomManager.muteOrCancelUser(request));
} catch (YppRunTimeException e) {
return Response.fail(e.getCode().getCode(), e.getCode().getMessage());
} catch (Exception e) {
log.error("muteUser error", e);
return Response.fail(ExceptionCode.SERVER_ERROR);
}
}
@Override
public Response<Boolean> cancelMuteUser(OperateRequest request) {
log.info("cancelMuteUser request:{}", JSON.toJSONString(request));
if (request == null || request.getRoomId() == 0 || request.getOperatorUid() == 0 || request.getTargetUid() == 0) {
return Response.fail(ExceptionCode.EMPTY_PARAM);
}
request.setOperate(OperateEnum.CANCEL.getCode());
try {
return Response.success(roomManager.muteOrCancelUser(request));
} catch (YppRunTimeException e) {
return Response.fail(e.getCode().getCode(), e.getCode().getMessage());
} catch (Exception e) {
log.error("cancelMuteUser error", e);
return Response.fail(ExceptionCode.SERVER_ERROR);
}
}
@Override
public Response<Boolean> blockUser(OperateRequest request) {
log.info("blockUser request:{}", JSON.toJSONString(request));
if (request == null || request.getRoomId() == 0 || request.getOperatorUid() == 0 || request.getTargetUid() == 0) {
return Response.fail(ExceptionCode.EMPTY_PARAM);
}
request.setOperate(OperateEnum.SET.getCode());
try {
return Response.success(roomManager.blockOrCancelUser(request));
} catch (YppRunTimeException e) {
return Response.fail(e.getCode().getCode(), e.getCode().getMessage());
} catch (Exception e) {
log.error("blockUser error", e);
return Response.fail(ExceptionCode.SERVER_ERROR);
}
}
@Override
public Response<Boolean> cancelBlockUser(OperateRequest request) {
log.info("cancelBlockUser request:{}", JSON.toJSONString(request));
if (request == null || request.getRoomId() == 0 || request.getOperatorUid() == 0 || request.getTargetUid() == 0) {
return Response.fail(ExceptionCode.EMPTY_PARAM);
}
request.setOperate(OperateEnum.CANCEL.getCode());
try {
return Response.success(roomManager.blockOrCancelUser(request));
} catch (YppRunTimeException e) {
return Response.fail(e.getCode().getCode(), e.getCode().getMessage());
} catch (Exception e) {
log.error("cancelBlockUser error", e);
return Response.fail(ExceptionCode.SERVER_ERROR);
}
}
@Override
public Response<Boolean> kickUser(OperateRequest request) {
log.info("kickUser request:{}", JSON.toJSONString(request));
if (request == null || request.getRoomId() == 0 || request.getOperatorUid() == 0 || request.getTargetUid() == 0) {
return Response.fail(ExceptionCode.EMPTY_PARAM);
}
try {
return Response.success(roomManager.kickUser(request));
} catch (YppRunTimeException e) {
return Response.fail(e.getCode().getCode(), e.getCode().getMessage());
} catch (Exception e) {
log.error("kickUser error", e);
return Response.fail(ExceptionCode.SERVER_ERROR);
}
}
@Override
public Response<Boolean> setAdmin(OperateRequest request) {
log.info("setAdmin request:{}", JSON.toJSONString(request));
if (request == null || request.getRoomId() == 0 || request.getOperatorUid() == 0 || request.getTargetUid() == 0) {
return Response.fail(ExceptionCode.EMPTY_PARAM);
}
request.setOperate(OperateEnum.SET.getCode());
try {
return Response.success(roomManager.setOrRemoveAdmin(request));
} catch (YppRunTimeException e) {
return Response.fail(e.getCode().getCode(), e.getCode().getMessage());
} catch (Exception e) {
log.error("setAdmin error", e);
return Response.fail(ExceptionCode.SERVER_ERROR);
}
}
@Override
public Response<Boolean> removeAdmin(OperateRequest request) {
log.info("removeAdmin request:{}", JSON.toJSONString(request));
if (request == null || request.getRoomId() == 0 || request.getOperatorUid() == 0 || request.getTargetUid() == 0) {
return Response.fail(ExceptionCode.EMPTY_PARAM);
}
request.setOperate(OperateEnum.CANCEL.getCode());
try {
return Response.success(roomManager.setOrRemoveAdmin(request));
} catch (YppRunTimeException e) {
return Response.fail(e.getCode().getCode(), e.getCode().getMessage());
} catch (Exception e) {
log.error("removeAdmin error", e);
return Response.fail(ExceptionCode.SERVER_ERROR);
}
}
@Override
public Response<Boolean> updateChatroomUserScore(Long roomId, Long uid, int score) {
log.info("updateChatroomUserScore roomId:{}, uid:{}, score:{}", roomId, uid, score);
if (roomId == null || uid == 0) {
return Response.fail(ExceptionCode.EMPTY_PARAM);
}
try {
return Response.success(roomManager.updateChatroomUserScore(roomId, uid, score));
} catch (YppRunTimeException e) {
return Response.fail(e.getCode().getCode(), e.getCode().getMessage());
} catch (Exception e) {
log.error("updateChatroomUserScore error", e);
return Response.fail(ExceptionCode.SERVER_ERROR);
}
}
@Override
public Response<Boolean> logReport(LogReportRequest request) {
if (request == null || StringUtils.isBlank(request.getData())) {
return Response.fail(Code.ERROR_PARAM);
}
RoomLogRecord logRecord = RoomLogRecord.convertRoomLogRecord(request);
if (logRecord == null) {
return Response.fail(Code.ERROR_PARAM);
}
//todo hermes log
// businessManager.saveHermesLog(logRecord);
Cat.logEvent("ErrorReport", Joiner.on(":").join(logRecord.getRoomId(), logRecord.getUid(), request.getCode()));
return Response.success(true);
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/constant/ChatRoomConstant.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/constant/ChatRoomConstant.java | package cn.bixin.sona.server.room.constant;
public class ChatRoomConstant {
public static final String SONA_POOL = "sonaExecutor";
public static final String THREAD_POOL_MIX_STREAM = "mixStreamExecutor";
public static final String THREAD_POOP_SWITCH_STREAM_EXECUTOR = "switchStreamExecutor";
public static final int ACK_TYPE = 106;
/***
* 等级前50名
*/
public static final int SMALL_RANGE_SIZE = 50;
public static final String INNER_SERVICE_KEY = "isInnerService";
public static final String PUSH_STREAM_FAIL_LOG = "push_stream_fail_log";
public static final int PAGE_SIZE_MAX_COUNT = 20;
/**
* tencent 流id
*/
public static final String TX_STREAM_ID = "txStreamId";
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/TencentService.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/TencentService.java | package cn.bixin.sona.server.room.service;
import cn.bixin.sona.dto.RoomDTO;
import cn.bixin.sona.server.room.domain.request.TencentStartMixRequest;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.dianping.cat.Cat;
import com.tencentcloudapi.common.Credential;
import com.tencentcloudapi.common.exception.TencentCloudSDKException;
import com.tencentcloudapi.common.profile.ClientProfile;
import com.tencentcloudapi.common.profile.HttpProfile;
import com.tencentcloudapi.trtc.v20190722.TrtcClient;
import com.tencentcloudapi.trtc.v20190722.models.StartMCUMixTranscodeRequest;
import com.tencentcloudapi.trtc.v20190722.models.StartMCUMixTranscodeResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
/**
* @author qinwei
*/
@Component
public class TencentService {
private static final Logger log = LoggerFactory.getLogger(TencentService.class);
@Resource
private RoomService roomService;
@Value("${tencent.secret.id}")
private String secretId;
@Value("${tencent.secret.key}")
private String secretKey;
@Value("${tencent.endpoint}")
private String endpoint;
@Value("${tencent.region}")
private String region;
@Value("${tencent.appid}")
private int tencentAppId;
@Async("mixStreamExecutor")
public void mix(long roomId) {
log.info("tencentStartMix roomId:{}", roomId);
RoomDTO roomDTO = roomService.getRoomByRoomId(roomId);
if (roomDTO == null) {
return;
}
try {
TrtcClient client = generateTrtcClient();
TencentStartMixRequest request = new TencentStartMixRequest();
request.setRoomId(roomId);
request.setSdkAppId(tencentAppId);
TencentStartMixRequest.OutputParams outputParams = new TencentStartMixRequest.OutputParams();
outputParams.setStreamId(String.valueOf(roomId));
outputParams.setPureAudioStream(0);
TencentStartMixRequest.EncodeParams encodeParams = new TencentStartMixRequest.EncodeParams();
encodeParams.setAudioSampleRate(48000);
encodeParams.setAudioBitrate(128);
encodeParams.setAudioChannels(2);
encodeParams.setVideoWidth(16);
encodeParams.setVideoHeight(16);
encodeParams.setVideoBitrate(2);
encodeParams.setVideoFramerate(15);
encodeParams.setVideoGop(2);
TencentStartMixRequest.LayoutParams layoutParams = new TencentStartMixRequest.LayoutParams();
layoutParams.setTemplate(0);
request.setEncodeParams(encodeParams);
request.setLayoutParams(layoutParams);
request.setOutputParams(outputParams);
StartMCUMixTranscodeRequest req = StartMCUMixTranscodeRequest.fromJsonString(JSON.toJSONString(request), StartMCUMixTranscodeRequest.class);
StartMCUMixTranscodeResponse resp = client.StartMCUMixTranscode(req);
JSONObject resultObj = JSON.parseObject(StartMCUMixTranscodeRequest.toJsonString(resp));
String requestId = resultObj.get("RequestId").toString();
log.info("tencentMix success. roomId:{}, requestId:{}", roomId, requestId);
} catch (TencentCloudSDKException e) {
log.error("TencentCloudSDKException error!", e);
Cat.logEvent("Tencent_MIX_ERROR", "Tencent_MIX" + roomId + ", requestId:" + e.getRequestId());
} catch (Exception e) {
log.error("tencentMix error!", e);
Cat.logEvent("Tencent_MIX_ERROR", "Tencent_MIX" + roomId);
}
}
private TrtcClient generateTrtcClient() {
Credential cred = new Credential(secretId, secretKey);
HttpProfile httpProfile = new HttpProfile();
httpProfile.setEndpoint(endpoint);
ClientProfile clientProfile = new ClientProfile();
clientProfile.setHttpProfile(httpProfile);
return new TrtcClient(cred, region, clientProfile);
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/RoomManagementService.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/RoomManagementService.java | package cn.bixin.sona.server.room.service;
import cn.bixin.sona.server.room.domain.enums.UserRoleEnum;
import java.util.List;
import java.util.Map;
public interface RoomManagementService {
/**
* 查询用户角色
*
* @param roomId: roomId
* @param uid: uid
* @return: user role
*/
UserRoleEnum getUserRole(long roomId, long uid);
/**
* 批量查询用户角色
*
* @param roomId: roomId
* @param uids: uids
* @return: user role map
*/
Map<Long, UserRoleEnum> getUserRoleBatch(long roomId, List<Long> uids);
/**
* 添加管理信息
*
* @param roomId: roomId
* @param uid: uid
* @param type: 1拉黑、2禁言、3踢出 4、管理员 5、房主
*/
int addRoomManagementInfo(long roomId, long uid, int type, long operator);
/**
* 将信息设置为无效
*
* @param roomId: roomId
* @param uid: uid
* @param type: 1拉黑、2禁言、3踢出 4、管理员 5、房主
*/
int updateManagementInfoInvalid(long roomId, long uid, int type, long operator);
/**
* 查询用户是否有管理员权限
*
* @param roomId: roomId
* @param uid: 用户uid
* @return true has auth, otherwise false
*/
boolean isUserHasAdminAuth(long roomId, long uid);
/**
* 查询用户是否被禁言
*
* @param roomId: roomId
* @param uid: 用户uid
* @return true has been muted, otherwise false
*/
boolean isUserMuted(long roomId, long uid);
/**
* 查询用户是否被踢出
*
* @param roomId: roomId
* @param uid: 用户uid
* @return true has been blocked, otherwise false
*/
boolean isUserBlocked(long roomId, long uid);
/**
* 临时禁言
*
* @param roomId 房间
* @param uid 用户
* @param minute 分钟
* @return
*/
int muteTemporary(long roomId, long uid, int minute, long operator);
/**
* 查询用户是否是管理员
*
* @param roomId: roomId
* @param uid: 用户uid
* @return true user is admin, otherwise false
*/
boolean isUserAdmin(long roomId, long uid);
/**
* 查询用户是否被禁止推流
* @param roomId
* @param uid
* @return
*/
boolean isUserStreamPushForBid(long roomId, long uid);
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/ZegoService.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/ZegoService.java | package cn.bixin.sona.server.room.service;
import cn.bixin.sona.common.trace.TraceHelper;
import cn.bixin.sona.common.util.IdGenerator;
import cn.bixin.sona.enums.RoomMixedEnum;
import cn.bixin.sona.server.room.client.MixStreamClient;
import cn.bixin.sona.server.room.config.RoomAsyncConfig;
import cn.bixin.sona.server.room.domain.convert.MixConfigConverter;
import cn.bixin.sona.server.room.domain.db.MixConfig;
import cn.bixin.sona.server.room.domain.db.Stream;
import cn.bixin.sona.server.room.domain.enums.StreamSupplierEnum;
import cn.bixin.sona.server.room.domain.request.ZegoMixRequest;
import cn.bixin.sona.server.room.domain.request.ZegoStopMixRequest;
import cn.bixin.sona.server.room.domain.stream.StreamContext;
import cn.bixin.sona.server.room.manager.AudioSwitchManager;
import cn.bixin.sona.server.room.utils.ZegoUtils;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.dianping.cat.Cat;
import com.dianping.cat.message.Transaction;
import com.google.common.base.Joiner;
import com.google.common.collect.Lists;
import io.netty.util.Timeout;
import io.netty.util.TimerTask;
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.data.redis.core.StringRedisTemplate;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import javax.annotation.Resource;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
/**
* @author qinwei
*/
@Service
public class ZegoService {
private static final Logger log = LoggerFactory.getLogger(ZegoService.class);
@Resource
private StreamService streamService;
@Resource
private IdGenerator idGenerator;
@Resource
private StringRedisTemplate stringRedisTemplate;
@Resource
private MixStreamClient mixStreamClient;
@Autowired
private MixConfigService mixConfigService;
@Resource
private AudioSwitchManager audioSwitchManager;
@Value("${zego.app.id}")
private int zegoAppId;
@Value("${zego.app.secret}")
private String zegoSecret;
@Value("${zego.start.mix.url}")
private String startMixStreamUrl;
@Value("${zego.stop.mix.url}")
private String stopMixStreamUrl;
@Value("${zego.token.url}")
private String zegoTokenUrl;
@Value("${zego.server.secret}")
private String zegoServerSecret;
@Value("${zego.mix.retry.count}")
private int retry;
private static final String KEY_ZEGO_ACCESS_TOKEN = "zego:access:token";
private static String getKeyZegoAccessToken(int zegoAppId) {
return Joiner.on(":").join(KEY_ZEGO_ACCESS_TOKEN, zegoAppId);
}
@Async("mixStreamExecutor")
public void mix(long roomId) {
TraceHelper.init();
log.info("start zego mix , roomId:{}", roomId);
Transaction transaction = Cat.newTransaction("ZegoMixStream", String.valueOf(roomId));
try {
List<Stream> streamList = getValidStreamIds(roomId);
if (CollectionUtils.isEmpty(streamList)) {
log.info("mix streamList is null. roomId:{}", roomId);
return;
}
String result = doMix(streamList, roomId);
int index = 1;
while (!doMixSuccess(result) && doMixNonExistStream(result) && index < retry) {
List<String> notExistStreamList = getNotExistSteamList(result);
if (!CollectionUtils.isEmpty(notExistStreamList)) {
notExistStreamList.forEach(s -> streamService.closeStream(s));
}
streamList = getValidStreamIds(roomId);
if (CollectionUtils.isEmpty(streamList)) {
result = "{\"code\":0,\"data\":{}}";
break;
}
result = doMix(streamList, roomId);
index++;
}
if (mixTimeoutOrOverclock(result)) {
Cat.logEvent("ZegoMixTimeoutOrOverclock", String.valueOf(roomId));
mixStream(roomId);
} else if (!doMixSuccess(result)) {
log.warn("zego mix stream failed, swith to single, roomId:{}, result:{}", roomId, result);
audioSwitchManager.roomSwitch(Lists.newArrayList(roomId), RoomMixedEnum.MIXED_ZEGO_SINGLE);
}
} catch (Exception e) {
log.error("zego mix stream failed, roomId:{}", roomId, e);
transaction.setStatus(e);
} finally {
transaction.complete();
TraceHelper.reset();
}
}
private String doMix(List<Stream> mixStreams, long roomId) {
log.info("doMix roomId:{}, zegoAppId:{}", roomId, zegoAppId);
//get zego mix request
ZegoMixRequest mixRequest = getZegoMixRequest(String.valueOf(roomId), zegoAppId);
List<ZegoMixRequest.MixInput> mixInputList = Lists.newArrayList();
//获取mix config 配置
MixConfig mixConfig = mixConfigService.getMixConfigOrDefaultAudioByRoomId(roomId);
log.info("get mix config, mixConfig: {}", mixConfig);
mixStreams.forEach(stream -> {
ZegoMixRequest.MixInput mixInput = getMixInput(stream.getStreamId(), mixConfig);
mixInput.setSound_level_id((int) stream.getUid());
mixInputList.add(mixInput);
});
mixRequest.setMixInput(mixInputList);
List<ZegoMixRequest.MixOutput> mixOutputList = Lists.newArrayList();
ZegoMixRequest.MixOutput mixOutput = getMixOutput(String.valueOf(roomId), mixConfig);
mixOutputList.add(mixOutput);
mixRequest.setMixOutput(mixOutputList);
String accessToken = getAccessToken();
String result = mixStreamClient.sendPost(startMixStreamUrl + accessToken, JSON.toJSONString(mixRequest));
log.info("doMix result:{}, roomId:{}", result, roomId);
return result;
}
/**
* get zego mix request
*/
private ZegoMixRequest getZegoMixRequest(String masterStream, int zegoAppId) {
ZegoMixRequest request = new ZegoMixRequest();
long timestamp = System.currentTimeMillis();
// request.setSignature(ZegoUtils.md5(zegoAppId + timestamp + zegoSecret));
request.setTimestamp(timestamp);
request.setId_name(masterStream);
request.setAppid(zegoAppId);
request.setSeq(Integer.parseInt(idGenerator.strId().substring(0, 9)));
request.setVersion(1);
request.setWith_sound_level(1);
return request;
}
/**
* get mix input
*/
private static ZegoMixRequest.MixInput getMixInput(String stream, MixConfig mixConfig) {
ZegoMixRequest.MixInput mixInput = new ZegoMixRequest.MixInput();
mixInput.setStream_id(stream);
ZegoMixRequest.RectInfo rectInfo = new ZegoMixRequest.RectInfo();
rectInfo.setTop(mixConfig.getTops());
rectInfo.setLeft(mixConfig.getLefts());
if (StreamContext.convertStringUid(stream).equals(mixConfig.getUid()) &&
MixConfigConverter.inMVStatus(mixConfig)) {
//混入MV用户, 单独设置配置
rectInfo.setBottom(mixConfig.getBottom());
rectInfo.setRight(mixConfig.getRights());
} else {
//其他用户默认设置音频参数
rectInfo.setBottom(16);
rectInfo.setRight(16);
}
mixInput.setRect(rectInfo);
return mixInput;
}
/**
* get mix output
*/
private static ZegoMixRequest.MixOutput getMixOutput(String masterStream, MixConfig mixConfig) {
ZegoMixRequest.MixOutput mixOutput = new ZegoMixRequest.MixOutput();
mixOutput.setStream_id(masterStream);
mixOutput.setBitrate(mixConfig.getBitrate());
mixOutput.setFps(mixConfig.getFps());
mixOutput.setHeight(mixConfig.getHeight());
mixOutput.setWidth(mixConfig.getWidth());
mixOutput.setAudio_enc_id(1);
mixOutput.setAudio_bitrate(128000);
mixOutput.setAudio_channel_cnt(2);
return mixOutput;
}
private static boolean doMixSuccess(String result) {
if (!StringUtils.hasText(result)) {
return false;
}
JSONObject resultObj = JSON.parseObject(result);
int code = resultObj.getIntValue("code");
return code == 0;
}
private static boolean mixTimeoutOrOverclock(String result) {
if (!StringUtils.hasText(result)) {
return false;
}
JSONObject resultObj = JSON.parseObject(result);
int code = resultObj.getIntValue("code");
return code == -888 || code == 5 || code == -889;
}
private static boolean doMixNonExistStream(String result) {
if (!StringUtils.hasText(result)) {
return false;
}
JSONObject resultObj = JSON.parseObject(result);
int code = resultObj.getIntValue("code");
return code == 150;
}
private static List<String> getNotExistSteamList(String result) {
JSONObject resultObj = JSON.parseObject(result);
String message = resultObj.getString("data");
JSONObject listObj = JSON.parseObject(message);
List<Object> nonExistList = listObj.getJSONArray("non_exist_streams");
if (CollectionUtils.isEmpty(nonExistList)) {
return Collections.emptyList();
}
return nonExistList.stream().map(Object::toString).collect(Collectors.toList());
}
private List<Stream> getValidStreamIds(long roomId) {
return streamService.getRoomLivingStream(roomId)
.stream()
.filter(stream -> StreamSupplierEnum.ZEGO.getCode() == stream.getSource())
.collect(Collectors.toList());
}
private String getAccessToken() {
String accessToken = stringRedisTemplate.opsForValue().get(getKeyZegoAccessToken(zegoAppId));
log.info("getAccessToken, accessToken:{}, zegoAppId:{}", accessToken, zegoAppId);
if (StringUtils.hasText(accessToken)) {
return accessToken;
}
accessToken = getToken(zegoAppId, zegoServerSecret, zegoTokenUrl);
if (accessToken == null) {
return null;
}
stringRedisTemplate.opsForValue().set(getKeyZegoAccessToken(zegoAppId), accessToken, 30, TimeUnit.MINUTES);
return accessToken;
}
public String getToken(int appid, String serverSecret, String url) {
String result = mixStreamClient.sendGet(url, "appid=" + appid + "&secret=" + serverSecret);
log.info("getToken, result:{}", result);
if (result == null) {
return null;
}
String token = JSON.parseObject(result).getJSONObject("data").getString("access_token");
log.info("getToken, access_token:{}", token);
return token;
}
private void mixStream(long roomId) {
RoomAsyncConfig.MIX_STREAM_TIMER.newTimeout(new TimerTask() {
@Override
public void run(Timeout timeout) throws Exception {
mix(roomId);
}
}, 1500, TimeUnit.MILLISECONDS);
}
public String stopMix(String roomId) {
ZegoStopMixRequest mixRequest = new ZegoStopMixRequest();
long timestamp = System.currentTimeMillis();
mixRequest.setAppid(zegoAppId);
mixRequest.setTimestamp(timestamp);
mixRequest.setSignature(ZegoUtils.md5(zegoAppId + timestamp + zegoSecret));
mixRequest.setId_name(roomId);
mixRequest.setLive_channel(roomId);
mixRequest.setStream_id(roomId);
mixRequest.setSeq(Integer.parseInt(idGenerator.strId().substring(0, 9)));
return stopMix(mixRequest);
}
public String stopMix(ZegoStopMixRequest request) {
String accessToken = getAccessToken();
String result = mixStreamClient.sendPost(stopMixStreamUrl + accessToken, JSON.toJSONString(request));
log.info("zego stopMix result:{}", result);
return result;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/ProductConfigService.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/ProductConfigService.java | package cn.bixin.sona.server.room.service;
import cn.bixin.sona.server.room.domain.db.ProductConfig;
import cn.bixin.sona.server.room.domain.db.RoomConfig;
import java.util.List;
import java.util.Map;
public interface ProductConfigService {
/**
* 查询配置信息
*
* @param productCode: 产品code
* @return: config info
*/
ProductConfig getConfigInfoByCode(String productCode);
ProductConfig getConfigInfoByShortCode(String shortCode);
/**
* 获取房间配置信息
* @param roomId: roomId
* @return config info
*/
RoomConfig getRoomConfig(long roomId);
Map<Long, RoomConfig> getRoomConfigBatch(List<Long> roomIds);
boolean addRoomConfig(List<RoomConfig> wrapNewRoomConfig);
boolean updateRoomConfigAudioStreams(List<RoomConfig> configs);
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/StreamOperation.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/StreamOperation.java | package cn.bixin.sona.server.room.service;
import cn.bixin.sona.request.callback.CloseStreamCallback;
import cn.bixin.sona.request.callback.CreateReplayCallback;
import cn.bixin.sona.request.callback.CreateStreamCallback;
import cn.bixin.sona.request.callback.MixStreamEndCallback;
import cn.bixin.sona.request.callback.MixStreamStartCallback;
import cn.bixin.sona.server.room.domain.stream.StreamContext;
public interface StreamOperation {
void handleCreate(CreateStreamCallback callback);
void handleClose(CloseStreamCallback callback);
void handleReplay(CreateReplayCallback callback);
void handleAdd(StreamContext context);
void handleClose(StreamContext context);
void handleMixStart(MixStreamStartCallback callback);
void handleMixEnd(MixStreamEndCallback callback);
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/MixConfigService.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/MixConfigService.java | package cn.bixin.sona.server.room.service;
import cn.bixin.sona.server.room.domain.db.MixConfig;
/**
* @author 木欣
* @create 2021-05-27
* @email baojiawei@bixin.cn
* create by intelliJ IDEA
*/
public interface MixConfigService {
/**
* 创建混流配置
*
* @param mixConfig
*/
void createMixConfig(MixConfig mixConfig);
/**
* 更新混流配置
*
* @param defaultAudioMixConfig
*/
void updateMixConfig(MixConfig defaultAudioMixConfig);
/**
* 通过房间ID获取混流参数
*
* @param roomId
* @return
*/
MixConfig getMixConfigByRoomId(Long roomId);
/**
* 获取混流配置, 如果为空走默认音频配置.
*
* @param roomId
* @return
*/
MixConfig getMixConfigOrDefaultAudioByRoomId(Long roomId);
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/GroupService.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/GroupService.java | package cn.bixin.sona.server.room.service;
import cn.bixin.sona.common.dto.PageResult;
import java.util.List;
import java.util.Map;
/**
* 群组类型房间Service
*/
public interface GroupService {
boolean enterGroup(long roomId, String productCode, long uid);
boolean leaveGroup(long roomId, long uid);
boolean removeGroupMembers(long roomId);
long getGroupMemberCount(long roomId);
Map<Long, Long> batchGetGroupMemberCount(List<Long> roomIds);
PageResult<Long> getRoomMemberList(long roomId, String anchor, int limit);
Map<Long, Boolean> isUserInGroup(long roomId, List<Long> uids);
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/ChatroomService.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/ChatroomService.java | package cn.bixin.sona.server.room.service;
import cn.bixin.sona.common.dto.PageResult;
import cn.bixin.sona.enums.UserTypeEnum;
import java.util.List;
import java.util.Map;
/**
* 聊天室类型房间service
*/
public interface ChatroomService {
boolean enterChatroom(long roomId, long uid, UserTypeEnum userType, Integer score);
boolean leaveChatroom(long roomId, long uid);
void removeChatroomUsers(long roomId);
boolean kickoutChatroom(long roomId, long uid);
boolean updateUserScore(long roomId, long uid, int score);
long getChatroomUserCount(long roomId);
Map<Long, Long> batchGetChatroomUserCount(List<Long> roomIds);
PageResult<Long> getChatroomUserList(long roomId, String anchor, int limit);
Map<Long, Boolean> isUserInChatroom(long roomId, List<Long> uids);
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/MessageService.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/MessageService.java | package cn.bixin.sona.server.room.service;
import cn.bixin.sona.server.room.constant.ChatRoomConstant;
import cn.bixin.sona.server.room.domain.db.Stream;
import org.springframework.scheduling.annotation.Async;
import java.util.List;
import java.util.Map;
public interface MessageService {
/**
* 发送创建房间消息
*
* @param roomId: roomId
* @param uid: uid
* @param imModule
*/
void sendSonaCreateRoomMessage(long roomId, long uid, String imModule);
/**
* 发送关闭房间消息
*
* @param roomId: roomId
* @param uid: uid
* @param imModule
*/
void sendSonaCloseRoomMessage(long roomId, long uid, String imModule);
/**
* 发送进入房间消息
*
* @param roomId: roomId
* @param uid: uid
* @param imModule
*/
void sendSonaEnterRoomMessage(long roomId, long uid, String imModule);
/**
* 离开进入房间消息
*
* @param roomId: roomId
* @param uid: uid
* @param imModule
*/
void sendSonaLeaveRoomMessage(long roomId, long uid, String imModule);
/**
* 设置/取消禁言消息
*
* @param roomId: roomId
* @param uid: uid
* @param setMute: true set mute, false cancel mute
* @param minute: mute minutes, mute forever if minute is null
*
*/
void sendSonaMuteMessage(long roomId, long uid, boolean setMute, Integer minute, String imModule);
/**
* 设置/取消拉黑消息
*
* @param roomId: roomId
* @param uid: uid
* @param setBlock: true set block, false remove block
*
*/
void sendSonaBlockMessage(long roomId, long uid, boolean setBlock, String imModule);
/**
* 踢人消息
*
* @param roomId: roomId
* @param uid: uid
*/
void sendSonaKickMessage(long roomId, long uid, String imModule);
/**
* 设置/取消管理员消息
*
* @param roomId: roomId
* @param uid: uid
* @param setAdmin: true set admin, false remove admin
*/
void sendSonaAdminMessage(long roomId, long uid, boolean setAdmin, String imModule);
/**
* 设置/取消静音消息
*
* @param roomId: roomId
* @param streamList: streamList
* @param setMute: true set mute, otherwise cancel mute
*/
void sendSonaMuteStreamMessage(long roomId, List<Stream> streamList, boolean setMute, String imModule);
/**
* 发送热切消息
* @param roomId
* @param contentMap
* @param imModule
*/
void sendSonaHotSwitchMessage(Long roomId, Map<String, Object> contentMap, String imModule);
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/RoomService.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/RoomService.java | package cn.bixin.sona.server.room.service;
import cn.bixin.sona.common.dto.PageResult;
import cn.bixin.sona.dto.RoomDTO;
import cn.bixin.sona.request.CreateRoomRequest;
import cn.bixin.sona.request.OpenCloseRoomRequest;
import cn.bixin.sona.server.room.domain.db.ProductConfig;
import cn.bixin.sona.server.room.domain.db.Room;
import java.util.List;
import java.util.Map;
public interface RoomService {
/**
* 获取房间
*
* @param roomId
* @return RoomDTO
*/
RoomDTO getRoomByRoomId(long roomId);
/**
* 批量获取房间
*
* @param roomIds
* @return RoomDTO
*/
Map<Long, RoomDTO> batchGetRooms(List<Long> roomIds);
/**
* 创建聊天室
* @param request: create chatroom request
*
* @return roomId: 内部房间Id
*/
Room createRoom(CreateRoomRequest request, ProductConfig config);
/**
* 打开聊天室
* @param request
*/
void openRoom(OpenCloseRoomRequest request);
/**
* 关闭聊天室
* @param request
* @return
*/
boolean closeRoom(OpenCloseRoomRequest request);
/**
* 修改密码
*
* @param roomId: 房间id(主键)
* @param password
*
* @return true update success, otherwise false
*/
boolean updatePassword(long roomId, String password);
/**
* 获取在线房间列表
* @param anchor
* @param limit
* @return
*/
PageResult<RoomDTO> getOnlineRoomList(String anchor, int limit);
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/StreamService.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/StreamService.java | package cn.bixin.sona.server.room.service;
import cn.bixin.sona.dto.AppInfoDTO;
import cn.bixin.sona.request.callback.CloseStreamCallback;
import cn.bixin.sona.request.callback.CreateReplayCallback;
import cn.bixin.sona.request.callback.CreateStreamCallback;
import cn.bixin.sona.request.callback.MixStreamEndCallback;
import cn.bixin.sona.request.callback.MixStreamStartCallback;
import cn.bixin.sona.server.room.domain.db.ProductConfig;
import cn.bixin.sona.server.room.domain.db.Stream;
import cn.bixin.sona.server.room.domain.stream.StreamContext;
import cn.bixin.sona.server.room.domain.stream.UserSginInputParam;
import java.util.List;
import java.util.Map;
public interface StreamService {
/**
* 初始化流
*/
String initStream(long roomId, long uid, ProductConfig config);
/**
* 获取用户有效的流
*
* @param uid: uid
* @return streamId
*/
Stream getUserLivingStream(long roomId, long uid);
/**
* 根据streamId获取stream对象
*
* @param streamId: streamId
* @return stream info
*/
Stream getStreamByStreamId(String streamId);
/**
* 批量获取用户有效流
* @param roomId
* @param uids
* @return
*/
Map<Long, Stream> batchGetUserLivingStream(long roomId, List<Long> uids);
List<Stream> getRoomLivingStream(long roomId);
boolean addStream(StreamContext streamContext);
boolean closeStream(String streamId);
/**
* 获取房间内单流的播放地址
*
* @param roomId
* @param supplier
* @return play url
*/
String getPlayUrl(long roomId, String supplier);
AppInfoDTO genUserSig(UserSginInputParam userSginInputParam);
/**
* 处理推流回调
*
* @param callback: {@link CreateStreamCallback}
*/
boolean createStreamCallback(CreateStreamCallback callback);
/**
* 处理关流回调
*
* @param callback: {@link CreateStreamCallback}
*/
boolean closeStreamCallback(CloseStreamCallback callback);
/**
* 处理回放回调
*
* @param callback: {@link CreateStreamCallback}
*/
void replayStreamCallback(CreateReplayCallback callback);
/**
* 处理 混流录制
* @param callback
*/
boolean handleMixReplay(CreateReplayCallback callback);
void addMixStream(MixStreamStartCallback callback, long roomId);
void stopMixStream(MixStreamEndCallback callback);
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/redis/StreamMixRedisRepo.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/redis/StreamMixRedisRepo.java | package cn.bixin.sona.server.room.service.redis;
import cn.bixin.sona.server.room.domain.db.MixConfig;
import com.alibaba.fastjson.JSONObject;
import com.google.common.base.Joiner;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
/**
* @author 木欣
* @create 2021-04-20
* @email baojiawei@bixin.cn
* create by intelliJ IDEA
*/
@Component
public class StreamMixRedisRepo {
@Autowired
private StringRedisTemplate redisTemplate;
/**
* Mix mv config redis key
*/
private static final String MIX_MV_CONFIG = "mix:mv:config";
/**
* get mix mv config
*
* @param roomId
* @return
*/
private String getMixMVConfigKey(Long roomId) {
return Joiner.on(":").join(MIX_MV_CONFIG, roomId);
}
/**
* Get redis mv config
*
* @param roomId
* @return
*/
public MixConfig getMixMVConfig(Long roomId) {
String mixConfig = redisTemplate.opsForValue().get(getMixMVConfigKey(roomId));
return JSONObject.parseObject(mixConfig, MixConfig.class);
}
/**
* Set mix mv config
*
* @param roomId
* @param mixConfig
*/
public void setMixMVConfig(Long roomId, MixConfig mixConfig) {
//default ttl 24h
redisTemplate.opsForValue().set(getMixMVConfigKey(roomId), JSONObject.toJSONString(mixConfig));
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/redis/ChatroomRedisRepo.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/redis/ChatroomRedisRepo.java | package cn.bixin.sona.server.room.service.redis;
import com.google.common.base.Joiner;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;
@Component
public class ChatroomRedisRepo {
private static final Logger log = LoggerFactory.getLogger(ChatroomRedisRepo.class);
@Autowired
private StringRedisTemplate redisTemplate;
public static final int SMALL_RANGE_SIZE = 200;
/**
* 长连全量在线列表
*/
private static final String SONA_KEY_CHATROOM_ALL_USER = "sona:all:u:set";
public String getSonaChatroomAllUserKey(long roomId) {
return Joiner.on(":").join(SONA_KEY_CHATROOM_ALL_USER, roomId);
}
/**
* 小群组在线列表
*/
private static final String SONA_KEY_CHATROOM_SMALL_RANGE_USER = "sona:c:u:zs";
public String getSonaSmallRangeKey(long roomId) {
return Joiner.on(":").join(SONA_KEY_CHATROOM_SMALL_RANGE_USER, roomId);
}
private String getSonaChatroomVipUserKey(long roomId, long uid) {
return Joiner.on(":").join("vip:user:info:", roomId, uid);
}
/**
* 活跃房间列表key
*/
private static final String SONA_ACTIVE_ROOM_KEY_PREFIX = "sona:active:room";
private String getActiveRoomSetRedisKey() {
return Joiner.on(":").join(SONA_ACTIVE_ROOM_KEY_PREFIX, getPushForward5MinSeconds());
}
/**
* sona:kick:out:user:flag
*
* @param roomId
* @param targetUid
* @return
*/
private String getKickOutUserFlag(long roomId, String targetUid) {
return Joiner.on(":").join("s:k:o:u:f", roomId, targetUid);
}
/**
* 获取在线人数
*
* @param roomId
* @return
*/
public long getOnlineUserCount(long roomId) {
Long count = redisTemplate.opsForSet().size(getSonaChatroomAllUserKey(roomId));
return count == null ? 0L : count;
}
/**
* 更新用户得分(长连在线列表)
*
* @param roomId 房间ID
* @param uid 用户uid
* @param score 用户得分
*/
public void updateUserScore(long roomId, long uid, int score) {
if (Boolean.FALSE.equals(redisTemplate.opsForSet().isMember(getSonaChatroomAllUserKey(roomId), String.valueOf(uid)))) {
return;
}
String key = getSonaSmallRangeKey(roomId);
redisTemplate.opsForZSet().add(key, String.valueOf(uid), score);
redisTemplate.expire(key, 12, TimeUnit.HOURS);
Long size = redisTemplate.opsForZSet().zCard(key);
if (size != null && size > SMALL_RANGE_SIZE) {
redisTemplate.opsForZSet().removeRange(key, 0, 0);
}
}
public void leaveChatroom(long roomId, long uid) {
RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
RedisCallback<String> callback = connection -> {
connection.sRem(serializer.serialize(getSonaChatroomAllUserKey(roomId)), serializer.serialize(String.valueOf(uid)));
connection.zRem(serializer.serialize(getSonaSmallRangeKey(roomId)), serializer.serialize(String.valueOf(uid)));
connection.del(serializer.serialize(getSonaChatroomVipUserKey(roomId, uid)));
return null;
};
redisTemplate.executePipelined(callback);
}
public void enterChatroom(long roomId, long uid) {
redisTemplate.opsForSet().add(getSonaChatroomAllUserKey(roomId), uid + "");
redisTemplate.expire(getSonaChatroomAllUserKey(roomId), 120, TimeUnit.MINUTES);
}
/**
* 加入活跃房间列表
*
* @param roomId 房间ID
*/
public void joinActiveRoomSet(long roomId) {
if (activeRoomExists(roomId)) {
return;
}
redisTemplate.opsForZSet().add(getActiveRoomSetRedisKey(), String.valueOf(roomId), System.currentTimeMillis());
redisTemplate.expire(getActiveRoomSetRedisKey(), 20, TimeUnit.MINUTES);
}
/**
* 设置用户被踢出房间标识
*
* @param roomId 房间ID
* @param targetUid 目标用户
*/
public void setKickOutUserFlag(long roomId, long targetUid) {
String kickOutFlag = getKickOutUserFlag(roomId, String.valueOf(targetUid));
//Set flag five minutes
redisTemplate.opsForValue().set(kickOutFlag, String.valueOf(targetUid), 5, TimeUnit.MINUTES);
}
private boolean activeRoomExists(long roomId) {
Long rank = redisTemplate.opsForZSet().rank(getActiveRoomSetRedisKey(), String.valueOf(roomId));
return rank != null && (rank > 0);
}
/**
* 获取当前时间往前推5分钟的一个整秒数
*
* <p>
* 2021-10-11 15:55:30 -> 2021-10-11 15:55:00
* 2021-10-11 15:51:10 -> 2021-10-11 15:50:00
* </p>
*/
private static long getPushForward5MinSeconds() {
ZonedDateTime time = LocalDateTime.now().atZone(ZoneId.systemDefault());
return time.minusMinutes(time.getMinute() % 5).minusSeconds(time.getSecond()).toLocalDateTime().toEpochSecond(ZoneOffset.of("+8"));
}
/**
* 分页获取聊天室在线人数列表
*
* @param roomId 房间ID
* @param limit 条数
* @return
*/
public Set<String> getAllUserUidListByLimit(long roomId, int limit) {
return redisTemplate.opsForSet().distinctRandomMembers(getSonaChatroomAllUserKey(roomId), limit);
}
/**
* 用户是否被踢出了某个房间
*
* @param roomId 房间ID
* @param targetUid 目标用户uid
*/
public boolean hasKickOut(long roomId, String targetUid) {
return redisTemplate.hasKey(getKickOutUserFlag(roomId, targetUid));
}
/**
* 用户是否在在线列表中
*
* @param roomId 房间ID
* @param uid 用户ID
* @return TRUE/FALSE
*/
public boolean userExistInOnlineList(long roomId, String uid) {
try {
return Boolean.TRUE.equals(redisTemplate.opsForSet().isMember(getSonaChatroomAllUserKey(roomId), uid));
} catch (Exception e) {
log.error("判断用户是否在在线列表中失败, roomId:[{}], uid:[{}]", roomId, uid, e);
return false;
}
}
public void enterChatroom(long roomId, String uid, int score) {
RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
RedisCallback<String> callback = connection -> {
byte[] allSet = serializer.serialize(getSonaChatroomAllUserKey(roomId));
connection.sAdd(allSet, serializer.serialize(uid));
connection.expire(allSet, 12 * 60 * 60);
byte[] smallSet = serializer.serialize(getSonaSmallRangeKey(roomId));
connection.zAdd(smallSet, score, serializer.serialize(uid));
connection.expire(smallSet, 12 * 60 * 60);
connection.zCard(smallSet);
return null;
};
List<Object> results = redisTemplate.executePipelined(callback);
Long size = (Long) results.get(results.size() - 1);
if (size != null && size > SMALL_RANGE_SIZE) {
redisTemplate.opsForZSet().removeRange(getSonaSmallRangeKey(roomId), 0, 0);
}
}
public String getChatroomVipUser(long roomId, String uid) {
return redisTemplate.opsForValue().get(getSonaChatroomVipUserKey(roomId, Long.parseLong(uid)));
}
public void saveUserVipInfo(long roomId, long uid) {
redisTemplate.opsForValue().set(getSonaChatroomVipUserKey(roomId, uid), "0", 12, TimeUnit.HOURS);
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/impl/MixConfigServiceImpl.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/impl/MixConfigServiceImpl.java | package cn.bixin.sona.server.room.service.impl;
import cn.bixin.sona.server.room.domain.convert.MixConfigConverter;
import cn.bixin.sona.server.room.domain.db.MixConfig;
import cn.bixin.sona.server.room.mapper.MixConfigMapper;
import cn.bixin.sona.server.room.service.MixConfigService;
import cn.bixin.sona.server.room.service.redis.StreamMixRedisRepo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Objects;
/**
* @author 木欣
* @create 2021-05-27
* @email baojiawei@bixin.cn
* create by intelliJ IDEA
*/
@Component
public class MixConfigServiceImpl implements MixConfigService {
private static final Logger log = LoggerFactory.getLogger(MixConfigServiceImpl.class);
@Autowired
private MixConfigMapper mixConfigMapper;
@Autowired
private StreamMixRedisRepo streamMixRedisRepo;
@Override
public void createMixConfig(MixConfig mixConfig) {
int count = mixConfigMapper.insertOrUpdate(mixConfig);
if (count > 0) {
streamMixRedisRepo.setMixMVConfig(mixConfig.getRoomId(), mixConfig);
}
}
@Override
public void updateMixConfig(MixConfig mixConfig) {
int count = mixConfigMapper.updateMixConfig(mixConfig);
if (count > 0) {
streamMixRedisRepo.setMixMVConfig(mixConfig.getRoomId(), mixConfig);
}
}
@Override
public MixConfig getMixConfigByRoomId(Long roomId) {
MixConfig config = streamMixRedisRepo.getMixMVConfig(roomId);
if (Objects.isNull(config)) {
return mixConfigMapper.getMixConfigByRoomId(roomId);
}
return config;
}
@Override
public MixConfig getMixConfigOrDefaultAudioByRoomId(Long roomId) {
MixConfig mixConfig = getMixConfigByRoomId(roomId);
if (Objects.isNull(mixConfig)) {
log.info("mix config is null, get default config, roomId: {}", roomId);
mixConfig = MixConfigConverter.defaultAudioMixConfig(roomId, "");
}
return mixConfig;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/impl/ChatroomServiceImpl.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/impl/ChatroomServiceImpl.java | package cn.bixin.sona.server.room.service.impl;
import cn.bixin.sona.common.dto.PageResult;
import cn.bixin.sona.enums.UserTypeEnum;
import cn.bixin.sona.server.room.service.ChatroomService;
import cn.bixin.sona.server.room.service.redis.ChatroomRedisRepo;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import org.apache.commons.collections.CollectionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
@Service
public class ChatroomServiceImpl implements ChatroomService {
private static final Logger log = LoggerFactory.getLogger(ChatroomServiceImpl.class);
@Resource
private ChatroomRedisRepo chatroomRedisRepo;
@Autowired
private StringRedisTemplate redisTemplate;
@Override
public boolean enterChatroom(long roomId, long uid, UserTypeEnum userType, Integer score) {
chatroomRedisRepo.joinActiveRoomSet(roomId);
// chatroomRedisRepo.enterChatroom(roomId, uid);
if (userType == UserTypeEnum.VIP) {
// chatroomRedisRepo.updateUserScore(roomId, uid, score);
chatroomRedisRepo.saveUserVipInfo(roomId, uid);
}
return true;
}
@Override
public boolean leaveChatroom(long roomId, long uid) {
chatroomRedisRepo.joinActiveRoomSet(roomId);
// chatroomRedisRepo.leaveChatroom(roomId, uid);
return true;
}
@Override
public void removeChatroomUsers(long roomId) {
redisTemplate.delete(Lists.newArrayList(
chatroomRedisRepo.getSonaChatroomAllUserKey(roomId),
chatroomRedisRepo.getSonaSmallRangeKey(roomId)));
}
@Override
public boolean kickoutChatroom(long roomId, long uid) {
boolean ret = leaveChatroom(roomId, uid);
if (ret) {
chatroomRedisRepo.setKickOutUserFlag(roomId, uid);
}
return ret;
}
@Override
public boolean updateUserScore(long roomId, long uid, int score) {
chatroomRedisRepo.updateUserScore(roomId, uid, score);
return true;
}
@Override
public long getChatroomUserCount(long roomId) {
return chatroomRedisRepo.getOnlineUserCount(roomId);
}
@Override
public Map<Long, Long> batchGetChatroomUserCount(List<Long> roomIds) {
if (CollectionUtils.isEmpty(roomIds)) {
return Collections.emptyMap();
}
Map<Long, Long> onlineNums = multiGetOnlineNums(roomIds);
Map<Long, Long> result = Maps.newHashMap();
roomIds.forEach(roomId -> {
long count = onlineNums.getOrDefault(roomId, 0L);
result.put(roomId, count);
});
return result;
}
private Map<Long, Long> multiGetOnlineNums(List<Long> roomIds) {
Map<Long, Long> map = Maps.newHashMap();
int limit = 30;
int size = roomIds.size();
int index = 0;
do {
int endIndex = size - index >= limit ? limit + index : size;
int len = Math.min(size - index, limit);
List<Long> subRoomIds = roomIds.subList(index, endIndex);
index = index + len;
List<Object> executeResultList = redisTemplate.executePipelined((RedisCallback<Object>) connection -> {
connection.openPipeline();
RedisSerializer<String> keySerializer = new StringRedisSerializer();
subRoomIds.forEach(roomId -> {
String key = chatroomRedisRepo.getSonaChatroomAllUserKey(roomId);
byte[] redisKey = keySerializer.serialize(key);
connection.sCard(redisKey);
});
return null;
});
if (CollectionUtils.isEmpty(executeResultList)) {
return map;
}
subRoomIds.forEach(roomId -> {
int idx = subRoomIds.indexOf(roomId);
long count = executeResultList.get(idx) == null ? 0 : Long.parseLong(executeResultList.get(idx) + "");
map.put(roomId, count);
});
} while (index < size);
return map;
}
@Override
public PageResult<Long> getChatroomUserList(long roomId, String anchor, int limit) {
int start = Integer.parseInt(anchor);
int end = start + limit;
long count = chatroomRedisRepo.getOnlineUserCount(roomId);
if (start > count) {
return PageResult.newPageResult(Lists.newArrayList(), true, count, anchor);
}
String smallRangeKey = chatroomRedisRepo.getSonaSmallRangeKey(roomId);
Long smallRangeSize = redisTemplate.opsForZSet().zCard(smallRangeKey);
if (smallRangeSize == null || start >= smallRangeSize) {
List<String> uids = getUids(roomId, limit);
return PageResult.newPageResult(uids.stream().map(Long::parseLong).collect(Collectors.toList()),
uids.size() < limit, count, anchor);
}
if (end <= smallRangeSize) {
Set<String> uidSet = redisTemplate.opsForZSet().reverseRange(smallRangeKey, start, end - 1);
return PageResult.newPageResult(uidSet.stream().map(Long::parseLong).collect(Collectors.toList()),
uidSet.size() < limit, count, String.valueOf(end));
}
Set<String> uidSet = redisTemplate.opsForZSet().reverseRange(smallRangeKey, start, smallRangeSize - 1);
if (CollectionUtils.isEmpty(uidSet)) {
uidSet = Sets.newHashSet();
}
List<String> uids = getUids(roomId, limit);
uidSet.addAll(uids);
return PageResult.newPageResult(uidSet.stream().map(Long::parseLong).collect(Collectors.toList()),
uidSet.size() < limit || limit >= count, count, String.valueOf(end));
}
private List<String> getUids(long roomId, int limit) {
return Lists.newArrayList(chatroomRedisRepo.getAllUserUidListByLimit(roomId, limit));
}
@Override
public Map<Long, Boolean> isUserInChatroom(long roomId, List<Long> uids) {
List<String> uidStringList = uids.stream().map(String::valueOf).collect(Collectors.toList());
List<Boolean> list = sIsMembers(chatroomRedisRepo.getSonaChatroomAllUserKey(roomId), uidStringList);
Map<Long, Boolean> result = Maps.newHashMap();
for (int i = 0; i < uids.size(); i++) {
result.put(uids.get(i), list.get(i));
}
return result;
}
private List<Boolean> sIsMembers(String key, List<String> members) {
List<Object> result = redisTemplate.executePipelined(new RedisCallback<Object>() {
@Override
public Long doInRedis(RedisConnection connection) throws DataAccessException {
connection.openPipeline();
RedisSerializer<String> keySerializer = new StringRedisSerializer();
RedisSerializer<String> valueSerializer = new StringRedisSerializer();
byte[] keyByte = keySerializer.serialize(key);
members.forEach(member -> {
byte[] value = valueSerializer.serialize(member);
connection.sIsMember(keyByte, value);
});
return null;
}
});
return result.stream().map(Boolean.TRUE::equals).collect(Collectors.toList());
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/impl/RoomManagementServiceImpl.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/impl/RoomManagementServiceImpl.java | package cn.bixin.sona.server.room.service.impl;
import cn.bixin.sona.server.room.domain.db.RoomManagementInfo;
import cn.bixin.sona.server.room.domain.db.RoomManagementLog;
import cn.bixin.sona.server.room.domain.enums.OperateEnum;
import cn.bixin.sona.server.room.domain.enums.RoomManagementEnum;
import cn.bixin.sona.server.room.domain.enums.UserRoleEnum;
import cn.bixin.sona.server.room.mapper.RoomManagementInfoMapper;
import cn.bixin.sona.server.room.mapper.RoomManagementLogMapper;
import cn.bixin.sona.server.room.service.RoomManagementService;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import javax.annotation.Resource;
import java.util.Collections;
import java.util.List;
import java.util.Map;
@Service
public class RoomManagementServiceImpl implements RoomManagementService {
private static final Logger log = LoggerFactory.getLogger(RoomManagementServiceImpl.class);
@Resource
private RoomManagementInfoMapper roomManagementInfoMapper;
@Resource
private RoomManagementLogMapper roomManagementLogMapper;
@Override
public UserRoleEnum getUserRole(long roomId, long uid) {
log.info("getUserRole roomId:{}, uid:{}", roomId, uid);
List<RoomManagementInfo> infoList = roomManagementInfoMapper.getUserAllValidManagementInfo(roomId, String.valueOf(uid));
if (CollectionUtils.isEmpty(infoList)) {
return UserRoleEnum.MEMBER;
}
for (RoomManagementInfo info : infoList) {
if (info.getType() == RoomManagementEnum.ADMIN.getCode()) {
return UserRoleEnum.ADMIN;
}
if (info.getType() == RoomManagementEnum.OWNER.getCode()) {
return UserRoleEnum.OWNER;
}
}
return UserRoleEnum.MEMBER;
}
@Override
public Map<Long, UserRoleEnum> getUserRoleBatch(long roomId, List<Long> uids) {
log.info("getUserRoleBatch roomId:{}, uids:{}", roomId, uids);
if (CollectionUtils.isEmpty(uids)) {
return Collections.emptyMap();
}
List<RoomManagementInfo> userInfoList = roomManagementInfoMapper.getUserManagementInfoBatch(roomId, convertLongToStringList(uids));
Map<Long, UserRoleEnum> roleMap = Maps.newHashMap();
if (CollectionUtils.isEmpty(userInfoList)) {
uids.forEach(uid -> roleMap.put(uid, UserRoleEnum.MEMBER));
} else {
userInfoList.forEach(userInfo -> roleMap.put(Long.valueOf(userInfo.getUid()), UserRoleEnum.getRoleByCode(userInfo.getType())));
uids.forEach(uid -> roleMap.putIfAbsent(uid, UserRoleEnum.MEMBER));
}
return roleMap;
}
private List<String> convertLongToStringList(List<Long> longList) {
if (CollectionUtils.isEmpty(longList)) {
return Collections.emptyList();
}
List<String> list = Lists.newArrayList();
longList.forEach(each -> list.add(String.valueOf(each)));
return list;
}
@Override
public boolean isUserMuted(long roomId, long uid) {
log.info("isUserMuted roomId:{}, uid:{}", roomId, uid);
RoomManagementInfo info = roomManagementInfoMapper.getUserManagementInfoByType(roomId, String.valueOf(uid), RoomManagementEnum.MUTE.getCode());
if (info == null) {
return false;
}
return !(info.getExpireTime() != null && System.currentTimeMillis() >= info.getExpireTime().getTime());
}
@Override
public boolean isUserBlocked(long roomId, long uid) {
log.info("isUserBlocked roomId:{}, uid:{}", roomId, uid);
RoomManagementInfo info = roomManagementInfoMapper.getUserManagementInfoByType(roomId, String.valueOf(uid), RoomManagementEnum.BLOCK.getCode());
return info != null;
}
@Override
public boolean isUserAdmin(long roomId, long uid) {
log.info("isUserAdmin roomId:{}, uid:{}", roomId, uid);
RoomManagementInfo info = roomManagementInfoMapper.getUserManagementInfoByType(roomId, String.valueOf(uid), RoomManagementEnum.ADMIN.getCode());
return info != null;
}
@Override
public boolean isUserStreamPushForBid(long roomId, long uid) {
log.info("isUserStreamPushForBid roomId:{}, uid:{}", roomId, uid);
RoomManagementInfo info = roomManagementInfoMapper.getUserManagementInfoByType(roomId, String.valueOf(uid), RoomManagementEnum.STREAM_PUSH_FORBID.getCode());
return info != null;
}
@Override
public int addRoomManagementInfo(long roomId, long uid, int type, long operator) {
log.info("addRoomManagementInfo roomId:{}, uid:{}, type:{}", roomId, uid, type);
int ret = roomManagementInfoMapper.insertSelective(RoomManagementInfo.wrapNewObj(roomId, uid, type));
if (ret > 0) {
roomManagementLogMapper.insertSelective(RoomManagementLog.wrapRecordObj(roomId, uid, type, OperateEnum.SET.getCode(), operator));
}
return ret;
}
@Override
public int updateManagementInfoInvalid(long roomId, long uid, int type, long operator) {
log.info("updateManagementInfoInvalid roomId:{}, uid:{}, type:{}", roomId, uid, type);
int ret = roomManagementInfoMapper.invalid(roomId, String.valueOf(uid), type);
if (ret > 0) {
roomManagementLogMapper.insertSelective(RoomManagementLog.wrapRecordObj(roomId, uid, type, OperateEnum.CANCEL.getCode(), operator));
}
return ret;
}
@Override
public int muteTemporary(long roomId, long uid, int minute, long operator) {
log.info("muteTemporary roomId:{}, uid:{}, minute:{}", roomId, uid, minute);
int ret = roomManagementInfoMapper.insertSelective(RoomManagementInfo.wrapNewObj(roomId, uid, RoomManagementEnum.MUTE.getCode(), minute));
if (ret > 0) {
roomManagementLogMapper.insertSelective(RoomManagementLog.wrapRecordObj(roomId, uid, RoomManagementEnum.MUTE.getCode(), OperateEnum.SET.getCode(), operator));
}
return ret;
}
@Override
public boolean isUserHasAdminAuth(long roomId, long uid) {
log.info("isUserHasAuth roomId:{}, uid:{}", roomId, uid);
return roomManagementInfoMapper.isUserAdminOrOwner(roomId, String.valueOf(uid)) > 0;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/impl/StreamServiceImpl.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/impl/StreamServiceImpl.java | package cn.bixin.sona.server.room.service.impl;
import cn.bixin.sona.common.exception.YppRunTimeException;
import cn.bixin.sona.common.util.IdGenerator;
import cn.bixin.sona.dto.AppInfoDTO;
import cn.bixin.sona.dto.RoomDTO;
import cn.bixin.sona.request.callback.*;
import cn.bixin.sona.server.exception.ExceptionCode;
import cn.bixin.sona.server.room.domain.db.MixStream;
import cn.bixin.sona.server.room.domain.db.MixStreamReplay;
import cn.bixin.sona.server.room.domain.db.ProductConfig;
import cn.bixin.sona.server.room.domain.db.Stream;
import cn.bixin.sona.server.room.domain.enums.StreamSupplierEnum;
import cn.bixin.sona.server.room.domain.stream.StreamContext;
import cn.bixin.sona.server.room.domain.stream.UserSginInputParam;
import cn.bixin.sona.server.room.mapper.MixStreamMapper;
import cn.bixin.sona.server.room.mapper.MixStreamReplayMapper;
import cn.bixin.sona.server.room.mapper.StreamMapper;
import cn.bixin.sona.server.room.service.RoomService;
import cn.bixin.sona.server.room.service.StreamService;
import cn.bixin.sona.server.room.utils.TLSSigAPIv2;
import cn.bixin.sona.server.room.utils.ZegoUtils;
import com.alibaba.fastjson.JSON;
import com.google.common.base.Joiner;
import com.google.common.collect.Lists;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
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.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;
import java.util.stream.Collectors;
@Service
public class StreamServiceImpl implements StreamService {
private static final Logger log = LoggerFactory.getLogger(StreamServiceImpl.class);
@Value("${tencent.prefix.url}")
private String tencentPrefixUrl;
@Value("${zego.prefix.url}")
private String zegoMixedPrefixUrl;
@Value("${zego.appsign}")
private String zegoAppSign;
@Value("${zego.app.id}")
private int zegoAppId;
@Value("${tencent.secretkey}")
private String tencentSecretKey;
@Value("${tencent.appid}")
private int tencentAppId;
@Resource
private IdGenerator idGenerator;
@Resource
private StreamMapper streamMapper;
@Autowired
private StringRedisTemplate redisTemplate;
@Resource
private RoomService roomService;
@Resource
private MixStreamMapper mixStreamMapper;
@Resource
private MixStreamReplayMapper mixStreamReplayMapper;
private static final String KEY_STREAM_INFO = "si:s";
public static String getStreamInfo(String streamId) {
return Joiner.on(":").join(KEY_STREAM_INFO, streamId);
}
private static final String CREATE_STREAM_KEY = "cr:s:k";
private String getCreateStreamKey(String streamId) {
return Joiner.on(":").join(CREATE_STREAM_KEY, streamId);
}
@Override
public String initStream(long roomId, long uid, ProductConfig config) {
String productCode = config.getProductCode();
String streamId = doGenerateStreamId(roomId, uid, config);
streamMapper.initStream(streamId, roomId, uid, productCode, StreamSupplierEnum.valueOf(config.getStreamSupplier()).getCode());
Stream streamInfo = new Stream();
streamInfo.setUid(uid);
streamInfo.setRoomId(roomId);
streamInfo.setProductCode(productCode);
streamInfo.setStreamId(streamId);
redisTemplate.opsForValue().set(getStreamInfo(streamId), JSON.toJSONString(streamInfo), 1, TimeUnit.MINUTES);
return streamId;
}
private String doGenerateStreamId(long roomId, long uid, ProductConfig config) {
String connector = StreamSupplierEnum.getDescBySupplier(config.getStreamSupplier());
if (StringUtils.isBlank(connector)) {
throw new YppRunTimeException(ExceptionCode.STREAM_SUPPLIER_NOT_FOUND);
}
String streamId = "S" +
config.getShortCode() + connector +
roomId + connector +
uid + connector +
idGenerator.strId();
return streamId.length() <= 64 ? streamId : streamId.substring(0, 64);
}
@Override
public Stream getUserLivingStream(long roomId, long uid) {
List<Stream> streams = streamMapper.selectLivingStreamByRoomIdAndUids(roomId, Lists.newArrayList(uid));
if (CollectionUtils.isEmpty(streams)) {
return null;
}
return streams.get(0);
}
@Override
public Stream getStreamByStreamId(String streamId) {
log.info("getStreamByStreamId streamId:{}", streamId);
String streamStr = redisTemplate.opsForValue().get(getStreamInfo(streamId));
if (StringUtils.isBlank(streamStr)) {
Stream stream = streamMapper.selectByStreamId(streamId);
redisTemplate.opsForValue().set(getStreamInfo(streamId), JSON.toJSONString(stream), 1, TimeUnit.MINUTES);
return stream;
}
try {
return JSON.parseObject(streamStr, Stream.class);
} catch (Exception e) {
log.error("parse stream obj error. e:{}", e);
return streamMapper.selectByStreamId(streamId);
}
}
@Override
public Map<Long, Stream> batchGetUserLivingStream(long roomId, List<Long> uids) {
List<Stream> streams = streamMapper.selectLivingStreamByRoomIdAndUids(roomId, uids);
return streams.stream().collect(Collectors.toMap(Stream::getUid, Function.identity(), (v1, v2) -> v2));
}
@Override
public List<Stream> getRoomLivingStream(long roomId) {
return streamMapper.getRoomLivingSteamList(roomId);
}
@Override
public boolean addStream(StreamContext streamContext) {
String streamId = streamContext.getStreamId();
Stream stream = streamMapper.selectByStreamId(streamId);
if (stream != null) {
log.info("addStream streamId is exist, {}", streamId);
return false;
}
Stream record = new Stream();
record.setStreamId(streamId);
record.setRoomId(streamContext.getRoomId());
record.setStatus(1);
record.setUid(streamContext.getUid());
record.setSource(streamContext.getStreamSupplier().getCode());
record.setProductCode(streamContext.getProductCode());
streamMapper.addStream(record);
return true;
}
@Override
public boolean closeStream(String streamId) {
Stream stream = streamMapper.selectByStreamId(streamId);
if (stream == null || stream.getStatus() == 0) {
return false;
}
streamMapper.closeStream(streamId, 0, "正常关闭");
return true;
}
@Override
public String getPlayUrl(long roomId, String supplier) {
if (StreamSupplierEnum.TENCENT.name().equals(supplier)) {
return tencentPrefixUrl + roomId + ".flv";
} else if (StreamSupplierEnum.ZEGO.name().equals(supplier)) {
return zegoMixedPrefixUrl + roomId;
}
return null;
}
@Override
public AppInfoDTO genUserSig(UserSginInputParam userSginInputParam) {
String streamSupplier = userSginInputParam.getStreamSupplier();
boolean needReplay = userSginInputParam.isNeedReplay();
long uid = userSginInputParam.getUid();
log.info("genUserSig supplier:{}, needReplay:{}, uid:{}", streamSupplier, needReplay, uid);
if (StreamSupplierEnum.ZEGO.name().equals(streamSupplier)) {
return getZegoUserSig(uid);
} else if (StreamSupplierEnum.TENCENT.name().equals(streamSupplier)) {
return getTencentUserSig(uid);
}
return null;
}
private AppInfoDTO getZegoUserSig(long uid) {
AppInfoDTO appInfoDTO = new AppInfoDTO();
appInfoDTO.setAppId(zegoAppId);
appInfoDTO.setAppID(String.valueOf(zegoAppId));
appInfoDTO.setAppSign(zegoAppSign);
appInfoDTO.setToken(ZegoUtils.getZeGouToken(String.valueOf(zegoAppId), zegoAppSign, String.valueOf(uid)));
return appInfoDTO;
}
private AppInfoDTO getTencentUserSig(long uid) {
AppInfoDTO appInfoDTO = new AppInfoDTO();
appInfoDTO.setAppId(tencentAppId);
appInfoDTO.setAppID(String.valueOf(tencentAppId));
long expireTime = 604800;
TLSSigAPIv2 api = new TLSSigAPIv2(tencentAppId, tencentSecretKey);
appInfoDTO.setAppSign(api.genSig(String.valueOf(uid), expireTime));
return appInfoDTO;
}
@Override
public boolean createStreamCallback(CreateStreamCallback callback) {
log.info("createStreamCallback. {}", JSON.toJSONString(callback));
String streamId = callback.getStreamId();
String picUrl = org.springframework.util.CollectionUtils.isEmpty(callback.getPicUrls()) ? ""
: callback.getPicUrls().get(0);
Stream stream = streamMapper.selectByStreamId(streamId);
if (stream != null && (stream.getStatus() == 1 || stream.getStatus() == -1)) {
log.info("createStreamCallback streamId is exist, {}", JSON.toJSONString(stream));
//对于已经存在数据不做更新
String rtmpUrls = StringUtils.isNotBlank(stream.getRtmpUrl()) ? null : JSON.toJSONString(
callback.getRtmpUrls());
String hlsUrls = StringUtils.isNotBlank(stream.getHlsUrl()) ? null : JSON.toJSONString(
callback.getHlsUrls());
String hdlUrls = StringUtils.isNotBlank(stream.getHdlUrl()) ? null : JSON.toJSONString(
callback.getHdlUrls());
picUrl = StringUtils.isNotBlank(stream.getPicUrl()) ? null : picUrl;
streamMapper.updateCreateStream(streamId, rtmpUrls, hlsUrls, hdlUrls, picUrl);
} else if (stream != null && stream.getStatus() == 0) {
streamMapper.openStream(streamId);
} else {
RoomDTO roomDTO = roomService.getRoomByRoomId(callback.getRoomId());
Stream record = new Stream();
record.setStreamId(streamId);
record.setRoomId(callback.getRoomId());
record.setStatus(1);
record.setUid(callback.getUid());
record.setSource(callback.getSource());
record.setRtmpUrl(JSON.toJSONString(callback.getRtmpUrls()));
record.setHlsUrl(JSON.toJSONString(callback.getHlsUrls()));
record.setHdlUrl(JSON.toJSONString(callback.getHdlUrls()));
record.setPicUrl(picUrl);
record.setCloseType(-1);
record.setProductCode(roomDTO.getProductCode());
log.info("createStreamCallback insert stream {}", JSON.toJSONString(record));
streamMapper.insert(record);
}
return true;
}
@Override
public boolean closeStreamCallback(CloseStreamCallback callback) {
Stream stream = streamMapper.selectByStreamId(callback.getStreamId());
if (stream == null || stream.getStatus() == 0) {
return false;
}
streamMapper.closeStream(callback.getStreamId(), callback.getCloseType(), "正常关闭");
return true;
}
@Override
public void replayStreamCallback(CreateReplayCallback callback) {
streamMapper.handleReplay(callback.getStreamId(), callback.getReplayUrl(), callback.getBeginTime(), callback.getEndTime());
}
@Override
public boolean handleMixReplay(CreateReplayCallback callback) {
if (callback == null || StringUtils.isEmpty(callback.getStreamId())) {
return false;
}
MixStream mixStream = mixStreamMapper.findLatestByStreamId(callback.getStreamId(), callback.getSource());
if (mixStream == null) {
log.info("handleMixReplay failed, not found mixStream record, streamId:{}", callback.getStreamId());
return false;
}
MixStreamReplay replay = MixStreamReplay.converter(mixStream, callback.getReplayUrl(), callback.getBeginTime(), callback.getEndTime());
int num = mixStreamReplayMapper.insert(replay);
log.info("handleMixReplay, insert mixReplayRecord result:{}, streamId:{}", num, callback.getStreamId());
return true;
}
@Override
public void addMixStream(MixStreamStartCallback callback, long roomId) {
MixStream mixStream = new MixStream();
mixStream.setRoomId(roomId);
mixStream.setBizRoomId(callback.getBizRoomId());
mixStream.setStreamId(callback.getStreamId());
mixStream.setSource(callback.getSource());
mixStream.setRtmpUrl(JSON.toJSONString(callback.getRtmpUrls()));
mixStream.setHlsUrl(JSON.toJSONString(callback.getHlsUrls()));
mixStream.setHdlUrl(JSON.toJSONString(callback.getHdlUrls()));
mixStream.setInputStream(JSON.toJSONString(callback.getInputStreamList()));
mixStream.setStatus(1);
mixStream.setBeginTime(callback.getCreateTime());
mixStream.setEndTime(callback.getCreateTime());
mixStreamMapper.insertSelective(mixStream);
}
@Override
public void stopMixStream(MixStreamEndCallback callback) {
mixStreamMapper.stopMixStream(callback.getStreamId(), callback.getSource(), callback.getCreateTime());
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/impl/MessageServiceImpl.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/impl/MessageServiceImpl.java | package cn.bixin.sona.server.room.service.impl;
import cn.bixin.sona.api.im.RouterRoomMessageService;
import cn.bixin.sona.api.im.enums.PriorityEnum;
import cn.bixin.sona.api.im.request.GroupMessageRequest;
import cn.bixin.sona.api.im.request.RoomMessageRequest;
import cn.bixin.sona.server.room.domain.db.Stream;
import cn.bixin.sona.server.room.domain.enums.IMModuleEnum;
import cn.bixin.sona.server.room.domain.enums.SonaMessageTypeEnum;
import cn.bixin.sona.server.room.service.MessageService;
import com.alibaba.fastjson.JSON;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
@Service
public class MessageServiceImpl implements MessageService {
private static final Logger log = LoggerFactory.getLogger(MessageServiceImpl.class);
@Resource
private RouterRoomMessageService routerRoomMessageService;
@Override
public void sendSonaCreateRoomMessage(long roomId, long uid, String imModule) {
log.info("sendSonaCreateRoomMessage roomId:{}, uid:{}", roomId, uid);
sendSonaMessage(roomId, uid, wrapMessageContent(SonaMessageTypeEnum.MSG_CREATE_ROOM, roomId, uid, null), SonaMessageTypeEnum.MSG_CREATE_ROOM, PriorityEnum.MEDIUM, imModule);
}
@Override
public void sendSonaCloseRoomMessage(long roomId, long uid, String imModule) {
log.info("sendSonaCloseRoomMessage roomId:{}, uid:{}", roomId, uid);
sendSonaMessage(roomId, uid, wrapMessageContent(SonaMessageTypeEnum.MSG_CLOSE_ROOM, roomId, uid, null), SonaMessageTypeEnum.MSG_CLOSE_ROOM, PriorityEnum.MEDIUM, imModule);
}
@Override
public void sendSonaEnterRoomMessage(long roomId, long uid, String imModule) {
log.info("sendSonaEnterRoomMessage roomId:{}, uid:{}", roomId, uid);
sendSonaMessage(roomId, uid, wrapMessageContent(SonaMessageTypeEnum.MSG_ENTER_ROOM, roomId, uid, null), SonaMessageTypeEnum.MSG_ENTER_ROOM, PriorityEnum.MEDIUM, imModule);
}
@Override
public void sendSonaLeaveRoomMessage(long roomId, long uid, String imModule) {
log.info("sendSonaLeaveRoomMessage roomId:{}, uid:{}", roomId, uid);
sendSonaMessage(roomId, uid, wrapMessageContent(SonaMessageTypeEnum.MSG_LEAVE_ROOM, roomId, uid, null), SonaMessageTypeEnum.MSG_LEAVE_ROOM, PriorityEnum.MEDIUM, imModule);
}
@Override
public void sendSonaMuteMessage(long roomId, long uid, boolean setMute, Integer minute, String imModule) {
log.info("sendSonaMuteMessage roomId:{}, uid:{}, setMute:{}, minute:{}", roomId, uid, setMute, minute);
Map<String, Object> extMap = Maps.newHashMap();
extMap.put("isMute", setMute ? "1" : "0");
if (setMute && minute != null) {
extMap.put("duration", String.valueOf(minute));
}
sendSonaMessage(roomId, uid, wrapMessageContent(SonaMessageTypeEnum.MSG_MUTE, roomId, uid, extMap), SonaMessageTypeEnum.MSG_MUTE, PriorityEnum.HIGH, imModule);
}
@Override
public void sendSonaBlockMessage(long roomId, long uid, boolean setBlock, String imModule) {
log.info("sendSonaBlockMessage roomId:{}, uid:{}, setBlock:{}", roomId, uid, setBlock);
Map<String, Object> extMap = Maps.newHashMap();
extMap.put("isBlock", setBlock ? "1" : "0");
sendSonaMessage(roomId, uid, wrapMessageContent(SonaMessageTypeEnum.MSG_BLOCK, roomId, uid, extMap), SonaMessageTypeEnum.MSG_BLOCK, PriorityEnum.HIGH, imModule);
}
@Override
public void sendSonaKickMessage(long roomId, long uid, String imModule) {
log.info("sendSonaKickMessage roomId:{}, uid:{}", roomId, uid);
sendSonaMessage(roomId, uid, wrapMessageContent(SonaMessageTypeEnum.MSG_KICK, roomId, uid, null), SonaMessageTypeEnum.MSG_KICK, PriorityEnum.HIGH, imModule);
}
@Override
public void sendSonaAdminMessage(long roomId, long uid, boolean setAdmin, String imModule) {
log.info("sendSonaAdminMessage roomId:{}, uid:{}, setAdmin:{}", roomId, uid, setAdmin);
Map<String, Object> extMap = Maps.newHashMap();
extMap.put("isAdmin", setAdmin ? "1" : "0");
sendSonaMessage(roomId, uid, wrapMessageContent(SonaMessageTypeEnum.MSG_ADMIN, roomId, uid, extMap), SonaMessageTypeEnum.MSG_ADMIN, PriorityEnum.HIGH, imModule);
}
@Override
public void sendSonaMuteStreamMessage(long roomId, List<Stream> streamList, boolean setMute, String imModule) {
log.info("sendSonaMuteStreamMessage roomId:{}, streamList:{}, setMute:{}", roomId, JSON.toJSONString(streamList), setMute);
Map<String, Object> extMap = Maps.newHashMap();
extMap.put("isMute", setMute ? "1" : "0");
List<StreamInfo> streams = Lists.newArrayList();
streamList.forEach(each -> streams.add(new StreamInfo(each.getUid(), each.getStreamId())));
extMap.put("streamList", streams);
sendSonaMessage(roomId, 0, wrapMessageContent(SonaMessageTypeEnum.MSG_VOICE, roomId, null, extMap), SonaMessageTypeEnum.MSG_VOICE, PriorityEnum.MEDIUM, imModule);
}
@Override
public void sendSonaHotSwitchMessage(Long roomId, Map<String, Object> contentMap, String imModule) {
Map<String, Object> map = wrapMessageContent(SonaMessageTypeEnum.MSG_SWITCH_AUDIO, roomId, null, contentMap);
sendSonaMessage(roomId, 0, map, SonaMessageTypeEnum.MSG_SWITCH_AUDIO, PriorityEnum.HIGH, imModule);
}
private static class StreamInfo {
private long uid;
private String streamId;
public StreamInfo(long uid, String streamId) {
this.uid = uid;
this.streamId = streamId;
}
public long getUid() {
return uid;
}
public void setUid(long uid) {
this.uid = uid;
}
public String getStreamId() {
return streamId;
}
public void setStreamId(String streamId) {
this.streamId = streamId;
}
}
private static Map<String, Object> wrapMessageContent(SonaMessageTypeEnum messageType, long roomId, Long uid, Map<String, Object> extMap) {
Map<String, Object> contentMap = Maps.newHashMap();
if (uid != null) {
contentMap.put("uid", String.valueOf(uid));
}
contentMap.put("roomId", String.valueOf(roomId));
if (!CollectionUtils.isEmpty(extMap)) {
contentMap.putAll(extMap);
}
Map<String, Object> map = Maps.newHashMap();
map.put("msgType", messageType.getCode());
map.put("data", contentMap);
map.put("roomId", roomId);
return map;
}
private void sendSonaMessage(long roomId, long uid, Map<String, Object> contentMap, SonaMessageTypeEnum msgType, PriorityEnum priority, String imModule) {
if (IMModuleEnum.CHATROOM.name().equals(imModule)) {
RoomMessageRequest request = new RoomMessageRequest();
request.setRoomId(roomId);
request.setPriority(priority);
request.setUid(uid);
request.setMsgType(msgType.getCode());
request.setContent(JSON.toJSONString(contentMap));
log.info("send sona chatroom message:{}", JSON.toJSONString(request));
routerRoomMessageService.sendChatRoomMessage(request);
} else if (IMModuleEnum.GROUP.name().equals(imModule)) {
GroupMessageRequest request = new GroupMessageRequest();
request.setGroupId(roomId);
request.setUid(uid);
request.setContent(JSON.toJSONString(contentMap));
log.info("send sona group message:{}", JSON.toJSONString(request));
routerRoomMessageService.sendGroupMessage(request);
}
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/impl/ProductConfigServiceImpl.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/impl/ProductConfigServiceImpl.java | package cn.bixin.sona.server.room.service.impl;
import cn.bixin.sona.common.exception.YppRunTimeException;
import cn.bixin.sona.server.exception.ExceptionCode;
import cn.bixin.sona.server.room.domain.db.ProductConfig;
import cn.bixin.sona.server.room.domain.db.RoomConfig;
import cn.bixin.sona.server.room.mapper.ProductConfigMapper;
import cn.bixin.sona.server.room.mapper.RoomConfigMapper;
import cn.bixin.sona.server.room.service.ProductConfigService;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.google.common.base.Joiner;
import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import com.google.common.collect.Maps;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;
import java.util.stream.Collectors;
@Service
public class ProductConfigServiceImpl implements ProductConfigService {
private static final Logger log = LoggerFactory.getLogger(ProductConfigServiceImpl.class);
private static final Cache<String, ProductConfig> configLocalCache = CacheBuilder.newBuilder()
.expireAfterWrite(1, TimeUnit.MINUTES).maximumSize(10000).build();
private static final Cache<String, ProductConfig> shortCodeConfigLocalCache = CacheBuilder.newBuilder()
.expireAfterWrite(1, TimeUnit.MINUTES).maximumSize(10000).build();
@Resource
private ProductConfigMapper productConfigMapper;
@Resource
private RoomConfigMapper roomConfigMapper;
@Autowired
private StringRedisTemplate redisTemplate;
private String KEY_ROOM_CONFIG = "room:config";
private String getKeyRoomConfig(long roomId) {
return Joiner.on(":").join(KEY_ROOM_CONFIG, roomId);
}
@Override
public ProductConfig getConfigInfoByCode(String productCode) {
ProductConfig config = configLocalCache.getIfPresent(productCode);
if (config == null) {
config = productConfigMapper.findByProductCode(productCode);
if (config == null) {
throw new YppRunTimeException(ExceptionCode.PRODUCT_NOT_FOUND);
}
configLocalCache.put(productCode, config);
return config;
}
return ProductConfig.copy(config);
}
@Override
public ProductConfig getConfigInfoByShortCode(String shortCode) {
ProductConfig config = shortCodeConfigLocalCache.getIfPresent(shortCode);
if (config == null) {
config = productConfigMapper.findByShortCode(shortCode);
if (config == null) {
throw new YppRunTimeException(ExceptionCode.PRODUCT_NOT_FOUND);
}
shortCodeConfigLocalCache.put(shortCode, config);
return config;
}
return ProductConfig.copy(config);
}
@Override
public RoomConfig getRoomConfig(long roomId) {
String roomConfigStr = redisTemplate.opsForValue().get(getKeyRoomConfig(roomId));
if (StringUtils.isBlank(roomConfigStr)) {
RoomConfig roomConfig = roomConfigMapper.findRoomConfig(roomId);
if (roomConfig == null) {
redisTemplate.opsForValue().set(getKeyRoomConfig(roomId), "null", 1, TimeUnit.MINUTES);
return null;
} else {
redisTemplate.opsForValue().set(getKeyRoomConfig(roomId), JSON.toJSONString(roomConfig), 1, TimeUnit.SECONDS);
return roomConfig;
}
} else {
if ("null".equals(roomConfigStr)) {
return null;
}
return JSON.parseObject(roomConfigStr, RoomConfig.class);
}
}
@Override
public Map<Long, RoomConfig> getRoomConfigBatch(List<Long> roomIds) {
if (CollectionUtils.isEmpty(roomIds)) {
return Maps.newHashMap();
}
List<RoomConfig> list = roomConfigMapper.findRoomConfigBatch(roomIds);
if (CollectionUtils.isEmpty(list)) {
return Maps.newHashMap();
}
return list.stream().collect(Collectors.toMap(RoomConfig::getRoomId, Function.identity(), (v1, v2) -> v1));
}
@Override
public boolean addRoomConfig(List<RoomConfig> roomConfigs) {
if (CollectionUtils.isEmpty(roomConfigs)){
return true;
}
for (RoomConfig roomConfig : roomConfigs) {
log.info("addRoomConfig list, roomConfig:{}", JSONObject.toJSONString(roomConfig));
roomConfigMapper.insertSelective(roomConfig);
try {
redisTemplate.opsForValue().set(getKeyRoomConfig(roomConfig.getRoomId()),
JSONObject.toJSONString(roomConfig), 30, TimeUnit.SECONDS);
} catch (Exception e) {
log.error("add room config to redis error", e);
}
}
return true;
}
@Override
public boolean updateRoomConfigAudioStreams(List<RoomConfig> configs) {
if (CollectionUtils.isEmpty(configs)) return false;
roomConfigMapper.updateStreamConfigAudios(configs);
List<Long> roomIds = configs.stream().map(RoomConfig::getRoomId).collect(Collectors.toList());
List<String> roomConfigKeys = roomIds.stream().map(this::getKeyRoomConfig).collect(Collectors.toList());
redisTemplate.delete(roomConfigKeys);
return true;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/impl/GroupServiceImpl.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/impl/GroupServiceImpl.java | package cn.bixin.sona.server.room.service.impl;
import cn.bixin.sona.common.dto.PageResult;
import cn.bixin.sona.server.room.domain.db.GroupMember;
import cn.bixin.sona.server.room.domain.db.GroupUserCount;
import cn.bixin.sona.server.room.mapper.RoomGroupMemberMapper;
import cn.bixin.sona.server.room.service.GroupService;
import com.google.common.base.Joiner;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;
import java.util.stream.Collectors;
@Service
public class GroupServiceImpl implements GroupService {
@Resource
private RoomGroupMemberMapper roomGroupMemberMapper;
@Autowired
private StringRedisTemplate redisTemplate;
private static final String KEY_GROUP_MEMBER_COUNT = "gmc:s";
private String getKeyGroupMemberCount(long roomId) {
return Joiner.on(":").join(KEY_GROUP_MEMBER_COUNT, roomId);
}
@Override
public boolean enterGroup(long roomId, String productCode, long uid) {
GroupMember groupMember = roomGroupMemberMapper.selectByRoomIdAndUid(roomId, uid);
if (groupMember != null) {
return true;
}
return roomGroupMemberMapper.insertSelective(GroupMember.wrapCreateObj(roomId, uid, productCode)) > 0;
}
@Override
public boolean leaveGroup(long roomId, long uid) {
return roomGroupMemberMapper.updateStatusLeave(roomId, uid) > 0;
}
@Override
public boolean removeGroupMembers(long roomId) {
roomGroupMemberMapper.disbandMember(roomId);
return true;
}
@Override
public long getGroupMemberCount(long roomId) {
//todo 人数缓存设计待优化
String cacheResult = redisTemplate.opsForValue().get(getKeyGroupMemberCount(roomId));
if (StringUtils.isBlank(cacheResult)) {
int count = roomGroupMemberMapper.selectGroupMemberCountByRoomId(roomId);
redisTemplate.opsForValue().set(getKeyGroupMemberCount(roomId), String.valueOf(count), 1, TimeUnit.SECONDS);
return count;
}
return Long.parseLong(cacheResult);
}
@Override
public Map<Long, Long> batchGetGroupMemberCount(List<Long> roomIds) {
if (CollectionUtils.isEmpty(roomIds)) {
return Collections.emptyMap();
}
List<String> countKeys = roomIds.stream().map(this::getKeyGroupMemberCount).collect(Collectors.toList());
List<String> counts = redisTemplate.opsForValue().multiGet(countKeys);
Map<Long, Long> result = Maps.newHashMap();
List<Long> roomIdsForDB = Lists.newArrayList();
for (int i = 0; i < roomIds.size(); i++) {
if (counts.get(i) != null) {
result.put(roomIds.get(i), Long.valueOf(counts.get(i)));
} else {
roomIdsForDB.add(roomIds.get(i));
}
}
result.putAll(getGroupMemberCountFromDB(roomIdsForDB));
return result;
}
private Map<Long, Long> getGroupMemberCountFromDB(List<Long> roomIdsForDB) {
if (CollectionUtils.isEmpty(roomIdsForDB)) {
return Collections.emptyMap();
}
Map<Long, Long> result = Maps.newHashMap();
// List<GroupMember> groupMembers = roomGroupMemberMapper.selectGroupMemberByRoomIds(roomIdsForDB);
//
// groupMembers.forEach(m -> {
// Long count = result.get(m.getRoomId());
// if (count == null) {
// result.put(m.getRoomId(), 1L);
// } else {
// result.put(m.getRoomId(), count + 1);
// }
// });
List<GroupUserCount> groupUserCounts = roomGroupMemberMapper.selectGroupUserCountByRoomIds(roomIdsForDB);
if (CollectionUtils.isNotEmpty(groupUserCounts)) {
groupUserCounts.forEach(guc -> result.put(guc.getRoomId(), guc.getCount()));
}
roomIdsForDB.forEach(roomId -> result.putIfAbsent(roomId, 0L));
redisTemplate.executePipelined((RedisCallback<Object>) connection -> {
connection.openPipeline();
RedisSerializer<String> keySerializer = new StringRedisSerializer();
RedisSerializer<String> valueSerializer = new StringRedisSerializer();
result.forEach((roomId, count) -> {
String key = getKeyGroupMemberCount(roomId);
byte[] redisKey = keySerializer.serialize(key);
byte[] redisValue = valueSerializer.serialize(String.valueOf(count));
connection.set(redisKey, redisValue);
connection.expire(redisKey, 1);
});
return null;
});
return result;
}
@Override
public PageResult<Long> getRoomMemberList(long roomId, String anchor, int limit) {
long anchorNum = Long.parseLong(anchor);
long count = getGroupMemberCount(roomId);
if (count == 0) {
return PageResult.newPageResult(Collections.emptyList(), true);
}
List<GroupMember> memberList = roomGroupMemberMapper.selectGroupMemberListByRoomId(roomId, anchorNum, limit);
return PageResult.newPageResult(memberList.stream().map(GroupMember::getUid).collect(Collectors.toList()),
memberList.size() < limit || limit >= count, count, String.valueOf(memberList.get(memberList.size() - 1).getId()));
}
@Override
public Map<Long, Boolean> isUserInGroup(long roomId, List<Long> uids) {
List<GroupMember> memberList = roomGroupMemberMapper.selectByRoomIdAndUids(roomId, uids);
if (org.springframework.util.CollectionUtils.isEmpty(memberList)) {
return Collections.emptyMap();
}
Map<Long, GroupMember> uid2GroupMemberMap = memberList.stream().collect(Collectors.toMap(GroupMember::getUid, Function.identity(), (v1, v2) -> v1));
Map<Long, Boolean> result = Maps.newHashMap();
uids.forEach(uid -> result.put(uid, uid2GroupMemberMap.get(uid) != null));
return result;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/impl/RoomServiceImpl.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/service/impl/RoomServiceImpl.java | package cn.bixin.sona.server.room.service.impl;
import cn.bixin.sona.common.dto.PageResult;
import cn.bixin.sona.common.exception.YppRunTimeException;
import cn.bixin.sona.common.util.IdGenerator;
import cn.bixin.sona.dto.RoomDTO;
import cn.bixin.sona.request.CreateRoomRequest;
import cn.bixin.sona.request.OpenCloseRoomRequest;
import cn.bixin.sona.server.exception.ExceptionCode;
import cn.bixin.sona.server.room.domain.convert.RoomDTOConverter;
import cn.bixin.sona.server.room.domain.db.ProductConfig;
import cn.bixin.sona.server.room.domain.db.Room;
import cn.bixin.sona.server.room.mapper.RoomMapper;
import cn.bixin.sona.server.room.service.RoomService;
import com.alibaba.fastjson.JSON;
import com.dianping.cat.Cat;
import com.google.common.base.Joiner;
import com.google.common.collect.Lists;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;
import java.util.stream.Collectors;
@Service
public class RoomServiceImpl implements RoomService {
private static final Logger log = LoggerFactory.getLogger(RoomServiceImpl.class);
@Resource
private IdGenerator idGenerator;
@Resource
private RoomMapper roomMapper;
@Autowired
private StringRedisTemplate redisTemplate;
@Override
public RoomDTO getRoomByRoomId(long roomId) {
log.debug("getRoomByRoomId roomId:{}", roomId);
String value = redisTemplate.opsForValue().get(getKeyChatroomInfo(roomId));
if (StringUtils.isNotBlank(value)) {
return RoomDTOConverter.convertDO(JSON.parseObject(value, Room.class));
}
Room room = roomMapper.getRoomByRoomId(roomId);
if (room == null) {
return null;
}
redisTemplate.opsForValue().set(getKeyChatroomInfo(roomId), JSON.toJSONString(room), 1, TimeUnit.MINUTES);
return RoomDTOConverter.convertDO(room);
}
@Override
public Map<Long, RoomDTO> batchGetRooms(List<Long> roomIds) {
List<String> roomKeys = roomIds.stream().map(this::getKeyChatroomInfo).collect(Collectors.toList());
List<String> redisList = redisTemplate.opsForValue().multiGet(roomKeys);
Map<Long, RoomDTO> ret = redisList.stream().filter(StringUtils::isNotBlank).map(value -> RoomDTOConverter.convertDO(JSON.parseObject(value, Room.class)))
.collect(Collectors.toMap(RoomDTO::getRoomId, Function.identity(), (v1, v2) -> v1));
List<Long> roomIdsForDB = roomIds.stream().filter(roomId -> ret.get(roomId) == null).collect(Collectors.toList());
if (CollectionUtils.isEmpty(roomIdsForDB)) {
return ret;
}
List<Room> rooms = roomMapper.getRoomsByRoomIds(roomIdsForDB);
if (CollectionUtils.isEmpty(roomIdsForDB)) {
Cat.logEvent("MISS_ROOM_ID", JSON.toJSONString(roomIdsForDB));
return ret;
}
redisTemplate.executePipelined((RedisCallback<Object>) connection -> {
connection.openPipeline();
RedisSerializer<String> keySerializer = new StringRedisSerializer();
RedisSerializer<String> valueSerializer = new StringRedisSerializer();
rooms.forEach(room -> {
byte[] redisKey = keySerializer.serialize(getKeyChatroomInfo(room.getRoomId()));
byte[] redisValue = valueSerializer.serialize(JSON.toJSONString(room));
connection.set(redisKey, redisValue);
connection.expire(redisKey, 60); // 1 min
});
return null;
});
ret.putAll(rooms.stream().collect(Collectors.toMap(Room::getRoomId, RoomDTOConverter::convertDO, (v1, v2) -> v1)));
return ret;
}
@Override
public Room createRoom(CreateRoomRequest request, ProductConfig config) {
try {
long roomId = idGenerator.id();
Room record = Room.wrapCreateObj(request, roomId, config.getImModule());
roomMapper.insertSelective(record);
log.debug("createRoom room:{}", JSON.toJSONString(record));
return record;
} catch (Exception e) {
log.error("createRoom error.", e);
throw new YppRunTimeException(ExceptionCode.CREATE_CHATROOM_ERROR);
}
}
@Override
public void openRoom(OpenCloseRoomRequest request) {
try {
log.debug("openRoom request:{}", JSON.toJSONString(request));
roomMapper.openRoom(request.getRoomId());
redisTemplate.delete(Lists.newArrayList(getKeyChatroomInfo(request.getRoomId())));
} catch (Exception e) {
log.error("openRoom error", e);
throw new YppRunTimeException(ExceptionCode.OPEN_CLOSE_CHATROOM_ERROR);
}
}
@Override
public boolean closeRoom(OpenCloseRoomRequest request) {
try {
log.debug("openRoom request:{}", JSON.toJSONString(request));
int ret = roomMapper.closeRoom(request.getRoomId());
redisTemplate.delete(Lists.newArrayList(getKeyChatroomInfo(request.getRoomId())));
return ret > 0;
} catch (Exception e) {
log.error("openRoom error", e);
throw new YppRunTimeException(ExceptionCode.OPEN_CLOSE_CHATROOM_ERROR);
}
}
@Override
public boolean updatePassword(long roomId, String password) {
int ret = roomMapper.updatePassword(roomId, password);
redisTemplate.delete(Lists.newArrayList(getKeyChatroomInfo(roomId)));
return ret > 0;
}
@Override
public PageResult<RoomDTO> getOnlineRoomList(String anchor, int limit) {
List<Room> roomList = roomMapper.selectOnlineRoomList(anchor, limit);
if (CollectionUtils.isEmpty(roomList)) {
return PageResult.newPageResult(Collections.emptyList(), true);
}
PageResult<RoomDTO> pageResult = new PageResult();
pageResult.setAnchor(roomList.get(roomList.size() - 1).getRoomId() + "");
pageResult.setCount(Long.valueOf(roomMapper.countOnlineRoomList() + ""));
List<RoomDTO> roomDTOList = Lists.newArrayList();
roomList.forEach(each -> {
RoomDTO dto = new RoomDTO();
BeanUtils.copyProperties(each, dto);
roomDTOList.add(dto);
});
pageResult.setList(roomDTOList);
pageResult.setEnd(roomList.size() < limit);
return pageResult;
}
private static final String KEY_CHATROOM_INFO = "ci:s";
private String getKeyChatroomInfo(long roomId) {
return Joiner.on(":").join(KEY_CHATROOM_INFO, roomId);
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/generator/StreamIdGenerator.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/generator/StreamIdGenerator.java | package cn.bixin.sona.server.room.generator;
import cn.bixin.sona.server.room.domain.enums.ProductEnum;
import cn.bixin.sona.server.room.domain.stream.StreamContext;
import org.springframework.stereotype.Component;
/**
* @author yuanye
* @date 2020/3/23 4:05 下午
*/
@Component
public class StreamIdGenerator {
public ProductEnum getPlatform(String streamId) {
StreamContext context = StreamContext.convert(streamId);
if (context != null) {
return ProductEnum.getPlatformByName(context.getProductCode());
}
return null;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/manager/AudioSwitchManager.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/manager/AudioSwitchManager.java | package cn.bixin.sona.server.room.manager;
import cn.bixin.sona.common.enums.PullMode;
import cn.bixin.sona.common.enums.RoomStatus;
import cn.bixin.sona.common.exception.YppRunTimeException;
import cn.bixin.sona.common.spring.SpringApplicationContext;
import cn.bixin.sona.dto.RoomDTO;
import cn.bixin.sona.enums.RoomMixedEnum;
import cn.bixin.sona.server.exception.ExceptionCode;
import cn.bixin.sona.server.room.domain.db.ProductConfig;
import cn.bixin.sona.server.room.domain.db.RoomConfig;
import cn.bixin.sona.server.room.domain.enums.IMModuleEnum;
import cn.bixin.sona.server.room.domain.enums.StreamSupplierEnum;
import cn.bixin.sona.server.room.service.*;
import cn.bixin.sona.server.room.utils.StreamUtil;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;
@Lazy
@Component
public class AudioSwitchManager {
private static final Logger log = LoggerFactory.getLogger(AudioSwitchManager.class);
@Resource
private ProductConfigService productConfigService;
@Resource
private RoomService roomService;
@Resource
private GroupService groupService;
@Resource
private ChatroomService chatroomService;
@Resource
private MessageService messageService;
@Resource
private StreamService streamService;
/**
* 默认码率 96k
*/
private static final int DEFAULT_BITRATE = 96000;
/**
* 默认播放器类型, 1: 三方 2: 自建
*/
private static final int DEFAULT_PLAYER_TYPE = 1;
public boolean roomSwitch(List<Long> roomIds, RoomMixedEnum roomMixedEnum) {
log.info("roomSwitch roomIds:{}, roomMixedEnum:{}", roomIds, roomMixedEnum);
if (CollectionUtils.isEmpty(roomIds) || roomMixedEnum == null) {
return false;
}
ProductConfig productConfig = getConfigInfoByRoomId(roomIds.get(0));
if (productConfig == null) {
return false;
}
List<Long> roomIdsWithPeople = getRoomIdsWithPeople(roomIds);
doRoomSwitchWithPeople(roomIdsWithPeople, roomMixedEnum, productConfig);
roomIds.removeAll(roomIdsWithPeople);
doRoomSwitchWithNoPeople(roomIds, roomMixedEnum, productConfig);
return true;
}
private ProductConfig getConfigInfoByRoomId(Long roomId) {
RoomDTO room = roomService.getRoomByRoomId(roomId);
ProductConfig config = productConfigService.getConfigInfoByCode(room.getProductCode());
String productCode = config.getProductCode();
//优先通过房间拿配置
RoomConfig roomConfig = productConfigService.getRoomConfig(roomId);
return roomConfig != null ? ProductConfig.convertConfigInfo(roomConfig, productCode) : productConfigService.getConfigInfoByCode(productCode);
}
private void doRoomSwitchWithNoPeople(List<Long> roomIds, RoomMixedEnum roomMixedEnum, ProductConfig productConfig) {
updateAudioConfigInfo(roomIds, roomMixedEnum, productConfig);
}
private List<Long> getRoomIdsWithPeople(List<Long> roomIds) {
Map<Long, Long> memberCount = batchGetRoomMemberCount(roomIds);
return memberCount.entrySet().stream().filter(e -> e.getValue() > 0L).map(Map.Entry::getKey).collect(Collectors.toList());
}
private void doRoomSwitchWithPeople(List<Long> roomIds, RoomMixedEnum roomMixedEnum, ProductConfig productConfig) {
updateAudioConfigInfo(roomIds, roomMixedEnum, productConfig);
sendSonaSwitchAudioSupplierMessage(roomIds, roomMixedEnum.getCode());
needToStopMixStream(roomIds, productConfig, roomMixedEnum);
}
public void sendSonaSwitchAudioSupplierMessage(List<Long> roomIds, int mixed) {
log.info("sendSonaSwitchAudioSupplierMessage, roomIds: {}, mixed: {}", roomIds, mixed);
Map<Long, RoomConfig> productConfigMap = productConfigService.getRoomConfigBatch(roomIds);
roomIds.forEach(roomId -> {
Map<String, Object> contentMap = Maps.newHashMap();
RoomMixedEnum roomMixedEnum = RoomMixedEnum.getRoomMixedEnum(mixed);
if (roomMixedEnum == null) {
return;
}
RoomConfig roomConfig = productConfigMap.get(roomId);
contentMap.put("pullMode", RoomMixedEnum.getPullMode(mixed));
contentMap.put("pushMode", RoomMixedEnum.getPushMode(mixed));
contentMap.put("supplier", RoomMixedEnum.getSupplier(mixed));
contentMap.put("roomId", roomId);
//设置码率
contentMap.put("bitrate", Objects.isNull(roomConfig) ? DEFAULT_BITRATE : roomConfig.getBitrate());
//设置播放器类型
contentMap.put("playerType", DEFAULT_PLAYER_TYPE);
String streamRoomId = String.valueOf(roomId);
if (roomMixedEnum == RoomMixedEnum.MIXED_ZEGO_MIXED || roomMixedEnum == RoomMixedEnum.MIXED_TECENT_MIXED) {
contentMap.put("streamId", streamRoomId);
if (roomConfig != null) {
contentMap.put("streamUrl", streamService.getPlayUrl(roomId, roomConfig.getStreamSupplier()));
}
}
messageService.sendSonaHotSwitchMessage(roomId, contentMap, roomConfig.getImModule());
});
}
private void updateAudioConfigInfo(List<Long> roomIds, RoomMixedEnum roomMixedEnum, ProductConfig productConfig) {
if (CollectionUtils.isEmpty(roomIds) || roomMixedEnum == null || productConfig == null) {
return;
}
//批量查询t_room_config
Map<Long, RoomConfig> roomConfigMap = productConfigService.getRoomConfigBatch(roomIds);
//注意: 不支持单独切码率
if (!StreamUtil.isProductStreamEqual(productConfig, roomMixedEnum)) {
List<Long> addRoomIds = getAddRoomIds(roomIds, roomConfigMap);
productConfigService.addRoomConfig(wrapNewRoomConfig(addRoomIds, roomMixedEnum, productConfig));
}
if (!CollectionUtils.isEmpty(roomConfigMap)) {
productConfigService.updateRoomConfigAudioStreams(
wrapUpdateRoomConfig(Lists.newArrayList(roomConfigMap.values()), roomMixedEnum));
}
}
public Map<Long, Long> batchGetRoomMemberCount(List<Long> roomIds) {
RoomDTO room = roomService.getRoomByRoomId(roomIds.get(0));
checkRoomValid(room);
ProductConfig config = productConfigService.getConfigInfoByCode(room.getProductCode());
if (IMModuleEnum.CHATROOM.name().equals(config.getImModule())) {
return chatroomService.batchGetChatroomUserCount(roomIds);
} else {
return groupService.batchGetGroupMemberCount(roomIds);
}
}
private void checkRoomValid(RoomDTO room) {
if (room == null) {
throw new YppRunTimeException(ExceptionCode.CHATROOM_NOT_EXISTS);
}
if (room.getStatus() == RoomStatus.INVALID.getCode()) {
throw new YppRunTimeException(ExceptionCode.ROOM_CLOSED_ERROR);
}
}
private List<Long> getAddRoomIds(List<Long> roomIds, Map<Long, RoomConfig> roomConfigMap) {
List<Long> addRoomIds = Lists.newArrayList();
if (CollectionUtils.isEmpty(roomConfigMap)) {
addRoomIds = roomIds;
} else {
for (Long each : roomIds) {
if (!roomConfigMap.containsKey(each)) {
addRoomIds.add(each);
}
}
}
return addRoomIds;
}
private List<RoomConfig> wrapNewRoomConfig(List<Long> roomIds, RoomMixedEnum roomMixedEnum,
ProductConfig productConfig) {
List<RoomConfig> list = Lists.newArrayList();
roomIds.forEach(each -> {
RoomConfig roomConfig = RoomConfig.convertByProductConfig(productConfig, roomMixedEnum);
roomConfig.setRoomId(each);
list.add(roomConfig);
});
return list;
}
private static List<RoomConfig> wrapUpdateRoomConfig(List<RoomConfig> roomConfigs, RoomMixedEnum roomMixedEnum) {
List<RoomConfig> list = Lists.newArrayList();
roomConfigs.forEach(each -> list.add(RoomConfig.convertByRoomConfig(each, roomMixedEnum)));
return list;
}
/**
* 是否需要停止混流
*
* @param roomIds
* @param productConfig
* @param roomMixedEnum
*/
private void needToStopMixStream(List<Long> roomIds, ProductConfig productConfig, RoomMixedEnum roomMixedEnum) {
log.info("needToStopMixStream, roomIds:{}, streamSupplier:{}, pullMode:{}, roomMixed:{}", roomIds,
productConfig.getStreamSupplier(), productConfig.getPullMode(), roomMixedEnum);
//zego 切换到 单流 或者 切换到 tencent 都需要停止混流
boolean zegoMix = isZegoMix(productConfig);
boolean nonEqualStream = !StreamUtil.isProductStreamEqual(productConfig, roomMixedEnum);
if (zegoMix && nonEqualStream) {
for (Long roomId : roomIds) {
SpringApplicationContext.getBean(ZegoService.class).stopMix(String.valueOf(roomId));
}
}
}
/**
* 是否是zego混流
*
* @param productConfig
* @return
*/
private boolean isZegoMix(ProductConfig productConfig) {
return StreamSupplierEnum.ZEGO.name().equals(productConfig.getStreamSupplier()) &&
PullMode.MIXED.name().equals(productConfig.getPullMode());
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/manager/StreamManagerImpl.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/manager/StreamManagerImpl.java | package cn.bixin.sona.server.room.manager;
import cn.bixin.sona.common.dto.Code;
import cn.bixin.sona.common.enums.PullMode;
import cn.bixin.sona.common.enums.RoomStatus;
import cn.bixin.sona.common.exception.YppRunTimeException;
import cn.bixin.sona.dto.AppInfoDTO;
import cn.bixin.sona.dto.RoomDTO;
import cn.bixin.sona.dto.StreamConfigInfoDTO;
import cn.bixin.sona.dto.SupplierConfigDTO;
import cn.bixin.sona.request.ChangeStreamRequest;
import cn.bixin.sona.request.MixMVRequest;
import cn.bixin.sona.server.exception.ExceptionCode;
import cn.bixin.sona.server.room.domain.convert.MixConfigConverter;
import cn.bixin.sona.server.room.domain.convert.StreamConfigInfoConverter;
import cn.bixin.sona.server.room.domain.db.ProductConfig;
import cn.bixin.sona.server.room.domain.db.RoomConfig;
import cn.bixin.sona.server.room.domain.db.Stream;
import cn.bixin.sona.server.room.domain.enums.PlatformEnum;
import cn.bixin.sona.server.room.domain.enums.StreamSupplierEnum;
import cn.bixin.sona.server.room.domain.stream.StreamContext;
import cn.bixin.sona.server.room.domain.stream.UserSginInputParam;
import cn.bixin.sona.server.room.service.*;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
import java.util.Objects;
@Component
public class StreamManagerImpl implements StreamManager {
private static final Logger log = LoggerFactory.getLogger(StreamManagerImpl.class);
@Resource
private StreamService streamService;
@Resource
private RoomManagementService roomManagementService;
@Resource
private RoomService roomService;
@Resource
private ProductConfigService productConfigService;
@Resource
private MessageService messageService;
@Resource
private MixConfigService mixConfigService;
@Override
public StreamConfigInfoDTO createStreamConfig(ProductConfig config, RoomDTO room, long uid, boolean isGuest) {
StreamConfigInfoDTO streamConfig = StreamConfigInfoConverter.convertStreamConfig(config);
buildStreamId(streamConfig, config, room.getRoomId(), uid);
buildAudioToken(streamConfig, config, uid);
buildStreamUrl(streamConfig, config, room.getRoomId());
buildStreamRoomId(streamConfig, room);
buildSwitchSpeaker(streamConfig);
buildAppInfo(streamConfig, config, uid, isGuest);
return streamConfig;
}
@Override
public String initStream(long roomId, long uid) {
if (roomManagementService.isUserStreamPushForBid(roomId, uid)) {
throw new YppRunTimeException(ExceptionCode.STREAM_PUSH_FORBID);
}
RoomDTO room = roomService.getRoomByRoomId(roomId);
checkRoomValid(room);
ProductConfig config = getProductConfig(roomId, room.getProductCode());
return streamService.initStream(roomId, uid, config);
}
@Override
public String getRoomStreamUrl(long roomId) {
RoomDTO room = roomService.getRoomByRoomId(roomId);
checkRoomValid(room);
ProductConfig config = getProductConfig(roomId, room.getProductCode());
return streamService.getPlayUrl(roomId, config.getStreamSupplier());
}
@Override
public Map<Long, String> batchGetRoomStreamUrls(List<Long> roomIds) {
Map<Long, RoomDTO> roomMap = roomService.batchGetRooms(roomIds);
if (MapUtils.isEmpty(roomMap)) {
return Maps.newHashMap();
}
Map<Long, RoomConfig> roomConfigMap = productConfigService.getRoomConfigBatch(roomIds);
Map<Long, String> result = Maps.newHashMap();
roomMap.forEach((roomId, room) -> {
RoomConfig config = roomConfigMap.get(roomId);
String supplier = config != null ? config.getStreamSupplier() : productConfigService.getConfigInfoByCode(room.getProductCode()).getStreamSupplier();
result.put(roomId, streamService.getPlayUrl(roomId, supplier));
});
return result;
}
@Override
public boolean muteStream(long roomId, List<Long> targetUids, boolean setMute) {
RoomDTO room = roomService.getRoomByRoomId(roomId);
checkRoomValid(room);
ProductConfig config = getProductConfig(roomId, room.getProductCode());
Map<Long, Stream> streamMap = streamService.batchGetUserLivingStream(roomId, targetUids);
if (MapUtils.isEmpty(streamMap)) {
return false;
}
messageService.sendSonaMuteStreamMessage(roomId, Lists.newArrayList(streamMap.values()), setMute, config.getImModule());
return true;
}
@Override
public boolean muteRoomStream(long roomId) {
RoomDTO room = roomService.getRoomByRoomId(roomId);
checkRoomValid(room);
ProductConfig config = getProductConfig(roomId, room.getProductCode());
List<Stream> streams = streamService.getRoomLivingStream(roomId);
if (CollectionUtils.isEmpty(streams)) {
return false;
}
messageService.sendSonaMuteStreamMessage(roomId, streams, true, config.getImModule());
return true;
}
@Override
public boolean addStream(ChangeStreamRequest request) {
RoomDTO room = roomService.getRoomByRoomId(request.getRoomId());
checkRoomValid(room);
StreamContext context = convertStreamContext(request.getStreamId());
if (context == null) {
throw new YppRunTimeException(ExceptionCode.PARSE_STREAM_ERROR);
}
return streamService.addStream(context);
}
@Override
public boolean closeStream(ChangeStreamRequest request) {
RoomDTO room = roomService.getRoomByRoomId(request.getRoomId());
checkRoomValid(room);
StreamContext context = convertStreamContext(request.getStreamId());
if (context == null) {
throw new YppRunTimeException(ExceptionCode.PARSE_STREAM_ERROR);
}
return streamService.closeStream(context.getStreamId());
}
private StreamContext convertStreamContext(String streamId) {
if (StringUtils.isBlank(streamId)) {
return null;
}
String[] streamArray = streamId.split("_");
if (streamArray.length != 7) {
return null;
}
ProductConfig config = productConfigService.getConfigInfoByShortCode(streamArray[0]);
if (config == null) {
return null;
}
StreamContext context = new StreamContext();
context.setStreamId(streamId);
context.setProductCode(config.getProductCode());
context.setStreamSupplier(StreamSupplierEnum.getByDesc(streamArray[1]));
context.setSonaSdkVersion(streamArray[2]);
context.setPlatform(PlatformEnum.getPlatformByCode(Integer.parseInt(streamArray[3])));
context.setRoomId(Long.valueOf(streamArray[4]));
context.setUid(Long.parseLong(streamArray[5]));
context.setRandomNumber(streamArray[6]);
context.setShortProductCode(streamArray[0]);
return context;
}
private ProductConfig getProductConfig(long roomId, String productCode) {
RoomConfig roomConfig = productConfigService.getRoomConfig(roomId);
return roomConfig != null ? ProductConfig.convertConfigInfo(roomConfig, productCode) : productConfigService.getConfigInfoByCode(productCode);
}
private void checkRoomValid(RoomDTO room) {
if (room == null) {
throw new YppRunTimeException(ExceptionCode.CHATROOM_NOT_EXISTS);
}
if (room.getStatus() == RoomStatus.INVALID.getCode()) {
throw new YppRunTimeException(ExceptionCode.ROOM_CLOSED_ERROR);
}
}
private void buildStreamId(StreamConfigInfoDTO streamConfig, ProductConfig config, long roomId, long uid) {
if (isTencentMulti(config)) {
streamConfig.setStreamId(streamService.initStream(roomId, uid, getProductConfig(roomId, config.getProductCode())));
} else {
streamConfig.setStreamId(String.valueOf(roomId));
}
}
private void buildStreamUrl(StreamConfigInfoDTO streamConfig, ProductConfig config, long roomId) {
streamConfig.setStreamUrl(streamService.getPlayUrl(roomId, config.getStreamSupplier()));
}
private void buildAudioToken(StreamConfigInfoDTO streamConfig, ProductConfig config, long uid) {
if (isTencent(config)) {
UserSginInputParam userSginInputParam = StreamConfigInfoConverter.convertUserSignInputParam(config, uid, false);
streamConfig.setAudioToken(streamService.genUserSig(userSginInputParam).getAppSign());
}
}
private void buildStreamRoomId(StreamConfigInfoDTO streamConfig, RoomDTO room) {
streamConfig.setStreamRoomId(getStreamRoomIdMap(room));
}
private Map<String, String> getStreamRoomIdMap(RoomDTO roomDTO) {
Map<String, String> streamIdMap = Maps.newHashMap();
streamIdMap.put(StreamSupplierEnum.ZEGO.name(), String.valueOf(roomDTO.getExt().get(StreamSupplierEnum.ZEGO.name())));
streamIdMap.put(StreamSupplierEnum.TENCENT.name(), String.valueOf(roomDTO.getExt().get(StreamSupplierEnum.TENCENT.name())));
return streamIdMap;
}
private void buildSwitchSpeaker(StreamConfigInfoDTO streamConfig) {
streamConfig.setSwitchSpeaker("0");
}
private void buildAppInfo(StreamConfigInfoDTO streamConfig, ProductConfig config, long uid, boolean isGuest) {
UserSginInputParam userSginInputParam = StreamConfigInfoConverter.convertUserSignInputParam(config, uid, isGuest);
streamConfig.setAppInfo(streamService.genUserSig(userSginInputParam));
}
private boolean isTencent(ProductConfig config) {
return StreamSupplierEnum.TENCENT.name().equals(config.getStreamSupplier());
}
private boolean isTencentMulti(ProductConfig config) {
return config.getPullMode().equals(PullMode.MULTI.name()) && StreamSupplierEnum.TENCENT.name().equals(config.getStreamSupplier());
}
@Override
public AppInfoDTO genUserSig(long roomId, long uid) {
RoomConfig roomConfig = productConfigService.getRoomConfig(roomId);
if (roomConfig == null) {
return null;
}
ProductConfig productConfig = new ProductConfig();
BeanUtils.copyProperties(roomConfig, productConfig);
UserSginInputParam userSginInputParam = StreamConfigInfoConverter.convertUserSignInputParam(productConfig, uid,false);
return streamService.genUserSig(userSginInputParam);
}
@Override
public SupplierConfigDTO syncRoomConfig(long roomId) {
RoomDTO roomDTO = roomService.getRoomByRoomId(roomId);
if (Objects.isNull(roomDTO)) {
throw new YppRunTimeException(ExceptionCode.CHATROOM_NOT_EXISTS);
}
RoomConfig productConfig = productConfigService.getRoomConfig(roomId);
if (productConfig == null) {
return null;
}
SupplierConfigDTO supplierConfig = new SupplierConfigDTO();
supplierConfig.setRoomId(String.valueOf(roomId));
StreamConfigInfoDTO streamConfigDTO = new StreamConfigInfoDTO();
streamConfigDTO.setSupplier(productConfig.getStreamSupplier());
streamConfigDTO.setStreamUrl(streamService.getPlayUrl(roomId, productConfig.getStreamSupplier()));
streamConfigDTO.setPullMode(productConfig.getPullMode());
streamConfigDTO.setPushMode(productConfig.getPushMode());
streamConfigDTO.setBitrate(productConfig.getBitrate());
streamConfigDTO.setType(productConfig.getType());
//云商为腾讯时不会使用该streamId字段
streamConfigDTO.setStreamId(String.valueOf(roomId));
supplierConfig.setStreamConfig(streamConfigDTO);
return supplierConfig;
}
public boolean mixedMV(MixMVRequest request) {
Long roomId = request.getRoomId();
Long uid = request.getUid();
RoomDTO roomDTO = roomService.getRoomByRoomId(roomId);
if (Objects.isNull(roomDTO)) {
log.info("room not exist, roomId: {}", roomId);
throw new YppRunTimeException(Code.ERROR_PARAM);
}
RoomConfig productConfig = productConfigService.getRoomConfig(roomId);
if (Objects.isNull(productConfig) || !StreamSupplierEnum.ZEGO.name().equals(
productConfig.getStreamSupplier())) {
log.info("stream supplier does not match, roomId:{}, productConfig: {}", request.getRoomId(), productConfig);
return false;
}
//开始混流, 设置MV参数, 保幂等
if (request.getMixStatus() == 1) {
log.info("mix status is {}, start to execute mix mv operation", 1);
mixConfigService.createMixConfig(MixConfigConverter
.defaultVideoMixConfig(roomId, String.valueOf(uid), request.getWidth(), request.getHeight()));
}
//停止混入MV信息
if (request.getMixStatus() == 2) {
log.info("mix status is {}, start to execute mix mv operation", 2);
mixConfigService.updateMixConfig(
MixConfigConverter.defaultAudioMixConfig(roomId, String.valueOf(uid)));
}
//开始混流
//zegoService.doMix(request.getRoomId(), bizRoomId, envService.isTest(), roomDTO.getAppId());
return true;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/manager/RoomManager.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/manager/RoomManager.java | package cn.bixin.sona.server.room.manager;
import cn.bixin.sona.common.dto.PageResult;
import cn.bixin.sona.dto.RoomConfigDTO;
import cn.bixin.sona.dto.RoomDTO;
import cn.bixin.sona.dto.RoomDetailInfoDTO;
import cn.bixin.sona.dto.RoomUserDTO;
import cn.bixin.sona.request.*;
import java.util.List;
import java.util.Map;
public interface RoomManager {
/**
* 查询房间
*/
RoomDTO getRoom(long roomId);
/**
* 批量查询房间
*/
Map<Long, RoomDTO> getRoomBatch(List<Long> roomIds);
/**
* 查询房间人数
*/
long getRoomMemberCount(long roomId);
/**
* 批量查询房间人数
* @param roomIds
* @return
*/
Map<Long, Long> batchGetRoomMemberCount(List<Long> roomIds);
/**
* 查询房间在线人员
*
* @param roomId: 房间id
* @param anchor: 游标 默认0
* @param limit: 查询数量
*
* @return member list
*/
PageResult<RoomUserDTO> getRoomMemberList(long roomId, String anchor, int limit);
/**
* 查询用户是否在线
* @param roomId: roomId
* @param uids: uids
* @return map
*/
Map<Long, Boolean> isUserInRoom(long roomId, List<Long> uids);
/**
* 创建房间
*/
RoomDetailInfoDTO createRoom(CreateRoomRequest request);
/**
* 打开房间
*/
RoomDetailInfoDTO openRoom(OpenCloseRoomRequest request);
/**
* 关闭房间
*/
boolean closeRoom(OpenCloseRoomRequest request);
/**
* 进入房间
*/
RoomDetailInfoDTO enterRoom(EnterRoomRequest request);
/**
* 离开房间
*/
boolean leaveRoom(LeaveRoomRequest request);
/**
* 更新密码
*/
boolean updatePassword(UpdatePasswordRequest request);
/**
* 禁言或取消禁言用户
*/
boolean muteOrCancelUser(OperateRequest request);
/**
* 拉黑或取消拉黑用户
*/
boolean blockOrCancelUser(OperateRequest request);
/**
* 踢出用户
*/
boolean kickUser(OperateRequest request);
/**
* 设置或取消管理员
*/
boolean setOrRemoveAdmin(OperateRequest request);
/**
* 更新聊天室用户分值
*
* @param roomId 房间ID
* @param uid 用户uid
* @param score 用户分值
* @return 是否成功
*/
boolean updateChatroomUserScore(long roomId, long uid, int score);
/**
* 获取房间配置
* @param roomId
* @return
*/
RoomConfigDTO getRoomConfig(long roomId);
/**
* 获取打开状态的房间
*/
PageResult<RoomDTO> getOnlineRoomList(String anchor, int limit);
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/manager/StreamManager.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/manager/StreamManager.java | package cn.bixin.sona.server.room.manager;
import cn.bixin.sona.dto.AppInfoDTO;
import cn.bixin.sona.dto.RoomDTO;
import cn.bixin.sona.dto.StreamConfigInfoDTO;
import cn.bixin.sona.dto.SupplierConfigDTO;
import cn.bixin.sona.request.ChangeStreamRequest;
import cn.bixin.sona.request.MixMVRequest;
import cn.bixin.sona.server.room.domain.db.ProductConfig;
import cn.bixin.sona.server.room.domain.stream.StreamContext;
import java.util.List;
import java.util.Map;
public interface StreamManager {
StreamConfigInfoDTO createStreamConfig(ProductConfig config, RoomDTO room, long uid, boolean isGuest);
String initStream(long roomId, long uid);
String getRoomStreamUrl(long roomId);
Map<Long, String> batchGetRoomStreamUrls(List<Long> roomIds);
boolean muteStream(long roomId, List<Long> targetUids, boolean setMute);
boolean muteRoomStream(long roomId);
boolean addStream(ChangeStreamRequest request);
boolean closeStream(ChangeStreamRequest request);
AppInfoDTO genUserSig(long roomId, long uid);
SupplierConfigDTO syncRoomConfig(long roomId);
boolean mixedMV(MixMVRequest request);
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/manager/RoomManagerImpl.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/manager/RoomManagerImpl.java | package cn.bixin.sona.server.room.manager;
import cn.bixin.sona.common.dto.PageResult;
import cn.bixin.sona.common.enums.RoomStatus;
import cn.bixin.sona.common.exception.YppRunTimeException;
import cn.bixin.sona.common.util.IdGenerator;
import cn.bixin.sona.dto.*;
import cn.bixin.sona.enums.UserTypeEnum;
import cn.bixin.sona.request.*;
import cn.bixin.sona.server.exception.ExceptionCode;
import cn.bixin.sona.server.room.domain.convert.RoomDTOConverter;
import cn.bixin.sona.server.room.domain.convert.RoomDetailInfoConverter;
import cn.bixin.sona.server.room.domain.db.ProductConfig;
import cn.bixin.sona.server.room.domain.db.Room;
import cn.bixin.sona.server.room.domain.db.RoomConfig;
import cn.bixin.sona.server.room.domain.db.RoomOperateLog;
import cn.bixin.sona.server.room.domain.enums.*;
import cn.bixin.sona.server.room.mapper.RoomOperateLogMapper;
import cn.bixin.sona.server.room.service.*;
import com.alibaba.fastjson.JSON;
import com.dianping.cat.Cat;
import com.dianping.cat.message.Transaction;
import com.google.common.collect.Lists;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import static cn.bixin.sona.server.room.domain.enums.TransactionTypeEnum.*;
/**
* 聊天室类型房间
*/
@Service
public class RoomManagerImpl implements RoomManager {
private static final Logger log = LoggerFactory.getLogger(RoomManagerImpl.class);
@Resource
private IdGenerator idGenerator;
@Resource
private StreamManager streamManager;
@Resource
private RoomService roomService;
@Resource
private ChatroomService chatroomService;
@Resource
private GroupService groupService;
@Resource
private ProductConfigService productConfigService;
@Resource
private RoomManagementService roomManagementService;
@Resource
private MessageService messageService;
@Resource
private RoomOperateLogMapper roomOperateLogMapper;
@Override
public RoomDTO getRoom(long roomId) {
return roomService.getRoomByRoomId(roomId);
}
@Override
public Map<Long, RoomDTO> getRoomBatch(List<Long> roomIds) {
return roomService.batchGetRooms(roomIds);
}
@Override
public long getRoomMemberCount(long roomId) {
RoomDTO room = roomService.getRoomByRoomId(roomId);
checkRoomValid(room);
ProductConfig config = productConfigService.getConfigInfoByCode(room.getProductCode());
if (IMModuleEnum.CHATROOM.name().equals(config.getImModule())) {
return chatroomService.getChatroomUserCount(roomId);
} else {
return groupService.getGroupMemberCount(roomId);
}
}
@Override
public Map<Long, Long> batchGetRoomMemberCount(List<Long> roomIds) {
RoomDTO room = roomService.getRoomByRoomId(roomIds.get(0));
checkRoomValid(room);
ProductConfig config = productConfigService.getConfigInfoByCode(room.getProductCode());
if (IMModuleEnum.CHATROOM.name().equals(config.getImModule())) {
return chatroomService.batchGetChatroomUserCount(roomIds);
} else {
return groupService.batchGetGroupMemberCount(roomIds);
}
}
@Override
public PageResult<RoomUserDTO> getRoomMemberList(long roomId, String anchor, int limit) {
RoomDTO room = roomService.getRoomByRoomId(roomId);
checkRoomValid(room);
ProductConfig config = productConfigService.getConfigInfoByCode(room.getProductCode());
PageResult<Long> uidPage;
if (IMModuleEnum.CHATROOM.name().equals(config.getImModule())) {
uidPage = chatroomService.getChatroomUserList(roomId, anchor, limit);
} else {
uidPage = groupService.getRoomMemberList(roomId, anchor, limit);
}
if (CollectionUtils.isEmpty(uidPage.getList())) {
return PageResult.newPageResult(Collections.emptyList(), true);
}
List<Long> uids = uidPage.getList();
Map<Long, UserRoleEnum> memberRoleMap = roomManagementService.getUserRoleBatch(roomId, uids);
return PageResult.newPageResult(
uids.stream().map(uid -> genRoomUserDTO(uid, memberRoleMap)).collect(Collectors.toList()),
uidPage.getEnd(), uidPage.getCount(), uidPage.getAnchor()
);
}
private RoomUserDTO genRoomUserDTO(long uid, Map<Long, UserRoleEnum> memberRoleMap) {
RoomUserDTO roomUserDTO = new RoomUserDTO();
roomUserDTO.setUid(uid);
UserRoleEnum userRoleEnum = memberRoleMap.get(uid);
if (userRoleEnum != null) {
roomUserDTO.setRole(userRoleEnum.getCode());
}
return roomUserDTO;
}
@Override
public Map<Long, Boolean> isUserInRoom(long roomId, List<Long> uids) {
RoomDTO room = roomService.getRoomByRoomId(roomId);
checkRoomValid(room);
ProductConfig config = productConfigService.getConfigInfoByCode(room.getProductCode());
if (IMModuleEnum.CHATROOM.name().equals(config.getImModule())) {
return chatroomService.isUserInChatroom(roomId, uids);
} else {
return groupService.isUserInGroup(roomId, uids);
}
}
@Override
public RoomDetailInfoDTO createRoom(CreateRoomRequest request) {
ProductConfig config = productConfigService.getConfigInfoByCode(request.getProductCode());
if (config == null) {
throw new YppRunTimeException(ExceptionCode.PRODUCT_NOT_FOUND);
}
String data = request.getProductCode() + "_" + request.getUid();
Transaction transaction = Cat.newTransaction(TransactionTypeEnum.TR_ROOM_CREATE.getCode(), TransactionTypeEnum.TR_ROOM_CREATE.name());
try {
log.debug("createRoom request:{}", JSON.toJSONString(request));
Room room = roomService.createRoom(request, config);
roomManagementService.addRoomManagementInfo(room.getRoomId(), request.getUid(), RoomManagementEnum.OWNER.getCode(), request.getUid());
logRoomOperateRecord(RoomOperateLog.wrapRoomLog(room.getRoomId(), config.getImModule(), RoomOperateEnum.CREATE.name(), String.valueOf(request.getUid())));
transaction.addData("data", data);
transaction.setSuccessStatus();
return wrapRoomDetailInfoDTO(config, RoomDTOConverter.convertDO(room), room.getUid());
} catch (Exception e) {
log.error("createRoom manager error", e);
transaction.setStatus(e);
throw new YppRunTimeException(ExceptionCode.CREATE_CHATROOM_ERROR);
} finally {
transaction.complete();
}
}
@Override
public RoomDetailInfoDTO openRoom(OpenCloseRoomRequest request) {
RoomDTO room = roomService.getRoomByRoomId(request.getRoomId());
if (room == null) {
throw new YppRunTimeException(ExceptionCode.CHATROOM_NOT_EXISTS);
}
checkUserHasAdminAuth(request.getRoomId(), request.getUid());
String data = room.getRoomId() + "_" + room.getUid();
Transaction transaction = Cat.newTransaction(TR_ROOM_OPEN.getCode(), TR_ROOM_OPEN.name());
try {
ProductConfig config = productConfigService.getConfigInfoByCode(room.getProductCode());
roomService.openRoom(request);
messageService.sendSonaCreateRoomMessage(request.getRoomId(), request.getUid(), config.getImModule());
logRoomOperateRecord(RoomOperateLog.wrapRoomLog(room.getRoomId(), config.getImModule(), RoomOperateEnum.OPEN.name(), String.valueOf(request.getUid())));
transaction.addData("data", data);
transaction.setSuccessStatus();
return wrapRoomDetailInfoDTO(config, room, room.getUid());
} catch (Exception e) {
transaction.setStatus(e);
log.error("openRoom manager error", e);
throw new YppRunTimeException(ExceptionCode.OPEN_CLOSE_CHATROOM_ERROR);
} finally {
transaction.complete();
}
}
@Override
public boolean closeRoom(OpenCloseRoomRequest request) {
RoomDTO room = roomService.getRoomByRoomId(request.getRoomId());
checkRoomValid(room);
checkUserHasAdminAuth(request.getRoomId(), request.getUid());
String data = room.getRoomId() + "_" + room.getUid();
Transaction transaction = Cat.newTransaction(TR_ROOM_CLOSE.getCode(), TR_ROOM_CLOSE.name());
try {
ProductConfig config = productConfigService.getConfigInfoByCode(room.getProductCode());
boolean ret = roomService.closeRoom(request);
logRoomOperateRecord(RoomOperateLog.wrapRoomLog(room.getRoomId(), config.getImModule(), RoomOperateEnum.CLOSE.name(), String.valueOf(request.getUid())));
if (IMModuleEnum.CHATROOM.name().equals(config.getImModule())) {
chatroomService.removeChatroomUsers(room.getRoomId());
} else {
groupService.removeGroupMembers(room.getRoomId());
}
messageService.sendSonaCloseRoomMessage(request.getRoomId(), request.getUid(), config.getImModule());
transaction.addData("data", data);
transaction.setSuccessStatus();
return ret;
} catch (Exception e) {
transaction.setStatus(e);
log.error("openRoom manager error", e);
throw new YppRunTimeException(ExceptionCode.OPEN_CLOSE_CHATROOM_ERROR);
} finally {
transaction.complete();
}
}
@Override
public RoomDetailInfoDTO enterRoom(EnterRoomRequest request) {
RoomDTO room = roomService.getRoomByRoomId(request.getRoomId());
checkRoomValid(room);
if (StringUtils.isNotBlank(room.getPassword()) && !StringUtils.equals(room.getPassword(), request.getPassword())) {
throw new YppRunTimeException(ExceptionCode.ERROR_PASSWORD);
}
if (request.getUid() != 0) {
boolean isBlocked = roomManagementService.isUserBlocked(request.getRoomId(), request.getUid());
if (isBlocked) {
throw new YppRunTimeException(ExceptionCode.HAS_BEEN_BLOCKED);
}
}
ProductConfig config = productConfigService.getConfigInfoByCode(room.getProductCode());
if (IMModuleEnum.CHATROOM.name().equals(config.getImModule())) {
if (request.getUid() == 0) {
return guestEnterChatroom(room, config);
} else {
return userEnterChatroom(room, config, request.getUid(), request.getUserTypeEnum());
}
} else {
if (request.getUid() == 0) {
throw new YppRunTimeException(ExceptionCode.EMPTY_PARAM);
}
return enterGroup(room, config, request.getUid());
}
}
@Override
public boolean leaveRoom(LeaveRoomRequest request) {
if (request.getUid() == 0){
return true;
}
RoomDTO room = roomService.getRoomByRoomId(request.getRoomId());
checkRoomValid(room);
ProductConfig config = productConfigService.getConfigInfoByCode(room.getProductCode());
boolean ret;
if (IMModuleEnum.CHATROOM.name().equals(config.getImModule())) {
ret = chatroomService.leaveChatroom(request.getRoomId(), request.getUid());
} else {
if (room.getUid() == request.getUid()) {
return false;
}
ret = groupService.leaveGroup(request.getRoomId(), request.getUid());
}
if (ret && config.isEnterNotifySwitch()) {
messageService.sendSonaLeaveRoomMessage(request.getRoomId(), request.getUid(), config.getImModule());
}
return ret;
}
@Override
public boolean updatePassword(UpdatePasswordRequest request) {
if (request == null || request.getRoomId() == 0 || request.getOperatorUid() == 0) {
throw new YppRunTimeException(ExceptionCode.EMPTY_PARAM);
}
RoomDTO room = roomService.getRoomByRoomId(request.getRoomId());
checkRoomValid(room);
checkUserHasAdminAuth(request.getRoomId(), request.getOperatorUid());
if (StringUtils.isNotBlank(room.getPassword()) && !room.getPassword().equals(request.getOldPassword())) {
throw new YppRunTimeException(ExceptionCode.ERROR_PASSWORD);
}
boolean ret = roomService.updatePassword(request.getRoomId(), request.getNewPassword());
if (ret) {
ProductConfig config = productConfigService.getConfigInfoByCode(room.getProductCode());
logRoomOperateRecord(RoomOperateLog.wrapRoomLog(room.getRoomId(), config.getImModule(), RoomOperateEnum.UPDATE_PASSWORD.name(), String.valueOf(request.getOperatorUid())));
}
return ret;
}
@Override
public boolean muteOrCancelUser(OperateRequest request) {
RoomDTO room = roomService.getRoomByRoomId(request.getRoomId());
checkRoomValid(room);
checkUserOperateAuth(request.getRoomId(), request.getOperatorUid(), request.getTargetUid());
boolean isMuted = roomManagementService.isUserMuted(request.getRoomId(), request.getTargetUid());
if (request.getOperate() == OperateEnum.SET.getCode()) {
if (isMuted) {
return true;
}
roomManagementService.muteTemporary(request.getRoomId(), request.getTargetUid(), request.getMinutes(), request.getOperatorUid());
} else {
if (!isMuted) {
return true;
}
roomManagementService.updateManagementInfoInvalid(request.getRoomId(), request.getTargetUid(), RoomManagementEnum.MUTE.getCode(), request.getOperatorUid());
}
ProductConfig config = productConfigService.getConfigInfoByCode(room.getProductCode());
messageService.sendSonaMuteMessage(request.getRoomId(), request.getTargetUid(), request.getOperate() == OperateEnum.SET.getCode(), request.getMinutes(), config.getImModule());
return true;
}
@Override
public boolean blockOrCancelUser(OperateRequest request) {
RoomDTO room = roomService.getRoomByRoomId(request.getRoomId());
checkRoomValid(room);
checkUserOperateAuth(request.getRoomId(), request.getOperatorUid(), request.getTargetUid());
ProductConfig config = productConfigService.getConfigInfoByCode(room.getProductCode());
boolean isBlocked = roomManagementService.isUserBlocked(request.getRoomId(), request.getTargetUid());
if (request.getOperate() == OperateEnum.SET.getCode()) {
if (isBlocked) {
return true;
}
roomManagementService.addRoomManagementInfo(request.getRoomId(), request.getTargetUid(), RoomManagementEnum.BLOCK.getCode(), request.getOperatorUid());
if (IMModuleEnum.CHATROOM.name().equals(config.getImModule())) {
chatroomService.kickoutChatroom(request.getRoomId(), request.getTargetUid());
} else {
groupService.leaveGroup(request.getRoomId(), request.getTargetUid());
}
} else {
if (!isBlocked) {
return true;
}
roomManagementService.updateManagementInfoInvalid(request.getRoomId(), request.getTargetUid(), RoomManagementEnum.BLOCK.getCode(), request.getOperatorUid());
}
messageService.sendSonaBlockMessage(request.getRoomId(), request.getTargetUid(), request.getOperate() == OperateEnum.SET.getCode(), config.getImModule());
return true;
}
@Override
public boolean kickUser(OperateRequest request) {
RoomDTO room = roomService.getRoomByRoomId(request.getRoomId());
checkRoomValid(room);
checkUserOperateAuth(request.getRoomId(), request.getOperatorUid(), request.getTargetUid());
ProductConfig config = productConfigService.getConfigInfoByCode(room.getProductCode());
if (IMModuleEnum.CHATROOM.name().equals(config.getImModule())) {
chatroomService.kickoutChatroom(request.getRoomId(), request.getTargetUid());
//todo 踢人消息？
// ChatroomMsgDTO chatroomMsgDTO = new ChatroomMsgDTO();
// chatroomMsgDTO.setRoomId(String.valueOf(request.getRoomId()));
// chatroomMsgDTO.setContent("踢人");
// roomMessageRemoteService.kickOutChatroom(chatroomMsgDTO, request.getTargetUid());
} else {
groupService.leaveGroup(request.getRoomId(), request.getTargetUid());
}
messageService.sendSonaKickMessage(request.getRoomId(), request.getTargetUid(), config.getImModule());
return true;
}
@Override
public boolean setOrRemoveAdmin(OperateRequest request) {
RoomDTO room = roomService.getRoomByRoomId(request.getRoomId());
checkRoomValid(room);
checkUserOperateAuth(request.getRoomId(), request.getOperatorUid(), request.getTargetUid());
boolean isAdmin = roomManagementService.isUserAdmin(request.getRoomId(), request.getTargetUid());
if (request.getOperate() == OperateEnum.SET.getCode()) {
if (isAdmin) {
return true;
}
roomManagementService.addRoomManagementInfo(request.getRoomId(), request.getTargetUid(), RoomManagementEnum.ADMIN.getCode(), request.getOperatorUid());
} else {
if (!isAdmin) {
return true;
}
roomManagementService.updateManagementInfoInvalid(request.getRoomId(), request.getTargetUid(), RoomManagementEnum.ADMIN.getCode(), request.getOperatorUid());
}
ProductConfig config = productConfigService.getConfigInfoByCode(room.getProductCode());
messageService.sendSonaAdminMessage(request.getRoomId(), request.getTargetUid(), request.getOperate() == OperateEnum.SET.getCode(), config.getImModule());
return true;
}
@Override
public boolean updateChatroomUserScore(long roomId, long uid, int score) {
RoomDTO room = roomService.getRoomByRoomId(roomId);
checkRoomValid(room);
ProductConfig config = productConfigService.getConfigInfoByCode(room.getProductCode());
if (IMModuleEnum.GROUP.name().equals(config.getImModule())) {
return false;
}
return chatroomService.updateUserScore(roomId, uid, score);
}
@Override
public RoomConfigDTO getRoomConfig(long roomId) {
RoomDTO room = roomService.getRoomByRoomId(roomId);
checkRoomValid(room);
RoomConfigDTO result = new RoomConfigDTO();
RoomConfig roomConfig = productConfigService.getRoomConfig(roomId);
if (roomConfig != null) {
BeanUtils.copyProperties(roomConfig, result);
return result;
}
ProductConfig productConfig = productConfigService.getConfigInfoByCode(room.getProductCode());
result.setRoomId(roomId);
BeanUtils.copyProperties(productConfig, result);
return result;
}
@Override
public PageResult<RoomDTO> getOnlineRoomList(String anchor, int limit) {
if (StringUtils.isBlank(anchor)) {
anchor = "0";
}
if (limit <= 0) {
limit = 20;
}
return roomService.getOnlineRoomList(anchor, limit);
}
private void checkRoomValid(RoomDTO room) {
if (room == null) {
throw new YppRunTimeException(ExceptionCode.CHATROOM_NOT_EXISTS);
}
if (room.getStatus() == RoomStatus.INVALID.getCode()) {
throw new YppRunTimeException(ExceptionCode.ROOM_CLOSED_ERROR);
}
}
private void checkUserHasAdminAuth(long roomId, long uid) {
if (!roomManagementService.isUserHasAdminAuth(roomId, uid)) {
throw new YppRunTimeException(ExceptionCode.ERROR_AUTH);
}
}
private void checkUserOperateAuth(long roomId, long operatorUid, long targetUid) {
log.info("checkUserOperateAuth roomId:{}, operatorUid:{}, targetUid:{}", roomId, operatorUid, targetUid);
List<Long> uids = Lists.newArrayList(operatorUid, targetUid);
Map<Long, UserRoleEnum> userRoleMap = roomManagementService.getUserRoleBatch(roomId, uids);
UserRoleEnum operatorRole = userRoleMap.get(operatorUid);
UserRoleEnum targetRole = userRoleMap.get(targetUid);
if (hasNoAuth(operatorRole, targetRole)) {
throw new YppRunTimeException(ExceptionCode.ERROR_AUTH);
}
}
private boolean hasNoAuth(UserRoleEnum operatorRole, UserRoleEnum targetRole) {
if (operatorRole.equals(targetRole) && operatorRole == UserRoleEnum.OWNER) {
return false;
}else {
return targetRole == UserRoleEnum.OWNER ||
targetRole == UserRoleEnum.ADMIN && (operatorRole == UserRoleEnum.MEMBER || operatorRole == UserRoleEnum.ADMIN) ||
targetRole == UserRoleEnum.MEMBER && operatorRole == UserRoleEnum.MEMBER;
}
}
private RoomDetailInfoDTO enterGroup(RoomDTO room, ProductConfig config, long uid) {
boolean ret = groupService.enterGroup(room.getRoomId(), config.getProductCode(), uid);
if (ret && config.isEnterNotifySwitch()) {
messageService.sendSonaEnterRoomMessage(room.getRoomId(), uid, config.getImModule());
}
return wrapRoomDetailInfoDTO(config, room, uid);
}
private RoomDetailInfoDTO guestEnterChatroom(RoomDTO room, ProductConfig config) {
long guestUid = idGenerator.id();
return wrapRoomDetailInfoDTOForChatroomGuest(config, room, guestUid);
}
private RoomDetailInfoDTO userEnterChatroom(RoomDTO room, ProductConfig config, long uid, UserTypeEnum userTypeEnum) {
// 可扩展score
boolean ret = chatroomService.enterChatroom(room.getRoomId(), uid, userTypeEnum, userTypeEnum == UserTypeEnum.VIP ? 100: 1);
if (ret && config.isEnterNotifySwitch()) {
messageService.sendSonaEnterRoomMessage(room.getRoomId(), uid, config.getImModule());
}
return wrapRoomDetailInfoDTO(config, room, uid);
}
private void logRoomOperateRecord(RoomOperateLog info) {
roomOperateLogMapper.insertSelective(info);
}
private RoomDetailInfoDTO wrapRoomDetailInfoDTO(ProductConfig config, RoomDTO room, long uid) {
return RoomDetailInfoConverter.convertDetailObj(config, room, wrapStreamConfigInfo(config, room, uid));
}
private StreamConfigInfoDTO wrapStreamConfigInfo(ProductConfig config, RoomDTO room, long uid) {
return streamManager.createStreamConfig(config, room, uid, false);
}
private RoomDetailInfoDTO wrapRoomDetailInfoDTOForChatroomGuest(ProductConfig config, RoomDTO room, long guestUid) {
return RoomDetailInfoConverter.convertDetailObjGuest(config, room, wrapStreamConfigInfoForChatroomGuest(config, room, guestUid), guestUid);
}
protected StreamConfigInfoDTO wrapStreamConfigInfoForChatroomGuest(ProductConfig config, RoomDTO room, long uid) {
return streamManager.createStreamConfig(config, room, uid,true);
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/stream/UserSginInputParam.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/stream/UserSginInputParam.java | package cn.bixin.sona.server.room.domain.stream;
/**
* 获得用户签名的输入参数
*/
public class UserSginInputParam {
/**
* 流提供商
*/
private String streamSupplier;
/**
* 是否需要录播
*/
private boolean needReplay;
/**
* uid
*/
private long uid;
/**
*
*/
private boolean isGuest;
/**
* 产品code
*/
private String productCode;
public String getStreamSupplier() {
return streamSupplier;
}
public void setStreamSupplier(String streamSupplier) {
this.streamSupplier = streamSupplier;
}
public boolean isNeedReplay() {
return needReplay;
}
public void setNeedReplay(boolean needReplay) {
this.needReplay = needReplay;
}
public long getUid() {
return uid;
}
public void setUid(long uid) {
this.uid = uid;
}
public boolean isGuest() {
return isGuest;
}
public void setGuest(boolean guest) {
isGuest = guest;
}
public String getProductCode() {
return productCode;
}
public void setProductCode(String productCode) {
this.productCode = productCode;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/stream/StreamContext.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/stream/StreamContext.java | package cn.bixin.sona.server.room.domain.stream;
import cn.bixin.sona.server.room.domain.enums.PlatformEnum;
import cn.bixin.sona.server.room.domain.enums.ProductEnum;
import cn.bixin.sona.server.room.domain.enums.StreamSupplierEnum;
import org.apache.commons.lang3.StringUtils;
public class StreamContext {
private String streamId;
private String productCode;
private StreamSupplierEnum streamSupplier;
private String sonaSdkVersion;
private PlatformEnum platform;
private Long roomId;
private Long uid;
private String randomNumber;
/**
* 短产品标识
*/
private String shortProductCode;
public static StreamContext convert(String streamId) {
if (StringUtils.isBlank(streamId)) {
return null;
}
String[] streamArray = streamId.split("_");
if (streamArray.length != 7) {
return null;
}
StreamContext context = new StreamContext();
context.setStreamId(streamId);
context.setProductCode(ProductEnum.getByCode(streamArray[0]).name());
context.setStreamSupplier(StreamSupplierEnum.getByDesc(streamArray[1]));
context.setSonaSdkVersion(streamArray[2]);
context.setPlatform(PlatformEnum.getPlatformByCode(Integer.valueOf(streamArray[3])));
context.setRoomId(Long.valueOf(streamArray[4]));
context.setUid(Long.parseLong(streamArray[5]));
context.setRandomNumber(streamArray[6]);
context.setShortProductCode(streamArray[0]);
return context;
}
public static String convertStringUid(String streamId) {
if (StringUtils.isBlank(streamId)) {
return null;
}
String[] streamArray = streamId.split("_");
if (streamArray.length != 7) {
return null;
}
return streamArray[5];
}
public String getStreamId() {
return streamId;
}
public void setStreamId(String streamId) {
this.streamId = streamId;
}
public String getProductCode() {
return productCode;
}
public void setProductCode(String productCode) {
this.productCode = productCode;
}
public StreamSupplierEnum getStreamSupplier() {
return streamSupplier;
}
public void setStreamSupplier(StreamSupplierEnum streamSupplier) {
this.streamSupplier = streamSupplier;
}
public String getSonaSdkVersion() {
return sonaSdkVersion;
}
public void setSonaSdkVersion(String sonaSdkVersion) {
this.sonaSdkVersion = sonaSdkVersion;
}
public PlatformEnum getPlatform() {
return platform;
}
public void setPlatform(PlatformEnum platform) {
this.platform = platform;
}
public Long getRoomId() {
return roomId;
}
public void setRoomId(Long roomId) {
this.roomId = roomId;
}
public Long getUid() {
return uid;
}
public void setUid(Long uid) {
this.uid = uid;
}
public String getRandomNumber() {
return randomNumber;
}
public void setRandomNumber(String randomNumber) {
this.randomNumber = randomNumber;
}
public String getShortProductCode() {
return shortProductCode;
}
public void setShortProductCode(String shortProductCode) {
this.shortProductCode = shortProductCode;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/stream/AppIdAndSign.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/stream/AppIdAndSign.java | package cn.bixin.sona.server.room.domain.stream;
public class AppIdAndSign {
private int appId;
private String appID;
public int getAppId() {
return appId;
}
public void setAppId(int appId) {
this.appId = appId;
}
public String getAppID() {
return appID;
}
public void setAppID(String appID) {
this.appID = appID;
}
public String getAppSign() {
return appSign;
}
public void setAppSign(String appSign) {
this.appSign = appSign;
}
private String appSign;
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/db/RoomConfig.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/db/RoomConfig.java | package cn.bixin.sona.server.room.domain.db;
import cn.bixin.sona.enums.RoomMixedEnum;
import org.springframework.beans.BeanUtils;
import java.util.Objects;
public class RoomConfig {
private Long roomId;
private String imModule;
/**
* 发送类型 长连 短连
* persistantCon,nonPersistantCon
*/
private int imSendType;
private String streamSupplier;
private String type;
private String pullMode;
private String pushMode;
private boolean enterNotifySwitch;
private boolean checkAdmin;
private boolean needReplay;
private Integer clientType;
private String productCode;
/**
* 码率
*/
private Integer bitrate;
private String shortCode;
public static RoomConfig convert(ProductConfig productConfig) {
RoomConfig roomConfig = new RoomConfig();
roomConfig.setImModule(productConfig.getImModule());
roomConfig.setStreamSupplier(productConfig.getStreamSupplier());
roomConfig.setType(productConfig.getType());
roomConfig.setPullMode(productConfig.getPullMode());
roomConfig.setPushMode(productConfig.getPushMode());
roomConfig.setEnterNotifySwitch(productConfig.isEnterNotifySwitch());
roomConfig.setCheckAdmin(productConfig.isCheckAdmin());
roomConfig.setNeedReplay(productConfig.isNeedReplay());
roomConfig.setProductCode(productConfig.getProductCode());
roomConfig.setImSendType(productConfig.getImSendType());
roomConfig.setClientType(productConfig.getClientType());
roomConfig.setBitrate(productConfig.getBitrate());
roomConfig.setShortCode(productConfig.getShortCode());
return roomConfig;
}
public static RoomConfig convertByRoomConfig(RoomConfig each, RoomMixedEnum roomMixedEnum) {
RoomConfig roomConfig = new RoomConfig();
BeanUtils.copyProperties(each, roomConfig);
fillRoomConfig(roomMixedEnum, roomConfig);
roomConfig.setBitrate(each.getBitrate());
return roomConfig;
}
public static RoomConfig convertByProductConfig(ProductConfig productConfig, RoomMixedEnum roomMixedEnum) {
RoomConfig roomConfig = convert(productConfig);
fillRoomConfig(roomMixedEnum, roomConfig);
fillAudioConfig(productConfig, roomConfig);
return roomConfig;
}
private static void fillAudioConfig(ProductConfig productConfig, RoomConfig roomConfig) {
if (Objects.isNull(roomConfig)) {
return;
}
roomConfig.setBitrate(productConfig.getBitrate());
}
private static void fillRoomConfig(RoomMixedEnum mixed, RoomConfig roomConfig) {
if (roomConfig == null) {
return;
}
roomConfig.setStreamSupplier(mixed.getSupplier());
roomConfig.setPullMode(mixed.getPullMode());
roomConfig.setPushMode(mixed.getPushMode());
}
public Long getRoomId() {
return roomId;
}
public void setRoomId(Long roomId) {
this.roomId = roomId;
}
public String getImModule() {
return imModule;
}
public void setImModule(String imModule) {
this.imModule = imModule;
}
public int getImSendType() {
return imSendType;
}
public void setImSendType(int imSendType) {
this.imSendType = imSendType;
}
public String getStreamSupplier() {
return streamSupplier;
}
public void setStreamSupplier(String streamSupplier) {
this.streamSupplier = streamSupplier;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public String getPullMode() {
return pullMode;
}
public void setPullMode(String pullMode) {
this.pullMode = pullMode;
}
public String getPushMode() {
return pushMode;
}
public void setPushMode(String pushMode) {
this.pushMode = pushMode;
}
public boolean isEnterNotifySwitch() {
return enterNotifySwitch;
}
public void setEnterNotifySwitch(boolean enterNotifySwitch) {
this.enterNotifySwitch = enterNotifySwitch;
}
public boolean isCheckAdmin() {
return checkAdmin;
}
public void setCheckAdmin(boolean checkAdmin) {
this.checkAdmin = checkAdmin;
}
public boolean isNeedReplay() {
return needReplay;
}
public void setNeedReplay(boolean needReplay) {
this.needReplay = needReplay;
}
public Integer getClientType() {
return clientType;
}
public void setClientType(Integer clientType) {
this.clientType = clientType;
}
public String getProductCode() {
return productCode;
}
public void setProductCode(String productCode) {
this.productCode = productCode;
}
public Integer getBitrate() {
return bitrate;
}
public void setBitrate(Integer bitrate) {
this.bitrate = bitrate;
}
public String getShortCode() {
return shortCode;
}
public void setShortCode(String shortCode) {
this.shortCode = shortCode;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/db/RoomManagementLog.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/db/RoomManagementLog.java | package cn.bixin.sona.server.room.domain.db;
public class RoomManagementLog {
private long roomId;
private long uid;
private int type;
private int operate; // 0: 取消 1: 设置
private long operator;
public static RoomManagementLog wrapRecordObj(long roomId, long targetUid, int type, int operate, long operator) {
RoomManagementLog log = new RoomManagementLog();
log.setRoomId(roomId);
log.setUid(targetUid);
log.setType(type);
log.setOperate(operate);
log.setOperator(operator);
return log;
}
public long getRoomId() {
return roomId;
}
public void setRoomId(long roomId) {
this.roomId = roomId;
}
public long getUid() {
return uid;
}
public void setUid(long uid) {
this.uid = uid;
}
public int getType() {
return type;
}
public void setType(int type) {
this.type = type;
}
public int getOperate() {
return operate;
}
public void setOperate(int operate) {
this.operate = operate;
}
public long getOperator() {
return operator;
}
public void setOperator(long operator) {
this.operator = operator;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/db/MixStreamReplay.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/db/MixStreamReplay.java | package cn.bixin.sona.server.room.domain.db;
import java.util.Date;
public class MixStreamReplay {
private Long id;
private Long roomId;
private String bizRoomId;
private String streamId;
private Integer source;
private String replayUrl;
private Date beginTime;
private Date endTime;
private Date createTime;
private Date updateTime;
public static MixStreamReplay converter(MixStream mixStream, String replayUrl, Date beginTime, Date endTime){
MixStreamReplay replay = new MixStreamReplay();
replay.setRoomId(mixStream.getRoomId());
replay.setBizRoomId(mixStream.getBizRoomId());
replay.setStreamId(mixStream.getStreamId());
replay.setSource(mixStream.getSource());
replay.setReplayUrl(replayUrl);
replay.setBeginTime(beginTime);
replay.setEndTime(endTime);
return replay;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public Long getRoomId() {
return roomId;
}
public void setRoomId(Long roomId) {
this.roomId = roomId;
}
public String getBizRoomId() {
return bizRoomId;
}
public void setBizRoomId(String bizRoomId) {
this.bizRoomId = bizRoomId;
}
public String getStreamId() {
return streamId;
}
public void setStreamId(String streamId) {
this.streamId = streamId;
}
public Integer getSource() {
return source;
}
public void setSource(Integer source) {
this.source = source;
}
public String getReplayUrl() {
return replayUrl;
}
public void setReplayUrl(String replayUrl) {
this.replayUrl = replayUrl;
}
public Date getBeginTime() {
return beginTime;
}
public void setBeginTime(Date beginTime) {
this.beginTime = beginTime;
}
public Date getEndTime() {
return endTime;
}
public void setEndTime(Date endTime) {
this.endTime = endTime;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public Date getUpdateTime() {
return updateTime;
}
public void setUpdateTime(Date updateTime) {
this.updateTime = updateTime;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/db/MixConfig.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/db/MixConfig.java | package cn.bixin.sona.server.room.domain.db;
import com.alibaba.fastjson.JSONObject;
import java.io.Serializable;
import java.util.Date;
/**
* 混流配置表
*
* @author 木欣
* @create 2021-05-27
* @email baojiawei@bixin.cn
* create by intelliJ IDEA
*/
public class MixConfig implements Serializable {
private static final long serialVersionUID = 1449637767939529176L;
/**
* 主键
*/
private Long id;
/**
* 房间ID
*/
private Long roomId;
/**
* 用户uid
*/
private String uid;
/**
* 画布宽
*/
private Integer width;
/**
* 画布高
*/
private Integer height;
/**
* 上边框
*/
private Integer tops;
/**
* 下边框
*/
private Integer bottom;
/**
* 左边框
*/
private Integer lefts;
/**
* 右边框
*/
private Integer rights;
/**
* 码率
*/
private Integer bitrate;
/**
* 帧率
*/
private Integer fps;
/**
* 记录状态 1: 视频 2: 音频
*/
private Integer status;
/**
* 创建时间
*/
private Date createTime;
/**
* 更新时间
*/
private Date updateTime;
@Override
public String toString() {
return JSONObject.toJSONString(this);
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public Long getRoomId() {
return roomId;
}
public void setRoomId(Long roomId) {
this.roomId = roomId;
}
public String getUid() {
return uid;
}
public void setUid(String uid) {
this.uid = uid;
}
public Integer getWidth() {
return width;
}
public void setWidth(Integer width) {
this.width = width;
}
public Integer getHeight() {
return height;
}
public void setHeight(Integer height) {
this.height = height;
}
public Integer getTops() {
return tops;
}
public void setTops(Integer tops) {
this.tops = tops;
}
public Integer getBottom() {
return bottom;
}
public void setBottom(Integer bottom) {
this.bottom = bottom;
}
public Integer getLefts() {
return lefts;
}
public void setLefts(Integer lefts) {
this.lefts = lefts;
}
public Integer getRights() {
return rights;
}
public void setRights(Integer rights) {
this.rights = rights;
}
public Integer getBitrate() {
return bitrate;
}
public void setBitrate(Integer bitrate) {
this.bitrate = bitrate;
}
public Integer getFps() {
return fps;
}
public void setFps(Integer fps) {
this.fps = fps;
}
public Integer getStatus() {
return status;
}
public void setStatus(Integer status) {
this.status = status;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public Date getUpdateTime() {
return updateTime;
}
public void setUpdateTime(Date updateTime) {
this.updateTime = updateTime;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/db/MixStream.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/db/MixStream.java | package cn.bixin.sona.server.room.domain.db;
import java.util.Date;
public class MixStream {
private Long id;
private Long roomId;
private String bizRoomId;
private String streamId;
private Integer source;
private String rtmpUrl;
private String hlsUrl;
private String hdlUrl;
private String inputStream;
private Integer status;
private Date beginTime;
private Date endTime;
private Date createTime;
private Date updateTime;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public Long getRoomId() {
return roomId;
}
public void setRoomId(Long roomId) {
this.roomId = roomId;
}
public String getBizRoomId() {
return bizRoomId;
}
public void setBizRoomId(String bizRoomId) {
this.bizRoomId = bizRoomId == null ? null : bizRoomId.trim();
}
public String getStreamId() {
return streamId;
}
public void setStreamId(String streamId) {
this.streamId = streamId == null ? null : streamId.trim();
}
public Integer getSource() {
return source;
}
public void setSource(Integer source) {
this.source = source;
}
public String getRtmpUrl() {
return rtmpUrl;
}
public void setRtmpUrl(String rtmpUrl) {
this.rtmpUrl = rtmpUrl == null ? null : rtmpUrl.trim();
}
public String getHlsUrl() {
return hlsUrl;
}
public void setHlsUrl(String hlsUrl) {
this.hlsUrl = hlsUrl == null ? null : hlsUrl.trim();
}
public String getHdlUrl() {
return hdlUrl;
}
public void setHdlUrl(String hdlUrl) {
this.hdlUrl = hdlUrl == null ? null : hdlUrl.trim();
}
public String getInputStream() {
return inputStream;
}
public void setInputStream(String inputStream) {
this.inputStream = inputStream == null ? null : inputStream.trim();
}
public Integer getStatus() {
return status;
}
public void setStatus(Integer status) {
this.status = status;
}
public Date getBeginTime() {
return beginTime;
}
public void setBeginTime(Date beginTime) {
this.beginTime = beginTime;
}
public Date getEndTime() {
return endTime;
}
public void setEndTime(Date endTime) {
this.endTime = endTime;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public Date getUpdateTime() {
return updateTime;
}
public void setUpdateTime(Date updateTime) {
this.updateTime = updateTime;
}
} | java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/db/RoomOperateLog.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/db/RoomOperateLog.java | package cn.bixin.sona.server.room.domain.db;
import cn.bixin.sona.server.room.domain.enums.IMModuleEnum;
public class RoomOperateLog {
private Long roomId;
private String type;
private String operate;
private String operator;
public static RoomOperateLog wrapRoomLog(long roomId, String imModule, String operate, String operator) {
RoomOperateLog log = new RoomOperateLog();
log.setRoomId(roomId);
log.setType(IMModuleEnum.CHATROOM.name());
log.setOperate(operate);
log.setOperator(operator);
return log;
}
public Long getRoomId() {
return roomId;
}
public void setRoomId(Long roomId) {
this.roomId = roomId;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public String getOperate() {
return operate;
}
public void setOperate(String operate) {
this.operate = operate;
}
public String getOperator() {
return operator;
}
public void setOperator(String operator) {
this.operator = operator;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/db/Room.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/db/Room.java | package cn.bixin.sona.server.room.domain.db;
import cn.bixin.sona.common.enums.RoomStatus;
import cn.bixin.sona.request.CreateRoomRequest;
import cn.bixin.sona.server.room.domain.enums.StreamSupplierEnum;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.google.common.collect.Maps;
import org.apache.commons.lang.StringUtils;
import org.springframework.util.CollectionUtils;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
public class Room {
private Long roomId;
private String name;
private Integer status;
private String password;
private Long uid;
private String productCode;
private String imModule;
private Date createTime;
private Date updateTime;
private String resourceRoomId;
private String ext;
public static Room wrapCreateObj(CreateRoomRequest request, Long roomId, String imModule) {
Room room = new Room();
room.setRoomId(roomId);
room.setName(StringUtils.isNotBlank(request.getName()) ? request.getName() : generateRoomTitle(request.getUid()));
room.setStatus(RoomStatus.VALID.getCode());
room.setPassword(request.getPassword());
room.setUid(request.getUid());
room.setProductCode(request.getProductCode());
room.setImModule(imModule);
room.setCreateTime(new Date());
room.setExt(CollectionUtils.isEmpty(request.getExtMap()) ?
JSONObject.toJSONString(initStreamExt(String.valueOf(roomId)))
: genExtWithStream(request.getExtMap(), String.valueOf(roomId)));
return room;
}
private static String generateRoomTitle(long uid) {
return "room" + uid + System.currentTimeMillis();
}
private static String genExtWithStream(Map<String, Object> extMap, String roomIdStr) {
Map<String, Object> result = Maps.newHashMap(extMap);
result.putAll(initStreamExt(roomIdStr));
return JSON.toJSONString(result);
}
private static Map<String, Object> initStreamExt(String roomIdStr) {
return new HashMap<String, Object>() {{
put(StreamSupplierEnum.ZEGO.name(), roomIdStr);
put(StreamSupplierEnum.TENCENT.name(), roomIdStr);
}};
}
public Long getRoomId() {
return roomId;
}
public void setRoomId(Long roomId) {
this.roomId = roomId;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getStatus() {
return status;
}
public void setStatus(Integer status) {
this.status = status;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public Long getUid() {
return uid;
}
public void setUid(Long uid) {
this.uid = uid;
}
public String getProductCode() {
return productCode;
}
public void setProductCode(String productCode) {
this.productCode = productCode;
}
public String getImModule() {
return imModule;
}
public void setImModule(String imModule) {
this.imModule = imModule;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public Date getUpdateTime() {
return updateTime;
}
public void setUpdateTime(Date updateTime) {
this.updateTime = updateTime;
}
public String getResourceRoomId() {
return resourceRoomId;
}
public void setResourceRoomId(String resourceRoomId) {
this.resourceRoomId = resourceRoomId;
}
public String getExt() {
return ext;
}
public void setExt(String ext) {
this.ext = ext;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/db/Stream.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/db/Stream.java | package cn.bixin.sona.server.room.domain.db;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.apache.commons.lang.StringUtils;
import java.util.Date;
import java.util.Objects;
public class Stream {
private String productCode;
private String streamId;
private long roomId;
private int status; // -1:初始化 0:关闭 1:打开
private long uid;
private int source;
private String rtmpUrl;
private String hlsUrl;
private String hdlUrl;
private String picUrl;
private String replayUrl;
private Date beginTime;
private Date closeTime;
private Date endTime;
private int closeType; //0-正常关闭 1-后台超时关闭 2-同一主播直播关闭之前没有关闭的流
private String errMsg;
private String ext;
/**
* 根据key获取扩展字段中的信息
*/
public String getExtByKey(String key) {
if (StringUtils.isEmpty(ext) || StringUtils.isEmpty(key)) {
return null;
}
JSONObject jsonObject = JSON.parseObject(ext);
return jsonObject.getString(key);
}
public Boolean getBooleanExtByKey(String key) {
if (StringUtils.isEmpty(ext) || StringUtils.isEmpty(key)) {
return null;
}
JSONObject jsonObject = JSON.parseObject(ext);
return jsonObject.getBoolean(key);
}
public Long getLongExtByKey(String key) {
if (StringUtils.isEmpty(ext) || StringUtils.isEmpty(key)) {
return null;
}
JSONObject jsonObject = JSON.parseObject(ext);
return jsonObject.getLongValue(key);
}
public Integer getIntegerExtByKey(String key) {
if (StringUtils.isEmpty(ext) || StringUtils.isEmpty(key)) {
return null;
}
JSONObject jsonObject = JSON.parseObject(ext);
return jsonObject.getInteger(key);
}
public void putExt(String key, Object value) {
if (StringUtils.isEmpty(key) || Objects.isNull(value)) {
return;
}
JSONObject jsonObject;
if (StringUtils.isEmpty(ext)) {
jsonObject = new JSONObject();
} else {
jsonObject = JSON.parseObject(ext);
}
jsonObject.put(key, value);
ext = jsonObject.toJSONString();
}
public String getProductCode() {
return productCode;
}
public void setProductCode(String productCode) {
this.productCode = productCode;
}
public String getStreamId() {
return streamId;
}
public void setStreamId(String streamId) {
this.streamId = streamId;
}
public long getRoomId() {
return roomId;
}
public void setRoomId(long roomId) {
this.roomId = roomId;
}
public int getStatus() {
return status;
}
public void setStatus(int status) {
this.status = status;
}
public long getUid() {
return uid;
}
public void setUid(long uid) {
this.uid = uid;
}
public int getSource() {
return source;
}
public void setSource(int source) {
this.source = source;
}
public String getRtmpUrl() {
return rtmpUrl;
}
public void setRtmpUrl(String rtmpUrl) {
this.rtmpUrl = rtmpUrl;
}
public String getHlsUrl() {
return hlsUrl;
}
public void setHlsUrl(String hlsUrl) {
this.hlsUrl = hlsUrl;
}
public String getHdlUrl() {
return hdlUrl;
}
public void setHdlUrl(String hdlUrl) {
this.hdlUrl = hdlUrl;
}
public String getPicUrl() {
return picUrl;
}
public void setPicUrl(String picUrl) {
this.picUrl = picUrl;
}
public String getReplayUrl() {
return replayUrl;
}
public void setReplayUrl(String replayUrl) {
this.replayUrl = replayUrl;
}
public Date getBeginTime() {
return beginTime;
}
public void setBeginTime(Date beginTime) {
this.beginTime = beginTime;
}
public Date getCloseTime() {
return closeTime;
}
public void setCloseTime(Date closeTime) {
this.closeTime = closeTime;
}
public Date getEndTime() {
return endTime;
}
public void setEndTime(Date endTime) {
this.endTime = endTime;
}
public int getCloseType() {
return closeType;
}
public void setCloseType(int closeType) {
this.closeType = closeType;
}
public String getErrMsg() {
return errMsg;
}
public void setErrMsg(String errMsg) {
this.errMsg = errMsg;
}
public String getExt() {
return ext;
}
public void setExt(String ext) {
this.ext = ext;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/db/GroupUserCount.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/db/GroupUserCount.java | package cn.bixin.sona.server.room.domain.db;
public class GroupUserCount {
private long roomId;
private long count;
public long getRoomId() {
return roomId;
}
public void setRoomId(long roomId) {
this.roomId = roomId;
}
public long getCount() {
return count;
}
public void setCount(long count) {
this.count = count;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/db/RoomManagementInfo.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/db/RoomManagementInfo.java | package cn.bixin.sona.server.room.domain.db;
import cn.bixin.sona.server.room.domain.request.OperateUserRequest;
import java.util.Calendar;
import java.util.Date;
public class RoomManagementInfo {
private long roomId;
private long uid;
private int status;
private Date expireTime;
private int type;
public static RoomManagementInfo wrapNewObj(long roomId, long uid, int type) {
RoomManagementInfo managementInfo = new RoomManagementInfo();
managementInfo.setRoomId(roomId);
managementInfo.setUid(uid);
managementInfo.setStatus(1);
managementInfo.setType(type);
return managementInfo;
}
public static RoomManagementInfo wrapNewObj(OperateUserRequest request, int type) {
RoomManagementInfo managementInfo = new RoomManagementInfo();
managementInfo.setRoomId(request.getRoomId());
managementInfo.setUid(request.getTargetUid());
managementInfo.setStatus(1);
managementInfo.setType(type);
return managementInfo;
}
public static RoomManagementInfo wrapNewObj(long roomId, long uid, int type, int minute) {
RoomManagementInfo managementInfo = new RoomManagementInfo();
managementInfo.setRoomId(roomId);
managementInfo.setUid(uid);
managementInfo.setStatus(1);
managementInfo.setExpireTime(addMinute(minute));
managementInfo.setType(type);
return managementInfo;
}
/**
* 当前时间加 minute分钟
*/
private static Date addMinute(int minute) {
Calendar cal = Calendar.getInstance();
cal.add(Calendar.MINUTE, minute);
return cal.getTime();
}
public long getRoomId() {
return roomId;
}
public void setRoomId(long roomId) {
this.roomId = roomId;
}
public long getUid() {
return uid;
}
public void setUid(long uid) {
this.uid = uid;
}
public int getStatus() {
return status;
}
public void setStatus(int status) {
this.status = status;
}
public Date getExpireTime() {
return expireTime;
}
public void setExpireTime(Date expireTime) {
this.expireTime = expireTime;
}
public int getType() {
return type;
}
public void setType(int type) {
this.type = type;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/db/ProductConfig.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/db/ProductConfig.java | package cn.bixin.sona.server.room.domain.db;
import cn.bixin.sona.enums.RoomMixedEnum;
import org.springframework.beans.BeanUtils;
import java.util.Date;
public class ProductConfig {
private Long id;
private Date createTime;
private Date updateTime;
private String productCode;
private String imModule;
/**
* 发送类型 长连 短连
* persistantCon,nonPersistantCon
*/
private int imSendType;
private String streamSupplier;
private String type;
private String pullMode;
private String pushMode;
private boolean enterNotifySwitch;
private boolean checkAdmin;
private boolean needReplay;
private int clientType;
/**
* 码率
*/
private Integer bitrate;
/**
* 短码
*/
private String shortCode;
public static ProductConfig copy(ProductConfig productConfig) {
ProductConfig result = new ProductConfig();
BeanUtils.copyProperties(productConfig, result);
return result;
}
public static ProductConfig convertConfigInfo(RoomConfig roomConfig, String productCode) {
ProductConfig productConfig = new ProductConfig();
BeanUtils.copyProperties(roomConfig, productConfig);
productConfig.setProductCode(productCode);
return productConfig;
}
public static void fillProductConfig(RoomMixedEnum mixed, ProductConfig productConfig) {
if (productConfig == null) return ;
productConfig.setStreamSupplier(mixed.getSupplier());
productConfig.setPullMode(mixed.getPullMode());
productConfig.setPushMode(mixed.getPushMode());
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public Date getUpdateTime() {
return updateTime;
}
public void setUpdateTime(Date updateTime) {
this.updateTime = updateTime;
}
public String getProductCode() {
return productCode;
}
public void setProductCode(String productCode) {
this.productCode = productCode;
}
public String getImModule() {
return imModule;
}
public void setImModule(String imModule) {
this.imModule = imModule;
}
public int getImSendType() {
return imSendType;
}
public void setImSendType(int imSendType) {
this.imSendType = imSendType;
}
public String getStreamSupplier() {
return streamSupplier;
}
public void setStreamSupplier(String streamSupplier) {
this.streamSupplier = streamSupplier;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public String getPullMode() {
return pullMode;
}
public void setPullMode(String pullMode) {
this.pullMode = pullMode;
}
public String getPushMode() {
return pushMode;
}
public void setPushMode(String pushMode) {
this.pushMode = pushMode;
}
public boolean isEnterNotifySwitch() {
return enterNotifySwitch;
}
public void setEnterNotifySwitch(boolean enterNotifySwitch) {
this.enterNotifySwitch = enterNotifySwitch;
}
public boolean isCheckAdmin() {
return checkAdmin;
}
public void setCheckAdmin(boolean checkAdmin) {
this.checkAdmin = checkAdmin;
}
public boolean isNeedReplay() {
return needReplay;
}
public void setNeedReplay(boolean needReplay) {
this.needReplay = needReplay;
}
public int getClientType() {
return clientType;
}
public void setClientType(int clientType) {
this.clientType = clientType;
}
public Integer getBitrate() {
return bitrate;
}
public void setBitrate(Integer bitrate) {
this.bitrate = bitrate;
}
public String getShortCode() {
return shortCode;
}
public void setShortCode(String shortCode) {
this.shortCode = shortCode;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/db/GroupMember.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/db/GroupMember.java | package cn.bixin.sona.server.room.domain.db;
public class GroupMember {
/**
* 自增ID
*/
private Long id;
/**
* 产品码
*/
private String productCode;
/**
* 房间ID
*/
private Long roomId;
/**
* 1在线，0离开
*/
private int status;
/**
* 用户UID
*/
private long uid;
public static GroupMember wrapCreateObj(long roomId, long uid, String productCode) {
GroupMember groupMember = new GroupMember();
groupMember.setRoomId(roomId);
groupMember.setUid(uid);
groupMember.setProductCode(productCode);
groupMember.setStatus(1);
return groupMember;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getProductCode() {
return productCode;
}
public void setProductCode(String productCode) {
this.productCode = productCode;
}
public Long getRoomId() {
return roomId;
}
public void setRoomId(Long roomId) {
this.roomId = roomId;
}
public int getStatus() {
return status;
}
public void setStatus(int status) {
this.status = status;
}
public long getUid() {
return uid;
}
public void setUid(long uid) {
this.uid = uid;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/db/RoomLogRecord.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/db/RoomLogRecord.java | package cn.bixin.sona.server.room.domain.db;
import cn.bixin.sona.request.LogReportRequest;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.apache.commons.lang3.StringUtils;
import java.util.Date;
public class RoomLogRecord {
private String roomId;
private long uid;
private String streamId;
private int type;
private int businessSide;
private int appId;
private String version;
private String request;
private String response;
private boolean success;
private String exception;
private Date createTime;
private int productId;
private String osName;
public static RoomLogRecord convertRoomLogRecord(LogReportRequest request) {
if (request == null || request.getCode() == 0 || StringUtils.isBlank(request.getData())) {
return null;
}
JSONObject jsonObject = JSONObject.parseObject(request.getData());
RoomLogRecord roomLogRecord = new RoomLogRecord();
roomLogRecord.setAppId(request.getAppId());
roomLogRecord.setVersion(request.getVersion());
roomLogRecord.setType(request.getCode());
if (jsonObject.getInteger("code") != null) {
jsonObject = jsonObject.getJSONObject("data");
}
roomLogRecord.setRoomId(jsonObject.getString("roomId"));
roomLogRecord.setUid(jsonObject.getLongValue("uid"));
roomLogRecord.setStreamId(jsonObject.getString("streamId"));
roomLogRecord.setSuccess(request.getCode() > 0);
roomLogRecord.setOsName(request.getOsName());
roomLogRecord.setProductId(request.getProductId());
String sdkCode = jsonObject.getString("sdkCode");
String message = jsonObject.getString("message");
JSONObject reportMsg = new JSONObject();
if (StringUtils.isNotBlank(sdkCode)) {
reportMsg.put("sdkCode", sdkCode);
}
if (StringUtils.isNotBlank(message)) {
reportMsg.put("message", message);
}
if (!jsonObject.isEmpty()) {
if (!roomLogRecord.isSuccess()) {
roomLogRecord.setException(JSON.toJSONString(reportMsg));
}else {
roomLogRecord.setResponse(JSON.toJSONString(reportMsg));
}
}
roomLogRecord.setCreateTime(new Date());
return roomLogRecord;
}
public String getRoomId() {
return roomId;
}
public void setRoomId(String roomId) {
this.roomId = roomId;
}
public long getUid() {
return uid;
}
public void setUid(long uid) {
this.uid = uid;
}
public String getStreamId() {
return streamId;
}
public void setStreamId(String streamId) {
this.streamId = streamId;
}
public int getType() {
return type;
}
public void setType(int type) {
this.type = type;
}
public int getBusinessSide() {
return businessSide;
}
public void setBusinessSide(int businessSide) {
this.businessSide = businessSide;
}
public int getAppId() {
return appId;
}
public void setAppId(int appId) {
this.appId = appId;
}
public String getVersion() {
return version;
}
public void setVersion(String version) {
this.version = version;
}
public String getRequest() {
return request;
}
public void setRequest(String request) {
this.request = request;
}
public String getResponse() {
return response;
}
public void setResponse(String response) {
this.response = response;
}
public boolean isSuccess() {
return success;
}
public void setSuccess(boolean success) {
this.success = success;
}
public String getException() {
return exception;
}
public void setException(String exception) {
this.exception = exception;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public int getProductId() {
return productId;
}
public void setProductId(int productId) {
this.productId = productId;
}
public String getOsName() {
return osName;
}
public void setOsName(String osName) {
this.osName = osName;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/request/TencentStartMixRequest.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/request/TencentStartMixRequest.java | package cn.bixin.sona.server.room.domain.request;
import com.alibaba.fastjson.annotation.JSONField;
public class TencentStartMixRequest {
//{
// "SdkAppId":1400282383,
// "RoomId":125092924,
// "OutputParams":{
// "StreamId":"7bc6a00a16c84eb19efba9b017b1389c",
// "PureAudioStream":1
// },
// "EncodeParams":{
// "AudioSampleRate":48000,
// "AudioBitrate":128,
// "AudioChannels":2
// },
// "LayoutParams":{
// "Template":0
// }
//}
@JSONField(name="SdkAppId")
private long sdkAppId;
@JSONField(name="RoomId")
private long roomId;
@JSONField(name="OutputParams")
private OutputParams outputParams;
@JSONField(name="EncodeParams")
private EncodeParams encodeParams;
@JSONField(name="LayoutParams")
private LayoutParams layoutParams;
public static class OutputParams {
@JSONField(name="StreamId")
private String streamId;
@JSONField(name="PureAudioStream")
private int pureAudioStream;
public String getStreamId() {
return streamId;
}
public void setStreamId(String streamId) {
this.streamId = streamId;
}
public int getPureAudioStream() {
return pureAudioStream;
}
public void setPureAudioStream(int pureAudioStream) {
this.pureAudioStream = pureAudioStream;
}
}
public static class EncodeParams {
@JSONField(name="AudioSampleRate")
private int audioSampleRate;
@JSONField(name="AudioBitrate")
private int audioBitrate;
@JSONField(name="AudioChannels")
private int audioChannels;
@JSONField(name="VideoWidth")
private int videoWidth;
@JSONField(name="VideoHeight")
private int videoHeight;
@JSONField(name="VideoBitrate")
private int videoBitrate;
@JSONField(name="VideoFramerate")
private int videoFramerate;
@JSONField(name="VideoGop")
private int videoGop;
public int getAudioSampleRate() {
return audioSampleRate;
}
public void setAudioSampleRate(int audioSampleRate) {
this.audioSampleRate = audioSampleRate;
}
public int getAudioBitrate() {
return audioBitrate;
}
public void setAudioBitrate(int audioBitrate) {
this.audioBitrate = audioBitrate;
}
public int getAudioChannels() {
return audioChannels;
}
public void setAudioChannels(int audioChannels) {
this.audioChannels = audioChannels;
}
public int getVideoWidth() {
return videoWidth;
}
public void setVideoWidth(int videoWidth) {
this.videoWidth = videoWidth;
}
public int getVideoHeight() {
return videoHeight;
}
public void setVideoHeight(int videoHeight) {
this.videoHeight = videoHeight;
}
public int getVideoBitrate() {
return videoBitrate;
}
public void setVideoBitrate(int videoBitrate) {
this.videoBitrate = videoBitrate;
}
public int getVideoFramerate() {
return videoFramerate;
}
public void setVideoFramerate(int videoFramerate) {
this.videoFramerate = videoFramerate;
}
public int getVideoGop() {
return videoGop;
}
public void setVideoGop(int videoGop) {
this.videoGop = videoGop;
}
}
public static class LayoutParams {
@JSONField(name="Template")
private int template;
public int getTemplate() {
return template;
}
public void setTemplate(int template) {
this.template = template;
}
}
public long getSdkAppId() {
return sdkAppId;
}
public void setSdkAppId(long sdkAppId) {
this.sdkAppId = sdkAppId;
}
public long getRoomId() {
return roomId;
}
public void setRoomId(long roomId) {
this.roomId = roomId;
}
public OutputParams getOutputParams() {
return outputParams;
}
public void setOutputParams(OutputParams outputParams) {
this.outputParams = outputParams;
}
public EncodeParams getEncodeParams() {
return encodeParams;
}
public void setEncodeParams(EncodeParams encodeParams) {
this.encodeParams = encodeParams;
}
public LayoutParams getLayoutParams() {
return layoutParams;
}
public void setLayoutParams(LayoutParams layoutParams) {
this.layoutParams = layoutParams;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/request/ZegoMixRequest.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/request/ZegoMixRequest.java | package cn.bixin.sona.server.room.domain.request;
import java.util.List;
import java.util.Map;
public class ZegoMixRequest {
private String signature;
private long timestamp = System.currentTimeMillis();
private String id_name;
private String live_channel;
private int appid;
private String output_bg_image;
private int with_sound_level;
private String output_bg_color;
private String userdata;
private int seq;
private String task_id;
private int version;
private List<MixInput> MixInput;
private List<MixOutput> MixOutput;
private Map<String, Object> extra_params;
public static class MixInput {
private String url;
private String stream_id;
private int sound_level_id;
private int content_control;
private RectInfo rect;
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public String getStream_id() {
return stream_id;
}
public void setStream_id(String stream_id) {
this.stream_id = stream_id;
}
public int getSound_level_id() {
return sound_level_id;
}
public void setSound_level_id(int sound_level_id) {
this.sound_level_id = sound_level_id;
}
public int getContent_control() {
return content_control;
}
public void setContent_control(int content_control) {
this.content_control = content_control;
}
public RectInfo getRect() {
return rect;
}
public void setRect(RectInfo rect) {
this.rect = rect;
}
}
public static class MixOutput {
private String stream_id;
private String mixurl;
private int bitrate;
private int fps;
private int height;
private int width;
private int audio_enc_id;
private int audio_bitrate;
private int audio_channel_cnt;
private int encode_mode;
private int encode_qua;
public String getStream_id() {
return stream_id;
}
public void setStream_id(String stream_id) {
this.stream_id = stream_id;
}
public String getMixurl() {
return mixurl;
}
public void setMixurl(String mixurl) {
this.mixurl = mixurl;
}
public int getBitrate() {
return bitrate;
}
public void setBitrate(int bitrate) {
this.bitrate = bitrate;
}
public int getFps() {
return fps;
}
public void setFps(int fps) {
this.fps = fps;
}
public int getHeight() {
return height;
}
public void setHeight(int height) {
this.height = height;
}
public int getWidth() {
return width;
}
public void setWidth(int width) {
this.width = width;
}
public int getAudio_enc_id() {
return audio_enc_id;
}
public void setAudio_enc_id(int audio_enc_id) {
this.audio_enc_id = audio_enc_id;
}
public int getAudio_bitrate() {
return audio_bitrate;
}
public void setAudio_bitrate(int audio_bitrate) {
this.audio_bitrate = audio_bitrate;
}
public int getAudio_channel_cnt() {
return audio_channel_cnt;
}
public void setAudio_channel_cnt(int audio_channel_cnt) {
this.audio_channel_cnt = audio_channel_cnt;
}
public int getEncode_mode() {
return encode_mode;
}
public void setEncode_mode(int encode_mode) {
this.encode_mode = encode_mode;
}
public int getEncode_qua() {
return encode_qua;
}
public void setEncode_qua(int encode_qua) {
this.encode_qua = encode_qua;
}
}
public static class RectInfo {
private int top;
private int left;
private int bottom;
private int right;
private int layer;
public int getTop() {
return top;
}
public void setTop(int top) {
this.top = top;
}
public int getLeft() {
return left;
}
public void setLeft(int left) {
this.left = left;
}
public int getBottom() {
return bottom;
}
public void setBottom(int bottom) {
this.bottom = bottom;
}
public int getRight() {
return right;
}
public void setRight(int right) {
this.right = right;
}
public int getLayer() {
return layer;
}
public void setLayer(int layer) {
this.layer = layer;
}
}
public String getSignature() {
return signature;
}
public void setSignature(String signature) {
this.signature = signature;
}
public long getTimestamp() {
return timestamp;
}
public void setTimestamp(long timestamp) {
this.timestamp = timestamp;
}
public String getId_name() {
return id_name;
}
public void setId_name(String id_name) {
this.id_name = id_name;
}
public String getLive_channel() {
return live_channel;
}
public void setLive_channel(String live_channel) {
this.live_channel = live_channel;
}
public int getAppid() {
return appid;
}
public void setAppid(int appid) {
this.appid = appid;
}
public String getOutput_bg_image() {
return output_bg_image;
}
public void setOutput_bg_image(String output_bg_image) {
this.output_bg_image = output_bg_image;
}
public int getWith_sound_level() {
return with_sound_level;
}
public void setWith_sound_level(int with_sound_level) {
this.with_sound_level = with_sound_level;
}
public String getOutput_bg_color() {
return output_bg_color;
}
public void setOutput_bg_color(String output_bg_color) {
this.output_bg_color = output_bg_color;
}
public String getUserdata() {
return userdata;
}
public void setUserdata(String userdata) {
this.userdata = userdata;
}
public int getSeq() {
return seq;
}
public void setSeq(int seq) {
this.seq = seq;
}
public String getTask_id() {
return task_id;
}
public void setTask_id(String task_id) {
this.task_id = task_id;
}
public int getVersion() {
return version;
}
public void setVersion(int version) {
this.version = version;
}
public List<MixInput> getMixInput() {
return MixInput;
}
public void setMixInput(List<MixInput> mixInput) {
MixInput = mixInput;
}
public List<MixOutput> getMixOutput() {
return MixOutput;
}
public void setMixOutput(List<MixOutput> mixOutput) {
MixOutput = mixOutput;
}
public Map<String, Object> getExtra_params() {
return extra_params;
}
public void setExtra_params(Map<String, Object> extra_params) {
this.extra_params = extra_params;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/request/ZegoStopMixRequest.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/request/ZegoStopMixRequest.java | package cn.bixin.sona.server.room.domain.request;
public class ZegoStopMixRequest {
private int appid;
private long timestamp = System.currentTimeMillis();
private String signature;
private String id_name;
private String live_channel;
private String mixurl;
private String stream_id;
private int seq;
public int getAppid() {
return appid;
}
public void setAppid(int appid) {
this.appid = appid;
}
public long getTimestamp() {
return timestamp;
}
public void setTimestamp(long timestamp) {
this.timestamp = timestamp;
}
public String getSignature() {
return signature;
}
public void setSignature(String signature) {
this.signature = signature;
}
public String getId_name() {
return id_name;
}
public void setId_name(String id_name) {
this.id_name = id_name;
}
public String getLive_channel() {
return live_channel;
}
public void setLive_channel(String live_channel) {
this.live_channel = live_channel;
}
public String getMixurl() {
return mixurl;
}
public void setMixurl(String mixurl) {
this.mixurl = mixurl;
}
public String getStream_id() {
return stream_id;
}
public void setStream_id(String stream_id) {
this.stream_id = stream_id;
}
public int getSeq() {
return seq;
}
public void setSeq(int seq) {
this.seq = seq;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/request/OperateUserRequest.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/request/OperateUserRequest.java | package cn.bixin.sona.server.room.domain.request;
import cn.bixin.sona.request.OperateRequest;
import cn.bixin.sona.server.room.domain.enums.RoomManagementEnum;
public class OperateUserRequest {
private long roomId;
private long operatorUid;
private long targetUid;
private RoomManagementEnum type;
private int operate; //1:设置 0:取消
private int minutes;
public static OperateUserRequest wrapOperationObj(OperateRequest request, RoomManagementEnum type) {
OperateUserRequest operateUserRequest = new OperateUserRequest();
operateUserRequest.setOperate(request.getOperate());
operateUserRequest.setRoomId(request.getRoomId());
operateUserRequest.setType(type);
operateUserRequest.setTargetUid(request.getTargetUid());
operateUserRequest.setOperatorUid(request.getOperatorUid());
operateUserRequest.setMinutes(request.getMinutes());
return operateUserRequest;
}
public long getRoomId() {
return roomId;
}
public void setRoomId(long roomId) {
this.roomId = roomId;
}
public long getOperatorUid() {
return operatorUid;
}
public void setOperatorUid(long operatorUid) {
this.operatorUid = operatorUid;
}
public long getTargetUid() {
return targetUid;
}
public void setTargetUid(long targetUid) {
this.targetUid = targetUid;
}
public RoomManagementEnum getType() {
return type;
}
public void setType(RoomManagementEnum type) {
this.type = type;
}
public int getOperate() {
return operate;
}
public void setOperate(int operate) {
this.operate = operate;
}
public int getMinutes() {
return minutes;
}
public void setMinutes(int minutes) {
this.minutes = minutes;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/convert/RoomDetailInfoConverter.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/convert/RoomDetailInfoConverter.java | package cn.bixin.sona.server.room.domain.convert;
import cn.bixin.sona.dto.ImConfigInfoDTO;
import cn.bixin.sona.dto.ProductConfigInfoDTO;
import cn.bixin.sona.dto.RoomDTO;
import cn.bixin.sona.dto.RoomDetailInfoDTO;
import cn.bixin.sona.dto.StreamConfigInfoDTO;
import cn.bixin.sona.server.room.domain.db.ProductConfig;
import cn.bixin.sona.server.room.domain.enums.ProductEnum;
import com.ctrip.framework.apollo.ConfigService;
public class RoomDetailInfoConverter {
public static RoomDetailInfoDTO convertDetailObj(ProductConfig config,
RoomDTO room,
StreamConfigInfoDTO streamConfigInfo) {
RoomDetailInfoDTO roomDetailInfoDTO = new RoomDetailInfoDTO();
ProductConfigInfoDTO productConfigInfoDTO = new ProductConfigInfoDTO();
fillProductConfigInfo(productConfigInfoDTO, config, streamConfigInfo);
roomDetailInfoDTO.setProductConfig(productConfigInfoDTO);
roomDetailInfoDTO.setRoomId(room.getRoomId());
roomDetailInfoDTO.setOwnerUid(room.getUid());
return roomDetailInfoDTO;
}
public static RoomDetailInfoDTO convertDetailObjGuest(ProductConfig config, RoomDTO room, StreamConfigInfoDTO streamConfigInfo, long guestUid) {
RoomDetailInfoDTO roomDetailInfoDTO = convertDetailObj(config, room, streamConfigInfo);
roomDetailInfoDTO.setGuestUid(guestUid);
roomDetailInfoDTO.setNickname("游客" + guestUid % 1000000);
return roomDetailInfoDTO;
}
private static void fillProductConfigInfo(ProductConfigInfoDTO productConfigInfoDTO,
ProductConfig config, StreamConfigInfoDTO streamConfigInfo) {
ImConfigInfoDTO imConfigInfoDTO = new ImConfigInfoDTO();
if (config != null) {
imConfigInfoDTO.setModule(config.getImModule());
imConfigInfoDTO.setImSendType(config.getImSendType());
productConfigInfoDTO.setProductCode(config.getProductCode());
ProductEnum productEnum = ProductEnum.getPlatformByName(config.getProductCode());
productConfigInfoDTO.setProductCodeAlias(productEnum != null ? productEnum.getCode() : "");
}
imConfigInfoDTO.setArrivalMessageSwitch(true);
imConfigInfoDTO.setMessageExpireTime(ConfigService.getAppConfig().getIntProperty("messageExpireTime", 40000));
imConfigInfoDTO.setClientQueueSize(ConfigService.getAppConfig().getIntProperty("clientQueueSize", 600));
productConfigInfoDTO.setImConfig(imConfigInfoDTO);
productConfigInfoDTO.setStreamConfig(streamConfigInfo);
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/convert/MixConfigConverter.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/convert/MixConfigConverter.java | package cn.bixin.sona.server.room.domain.convert;
import cn.bixin.sona.server.room.domain.db.MixConfig;
/**
* @author 木欣
* @create 2021-05-27
* @email baojiawei@bixin.cn
* create by intelliJ IDEA
*/
public class MixConfigConverter {
/**
* 创建默认视频配置
*
* @param roomId
* @param width
* @param height
* @return
*/
public static MixConfig defaultVideoMixConfig(Long roomId, String uid, Integer width, Integer height) {
MixConfig mixConfig = new MixConfig();
mixConfig.setRoomId(roomId);
mixConfig.setUid(uid);
mixConfig.setWidth(width);
mixConfig.setHeight(height);
mixConfig.setTops(0);
mixConfig.setBottom(height);
mixConfig.setLefts(0);
mixConfig.setRights(width);
mixConfig.setBitrate(1200000);
mixConfig.setFps(15);
mixConfig.setStatus(1);
return mixConfig;
}
/**
* 创建默认音频设置
*
* @param roomId
* @param uid
* @return
*/
public static MixConfig defaultAudioMixConfig(Long roomId, String uid) {
MixConfig mixConfig = new MixConfig();
mixConfig.setRoomId(roomId);
mixConfig.setUid(uid);
mixConfig.setWidth(16);
mixConfig.setHeight(16);
mixConfig.setTops(0);
mixConfig.setBottom(16);
mixConfig.setLefts(0);
mixConfig.setRights(16);
mixConfig.setBitrate(1);
mixConfig.setFps(15);
mixConfig.setStatus(2);
return mixConfig;
}
/**
* 在视频混流状态
*
* @param mixConfig
* @return
*/
public static boolean inMVStatus(MixConfig mixConfig) {
return 1 == mixConfig.getStatus();
}
/**
* 在音频混流状态
*
* @param mixConfig
* @return
*/
public static boolean inAudioStatus(MixConfig mixConfig) {
return 2 == mixConfig.getStatus();
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/convert/RoomDTOConverter.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/convert/RoomDTOConverter.java | package cn.bixin.sona.server.room.domain.convert;
import cn.bixin.sona.dto.RoomDTO;
import cn.bixin.sona.server.room.domain.db.Room;
import com.alibaba.fastjson.JSON;
import java.util.Map;
public class RoomDTOConverter {
public static RoomDTO convertDO(Room room) {
if (room == null) {
return null;
}
RoomDTO roomDTO = new RoomDTO();
roomDTO.setRoomId(room.getRoomId());
roomDTO.setName(room.getName());
roomDTO.setStatus(room.getStatus());
roomDTO.setPassword(room.getPassword());
roomDTO.setUid(room.getUid());
roomDTO.setProductCode(room.getProductCode());
roomDTO.setCreateTime(room.getCreateTime());
roomDTO.setExt(JSON.parseObject(room.getExt(), Map.class));
return roomDTO;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/convert/StreamConfigInfoConverter.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/convert/StreamConfigInfoConverter.java | package cn.bixin.sona.server.room.domain.convert;
import cn.bixin.sona.dto.StreamConfigInfoDTO;
import cn.bixin.sona.server.room.domain.db.ProductConfig;
import cn.bixin.sona.server.room.domain.stream.UserSginInputParam;
public class StreamConfigInfoConverter {
public static StreamConfigInfoDTO convertStreamConfig(ProductConfig config) {
StreamConfigInfoDTO streamConfig = new StreamConfigInfoDTO();
streamConfig.setPullMode(config.getPullMode());
streamConfig.setPushMode(config.getPushMode());
streamConfig.setSupplier(config.getStreamSupplier());
streamConfig.setType(config.getType());
streamConfig.setBitrate(config.getBitrate());
return streamConfig;
}
public static UserSginInputParam convertUserSignInputParam(ProductConfig productConfig, long uid, boolean isGuest) {
if (productConfig == null) return null;
UserSginInputParam userSginInputParam = new UserSginInputParam();
userSginInputParam.setStreamSupplier(productConfig.getStreamSupplier());
userSginInputParam.setNeedReplay(productConfig.isNeedReplay());
userSginInputParam.setGuest(isGuest);
userSginInputParam.setUid(uid);
userSginInputParam.setProductCode(productConfig.getProductCode());
return userSginInputParam;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/enums/OperateEnum.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/enums/OperateEnum.java | package cn.bixin.sona.server.room.domain.enums;
public enum OperateEnum {
SET(1, "设置"),
CANCEL(0, "取消"),
;
private int code;
private String desc;
OperateEnum(int code, String desc) {
this.code = code;
this.desc = desc;
}
public int getCode() {
return code;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/enums/PullModeEnum.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/enums/PullModeEnum.java | package cn.bixin.sona.server.room.domain.enums;
public enum PullModeEnum {
SINGLE,
MULTI,
MIXED,
;
PullModeEnum() {
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/enums/ProductEnum.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/enums/ProductEnum.java | package cn.bixin.sona.server.room.domain.enums;
import org.apache.commons.lang3.StringUtils;
import java.util.Arrays;
public enum ProductEnum {
/**
* 聊天室
*/
CHATROOM("C"),
/**
* 直播
*/
LIVING("L"),
/**
* 小游戏
*/
GAME("G");
private String code;
ProductEnum(String code) {
this.code = code;
}
public static ProductEnum getByCode(String code) {
if (StringUtils.isBlank(code)) {
return null;
}
return Arrays.stream(values()).filter(each -> each.getCode().equalsIgnoreCase(code)).findFirst().orElse(null);
}
public static ProductEnum getPlatformByName(String productCode) {
if (StringUtils.isBlank(productCode)) {
return null;
}
return Arrays.stream(values()).filter(each -> each.name().equalsIgnoreCase(productCode)).findFirst().orElse(null);
}
public String getCode() {
return code;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/enums/IMModuleEnum.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/enums/IMModuleEnum.java | package cn.bixin.sona.server.room.domain.enums;
import cn.bixin.sona.common.annotation.Description;
public enum IMModuleEnum {
@Description("聊天室")
CHATROOM,
@Description("群组")
GROUP,
;
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/enums/UserRoleEnum.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/enums/UserRoleEnum.java | package cn.bixin.sona.server.room.domain.enums;
public enum UserRoleEnum {
MEMBER(0),
ADMIN(4),
OWNER(5),
;
private int code;
UserRoleEnum(int code) {
this.code = code;
}
public int getCode() {
return code;
}
public static UserRoleEnum getRoleByCode(int code) {
for (UserRoleEnum each : UserRoleEnum.values()) {
if (each.getCode() == code) {
return each;
}
}
return null;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/enums/StreamSupplierEnum.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/enums/StreamSupplierEnum.java | package cn.bixin.sona.server.room.domain.enums;
public enum StreamSupplierEnum {
ZEGO(1, "Z"),
TENCENT(2, "T"),
;
private int code;
private String desc;
StreamSupplierEnum(int code, String desc) {
this.code = code;
this.desc = desc;
}
public int getCode() {
return code;
}
public String getDesc() {
return desc;
}
public static String getDescBySupplier(String supplier) {
for (StreamSupplierEnum each : StreamSupplierEnum.values()) {
if (each.name().equals(supplier)) {
return each.getDesc();
}
}
return "";
}
public static StreamSupplierEnum getByName(String supplier) {
for (StreamSupplierEnum each : StreamSupplierEnum.values()) {
if (each.name().equals(supplier)) {
return each;
}
}
return null;
}
public static StreamSupplierEnum getByDesc(String desc) {
for (StreamSupplierEnum each : StreamSupplierEnum.values()) {
if (each.getDesc().equals(desc)) {
return each;
}
}
return null;
}
public static StreamSupplierEnum getByCode(int code) {
for (StreamSupplierEnum each : StreamSupplierEnum.values()) {
if (each.getCode() == code) {
return each;
}
}
return null;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/enums/HermesLogTypeEnum.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/enums/HermesLogTypeEnum.java | package cn.bixin.sona.server.room.domain.enums;
public enum HermesLogTypeEnum {
ROOM_CREATE("room_create", "创建房间"),
ROOM_ENTER("room_enter", "进入房间"),
ROOM_LEAVE("room_leave", "离开房间"),
ROOM_CLOSE("room_close", "关闭房间"),
ROOM_PASSWORD("room_password", "设置密码"),
ROOM_KICK("room_kick", "房间踢人"),
GAME_START("game_start", "开始游戏"),
STREAM_PUSH("stream_push", "推流"),
STREAM_MIX("stream_mix", "混流"),
;
private String codeStr;
private String desc;
HermesLogTypeEnum(String codeStr, String desc){
this.codeStr = codeStr;
this.desc = desc;
}
public String getCodeStr() {
return codeStr;
}
public String getDesc() {
return desc;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/enums/StreamChangeEnum.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/enums/StreamChangeEnum.java | package cn.bixin.sona.server.room.domain.enums;
public enum StreamChangeEnum {
ADD(1, "新增流"),
CLOSE(2, "关闭流"),
;
private int type;
private String desc;
StreamChangeEnum(int type, String desc) {
this.type = type;
this.desc = desc;
}
public int getType() {
return type;
}
public String getDesc() {
return desc;
}
public static StreamChangeEnum getByType(int type) {
for (StreamChangeEnum each : StreamChangeEnum.values()) {
if (type == each.getType()) {
return each;
}
}
return null;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/enums/PlatformEnum.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/enums/PlatformEnum.java | package cn.bixin.sona.server.room.domain.enums;
import cn.bixin.sona.common.annotation.Description;
import org.apache.commons.lang.StringUtils;
public enum PlatformEnum {
@Description("无法识别")
UN_KNOWN(0),
@Description("android包")
ANDROID(1),
@Description("ios包")
IOS(2),
@Description("pc包")
WINDOWS(3),
@Description("微信小程序")
WECHAT_APPLET(4),
;
private int code;
PlatformEnum(int code) {
this.code = code;
}
public int getCode() {
return code;
}
public static PlatformEnum getPlatformByCode(int code) {
for (PlatformEnum platform : values()) {
if (platform.getCode() == code) {
return platform;
}
}
return PlatformEnum.UN_KNOWN;
}
public static PlatformEnum getByCode(String code) {
if (StringUtils.isBlank(code)) {
return null;
}
for (PlatformEnum each : PlatformEnum.values()) {
if (each.getCode() == Integer.valueOf(code)) {
return each;
}
}
return null;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/enums/RoomManagementEnum.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/enums/RoomManagementEnum.java | package cn.bixin.sona.server.room.domain.enums;
public enum RoomManagementEnum {
//1拉黑、2禁言、3踢出 4、管理员 5、房主 6、禁止推流
BLOCK(1),
MUTE(2),
KICK(3),
ADMIN(4),
OWNER(5),
STREAM_PUSH_FORBID(6);
private int code;
RoomManagementEnum(int code) {
this.code = code;
}
public int getCode() {
return code;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/enums/SonaMessageTypeEnum.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/enums/SonaMessageTypeEnum.java | package cn.bixin.sona.server.room.domain.enums;
/**
* @author qinwei
*/
public enum SonaMessageTypeEnum {
MSG_CREATE_ROOM("10000", "打开房间"),
MSG_CLOSE_ROOM("10001", "关闭房间"),
MSG_ENTER_ROOM("10002", "进入房间"),
MSG_LEAVE_ROOM("10003", "离开房间"),
MSG_ADMIN("10004", "管理员设置/取消"),
MSG_BLOCK("10005", "拉黑设置/取消"),
MSG_MUTE("10006", "禁言设置/取消"),
MSG_KICK("10007", "踢人"),
MSG_SWITCH_AUDIO("10008", "切换供应商"),
MSG_VOICE("10009", "静音设置/取消");
private String code;
private String desc;
SonaMessageTypeEnum(String code, String desc) {
this.code = code;
this.desc = desc;
}
public String getCode() {
return code;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/enums/RoomOperateEnum.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/enums/RoomOperateEnum.java | package cn.bixin.sona.server.room.domain.enums;
public enum RoomOperateEnum {
CREATE,
OPEN,
CLOSE,
UPDATE_PASSWORD
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/enums/TransactionTypeEnum.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/domain/enums/TransactionTypeEnum.java | package cn.bixin.sona.server.room.domain.enums;
public enum TransactionTypeEnum {
/**
* 创建房间
*/
TR_ROOM_CREATE("TR_ROOM_CREATE", "创建房间"),
/**
* 打开房间
*/
TR_ROOM_OPEN("TR_ROOM_OPEN", "打开房间"),
/**
* 进入房间
*/
TR_ROOM_ENTER("TR_ROOM_ENTER", "进入房间"),
/**
* 关闭房间
*/
TR_ROOM_CLOSE("TR_ROOM_CLOSE", "关闭房间"),
/**
* 离开房间
*/
TR_ROOM_LEAVE("TR_ROOM_LEAVE", "离开房间"),
/**
* 创建群组
*/
TR_GROUP_CREATE("TR_GROUP_CREATE", "创建群组"),
/**
* 打开群组
*/
TR_GROUP_OPEN("TR_GROUP_OPEN", "打开群组"),
/**
* 进入群组
*/
TR_GROUP_ENTER("TR_GROUP_ENTER", "进入群组"),
/**
* 关闭群组
*/
TR_GROUP_CLOSE("TR_GROUP_CLOSE", "关闭群组"),
/**
* 离开群组
*/
TR_GROUP_LEAVE("TR_GROUP_LEAVE", "离开群组"),
/**
* 修改聊天室状态
*/
TR_ROOM_STATUS("TR_ROOM_STATUS", "修改聊天室状态"),
/**
* 修改群组状态
*/
TR_GROUP_STATUS("TR_GROUP_STATUS", "修改群组状态"),
/**
* 获取房间列表
*/
TR_ROOM_ONLINE_USER("TR_ROOM_ONLINE_USER", "获取房间列表"),
/**
* 获取聊天室信息
*/
TR_ROOM_DETAIL("TR_ROOM_DETAIL", "获取聊天室信息"),
/**
* 聊天室踢人
*/
TR_ROOM_KICK_OUT("TR_ROOM_KICK_OUT", "聊天室踢人"),
/**
* 设置用户角色
*/
TR_SET_USER_ROLE("TR_SET_USER_ROLE", "设置用户角色"),
/**
* 增加群组成员
*/
TR_GROUP_ADD("TR_GROUP_ADD", "增加群组成员"),
/**
* 群组踢人
*/
TR_GROUP_KICK_OUT("TR_GROUP_KICK_OUT", "群组踢人"),
/**
* 移除群组
*/
TR_GROUP_REMOVE("TR_GROUP_REMOVE", "移除群组"),
/**
* 设置群组管理员
*/
TR_GROUP_SET_ADMIN("TR_GROUP_SET_ADMIN", "设置群组管理员"),
/**
* 移除群组管理员
*/
TR_GROUP_REMOVE_ADMIN("TR_GROUP_REMOVE_ADMIN", "移除群组管理员"),
/**
* 房间明细信息
*/
YX_ROOM_DETAIL("YX_ROOM_DETAIL", "房间明细信息"),
/**
* 长连进入房间
*/
MERCURY_ENTER_ROOM_NEW("MERCURY_ENTER_ROOM_NEW", "新版长连进入房间"),
/**
* 长连离开房间
*/
MERCURY_LEAVE_ROOM_NEW("MERCURY_LEAVE_ROOM_NEW", "新版长连离开房间"),
/**
* 异步创建聊天室失败
*/
ASYNC_CREATE_CHATROOM_ERROR("ASYNC_CREATE_CHATROOM_ERROR", "异步创建聊天室失败"),
/**
* 异步创建群组失败
*/
ASYNC_CREATE_GROUP_ERROR("ASYNC_CREATE_GROUP_ERROR", "异步创建群组失败"),
/**
* 异步打开聊天室失败
*/
ASYNC_OPEN_CHATROOM_ERROR("ASYNC_OPEN_CHATROOM_ERROR", "异步打开聊天室失败"),
/**
* 异步关闭聊天室失败
*/
ASYNC_CLOSE_CHATROOM_ERROR("ASYNC_CLOSE_CHATROOM_ERROR", "异步关闭聊天室失败"),
/**
* 异步关闭群组失败
*/
ASYNC_CLOSE_GROUP_ERROR("ASYNC_CLOSE_GROUP_ERROR", "异步关闭群组失败"),
/**
* 异步进入群组失败
*/
ASYNC_ENTER_GROUP_ERROR("ASYNC_ENTER_GROUP_ERROR", "异步进入群组失败"),
/**
* 异步离开群组失败
*/
ASYNC_LEAVE_GROUP_ERROR("ASYNC_LEAVE_GROUP_ERROR", "异步离开群组失败")
;
private final String code;
private final String desc;
TransactionTypeEnum(String code, String desc) {
this.code = code;
this.desc = desc;
}
public String getCode() {
return code;
}
public String getDesc() {
return desc;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/utils/TLSSigAPIv2.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/utils/TLSSigAPIv2.java | package cn.bixin.sona.server.room.utils;
// 使用旧版本 base64 编解码实现增强兼容性
import com.alibaba.fastjson.JSONObject;
import sun.misc.BASE64Encoder;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.zip.Deflater;
public class TLSSigAPIv2 {
private long sdkappid;
private String key;
public TLSSigAPIv2(long sdkappid, String key) {
this.sdkappid = sdkappid;
this.key = key;
}
private String hmacsha256(String identifier, long currTime, long expire, String base64Userbuf) {
String contentToBeSigned = "TLS.identifier:" + identifier + "\n"
+ "TLS.sdkappid:" + sdkappid + "\n"
+ "TLS.time:" + currTime + "\n"
+ "TLS.expire:" + expire + "\n";
if (null != base64Userbuf) {
contentToBeSigned += "TLS.userbuf:" + base64Userbuf + "\n";
}
try {
byte[] byteKey = key.getBytes("UTF-8");
Mac hmac = Mac.getInstance("HmacSHA256");
SecretKeySpec keySpec = new SecretKeySpec(byteKey, "HmacSHA256");
hmac.init(keySpec);
byte[] byteSig = hmac.doFinal(contentToBeSigned.getBytes("UTF-8"));
return (new BASE64Encoder().encode(byteSig)).replaceAll("\\s*", "");
} catch (UnsupportedEncodingException e) {
return "";
} catch (NoSuchAlgorithmException e) {
return "";
} catch (InvalidKeyException e) {
return "";
}
}
private String genSig(String identifier, long expire, byte[] userbuf) {
try {
long currTime = System.currentTimeMillis()/1000;
JSONObject sigDoc = new JSONObject();
sigDoc.put("TLS.ver", "2.0");
sigDoc.put("TLS.identifier", identifier);
sigDoc.put("TLS.sdkappid", sdkappid);
sigDoc.put("TLS.expire", expire);
sigDoc.put("TLS.time", currTime);
String base64UserBuf = null;
if (null != userbuf) {
base64UserBuf = new BASE64Encoder().encode(userbuf);
sigDoc.put("TLS.userbuf", base64UserBuf);
}
String sig = hmacsha256(identifier, currTime, expire, base64UserBuf);
if (sig.length() == 0) {
return "";
}
sigDoc.put("TLS.sig", sig);
Deflater compressor = new Deflater();
compressor.setInput(sigDoc.toString().getBytes(Charset.forName("UTF-8")));
compressor.finish();
byte [] compressedBytes = new byte[2048];
int compressedBytesLength = compressor.deflate(compressedBytes);
compressor.end();
return (new String(Base64URL.base64EncodeUrl(Arrays.copyOfRange(compressedBytes,
0, compressedBytesLength)))).replaceAll("\\s*", "");
} catch (Exception e) {
return "";
}
}
public String genSig(String identifier, long expire) {
return genSig(identifier, expire, null);
}
public String genSigWithUserBuf(String identifier, long expire, byte[] userbuf) {
return genSig(identifier, expire, userbuf);
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/utils/Base64URL.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/utils/Base64URL.java | package cn.bixin.sona.server.room.utils;
// 使用旧版本 base64 编解码实现增强兼容性
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
import java.io.IOException;
public class Base64URL {
public static byte[] base64EncodeUrl(byte[] input) {
byte[] base64 = new BASE64Encoder().encode(input).getBytes();
for (int i = 0; i < base64.length; ++i)
switch (base64[i]) {
case '+':
base64[i] = '*';
break;
case '/':
base64[i] = '-';
break;
case '=':
base64[i] = '_';
break;
default:
break;
}
return base64;
}
public static byte[] base64DecodeUrl(byte[] input) throws IOException {
byte[] base64 = input.clone();
for (int i = 0; i < base64.length; ++i)
switch (base64[i]) {
case '*':
base64[i] = '+';
break;
case '-':
base64[i] = '/';
break;
case '_':
base64[i] = '=';
break;
default:
break;
}
return new BASE64Decoder().decodeBuffer(base64.toString());
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/utils/StreamUtil.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/utils/StreamUtil.java | package cn.bixin.sona.server.room.utils;
import cn.bixin.sona.enums.RoomMixedEnum;
import cn.bixin.sona.server.room.domain.db.ProductConfig;
import cn.bixin.sona.server.room.domain.db.RoomConfig;
import java.util.Objects;
import static cn.bixin.sona.enums.RoomMixedEnum.MIXED_TECENT_MIXED;
import static cn.bixin.sona.enums.RoomMixedEnum.MIXED_ZEGO_MIXED;
public class StreamUtil {
public static boolean isRoomStreamEqual(RoomConfig productConfig, RoomMixedEnum mix) {
return mix.getPullMode().equals(productConfig.getPullMode()) &&
mix.getPushMode().equals(mix.getPushMode()) && mix.getSupplier().equals(productConfig.getStreamSupplier());
}
public static boolean isProductStreamEqual(ProductConfig productConfig, RoomMixedEnum mix) {
return mix.getPullMode().equals(productConfig.getPullMode()) &&
mix.getPushMode().equals(mix.getPushMode()) && mix.getSupplier().equals(productConfig.getStreamSupplier());
}
/**
* 若是腾讯异常，则切换ZEGO混流
* 若是即构异常，则切换腾讯混流
*
* @param errorCloudProvider
* @param event
* @return
*/
public static RoomMixedEnum getStreamScheme(String errorCloudProvider,
String event) {
if ("TENCENT".equalsIgnoreCase(errorCloudProvider)) {
return MIXED_ZEGO_MIXED;
} else {
return MIXED_TECENT_MIXED;
}
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/utils/ZegoUtils.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/utils/ZegoUtils.java | package cn.bixin.sona.server.room.utils;
import com.alibaba.fastjson.JSONObject;
import org.apache.commons.codec.binary.Hex;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Base64;
import java.util.UUID;
public class ZegoUtils {
/**
* 拉流端获取登录token
*
* @param appId 即构分配的appId
* @param appSign 即构分配的appSign
* @param idName //这里的idname需要和小程序sdk前端传入的idname一致，
* //否则校验失败(因为这里的idname是为了校验和前端传进来的idname是否一致)。
* @return
*/
public static String getZeGouToken(String appId, String appSign, String idName) {
try {
String nonce = UUID.randomUUID().toString().replaceAll("-", "");
long time = System.currentTimeMillis() / 1000 + 30 * 60;
String appSign32 = appSign.replace("0x", "").replace(",", "").substring(0, 32);
if (appSign32.length() < 32) {
return null;
}
String source = md5(appId + appSign32 + idName + nonce + time);
JSONObject json = new JSONObject();
json.put("ver", 1);
json.put("hash", source);
json.put("nonce", nonce);
json.put("expired", time);
Base64.Encoder encoder = Base64.getEncoder();
return encoder.encodeToString(json.toString().getBytes());
} catch (Exception e) {
}
return null;
}
public static String md5(String str) {
MessageDigest md;
try {
md = MessageDigest.getInstance("MD5");
} catch (NoSuchAlgorithmException var3) {
return null;
}
byte[] md5Bytes = md.digest(str.getBytes());
return Hex.encodeHexString(md5Bytes);
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/config/RoomAsyncConfig.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/config/RoomAsyncConfig.java | package cn.bixin.sona.server.room.config;
import com.alibaba.ttl.threadpool.TtlExecutors;
import io.netty.util.HashedWheelTimer;
import io.netty.util.Timer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
@Configuration
@EnableAsync
public class RoomAsyncConfig {
@Bean
public Executor mixStreamExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(20);
executor.setMaxPoolSize(50);
executor.setQueueCapacity(100);
executor.setKeepAliveSeconds(10);
executor.setThreadNamePrefix("mix-stream-executor");
// 线程池对拒绝任务的处理策略
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
// 初始化
executor.initialize();
return TtlExecutors.getTtlExecutor(executor);
}
@Bean
public Executor sonaExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(20);
executor.setMaxPoolSize(100);
executor.setQueueCapacity(200);
executor.setKeepAliveSeconds(10);
executor.setThreadNamePrefix("sona-executor");
// 线程池对拒绝任务的处理策略
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
// 初始化
executor.initialize();
return TtlExecutors.getTtlExecutor(executor);
}
public static final Timer MIX_STREAM_TIMER = new HashedWheelTimer(100, TimeUnit.MILLISECONDS, 100);
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/config/AppConfig.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/config/AppConfig.java | package cn.bixin.sona.server.room.config;
import okhttp3.OkHttpClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import java.util.concurrent.TimeUnit;
@Configuration
@EnableAsync
public class AppConfig {
@Bean
public OkHttpClient okHttpClient() {
OkHttpClient okHttpClient = new OkHttpClient();
okHttpClient.dispatcher().setMaxRequestsPerHost(64);
return okHttpClient;
}
@Bean("mixHttpClient")
public OkHttpClient mixHttpClient() {
return new OkHttpClient.Builder()
.readTimeout(5, TimeUnit.SECONDS)
.writeTimeout(500, TimeUnit.MILLISECONDS)
.connectTimeout(500, TimeUnit.MILLISECONDS).build();
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/client/MixStreamClient.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/client/MixStreamClient.java | package cn.bixin.sona.server.room.client;
import okhttp3.*;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.io.IOException;
import java.net.SocketTimeoutException;
import static com.google.common.net.HttpHeaders.CONTENT_TYPE;
@Component
public class MixStreamClient {
private static final Logger log = LoggerFactory.getLogger(MixStreamClient.class);
@Resource(name = "mixHttpClient")
private OkHttpClient okHttpClient;
public String sendPost(String url, String param) {
MediaType mediaType = MediaType.parse("application/json; charset=utf-8");
RequestBody requestBody = RequestBody.create(mediaType, param);
Request request = new Request.Builder().url(url).addHeader(CONTENT_TYPE, "application/json").post(requestBody).build();
try {
Response response = okHttpClient.newCall(request).execute();
if (response.body() != null) {
return response.body().string();
}
} catch (SocketTimeoutException e) {
log.error("zego.sendPost SocketTimeoutException", e);
return "{code:-889}";
} catch (IOException e) {
log.error("zego.sendPost exception", e);
}
return StringUtils.EMPTY;
}
public String sendGet(String url, String param) {
Request request = new Request.Builder().url(url + '?' + param).build();
try {
Response response = okHttpClient.newCall(request).execute();
if (response.body() != null) {
return response.body().string();
}
} catch (IOException e) {
log.error("zego.sendGet exception", e);
}
return null;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/mapper/RoomManagementLogMapper.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/mapper/RoomManagementLogMapper.java | package cn.bixin.sona.server.room.mapper;
import cn.bixin.sona.server.room.domain.db.RoomManagementLog;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface RoomManagementLogMapper {
int insertSelective(RoomManagementLog record);
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/mapper/MixStreamReplayMapper.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/mapper/MixStreamReplayMapper.java | package cn.bixin.sona.server.room.mapper;
import java.util.Date;
import java.util.List;
import cn.bixin.sona.server.room.domain.db.MixStreamReplay;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
@Mapper
public interface MixStreamReplayMapper {
/**
* 添加记录
* @param record
* @return
*/
int insert(MixStreamReplay record);
/**
* 分页查询房间混流录制
* @param bizRoomId
* @param beginTime
* @param endTime
* @param start
* @param limit
* @return
*/
List<MixStreamReplay> findMixStreamReplayByRoomId(@Param("bizRoomId") String bizRoomId,
@Param("beginTime") Date beginTime, @Param("endTime") Date endTime, @Param("start") int start,
@Param("limit") int limit);
/**
* 查询总数量
* @param bizRoomId
* @param beginTime
* @param endTime
* @return
*/
long findCountMixStreamReplayByRoomId(@Param("bizRoomId") String bizRoomId, @Param("beginTime") Date beginTime,
@Param("endTime") Date endTime);
} | java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/mapper/MixConfigMapper.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/mapper/MixConfigMapper.java | package cn.bixin.sona.server.room.mapper;
import cn.bixin.sona.server.room.domain.db.MixConfig;
import org.apache.ibatis.annotations.Mapper;
/**
* 混流配置
*
* @author 木欣
* @create 2021-05-27
* @email baojiawei@bixin.cn
* create by intelliJ IDEA
*/
@Mapper
public interface MixConfigMapper {
/**
* 插入/更新配置
*
* @param config
* @return
*/
int insertOrUpdate(MixConfig config);
/**
* 更新配置
*
* @param mixConfig
* @return
*/
int updateMixConfig(MixConfig mixConfig);
/**
* 通过房间ID获取混流配置
*
* @param roomId
* @return
*/
MixConfig getMixConfigByRoomId(Long roomId);
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/mapper/MixStreamMapper.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/mapper/MixStreamMapper.java | package cn.bixin.sona.server.room.mapper;
import java.util.Date;
import cn.bixin.sona.server.room.domain.db.MixStream;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
@Mapper
public interface MixStreamMapper {
int deleteByPrimaryKey(Long id);
int insert(MixStream record);
int insertSelective(MixStream record);
MixStream selectByPrimaryKey(Long id);
int updateByPrimaryKeySelective(MixStream record);
int updateByPrimaryKey(MixStream record);
int stopMixStream(@Param("streamId") String streamId, @Param("source") int source, @Param("endTime") Date endTime);
/**
* 通过streamId 查询 最新一条记录
* @param streamId
* @param source
* @return
*/
MixStream findLatestByStreamId(@Param("streamId") String streamId, @Param("source") int source);
} | java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/mapper/RoomMapper.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/mapper/RoomMapper.java | package cn.bixin.sona.server.room.mapper;
import cn.bixin.sona.server.room.domain.db.Room;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
@Mapper
public interface RoomMapper {
int insertSelective(Room record);
/**
* 打开房间
*
* @param roomId: roomId
*/
void openRoom(@Param("roomId") long roomId);
/**
* 关闭
*
* @param roomId: roomId
*/
int closeRoom(@Param("roomId") long roomId);
/**
* 根据roomId查找聊天室信息
*
* @param roomId: 房间id
*
* @return chatroom info
*/
Room getRoomByRoomId(@Param("roomId") long roomId);
/**
* 更新密码
*
* @param roomId: 房间id(主键)
* @param password: new password
*/
int updatePassword(@Param("roomId") Long roomId, @Param("password") String password);
/**
* 根据roomId查找聊天室信息
*
* @param roomIds: 房间id
*
* @return chatroom info
*/
List<Room> getRoomsByRoomIds(@Param("roomIds") List<Long> roomIds);
/**
* 分页查询在线房间
* @param anchor: roomId
* @param limit
* @return
*/
List<Room> selectOnlineRoomList(@Param("anchor") String anchor, @Param("limit") int limit);
/**
* 获取在线房间数量
* @return
*/
int countOnlineRoomList();
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/mapper/StreamMapper.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/mapper/StreamMapper.java | package cn.bixin.sona.server.room.mapper;
import cn.bixin.sona.server.room.domain.db.Stream;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.Date;
import java.util.List;
@Mapper
public interface StreamMapper {
void initStream(@Param("streamId") String streamId, @Param("roomId") long roomId,
@Param("uid") long uid, @Param("productCode") String productCode,
@Param("source") int source);
Stream selectByStreamId(@Param("streamId") String streamId);
void addStream(Stream stream);
List<Stream> selectLivingStreamByRoomIdAndUids(@Param("roomId") long roomId, @Param("uids") List<Long> uids);
List<Stream> getRoomLivingSteamList(@Param("roomId") long roomId);
void updateCreateStream(@Param("streamId") String streamId, @Param("rtmpUrls") String rtmpUrls,
@Param("hlsUrls") String hlsUrls, @Param("hdlUrls") String hdlUrls, @Param("picUrls") String picUrls);
void openStream(@Param("streamId") String streamId);
void closeStream(@Param("streamId") String streamId, @Param("closeType") int closeType,
@Param("errMsg") String errMsg);
void closeStreams(@Param("streamIds") List<String> streamIds);
void handleReplay(@Param("streamId") String streamId, @Param("replayUrl") String replayUrl,
@Param("beginTime") Date beginTime, @Param("endTime") Date endTime);
void insert(Stream stream);
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/mapper/ProductConfigMapper.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/mapper/ProductConfigMapper.java | package cn.bixin.sona.server.room.mapper;
import cn.bixin.sona.server.room.domain.db.ProductConfig;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
@Mapper
public interface ProductConfigMapper {
ProductConfig findByProductCode(@Param("productCode") String productCode);
ProductConfig findByShortCode(@Param("shortCode") String shortCode);
int insertSelective(ProductConfig record);
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/mapper/RoomGroupMemberMapper.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/mapper/RoomGroupMemberMapper.java | package cn.bixin.sona.server.room.mapper;
import cn.bixin.sona.server.room.domain.db.GroupMember;
import cn.bixin.sona.server.room.domain.db.GroupUserCount;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
@Mapper
public interface RoomGroupMemberMapper {
int insertSelective(GroupMember groupMember);
GroupMember selectByRoomIdAndUid(@Param("roomId") long roomId, @Param("uid") long uid);
int updateStatusLeave(@Param("roomId") long roomId, @Param("uid") long uid);
/**
* 解散房间成员
*
* @param roomId 房间
* @return row
*/
int disbandMember(@Param("roomId") long roomId);
/**
* 获取群组成员人数
*
* @param roomId: roomId
* @return member count
*/
int selectGroupMemberCountByRoomId(@Param("roomId") long roomId);
// List<GroupMember> selectGroupMemberByRoomIds(@Param("roomIds") List<Long> roomIds);
List<GroupUserCount> selectGroupUserCountByRoomIds(@Param("roomIds") List<Long> roomIds);
List<GroupMember> selectGroupMemberListByRoomId(@Param("roomId") long roomId,
@Param("anchor") long anchor,
@Param("limit") int limit);
List<GroupMember> selectByRoomIdAndUids(@Param("roomId") long roomId, @Param("uids") List<Long> uids);
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/mapper/RoomConfigMapper.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/mapper/RoomConfigMapper.java | package cn.bixin.sona.server.room.mapper;
import cn.bixin.sona.server.room.domain.db.RoomConfig;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
@Mapper
public interface RoomConfigMapper {
RoomConfig findRoomConfig(@Param("roomId") long roomId);
List<RoomConfig> findRoomConfigBatch(@Param("roomIds") List<Long> roomIds);
int insertSelective(RoomConfig roomConfig);
int updateStreamConfigAudios(List<RoomConfig> config);
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/mapper/RoomOperateLogMapper.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/mapper/RoomOperateLogMapper.java | package cn.bixin.sona.server.room.mapper;
import cn.bixin.sona.server.room.domain.db.RoomOperateLog;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface RoomOperateLogMapper {
int insertSelective(RoomOperateLog record);
} | java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/mapper/RoomManagementInfoMapper.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/mapper/RoomManagementInfoMapper.java | package cn.bixin.sona.server.room.mapper;
import cn.bixin.sona.server.room.domain.db.RoomManagementInfo;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
@Mapper
public interface RoomManagementInfoMapper {
int insertSelective(RoomManagementInfo record);
/**
* 使某个类型失效(单个用户)
*
* @param roomId: 房间Id
* @param targetUid: 目标uid
* @param type: 类型
*/
int invalid(@Param("roomId") long roomId, @Param("targetUid") String targetUid, @Param("type") int type);
/**
* 使某个类型失效(所有用户)
*
* @param roomId: 房间Id
* @param type: 类型
*/
int invalidType(@Param("roomId") long roomId, @Param("type") int type);
/**
* 使某个类型生效
*
* @param roomId: 房间Id
* @param targetUid: 目标uid
* @param type: 类型
*/
int valid(@Param("roomId") long roomId, @Param("targetUid") String targetUid, @Param("type") int type);
/**
* 查询用户是否是管理员或者房主
*
* @param roomId: 房间Id
* @param uid: 目标uid
*/
Long isUserAdminOrOwner(@Param("roomId") long roomId, @Param("uid") String uid);
/**
* 查询用户管理信息
*
* @param roomId: roomId
* @param uid: uid
* @return management info
*/
List<RoomManagementInfo> getUserAllValidManagementInfo(@Param("roomId") long roomId, @Param("uid") String uid);
/**
* 批量查询用户管理信息
*
* @param roomId: roomId
* @param uids: uids
* @return management info list
*/
List<RoomManagementInfo> getUserManagementInfoBatch(@Param("roomId") long roomId, @Param("uidList") List<String> uids);
/**
* 根据用户type查询用户管理信息
*
* @param roomId: roomId
* @param uid: uid
* @param type:
*
* @return management info list
*/
RoomManagementInfo getUserManagementInfoByType(@Param("roomId") long roomId, @Param("uid") String uid, @Param("type") int type);
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/listener/SonaSessionListener.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/listener/SonaSessionListener.java | package cn.bixin.sona.server.room.listener;
import cn.bixin.sona.dto.RoomDTO;
import cn.bixin.sona.server.mq.RocketSender;
import cn.bixin.sona.server.room.domain.db.ProductConfig;
import cn.bixin.sona.server.room.domain.enums.IMModuleEnum;
import cn.bixin.sona.server.room.service.ProductConfigService;
import cn.bixin.sona.server.room.service.RoomService;
import cn.bixin.sona.server.room.service.redis.ChatroomRedisRepo;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.dianping.cat.Cat;
import com.dianping.cat.message.Transaction;
import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.spring.annotation.ConsumeMode;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils;
import javax.annotation.Resource;
import java.nio.charset.StandardCharsets;
/**
* @author qinwei
*/
@Component
@RocketMQMessageListener(topic = "TOPIC_CHATROOM_SESSION_SONA", consumerGroup = "CHATROOM_SESSION-SONA_GROUP", consumeMode = ConsumeMode.ORDERLY)
public class SonaSessionListener implements RocketMQListener<MessageExt> {
private static final Logger log = LoggerFactory.getLogger(SonaSessionListener.class);
@Resource
private ProductConfigService productConfigService;
@Resource
private RoomService roomService;
@Resource
private ChatroomRedisRepo chatroomRedisRepo;
@Resource
private RocketSender rocketSender;
@Override
public void onMessage(MessageExt messageExt) {
Cat.logBatchEvent("RocketMQListener", getClass().getSimpleName(), 1, 0);
if (ObjectUtils.isEmpty(messageExt.getBody())) {
log.warn("SonaSessionListener.onMessage, msg empty, msg={}", JSON.toJSONString(messageExt));
return;
}
String body = new String(messageExt.getBody(), StandardCharsets.UTF_8);
log.info("SonaSessionListener.onMessage， body={}, msgId={}", body, messageExt.getMsgId());
JSONObject json = JSON.parseObject(body);
Long roomId = json.getLong("room");
Transaction t = Cat.newTransaction("MQListener.SonaSession", String.valueOf(roomId));
try {
RoomDTO roomDTO = roomService.getRoomByRoomId(roomId);
if (roomDTO == null) {
log.error("SonaSessionListener, the room not exist, roomId={}", roomId);
return;
}
ProductConfig productConfig = productConfigService.getConfigInfoByCode(roomDTO.getProductCode());
if (!IMModuleEnum.CHATROOM.name().equals(productConfig.getImModule())) {
log.warn("SonaSessionListener roomId is belong group. roomId= {}", roomId);
return;
}
String uid = json.getString("uid");
if (json.getIntValue("cmd") == 10) {
handEnter(roomId, uid);
} else {
// 业务正常离开,直接退出房间，否则延迟检测
if (json.getIntValue("reason") == 1) {
chatroomRedisRepo.leaveChatroom(roomId, Long.parseLong(uid));
} else {
rocketSender.sendDelay("TOPIC_SONA_MERCURY_OFFLINE", body, 2);
}
}
} catch (Exception e) {
t.setStatus(e);
log.error("SonaSessionListener.onMessage fail, msg: {}", body, e);
} finally {
t.complete();
}
}
private void handEnter(Long roomId, String uid) {
//踢出房间校验
if (chatroomRedisRepo.hasKickOut(roomId, uid)) {
log.warn("SonaSessionListener, the user has been kicked out from room , uid={}, roomId={}", uid, roomId);
return;
}
//是否已经存在
if (chatroomRedisRepo.userExistInOnlineList(roomId, uid)) {
log.info("SonaSessionListener, the user has been enter room uid={}, roomId={}", uid, roomId);
return;
}
int score = StringUtils.hasText(chatroomRedisRepo.getChatroomVipUser(roomId, uid)) ? 100 : 1;
chatroomRedisRepo.enterChatroom(roomId, uid, score);
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/listener/SonaMercuryOfflineListener.java | sona-service/sona-core/src/main/java/cn/bixin/sona/server/room/listener/SonaMercuryOfflineListener.java | package cn.bixin.sona.server.room.listener;
import cn.bixin.sona.common.dto.Response;
import cn.bixin.sona.server.mq.RocketSender;
import cn.bixin.sona.server.room.service.redis.ChatroomRedisRepo;
import cn.bixin.sona.session.api.UserSessionRemoteService;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.dianping.cat.Cat;
import com.dianping.cat.message.Transaction;
import org.apache.dubbo.config.annotation.DubboReference;
import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.util.ObjectUtils;
import javax.annotation.Resource;
import java.nio.charset.StandardCharsets;
import java.util.List;
/**
* @author qinwei
*/
@Component
@RocketMQMessageListener(topic = "TOPIC_SONA_MERCURY_OFFLINE", consumerGroup = "SONA_MERCURY_OFFLINE-SONA_GROUP")
public class SonaMercuryOfflineListener implements RocketMQListener<MessageExt> {
private static final Logger log = LoggerFactory.getLogger(SonaMercuryOfflineListener.class);
@Resource
private ChatroomRedisRepo chatroomRedisRepo;
@Resource
private RocketSender rocketSender;
@DubboReference
private UserSessionRemoteService userSessionRemoteService;
@Override
public void onMessage(MessageExt messageExt) {
Cat.logBatchEvent("RocketMQListener", getClass().getSimpleName(), 1, 0);
if (ObjectUtils.isEmpty(messageExt.getBody())) {
log.warn("SonaMercuryOfflineListener.onMessage, msg empty, msg={}", JSON.toJSONString(messageExt));
return;
}
String body = new String(messageExt.getBody(), StandardCharsets.UTF_8);
log.info("SonaMercuryOfflineListener.onMessage， body={}, msgId={}", body, messageExt.getMsgId());
JSONObject json = JSON.parseObject(body);
Long roomId = json.getLong("room");
Long uid = json.getLong("uid");
Transaction t = Cat.newTransaction("MQListener.MercuryOffline", String.valueOf(roomId));
t.addData("u", uid);
try {
Response<List<String>> response = userSessionRemoteService.getChatRoomOnlineState(uid);
if (!response.isSuccess()) {
log.error("SonaMercuryOfflineListener, getChatRoomOnlineState failed ! uid= {}", uid);
rocketSender.sendDelay("TOPIC_SONA_MERCURY_OFFLINE", body, 1);
return;
}
if (response.getResult().contains(String.valueOf(roomId))) {
log.info("SonaMercuryOfflineListener, user reconnect. uid= {}", uid);
return;
}
chatroomRedisRepo.leaveChatroom(roomId, uid);
} catch (Exception e) {
t.setStatus(e);
log.error("SonaMercuryOfflineListener.onMessage fail, msg: {}", body, e);
} finally {
t.complete();
}
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.