/// <summary>
/// Join group after connected to the server. Make sure the server enable group feature before call this method.
/// </summary>
/// <param name="groupArray">The group array that the client to join.</param>
public void JoinGroup(params string[] groupArray)
{
if (_clientStatus != ClientStatus.Connected)
{
throw new Exception(Constants.ExMessageClientNotConnected);
}
byte[] joinGroupMessage = JoinGroupMessage.MakeMessage(groupArray);
SendMessageAsync(joinGroupMessage, null, null);
_groupArray = groupArray;
}
public static bool TryParse(ArraySegment <byte> messageRawData, out JoinGroupMessage outMessage)
{
//| mark(4bytes) | group names |
try
{
if (messageRawData.Count <= 4)
{
outMessage = null;
return(false);
}
UInt32 joinGroupMark = BitConverter.ToUInt32(messageRawData.Array, messageRawData.Offset);
string groupNameDes = Encoding.UTF8.GetString(messageRawData.Array, messageRawData.Offset + 4, messageRawData.Count - 4);
if (string.IsNullOrWhiteSpace(groupNameDes))
{
outMessage = null;
return(false);
}
string[] groupArray = groupNameDes.Split('|');
IEnumerable <string> groupList = groupArray.Where(p => p.Trim() != "");
if (!groupList.Any())
{
outMessage = null;
return(false);
}
JoinGroupMessage joinGroupMsg = new JoinGroupMessage()
{
JoinGroupMark = joinGroupMark,
GroupSet = new HashSet <string>(groupList)
};
outMessage = joinGroupMsg;
return(true);
}
catch
{
outMessage = null;
return(false);
}
}
protected override void OnRawMessageReceived(TcpRawMessageReceivedEventArgs args)
{
if (args.Error == null)
{
ArraySegment <byte> rawSegment = args.Message.MessageRawData;
if (rawSegment.Count >= 4)
{
UInt32 specialMark = BitConverter.ToUInt32(rawSegment.Array, rawSegment.Offset);
if (specialMark == TcpUtility.JOIN_GROUP_MARK)
{
if (!EnableGroup)
{
return;
}
JoinGroupMessage joinGroupMsg = null;
if (!JoinGroupMessage.TryParse(rawSegment, out joinGroupMsg))
{
return;
}
if (_clients.TryGetValue(args.Message.ClientID, out ClientContext clientContext))
{
clientContext.Groups = joinGroupMsg.GroupSet;
AddClientToGroup(clientContext);
}
return;
}
else if (specialMark == TcpUtility.GROUP_TRANSMIT_MSG_MARK ||
specialMark == TcpUtility.GROUP_TRANSMIT_MSG_LOOP_BACK_MARK)
{
bool loopBack = specialMark == TcpUtility.GROUP_TRANSMIT_MSG_LOOP_BACK_MARK;
if (!EnableGroup)
{
return;
}
GroupTransmitMessage transPacket = null;
if (!GroupTransmitMessage.TryParse(rawSegment, out transPacket))
{
return;
}
try
{
if (!ServerConfig.AllowCrossGroupMessage)
{
ClientContext sourceClient = GetClient(args.Message.ClientID);
if (sourceClient == null || sourceClient.Groups == null || sourceClient.Groups.Count == 0)
{
return;
}
foreach (string groupName in transPacket.GroupNameCollection)
{
if (!sourceClient.Groups.Contains(groupName))
{
return;
}
}
}
SendGroupMessageAsync(transPacket.GroupNameCollection, transPacket.TransMessageData.Array, transPacket.TransMessageData.Offset, transPacket.TransMessageData.Count
, loopBack ? -1 : args.Message.ClientID);
}
catch (Exception ex)
{
_logger?.Warn("Transmit group message exception.", ex.Message);
}
return;
}
}
if (ReceivedMessageFilter(args))
{
return;
}
}
MessageReceived?.Invoke(this, args);
return;
}
