Ref T610, added COM async getter functions and bundled async calls

* reduced the number of async XSwiftBus calls by getting multiple values at once
* the concept was already used for getOwnAircraftSituationDataAsync
* now also used for COM, parts, model and lights
* As Qt restricts to 8 parameters not further bundled
* new COM1 getter functions for receive/volume/transmit

src/plugins/simulator/xplane/simulatorxplane.cpp

@@ -205,22 +205,18 @@ namespace BlackSimPlugin
         {
             if (this->isConnected())
             {
-                m_serviceProxy->getOwnAircraftSituationData(&m_xplaneData);
-                m_serviceProxy->getCom1ActiveKhzAsync(&m_xplaneData.com1ActiveKhz);
-                m_serviceProxy->getCom1StandbyKhzAsync(&m_xplaneData.com1StandbyKhz);
-                m_serviceProxy->getCom2ActiveKhzAsync(&m_xplaneData.com2ActiveKhz);
-                m_serviceProxy->getCom2StandbyKhzAsync(&m_xplaneData.com2StandbyKhz);
-                m_serviceProxy->getTransponderCodeAsync(&m_xplaneData.xpdrCode);
-                m_serviceProxy->getTransponderModeAsync(&m_xplaneData.xpdrMode);
-                m_serviceProxy->getTransponderIdentAsync(&m_xplaneData.xpdrIdent);
+                m_serviceProxy->getOwnAircraftSituationDataAsync(&m_xplaneData);
+                m_serviceProxy->getOwnAircraftCom1DataAsync(&m_xplaneData);
+                m_serviceProxy->getOwnAircraftCom2DataAsync(&m_xplaneData);
+                m_serviceProxy->getOwnAircraftXpdrAsync(&m_xplaneData);
                 m_serviceProxy->getAllWheelsOnGroundAsync(&m_xplaneData.onGroundAll);
 
                 CAircraftSituation situation;
                 situation.setPosition({ m_xplaneData.latitudeDeg, m_xplaneData.longitudeDeg, 0 });
-                CAltitude altitude { m_xplaneData.altitudeM, CAltitude::MeanSeaLevel, CLengthUnit::m() };
-                situation.setAltitude({ m_xplaneData.altitudeM, CAltitude::MeanSeaLevel, CLengthUnit::m() });
-                CPressure seaLevelPressure({ m_xplaneData.seaLevelPressureInHg, CPressureUnit::inHg() });
-                CAltitude pressureAltitude(altitude.toPressureAltitude(seaLevelPressure));
+                const CAltitude altitude { m_xplaneData.altitudeM, CAltitude::MeanSeaLevel, CLengthUnit::m() };
+                situation.setAltitude(altitude);
+                const CPressure seaLevelPressure({ m_xplaneData.seaLevelPressureInHg, CPressureUnit::inHg() });
+                const CAltitude pressureAltitude(altitude.toPressureAltitude(seaLevelPressure));
                 situation.setPressureAltitude(pressureAltitude);
                 situation.setHeading({ m_xplaneData.trueHeadingDeg, CHeading::True, CAngleUnit::deg() });
                 situation.setPitch({ m_xplaneData.pitchDeg, CAngleUnit::deg() });
@@ -241,10 +237,20 @@ namespace BlackSimPlugin
                 // updates
                 com1.setFrequencyActive(CFrequency(m_xplaneData.com1ActiveKhz, CFrequencyUnit::kHz()));
                 com1.setFrequencyStandby(CFrequency(m_xplaneData.com1StandbyKhz, CFrequencyUnit::kHz()));
+                const int v1 = qRound(m_xplaneData.com1Volume);
+                com1.setVolumeReceive(v1);
+                com1.setVolumeTransmit(v1);
+                com1.setReceiveEnabled(m_xplaneData.isCom1Receiving);
+                com1.setTransmitEnabled(m_xplaneData.isCom1Transmitting);
                 const bool changedCom1 = myAircraft.getCom1System() != com1;
 
                 com2.setFrequencyActive(CFrequency(m_xplaneData.com2ActiveKhz, CFrequencyUnit::kHz()));
                 com2.setFrequencyStandby(CFrequency(m_xplaneData.com2StandbyKhz, CFrequencyUnit::kHz()));
+                const int v2 = qRound(m_xplaneData.com1Volume);
+                com2.setVolumeReceive(v2);
+                com2.setVolumeTransmit(v2);
+                com2.setReceiveEnabled(m_xplaneData.isCom2Receiving);
+                com2.setTransmitEnabled(m_xplaneData.isCom2Transmitting);
                 const bool changedCom2 = myAircraft.getCom2System() != com2;
 
                 transponder = CTransponder::getStandardTransponder(m_xplaneData.xpdrCode, xpdrMode(m_xplaneData.xpdrMode, m_xplaneData.xpdrIdent));
@@ -268,7 +274,7 @@ namespace BlackSimPlugin
                             requestWeatherGrid(weatherGrid, { this, &CSimulatorXPlane::injectWeatherGrid });
                         }
                     }
-                }
+                } // weather
             }
         }
 
@@ -277,17 +283,9 @@ namespace BlackSimPlugin
             if (isConnected())
             {
                 // own aircraft data
-                m_serviceProxy->getAircraftModelPathAsync(&m_xplaneData.aircraftModelPath); // this is NOT the model string
-                m_serviceProxy->getAircraftIcaoCodeAsync(&m_xplaneData.aircraftIcaoCode);
-                m_serviceProxy->getBeaconLightsOnAsync(&m_xplaneData.beaconLightsOn);
-                m_serviceProxy->getLandingLightsOnAsync(&m_xplaneData.landingLightsOn);
-                m_serviceProxy->getNavLightsOnAsync(&m_xplaneData.navLightsOn);
-                m_serviceProxy->getStrobeLightsOnAsync(&m_xplaneData.strobeLightsOn);
-                m_serviceProxy->getTaxiLightsOnAsync(&m_xplaneData.taxiLightsOn);
-                m_serviceProxy->getFlapsDeployRatioAsync(&m_xplaneData.flapsReployRatio);
-                m_serviceProxy->getGearDeployRatioAsync(&m_xplaneData.gearReployRatio);
-                m_serviceProxy->getEngineN1PercentageAsync(&m_xplaneData.enginesN1Percentage);
-                m_serviceProxy->getSpeedBrakeRatioAsync(&m_xplaneData.speedBrakeRatio);
+                m_serviceProxy->getOwnAircraftModelDataAsync(&m_xplaneData);
+                m_serviceProxy->getOwnAircraftLightsAsync(&m_xplaneData);
+                m_serviceProxy->getOwnAircraftPartsAsync(&m_xplaneData);
 
                 CAircraftEngineList engines;
                 for (int engineNumber = 0; engineNumber < m_xplaneData.enginesN1Percentage.size(); ++engineNumber)
@@ -298,7 +296,7 @@ namespace BlackSimPlugin
                     engines.push_back(engine);
                 }
 
-                CAircraftParts parts { {
+                const CAircraftParts parts { {
                         m_xplaneData.strobeLightsOn, m_xplaneData.landingLightsOn, m_xplaneData.taxiLightsOn,
                         m_xplaneData.beaconLightsOn, m_xplaneData.navLightsOn, false
                     },
@@ -324,9 +322,8 @@ namespace BlackSimPlugin
                     xplaneAircraft.setSimulatedAircraft(simulatedAircraft);
                 }
 
-                int i = 0;
-
                 // remove the invalid ones
+                int i = 0;
                 for (const CCallsign &cs : invalid)
                 {
                     this->triggerRemoveAircraft(cs, ++i * 100);

src/plugins/simulator/xplane/xswiftbusserviceproxy.cpp

@@ -43,8 +43,9 @@ namespace BlackSimPlugin
             return m_dbusInterface->callDBusRet<QString>(QLatin1String("getVersionNumber"));
         }
 
-        void CXSwiftBusServiceProxy::getOwnAircraftSituationData(XPlaneData *o_xplaneData)
+        void CXSwiftBusServiceProxy::getOwnAircraftSituationDataAsync(XPlaneData *o_xplaneData)
         {
+            if (!o_xplaneData) { return; }
             QPointer<CXSwiftBusServiceProxy> myself(this);
             std::function<void(QDBusPendingCallWatcher *)> callback = [ = ](QDBusPendingCallWatcher * watcher)
             {
@@ -66,6 +67,126 @@ namespace BlackSimPlugin
             m_dbusInterface->callDBusAsync(QLatin1String("getOwnAircraftSituationData"), callback);
         }
 
+        void CXSwiftBusServiceProxy::getOwnAircraftCom1DataAsync(XPlaneData *o_xplaneData)
+        {
+            if (!o_xplaneData) { return; }
+            QPointer<CXSwiftBusServiceProxy> myself(this);
+            std::function<void(QDBusPendingCallWatcher *)> callback = [ = ](QDBusPendingCallWatcher * watcher)
+            {
+                if (!myself) { return; }
+                QDBusPendingReply<int, int, double, bool, bool> reply = *watcher;
+                if (!reply.isError())
+                {
+                    o_xplaneData->com1ActiveKhz = reply.argumentAt<0>();
+                    o_xplaneData->com1StandbyKhz = reply.argumentAt<1>();
+                    o_xplaneData->com1Volume = reply.argumentAt<2>();
+                    o_xplaneData->isCom1Receiving = reply.argumentAt<3>();
+                    o_xplaneData->isCom1Transmitting = reply.argumentAt<4>();
+                }
+                watcher->deleteLater();
+            };
+            m_dbusInterface->callDBusAsync(QLatin1String("getOwnAircraftCom1Data"), callback);
+        }
+
+        void CXSwiftBusServiceProxy::getOwnAircraftCom2DataAsync(XPlaneData *o_xplaneData)
+        {
+            if (!o_xplaneData) { return; }
+            QPointer<CXSwiftBusServiceProxy> myself(this);
+            std::function<void(QDBusPendingCallWatcher *)> callback = [ = ](QDBusPendingCallWatcher * watcher)
+            {
+                if (!myself) { return; }
+                QDBusPendingReply<int, int, double, bool, bool> reply = *watcher;
+                if (!reply.isError())
+                {
+                    o_xplaneData->com2ActiveKhz = reply.argumentAt<0>();
+                    o_xplaneData->com2StandbyKhz = reply.argumentAt<1>();
+                    o_xplaneData->com2Volume = reply.argumentAt<2>();
+                    o_xplaneData->isCom2Receiving = reply.argumentAt<3>();
+                    o_xplaneData->isCom2Transmitting = reply.argumentAt<4>();
+                }
+                watcher->deleteLater();
+            };
+            m_dbusInterface->callDBusAsync(QLatin1String("getOwnAircraftCom2Data"), callback);
+        }
+
+        void CXSwiftBusServiceProxy::getOwnAircraftXpdrAsync(XPlaneData *o_xplaneData)
+        {
+            if (!o_xplaneData) { return; }
+            QPointer<CXSwiftBusServiceProxy> myself(this);
+            std::function<void(QDBusPendingCallWatcher *)> callback = [ = ](QDBusPendingCallWatcher * watcher)
+            {
+                if (!myself) { return; }
+                QDBusPendingReply<int, int, bool> reply = *watcher;
+                if (!reply.isError())
+                {
+                    o_xplaneData->xpdrCode  = reply.argumentAt<0>();
+                    o_xplaneData->xpdrMode  = reply.argumentAt<1>();
+                    o_xplaneData->xpdrIdent = reply.argumentAt<2>();
+                }
+                watcher->deleteLater();
+            };
+            m_dbusInterface->callDBusAsync(QLatin1String("getOwnAircraftXpdr"), callback);
+        }
+
+        void CXSwiftBusServiceProxy::getOwnAircraftLightsAsync(XPlaneData *o_xplaneData)
+        {
+            if (!o_xplaneData) { return; }
+            QPointer<CXSwiftBusServiceProxy> myself(this);
+            std::function<void(QDBusPendingCallWatcher *)> callback = [ = ](QDBusPendingCallWatcher * watcher)
+            {
+                if (!myself) { return; }
+                QDBusPendingReply<bool, bool, bool, bool, bool> reply = *watcher;
+                if (!reply.isError())
+                {
+                    o_xplaneData->beaconLightsOn   = reply.argumentAt<0>();
+                    o_xplaneData->landingLightsOn  = reply.argumentAt<1>();
+                    o_xplaneData->navLightsOn      = reply.argumentAt<2>();
+                    o_xplaneData->strobeLightsOn   = reply.argumentAt<3>();
+                    o_xplaneData->taxiLightsOn     = reply.argumentAt<4>();
+                }
+                watcher->deleteLater();
+            };
+            m_dbusInterface->callDBusAsync(QLatin1String("getOwnAircraftLights"), callback);
+        }
+
+        void CXSwiftBusServiceProxy::getOwnAircraftPartsAsync(XPlaneData *o_xplaneData)
+        {
+            if (!o_xplaneData) { return; }
+            QPointer<CXSwiftBusServiceProxy> myself(this);
+            std::function<void(QDBusPendingCallWatcher *)> callback = [ = ](QDBusPendingCallWatcher * watcher)
+            {
+                if (!myself) { return; }
+                QDBusPendingReply<double, double, double, QList<double> > reply = *watcher;
+                if (!reply.isError())
+                {
+                    o_xplaneData->flapsReployRatio = reply.argumentAt<0>();
+                    o_xplaneData->gearReployRatio  = reply.argumentAt<1>();
+                    o_xplaneData->speedBrakeRatio  = reply.argumentAt<2>();
+                    o_xplaneData->enginesN1Percentage = reply.argumentAt<3>();
+                }
+                watcher->deleteLater();
+            };
+            m_dbusInterface->callDBusAsync(QLatin1String("getOwnAircraftParts"), callback);
+        }
+
+        void CXSwiftBusServiceProxy::getOwnAircraftModelDataAsync(XPlaneData *o_xplaneData)
+        {
+            if (!o_xplaneData) { return; }
+            QPointer<CXSwiftBusServiceProxy> myself(this);
+            std::function<void(QDBusPendingCallWatcher *)> callback = [ = ](QDBusPendingCallWatcher * watcher)
+            {
+                if (!myself) { return; }
+                QDBusPendingReply<QString, QString> reply = *watcher;
+                if (!reply.isError())
+                {
+                    o_xplaneData->aircraftModelPath = reply.argumentAt<0>(); // this is NOT the model string
+                    o_xplaneData->aircraftIcaoCode  = reply.argumentAt<1>();
+                }
+                watcher->deleteLater();
+            };
+            m_dbusInterface->callDBusAsync(QLatin1String("getOwnAircraftModelData"), callback);
+        }
+
         void CXSwiftBusServiceProxy::addTextMessage(const QString &text, double red, double green, double blue)
         {
             m_dbusInterface->callDBus(QLatin1String("addTextMessage"), text, red, green, blue);

src/plugins/simulator/xplane/xswiftbusserviceproxy.h

@@ -101,7 +101,25 @@ namespace BlackSimPlugin
             QString getVersionNumber();
 
             //! Get own aircraft situation data
-            void getOwnAircraftSituationData(BlackSimPlugin::XPlane::XPlaneData *o_xplaneData);
+            void getOwnAircraftSituationDataAsync(BlackSimPlugin::XPlane::XPlaneData *o_xplaneData);
+
+            //! Get own aircraft COM1 data
+            void getOwnAircraftCom1DataAsync(BlackSimPlugin::XPlane::XPlaneData *o_xplaneData);
+
+            //! Get own aircraft COM2 data
+            void getOwnAircraftCom2DataAsync(BlackSimPlugin::XPlane::XPlaneData *o_xplaneData);
+
+            //! Get own XPDR data
+            void getOwnAircraftXpdrAsync(BlackSimPlugin::XPlane::XPlaneData *o_xplaneData);
+
+            //! Get own lights data
+            void getOwnAircraftLightsAsync(BlackSimPlugin::XPlane::XPlaneData *o_xplaneData);
+
+            //! Get own parts such as gear, flaps
+            void getOwnAircraftPartsAsync(BlackSimPlugin::XPlane::XPlaneData *o_xplaneData);
+
+            //! Get own model data
+            void getOwnAircraftModelDataAsync(BlackSimPlugin::XPlane::XPlaneData *o_xplaneData);
 
             //! \copydoc XSwiftBus::CService::addTextMessage
             void addTextMessage(const QString &text, double red, double green, double blue);

src/xswiftbus/service.cpp

@@ -275,14 +275,14 @@ namespace XSwiftBus
             {
                 queueDBusCall([ = ]()
                 {
-                    double lat = m_latitude.get();
-                    double lon = m_longitude.get();
-                    double alt = m_elevation.get();
-                    double gs = m_groundSpeed.get();
-                    double pitch = m_pitch.get();
-                    double roll = m_roll.get();
-                    double trueHeading = m_heading.get();
-                    double qnh = m_qnhInhg.get();
+                    const double lat = m_latitude.get();
+                    const double lon = m_longitude.get();
+                    const double alt = m_elevation.get();
+                    const double gs = m_groundSpeed.get();
+                    const double pitch = m_pitch.get();
+                    const double roll = m_roll.get();
+                    const double trueHeading = m_heading.get();
+                    const double qnh = m_qnhInhg.get();
                     CDBusMessage reply = CDBusMessage::createReply(sender, serial);
                     reply.beginArgumentWrite();
                     reply.appendArgument(lat);
@@ -296,6 +296,108 @@ namespace XSwiftBus
                     sendDBusMessage(reply);
                 });
             }
+            else if (message.getMethodName() == "getOwnAircraftCom1Data")
+            {
+                queueDBusCall([ = ]()
+                {
+                    const int active  = m_com1Active.get();
+                    const int standby = m_com1Standby.get();
+                    const double volume = m_com1Volume.get();
+                    const bool rec = this->isCom1Receiving();
+                    const bool tx  = this->isCom1Transmitting();
+                    CDBusMessage reply = CDBusMessage::createReply(sender, serial);
+                    reply.beginArgumentWrite();
+                    reply.appendArgument(active);
+                    reply.appendArgument(standby);
+                    reply.appendArgument(volume);
+                    reply.appendArgument(rec);
+                    reply.appendArgument(tx);
+                    sendDBusMessage(reply);
+                });
+            }
+            else if (message.getMethodName() == "getOwnAircraftCom2Data")
+            {
+                queueDBusCall([ = ]()
+                {
+                    const int active  = m_com2Active.get();
+                    const int standby = m_com2Standby.get();
+                    const double volume = m_com2Volume.get();
+                    const bool rec = this->isCom2Receiving();
+                    const bool tx  = this->isCom2Transmitting();
+                    CDBusMessage reply = CDBusMessage::createReply(sender, serial);
+                    reply.beginArgumentWrite();
+                    reply.appendArgument(active);
+                    reply.appendArgument(standby);
+                    reply.appendArgument(volume);
+                    reply.appendArgument(rec);
+                    reply.appendArgument(tx);
+                    sendDBusMessage(reply);
+                });
+            }
+            else if (message.getMethodName() == "getOwnAircraftXpdr")
+            {
+                queueDBusCall([ = ]()
+                {
+                    const int code = m_xpdrCode.get();
+                    const int mode = m_xpdrMode.get();
+                    const bool id  = m_xpdrIdent.get();
+                    CDBusMessage reply = CDBusMessage::createReply(sender, serial);
+                    reply.beginArgumentWrite();
+                    reply.appendArgument(code);
+                    reply.appendArgument(mode);
+                    reply.appendArgument(id);
+                    sendDBusMessage(reply);
+                });
+            }
+            else if (message.getMethodName() == "getOwnAircraftLights")
+            {
+                queueDBusCall([ = ]()
+                {
+                    const bool beaconLightsOn  = m_beaconLightsOn.get();
+                    const bool landingLightsOn = m_landingLightsOn.get();
+                    const bool navLightsOn     = m_navLightsOn.get();
+                    const bool strobeLightsOn  = m_strobeLightsOn.get();
+                    const bool taxiLightsOn    = m_taxiLightsOn.get();
+                    CDBusMessage reply = CDBusMessage::createReply(sender, serial);
+                    reply.beginArgumentWrite();
+                    reply.appendArgument(beaconLightsOn);
+                    reply.appendArgument(landingLightsOn);
+                    reply.appendArgument(navLightsOn);
+                    reply.appendArgument(strobeLightsOn);
+                    reply.appendArgument(taxiLightsOn);
+                    sendDBusMessage(reply);
+                });
+            }
+            else if (message.getMethodName() == "getOwnAircraftParts")
+            {
+                queueDBusCall([ = ]()
+                {
+                    const double flapsReployRatio = m_flapsReployRatio.get();
+                    const double gearReployRatio  = m_gearReployRatio.getAt(0);
+                    const double speedBrakeRatio  = m_speedBrakeRatio.get();
+                    const std::vector<double> enginesN1Percentage = this->getEngineN1Percentage();
+                    CDBusMessage reply = CDBusMessage::createReply(sender, serial);
+                    reply.beginArgumentWrite();
+                    reply.appendArgument(flapsReployRatio);
+                    reply.appendArgument(gearReployRatio);
+                    reply.appendArgument(speedBrakeRatio);
+                    reply.appendArgument(enginesN1Percentage);
+                    sendDBusMessage(reply);
+                });
+            }
+            else if (message.getMethodName() == "getOwnAircraftModelData")
+            {
+                queueDBusCall([ = ]()
+                {
+                    const std::string aircraftModelPath = this->getAircraftModelPath();
+                    const std::string aircraftIcaoCode  = this->getAircraftIcaoCode();
+                    CDBusMessage reply = CDBusMessage::createReply(sender, serial);
+                    reply.beginArgumentWrite();
+                    reply.appendArgument(aircraftModelPath);
+                    reply.appendArgument(aircraftIcaoCode);
+                    sendDBusMessage(reply);
+                });
+            }
             else if (message.getMethodName() == "updateAirportsInRange")
             {
                 maybeSendEmptyDBusReply(wantsReply, sender, serial);
@@ -703,8 +805,8 @@ namespace XSwiftBus
             {
                 queueDBusCall([ = ]()
                 {
-                    std::vector<double> array = getEngineN1Percentage();
-                    sendDBusReply(sender, serial, array);
+                    const std::vector<double> enginesN1Percentage = getEngineN1Percentage();
+                    sendDBusReply(sender, serial, enginesN1Percentage);
                 });
             }
             else if (message.getMethodName() == "getSpeedBrakeRatio")