mqtt_dialog.cpp

Go to the documentation of this file.

#include "mqtt_dialog.h"
#include <QFileDialog>
#include "PlotJuggler/svg_util.h"
 
void MQTT_Dialog::onConnectionClosed()
{
  _client->disconnect();
  changeConnectionState(false);
  ui->listWidget->clear();
  _topic_list.clear();
  ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
  _topic_list_timer->stop();
}
 
MQTT_Dialog::MQTT_Dialog(MQTTClient::Ptr mosq_client)
  : QDialog(nullptr), ui(new Ui::DataStreamMQTT), _client(mosq_client)
{
  ui->setupUi(this);
  ui->lineEditPort->setValidator(new QIntValidator);
 
  ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
 
  static QString uuid = QString("Plotjuggler-") + QString::number(rand());
 
  QSettings settings;
  restoreGeometry(settings.value("MosquittoMQTT::geometry").toByteArray());
 
  QString host = settings.value("MosquittoMQTT::host").toString();
  ui->lineEditHost->setText(host);
 
  int port = settings.value("MosquittoMQTT::port", 1883).toInt();
  ui->lineEditPort->setText(QString::number(port));
 
  int qos = settings.value("MosquittoMQTT::qos", 0).toInt();
  ui->comboBoxQoS->setCurrentIndex(qos);
 
  int protocol_mqtt = settings.value("MosquittoMQTT::protocol_version").toInt();
  ui->comboBoxVersion->setCurrentIndex(protocol_mqtt);
 
  QString topic_filter = settings.value("MosquittoMQTT::filter").toString();
  ui->lineEditTopicFilter->setText(topic_filter);
 
  QString username = settings.value("MosquittoMQTT::username", "").toString();
  ui->lineEditUsername->setText(username);
 
  QString password = settings.value("MosquittoMQTT::password", "").toString();
  ui->lineEditPassword->setText(password);
 
  _server_certificate_file =
      settings.value("MosquittoMQTT::server_certificate", "").toString();
  if (!_server_certificate_file.isEmpty())
  {
    ui->labelServerCertificate->setText(QFileInfo(_server_certificate_file).fileName());
    ui->buttonEraseServerCertificate->setEnabled(true);
  }
 
  _client_certificate_file =
      settings.value("MosquittoMQTT::client_certificate", "").toString();
  if (!_client_certificate_file.isEmpty())
  {
    ui->labelClientCertificate->setText(QFileInfo(_client_certificate_file).fileName());
    ui->buttonEraseClientCertificate->setEnabled(true);
  }
 
  _private_key_file = settings.value("MosquittoMQTT::private_key", "").toString();
  if (!_private_key_file.isEmpty())
  {
    ui->labelPrivateKey->setText(QFileInfo(_private_key_file).fileName());
    ui->buttonErasePrivateKey->setEnabled(true);
  }
 
  bool enable_tls = settings.value("MosquittoMQTT::enable_tls", false).toBool();
  ui->checkBoxSecurity->setChecked(enable_tls);
 
  _topic_list_timer = new QTimer(this);
 
  QString theme = settings.value("StyleSheet::theme", "light").toString();
 
  const QPixmap& icon_pixmap = LoadSvg(":/resources/svg/import.svg", theme);
  ui->buttonLoadServerCertificate->setIcon(icon_pixmap);
  ui->buttonLoadClientCertificate->setIcon(icon_pixmap);
  ui->buttonLoadPrivateKey->setIcon(icon_pixmap);
 
  connect(ui->buttonConnect, &QPushButton::clicked, this, &MQTT_Dialog::onButtonConnect);
 
  connect(_topic_list_timer, &QTimer::timeout, this, &MQTT_Dialog::onUpdateTopicList);
 
  connect(ui->listWidget, &QListWidget::itemSelectionChanged, this,
          &MQTT_Dialog::onSelectionChanged);
 
  connect(ui->buttonLoadServerCertificate, &QPushButton::clicked, this,
          &MQTT_Dialog::onLoadServerCertificate);
 
  connect(ui->buttonLoadClientCertificate, &QPushButton::clicked, this,
          &MQTT_Dialog::onLoadClientCertificate);
 
  connect(ui->buttonLoadPrivateKey, &QPushButton::clicked, this,
          &MQTT_Dialog::onLoadPrivateKey);
 
  connect(ui->buttonEraseServerCertificate, &QPushButton::clicked, this, [this]() {
    ui->buttonEraseServerCertificate->setEnabled(false);
    ui->labelServerCertificate->setText("");
    _server_certificate_file.clear();
  });
 
  connect(ui->buttonEraseClientCertificate, &QPushButton::clicked, this, [this]() {
    ui->buttonEraseClientCertificate->setEnabled(false);
    ui->labelClientCertificate->setText("");
    _client_certificate_file.clear();
  });
 
  connect(ui->buttonErasePrivateKey, &QPushButton::clicked, this, [this]() {
    ui->buttonErasePrivateKey->setEnabled(false);
    ui->labelPrivateKey->setText("");
    _private_key_file.clear();
  });
 
  connect(_client.get(), &MQTTClient::disconnected, this, [this]() {
    onConnectionClosed();
    QMessageBox::warning(this, "Connection Lost",
                         "Client disconnected. Maybe a problem with autentication?");
  });
}
 
void MQTT_Dialog::saveSettings()
{
  QSettings settings;
  settings.setValue("MosquittoMQTT::geometry", this->saveGeometry());
 
  // save back to service
  settings.setValue("MosquittoMQTT::host", ui->lineEditHost->text());
  settings.setValue("MosquittoMQTT::port", ui->lineEditPort->text().toInt());
  settings.setValue("MosquittoMQTT::filter", ui->lineEditTopicFilter->text());
  settings.setValue("MosquittoMQTT::username", ui->lineEditPassword->text());
  settings.setValue("MosquittoMQTT::password", ui->lineEditUsername->text());
  settings.setValue("MosquittoMQTT::protocol_version",
                    ui->comboBoxVersion->currentIndex());
  settings.setValue("MosquittoMQTT::qos", ui->comboBoxQoS->currentIndex());
  settings.setValue("MosquittoMQTT::serialization_protocol",
                    ui->comboBoxProtocol->currentText());
  settings.setValue("MosquittoMQTT::server_certificate", _server_certificate_file);
  settings.setValue("MosquittoMQTT::client_certificate", _client_certificate_file);
  settings.setValue("MosquittoMQTT::private_key", _private_key_file);
  settings.setValue("MosquittoMQTT::enable_tls", ui->checkBoxSecurity->isChecked());
}
 
MQTT_Dialog::~MQTT_Dialog()
{
  while (ui->layoutOptions->count() > 0)
  {
    auto item = ui->layoutOptions->takeAt(0);
    item->widget()->setParent(nullptr);
  }
 
  saveSettings();
 
  delete ui;
}
 
void MQTT_Dialog::onButtonConnect()
{
  if (_client->isConnected())
  {
    onConnectionClosed();
    return;
  }
 
  MosquittoConfig config;
 
  config.host = ui->lineEditHost->text().toStdString();
  config.port = ui->lineEditPort->text().toInt();
  config.topics.clear();
  config.topics.push_back(ui->lineEditTopicFilter->text().toStdString());
  config.username = ui->lineEditUsername->text().toStdString();
  config.password = ui->lineEditPassword->text().toStdString();
  config.qos = ui->comboBoxQoS->currentIndex();
  config.protocol_version = MQTT_PROTOCOL_V31 + ui->comboBoxVersion->currentIndex();
 
  config.keepalive = 60;        // TODO
  config.bind_address = "";     // TODO
  config.max_inflight = 20;     // TODO
  config.clean_session = true;  // TODO
  config.eol = true;            // TODO
 
  if (ui->checkBoxSecurity->isChecked())
  {
    config.cafile = _server_certificate_file.toStdString();
    config.certfile = _client_certificate_file.toStdString();
    config.keyfile = _private_key_file.toStdString();
  }
 
  changeConnectionState(true);
  _client->connect(config);
  _topic_list_timer->start(2000);
 
  saveSettings();
}
 
void MQTT_Dialog::onUpdateTopicList()
{
  auto topic_list = _client->getTopicList();
 
  bool changed = ui->listWidget->count() != topic_list.size();
  if (!changed)
  {
    for (const auto& topic : topic_list)
    {
      if (_topic_list.count(topic) == 0)
      {
        changed = true;
        break;
      }
    }
  }
 
  if (changed)
  {
    ui->listWidget->clear();
    for (const auto& topic : topic_list)
    {
      ui->listWidget->addItem(QString::fromStdString(topic));
      _topic_list.insert(topic);
    }
    ui->listWidget->sortItems();
  }
 
  if (_client->isConnected() == false)
  {
    onConnectionClosed();
  }
}
 
void MQTT_Dialog::onSelectionChanged()
{
  bool selected = ui->listWidget->selectedItems().count() > 0;
  ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(selected);
}
 
void MQTT_Dialog::changeConnectionState(bool connected)
{
  ui->connectionFrame->setEnabled(!connected);
  ui->buttonConnect->setText(connected ? "Disconnect" : "Connect");
  ui->lineEditTopicFilter->setEnabled(!connected);
  ui->listWidget->setEnabled(connected);
}
 
void MQTT_Dialog::onLoadServerCertificate()
{
  QSettings settings;
  QString directory =
      settings.value("MQTT_Dialog.loadDirectory", QDir::currentPath()).toString();
 
  QString filename = QFileDialog::getOpenFileName(this, "Select Server Certificate",
                                                  directory, tr("CRT (*.crt)"));
 
  if (!filename.isEmpty())
  {
    _server_certificate_file = filename;
    directory = QFileInfo(filename).absolutePath();
    settings.setValue("MQTT_Dialog.loadDirectory", directory);
 
    ui->labelServerCertificate->setText(QFileInfo(filename).fileName());
    ui->buttonEraseServerCertificate->setEnabled(true);
  }
}
 
void MQTT_Dialog::onLoadClientCertificate()
{
  QSettings settings;
  QString directory =
      settings.value("MQTT_Dialog.loadDirectory", QDir::currentPath()).toString();
 
  QString filename = QFileDialog::getOpenFileName(this, "Select Client Certificate",
                                                  directory, tr("CRT (*.crt)"));
 
  if (!filename.isEmpty())
  {
    _client_certificate_file = filename;
    directory = QFileInfo(filename).absolutePath();
    settings.setValue("MQTT_Dialog.loadDirectory", directory);
 
    ui->labelClientCertificate->setText(QFileInfo(filename).fileName());
    ui->buttonEraseClientCertificate->setEnabled(true);
  }
}
 
void MQTT_Dialog::onLoadPrivateKey()
{
  QSettings settings;
  QString directory =
      settings.value("MQTT_Dialog.loadDirectory", QDir::currentPath()).toString();
 
  QString filename = QFileDialog::getOpenFileName(this, "Select PrivateKey", directory,
                                                  tr("Key (*.key)"));
 
  if (!filename.isEmpty())
  {
    _private_key_file = filename;
    directory = QFileInfo(filename).absolutePath();
    settings.setValue("MQTT_Dialog.loadDirectory", directory);
 
    ui->labelPrivateKey->setText(QFileInfo(filename).fileName());
    ui->buttonErasePrivateKey->setEnabled(true);
  }
}