private void Receive()
{
Task onStopTask = Task.Run(() => _onStop.WaitOne());
_onThreadStarted.Set();
while (true)
{
try
{
_isSocketReady.WaitOne();
Task <UdpReceiveResult> result = _udpClient.ReceiveAsync();
if (Task.WaitAny(onStopTask, result) == 0)
{
return;
}
OnMessageReceived?.Invoke(this, result.Result);
}
catch (Exception e)
{
OnMessageReceivedFailure?.Invoke(this, new ReceiveFailureException("UDPClient threw an exception when receiving", e));
RebuildUdpClient();
}
}
}
/// <summary>
/// Handle Android OnNewIntent
/// </summary>
/// <param name="intent">Android <see cref="Intent"/></param>
internal void HandleNewIntent(Intent intent)
{
if (intent == null)
{
return;
}
if (intent.Action == NfcAdapter.ActionTagDiscovered || intent.Action == NfcAdapter.ActionNdefDiscovered)
{
_currentTag = intent.GetParcelableExtra(NfcAdapter.ExtraTag) as Tag;
if (_currentTag != null)
{
var nTag = GetTagInfo(_currentTag);
if (_isWriting)
{
// Write mode
OnTagDiscovered?.Invoke(nTag, _isFormatting);
}
else
{
// Read mode
OnMessageReceived?.Invoke(nTag);
}
}
}
}
private void HandleDataMessage(NetIncomingMessage inc)
{
if (!isActive)
{
return;
}
byte incByte = inc.ReadByte();
bool isCompressed = (incByte & (byte)PacketHeader.IsCompressed) != 0;
bool isConnectionInitializationStep = (incByte & (byte)PacketHeader.IsConnectionInitializationStep) != 0;
//DebugConsole.NewMessage(isCompressed + " " + isConnectionInitializationStep + " " + (int)incByte);
if (isConnectionInitializationStep && initializationStep != ConnectionInitialization.Success)
{
ReadConnectionInitializationStep(inc);
}
else
{
if (initializationStep != ConnectionInitialization.Success)
{
OnInitializationComplete?.Invoke();
initializationStep = ConnectionInitialization.Success;
}
UInt16 length = inc.ReadUInt16();
IReadMessage msg = new ReadOnlyMessage(inc.Data, isCompressed, inc.PositionInBytes, length, ServerConnection);
OnMessageReceived?.Invoke(msg);
}
}
public void SubscribeHubMethod(string methodName)
{
_hub.On <string>(methodName, (data) =>
{
OnMessageReceived?.Invoke(data);
});
}
public async Task BeginListening(CancellationToken token)
{
while (!token.IsCancellationRequested)
{
try
{
var(msg, msgId, transaction) =
await GetMessage(
_connectionString,
_queueName,
token);
OnMessageReceived?.Invoke(
this,
new MessageEventArgs
{
Message = new AcknowledgeableMessage(
msg,
msgId,
transaction)
});
}
catch (Exception e)
{
OnMessageException?.Invoke(
this,
new MessageExceptionArgs
{
Exception = e
});
await Task.Delay(1000, token);
}
}
}
public HubClient(AuthenticationToken token)
{
this.token = token;
Debug.WriteLine("Starting client" + Helpers.Main.Server);
hubConnection = new HubConnection(Helpers.Main.Server,
new Dictionary <string, string>
{
{ "access_token", token.access_token }
});
//hubConnection.TraceLevel = TraceLevels.All;
//hubConnection.TraceWriter = Console.Out;
myHubProxy = hubConnection.CreateHubProxy("AbsenHub");
myHubProxy.On <absen>("addNewAbsen", (absen) =>
{
OnMessageReceived?.Invoke(absen);
});
myHubProxy.On <absen>("addToUser", (absen) =>
{
OnThisUserAbsen?.Invoke(absen);
});
myHubProxy.On("heartbeat", () => Debug.WriteLine("Recieved heartbeat \n"));
myHubProxy.On <absen>("SendNewAbsen", ab =>
Debug.WriteLine("Recieved sendHelloObject {0}, {1} \n", ab.JamMasuk, ab.JamPulang));
hubConnection.StateChanged += HubConnection_StateChanged;
}
public async Task Connect(string userName)
{
await _connection.Start();
ConnectionId = _connection.ConnectionId;
await _proxy.Invoke("Login", userName);
_proxy.On("AddNewMessageToPage", (string name, string message) =>
{
OnMessageReceived?.Invoke(this, new Message
{
UserName = name,
Text = message,
SendDate = DateTime.Now
});
});
_proxy.On("AudioRecognized", (string text) =>
{
OnAudioRecognized?.Invoke(this, text);
});
_proxy.On("NewUser", (string name) =>
{
OnNewUser?.Invoke(this, name);
});
}
/// <summary>
/// Runs the message IO loop for the peer node.
/// </summary>
public async Task RunLoop(CancellationToken cancellationToken)
{
LastMessageInTime = DateTime.Now;
LastPingTime = LastMessageInTime;
while (!cancellationToken.IsCancellationRequested)
{
await readAsync();
// FIXME: message queues are not locked for Enqueue/Dequeue,
// which might be risky in a multi-threaded usage scenario.
while (inMessageQueue.Count > 0 && ShouldDisconnect is false)
{
LastMessageInTime = DateTime.Now;
// Also update ping timestamp to reduce unnecessary pings
LastPingTime = LastMessageInTime;
var msg = inMessageQueue.Dequeue();
OnMessageReceived?.Invoke(this, msg);
}
while (outMessageQueue.Count > 0 && ShouldDisconnect is false)
{
var msg = outMessageQueue.Dequeue();
await writeAsync(msg);
}
await Task.Delay(100, cancellationToken);
}
}
private void OnConsumerReceived(object sender, BasicDeliverEventArgs e)
{
_deliveryTag = e.DeliveryTag;
var message = new MessageEventArgs(e.RoutingKey, Encoding.UTF8.GetString(e.Body));
OnMessageReceived?.Invoke(sender, message);
}
/// <summary>
/// Publish received message through <see cref="OnMessageReceived"/>.
/// </summary>
/// <param name="receivedMessage">Received message.</param>
protected void PublishMessage(MessageContainer <TMessage> receivedMessage)
{
if (receivedMessage != null && !receivedMessage.IsEmpty)
{
OnMessageReceived?.Invoke(receivedMessage);
}
}
private void OnMessage(string message)
{
;
var msgObj = MessageSerializer.Deserailize(Regex.Unescape(message));
switch (msgObj.FrameCommand)
{
case "CONNECTED":
this.IsConnected = true;
OnConntected?.Invoke();
break;
case "MESSAGE":
OnMessageReceived?.Invoke(msgObj);
break;
case "RECEIPT":
OnReceipt?.Invoke(msgObj);
break;
case "ERROR":
OnError?.Invoke(msgObj.Headers["message"], msgObj);
this.IsConnected = false;
break;
}
}
/// <summary>
/// Asynchronously start the socket service with the specified port.
/// </summary>
/// <param name="port">
/// Selected port number.
/// </param>
public override async Task StartAsync(int port)
{
_socket = new WebSocket($"ws://127.0.0.1:{port}")
{
Log = { Output = (_, __) => { } }
};
_socket.OnMessage += (sender, args) =>
{
_buffer += args.Data;
var buffer = _buffer.Split("---Message--End---");
for (var i = 0; i < buffer.Length - 1; i++)
{
OnMessageReceived?.Invoke(buffer[i].FromJson <Message>());
}
_buffer = buffer.Last();
};
_socket.OnOpen += (sender, args) =>
{
Send("remote_control_data", new Params
{
{ "script", Options.ScriptName },
{ "password", Options.Password },
{ "login", Options.Login }
});
};
await ConnectAsync().ConfigureAwait(false);
}
//public void SendCommentReplyNotice(string userName, MessageType type, int id)
//{
// OnCommentReplyReceived?.Invoke(this, new MessageReceivedEventArgs() { UserName = userName, MessageType = type, ReferenceID = id });
//}
public void SendMessageNotice(string userName, string sendingUserName, MessageTypeFlag type, ContentType?referenceType, int?referenceID, string message = null)
{
OnMessageReceived?.Invoke(this, new MessageReceivedEventArgs()
{
TargetUserName = userName, SendingUserName = sendingUserName, MessageType = type, ReferenceType = referenceType, ReferenceID = referenceID, Message = message
});
}
public void Init()
{
// TODO: Implement a way for the server to tell the client they are ready to communicate
WebSocket = IO.Socket("https://qubicredserver-frosenos.rhcloud.com:8443/");
//WebSocket = IO.Socket("http://localhost:8080/");
//WebSocket = IO.Socket("https://home-frosenos.rhcloud.com:8443/");
WebSocket.On(Socket.EVENT_CONNECT, () =>
{
SocketEvent?.Invoke(new SocketEvent("Connected", true));
});
WebSocket.On(Socket.EVENT_DISCONNECT, () =>
{
SocketEvent?.Invoke(new SocketEvent("Connected", false));
});
WebSocket.On(Socket.EVENT_CONNECT_ERROR, (data) =>
{
Exception e = data as Exception;
if (e == null)
{
throw new Exception("Unknown Connection Error!");
}
throw e.InnerException.InnerException;
});
WebSocket.On("message", (data) => { OnMessageReceived?.Invoke(new SocketMessage(data)); });
WebSocket.On("login", (data) => { SocketEvent?.Invoke(new SocketEvent("login", data)); });
WebSocket.On("moduleregistered", (data) => { SocketEvent?.Invoke(new SocketEvent("moduleregistered", data)); });
WebSocket.On("friendslist", (data) => { SocketEvent?.Invoke(new SocketEvent("friendslist", data)); });
WebSocket.On("conversations", (data) => { SocketEvent?.Invoke(new SocketEvent("conversations", data)); });
WebSocket.On("typing", (data) => { SocketEvent?.Invoke(new SocketEvent("typing", data)); });
}
public async void StartBot()
{
LogMessage?.Invoke("The bot is running");
while (true)
{
try
{
var updates = await GetUpdatesAsync();
foreach (var update in updates)
{
if (update.Message.Text != null && update.Message.Text != String.Empty)
{
OnMessageReceived?.Invoke(update.Message);
}
_offset = update.Id + 1;
}
}
catch (Exception)
{
Thread.Sleep(10000);
}
}
}
//Remoting
public void ReceiveMessage(string username, IVectorMessage <IMessage> message)
{
this.vetorClockManager.ReceiveMessage(username, message);//quando recebe manda para o vetorclock para ele ver
//se existe dependencias
//pede a lista e mostra no jogo
OnMessageReceived?.Invoke(this.vetorClockManager.GetMessages());
}
public void getMessage()
{
try
{
while (isConnected)
{
string message = reader.ReadLine();
List <string> info = new List <string>();
while (message != "<EOF>")
{
if (string.IsNullOrEmpty(message))
{
continue;
}
info.Add(message);
Console.WriteLine("got a message: " + message);
message = reader.ReadLine();
}
OnMessageReceived?.Invoke(this, info);
}
} catch (Exception e)
{
if (client != null)
{
client.Close();
}
isConnected = false;
Console.WriteLine(e.Message);
}
}
public void PublishMessage(string username, string message)
{
//cria a mensagem, dá um tick o clock
Message m = new Message(username, message);
IVectorMessage <IMessage> vetorMessage = this.vetorClockManager.Tick(m);
//todo upadate
OnMessageReceived?.Invoke(this.vetorClockManager.GetMessages());
foreach (IClient client in this.Peers)
{
Task.Run(() => {
try
{
if (client.Username == username)
{
return;
}
//envia para cada cliente
((IChat)client).ReceiveMessage(username, vetorMessage);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
});
}
}
public void SubscribeHubMethod(string methodName)
{
_hub.On <LocationUpdate>(methodName, (locationUpdate) =>
{
OnMessageReceived?.Invoke(locationUpdate);
});
}
private void MessageRecieved(IAsyncResult result)
{
try
{
int byteLength = _stream.EndRead(result);
if (byteLength > 0)
{
ThreadManager.ExecuteOnMainThread(() =>
{
OnMessageReceived?.Invoke(id, _receiveBuffer);
});
}
else
{
OnDisconnected?.Invoke(id);
Debug.Log("Error: recieved byte length " + byteLength);
return;
}
_stream.BeginRead(_receiveBuffer, 0, DATA_BUFFER_SIZE, MessageRecieved, null);
}
catch (Exception ex)
{
OnDisconnected?.Invoke(id);
Debug.Log($"Error receiving TCP data: {ex}");
}
}
/// <summary>
/// A loop that receives and parses link messages.
/// </summary>
private void ReceiveLoop()
{
MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
while (!Closed)
{
if (Tunnel.Closed)
{
Log.Error("ITunnel closed, ending ReceiveLoop");
Close();
return;
}
Message msg = Receive();
if (msg == null)
{
Log.Trace("Null message, continuing");
continue;
}
OnMessageReceived?.Invoke(this, msg);
if (msg.Type == MessageType.Data)
{
Tunnel.DataBytesReceived += msg.Store["data"].Length;
OnDataReceived?.Invoke(this, msg.Store["data"]);
}
if (msg.Type == MessageType.Heartbeat && !HeartbeatCapable)
{
HeartbeatCapable = true;
}
}
}
static void PostMessage(string message)
{
if (OnMessageReceived != null)
{
OnMessageReceived.Invoke();
}
}
public void Listening(TimeSpan timeout, CancellationToken cancellationToken)
{
Connect();
var request = new ReceiveMessageRequest(_queueUrl)
{
WaitTimeSeconds = 5,
MaxNumberOfMessages = 1
};
while (true)
{
var response = _sqsClient.ReceiveMessageAsync(request, cancellationToken).GetAwaiter().GetResult();
if (response.Messages.Count == 1)
{
var messageObj = JsonConvert.DeserializeObject <SQSReceivedMessage>(response.Messages[0].Body);
var header = messageObj.MessageAttributes.ToDictionary(x => x.Key, x => x.Value.Value);
var body = messageObj.Message;
var message = new TransportMessage(header, body != null ? Encoding.UTF8.GetBytes(body) : null);
message.Headers.Add(Headers.Group, _groupId);
OnMessageReceived?.Invoke(response.Messages[0].ReceiptHandle, message);
}
else
{
cancellationToken.ThrowIfCancellationRequested();
cancellationToken.WaitHandle.WaitOne(timeout);
}
}
}
/// <summary>
/// Boucle de lecture des données reçu. Si l'utilisateur se déconnecte,
/// une exception est déclanché lors de la lecture et on arrêt la boucle en appelant la méthode ClientDisconnect
/// </summary>
private void WaitForData(StreamSocket socket)
{
var dr = new StreamReader(socket.InputStream.AsStreamForRead());
while (_isClientConnected)
{
try
{
string message = dr.ReadLine();
if (!string.IsNullOrEmpty(message))
{
OnMessageReceived?.Invoke(this, message);
}
else
{
ClientDisconnect();
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
ClientDisconnect();
}
}
dr.Dispose();
}
private void OnConsumerReceived(TransportMessage e)
{
var headers = e.Headers;
headers.TryAdd(Messages.Headers.Group, _subscriptionName);
OnMessageReceived?.Invoke(null, e);
}
public void Connect(string _username)
{
Connection = new HubConnection(url, new Dictionary
<string, string>
{
{ "username", _username }
});
Connection.StateChanged += Connection_StateChanged;
ChatHubProxy = Connection.CreateHubProxy("ChatHub");
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();
}
});
}
public void OnMessageReceivedCallback(string userName, string msg)
{
if (OnMessageReceived != null)
{
OnMessageReceived.Invoke(userName, msg);
}
}
public Task HandleApplicationMessageReceivedAsync(MqttApplicationMessageReceivedEventArgs e)
{
return(Task.Run(() =>
{
OnMessageReceived?.Invoke(this, new MQTTMessageReceivedEventArgs(e.ApplicationMessage));
}));
}
protected override void OnPlayerPacketReceived(IPlayer player, IBasePacket packet)
{
if (packet is ChatMessage chatMessage)
{
if (chatMessage.Message.Length < 1)
{
return;
}
if (Game.IsHost)
{
if (chatMessage.Message.Length > MaxMessageLength)
{
chatMessage.Message = chatMessage.Message.Substring(0, MaxMessageLength);
}
if (chatMessage.Message[0] == CommandChar)
{
ParseCommand(player, chatMessage.Message);
}
else
{
var msgToSend = PacketUtility.TakePacket <ChatMessage>();
msgToSend.ClientIndex = player.ClientIndex;
msgToSend.Name = player.DisplayName;
msgToSend.Message = chatMessage.Message;
msgToSend.Scope = chatMessage.Scope;
msgToSend.SupporterLevel = chatMessage.SupporterLevel;
Game.Network.BroadcastPacket(msgToSend);
}
}
OnMessageReceived?.Invoke(chatMessage, chatMessage.Name, chatMessage.Message, chatMessage.ClientIndex == -1);
}
}
public async void BeginRead()
{
try
{
while (true)
{
string response = await Reader.ReadLineAsync();
if (response == null)
{
break;
}
else
{
OnMessageReceived?.Invoke(response);
}
}
}
catch (Exception)
{
}
finally
{
Connected = false;
OnDisconnected?.Invoke();
if (Persistent)
{
Connect();
}
else
{
Close();
}
}
}
