private async void Communicate(TCPConnection connection)
{
try {
while (connection.active)
{
List <byte> data = await connection.Receive();
string channel = data.ReadString();
if (channel == "disconnection")
{
connection.active = false;
}
else
{
//received a message from the host!
onMessageReception.Invoke(connection, channel, data);
}
}
onConnectionEnd.Invoke(connection);
hosts.Remove(connection);
}catch (SocketException se) {
Haze.Logger.LogError("[TCPClient] Socket Exception (" + se.ErrorCode + "), cannot communicate with host: " + se.ToString(), this);
}catch (Exception e) {
Haze.Logger.LogError("[TCPClient] Error, cannot communicate with host: " + e.ToString(), this);
}
}
private void SafeInvokeMessageRecevied(MessageReceivedEventArgs eventArgs)
{
if (this.RemoteMessage == null)
{
return; //No Listeners
}
MessageReceivedEvent listener = null;
Delegate[] dels = this.RemoteMessage.GetInvocationList();
foreach (Delegate del in dels)
{
try
{
listener = (MessageReceivedEvent)del;
listener.Invoke(eventArgs);
}
catch (Exception)
{
//Could not reach the destination, so remove it
//from the list
this.RemoteMessage -= listener;
}
}
}
private async void PacketReceivedEventHandler(object sender, PacketReceivedEventArgs e)
{
if (!Message.IsMessageContentType(e.Packet.ContentType))
{
await ErrorAsync("Packet content is not a message!").ConfigureAwait(false);
return;
}
// TODO: exceptions here?
Logger.Debug("Attempting to parse a message...");
Message message = await Message.DeSerializeAsync(e.Packet.ContentType, e.Packet.Encoding, e.Packet.Content, 0, e.Packet.ContentLength, MessageFactory).ConfigureAwait(false);
if (null == message)
{
await ErrorAsync("Failed to parse a message!").ConfigureAwait(false);
return;
}
Logger.Debug($"{message.Type} message parsed!");
MessageReceivedEvent?.Invoke(this, new MessageReceivedEventArgs
{
Message = message
}
);
}
private void WaitForData()
{
while (true)
{
try
{
var data = new byte[GlobalConfig.Size];
var builder = new StringBuilder();
UserMessage receivedObject;
do
{
var bytes = Stream.Read(data, 0, data.Length);
receivedObject = JsonSerializer.Deserialize <UserMessage>(Encoding.UTF8.GetString(data, 0, bytes));
builder.Append(receivedObject);
}while (Stream.DataAvailable);
var message = builder.ToString();
Console.WriteLine(message);
MessageReceivedEvent?.Invoke(receivedObject, this);
}
catch (JsonException ex)
{
Console.WriteLine(ex.Message);
}
catch
{
Console.WriteLine($"Подключение {Id} прервано!");
Disconnect();
break;
}
}
}
private async Task ReadAsync(Package package)
{
// побуферно читаем сообщения, что позволяет не ограничиваться его размером
var readBytes = await _pipeServer.ReadAsync(package.Buffer, 0, package.Buffer.Length);
if (readBytes > 0)
{
byte[] result;
if (_pipeServer.IsMessageComplete)
{
result = new byte[readBytes];
Array.Copy(package.Buffer, 0, result, 0, readBytes);
}
else
{
result = package.Buffer;
}
package.Result.AddRange(result);
// если не дочитали...
if (!_pipeServer.IsMessageComplete)
{
// ...то читаем следующий буфер
await ReadAsync(package);
}
else
{
using (var stream = new MemoryStream(package.Result.ToArray()))
{
var message = Serializer.Deserialize <T>(stream);
MessageReceivedEvent?.Invoke(this,
new MessageReceivedEventArgs <T>
{
ClientId = responceClientId,
Message = message
});
}
await ReadAsync(new Package());
}
}
// Если прочитано 0 байт, то клиент вероятно отключился
else
{
if (!_isStopping)
{
Stop();
ClientDisconnectedEvent?.Invoke(
this,
new ClientDisconnectedEventArgs {
ClientId = responceClientId
});
}
}
}
/// <summary>
/// Message event as decoded string
/// </summary>
/// <param name="message">Decoded message</param>
public void MessageReceived(string message)
{
//Debug.Log ("UDP:Received:"+message);
//Message Received event for listeners
if (MessageReceivedEvent != null)
{
MessageReceivedEvent.Invoke(message);
}
}
private async Task ReceiveMessage(MqttApplicationMessageReceivedEventArgs e)
{
Debug.WriteLine("### RECEIVED APPLICATION MESSAGE ###");
Debug.WriteLine($"+ Topic = {e.ApplicationMessage.Topic}");
Debug.WriteLine($"+ Payload = {Encoding.UTF8.GetString(e.ApplicationMessage.Payload)}");
Debug.WriteLine($"+ QoS = {e.ApplicationMessage.QualityOfServiceLevel}");
Debug.WriteLine($"+ Retain = {e.ApplicationMessage.Retain}");
Debug.WriteLine("");
MessageReceivedEvent?.Invoke(e);
}
protected virtual void OnMessage(RemoteServer server, MessageEventArgs args)
{
MessageEvent?.Invoke(server, args);
if (args.Sent)
{
MessageSentEvent?.Invoke(server, args);
}
else
{
MessageReceivedEvent?.Invoke(server, args);
}
}
private void OnMessageReceived(object o, BasicDeliverEventArgs e)
{
Console.WriteLine("Message received");
if (!string.Equals(API.DemoMessage.Descriptor.Name, e.BasicProperties.Type,
StringComparison.OrdinalIgnoreCase))
{
return;
}
var message = API.DemoMessage.Parser.ParseFrom(e.Body.ToArray());
MessageReceivedEvent?.Invoke(this, new MessageReceivedEventArgs(message));
}
private void HandleMessage(string msg)
{
MediaResult result = MediaResult.FromJson(msg);
if (result.isOk())
{
MessageReceivedEvent?.Invoke(result);
}
else
{
Debug.Print("error: " + result.ToString());
}
Debug.Print(result.ToString());
}
private void Run()
{
while (true)
{
Message m = _messageQueue.Receive();
Stock s = m.Body as Stock;
if (s != null)
{
if (s.Index.Equals(_indexFilter))
{
MessageReceivedEvent.Invoke(this, new StockMessageEventArgs(s));
}
}
}
}
private void BeginReceive()
{
receiveTask = Task.Factory.StartNew(async() =>
{
while (!ShutDown && Client.Connected)
{
var data = new byte[client.ReceiveBufferSize];
var count = await stream.ReadAsync(data, 0, client.ReceiveBufferSize);
var message = Encoding.ASCII.GetString(data, 0, count);
var address = (IPEndPoint)client.Client.RemoteEndPoint;
MessageReceivedEvent?.Invoke(new Message(message, address), message.Split('|'));
}
});
}
public void OnMessageReceived(IntPtr lc, IntPtr room, IntPtr message)
{
var peer_address = ChatModule.linphone_chat_room_get_peer_address(room);
if (peer_address.IsNonZero())
{
var addressStringPtr = CallModule.linphone_address_as_string(peer_address);
var chatMessagePtr = ChatModule.linphone_chat_message_get_text(message);
string addressString, chatMessage;
if (MarshalingExtensions.TryConvert(addressStringPtr, out addressString) && MarshalingExtensions.TryConvert(chatMessagePtr, out chatMessage))
{
MessageReceivedEvent?.Invoke(addressString, chatMessage);
}
}
}
private void WaitConnection()
{
_ = Task.Run(() =>
{
while (true)
{
ps_ = new NamedPipeServerStream(GameServerPipeName, PipeDirection.InOut);
ps_.WaitForConnection();
using (var sr = new StreamReader(ps_))
{
var message = sr.ReadToEnd();
MessageReceivedEvent?.Invoke(this, new MessageReceivedEventArgs(message));
}
}
});
}
private void OnInputFileChanged(object sender, FileSystemEventArgs fileSystemEventArgs)
{
if (inputEventRaised)
{
// We get 2 events for every save of the file...
inputEventRaised = false;
return;
}
inputEventRaised = true;
var inputText = File.ReadAllText(inputFile);
logger.LogDebug($"Input Received: {inputText}");
MessageReceivedEvent?.Invoke(this, inputText);
}
private async void Communicate(TCPConnection connection)
{
while (connection.active)
{
List <byte> data = await connection.Receive();
if (data.Count > 0)
{
string channel = data.ReadString();
if (channel == "disconnection")
{
connection.active = false;
}
else
{
//received a message from the host!
onMessageReception.Invoke(connection, channel, data);
}
}
else
{
Haze.Logger.LogWarning("Received data with length == 0 from connection " + connection);
connection.active = false;
}
}
//Attempt to send a "disconnection" message before closing
{
List <byte> data = new List <byte>();
data.WriteString("disconnection");
try {
await connection.Send(data);
} catch (Exception e) {
//nevermind.
}
}
onConnectionEnd.Invoke(connection);
users.Remove(connection);
if (!connection.UDP)
{
connection.client.Close();
}
}
private void SendMessageReceived(UdpReceiveResult result)
{
var bytes = result.Buffer;
if (bytes?.Any() ?? false)
{
var content = Encoding.ASCII.GetString(
bytes: bytes.ToArray(),
index: 0,
count: bytes.Count()).TrimEnd(EndChar);
if (!string.IsNullOrWhiteSpace(content))
{
MessageReceivedEvent?.Invoke(
sender: this,
e: new MessageReceivedArgs(content));
}
}
}
/// <summary>
/// Invokes a event
/// </summary>
/// <typeparam name="T">The event</typeparam>
/// <param name="message">The message</param>
public void RaiseServerEvent <T>(T message) where T : IServerEvent
{
Type messageType = typeof(T);
if (m_MessageAwaiters.ContainsKey(messageType))
{
MessageReceivedEvent awaiter = m_MessageAwaiters[messageType];
awaiter.Invoke((object)message);
}
if (m_ServerEventHandlers.ContainsKey(messageType))
{
m_ServerEventHandlers[messageType].DynamicInvoke(message);
}
if (m_GroupServerEventHandlers.ContainsKey(messageType))
{
m_GroupServerEventHandlers[messageType].Invoke(this, message);
}
}
// Through this method, we can fire the event in a thread safe manor from everywhere inside the class.
private void IncommingMessage(NewMessageEventArgs e)
{
lock (messageReceivedEventPadlock) {
// When the server is notified it will raise its own event with the same message and id.
MessageReceivedEvent?.Invoke(id, e);
// ?. is called a null conditional operator.
// If the target (here, messageReceivedEvent) is null, it returns null
// Otherwise it calls the specified member.
// In normal syntax this is (explicitely):
// MessageReceivedHandler handler = messageReceivedEvent;
// if (handler == null) return null;
// else return messageReceivedEvent.Invoke(id, new NewMessageEventArgs(message));
// For this case it would be:
// MessageReceivedHandler handler = messageReceivedEvent;
// if (handler != null) messageReceivedEvent.Invoke(id, new NewMessageEventArgs(message));
// as returns from operators are ignored the value is not assigned to anything.
}
}
private void ReciveMessages()
{
while (true)
{
try
{
var builder = new StringBuilder();
var data = new byte[GlobalConfig.GlobalConfig.Size];
UserMessage receivedObject;
do
{
var bytes = Stream.Read(data, 0, data.Length);
receivedObject = JsonSerializer.Deserialize <UserMessage>(Encoding.UTF8.GetString(data, 0, bytes));
builder.Append(receivedObject);
}while (Stream.DataAvailable);
MessageReceivedEvent?.Invoke(receivedObject);
var message = builder.ToString();
Console.WriteLine(message);
}
catch (JsonException ex)
{
Console.WriteLine(ex.Message);
break;
}
catch (Exception ex) when(ex is SocketException || ex is IOException)
{
Console.WriteLine($"Error: {ex.Message} = {ex.GetType()} Подключение прервано!");
RunEventDelegatesAsync(ConnectionLostEvent?.GetInvocationList());
break;
}
}
}
private void HandleMessageReceived(object sender, MessageReceivedEventArgs state)
{
MessageReceivedEvent?.Invoke(state.Message);
}
protected virtual void OnMessageReceivedEvent(SocketEventArgs e)
{
MessageReceivedEvent?.Invoke(this, e);
}
/// <summary>
/// 触发事件
/// </summary>
public void Raise_MessageReceivedEvent(object sender, decimal number)
{
MessageReceivedEvent?.Invoke(sender, number);
}
private async void ProcessClientStream(TcpClient client)
{
var stream = client.GetStream();
while (!ShutDown)
{
if (client.Client != null && client.Connected)
{
//if (client.Client.Poll(TimeOutTime, SelectMode.SelectRead))
//{
// Player player = null;
// byte[] buff = new byte[1];
// if (client.Client.Receive(buff, SocketFlags.Peek) == 0)
// {
// Client Disconnected
// foreach (var pl in GameStore.Instance.Game.PlayerList)
// {
// if (pl.Key.Client == client)
// {
// player = pl.Key;
// Console.WriteLine("A player : " + pl.Key.PlayerAddress + " has disconnected");
// pl.Value.Dispose();
// }
// }
// if (player != null) GameStore.Instance.Game.PlayerList.Remove(player);
// return;
// }
// else
// {
// }
// = GameStore.Instance.Game.GetPlayerFromIpEndPoint((IPEndPoint)client.Client.RemoteEndPoint);
// Console.WriteLine("A player : " + pl.PlayerAddress + " has disconnected");
// pl.Value.Wait();
//}
var data = new byte[client.ReceiveBufferSize];
int count;
try
{
count = await stream.ReadAsync(data, 0, client.ReceiveBufferSize);
}
//A player Just Disconnected Sudden Disconnection
//The listener tried to read from a stream that was suddenly broked
catch (IOException)
{
DisconnectClient(client);
//Wait for a new client to connect
StartAwaitClients();
return;
}
//Client is Still Connected
var message = Encoding.ASCII.GetString(data, 0, count);
//Message Received just after client closes his stream
if (message == CodeMessages.PLAYER_DISCONNECTED)
{
//GameStore.Instance.Game.GetPlayer()
DisconnectClient(client);
//Wait for a new client to connect
StartAwaitClients();
return;
}
var address = (IPEndPoint)client.Client.RemoteEndPoint;
MessageReceivedEvent?.Invoke(new Message(message, address));
}
}
}
internal void RaiseOnMessageReceived(BotWideMessageArguments args)
{
OnMessageReceived?.Invoke(args);
}
private void MessageReceivedHandler(object sender, MessageReceivedEventArgs <T> eventArgs)
{
_synchronizationContext.Post(
e => MessageReceivedEvent?.Invoke(this, (MessageReceivedEventArgs <T>)e),
eventArgs);
}
private void OnMessageReceived(object sender, MessageReceivedEventArgs args)
{
var message = Encoding.ASCII.GetString(args.Data);
MessageReceivedEvent?.Invoke(this, message);
}
private void OnClientData(int id, ArraySegment <byte> data)
{
MessageReceivedEvent?.Invoke(id, data);
}
private void LinphoneWrapper_MessageReceivedEvent(string from, string message)
{
MessageReceivedEvent?.Invoke(from, message);
}
private void MessageReceivedHandle(Message message)
{
MessageReceivedEvent?.Invoke(this, new MessageReceivedEventArgs(message));
}