public async Task SendMessage(Action action, Sensor sensor, double value)
{
var typedMessage = new TypedMessage();
var taskDescriptor = new TaskDescriptor();
var actionDescriptor = new ActionDescriptor();
actionDescriptor.Parameter = "true";
actionDescriptor.Type = Action.Indication;
taskDescriptor.Action = actionDescriptor;
var conditionDescriptor = new ConditionDescriptor();
conditionDescriptor.ComparisonType = Condition.GreaterThan;
conditionDescriptor.SensorType = sensor;
conditionDescriptor.Target = value;
taskDescriptor.Condition = conditionDescriptor;
taskDescriptor.DeviceId = "raspberry1";
typedMessage.Data = taskDescriptor;
typedMessage.Type = AutomationSystemCore.Management.MessageHeaders.CreateTask;
string connectionString = "HostName=AutomationSystemHub.azure-devices.net;DeviceId=test;SharedAccessKey=O/B4sln1uG0KmnBeSeEZoxbVODL27q5coJmd8G/z2s4=";
var deviceClientSend = DeviceClient.CreateFromConnectionString(connectionString);
var messageString = JsonConvert.SerializeObject(typedMessage);
var message = new Microsoft.Azure.Devices.Client.Message(Encoding.ASCII.GetBytes(messageString));
await deviceClientSend.SendEventAsync(message);
Debug.WriteLine("{0} > Sending message: {1}", DateTime.Now, messageString);
}
public static TypedMessage FromByteArray(byte[] data)
{
TypedMessage packet = new TypedMessage();
using (MemoryStream ms = new MemoryStream(data, false))
using (BinaryReader reader = new BinaryReader(ms))
{
packet.messageType = reader.ReadByte();
packet.message = reader.ReadBytes(data.Length - 1);
return(packet);
}
}
private void NewAliveServer(Guid server_id)
{
ServerData server_data = DatabaseHelper.GetServerByID(database, server_id);
if (server_data == null)
{
log.Append(String.Format("Sending description request for {0}", server_id));
TypedMessage requestMessage = new TypedMessage(MessageType.DescriptionRequest, ClientID.ToByteArray());
networkNode.SendDirect(requestMessage.GetBytes(), server_id);
}
else
{
log.Append(String.Format("Using database description for {0}", server_id));
AddAliveServer(server_data);
}
}
private async void InsertLink_click()
{
try
{
string pattern = @"^(ht|f)tp(s?)\:\/\/[0-9a-zA-Z]([-.\w]*[0-9a-zA-Z])*(:(0-9)*)*(\/?)([a-zA-Z0-9\-\.\?\,\'\/\\\+&%\$#_]*)?$";
if (TypedMessage.Contains("\n"))
{
var messge = TypedMessage.Replace("\n", null);
TypedMessage = messge;
}
if (!string.IsNullOrEmpty(Link))
{
var m = Regex.Match(Link, pattern, RegexOptions.IgnoreCase | RegexOptions.Compiled, TimeSpan.FromSeconds(1));
if (m.Success)
{
if (!string.IsNullOrEmpty(TypedMessage))
{
TypedMessage = TypedMessage + "\n" + Link;
}
else
{
TypedMessage = Link;
}
App.Link = Link;
Link = null;
await ClosePopup();
}
else
{
LinkValidationText = "Invalid Link";
isValidationVisible = true;
}
}
else
{
LinkValidationText = "Link field is required";
isValidationVisible = true;
}
}
catch (Exception ex)
{
Debug.WriteLine($"Exception: { ex.Message}");
}
}
private void DigestMessage(TypedMessage msg)
{
switch (msg.Type)
{
case MessageHeaders.CreateTask:
TaskDescriptor desc = ((JObject)msg.Data).ToObject <TaskDescriptor>();
AutomationTask newTask = new AutomationTask(thisDevice)
{
Id = "0",
DeviceSensor = desc.Condition.SensorType,
TaskCondition = desc.Condition.ComparisonType,
Value = desc.Condition.Target,
ActionType = desc.Action.Type,
ActionParameter = desc.Action.Parameter,
};
asdf = DateTime.Now;
tasks.Add(newTask);
break;
}
}
private void OnPacketReceived(DataPacket dataPacket)
{
TypedMessage msg = TypedMessage.FromByteArray(dataPacket.payload);
if (dataPacket.channel < (byte)EStreamChannel.KEstreamChannelDataChannelStart)
{
if (dataPacket.channel == (byte)EStreamChannel.KEstreamChannelDiscovery)
{
throw new NotImplementedException();
}
else if (dataPacket.channel == (byte)EStreamChannel.KEstreamChannelControl)
{
ProcessControlMessage((EStreamControlMessage)msg.messageType, msg.message);
}
else if (dataPacket.channel == (byte)EStreamChannel.KEstreamChannelStats)
{
ProcessStatsMessage((EStreamStatsMessage)msg.messageType, msg.message);
}
}
else
{
ProcessStreamDataMessage(dataPacket.channel, (EStreamDataMessage)msg.messageType, msg.message);
}
}
void networkNode_MessageReceived(object sender, MessageEventArgs args)
{
try
{
log.Append("networkNode_MessageReceived", String.Format("Message Received from {0}", args.SenderID.ToString()));
TypedMessage message = new TypedMessage(args.Data, args.Data.GetLength(0));
switch (message.type)
{
case MessageType.AliveMessage:
ProcessAliveMessage(args.SenderID, message.data);
break;
case MessageType.DescriptionMessage:
ProcessDescriptionMessage(args.SenderID, message);
break;
default:
break;
}
}
catch (Exception ex)
{
log.LogException(ex, "Exception when processing message");
MessageBox.Show(ex.Message, "Exception :(");
}
}
public void HandleIncomingMessage(TypedMessage<TestMessage> message)
{
var contents = message.Value;
Trace.WriteLine(contents.MessageIdentifier);
}
private void RecvThread()
{
while (Active)
{
try
{
var from = new IPEndPoint(0, 0);
var recvBuffer = udpClient.Receive(ref from);
if (recvBuffer == null || recvBuffer.Length == 0)
{
continue;
}
NetworkPacket packet = NetworkPacket.FromByteArray(recvBuffer);
if ((packet.from != remoteId && packet.from != 0) || (packet.to != localId && packet.to != 0))
{
continue;
}
switch (packet.packetType)
{
case PacketType.SYN:
case PacketType.SYN_ACK:
throw new InvalidOperationException();
case PacketType.FIN:
SendRawPacket(new NetworkPacket()
{
packetType = PacketType.FIN,
from = localId,
to = remoteId
});
Reset();
break;
case PacketType.Raw:
if (packet.channel != (byte)EStreamChannel.KEstreamChannelDiscovery)
{
throw new InvalidOperationException();
}
TypedMessage msg = TypedMessage.FromByteArray(packet.payload);
EStreamDiscoveryMessage msgType = (EStreamDiscoveryMessage)msg.messageType;
switch (msgType)
{
case EStreamDiscoveryMessage.KEstreamDiscoveryPingRequest:
msg.messageType = (byte)EStreamDiscoveryMessage.KEstreamDiscoveryPingResponse;
SendRawPacket(new NetworkPacket()
{
packetType = PacketType.Raw,
from = packet.to,
to = packet.from,
channel = (byte)EStreamChannel.KEstreamChannelDiscovery,
payload = msg.ToByteArray()
});
break;
default:
throw new InvalidOperationException();
}
break;
case PacketType.Reliable:
case PacketType.ReliableFragment:
case PacketType.Unreliable:
case PacketType.UnreliableFragment:
ChannelData channelData = channels.GetOrNew(packet.channel);
if (!channelData.receiveQueue.ContainsKey(packet.seq))
{
channelData.receiveQueue.Add(packet.seq, packet);
if (packet.seq < channelData.remoteSeq)
{
Console.WriteLine("WARNING! Late packet " + packet.seq + " we are already at " + channelData.remoteSeq);
}
}
else
{
Console.WriteLine("WARNING! Got a resend of " + packet.seq);
}
// TODO: Clear the recv queue
ushort?lastValidPacketSeq = channelData.remoteSeq > 0 ? (ushort)(channelData.remoteSeq - 1) : (ushort?)null;
bool droppedIncompletePacket = false;
foreach (NetworkPacket firstPacket in channelData.receiveQueue.Values)
{
if (firstPacket.seq < channelData.remoteSeq)
{
continue;
}
if (firstPacket.packetType == PacketType.ReliableFragment || firstPacket.packetType == PacketType.UnreliableFragment)
{
continue;
}
// Check if the packet has all the fragments
bool isComplete = true;
for (ushort neededSeq = firstPacket.seq; neededSeq <= firstPacket.seq + firstPacket.fragment; ++neededSeq)
{
if (!channelData.receiveQueue.ContainsKey(neededSeq))
{
isComplete = false;
break;
}
else
{
lastValidPacketSeq = neededSeq;
}
}
if (!isComplete)
{
// The packet is not yet fully complete
if (firstPacket.packetType == PacketType.Unreliable)
{
droppedIncompletePacket = true;
continue; // this is unreliable so check if maybe next packet is complete
}
else
{
break; // we cannot skip any packet on reliable transports
}
}
if (channelData.remoteSeq != firstPacket.seq)
{
Console.WriteLine("WARNING! Dropping unreliable packets! Jump from " + channelData.remoteSeq + " to " + firstPacket.seq + (droppedIncompletePacket ? " (previous incomplete)" : ""));
}
// We have a complete packet, receive it
List <NetworkPacket> reassembleList = new List <NetworkPacket>();
for (ushort seq = firstPacket.seq; seq <= firstPacket.seq + firstPacket.fragment; ++seq)
{
if (seq != firstPacket.seq)
{
if (firstPacket.packetType == PacketType.Reliable)
{
Debug.Assert(channelData.receiveQueue[seq].packetType == PacketType.ReliableFragment);
}
else if (firstPacket.packetType == PacketType.Unreliable)
{
Debug.Assert(channelData.receiveQueue[seq].packetType == PacketType.UnreliableFragment);
}
else
{
Debug.Assert(false);
}
}
reassembleList.Add(channelData.receiveQueue[seq]);
}
DataPacket dataPacket = ReassembleDataPacket(reassembleList);
try
{
OnPacketReceived?.Invoke(dataPacket);
}
catch (Exception e)
{
Console.WriteLine(e);
}
channelData.remoteSeq = (ushort)(firstPacket.seq + firstPacket.fragment + 1);
}
if ((packet.packetType == PacketType.Reliable || packet.packetType == PacketType.ReliableFragment) && lastValidPacketSeq.HasValue)
{
using (MemoryStream ms = new MemoryStream())
using (BinaryWriter writer = new BinaryWriter(ms))
{
writer.Write(channelData.receiveQueue[lastValidPacketSeq.Value].timestamp);
writer.Flush();
SendRawPacket(new NetworkPacket()
{
packetType = PacketType.ReliableACK,
from = localId,
to = remoteId,
channel = packet.channel,
seq = lastValidPacketSeq.Value,
payload = ms.ToArray()
});
}
}
break;
case PacketType.ReliableACK:
//Console.WriteLine("ACKed channel=" + packet.channel + ", seq=" + packet.seq);
// TODO
break;
}
}
catch (SocketException)
{
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
}
private async Task SendMessage()
{
try
{
if (TypedMessage == null || TypedMessage == "" || string.IsNullOrWhiteSpace(TypedMessage))
{
return;
}
else
{
var message = !string.IsNullOrEmpty(TypedMessage.Trim()) ? TypedMessage.Trim() : string.Empty;
var values = new Dictionary <object, object>
{
{ "author", userId },
{ "threadId", threadId },
{ "plainContent", message },
{ "createdDate", DateTime.Now.ToUniversalTime() },
{ "memoToFile", null },
{ "sendToOfficer", false },
};
httpClient = new HttpClient();
var content = new StringContent(JsonConvert.SerializeObject(values), Encoding.UTF8, "application/json");
var response = await httpClient.PostAsync(Config.SAVE_MESSAGE_API, content);
if (response.StatusCode != System.Net.HttpStatusCode.OK || response.Content == null)
{
await ClosePopup();
Device.BeginInvokeOnMainThread(async() =>
{
await ShowAlert("Data Not Sent!!", string.Format("Response contained status code: {0}", response.StatusCode));
});
}
else
{
await ClosePopup();
var content1 = await response.Content.ReadAsStringAsync();
Debug.WriteLine(content1);
TypedMessage = null;
Settings.TypedMessage = TypedMessage;
MessageReplayViewModel thisVm = new MessageReplayViewModel();
await FetchThreadUserData();
//await SendThreadUsersAsync();
//await ShowAlertWithAction("Success", content1, "Ok", "Cancel");
//var yesSelected = await DisplayAlert("Simon", content, "Ok", "Cancel"); // the call is awaited
//if (yesSelected) // No compile error, as the result will be bool, since we awaited the Task<bool>
//{
// await Navigation.PopToRootAsync();
//}
//else { return; }
}
}
}
catch (Exception ex)
{
await ClosePopup();
ShowExceptionAlert(ex);
}
finally
{
await ClosePopup();
}
}
private void ProcessDescriptionMessage(Guid sender_id, TypedMessage message)
{
log.Append("ProcessDescriptionMessage", String.Format("Description from {0}", sender_id.ToString()));
DescriptionMessage description = new DescriptionMessage(message.data);
if (aliveServers.GetItem(sender_id) == null)
{
bool alreadySaved = DatabaseHelper.GetServerSaved(database, sender_id);
ServerData serverData = new ServerData(sender_id, description.Name, description.Location, description.Description, description.Sensors, description.PictureBytes);
if (alreadySaved == false)
{
DatabaseHelper.SaveServerConfigData(database, serverData);
}
AddAliveServer(serverData);
}
log.Append("ProcessDescriptionMessage", String.Format("Description from {0} at {1}", description.Name, sender_id.ToString()));
//MessageBox.Show(String.Format("Description from {0} at {1}", description.Name, sender.ToString()));
}
private void SendAliveMessage(object ob)
{
TypedMessage message = new TypedMessage(MessageType.AliveMessage, BitConverter.GetBytes((Int64)DateTime.UtcNow.Ticks));
networkNode.Send(message.GetBytes());
}
void networkNode_MessageReceived(object sender, MessageEventArgs args)
{
log.Append("networkNode_MessageReceived", String.Format("Message Received from {0}", args.SenderID.ToString()));
TypedMessage message = new TypedMessage(args.Data, args.Data.Length);
switch (message.type)
{
case MessageType.DescriptionRequest:
log.Append("networkNode_MessageReceived", "Description Request received");
DescriptionMessage description = new DescriptionMessage(CurrentServerData);
TypedMessage reply = new TypedMessage(MessageType.DescriptionMessage, description.GetBytes());
networkNode.SendDirect(reply.GetBytes(), args.SenderID);
break;
default:
break;
}
}
public void TypedMessageOperation(TypedMessage typedMessage)
{
}
