private void Button_Clicked(object sender, EventArgs e)
{
IPlatformMessage service = DependencyService.Get <IPlatformMessage>();
string message = service.getMessage();
DisplayAlert("DependeencyService", message, "OK");
}
private bool MatchTrigger(IPlatformMessage message, NetworkEvent evt, SensorTrigger info, ref bool textTriggered, ref bool measurementTriggered)
{
if (!this.VerifySensorTrigger(message, info))
{
return(false);
}
evt.Actions.Add(NetworkEventType.MessageTriggered);
if (!textTriggered && info.IsTextTrigger)
{
textTriggered = true;
this.EnqueueToTriggerService(message);
}
else if (!measurementTriggered && !info.IsTextTrigger)
{
measurementTriggered = true;
this.EnqueueToTriggerService(message);
}
if (textTriggered && measurementTriggered)
{
this.m_logger.LogDebug($"Skipping trigger for {message.SensorID}: already queued");
return(true);
}
return(false);
}
private void InternalRoute(IPlatformMessage message)
{
using (this.m_duration.NewTimer()) {
var sensor = this.m_cache[message.SensorID];
this.ProcessMessage(sensor, message);
}
}
private void RouteMessage(IPlatformMessage message, Sensor sensor)
{
var @event = CreateNetworkEvent(sensor);
this.m_counter.Inc();
message.PlatformTimestamp = DateTime.UtcNow;
foreach (var router in this.m_routers)
{
bool result;
try {
this.m_logger.LogDebug("Routing message to the {routerName}", router.Name);
result = router.Route(sensor, message, @event);
} catch (RouterException ex) {
result = false;
this.m_logger.LogWarning(ex, "Unable to route message for sensor {sensorId} using router {routerName}",
message.SensorID.ToString(), router.Name);
}
if (!result)
{
this.LogDroppedMessage(router, @event);
break;
}
this.m_logger.LogDebug("Routing by the {routerName} finished", router.Name);
}
@event.Actions.Add(NetworkEventType.MessageRouted);
this.m_eventQueue.EnqueueEvent(@event);
}
public bool Route(Sensor sensor, IPlatformMessage message, NetworkEvent networkEvent)
{
if (message.Type != MessageType.ControlMessage)
{
return(true);
}
this.m_counter.Inc();
return(this.ProcessMessage(sensor, message as ControlMessage));
}
private bool VerifySensorTrigger(IPlatformMessage message, SensorTrigger info)
{
if (!info.HasActions)
{
this.m_logger.LogDebug($"Skipping message from sensor {message.SensorID}: no actions available");
return(false);
}
return((!info.IsTextTrigger || message.Type == MessageType.Message) && (info.IsTextTrigger || message.Type == MessageType.Measurement));
}
public int SendPlatformMessage(string endpointArn, Platform platform, String message)
{
IPlatformMessage msg = BuildPlatformMessage(platform, message);
if (msg != null)
{
return(SendPlatformMessage(endpointArn, msg));
}
return(0);
}
public void EnqueueMessageToTarget(IPlatformMessage message, RoutingTarget target)
{
this.m_liveDataLock.Lock();
try {
this.m_textMessageQueues[target.Target].Messages.Add(MessageProtobufConverter.Convert(message as Message));
this.m_gaugeLiveDataService.Inc();
} finally {
this.m_liveDataLock.Unlock();
}
}
public void EnqueueMeasurementToTriggerService(IPlatformMessage message)
{
this.m_measurementLock.Lock();
try {
this.m_triggerMeasurements.Measurements.Add(MeasurementProtobufConverter.Convert(message as Measurement));
this.m_gaugeTriggerSerivce.Inc();
} finally {
this.m_measurementLock.Unlock();
}
}
private void ProcessMessage(Sensor sensor, IPlatformMessage message)
{
if (!this.VerifySensor(message.SensorID, sensor))
{
this.m_dropCounter.Inc();
return;
}
this.m_logger.LogDebug("Routing message of type {type} for sensor {sensorId}", message.Type.ToString("G"), sensor.ID.ToString());
this.RouteMessage(message, sensor);
}
public bool Route(Sensor sensor, IPlatformMessage message, NetworkEvent networkEvent)
{
var account = this.m_cache.GetAccount(sensor.AccountID);
var key = this.m_cache.GetApiKey(sensor.SensorKey);
var result = this.VerifySensor(sensor) && this.IsValidSensor(sensor, account, key);
if (!result)
{
this.m_logger.LogInformation("Dropping message for sensor {sensorId}: authorization failed", sensor.ID.ToString());
}
return(result);
}
public void Enqueue(IPlatformMessage message)
{
if (message.Type == MessageType.Measurement)
{
this.m_measurements.Add(message as Measurement);
}
else
{
this.m_messages.Add(message as Message);
}
this.m_gauge.Inc();
}
public bool Route(Sensor sensor, IPlatformMessage message, NetworkEvent networkEvent)
{
if (!this.ShouldStoreMessage(sensor, message))
{
return(true);
}
this.m_counter.Inc();
this.m_storageQueue.Enqueue(message);
networkEvent.Actions.Add(NetworkEventType.MessageStorage);
return(true);
}
private bool ProcessMessage(Sensor sensor, IPlatformMessage message, NetworkEvent evt)
{
this.m_liveDataCounter.Inc();
evt.Actions.Add(NetworkEventType.MessageLiveData);
var routes = sensor.LiveDataRouting.ToList(); // Take a snapshot
foreach (var info in routes)
{
this.EnqueueTo(message, info);
}
return(true);
}
private void EnqueueToTriggerService(IPlatformMessage message)
{
this.m_counter.Inc();
switch (message.Type)
{
case MessageType.Measurement:
this.m_internalRemote.EnqueueMeasurementToTriggerService(message);
break;
case MessageType.Message:
this.m_internalRemote.EnqueueMessageToTriggerService(message);
break;
}
}
public bool Route(Sensor sensor, IPlatformMessage message, NetworkEvent networkEvent)
{
if (this.Cancel)
{
return(false);
}
if (this.Exception != null)
{
throw this.Exception;
}
this.Executed = true;
return(true);
}
private bool ShouldStoreMessage(Sensor sensor, IPlatformMessage message)
{
if (!sensor.StorageEnabled)
{
this.m_logger.LogDebug("Skipping storage for {sensorId}: storage not enabled", sensor.ID.ToString());
return(false);
}
if (message.Type == MessageType.ControlMessage)
{
this.m_logger.LogDebug("Skipping storage for {sensorId}: message is of type Control Message", sensor.ID.ToString());
return(false);
}
return(true);
}
private void ProcessMessage(Sensor sensor, IPlatformMessage message, NetworkEvent evt)
{
var textTriggered = false;
var measurementTriggered = false;
var triggers = sensor.TriggerInformation.ToList(); // Snap shot
foreach (var info in triggers)
{
var done = this.MatchTrigger(message, evt, info, ref textTriggered, ref measurementTriggered);
if (done)
{
break;
}
}
}
public bool Route(Sensor sensor, IPlatformMessage message, NetworkEvent networkEvent)
{
if (message.Type == MessageType.ControlMessage)
{
return(true);
}
if (sensor.TriggerInformation == null || sensor.TriggerInformation.Count <= 0)
{
this.m_logger.LogDebug($"Skipping the trigger router for sensor {sensor.ID}: no triggers available");
return(true);
}
this.ProcessMessage(sensor, message, networkEvent);
return(true);
}
public bool Route(Sensor sensor, IPlatformMessage message, NetworkEvent networkEvent)
{
if (sensor.LiveDataRouting == null || sensor.LiveDataRouting?.Count <= 0)
{
return(true);
}
switch (message.Type)
{
case MessageType.Measurement:
case MessageType.Message:
case MessageType.ControlMessage:
return(this.ProcessMessage(sensor, message, networkEvent));
default:
throw new RouterException(this.Name, $"unable to route message of type {message.Type:G}");
}
}
private void EnqueueTo(IPlatformMessage message, RoutingTarget target)
{
switch (message.Type)
{
case MessageType.ControlMessage:
this.m_logger.LogDebug("Queueing control message to {target}", target.Target);
this.m_internalQueue.EnqueueControlMessageToTarget(message, target);
break;
case MessageType.Message:
this.m_logger.LogDebug("Queueing message to {target}", target.Target);
this.m_internalQueue.EnqueueMessageToTarget(message, target);
break;
case MessageType.Measurement:
this.m_logger.LogDebug("Queueing measurement to {target}", target.Target);
this.m_internalQueue.EnqueueMeasurementToTarget(message, target);
break;
}
}
public bool Route(Sensor sensor, IPlatformMessage message, NetworkEvent networkEvent)
{
switch (message.Type)
{
case MessageType.Measurement:
networkEvent.MessageType = NetworkMessageType.Measurement;
break;
case MessageType.Message:
networkEvent.MessageType = NetworkMessageType.Message;
break;
case MessageType.ControlMessage:
networkEvent.MessageType = NetworkMessageType.ControlMessage;
break;
default:
this.m_logger.LogWarning("Unable to determine message type of type {type}. Integer value: {integerValue}.",
message.Type.ToString("G"), message.Type.ToString("D"));
throw new RouterException(this.Name, $"invalid message type {message.Type}");
}
return(true);
}
public int SendPlatformMessage(string endpointArn, IPlatformMessage message)
{
return(SendMessage(endpointArn, message.ToString()));
}
