simulatorflightgear.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2019 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_SIMPLUGIN_SIMULATOR_FLIGHTGEAR_H
#define SWIFT_SIMPLUGIN_SIMULATOR_FLIGHTGEAR_H
 
#include <QDBusConnection>
#include <QHash>
#include <QList>
#include <QObject>
#include <QPair>
#include <QString>
#include <QStringList>
#include <QTimer>
 
#include "flightgearmpaircraft.h"
 
#include "misc/aviation/airportlist.h"
#include "misc/aviation/callsignset.h"
#include "misc/geo/coordinategeodetic.h"
#include "misc/identifier.h"
#include "misc/pixmap.h"
#include "misc/pq/time.h"
#include "misc/pq/units.h"
#include "misc/sequence.h"
#include "misc/settingscache.h"
#include "misc/simulation/aircraftmodellist.h"
#include "misc/simulation/data/modelcaches.h"
#include "misc/simulation/settings/fgswiftbussettings.h"
#include "misc/simulation/settings/simulatorsettings.h"
#include "misc/simulation/simulatedaircraftlist.h"
#include "misc/statusmessage.h"
#include "plugins/simulator/flightgearconfig/simulatorflightgearconfig.h"
#include "plugins/simulator/plugincommon/simulatorplugincommon.h"
 
class QDBusServiceWatcher;
 
namespace swift::misc
{
    namespace aviation
    {
        class CAircraftParts;
        class CAircraftSituation;
        class CCallsign;
    } // namespace aviation
    namespace network
    {
        class CTextMessage;
    }
    namespace simulation
    {
        class CSimulatedAircraft;
        class CSimulatorPluginInfo;
        class IOwnAircraftProvider;
        class IRemoteAircraftProvider;
    } // namespace simulation
} // namespace swift::misc
 
namespace swift::simplugin::flightgear
{
    extern int FGSWIFTBUS_API_VERSION;
    extern QList<int> incompatibleVersions;
    class CFGSwiftBusServiceProxy;
    class CFGSwiftBusTrafficProxy;
 
    struct FlightgearData
    {
        QString aircraftModelPath; 
        QString aircraftIcaoCode; 
        double latitudeDeg = 0; 
        double longitudeDeg = 0; 
        double altitudeFt = 0; 
        double groundspeedKts = 0; 
        double pitchDeg = 0; 
        double rollDeg = 0; 
        double trueHeadingDeg = 0; 
        double velocityXMs = 0; 
        double velocityYMs = 0; 
        double velocityZMs = 0; 
        double pitchRateRadPerSec = 0; 
        double rollRateRadPerSec = 0; 
        double yawRateRadPerSec = 0; 
        bool onGroundAll = false; 
        int com1ActiveKhz = 122800; 
        int com1StandbyKhz = 122800; 
        int com2ActiveKhz = 122800; 
        int com2StandbyKhz = 122800; 
        int xpdrCode = 2000; 
        int xpdrMode = 0; 
        bool xpdrIdent = false; 
        bool beaconLightsOn = false; 
        bool landingLightsOn = false; 
        bool navLightsOn = false; 
        bool strobeLightsOn = false; 
        bool taxiLightsOn = false; 
        double flapsReployRatio = false; 
        double gearReployRatio = false; 
        QList<double> enginesN1Percentage; 
        double speedBrakeRatio = 0; 
        double pressureAltitudeFt = 0; 
        double groundElevation = 0; 
        double volumeCom1 = 1; 
        double volumeCom2 = 1; 
    };
 
    class CSimulatorFlightgear : public common::CSimulatorPluginCommon
    {
        Q_OBJECT
 
    public:
        CSimulatorFlightgear(const swift::misc::simulation::CSimulatorPluginInfo &info,
                             swift::misc::simulation::IOwnAircraftProvider *ownAircraftProvider,
                             swift::misc::simulation::IRemoteAircraftProvider *remoteAircraftProvider,
                             swift::misc::network::IClientProvider *clientProvider, QObject *parent = nullptr);
 
        virtual ~CSimulatorFlightgear() override;
 
        virtual bool connectTo() override;
        virtual bool disconnectFrom() override;
        virtual bool updateOwnSimulatorCockpit(const swift::misc::simulation::CSimulatedAircraft &aircraft,
                                               const swift::misc::CIdentifier &originator) override;
        virtual bool updateOwnSimulatorSelcal(const swift::misc::aviation::CSelcal &selcal,
                                              const swift::misc::CIdentifier &originator) override;
        virtual void displayStatusMessage(const swift::misc::CStatusMessage &message) const override;
        virtual void displayTextMessage(const swift::misc::network::CTextMessage &message) const override;
        virtual bool isPhysicallyRenderedAircraft(const swift::misc::aviation::CCallsign &callsign) const override;
        virtual swift::misc::aviation::CCallsignSet physicallyRenderedAircraft() const override;
        virtual void unload() override;
        virtual QString getStatisticsSimulatorSpecific() const override;
        virtual void resetAircraftStatistics() override;
        virtual swift::misc::CStatusMessageList
        getInterpolationMessages(const swift::misc::aviation::CCallsign &callsign) const override;
        virtual bool testSendSituationAndParts(const swift::misc::aviation::CCallsign &callsign,
                                               const swift::misc::aviation::CAircraftSituation &situation,
                                               const swift::misc::aviation::CAircraftParts &parts) override;
        virtual bool requestElevation(const swift::misc::geo::ICoordinateGeodetic &reference,
                                      const swift::misc::aviation::CCallsign &callsign) override;
 
    protected:
        virtual bool isConnected() const override;
        virtual bool
        physicallyAddRemoteAircraft(const swift::misc::simulation::CSimulatedAircraft &newRemoteAircraft) override;
        virtual bool physicallyRemoveRemoteAircraft(const swift::misc::aviation::CCallsign &callsign) override;
        virtual int physicallyRemoveAllRemoteAircraft() override;
        virtual void clearAllRemoteAircraftData() override;
        virtual bool isPaused() const override { return false; }
 
    private slots:
        void onDBusServiceUnregistered();
 
    private:
        enum DBusMode
        {
            Session,
            P2P
        };
 
        using QDoubleList = QList<double>;
 
        void emitOwnAircraftModelChanged(const QString &path, const QString &filename, const QString &livery,
                                         const QString &icao, const QString &modelString, const QString &name,
                                         const QString &description);
        void fastTimerTimeout();
        void slowTimerTimeout();
 
        void updateRemoteAircraft();
 
        void requestRemoteAircraftDataFromFlightgear();
        void requestRemoteAircraftDataFromFlightgear(const swift::misc::aviation::CCallsignSet &callsigns);
        void triggerRequestRemoteAircraftDataFromFlightgear(const swift::misc::aviation::CCallsignSet &callsigns);
 
        void addNextPendingAircraft();
        void triggerAddNextPendingAircraft();
 
        int detectTimeoutAdding();
 
        void triggerRemoveAircraft(const swift::misc::aviation::CCallsign &callsign, qint64 deferMs);
 
        QPair<qint64, qint64> minMaxTimestampsAddInProgress() const;
 
        bool canAddAircraft() const;
 
        void onRemoteAircraftAdded(const QString &callsign);
        void onRemoteAircraftAddingFailed(const QString &callsign);
        void updateRemoteAircraftFromSimulator(const QStringList &callsigns, const QDoubleList &latitudesDeg,
                                               const QDoubleList &longitudesDeg, const QDoubleList &elevationsMeters,
                                               const QDoubleList &verticalOffsetsMeters);
 
        void disconnectFromDBus();
 
        DBusMode m_dbusMode;
        swift::misc::CSettingReadOnly<swift::misc::simulation::settings::TFGSwiftBusServer> m_fgswiftbusServerSetting {
            this
        };
        static constexpr qint64 TimeoutAdding = 10000;
        QDBusConnection m_dBusConnection { "default" };
        QDBusServiceWatcher *m_watcher { nullptr };
        CFGSwiftBusServiceProxy *m_serviceProxy { nullptr };
        CFGSwiftBusTrafficProxy *m_trafficProxy { nullptr };
        QTimer m_fastTimer;
        QTimer m_slowTimer;
        QTimer m_pendingAddedTimer;
        swift::misc::CData<swift::misc::simulation::data::TModelSetCacheFG> m_modelSet {
            this
        }; 
        swift::misc::simulation::CSimulatedAircraftList m_pendingToBeAddedAircraft; 
        QHash<swift::misc::aviation::CCallsign, qint64> m_addingInProgressAircraft; 
        swift::misc::simulation::CSimulatedAircraftList m_aircraftAddedFailed; 
        CFlightgearMPAircraftObjects m_flightgearAircraftObjects; 
        FlightgearData m_flightgearData; 
 
        // statistics
        qint64 m_statsAddMaxTimeMs = -1;
        qint64 m_statsAddCurrentTimeMs = -1;
 
        bool m_simulatorPaused = false;
 
        void resetFlightgearData() { m_flightgearData = {}; }
    };
 
    class CSimulatorFlightgearListener : public swift::core::ISimulatorListener
    {
        Q_OBJECT
 
    public:
        CSimulatorFlightgearListener(const swift::misc::simulation::CSimulatorPluginInfo &info);
 
    protected:
        virtual void startImpl() override;
 
        virtual void stopImpl() override;
 
        virtual void checkImpl() override;
 
    private:
        void checkConnection();
        void checkConnectionViaSessionBus();
        void checkConnectionViaPeer(const QString &address);
        void checkConnectionCommon();
 
        void serviceRegistered(const QString &serviceName);
        void fgSwiftBusServerSettingChanged();
 
        QTimer m_timer { this };
        QDBusConnection m_conn { "default" };
        swift::misc::CSettingReadOnly<swift::misc::simulation::settings::TFGSwiftBusServer> m_fgSswiftBusServerSetting {
            this, &CSimulatorFlightgearListener::fgSwiftBusServerSettingChanged
        };
    };
 
    class CSimulatorFlightgearFactory : public QObject, public swift::core::ISimulatorFactory
    {
        Q_OBJECT
        Q_PLUGIN_METADATA(IID "org.swift-project.swift_core.simulatorinterface" FILE "simulatorflightgear.json")
        Q_INTERFACES(swift::core::ISimulatorFactory)
 
    public:
        virtual swift::core::ISimulator *
        create(const swift::misc::simulation::CSimulatorPluginInfo &info,
               swift::misc::simulation::IOwnAircraftProvider *ownAircraftProvider,
               swift::misc::simulation::IRemoteAircraftProvider *remoteAircraftProvider,
               swift::misc::network::IClientProvider *clientProvider) override;
 
        virtual swift::core::ISimulatorListener *
        createListener(const swift::misc::simulation::CSimulatorPluginInfo &info) override
        {
            return new CSimulatorFlightgearListener(info);
        }
    };
} // namespace swift::simplugin::flightgear
 
#endif // SWIFT_SIMPLUGIN_SIMULATOR_FLIGHTGEAR_H