public DeviceRegistryService(MqttService mqttService, ILogger <DeviceRegistryService> logger)
{
_mqttService = mqttService ?? throw new ArgumentNullException(nameof(mqttService));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_mqttService.Subscribe(null, "$wirehome/devices/+/report/+", OnPropertyReportedViaMqtt);
}
private void TimerOnTick(object sender, object e)
{
try
{
var movements = DataService.GetMovements();
foreach (var movement in movements)
{
try
{
dynamic movementDto = new JObject();
movementDto.CardId = movement.CardId;
movementDto.DeviceId = _deviceId;
movementDto.InLocation = movement.InLocation ? 1 : 0;
movementDto.SwipeTime = movement.SwipeTime;
MqttService.Publish(_topic, movementDto);
Debug.WriteLine("[MovementManager] Movement published!!");
DataService.DeleteMovement(movement.Id);
}
catch (Exception ex)
{
Debug.WriteLine("[MovementManager] TimerTick ERROR: {0}", ex.Message);
}
}
}
catch (Exception ex)
{
Debug.WriteLine("[MovementManager] TimerTick ERROR: {0}", ex.Message);
}
}
public MainPage()
{
this.DataContext = new MainPageViewModel();
mqttService = new MqttService();
devicePicker = new DevicePicker();
this.devicePicker.DeviceSelected += async(devicePicker, args) =>
{
var device = args.SelectedDevice;
devicePicker.Hide();
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
{
try
{
await mqttService.StartAsync();
await PairDeviceIfNecessary(device);
await ConnectIGrill(device);
Settings.SelectedDeviceId = device.Id;
} catch (Exception ex)
{
}
});
};
devicePicker.Filter.SupportedDeviceSelectors.Add(BluetoothLEDevice.GetDeviceSelectorFromPairingState(false));
devicePicker.Filter.SupportedDeviceSelectors.Add(BluetoothLEDevice.GetDeviceSelectorFromPairingState(true));
this.InitializeComponent();
}
public async Task <JObject> SetLightsAsync([FromBody] Light light)
{
try
{
if (light.Controller)
{
var context = new DatabaseContext();
context.Lights.Add(light);
context.SaveChanges();
}
else
{
var service = new MqttService();
GetLight newLight = new GetLight()
{
Animation = light.Animation, Brightness = light.Brightness, Color = light.Color
};
await service.SendMessageAsync("boominator", JObject.FromObject(newLight).ToString());
}
var value = "{ \"response\": \"success\" }";
return(JObject.Parse(value));
}
catch (Exception e)
{
var value = "{ \"response\": \"error " + e.Message + "\" }";
return(JObject.Parse(value));
}
}
void Setup()
{
Index = 0;
iot = new MqttService();
Devices = DeviceData.GetAllDevices();
LoadDesc(Index);
}
static void ConfigureMqttWebSocketEndpoint(IApplicationBuilder app, MqttService mqttService)
{
app.Use(async(context, next) =>
{
if (context.Request.Path == "/mqtt")
{
if (context.WebSockets.IsWebSocketRequest)
{
string subProtocol = null;
if (context.Request.Headers.TryGetValue("Sec-WebSocket-Protocol", out var requestedSubProtocolValues))
{
subProtocol = MqttSubProtocolSelector.SelectSubProtocol(requestedSubProtocolValues);
}
using (var webSocket = await context.WebSockets.AcceptWebSocketAsync(subProtocol).ConfigureAwait(false))
{
await mqttService.RunWebSocketConnectionAsync(webSocket, context).ConfigureAwait(false);
}
}
else
{
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
}
}
else
{
await next().ConfigureAwait(false);
}
});
}
static async Task Main(string[] args)
{
config = new ConfigurationBuilder()
.AddJsonFile("settings.json", true, true)
.AddJsonFile("local.settings.json", true, true)
.Build();
AppConstants.MqttHost = config["mqtt-host"];
AppConstants.MqttUser = config["mqtt-user"];
AppConstants.MqttPass = config["mqtt-pass"];
AppConstants.MqttTopic = config["mqtt-topic"];
if (mqttService == null)
{
mqttService = new MqttService();
}
mqttService.SubscribeTopic(new string[] { AppConstants.MqttTopic });
mqttService.OnMessageReceived += MqttService_OnMessageReceived;
//storageClient = new StorageClient(config);
//storageClient.InitialiseConnection();
if (parser == null)
{
parser = new Parser();
}
redis = new RedisDB(config["RedisCon"], 7);
Task task1 = new Task(StartAISReceiver);
task1.Start();
Console.WriteLine("receiver is running, press any key to stop.");
Console.ReadLine();
task1.Dispose();
}
private void cmbOpciones_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (cmbOpciones.SelectedItem != null)
{
MqttService.Publicar(topico, (cmbOpciones.SelectedItem as ComandosModel).Comando);
}
}
private void lstDispositivos_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
ActualizarDatos();
topico = $"SolucionIoTKobra/{model.DispositivoSeleccionado.Id}";
MqttService.Suscribir(topico);
btnActualizar.IsEnabled = true;
}
public MainPage()
{
InitializeComponent();
//TODO get config from
_movementManager = new MovementManager(2, 4);
_personManager = new PersonManager();
_personManager.PeopleReceivedEventHandler += new EventHandler <List <Person> >(PeopleReceived);
_pobCount = 0;
txtCount.Text = _pobCount.ToString();
PeopleOnBoard = new SortedObservableCollection <PobItem>();
DataContext = this;
_personService = new PersonService();
_dispatcher = Window.Current.Dispatcher;
//start background task to connect to card Reader.
var task = new Task(async() => await CreateNfcReader());
task.Start();
//Mqtt Service Connect
MqttService.Connect();
MqttService.MessageReceived += new EventHandler <Movement>(MovementMessage);
}
public Startup(IConfiguration configuration)
{
Configuration = configuration;
MqttService.Conectar("WEBKobra" + r.Next(0, 10000), "broker.hivemq.com");
MqttService.Conectado += MqttService_Conectado;
MqttService.MensajeRecibido += MqttService_MensajeRecibido;
}
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
_mqttService = new MqttService();
SetUpMain();
}
public async Task StartAsync(CancellationToken cancellationToken)
{
Console.WriteLine("Connect to MQTT Broker");
mqttService = new MqttService(_mqttconfig.Value.Server, _mqttconfig.Value.Port);
simulateData = new SimulateData(mqttService);
await DirectMethods.Init(simulateData);
}
public Synchronizer(MqttService mqtt, BridgeConfig mqttConfig, EndpointsManager smartthings, SmartthingsConfig stConfig, IScheduler scheduler)
{
_mqtt = mqtt;
_mqttConfig = mqttConfig;
_smartthings = smartthings;
_smartthingsConfig = stConfig;
_scheduler = scheduler;
}
static void ConfigureWebApps(
IApplicationBuilder app,
GlobalVariablesService globalVariablesService,
PackageManagerService packageManagerService,
MqttService mqttService)
{
var storagePaths = new StoragePaths();
var customContentRootPath = Path.Combine(storagePaths.DataPath, "CustomContent");
var packagesRootPath = Path.Combine(storagePaths.DataPath, "Packages");
var storageService = new StorageService(new JsonSerializerService(), new LoggerFactory().CreateLogger <StorageService>());
storageService.Start();
if (storageService.TryReadSerializedValue(out PackageManagerServiceOptions repositoryServiceOptions, PackageManagerServiceOptions.Filename))
{
if (!string.IsNullOrEmpty(repositoryServiceOptions.RootPath))
{
packagesRootPath = repositoryServiceOptions.RootPath;
}
}
if (!Directory.Exists(customContentRootPath))
{
Directory.CreateDirectory(customContentRootPath);
}
if (!Directory.Exists(packagesRootPath))
{
Directory.CreateDirectory(packagesRootPath);
}
app.Map("/upnp.xml", options =>
{
options.Run(async h =>
{
var upnpFilePath = Path.Combine(storagePaths.BinPath, "Discovery", "upnp.xml");
var upnpDefinition = await File.ReadAllBytesAsync(upnpFilePath).ConfigureAwait(false);
await h.Response.Body.WriteAsync(upnpDefinition).ConfigureAwait(false);
});
});
// Open the configurator by default if no path is specified.
var option = new RewriteOptions();
option.AddRedirect("^$", "/configurator");
app.UseRewriter(option);
ExposeDirectory(app, "/app", new PackageFileProvider(GlobalVariableUids.AppPackageUid, globalVariablesService, packageManagerService));
ExposeDirectory(app, "/configurator", new PackageFileProvider(GlobalVariableUids.AppPackageUid, globalVariablesService, packageManagerService));
ExposeDirectory(app, "/customContent", new PhysicalFileProvider(customContentRootPath));
ExposeDirectory(app, "/packages", new PhysicalFileProvider(packagesRootPath));
var webSocketOptions = new WebSocketOptions();
app.UseWebSockets(webSocketOptions);
ConfigureMqttWebSocketEndpoint(app, mqttService);
}
public void ConfigurationTest2()
{
var mqtt = new MqttService(_configuration);
mqtt.ConnectionStart();
InternalConfigurationTest(mqtt);
mqtt.ConnectionStop();
Assert.NotNull(mqtt);
}
public void ConfigurationTest(string login)
{
var builder = new UriBuilder(login);
var mqtt = new MqttService();
mqtt.ConnectionStart(builder.Uri);
mqtt.OnMessageReciver += Mqtt_OnMessageReciver;
InternalConfigurationTest(mqtt);
Assert.NotNull(mqtt);
}
private void InitClass()
{
_mqttService = new MqttService(this);
_youtubeService = new YoutubeService();
_textService = new SpeechToTextService();
_cloudStorageService = new CloudStorageService();
_textService.OnStatusChanged += _textService_OnStatusChanged;
_textService.OnTranscribeDone += _textService_OnTranscribeDone;
}
public PollingHostedService(ILogger <PollingHostedService> logger, ILupusecService lupusecService, IConfiguration configuration)
{
_logger = logger;
_lupusecService = lupusecService;
_configuration = configuration;
_conversionService = new ConversionService(_configuration, logger);
_mqttService = new MqttService(_configuration);
_cancellationTokenSource = new CancellationTokenSource();
}
public void GetConnectionStatusTest()
{
Task.Run(async() =>
{
IBusService.ConnectionStatus value;
using var mqtt = new MqttService();
var builder = new Uri("tcp://*****:*****@broker.mqttdashboard.com:1883/topic/bowling/MQTT_xUnitTests");
await mqtt.ConnectionStopAsync();
mqtt.OnMessageReciver += Mqtt_OnMessageReciver;
mqtt.OnConnection += Mqtt_OnConnection;
mqtt.OnStatusChange += (IBusService.ConnectionStatus arg1, IBusService.ConnectionInfo arg2) =>
{
Assert.Equal(arg2.BrokerUri, builder);
};
value = mqtt.GetConnectionStatus();
Assert.Equal(IBusService.ConnectionStatus.Disabled, value);
await mqtt.ConnectionStartAsync(builder);
value = mqtt.GetConnectionStatus();
Assert.Equal(IBusService.ConnectionStatus.Connected, value);
Assert.Null(mqtt.GetError());
InternalConfigurationTest(mqtt);
await mqtt.ConnectionStopAsync();
await Task.Delay(1000);
value = mqtt.GetConnectionStatus();
Assert.Equal(IBusService.ConnectionStatus.Disabled, value);
try
{
builder = new Uri("tcp://*****:*****@0.0.0.0:1883/topic/bowling/MQTT_xUnitTests");
value = mqtt.GetConnectionStatus();
Assert.Equal(IBusService.ConnectionStatus.Disabled, value);
await mqtt.ConnectionStartAsync(builder);
value = mqtt.GetConnectionStatus();
Assert.Equal(IBusService.ConnectionStatus.Error, value);
Assert.NotNull(mqtt.GetError());
}
finally
{
//ignore
}
}).GetAwaiter().GetResult();
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
iot = new MqttService();
}
BtnPass.Click += BtnPass_Click;
BtnMonster.Click += DoAction;
BtnTornado.Click += DoAction;
BtnPolice.Click += DoAction;
BtnScream.Click += DoAction;
BtnLedOff.Click += DoAction;
BtnLedOn.Click += DoAction;
BtnCCTVOn.Click += DoAction;
BtnCCTVOff.Click += DoAction;
BtnCCTVInterval.Click += DoAction;
BtnRelay1.Click += DoAction;
BtnRelay1Off.Click += DoAction;
BtnRelay2.Click += DoAction;
BtnRelay2Off.Click += DoAction;
WaterInBtn1.Click += DoAction;
WaterInBtn2.Click += DoAction;
WaterOutBtn1.Click += DoAction;
WaterOutBtn2.Click += DoAction;
BtnRelayAqua1.Click += DoAction;
BtnRelayAqua1Off.Click += DoAction;
BtnRelayAqua2.Click += DoAction;
BtnRelayAqua2Off.Click += DoAction;
BtnDrainageOn.Click += DoAction;
BtnDrainageOff.Click += DoAction;
BtnDrainageFillOn.Click += DoAction;
BtnDrainageFillOff.Click += DoAction;
BtnEmergency.Click += DoAction;
if (!IsPostBack)
{
var data = DeviceData.GetAllDevices();
RptControlDevice.DataSource = data;
RptControlDevice.DataBind();
}
}
// ReSharper disable once UnusedMember.Global
public void Configure(
IApplicationBuilder app,
HttpServerService httpServerService,
LogService logService,
ILoggerFactory loggerFactory,
IServiceProvider serviceProvider,
GlobalVariablesService globalVariablesService,
PackageManagerService packageManagerService,
MqttService mqttService)
{
if (app == null)
{
throw new ArgumentNullException(nameof(app));
}
if (httpServerService == null)
{
throw new ArgumentNullException(nameof(httpServerService));
}
if (logService == null)
{
throw new ArgumentNullException(nameof(logService));
}
if (loggerFactory == null)
{
throw new ArgumentNullException(nameof(loggerFactory));
}
if (mqttService == null)
{
throw new ArgumentNullException(nameof(mqttService));
}
loggerFactory.AddProvider(new LogServiceLoggerProvider(logService));
app.UseResponseCompression();
app.UseCors(p => p.AllowAnyOrigin().AllowAnyHeader().AllowAnyMethod());
ConfigureSwagger(app);
ConfigureWebApps(app, globalVariablesService, packageManagerService, mqttService);
ConfigureMvc(app);
app.Run(httpServerService.HandleRequestAsync);
StartServices(serviceProvider);
}
public void SendAndReciverMensageObjectNotConvert()
{
Task.Run(async() =>
{
var test1 = new KeyValuePair <int, int>(0, 1);
var test2 = new Version(1, 0, 0);
var result = default(Version);
using var mqtt = new MqttService(_configuration);
await mqtt.ConnectionStartAsync();
var value = mqtt.GetConnectionStatus();
Assert.Equal(IBusService.ConnectionStatus.Connected, value);
mqtt.OnObjectReciver <Version>((o) => { Assert.Equal(test2, o); });
mqtt.SendObject(test1);
await Task.Delay(2000);
Assert.Null(result);
mqtt.SendObject(test2);
await Task.Delay(2000);
}).GetAwaiter().GetResult();
}
public void OnGet(string id, string opcion)
{
Dispositivo = FactoryManager.DispositivoManager().BuscarPorId(id);
#if DEBUG
Random r = new Random();
FactoryManager.LecturaManager().Insertar(new Lectura()
{
IdDispositivo = id,
Temperatura = r.Next(2, 40),
Humedad = r.Next(0, 100),
Luminosidad = r.Next(0, 1024)
});
#endif
Lecturas = FactoryManager.LecturaManager().LecturasDelDispositivo(id).ToList();
if (opcion != null)
{
MqttService.Publicar("SolucionIoT/" + id, opcion);
}
Opciones = new Dictionary <string, string>
{
{ "R11", $"Encender {Dispositivo.UsoRelevador1}" },
{ "R10", $"Apagar {Dispositivo.UsoRelevador1}" },
{ "R21", $"Encender {Dispositivo.UsoRelevador2}" },
{ "R20", $"Apagar {Dispositivo.UsoRelevador2}" },
{ "R31", $"Encender {Dispositivo.UsoRelevador3}" },
{ "R30", $"Apagar {Dispositivo.UsoRelevador3}" },
{ "R41", $"Encender {Dispositivo.UsoRelevador4}" },
{ "R40", $"Apagar {Dispositivo.UsoRelevador4}" },
{ "B1", $"Encender {Dispositivo.UsoBuzzer}" },
{ "B0", $"Apagar {Dispositivo.UsoBuzzer}" }
};
}
public PanelUsuario(Usuario usuario)
{
InitializeComponent();
this.SizeChanged += PanelUsuario_SizeChanged;
timer = new DispatcherTimer
{
Interval = new TimeSpan(0, 0, 0, 0, 100)
};
timer.Start();
timer.Tick += Timer_Tick;
r = new Random();
MqttService.Conectar("SolucionIoTWPF" + r.Next(0, 100000).ToString(), "broker.hivemq.com");
MqttService.Conectado += MqttService_Conectado;
MqttService.MensajeRecibido += MqttService_MensajeRecibido;
MqttService.Error += MqttService_Error;
MqttService.Mensaje += MqttService_Mensaje;
model = this.DataContext as PanelUsuarioModel;
model.Usuario = usuario;
model.Dispositivos = FactoryManager.DispositivoManager().DispositivosDeUsuarioPorId(usuario.Id).ToList();
lstDispositivos.ItemsSource = null;
lstDispositivos.ItemsSource = model.Dispositivos;
topico = "";
}
public MqttController(MqttService mqttService)
{
_mqttService = mqttService ?? throw new ArgumentNullException(nameof(mqttService));
}
public MqttPythonProxy(MqttService mqttService)
{
_mqttService = mqttService ?? throw new ArgumentNullException(nameof(mqttService));
}
public DispositivoTabbedPage(PanelUsuarioModel model)
{
InitializeComponent();
r = new Random();
log = new List <string>();
this.model = model;
this.BindingContext = model;
model.LecturasDelDispositivo = FactoryManager.LecturaManager().LecturasDelDispositivo(model.DispositivoSeleccionado.Id).ToList();
MqttService.Conectar("SolucionIoTMovil" + r.Next(0, 1000).ToString(), "broker.hivemq.com");
MqttService.Conectado += MqttService_Conectado;
MqttService.Error += MqttService_Error;
MqttService.Mensaje += MqttService_Mensaje;
MqttService.MensajeRecibido += MqttService_MensajeRecibido;
model.LecturasDelDispositivo = FactoryManager.LecturaManager().LecturasDelDispositivo(model.DispositivoSeleccionado.Id).OrderBy(e => e.FechaHora).ToList();
lstLecturas.ItemsSource = null;
lstLecturas.ItemsSource = model.LecturasDelDispositivo;
topico = "SolucionIoTKobra/" + model.DispositivoSeleccionado.Id;
LlenarComandos();
Graficar();
mensajeRecibido = null;
Device.StartTimer(TimeSpan.FromMilliseconds(100), () =>
{
lstLog.ItemsSource = null;
lstLog.ItemsSource = log;
if (mensajeRecibido != null)
{
if (mensajeRecibido.Topico == topico)
{
log.Add($"<{ mensajeRecibido.Mensaje}");
if (mensajeRecibido.Mensaje.Contains("="))
{
string[] parte = mensajeRecibido.Mensaje.Split('=');
switch (parte[0])
{
case "B":
lblEB.Text = parte[1] == "1" ? "Encendido" : "Apagado";
break;
case "R1":
lblER1.Text = parte[1] == "1" ? "Encendido" : "Apagado";
break;
case "R2":
lblER2.Text = parte[1] == "1" ? "Encendido" : "Apagado";
break;
case "R3":
lblER3.Text = parte[1] == "1" ? "Encendido" : "Apagado";
break;
case "R4":
lblER4.Text = parte[1] == "1" ? "Encendido" : "Apagado";
break;
case "R":
lblER1.Text = parte[1][0] == '1' ? "Encendido" : "Apagado";
lblER2.Text = parte[1][1] == '1' ? "Encendido" : "Apagado";
lblER3.Text = parte[1][2] == '1' ? "Encendido" : "Apagado";
lblER4.Text = parte[1][3] == '1' ? "Encendido" : "Apagado";
break;
case "M":
lblEM.Text = DateTime.Now.ToShortTimeString();
break;
default:
break;
}
}
}
mensajeRecibido = null;
}
return(true);
});
Thread.Sleep(2000);
MqttService.Suscribir("SolucionIoTKobra/" + model.DispositivoSeleccionado.Id);
}
private void btnB0_Clicked(object sender, EventArgs e)
{
MqttService.Publicar(topico, "B0");
}
private void btnActualizar_Clicked(object sender, EventArgs e)
{
MqttService.Publicar(topico, "?R");
Thread.Sleep(2000);
MqttService.Publicar(topico, "?B");
}
