Example #1
0
        static string ReceiveMesHandler(MQTTnet.Client.IMqttClient mqttClient)
        {
            string mes = null;

            do
            {
                mqttClient.UseApplicationMessageReceivedHandler(e =>
                {
                    try
                    {
                        string topic = e.ApplicationMessage.Topic;

                        if (string.IsNullOrWhiteSpace(topic) == false)
                        {
                            mes = Encoding.UTF8.GetString(e.ApplicationMessage.Payload);
                        }
                    }
                    catch (Exception ex)
                    {
                        mes = ex.Message;
                    }
                });
            } while (mes == null);
            return(mes);
        }
Example #2
0
        private void Page_Loaded(object sender, RoutedEventArgs e)
        {
            if (initial)
            {
                return;
            }

            BrokerTextBox.DataContext     = Tools.Global.setting;
            PortTextBox.DataContext       = Tools.Global.setting;
            ClientTextBox.DataContext     = Tools.Global.setting;
            TLSCheckBox.DataContext       = Tools.Global.setting;
            UserTextBox.DataContext       = Tools.Global.setting;
            PasswordTextBox.DataContext   = Tools.Global.setting;
            KeepAliveTextBox.DataContext  = Tools.Global.setting;
            CleanTextBox.DataContext      = Tools.Global.setting;
            HexCheckBox.DataContext       = Tools.Global.setting;
            ConnectButton.DataContext     = this;
            SettingStackPanel.DataContext = this;

            mqttClient.UseConnectedHandler(async e =>
            {
                this.Dispatcher.Invoke(new Action(delegate
                {
                    MqttIsConnected = mqttClient.IsConnected;
                    subListBox.Items.Clear();
                }));
            });
            mqttClient.UseDisconnectedHandler(async e =>
            {
                this.Dispatcher.Invoke(new Action(delegate
                {
                    MqttIsConnected = mqttClient.IsConnected;
                    subListBox.Items.Clear();
                    subListBox.Items.Add(TryFindResource("MQTTNotConnect") as string ?? "?!");
                }));
            });
            //
            mqttClient.UseApplicationMessageReceivedHandler(e =>
            {
                this.Dispatcher.Invoke(new Action(delegate
                {
                    Tools.Logger.ShowDataRaw(new Tools.DataShowRaw {
                        title = $"MQTT → {e.ApplicationMessage.Topic}({(int)e.ApplicationMessage.QualityOfServiceLevel})",
                        data  = e.ApplicationMessage.Payload,
                        color = Brushes.DarkGreen
                    });
                }));
            });


            initial = true;
        }
        public async Task ConnectToBrokerAsync(string nelloTopicId)
        {
            try
            {
                _nelloTopicId = nelloTopicId;

                var options = new MqttClientOptionsBuilder()
                              .WithTcpServer(SERVER_ADDRESS, SERVER_PORT)
                              .Build();

                _client.UseDisconnectedHandler(async e =>
                {
                    try
                    {
                        await _client.ReconnectAsync();
                    }
                    catch (Exception ex)
                    {
                        _logger.LogError("UseDisconnectedHandler error:\n" + ex.ToString());
                    }
                });

                _client.UseConnectedHandler(async e =>
                {
                    try
                    {
                        foreach (var topic in _mqttListeningTopics)
                        {
                            await SubscribeToTopicAsync(string.Format("{0}{1}/{2}", TOPIC_PREFIX, _nelloTopicId, topic));
                        }
                    }
                    catch (Exception ex)
                    {
                        _logger.LogError("UseDisconnectedHandler error:\n" + ex.ToString());
                    }
                });

                _client.UseApplicationMessageReceivedHandler(e =>
                {
                    try
                    {
                        if (e.ApplicationMessage.Topic.StartsWith("/nello_one"))
                        {
                            var args      = new MqttMessageEventArgs();
                            args.ClientId = e.ClientId;
                            args.Message  = Encoding.UTF8.GetString(e.ApplicationMessage.Payload);
                            args.Topic    = e.ApplicationMessage.Topic;
                            MqttMessageReceived?.Invoke(this, args);
                        }
                    }
                    catch (Exception ex)
                    {
                        _logger.LogError("UseDisconnectedHandler error:\n" + ex.ToString());
                    }
                });

                await _client.ConnectAsync(options);
            }
            catch (Exception ex)
            {
                _logger.LogError("ConnectToBrokerAsync error:\n" + ex.ToString());
            }
        }
Example #4
0
        public async Task <bool> ConnectAsync(string clientId, string host, int port, bool tls, string username, string password)
        {
            this.mqttState.AddMessage($"connecting to {host}");
            var options = new MqttClientOptionsBuilder()
                          .WithClientId(clientId)
                          .WithTcpServer(host, port)
                          .WithCleanSession();

            if (!string.IsNullOrEmpty(username))
            {
                options = options.WithCredentials(username, password);
            }

            if (tls)
            {
                options = options.WithTls();
            }

            client = new MqttFactory().CreateMqttClient();

            var t  = new TaskCompletionSource <Boolean>();
            var ct = new CancellationTokenSource(5000); // timeout ms

            ct.Token.Register(() => { if (!t.Task.IsCompleted)
                                      {
                                          t.SetResult(false);
                                      }
                              }, useSynchronizationContext: false);
            client.UseConnectedHandler(e => {
                this.mqttState.AddMessage("Connected");
                mqttState.SetConnected(true);
                t.SetResult(true);
            });

            client.UseDisconnectedHandler(e => {
                this.mqttState.AddMessage("Disconnected");
                mqttState.SetConnected(false);
            });

            client.UseApplicationMessageReceivedHandler(e =>
            {
                var subscription = mqttState.Subscriptions.SingleOrDefault(s => s.Topic == e.ApplicationMessage.Topic);
                if (subscription != null)
                {
                    subscription.AddMessage(
                        new MqttSubscriptionMessage(
                            e.ApplicationMessage.Topic,
                            Encoding.Default.GetString(e.ApplicationMessage.Payload),
                            DateTime.Now)
                        );
                }
            });


            try
            {
                var result = await client.ConnectAsync(options.Build(), CancellationToken.None);

                if (result.ResultCode != MQTTnet.Client.Connecting.MqttClientConnectResultCode.Success)
                {
                    this.mqttState.AddMessage("Error: " + result.ReasonString);
                }
            }
            catch (Exception e)
            {
                Console.Error.WriteLine(e.Message + " : " + e.StackTrace);
                t.SetResult(false);
            }

            return(await t.Task);
        }