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(); } } }