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