private async void ClientOnMessageReceived(object sender, MessageEventArgs messageEventArgs)
{
var message = messageEventArgs.Message;
if (message == null || message.Type != MessageType.Text)
{
return;
}
var messageInfo = message.ToChatMessage();
OnMessageReceived?.Invoke(messageInfo);
try
{
var response = _messagesProcessor.ProcessMessage(messageInfo);
if (!string.IsNullOrEmpty(response))
{
await _client.SendTextMessageAsync(message.Chat.Id, response);
}
}
catch (Exception e)
{
OnErrorOccured?.Invoke(e.Message);
}
}
public void OnMessageReceivedCallback(string userName, string msg)
{
if (OnMessageReceived != null)
{
OnMessageReceived.Invoke(userName, msg);
}
}
protected void ChatHandler(NeutronPlayer player, ChatMode packet, MatchmakingTo matchmakingTo, int viewId, string message)
{
if (OnMessageReceived.Invoke(player, message))
{
using (NeutronStream stream = Neutron.PooledNetworkStreams.Pull())
{
NeutronStream.IWriter writer = stream.Writer;
writer.WritePacket((byte)Packet.Chat);
writer.Write(message);
if (packet == ChatMode.Global)
{
player.Write(writer, TargetTo.All, matchmakingTo, Protocol.Tcp);
}
else if (packet == ChatMode.Private)
{
if (MatchmakingHelper.Server.GetPlayer(viewId, out NeutronPlayer playerFound))
{
playerFound.Write(player, writer, TargetTo.Me, MatchmakingTo.Me, Protocol.Tcp);
}
else
{
player.Error(Packet.Chat, "Player not found!", ErrorMessage.PLAYER_NOT_FOUND);
}
}
}
}
}
public void Listening(TimeSpan timeout, CancellationToken cancellationToken)
{
Connect();
while (true)
{
string topic = string.Empty;
try
{
var buffer = _sub.ReceiveMultipartMessage();
topic = buffer[0].ConvertToString();
string header = buffer[1].ConvertToString();
var body = buffer[2].ToByteArray();
var _header = System.Text.Json.JsonSerializer.Deserialize <Dictionary <string, string> >(header);
_header.Add(DotNetCore.CAP.Messages.Headers.Group, _queueName);
var message = new TransportMessage(_header, body);
OnMessageReceived?.Invoke(_sub, message);
}
catch (Exception ex)
{
OnLog?.Invoke(this, new LogMessageEventArgs()
{
LogType = MqLogType.ExceptionReceived, Reason = $"{_queueName}-{topic}-{ex.Message}"
});
}
cancellationToken.ThrowIfCancellationRequested();
cancellationToken.WaitHandle.WaitOne(timeout);
}
}
/// <summary>
/// 订阅消息
/// </summary>
/// <typeparam name="TMessage"></typeparam>
public void Subscribe <TMessage>() where TMessage : class
{
(string QueueName, string RoutingKey, string ExchangeName)queue = GetQueue(typeof(TMessage));
IModel channel = CreateQueue(queue.ExchangeName, queue.QueueName, queue.RoutingKey);
EventingBasicConsumer _consumer = new EventingBasicConsumer(channel);
_consumer.Received += async(ch, ea) =>
{
string messageBody = Encoding.UTF8.GetString(ea.Body);
TMessage message = JsonConvert.DeserializeObject <TMessage>(messageBody);
foreach (Type handleType in GetHandlers(typeof(TMessage)))
{
if (OnMessageReceived != null)
{
OnMessageReceived?.Invoke(ea, new MessageContext(handleType, message, messageBody));
}
else
{
IRabbitMQBusHandler <TMessage> handle = Activator.CreateInstance(handleType) as IRabbitMQBusHandler <TMessage>;
await handle.Handle(message);
}
}
channel.BasicAck(ea.DeliveryTag, false);
};
channel.BasicConsume(queue.QueueName, false, _consumer);
Console.WriteLine($"\t订阅\tExchange::{queue.ExchangeName}\tRoutingKey::{queue.RoutingKey}");
}
/// <summary>
/// 自定订阅
/// </summary>
public void AutoSubscribe()
{
Console.WriteLine("开启自动订阅::BEGIN");
foreach (Type messageType in GetQueues())
{
(string QueueName, string RoutingKey, string ExchangeName)queue = GetQueue(messageType);
IModel channel = CreateQueue(queue.ExchangeName, queue.QueueName, queue.RoutingKey);
EventingBasicConsumer _consumer = new EventingBasicConsumer(channel);
_consumer.Received += (ch, ea) =>
{
string messageBody = Encoding.UTF8.GetString(ea.Body);
object message = JsonConvert.DeserializeObject(messageBody, messageType);
foreach (Type handleType in GetHandlers(messageType))
{
if (OnMessageReceived != null)
{
OnMessageReceived?.Invoke(ea, new MessageContext(handleType, message, messageBody));
}
else
{
object handle = Activator.CreateInstance(handleType);
MethodInfo method = handleType.GetMethod(nameof(IRabbitMQBusHandler.Handle));
Task task = (Task)method.Invoke(handle, new[] { message });
task.GetAwaiter().GetResult();
}
}
channel.BasicAck(ea.DeliveryTag, false);
};
channel.BasicConsume(queue.QueueName, false, _consumer);
Console.WriteLine($"\t订阅\tExchange::{queue.ExchangeName}\tRoutingKey::{queue.RoutingKey}");
}
Console.WriteLine("开启自动订阅::END");
}
void Tick(object state)
{
var h = OnMessageReceived.GetInvocationList().ToArray();
var awt = h.Select(d =>
{
var dd = (MessageReceivedEventHandler)d;
return(dd?.Invoke(new SlackMessage
{
User = new SlackUser
{
Id = "TestUser",
Name = "Test",
},
Timestamp = DateTime.Now.Ticks,
Text = "A message",
MentionsBot = false,
ChatHub = new SlackChatHub
{
Name = "Hob",
Id = "HHOD",
Members = new String[0],
Type = SlackChatHubType.Channel
},
MessageSubType = SlackMessageSubType.ChannelArchive,
RawData = "Some rasw data"
}) ?? Task.CompletedTask);
}).ToArray();
Task.WaitAll(awt);
}
public void MessageReceived(MessagePartialTransportModel obj)
{
OnMessageReceived?.Invoke(this, new MessageReceivedEventArgs
{
Message = obj.Mapping <MessagePartialModel>()
});
}
/// <summary>
/// Used internally. Receives as message and passes it to the ComChannels listeners.
/// </summary>
/// <param name="amqMessage">The received raw amq message</param>
internal void _OnMessage(IMessage amqMessage)
{
if (!(amqMessage is ITextMessage))
{
Console.Error.WriteLine("[ComChannel] Recieved unsupported amq message type: " + amqMessage.GetType());
return;
}
string messageType = null;
messageType = amqMessage.Properties.GetString(MESSAGETYPE_PROPERTY);
if (messageType == null)
{
Console.Error.WriteLine("[ComChannel] Cannot determine message type");
}
else if (messageType.Equals(string.Empty))
{
Console.Error.WriteLine("[ComChannel] Cannot determine message type");
}
ITextMessage amqTextMessage = amqMessage as ITextMessage;
string message = amqTextMessage.Text;
OnMessageReceived?.Invoke(messageType, message);
}
public void Connect(string _username, string roomname)
{
Connection = new HubConnection(url, new Dictionary <string, string> {
{ "username", _username }
}
);
Connection.StateChanged += Connection_StateChanged;
ChatHubProxy = Connection.CreateHubProxy("ChatHub");
ConnectedUser.Ids.Add(Connection.ConnectionId);
ChatHubProxy.On <string, string>("MessageReceived", (username, message) =>
{
var user = new SignalrUser
{
username = username,
message = message,
};
OnMessageReceived?.Invoke(user);
});
Start().ContinueWith(task =>
{
if (task.IsFaulted)
{
ConnectionError.Invoke();
}
});
}
private void GenericNpmRunnerOnMessageReceived(object sender, MessageEventArgs e)
{
if (!e.Error)
{
TryParsePort(e.Message);
}
OnMessageReceived?.Invoke(this, e);
}
private void HandleMessage(Group server, Channel channel, MessageResponse message)
{
var chatChannel = new ChatChannel(message.ConversationID, channel.GroupTitle);
var sender = new ChatUser(message.SenderName, message.SenderID.ToString());
var msg = new ChatMessage(message.Timestamp, sender, chatChannel, message.Body);
OnMessageReceived?.Invoke(msg);
}
private void ExtendedTextMessage(object sender, TextMessage eventArgs)
{
if (connectionData.suppressLoopback && eventArgs.InvokerId == me.ClientId)
{
return;
}
OnMessageReceived?.Invoke(sender, eventArgs);
}
private void OnConsumerReceived(object sender, BasicDeliverEventArgs e)
{
_deliveryTag = e.DeliveryTag;
if (OnMessageReceived != null)
{
OnMessageReceived.Invoke(sender, e);
}
}
internal void SetOnMessageReceivedCallback(OnMessageReceived callback)
{
C.MessageListenerHelper_SetOnMessageReceivedCallback(
SelfPtr(),
InternalOnMessageReceivedCallback,
Callbacks.ToIntPtr(callback)
);
}
/// <summary>
/// Publish received message.
/// </summary>
/// <param name="receivedMessage">Received message.</param>
protected void PublishMessage(MessageContainer <TMessage> receivedMessage)
{
if (receivedMessage != null && !receivedMessage.IsEmpty)
{
// This is not awaited.
OnMessageReceived?.Invoke(receivedMessage);
}
}
public void FetchNewSQSMessages(OnMessageReceived mesgRecvCallback)
{
if (!hasPendingFetch)
{
hasPendingFetch = true;
StartCoroutine(SQSMessageGetAsync(mesgRecvCallback));
}
}
public void SetCallback(int MsgType, OnMessageReceived onMsgReceived)
{
if (MsgType >= (int)PackMsg.PackMsg.MsgKind_e.PACK_MSG_NUMBER)
{
return;
}
msgHandlers[MsgType] = onMsgReceived;
}
private Task OnConsumerReceived(Message message, CancellationToken token)
{
var context = ConvertMessage(message);
OnMessageReceived?.Invoke(new AzureServiceBusConsumerCommitInput(message.SystemProperties.LockToken), context);
return(Task.CompletedTask);
}
// call if received message not find event for processing
static void MessageReceived(Connection connection, Response msg)
{
Unity.Console.DebugLog(Unity.Console.SetYellowColor("Received unbinding message:"), Unity.Console.SetWhiteColor(msg));
if (!OnMessageReceived.IsNull())
{
OnMessageReceived(connection, msg);
}
}
public async Task AddChatMessage(IChatMessage msg)
{
var test = await httpClient.PostJsonAsync <ChatMessageModel>("http://localhost:46473/api/Chat", msg);
ChatMessages.Add(test);
OnMessageReceived?.Invoke(this, null);
// instances.ForEach(x => x.OnMessageReceived?.Invoke(this, test));
}
internal void SetOnMessageReceivedCallback(OnMessageReceived callback)
{
C.MessageListenerHelper_SetOnMessageReceivedCallback(
SelfPtr(),
InternalOnMessageReceivedCallback,
Callbacks.ToIntPtr(callback)
);
}
public override void Connect()
{
base.Connect();
// If it's the first access for the user, we send the added meta message
if (FirstAccess)
{
SendMetaMessage(MetaState.Added);
}
// Now send a meta message, that the user is online
SendMetaMessage(MetaState.Online);
// Declare the queue for the user
var queue = GroupChat.SharedSecret.GroupChatName + "." + GroupChat.ChatMember;
Model.QueueDeclare(queue, true, false, false, null);
var consumer = new EventingBasicConsumer(Model);
consumer.Received += (obj, ea) =>
{
var message = BinaryFormatter <ChatMessage> .FromBinary(ea.Body);
// Proof that receiver is not the sender
if (message.Sender == GroupChat.ChatMember)
{
return;
}
// Decrypt the message
if (message.IsEncrypted)
{
message = GroupChat.Decrypt(message);
}
// if Message can't decrypted (due to wrong shared key etc)
if (message == null)
{
return;
}
// Check, if the plain text is a json meta object
var parsedJsonObject = JObject.Parse(message.PlainText);
if (parsedJsonObject.IsValid(MetaMessageSchema))
{
var metaMessage = JsonConvert.DeserializeObject <MetaMessage>(message.PlainText);
OnMetaMessageReceived?.Invoke(GroupChat.ChatMember, message.Sender, metaMessage);
}
else if (parsedJsonObject.IsValid(ContentMessageSchema))
{
var contentMessage = JsonConvert.DeserializeObject <TMessageObject>(message.PlainText);
OnMessageReceived?.Invoke(GroupChat.ChatMember, message.Sender, contentMessage);
}
};
Model.QueueBind(queue, "amq.fanout", GroupChat.SharedSecret.GroupChatName, null);
Model.BasicConsume(queue, true, string.Empty, false, true, null, consumer);
}
public void OnRecievedData(IAsyncResult arg)
{
var sock = (SocketAdapter)arg.AsyncState;
int nBytesRec = sock.EndReceive(arg);
string sRecieved = Encoding.Unicode.GetString(buffer, 0, nBytesRec);
OnMessageReceived?.Invoke(sRecieved);
SetupRecieveCallback(sock);
}
public void Send(int opCode, object parameters)
{
Task.Run(() => {
// emulating interoperation with a bank terminal device
Console.WriteLine("Operation is active");
Thread.Sleep(3000);
OnMessageReceived?.Invoke(this, new ProtocolMessage(OperationStatus.Finished));
});
}
public Task ListenAsync(CancellationToken cancellationToken = default)
{
_currentConsumer.OnMessageReceived += (sender, msg) =>
{
OnMessageReceived.Invoke(sender, new TransportMessage(new Dictionary <string, string>(), msg));
};
return(Task.CompletedTask);
}
// Handle the direct method call
private Task <MethodResponse> SwitchRelay(MethodRequest methodRequest, object userContext)
{
OnMessageReceived?.Invoke("Executed direct method: " + methodRequest.Name);
_relayModule.ChangeState();
string result = "{\"result\":\"Relay state: " + _relayModule.RelayState + "\"}";
return(Task.FromResult(new MethodResponse(Encoding.UTF8.GetBytes(result), 200)));
}
private void ReceiveCallback(IAsyncResult result)
{
var endPoint = LocalEndPoint;
var bytes = _client.EndReceive(result, ref endPoint);
var eventArgs = new UdpReceivedEventArgs(bytes);
OnMessageReceived?.Invoke(this, eventArgs);
Receive();
}
private void ExtendedTextMessage(object sender, TextMessage textMessage)
{
// Prevent loopback of own textmessages
if (textMessage.InvokerId == tsFullClient.ClientId)
{
return;
}
OnMessageReceived?.Invoke(sender, textMessage);
}
public void AddMessage(string message)
{
lock (Messages)
{
Messages.Add(message);
}
OnMessageReceived?.Invoke(this, EventArgs.Empty);
}
protected override void OnMessage(MessageEventArgs e)
{
var settings = new JsonSerializerSettings {
TypeNameHandling = TypeNameHandling.All
};
BaseMessage message = JsonConvert.DeserializeObject <BaseMessage>(e.Data, settings);
OnMessageReceived?.Invoke(this, message);
}
/// <summary>
/// This method allows you to get subscribed to the MessageReceived event
/// </summary>
/// <param name="_method"> the method to run when this event fires </param>
public void SubscribeToMessageReceived(OnMessageReceived _method)
{
MessageReceived += _method;
}
public void SetCallback(int MsgType, OnMessageReceived onMsgReceived)
{
if (MsgType >= (int)PackMsg.PackMsg.MsgKind_e.PACK_MSG_NUMBER)
{
return;
}
msgHandlers[MsgType] = onMsgReceived;
}
/// <summary>
/// Unsubscribe from this event
/// </summary>
/// <param name="_method"> the method you want to unsubscribe from this event </param>
public void UnsubscribeToMessageReceived(OnMessageReceived _method)
{
MessageReceived -= _method;
}
