public static List <MQTTMessage> GetUnreadMessagesByGmail(string gmail)
        {
            MessengerDataContext dc = new MessengerDataContext();

            List <MQTTMessage> mqttMessageList = new List <MQTTMessage>();

            IQueryable <Message> messageList = from messages in dc.Messages
                                               join users in dc.Users on
                                               messages.ToID equals users.ID
                                               where users.gmail == gmail &&
                                               messages.SendingPending
                                               select messages;

            foreach (Message message in messageList)
            {
                MQTTMessage mqttMessage = new MQTTMessage();
                mqttMessage.gmail   = GetGmailByID(message.FromID);
                mqttMessage.message = message.Text;
                mqttMessage.time    = message.Time.ToString();

                mqttMessageList.Add(mqttMessage);
            }

            return(mqttMessageList);
        }
        private MQTTMessage GetPeerMessage(string toInstanceId = "ALL", string type = "INSTANCE_CONNECTED")
        {
            var myPeerData = new MQTTPeerMessageContent()
            {
                PeerId        = Program.InstanceConfig.ServerInstanceID,
                DiscoveryUrls = string.Format("http://{0}/eureka/apps", Program.InstanceConfig.Urls),
                InstanceIP    = Program.INSTANCE_IP,
                InstancePort  = Program.INSTANCE_PORT
            };

            var jsonPeer = JsonConvert.SerializeObject(myPeerData).Replace("\"", "'");

            var destInstances = new List <string>();

            destInstances.Add(toInstanceId);

            var newPeerMessage = new MQTTMessage()
            {
                FromInstanceId = Program.InstanceConfig.ServerInstanceID,
                ToInstancesIds = destInstances,
                Type           = type,
                Message        = jsonPeer
            };

            return(newPeerMessage);
        }
Exemple #3
0
        public void PublishDeletedInstance(string tenantId, string appName, string instanceId)
        {
            var toIds = GetPeerIds();

            if (toIds.Count == 0)
            {
                return;
            }

            var deleteMessage = new MQTTInstanceDeleteMessageContent()
            {
                AppName    = appName,
                TenantId   = tenantId,
                InstanceId = instanceId
            };

            var jsonMessage = JsonConvert.SerializeObject(deleteMessage);

            jsonMessage = jsonMessage.Replace("\"", "'");

            var mqttMessage = new MQTTMessage()
            {
                FromInstanceId = Program.InstanceConfig.ServerInstanceID,
                ToInstancesIds = toIds,
                Type           = "DELETE_INSTANCE",
                Message        = jsonMessage
            };

            _mqttService.SendMQTTMessageToMultipleInstances(tenantId, toIds, mqttMessage);
        }
        public void SendMQTTMessageToInstance(string tenantId, string toInstanceId, MQTTMessage message)
        {
            Task task = Task.Factory.StartNew(async() =>
            {
                MqttClientPublishResult res = null;

                var myMqttClient = _mqttClients.SingleOrDefault(c => (c.TenantId + "-" + c.TenantType).CompareTo(tenantId) == 0);

                message.ToInstancesIds = new List <string>();
                message.ToInstancesIds.Add(toInstanceId);

                string jsonMessage = JsonConvert.SerializeObject(message);

                if (myMqttClient != null && myMqttClient.mqttClient.IsConnected)
                {
                    res = await myMqttClient.mqttClient.PublishAsync(myMqttClient.mqttTopic, jsonMessage, MyMQTTClient.MQTTQualityOfService);
                    InstanceHealthService.Health.MQTTMessagesSent += 1;
                }
                else
                {
                    if (MQTTSendQueue.CheckIfMQTTIsConfigured())
                    {
                        MQTTSendQueue.MessagesToSend.Add(new MQTTQueueMessage()
                        {
                            Topic         = myMqttClient.mqttTopic,
                            QueuedMessage = jsonMessage,
                            QoS           = MyMQTTClient.MQTTQualityOfService
                        });
                    }
                }

                return(res);
            });
        }
        public void Notify(MQTTMessage msg)
        {
            //Set up an intent so that tapping the notification returns to this app
            Intent intent = new Intent(ctx, typeof(MainActivity));

            //Create a PendingIntent;
            const int     pendingIntentId = 0;
            PendingIntent pendingIntent   =
                PendingIntent.GetActivity(ctx, pendingIntentId, intent, PendingIntentFlags.OneShot);

            //Instantiate the builder and set notification elements, including Pending Intent
            Notification.Builder builder = new Notification.Builder(ctx)
                                           .SetContentIntent(pendingIntent)
                                           .SetContentTitle(msg.Topic)
                                           .SetContentText(msg.Payload)
                                           .SetSmallIcon(Resource.Drawable.ic_stat_button_click);

            //Build the notification
            Notification notification = builder.Build();

            //Get the notification manager
            NotificationManager notificationManager =
                ctx.GetSystemService(Context.NotificationService) as NotificationManager;

            //Publish the notification
            const int notificationId = 0;

            notificationManager.Notify(notificationId, notification);
        }
Exemple #6
0
        private MQTTMessage CreateMQTTMessage(MessageDispatch dispatch)
        {
            MQTTMessage message = dispatch.Message.Clone() as MQTTMessage;

            if (this.ConsumerTransformer != null)
            {
                IMessage newMessage = ConsumerTransformer(this.session, this, message);
                if (newMessage != null)
                {
                    message = this.messageTransformation.TransformMessage <MQTTMessage>(newMessage);
                }
            }

            message.Connection = this.session.Connection;

            if (IsClientAcknowledge)
            {
                message.Acknowledger += new AcknowledgeHandler(DoClientAcknowledge);
            }
            else if (IsIndividualAcknowledge)
            {
                message.Acknowledger += new AcknowledgeHandler(DoIndividualAcknowledge);
            }
            else
            {
                message.Acknowledger += new AcknowledgeHandler(DoNothingAcknowledge);
            }

            return(message);
        }
Exemple #7
0
        protected void DoIndividualAcknowledge(MQTTMessage message)
        {
            MessageDispatch dispatch = null;

            lock (this.dispatchedMessages)
            {
                foreach (MessageDispatch originalDispatch in this.dispatchedMessages)
                {
                    if (originalDispatch.Message.MessageId.Equals(message.MessageId))
                    {
                        dispatch = originalDispatch;
                        this.dispatchedMessages.Remove(originalDispatch);
                        break;
                    }
                }
            }

            if (dispatch == null)
            {
                Tracer.DebugFormat("Attempt to Ack MessageId[{0}] failed because the original dispatch is not in the Dispatch List", message.MessageId);
                return;
            }

//			MessageAck ack = new MessageAck(dispatch, (byte) AckType.IndividualAck, 1);
//			Tracer.Debug("Sending Individual Ack for MessageId: " + ack.LastMessageId.ToString());
//			this.session.SendAck(ack);
        }
Exemple #8
0
        public void WaterSwitchClick(string WaterSystemOnOffFeedback)
        {
            MQTTMessage wateringStatus = App.Client.MQTTMessageStore.GetLatestMessageFromTopic("WateringSystem/Status");

            if (LastTimeWatered != null)
            {
                if ((DateTime.Now - LastTimeWatered).TotalSeconds <= 5)
                {
                    this.SetErrorMessageAndShowLabel("Watering the plant has a 5 second cooldown to prevent accidents!");
                    return;
                }
            }
            if (wateringStatus == null)
            {
                this.SetErrorMessageAndShowLabel("Cannot use button when no information about the current state is available");
                return;
            }

            if (wateringStatus.Message == "ON")
            {
                App.Client.Publish("WateringSystem", "OFF");
            }
            else
            {
                App.Client.Publish("WateringSystem", "ON");
            }
            LastTimeWatered = DateTime.Now;
        }
        public async void InitCycle(bool FirstCall = false)
        {
            //await App.MoistMeterDatabase.EmptyDatabase();
            MQTTMessage latestMessage = App.Client.MQTTMessageStore.GetLatestMessageFromTopic(this.Topic);

            if (latestMessage != null)
            {
                await SaveEntryToDatabase(latestMessage);
            }
            CreateXamlView();

            if (FirstCall)
            {
                Device.StartTimer(TimeSpan.FromSeconds(5), () =>
                {
                    Device.BeginInvokeOnMainThread(() =>
                    {
                        InitCycle();
                    });

                    //return true to keep loop going, false to stop timer
                    return(true);
                });
            }
        }
        public void PublishClientConfigurationActivity(string tenantId, string clientHostname)
        {
            var toIds = GetPeerIds();

            if (toIds.Count == 0)
            {
                return;
            }

            var activityMessage = new MQTTConfigurationClientActivityMessageContent()
            {
                TenantId            = tenantId,
                ClientHostname      = clientHostname,
                LastUpdateTimestamp = DateTime.UtcNow
            };

            var jsonMessage = JsonConvert.SerializeObject(activityMessage);

            jsonMessage = jsonMessage.Replace("\"", "'");

            var mqttMessage = new MQTTMessage()
            {
                FromInstanceId = Program.InstanceConfig.ServerInstanceID,
                ToInstancesIds = toIds,
                Type           = "CLIENT_CONFIGURATION_ACTIVITY",
                Message        = jsonMessage
            };

            _mqttService.SendMQTTMessageToMultipleInstances(tenantId, toIds, mqttMessage);
        }
Exemple #11
0
        public void PublishInstanceStatusChange(string tenantId, string appName, string instanceId, string status, long dirtyTimestamp)
        {
            var toIds = GetPeerIds();

            if (toIds.Count == 0)
            {
                return;
            }

            var changeMessage = new MQTTInstanceChangeStatusMessageContent()
            {
                AppName            = appName,
                TenantId           = tenantId,
                InstanceId         = instanceId,
                Status             = status,
                LastDirtyTimestamp = dirtyTimestamp
            };

            var jsonMessage = JsonConvert.SerializeObject(changeMessage);

            jsonMessage = jsonMessage.Replace("\"", "'");

            var mqttMessage = new MQTTMessage()
            {
                FromInstanceId = Program.InstanceConfig.ServerInstanceID,
                ToInstancesIds = toIds,
                Type           = "CHANGE_INSTANCE_STATUS",
                Message        = jsonMessage
            };

            _mqttService.SendMQTTMessageToMultipleInstances(tenantId, toIds, mqttMessage);
        }
Exemple #12
0
        public void GetLatestTempStatus()
        {
            MQTTMessage latestTemperature = App.Client.MQTTMessageStore.GetLatestMessageFromTopic("Plant/Temperature");

            if (latestTemperature != null)
            {
                CurrentTempStatus = $"Temperature: {latestTemperature.Message}°C";
            }
        }
Exemple #13
0
        public void GetLatestCoffeeStatus()
        {
            MQTTMessage latestCoffeeStatus = App.Client.MQTTMessageStore.GetLatestMessageFromTopic("Coffee/Status");

            if (latestCoffeeStatus != null)
            {
                CurrentCoffeeStatus = latestCoffeeStatus.Message;
            }
        }
Exemple #14
0
        public void Test()
        {
            MQTTMessage mqttMessage = App.Client.MQTTMessageStore.GetLatestMessageFromTopic("Coffee");

            if (mqttMessage != null)
            {
                TestLabel = mqttMessage.Message;
            }
        }
Exemple #15
0
        public void GetLatestHumidityStatus()
        {
            MQTTMessage latesHumidity = App.Client.MQTTMessageStore.GetLatestMessageFromTopic("Plant/Humidity");

            if (latesHumidity != null)
            {
                CurrentHumidityStatus = $"Humidity: {latesHumidity.Message}%";
            }
        }
Exemple #16
0
        public void GetLatestWaterStatus()
        {
            MQTTMessage latestWaterStatus = App.Client.MQTTMessageStore.GetLatestMessageFromTopic("WateringSystem/Status");

            if (latestWaterStatus != null)
            {
                CurrentWaterStatus = latestWaterStatus.Message;
            }
        }
Exemple #17
0
        public void GetLatestMoistureStatus()
        {
            MQTTMessage latestMoisture = App.Client.MQTTMessageStore.GetLatestMessageFromTopic("Plant/Moisture");

            if (latestMoisture != null)
            {
                CurrentGroundMoisture = $"Soil moisture: {latestMoisture.Message}%";
            }
        }
        public void AddMessage()
        {
            List <MQTTMessage> expected     = new List <MQTTMessage>();
            MQTTMessageStore   messageStore = new MQTTMessageStore();
            MQTTMessage        msg          = new MQTTMessage("test", "test", DateTime.Now);

            messageStore.AddMessage(msg);
            expected.Add(msg);
            Assert.AreEqual(expected.Count, messageStore.Messages.Count);
        }
        public void GetLastAddedItemByTopicName()
        {
            MQTTMessageStore messageStore = new MQTTMessageStore();
            MQTTMessage      msg          = new MQTTMessage("test", "test", DateTime.Now);

            messageStore.AddMessage(msg);

            MQTTMessage result = messageStore.GetLatestMessageFromTopic("test");

            Assert.AreEqual(result, msg);
        }
Exemple #20
0
        public async Task PreventDuplicateMessage()
        {
            MQTTMockClient client = new MQTTMockClient();

            _ = await client.Connect(this.IP, this.PORT, this.PASSWORD);

            MQTTMessage duplicateMessage = new MQTTMessage(this.TESTCHANNEL, "hello world", DateTime.Now);

            client.MQTTMessageStore.AddMessage(duplicateMessage);
            Assert.IsFalse(client.MQTTMessageStore.AddMessage(duplicateMessage));
        }
Exemple #21
0
        public async Task SubscribeAndSendMessageMockup()
        {
            MQTTMockClient client = new MQTTMockClient();

            _ = await client.Connect(this.IP, this.PORT, this.PASSWORD);

            client.Subscribe(this.TESTCHANNEL);
            client.Publish(this.TESTCHANNEL, "hello world");
            MQTTMessage message = client.MQTTMessageStore.GetLatestMessageFromTopic(this.TESTCHANNEL);

            Assert.AreEqual("hello world", message.Message);
        }
        public void ProcessClientConfigurationActivity(MQTTMessage mqttMessage, string topic)
        {
            InstanceHealthService.Health.MQTTMessagesReceived += 1;

            var receivedMessage = mqttMessage.Message.ToString().Replace("'", "\"");

            var messageContent = JsonConvert.DeserializeObject <MQTTConfigurationClientActivityMessageContent>(receivedMessage);

            if (messageContent != null && mqttMessage.FromInstanceId.CompareTo(Program.InstanceConfig.ServerInstanceID) != 0)
            {
                this._clientConfigurationRepo.Add(new DiscoveryClient(messageContent.ClientHostname, messageContent.LastUpdateTimestamp));
            }
        }
        public void ProcessInstanceDelete(MQTTMessage mqttMessage, string topic)
        {
            InstanceHealthService.Health.MQTTMessagesReceived += 1;

            var receivedMessage = mqttMessage.Message.ToString().Replace("'", "\"");

            var messageContent = JsonConvert.DeserializeObject <MQTTInstanceDeleteMessageContent>(receivedMessage);

            if (messageContent != null && mqttMessage.FromInstanceId.CompareTo(Program.InstanceConfig.ServerInstanceID) != 0)
            {
                var memoryRepo = new MemoryServicesRepository(messageContent.TenantId, Program.InstanceConfig.EvictionInSecs);
                memoryRepo.Delete(messageContent.AppName, messageContent.InstanceId);
            }
        }
        public void ProcessInstanceUpdated(MQTTMessage mqttMessage, string topic)
        {
            InstanceHealthService.Health.MQTTMessagesReceived += 1;

            var receivedMessage = mqttMessage.Message.ToString().Replace("'", "\"");

            var instance = JsonConvert.DeserializeObject <Instance>(receivedMessage);

            instance.TenantId = GetTenantFromTopicName(topic);

            if (instance != null && mqttMessage.FromInstanceId.CompareTo(Program.InstanceConfig.ServerInstanceID) != 0)
            {
                var memoryRepo = new MemoryServicesRepository(instance.TenantId, Program.InstanceConfig.EvictionInSecs);
                memoryRepo.Add(instance);
            }
        }
        public async Task <int> SaveEntryToDatabase(MQTTMessage latestMessage)
        {
            if (latestMessage == null)
            {
                return(0);
            }

            MoistMeter compressedMoistMeter = new MoistMeter
            {
                Topic    = Topic,
                Data     = Convert.ToDouble(latestMessage.Message),
                DateTime = DateTime.Now
            };

            return(await App.MoistMeterDatabase.SaveItemAsync(compressedMoistMeter));
        }
Exemple #26
0
        public void CoffeeSwitchClick(string CoffeeOnOffFeedback)
        {
            MQTTMessage coffeeStatus = App.Client.MQTTMessageStore.GetLatestMessageFromTopic("Coffee/Status");

            if (coffeeStatus == null)
            {
                this.SetErrorMessageAndShowLabel("Cannot use button when no information about the current state is available");
                return;
            }
            if (coffeeStatus.Message == "ON")
            {
                App.Client.Publish("cmnd/coffee/POWER", "OFF");
            }
            else
            {
                App.Client.Publish("cmnd/coffee/POWER", "ON");
            }
        }
        /*  PROCESS RECEIVING MESSAGES  */

        private void ProcessInstanceConnected(string topic, MQTTMessage mqttMessage)
        {
            InstanceHealthService.Health.MQTTMessagesReceived += 1;

            var receivedMessage = mqttMessage.Message.ToString().Replace("'", "\"");

            var peerMessageContent = JsonConvert.DeserializeObject <MQTTPeerMessageContent>(receivedMessage);

            if (peerMessageContent != null && mqttMessage.FromInstanceId.CompareTo(Program.InstanceConfig.ServerInstanceID) != 0)
            {
                // respond back with my peer data
                var myMqttClient = _mqttClients.SingleOrDefault(c => c.mqttTopic.CompareTo(topic) == 0);

                if (myMqttClient != null && myMqttClient.mqttClient.IsConnected)
                {
                    var myPeerMessage = GetPeerMessage(peerMessageContent.PeerId, "INSTANCE_HEARTBEAT");
                    myMqttClient.mqttClient.PublishAsync(myMqttClient.mqttTopic, JsonConvert.SerializeObject(myPeerMessage));
                }

                // add new peer to my peers
                DiscoveryPeer existingPeer = null;

                lock (Memory.Peers)
                {
                    existingPeer = Memory.Peers.FirstOrDefault(p => p.ServerInstanceID.CompareTo(peerMessageContent.PeerId) == 0);
                }

                if (existingPeer == null)
                {
                    var newPeer = new DiscoveryPeer()
                    {
                        LastUpdateTimestamp = DateTime.UtcNow,
                        ServerInstanceID    = peerMessageContent.PeerId,
                        DiscoveryUrls       = peerMessageContent.DiscoveryUrls,
                        InstanceIP          = peerMessageContent.InstanceIP,
                        InstancePort        = peerMessageContent.InstancePort
                    };

                    Memory.Peers.Add(newPeer);
                }
            }
        }
        public void ProcessInstanceHeartbeat(string topic, MQTTMessage mqttMessage)
        {
            InstanceHealthService.Health.MQTTMessagesReceived += 1;

            var receivedMessage = mqttMessage.Message.ToString().Replace("'", "\"");

            var peerMessageContent = JsonConvert.DeserializeObject <MQTTPeerMessageContent>(receivedMessage);

            if (peerMessageContent != null && mqttMessage.FromInstanceId.CompareTo(Program.InstanceConfig.ServerInstanceID) != 0)
            {
                DiscoveryPeer existingPeer = null;

                // add new peer to my peers
                lock (Memory.Peers)
                {
                    existingPeer = Memory.Peers.FirstOrDefault(p => p.ServerInstanceID.CompareTo(peerMessageContent.PeerId) == 0);
                }

                if (existingPeer == null)
                {
                    var newPeer = new DiscoveryPeer()
                    {
                        LastUpdateTimestamp = DateTime.UtcNow,
                        ServerInstanceID    = peerMessageContent.PeerId,
                        DiscoveryUrls       = peerMessageContent.DiscoveryUrls,
                        InstanceIP          = peerMessageContent.InstanceIP,
                        InstancePort        = peerMessageContent.InstancePort
                    };

                    _memoryDiscoveryPeerRepository.Add(newPeer);
                }
                else
                {
                    existingPeer.LastUpdateTimestamp = DateTime.UtcNow;
                    existingPeer.DiscoveryUrls       = peerMessageContent.DiscoveryUrls;
                    existingPeer.InstanceIP          = peerMessageContent.InstanceIP;
                    existingPeer.InstancePort        = peerMessageContent.InstancePort;
                }
            }
        }
Exemple #29
0
        public void PublishAddedOrUpdatedInstance(Instance instance, string type = "ADD_INSTANCE")
        {
            var toIds = GetPeerIds();

            if (toIds.Count == 0)
            {
                return;
            }

            var jsonMessage = JsonConvert.SerializeObject(instance);

            jsonMessage = jsonMessage.Replace("\"", "'");

            var mqttMessage = new MQTTMessage()
            {
                FromInstanceId = Program.InstanceConfig.ServerInstanceID,
                ToInstancesIds = toIds,
                Type           = type,
                Message        = jsonMessage
            };

            _mqttService.SendMQTTMessageToMultipleInstances(instance.TenantId, toIds, mqttMessage);
        }
Exemple #30
0
        static async Task Start()
        {
            var mqttService = new MQTTService();

            var mqttClientOptions = new Options
            {
                Uri = new Uri("mqtt://test.mosquitto.org:1883"),
                //UseTls = true,
                //IgnoreCertificateChainErrors = true,
                //IgnoreCertificateRevocationErrors = true,
                //AllowUntrustedCertificates = true,

                //Uri = new Uri("ws://broker.mqttdashboard.com:8000/mqtt"),
                //Server = "broker.mqttdashboard.com",
                ////Port = 1883,
                //Port = 8000,
                //Url = "broker.mqttdashboard.com",
                //Path = "mqtt",
                ConnectionType = ConnectionType.Tcp,
                //ConnectionType = ConnectionType.WebSocket
            };

            var topic1 = new TopicFilter
            {
                QualityOfServiceLevel = QoSLevel.ExactlyOnce,
                //Topic = "PP/#"
                Topic = "/#"
            };

            var topic2 = new TopicFilter
            {
                QualityOfServiceLevel = QoSLevel.AtLeastOnce,
                //Topic = "EFM/#"
                Topic = "MQTTClientRx/Test"
            };

            ITopicFilter[] topicFilters =
            {
                topic1,
                //topic2
            };

            var MQTTService = mqttService.CreateObservableMQTTService(mqttClientOptions, topicFilters);

            _disp1 = MQTTService.observableMessage.Subscribe(
                msg =>
            {
                if (msg.Topic.Contains("EFM"))
                {
                    Console.ForegroundColor = ConsoleColor.Yellow;
                }
                else
                {
                    Console.ForegroundColor = ConsoleColor.Blue;
                }

                Console.WriteLine($"{Encoding.UTF8.GetString(msg.Payload)}, " +
                                  $"{msg.QualityOfServiceLevel.ToString()}, " +
                                  $"Retain: {msg.Retain}, " +
                                  $"Topic: {msg.Topic}");
            },
                ex =>
            {
                Console.WriteLine($"{ex.Message} : inner {ex.InnerException.Message}");
            },
                () =>
            {
                Console.WriteLine("Completed...");
            });

            await Task.Delay(TimeSpan.FromSeconds(5));

            var newMessage = new MQTTMessage
            {
                Payload = Encoding.UTF8.GetBytes("Hello MQTT EO"),
                QualityOfServiceLevel = QoSLevel.ExactlyOnce,
                Retain = false,
                Topic  = "MQTTClientRx/Test"
            };

            await MQTTService.client.PublishAsync(newMessage);

            _disp2 = MQTTService.observableMessage.Subscribe(
                msg =>
            {
                if (msg.Topic.Contains("EFM"))
                {
                    Console.ForegroundColor = ConsoleColor.Cyan;
                }
                else
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                }

                Console.WriteLine($"{Encoding.UTF8.GetString(msg.Payload)}, " +
                                  $"{msg.QualityOfServiceLevel.ToString()}, " +
                                  $"Retain: {msg.Retain}, " +
                                  $"Topic: {msg.Topic}");
            },
                ex =>
            {
                Console.WriteLine($"{ex.Message} : inner {ex.InnerException.Message}");
            },
                () =>
            {
                Console.WriteLine("Completed...");
            });

            await Task.Delay(TimeSpan.FromSeconds(2));

            await MQTTService.client.UnsubscribeAsync(new[] { topic2 });

            await Task.Delay(TimeSpan.FromSeconds(5));

            //await MQTTService.client.UnsubscribeAsync(new [] {topic1});

            //await Task.Delay(TimeSpan.FromSeconds(2));



            //await MQTTService.client.SubscribeAsync(new[] { topic2 });


            await Task.Delay(TimeSpan.FromSeconds(2));

            _disp2.Dispose();

            await Task.Delay(TimeSpan.FromSeconds(2));

            _disp1.Dispose();

            await Task.Delay(TimeSpan.FromSeconds(30));

            //var topic2a = new TopicFilter
            //{
            //    QualityOfServiceLevel = QoSLevel.ExactlyOnce,
            //    Topic = "EFM/#"
            //};
            //Console.ForegroundColor = ConsoleColor.DarkBlue;
            //await MQTTService.client.UnsubscribeAsync(new[] { topic2 });
            //await MQTTService.client.SubscribeAsync(new[] { topic2a });
        }