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