simulatorxplane.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2013 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_SIMPLUGIN_SIMULATOR_XPLANE_H
#define SWIFT_SIMPLUGIN_SIMULATOR_XPLANE_H
 
#include <QDBusConnection>
#include <QHash>
#include <QList>
#include <QObject>
#include <QPair>
#include <QString>
#include <QStringList>
#include <QTimer>
 
#include "xplanempaircraft.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/simulatorsettings.h"
#include "misc/simulation/settings/xswiftbussettings.h"
#include "misc/simulation/simulatedaircraftlist.h"
#include "misc/statusmessage.h"
#include "plugins/simulator/plugincommon/simulatorplugincommon.h"
#include "plugins/simulator/xplaneconfig/simulatorxplaneconfig.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::xplane
{
    class CXSwiftBusServiceProxy;
    class CXSwiftBusTrafficProxy;
 
    struct XPlaneData
    {
        QString aircraftModelPath; 
        QString aircraftIcaoCode; 
        double latitudeDeg = 0; 
        double longitudeDeg = 0; 
        double altitudeM = 0; 
        double pressureAltitudeFt = 0; 
        double heightAglM = 0; 
        double groundspeedMs = 0; 
        double pitchDeg = 0; 
        double rollDeg = 0; 
        double trueHeadingDeg = 0; 
        double localXVelocityMs = 0; 
        double localYVelocityMs = 0; 
        double localZVelocityMs = 0; 
        double pitchRadPerSec = 0; 
        double rollRadPerSec = 0; 
        double headingRadPerSec = 0; 
        bool onGroundAll = false; 
        double groundElevation = 0; 
        int com1ActiveKhz = 122800; 
        int com1StandbyKhz = 122800; 
        bool isCom1Receiving = true; 
        bool isCom1Transmitting = true; 
        double com1Volume = 1; 
        int com2ActiveKhz = 122800; 
        int com2StandbyKhz = 122800; 
        bool isCom2Receiving = true; 
        bool isCom2Transmitting = true; 
        double com2Volume = 1; 
        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 flapsDeployRatio = 0; 
        double gearDeployRatio = 0; 
        QList<double> enginesN1Percentage; 
        double speedBrakeRatio = 0; 
        double seaLevelPressureInHg = 0; 
    };
 
    class CSimulatorXPlane : public common::CSimulatorPluginCommon
    {
        Q_OBJECT
 
    public:
        CSimulatorXPlane(const swift::misc::simulation::CSimulatorPluginInfo &info,
                         swift::misc::simulation::IOwnAircraftProvider *ownAircraftProvider,
                         swift::misc::simulation::IRemoteAircraftProvider *remoteAircraftProvider,
                         swift::misc::network::IClientProvider *clientProvider, QObject *parent = nullptr);
 
        ~CSimulatorXPlane() override;
 
        bool connectTo() override;
        bool disconnectFrom() override;
        bool updateOwnSimulatorCockpit(const swift::misc::simulation::CSimulatedAircraft &aircraft,
                                       const swift::misc::CIdentifier &originator) override;
        bool updateOwnSimulatorSelcal(const swift::misc::aviation::CSelcal &selcal,
                                      const swift::misc::CIdentifier &originator) override;
        void displayStatusMessage(const swift::misc::CStatusMessage &message) const override;
        void displayTextMessage(const swift::misc::network::CTextMessage &message) const override;
        bool isPhysicallyRenderedAircraft(const swift::misc::aviation::CCallsign &callsign) const override;
        swift::misc::aviation::CCallsignSet physicallyRenderedAircraft() const override;
        bool followAircraft(const swift::misc::aviation::CCallsign &callsign) override;
        void unload() override;
        QString getStatisticsSimulatorSpecific() const override;
        void resetAircraftStatistics() override;
        swift::misc::CStatusMessageList
        getInterpolationMessages(const swift::misc::aviation::CCallsign &callsign) const override;
        bool testSendSituationAndParts(const swift::misc::aviation::CCallsign &callsign,
                                       const swift::misc::aviation::CAircraftSituation &situation,
                                       const swift::misc::aviation::CAircraftParts &parts) override;
        void callbackReceivedRequestedElevation(const swift::misc::geo::CElevationPlane &plane,
                                                const swift::misc::aviation::CCallsign &callsign,
                                                bool isWater) override;
        void setFlightNetworkConnected(bool connected) override;
 
        bool requestElevation(const swift::misc::geo::ICoordinateGeodetic &reference,
                              const swift::misc::aviation::CCallsign &callsign) override;
 
    protected:
        bool isConnected() const override;
        bool physicallyAddRemoteAircraft(const swift::misc::simulation::CSimulatedAircraft &newRemoteAircraft) override;
        bool physicallyRemoveRemoteAircraft(const swift::misc::aviation::CCallsign &callsign) override;
        int physicallyRemoveAllRemoteAircraft() override;
        void clearAllRemoteAircraftData() override;
        bool isPaused() const override
        {
            return false;
        }
 
    private slots:
        void onDBusServiceUnregistered();
 
    private:
        enum DBusMode
        {
            Session,
            P2P
        };
 
        using QDoubleList = QList<double>;
        using QBoolList = QList<bool>;
 
        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 loadCslPackages();
        QString findCslPackage(const QString &modelFileName);
 
        void updateRemoteAircraft();
 
        void requestRemoteAircraftDataFromXPlane();
        void requestRemoteAircraftDataFromXPlane(const swift::misc::aviation::CCallsignSet &callsigns);
        void triggerRequestRemoteAircraftDataFromXPlane(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 QBoolList &waterFlags, const QDoubleList &verticalOffsetsMeters);
 
        void disconnectFromDBus();
 
        bool sendXSwiftBusSettings();
        swift::misc::simulation::settings::CXSwiftBusSettings receiveXSwiftBusSettings(bool &ok);
 
        void onXSwiftBusSettingsChanged();
 
        void setMinTerrainProbeDistance(const swift::misc::physical_quantities::CLength &distance);
 
        bool handleProbeValue(const swift::misc::geo::CElevationPlane &plane,
                              const swift::misc::aviation::CCallsign &callsign, bool waterFlag, const QString &hint,
                              bool ignoreOutsideRange);
 
        static bool isSuspiciousTerrainValue(const swift::misc::geo::CElevationPlane &elevation);
        static const swift::misc::physical_quantities::CLength &maxTerrainRequestDistance();
 
        static swift::misc::physical_quantities::CLength
        fixSimulatorCg(const swift::misc::physical_quantities::CLength &cg,
                       const swift::misc::simulation::CAircraftModel &model);
 
        DBusMode m_dbusMode;
        swift::misc::CSetting<swift::misc::simulation::settings::TXSwiftBusSettings> m_xSwiftBusServerSettings {
            this, &CSimulatorXPlane::onXSwiftBusSettingsChanged
        };
        static constexpr qint64 TimeoutAdding = 10000;
        QDBusConnection m_dBusConnection { "default" };
        QDBusServiceWatcher *m_watcher { nullptr };
        CXSwiftBusServiceProxy *m_serviceProxy { nullptr };
        CXSwiftBusTrafficProxy *m_trafficProxy { nullptr };
        QTimer m_fastTimer;
        QTimer m_slowTimer;
        QTimer m_pendingAddedTimer;
        unsigned int m_fastTimerCalls = 0; 
        unsigned int m_slowTimerCalls = 0; 
 
        CXPlaneMPAircraftObjects m_xplaneAircraftObjects; 
 
        swift::misc::simulation::CSimulatedAircraftList m_pendingToBeAddedAircraft; 
        QHash<swift::misc::aviation::CCallsign, qint64> m_addingInProgressAircraft; 
        swift::misc::simulation::CSimulatedAircraftList m_aircraftAddedFailed; 
        swift::misc::physical_quantities::CLength m_minSuspicousTerrainProbe {
            nullptr
        }; 
        XPlaneData m_xplaneData; 
        swift::misc::physical_quantities::CLength
            m_altitudeDelta; 
 
        // statistics
        qint64 m_statsAddMaxTimeMs = -1;
        qint64 m_statsAddCurrentTimeMs = -1;
 
        void resetXPlaneData() { m_xplaneData = {}; }
    };
 
    class CSimulatorXPlaneListener : public swift::core::ISimulatorListener
    {
        Q_OBJECT
 
    public:
        CSimulatorXPlaneListener(const swift::misc::simulation::CSimulatorPluginInfo &info);
 
    protected:
        void startImpl() override;
 
        void stopImpl() override;
 
        void checkImpl() override;
 
    private:
        void checkConnection();
        void checkConnectionViaSessionBus();
        void checkConnectionViaPeer(const QString &address);
        void checkConnectionCommon();
 
        void serviceRegistered(const QString &serviceName);
        void onXSwiftBusServerSettingChanged();
 
        QTimer m_timer { this };
        QDBusConnection m_DBusConnection { "default" };
        QString m_dBusServerAddress;
        swift::misc::CSettingReadOnly<swift::misc::simulation::settings::TXSwiftBusSettings> m_xSwiftBusServerSettings {
            this, &CSimulatorXPlaneListener::onXSwiftBusServerSettingChanged
        };
    };
 
    class CSimulatorXPlaneFactory : public QObject, public swift::core::ISimulatorFactory
    {
        Q_OBJECT
        Q_PLUGIN_METADATA(IID "org.swift-project.swift_core.simulatorinterface" FILE "simulatorxplane.json")
        Q_INTERFACES(swift::core::ISimulatorFactory)
 
    public:
        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;
 
        swift::core::ISimulatorListener *
        createListener(const swift::misc::simulation::CSimulatorPluginInfo &info) override
        {
            return new CSimulatorXPlaneListener(info);
        }
    };
} // namespace swift::simplugin::xplane
 
#endif // SWIFT_SIMPLUGIN_SIMULATOR_XPLANE_H