Feature plugins framework: REST API and server implementationo

plugins/feature/simpleptt/simpleptt.cpp

@@ -16,6 +16,15 @@
 ///////////////////////////////////////////////////////////////////////////////////
 
 #include <QDebug>
+#include <QNetworkAccessManager>
+#include <QNetworkReply>
+#include <QBuffer>
+
+#include "SWGFeatureSettings.h"
+#include "SWGFeatureReport.h"
+#include "SWGFeatureActions.h"
+#include "SWGSimplePTTReport.h"
+#include "SWGDeviceState.h"
 
 #include "dsp/dspengine.h"
 
@@ -30,7 +39,8 @@ const QString SimplePTT::m_featureIdURI = "sdrangel.feature.simpleptt";
 const QString SimplePTT::m_featureId = "SimplePTT";
 
 SimplePTT::SimplePTT(WebAPIAdapterInterface *webAPIAdapterInterface) :
-    Feature(m_featureIdURI, webAPIAdapterInterface)
+    Feature(m_featureIdURI, webAPIAdapterInterface),
+    m_ptt(false)
 {
     setObjectName(m_featureId);
     m_worker = new SimplePTTWorker(webAPIAdapterInterface);
@@ -44,7 +54,7 @@ SimplePTT::~SimplePTT()
         stop();
     }
 
-    delete m_worker;    
+    delete m_worker;
 }
 
 void SimplePTT::start()
@@ -83,9 +93,10 @@ bool SimplePTT::handleMessage(const Message& cmd)
     else if (MsgPTT::match(cmd))
     {
         MsgPTT& cfg = (MsgPTT&) cmd;
-        qDebug() << "SimplePTT::handleMessage: MsgPTT: tx:" << cfg.getTx();
+        m_ptt = cfg.getTx();
+        qDebug() << "SimplePTT::handleMessage: MsgPTT: tx:" << m_ptt;
 
-        SimplePTTWorker::MsgPTT *msg = SimplePTTWorker::MsgPTT::create(cfg.getTx()); 
+        SimplePTTWorker::MsgPTT *msg = SimplePTTWorker::MsgPTT::create(m_ptt);
         m_worker->getInputMessageQueue()->push(msg);
 
         return true;
@@ -142,10 +153,260 @@ void SimplePTT::applySettings(const SimplePTTSettings& settings, bool force)
             << " m_tx2RxDelayMs: " << settings.m_tx2RxDelayMs
             << " force: " << force;
 
+    QList<QString> reverseAPIKeys;
+
+    if ((m_settings.m_title != settings.m_title) || force) {
+        reverseAPIKeys.append("title");
+    }
+    if ((m_settings.m_rgbColor != settings.m_rgbColor) || force) {
+        reverseAPIKeys.append("rgbColor");
+    }
+    if ((m_settings.m_rxDeviceSetIndex != settings.m_rxDeviceSetIndex) || force) {
+        reverseAPIKeys.append("rxDeviceSetIndex");
+    }
+    if ((m_settings.m_txDeviceSetIndex != settings.m_txDeviceSetIndex) || force) {
+        reverseAPIKeys.append("txDeviceSetIndex");
+    }
+    if ((m_settings.m_rx2TxDelayMs != settings.m_rx2TxDelayMs) || force) {
+        reverseAPIKeys.append("rx2TxDelayMs");
+    }
+    if ((m_settings.m_tx2RxDelayMs != settings.m_tx2RxDelayMs) || force) {
+        reverseAPIKeys.append("tx2RxDelayMs");
+    }
+
     SimplePTTWorker::MsgConfigureSimplePTTWorker *msg = SimplePTTWorker::MsgConfigureSimplePTTWorker::create(
         settings, force
-    ); 
+    );
     m_worker->getInputMessageQueue()->push(msg);
 
+    if (settings.m_useReverseAPI)
+    {
+        bool fullUpdate = ((m_settings.m_useReverseAPI != settings.m_useReverseAPI) && settings.m_useReverseAPI) ||
+                (m_settings.m_reverseAPIAddress != settings.m_reverseAPIAddress) ||
+                (m_settings.m_reverseAPIPort != settings.m_reverseAPIPort) ||
+                (m_settings.m_reverseAPIDeviceIndex != settings.m_reverseAPIDeviceIndex) ||
+                (m_settings.m_reverseAPIChannelIndex != settings.m_reverseAPIChannelIndex);
+        webapiReverseSendSettings(reverseAPIKeys, settings, fullUpdate || force);
+    }
+
     m_settings = settings;
 }
+
+int SimplePTT::webapiRun(bool run,
+    SWGSDRangel::SWGDeviceState& response,
+    QString& errorMessage)
+{
+    getFeatureStateStr(*response.getState());
+    MsgStartStop *msg = MsgStartStop::create(run);
+    getInputMessageQueue()->push(msg);
+    return 202;
+}
+
+int SimplePTT::webapiSettingsGet(
+    SWGSDRangel::SWGFeatureSettings& response,
+    QString& errorMessage)
+{
+    (void) errorMessage;
+    response.setSimplePttSettings(new SWGSDRangel::SWGSimplePTTSettings());
+    response.getSimplePttSettings()->init();
+    webapiFormatFeatureSettings(response, m_settings);
+    return 200;
+}
+
+int SimplePTT::webapiSettingsPutPatch(
+    bool force,
+    const QStringList& featureSettingsKeys,
+    SWGSDRangel::SWGFeatureSettings& response,
+    QString& errorMessage)
+{
+    (void) errorMessage;
+    SimplePTTSettings settings = m_settings;
+    webapiUpdateFeatureSettings(settings, featureSettingsKeys, response);
+
+    MsgConfigureSimplePTT *msg = MsgConfigureSimplePTT::create(settings, force);
+    m_inputMessageQueue.push(msg);
+
+    qDebug("SimplePTT::webapiSettingsPutPatch: forward to GUI: %p", m_guiMessageQueue);
+    if (m_guiMessageQueue) // forward to GUI if any
+    {
+        MsgConfigureSimplePTT *msgToGUI = MsgConfigureSimplePTT::create(settings, force);
+        m_guiMessageQueue->push(msgToGUI);
+    }
+
+    webapiFormatFeatureSettings(response, settings);
+
+    return 200;
+}
+
+int SimplePTT::webapiReportGet(
+    SWGSDRangel::SWGFeatureReport& response,
+    QString& errorMessage)
+{
+    (void) errorMessage;
+    response.setSimplePttReport(new SWGSDRangel::SWGSimplePTTReport());
+    response.getSimplePttReport()->init();
+    webapiFormatFeatureReport(response);
+    return 200;
+}
+
+int SimplePTT::webapiActionsPost(
+    const QStringList& featureActionsKeys,
+    SWGSDRangel::SWGFeatureActions& query,
+    QString& errorMessage)
+{
+    SWGSDRangel::SWGSimplePTTActions *swgSimplePTTActions = query.getSimplePttActions();
+
+    if (swgSimplePTTActions)
+    {
+        if (featureActionsKeys.contains("ptt"))
+        {
+            bool ptt = swgSimplePTTActions->getPtt() != 0;
+
+            MsgPTT *msg = MsgPTT::create(ptt);
+            getInputMessageQueue()->push(msg);
+
+            if (getMessageQueueToGUI())
+            {
+                MsgPTT *msgToGUI = MsgPTT::create(ptt);
+                getMessageQueueToGUI()->push(msgToGUI);
+            }
+        }
+
+        return 202;
+    }
+    else
+    {
+        errorMessage = "Missing SimplePTTActions in query";
+        return 400;
+    }
+}
+
+void SimplePTT::webapiFormatFeatureSettings(
+    SWGSDRangel::SWGFeatureSettings& response,
+    const SimplePTTSettings& settings)
+{
+    if (response.getSimplePttSettings()->getTitle()) {
+        *response.getSimplePttSettings()->getTitle() = settings.m_title;
+    } else {
+        response.getSimplePttSettings()->setTitle(new QString(settings.m_title));
+    }
+
+    response.getSimplePttSettings()->setRgbColor(settings.m_rgbColor);
+    response.getSimplePttSettings()->setRxDeviceSetIndex(settings.m_rxDeviceSetIndex);
+    response.getSimplePttSettings()->setTxDeviceSetIndex(settings.m_txDeviceSetIndex);
+    response.getSimplePttSettings()->setRx2TxDelayMs(settings.m_rx2TxDelayMs);
+    response.getSimplePttSettings()->setTx2RxDelayMs(settings.m_tx2RxDelayMs);
+
+    response.getSimplePttSettings()->setUseReverseApi(settings.m_useReverseAPI ? 1 : 0);
+
+    if (response.getSimplePttSettings()->getReverseApiAddress()) {
+        *response.getSimplePttSettings()->getReverseApiAddress() = settings.m_reverseAPIAddress;
+    } else {
+        response.getSimplePttSettings()->setReverseApiAddress(new QString(settings.m_reverseAPIAddress));
+    }
+
+    response.getSimplePttSettings()->setReverseApiPort(settings.m_reverseAPIPort);
+    response.getSimplePttSettings()->setReverseApiDeviceIndex(settings.m_reverseAPIDeviceIndex);
+    response.getSimplePttSettings()->setReverseApiChannelIndex(settings.m_reverseAPIChannelIndex);
+}
+
+void SimplePTT::webapiUpdateFeatureSettings(
+    SimplePTTSettings& settings,
+    const QStringList& featureSettingsKeys,
+    SWGSDRangel::SWGFeatureSettings& response)
+{
+    if (featureSettingsKeys.contains("title")) {
+        settings.m_title = *response.getSimplePttSettings()->getTitle();
+    }
+    if (featureSettingsKeys.contains("rgbColor")) {
+        settings.m_rgbColor = response.getSimplePttSettings()->getRgbColor();
+    }
+    if (featureSettingsKeys.contains("rxDeviceSetIndex")) {
+        settings.m_rxDeviceSetIndex = response.getSimplePttSettings()->getRxDeviceSetIndex();
+    }
+    if (featureSettingsKeys.contains("txDeviceSetIndex")) {
+        settings.m_txDeviceSetIndex = response.getSimplePttSettings()->getTxDeviceSetIndex();
+    }
+    if (featureSettingsKeys.contains("rx2TxDelayMs")) {
+        settings.m_rx2TxDelayMs = response.getSimplePttSettings()->getRx2TxDelayMs();
+    }
+    if (featureSettingsKeys.contains("tx2RxDelayMs")) {
+        settings.m_tx2RxDelayMs = response.getSimplePttSettings()->getTx2RxDelayMs();
+    }
+}
+
+void SimplePTT::webapiFormatFeatureReport(SWGSDRangel::SWGFeatureReport& response)
+{
+    response.getSimplePttReport()->setPtt(m_ptt ? 1 : 0);
+}
+
+void SimplePTT::webapiReverseSendSettings(QList<QString>& channelSettingsKeys, const SimplePTTSettings& settings, bool force)
+{
+    SWGSDRangel::SWGFeatureSettings *swgFeatureSettings = new SWGSDRangel::SWGFeatureSettings();
+    // swgFeatureSettings->setOriginatorFeatureIndex(getIndexInDeviceSet());
+    // swgFeatureSettings->setOriginatorFeatureSetIndex(getDeviceSetIndex());
+    swgFeatureSettings->setFeatureType(new QString("SimplePTT"));
+    swgFeatureSettings->setSimplePttSettings(new SWGSDRangel::SWGSimplePTTSettings());
+    SWGSDRangel::SWGSimplePTTSettings *swgSimplePTTSettings = swgFeatureSettings->getSimplePttSettings();
+
+    // transfer data that has been modified. When force is on transfer all data except reverse API data
+
+    if (channelSettingsKeys.contains("title") || force) {
+        swgSimplePTTSettings->setTitle(new QString(settings.m_title));
+    }
+    if (channelSettingsKeys.contains("rgbColor") || force) {
+        swgSimplePTTSettings->setRgbColor(settings.m_rgbColor);
+    }
+    if (channelSettingsKeys.contains("rxDeviceSetIndex") || force) {
+        swgSimplePTTSettings->setRxDeviceSetIndex(settings.m_rxDeviceSetIndex);
+    }
+    if (channelSettingsKeys.contains("txDeviceSetIndex") || force) {
+        swgSimplePTTSettings->setTxDeviceSetIndex(settings.m_txDeviceSetIndex);
+    }
+    if (channelSettingsKeys.contains("rx2TxDelayMs") || force) {
+        swgSimplePTTSettings->setRx2TxDelayMs(settings.m_rx2TxDelayMs);
+    }
+    if (channelSettingsKeys.contains("tx2RxDelayMs") || force) {
+        swgSimplePTTSettings->setTx2RxDelayMs(settings.m_tx2RxDelayMs);
+    }
+
+    QString channelSettingsURL = QString("http://%1:%2/sdrangel/featureset/%3/feature/%4/settings")
+            .arg(settings.m_reverseAPIAddress)
+            .arg(settings.m_reverseAPIPort)
+            .arg(settings.m_reverseAPIDeviceIndex)
+            .arg(settings.m_reverseAPIChannelIndex);
+    m_networkRequest.setUrl(QUrl(channelSettingsURL));
+    m_networkRequest.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
+
+    QBuffer *buffer = new QBuffer();
+    buffer->open((QBuffer::ReadWrite));
+    buffer->write(swgFeatureSettings->asJson().toUtf8());
+    buffer->seek(0);
+
+    // Always use PATCH to avoid passing reverse API settings
+    QNetworkReply *reply = m_networkManager->sendCustomRequest(m_networkRequest, "PATCH", buffer);
+    buffer->setParent(reply);
+
+    delete swgFeatureSettings;
+}
+
+void SimplePTT::networkManagerFinished(QNetworkReply *reply)
+{
+    QNetworkReply::NetworkError replyError = reply->error();
+
+    if (replyError)
+    {
+        qWarning() << "SimplePTT::networkManagerFinished:"
+                << " error(" << (int) replyError
+                << "): " << replyError
+                << ": " << reply->errorString();
+    }
+    else
+    {
+        QString answer = reply->readAll();
+        answer.chop(1); // remove last \n
+        qDebug("SimplePTT::networkManagerFinished: reply:\n%s", answer.toStdString().c_str());
+    }
+
+    reply->deleteLater();
+}

plugins/feature/simpleptt/simpleptt.h

@@ -19,6 +19,7 @@
 #define INCLUDE_FEATURE_SIMPLEPTT_H_
 
 #include <QThread>
+#include <QNetworkRequest>
 
 #include "feature/feature.h"
 #include "util/message.h"
@@ -27,6 +28,12 @@
 
 class WebAPIAdapterInterface;
 class SimplePTTWorker;
+class QNetworkAccessManager;
+class QNetworkReply;
+
+namespace SWGSDRangel {
+    class SWGDeviceState;
+}
 
 class SimplePTT : public Feature
 {
@@ -91,18 +98,50 @@ public:
             m_startStop(startStop)
         { }
     };
-    
+
     SimplePTT(WebAPIAdapterInterface *webAPIAdapterInterface);
     ~SimplePTT();
     virtual void destroy() { delete this; }
-    virtual bool handleMessage(const Message& cmd);   
-    
-    virtual void getIdentifier(QString& id) { id = objectName(); }
-    virtual void getTitle(QString& title) { title = m_settings.m_title; }
+    virtual bool handleMessage(const Message& cmd);
+
+    virtual void getIdentifier(QString& id) const { id = objectName(); }
+    virtual void getTitle(QString& title) const { title = m_settings.m_title; }
 
     virtual QByteArray serialize() const;
     virtual bool deserialize(const QByteArray& data);
 
+    virtual int webapiRun(bool run,
+            SWGSDRangel::SWGDeviceState& response,
+            QString& errorMessage);
+
+    virtual int webapiSettingsGet(
+            SWGSDRangel::SWGFeatureSettings& response,
+            QString& errorMessage);
+
+    virtual int webapiSettingsPutPatch(
+            bool force,
+            const QStringList& featureSettingsKeys,
+            SWGSDRangel::SWGFeatureSettings& response,
+            QString& errorMessage);
+
+    virtual int webapiReportGet(
+            SWGSDRangel::SWGFeatureReport& response,
+            QString& errorMessage);
+
+    virtual int webapiActionsPost(
+            const QStringList& featureActionsKeys,
+            SWGSDRangel::SWGFeatureActions& query,
+            QString& errorMessage);
+
+    static void webapiFormatFeatureSettings(
+        SWGSDRangel::SWGFeatureSettings& response,
+        const SimplePTTSettings& settings);
+
+    static void webapiUpdateFeatureSettings(
+            SimplePTTSettings& settings,
+            const QStringList& featureSettingsKeys,
+            SWGSDRangel::SWGFeatureSettings& response);
+
     static const QString m_featureIdURI;
     static const QString m_featureId;
 
@@ -110,10 +149,19 @@ private:
     QThread m_thread;
     SimplePTTWorker *m_worker;
     SimplePTTSettings m_settings;
+    bool m_ptt;
+
+    QNetworkAccessManager *m_networkManager;
+    QNetworkRequest m_networkRequest;
 
     void start();
     void stop();
     void applySettings(const SimplePTTSettings& settings, bool force = false);
+    void webapiFormatFeatureReport(SWGSDRangel::SWGFeatureReport& response);
+    void webapiReverseSendSettings(QList<QString>& featureSettingsKeys, const SimplePTTSettings& settings, bool force);
+
+private slots:
+    void networkManagerFinished(QNetworkReply *reply);
 };
 
-#endif // INCLUDE_FEATURE_SIMPLEPTT_H_
+#endif // INCLUDE_FEATURE_SIMPLEPTT_H_

plugins/feature/simpleptt/simplepttgui.cpp

@@ -62,13 +62,13 @@ QByteArray SimplePTTGUI::serialize() const
 
 bool SimplePTTGUI::deserialize(const QByteArray& data)
 {
-    if (m_settings.deserialize(data)) 
+    if (m_settings.deserialize(data))
     {
         displaySettings();
         applySettings(true);
         return true;
-    } 
-    else 
+    }
+    else
     {
         resetToDefaults();
         return false;
@@ -87,7 +87,7 @@ bool SimplePTTGUI::handleMessage(const Message& message)
         blockApplySettings(false);
 
         return true;
-    } 
+    }
     else if (SimplePTTReport::MsgRadioState::match(message))
     {
         qDebug("SimplePTTGUI::handleMessage: SimplePTTReport::MsgRadioState");
@@ -95,8 +95,19 @@ bool SimplePTTGUI::handleMessage(const Message& message)
         SimplePTTReport::RadioState state = cfg.getState();
         ui->statusIndicator->setStyleSheet("QLabel { background-color: " +
 			m_statusColors[(int) state] + "; border-radius: 12px; }");
-        ui->statusIndicator->setToolTip(m_statusTooltips[(int) state]);            
-        
+        ui->statusIndicator->setToolTip(m_statusTooltips[(int) state]);
+
+        return true;
+    }
+    else if (SimplePTT::MsgPTT::match(message))
+    {
+        qDebug("SimplePTTGUI::handleMessage: SimplePTT::MsgPTT");
+        const SimplePTT::MsgPTT& cfg = (SimplePTT::MsgPTT&) message;
+        bool ptt = cfg.getTx();
+        ui->ptt->blockSignals(true);
+        ui->ptt->setChecked(ptt);
+        ui->ptt->blockSignals(false);
+
         return true;
     }
 
@@ -136,12 +147,12 @@ SimplePTTGUI::SimplePTTGUI(PluginAPI* pluginAPI, FeatureUISet *featureUISet, Fea
     m_simplePTT = reinterpret_cast<SimplePTT*>(feature);
     m_simplePTT->setMessageQueueToGUI(&m_inputMessageQueue);
 
-    m_featureUISet->registerFeatureInstance(SimplePTT::m_featureIdURI, this);
+    m_featureUISet->registerFeatureInstance(SimplePTT::m_featureIdURI, this, m_simplePTT);
 	m_featureUISet->addRollupWidget(this);
 
     connect(this, SIGNAL(customContextMenuRequested(const QPoint &)), this, SLOT(onMenuDialogCalled(const QPoint &)));
     connect(getInputMessageQueue(), SIGNAL(messageEnqueued()), this, SLOT(handleInputMessages()));
-	
+
 	connect(&m_statusTimer, SIGNAL(timeout()), this, SLOT(updateStatus()));
 	m_statusTimer.start(1000);
 
@@ -174,6 +185,10 @@ void SimplePTTGUI::displaySettings()
 {
     setTitleColor(m_settings.m_rgbColor);
     setWindowTitle(m_settings.m_title);
+    blockApplySettings(true);
+    ui->rxtxDelay->setValue(m_settings.m_rx2TxDelayMs);
+    ui->txrxDelay->setValue(m_settings.m_tx2RxDelayMs);
+    blockApplySettings(false);
 }
 
 void SimplePTTGUI::updateDeviceSetLists()
@@ -208,26 +223,39 @@ void SimplePTTGUI::updateDeviceSetLists()
         }
     }
 
+    int rxDeviceIndex;
+    int txDeviceIndex;
+
     if (rxIndex > 0)
     {
         if (m_settings.m_rxDeviceSetIndex < 0) {
-            ui->rxDevice->setCurrentIndex(0);    
+            ui->rxDevice->setCurrentIndex(0);
         } else {
-            ui->rxDevice->setCurrentIndex(m_settings.m_rxDeviceSetIndex); 
+            ui->rxDevice->setCurrentIndex(m_settings.m_rxDeviceSetIndex);
         }
+
+        rxDeviceIndex = ui->rxDevice->currentData().toInt();
     }
-    
+    else
+    {
+        rxDeviceIndex = -1;
+    }
+
+
     if (txIndex > 0)
     {
         if (m_settings.m_txDeviceSetIndex < 0) {
-            ui->txDevice->setCurrentIndex(0);    
+            ui->txDevice->setCurrentIndex(0);
         } else {
             ui->txDevice->setCurrentIndex(m_settings.m_txDeviceSetIndex);
         }
+
+        txDeviceIndex = ui->txDevice->currentData().toInt();
+    }
+    else
+    {
+        txDeviceIndex = -1;
     }
-    
-    int rxDeviceIndex = ui->rxDevice->currentData().toInt();
-    int txDeviceIndex = ui->txDevice->currentData().toInt();
 
     if ((rxDeviceIndex != m_settings.m_rxDeviceSetIndex) ||
         (txDeviceIndex != m_settings.m_txDeviceSetIndex))
@@ -257,12 +285,22 @@ void SimplePTTGUI::onMenuDialogCalled(const QPoint &p)
         BasicFeatureSettingsDialog dialog(this);
         dialog.setTitle(m_settings.m_title);
         dialog.setColor(m_settings.m_rgbColor);
+        dialog.setUseReverseAPI(m_settings.m_useReverseAPI);
+        dialog.setReverseAPIAddress(m_settings.m_reverseAPIAddress);
+        dialog.setReverseAPIPort(m_settings.m_reverseAPIPort);
+        dialog.setReverseAPIDeviceIndex(m_settings.m_reverseAPIDeviceIndex);
+        dialog.setReverseAPIChannelIndex(m_settings.m_reverseAPIChannelIndex);
 
         dialog.move(p);
         dialog.exec();
 
         m_settings.m_rgbColor = dialog.getColor().rgb();
         m_settings.m_title = dialog.getTitle();
+        m_settings.m_useReverseAPI = dialog.useReverseAPI();
+        m_settings.m_reverseAPIAddress = dialog.getReverseAPIAddress();
+        m_settings.m_reverseAPIPort = dialog.getReverseAPIPort();
+        m_settings.m_reverseAPIDeviceIndex = dialog.getReverseAPIDeviceIndex();
+        m_settings.m_reverseAPIChannelIndex = dialog.getReverseAPIChannelIndex();
 
         setWindowTitle(m_settings.m_title);
         setTitleColor(m_settings.m_rgbColor);

plugins/feature/simpleptt/simplepttgui.ui

@@ -146,7 +146,7 @@
          </size>
         </property>
         <property name="toolTip">
-         <string>Refresh indexes of available local devices</string>
+         <string>Refresh indexes of available device sets</string>
         </property>
         <property name="text">
          <string/>

plugins/feature/simpleptt/simplepttsettings.cpp

@@ -33,8 +33,13 @@ void SimplePTTSettings::resetToDefaults()
     m_rgbColor = QColor(255, 0, 0).rgb();
     m_rxDeviceSetIndex = -1;
     m_txDeviceSetIndex = -1;
-    m_rx2TxDelayMs = 0;
-    m_tx2RxDelayMs = 0;
+    m_rx2TxDelayMs = 100;
+    m_tx2RxDelayMs = 100;
+    m_useReverseAPI = false;
+    m_reverseAPIAddress = "127.0.0.1";
+    m_reverseAPIPort = 8888;
+    m_reverseAPIDeviceIndex = 0;
+    m_reverseAPIChannelIndex = 0;
 }
 
 QByteArray SimplePTTSettings::serialize() const
@@ -47,7 +52,12 @@ QByteArray SimplePTTSettings::serialize() const
     s.writeS32(4, m_txDeviceSetIndex);
     s.writeU32(5, m_rx2TxDelayMs);
     s.writeU32(6, m_tx2RxDelayMs);
-    
+    s.writeBool(7, m_useReverseAPI);
+    s.writeString(8, m_reverseAPIAddress);
+    s.writeU32(9, m_reverseAPIPort);
+    s.writeU32(10, m_reverseAPIDeviceIndex);
+    s.writeU32(11, m_reverseAPIChannelIndex);
+
     return s.final();
 }
 
@@ -72,8 +82,22 @@ bool SimplePTTSettings::deserialize(const QByteArray& data)
         d.readU32(2, &m_rgbColor, QColor(255, 0, 0).rgb());
         d.readS32(3, &m_rxDeviceSetIndex, -1);
         d.readS32(4, &m_txDeviceSetIndex, -1);
-        d.readU32(5, &m_rx2TxDelayMs, 0);
-        d.readU32(6, &m_tx2RxDelayMs, 0);
+        d.readU32(5, &m_rx2TxDelayMs, 100);
+        d.readU32(6, &m_tx2RxDelayMs, 100);
+        d.readBool(7, &m_useReverseAPI, false);
+        d.readString(8, &m_reverseAPIAddress, "127.0.0.1");
+        d.readU32(9, &utmp, 0);
+
+        if ((utmp > 1023) && (utmp < 65535)) {
+            m_reverseAPIPort = utmp;
+        } else {
+            m_reverseAPIPort = 8888;
+        }
+
+        d.readU32(10, &utmp, 0);
+        m_reverseAPIDeviceIndex = utmp > 99 ? 99 : utmp;
+        d.readU32(11, &utmp, 0);
+        m_reverseAPIChannelIndex = utmp > 99 ? 99 : utmp;
 
         return true;
     }

plugins/feature/simpleptt/simplepttsettings.h

@@ -31,6 +31,11 @@ struct SimplePTTSettings
     int m_txDeviceSetIndex;
     unsigned int m_rx2TxDelayMs;
     unsigned int m_tx2RxDelayMs;
+    bool m_useReverseAPI;
+    QString m_reverseAPIAddress;
+    uint16_t m_reverseAPIPort;
+    uint16_t m_reverseAPIDeviceIndex;
+    uint16_t m_reverseAPIChannelIndex;
 
     SimplePTTSettings();
     void resetToDefaults();

plugins/feature/simpleptt/simplepttworker.cpp

@@ -33,6 +33,7 @@ SimplePTTWorker::SimplePTTWorker(WebAPIAdapterInterface *webAPIAdapterInterface)
     m_webAPIAdapterInterface(webAPIAdapterInterface),
     m_msgQueueToGUI(nullptr),
     m_running(false),
+    m_tx(false),
     m_mutex(QMutex::Recursive)
 {
     qDebug("SimplePTTWorker::SimplePTTWorker");