public void PushNotificationReceived(string content, object rawContent) { var conent = new ReceivedMessageEventArgs(content, rawContent); var message = OnMessageReceived; message?.Invoke(null, conent); }
void OnUDPMessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args) { try { var reader = args.GetDataReader(); var guid = reader.ReadGuid(); var count = reader.UnconsumedBufferLength; var data = reader.ReadString(count); if (guid == AppGUID || !EnforceGUIDMatch) { Debug.WriteLine("UDPMessage Recieved: " + data); if (UDPMessageRecieved != null) { var outputArgs = new ReceivedMessageEventArgs(data, new NetworkConnectionEndpoint(args.RemoteAddress, args.RemotePort)); UDPMessageRecieved(this, outputArgs); } if (data == ConnectionCloseMessage) { ResetUDP(); } } } catch (Exception ex) { Debug.WriteLine(DebugTools.PrintOutException("OnUDPMessageRecieved", ex)); } }
public void PushNotificationOpened(string recdMessage) { var conent = new ReceivedMessageEventArgs(recdMessage, recdMessage); var message = OnMessageOpened; message?.Invoke(null, conent); }
private async void TransceiverOnMessageReceived(object sender, ReceivedMessageEventArgs e) { ReceivedMessage message = e.Message; Debug.WriteLine("Received: " + message); if (!message.CrcOk || message.Timeout) { return; } var rxpkMessage = new RxpkMessage( message.UtcTimestamp, GetElapsedMicroSeconds(), _gatewaySettings.Frequency / 1000000.0, 0, 0, 1, "LORA", _datr, _codr, message.PacketRssi, message.PacketSnr, (uint)message.Buffer.Length, Convert.ToBase64String(message.Buffer)); JsonObject jsonData = JsonSerializer.ToJson(rxpkMessage); Debug.WriteLine("Sending JSON: " + jsonData); await PushData(jsonData).ConfigureAwait(false); _forwardedFrameCount++; }
private void Channel_PushNotificationReceived(PushNotificationChannel sender, PushNotificationReceivedEventArgs args) { ReceivedMessageEventArgs content; switch (args.NotificationType) { case PushNotificationType.Badge: content = new ReceivedMessageEventArgs(args.BadgeNotification?.Content.GetXml() ?? string.Empty, args.BadgeNotification); break; case PushNotificationType.Tile: content = new ReceivedMessageEventArgs(args.TileNotification?.Content.GetXml() ?? string.Empty, args.TileNotification); break; case PushNotificationType.Toast: content = new ReceivedMessageEventArgs(args.ToastNotification?.Content.GetXml() ?? string.Empty, args.ToastNotification); break; case PushNotificationType.Raw: content = new ReceivedMessageEventArgs(args.RawNotification?.Content ?? string.Empty, args.RawNotification); args.Cancel = true; break; default: content = new ReceivedMessageEventArgs(string.Empty); break; } var message = OnMessageReceived; message?.Invoke(null, content); }
private void ReceiveCallback(IAsyncResult asyncResult) { try { ReceivedMessageEventArgs receivedMessage = (ReceivedMessageEventArgs)asyncResult.AsyncState; Socket socket = receivedMessage.Socket; int bytesRead = socket.EndReceive(asyncResult); receivedMessage.Message += (bytesRead > 0) ? Encoding.ASCII.GetString(receivedMessage.Buffer, 0, bytesRead) : string.Empty; if (bytesRead == receivedMessage.BufferSize) { BeginReceive(receivedMessage); } else { receivedMessage.DateTime = DateTime.Now; OnReceivedMessage(receivedMessage); _receiveDone.Set(); } } catch (Exception e) { Console.WriteLine(e.ToString()); } }
private void TransceiverOnMessageReceived(object sender, ReceivedMessageEventArgs e) { // A message is received -- handle it accordingly! ReceivedMessage message = e.Message; WriteLog("Message Received: " + message); }
private static void node_ReceivedMessage(object source, ReceivedMessageEventArgs args) { if (args.Message.Data.StartsWith("write")) { string data = args.Message.Data.Substring(5); int key = int.Parse(data.Split(' ')[0]); string value = data.Substring(data.Split(' ')[0].Length + 1); SetValue(key, value); } else if (args.Message.Data.StartsWith("read")) { int key = int.Parse(args.Message.Data.Substring(4)); if (database.ContainsKey(key)) { _node.SendResponse(args.Message, "y" + database[key]); } else { _node.SendResponse(args.Message, "n"); } } else if (args.Message.InResponseToMessage == false) { Console.WriteLine(args.Message.Data); } }
// Trigger for notifying reception of new message from Connect The Dots dashboard protected virtual void OnReceivedMessage(ReceivedMessageEventArgs e) { if (ReceivedMessage != null) { ReceivedMessage(this, e); } }
private void OnReceiveMsg(object sender, ReceivedMessageEventArgs args) { HandsetMsg msg; HandsetNotifyMsg notify = JsonConvert.DeserializeObject <HandsetNotifyMsg>(args.Message); switch (notify.MsgNotifyCode) { case HANDSETMSG_NOTIFY_CODE.MSG_NOTIFY_INFO: msg = JsonConvert.DeserializeObject <HandsetNotifyInfoMsg>(args.Message); break; case HANDSETMSG_NOTIFY_CODE.MSG_NOTIFY_CALLSTATE: msg = JsonConvert.DeserializeObject <HandsetNotifyCallStateMsg>(args.Message); break; default: msg = notify; break; } if (msg != null && MsgReceived != null) { MsgReceived(this, new HandsetMsgArgs(msg)); } }
private void Channel_ShellToastNotificationReceived(object sender, NotificationEventArgs e) { var conent = new ReceivedMessageEventArgs(string.Join(";", e?.Collection?.Select(x => x.Key + "=" + x.Value).ToArray() ?? new [] { string.Empty }), e?.Collection); var message = OnMessageReceived; message?.Invoke(null, conent); }
void lanHelper_UDPMessageRecieved(object sender, ReceivedMessageEventArgs e) { Debug.WriteLine("InAppDataEvent"); CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { chatTextBlock.Text = e.Message; }); }
/// <summary> /// Raises the message received event. /// </summary> /// <param name="args">Arguments.</param> protected virtual void OnMessageReceived(ReceivedMessageEventArgs args) { //logger.Debug(BitConverter.ToString(args.Data)); if (ReceivedMessage != null) { ReceivedMessage(this, args); } }
public void port_MessageReceived(object sender, ReceivedMessageEventArgs e) { try { var message = System.Text.Encoding.Default.GetString(e.Data); } catch (Exception ex) { Log.Trace(ex.Message, ex.StackTrace, configuration.Verbose); } }
private async Task ProcessNotification(ReceivedMessageEventArgs e) { if (e != null && e.Content != null) { PushNoticationMessage recdMessage = JsonConvert.DeserializeObject <PushNoticationMessage>(e.Content); await NavigationService.NavigateAsync("/Index/Navigation/Home"); } }
private void TtsHelperMessageReceived(object sender, ReceivedMessageEventArgs e) { DispatcherHelper.UIDispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { ReceivedMessages.Add(e.Message); }); }
protected virtual void OnReceivedMessage(ReceivedMessageEventArgs e) { EventHandler <ReceivedMessageEventArgs> handler = ReceivedMessage; if (handler != null) { handler?.Invoke(this, e); } }
public void MessageReceived(object sender, ReceivedMessageEventArgs e) { // A message is received -- handle it accordingly! ReceivedMessage message = e.Message; string messageText = UTF8Encoding.UTF8.GetString(e.Message.Buffer); Debug.WriteLine("MessageReceived {0} byte message {1}", e.Message.Buffer, messageText); }
private void InvokeReceivedMessageEvent(User sender, string message) { var args = new ReceivedMessageEventArgs { Sender = sender, Message = message }; ReceivedMessage?.Invoke(this, args); }
public bool OnMessage(object sender, ReceivedMessageEventArgs args) { GpsMessage msg = args.Message as GpsMessage; if (msg != null) { UpdateLocation(msg.DeviceId, msg.Latitude, msg.Longitude); } return(true); }
public void ReadCallback(IAsyncResult asyncResult) { ReceivedMessageEventArgs receivedMessage = (ReceivedMessageEventArgs)asyncResult.AsyncState; Socket clientSocket = receivedMessage.Socket; int bytesRead = clientSocket.EndReceive(asyncResult); receivedMessage.DateTime = DateTime.Now; receivedMessage.Message = (bytesRead > 0) ? Encoding.ASCII.GetString(receivedMessage.Buffer, 0, bytesRead) : string.Empty; OnReceivedMessage(receivedMessage); }
public bool OnMessage(object sender, ReceivedMessageEventArgs args) { GpsMessage msg = args.Message as GpsMessage; if (msg != null) { _mapData.UpdateLocation(msg.DeviceId, msg.Latitude, msg.Longitude); } //RedirectToAction("Index", "GpsTracking"); return(true); }
private void Receive(Socket socket) { try { var receivedMessage = new ReceivedMessageEventArgs(_bufferSize); receivedMessage.Socket = socket; receivedMessage.Message = string.Empty; BeginReceive(receivedMessage); } catch (Exception e) { Console.WriteLine(e.ToString()); } }
private async void TransceiverOnMessageReceived(object sender, ReceivedMessageEventArgs e) { // A message is received -- handle it accordingly! ReceivedMessage message = e.Message; WriteLog("Message Received: " + message); // In this example project, the message data is reversed and sent back. // Take the message received, reverse the bytes... byte[] response = message.Buffer.Reverse().ToArray(); // ...and send it back. await SendMessage(_transceiver, response, TimeSpan.FromSeconds(5)).ConfigureAwait(false); }
private Task ClientOnMessageReceived(SocketMessage msg) { var args = new ReceivedMessageEventArgs { Message = msg.Content, SenderUsername = msg.Author.Username, ChannelName = msg.Channel.Name, SenderAvatarUrl = msg.Author.GetAvatarUrl(), SenderId = msg.Author.Id, ChannelId = msg.Channel.Id, SenderReputation = 0 // TODO: Pull when reputation is implemented }; OnBotReceivedMessage?.Invoke(this, args); return(Task.CompletedTask); }
public void AcceptCallback(IAsyncResult asyncResult) { _allDone.Set(); Socket listener = (Socket)asyncResult.AsyncState; Socket clientSocket = listener.EndAccept(asyncResult); AddClientSocketToDictionary(clientSocket); Console.WriteLine($" - Client connected... {clientSocket.RemoteEndPoint}"); var receivedMessage = new ReceivedMessageEventArgs(_bufferSize); receivedMessage.Socket = clientSocket; clientSocket.BeginReceive(receivedMessage.Buffer, 0, receivedMessage.BufferSize, SocketFlags.None, new AsyncCallback(ReadCallback), receivedMessage); }
public bool OnMessage(object sender, ReceivedMessageEventArgs args) { BaseMessage msg = args.Message as BaseMessage; if (msg == null) { return(false); } switch (msg.MessageClass) { case "GpsMessage": ProcessGpsMessage(msg as GpsMessage); break; } return(true); }
void Server_OnReceivedMessage(object sender, ReceivedMessageEventArgs e) { int CrlfPosition = e.Message.LastIndexOf("\r\n"); e.Message = e.Message.Remove(CrlfPosition); if (e.Message.Contains("EXEC")) { lock (_sync) { _waitForCommand = false; } _logger.Info("READY TO EXEC", e.Message); } else { _clientArgs.Add(e.Message); _logger.Info("RCV : {0}", e.Message); } }
private void ReceivedMessageHandler(object sender, ReceivedMessageEventArgs e) { var msg = e.ReceivedMessage; switch (msg.MessageType) { case NetIncomingMessageType.StatusChanged: Events.OnGuiLogMessageEvent($"New status message: {e.ReceivedMessage.MessageType}:{(NetConnectionStatus)e.ReceivedMessage.ReadByte()} from {e.ReceivedMessage.SenderConnection}"); break; case NetIncomingMessageType.Data: var bytes = msg.ReadBytes(msg.LengthBytes); HandleDataMessage(bytes.Deserialize <Message>(), e.ReceivedMessage.SenderConnection); break; case NetIncomingMessageType.ConnectionApproval: e.ReceivedMessage.SenderConnection.Approve(); break; } }
public MessageEntry(ICoreDispatcher dispatcher, ReceivedMessageEventArgs receivedMessage) { ReceivedMessage = receivedMessage; Dispatcher = dispatcher; if (receivedMessage != null) { _via = receivedMessage.GetVia(); IsRequest = receivedMessage.GetHeaderValue(MessageBasicPropertiesHeaders.DIRECTION) != MessageBasicPropertiesHeaders.DIRECTION_VALUE_RESPONSE; if (_via == null) { _via = new ViaContainer() { queue = new Stack <ViaElement>() }; if (receivedMessage.Properties != null) { _via.queue.Push(new ViaElement() { appId = receivedMessage.Properties.AppId, messageId = receivedMessage.Properties.MessageId, mqWorkKind = ExchangeTypes.Get(receivedMessage.GetHeaderValue(MessageBasicPropertiesHeaders.WORKKIND)) ?? ExchangeTypes.EXCHANGETYPE_FANOUT, priority = receivedMessage.Properties.Priority, queryHandlerName = receivedMessage.Properties.ContentType, replyTo = receivedMessage.Properties.ReplyTo }); } } } else { _via = new ViaContainer() { queue = new Stack <ViaElement>() }; } }
// Trigger for notifying reception of new message from Connect The Dots dashboard protected virtual void OnReceivedMessage(ReceivedMessageEventArgs e) { if (ReceivedMessage != null) ReceivedMessage(this, e); }