simulator.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_CORE_SIMULATOR_H
#define SWIFT_CORE_SIMULATOR_H
 
#include <atomic>
 
#include <QFlags>
#include <QObject>
#include <QString>
 
#include "config/buildconfig.h"
#include "core/application.h"
#include "core/swiftcoreexport.h"
#include "misc/aviation/airportlist.h"
#include "misc/aviation/callsignset.h"
#include "misc/geo/elevationplane.h"
#include "misc/identifiable.h"
#include "misc/identifier.h"
#include "misc/network/clientprovider.h"
#include "misc/pixmap.h"
#include "misc/pq/length.h"
#include "misc/pq/time.h"
#include "misc/simplecommandparser.h"
#include "misc/simulation/aircraftmodellist.h"
#include "misc/simulation/autopublishdata.h"
#include "misc/simulation/interpolation/interpolationrenderingsetup.h"
#include "misc/simulation/interpolation/interpolationsetupprovider.h"
#include "misc/simulation/interpolation/interpolatormulti.h"
#include "misc/simulation/ownaircraftprovider.h"
#include "misc/simulation/remoteaircraftprovider.h"
#include "misc/simulation/settings/simulatorsettings.h"
#include "misc/simulation/simulatedaircraft.h"
#include "misc/simulation/simulationenvironmentprovider.h"
#include "misc/simulation/simulatorinternals.h"
#include "misc/simulation/simulatorplugininfo.h"
#include "misc/statusmessage.h"
#include "misc/tokenbucket.h"
 
namespace swift::misc::network
{
    class CTextMessage;
}
 
namespace swift::core
{
    class SWIFT_CORE_EXPORT ISimulator :
        public QObject,
        public swift::misc::simulation::COwnAircraftAware, // access to in memory own aircraft data
        public swift::misc::simulation::CRemoteAircraftAware, // access to in memory remote aircraft data
        public swift::misc::network::CClientAware, // the network client with its capabilities
        public swift::misc::simulation::ISimulationEnvironmentProvider, // give access to elevation etc.
        public swift::misc::simulation::IInterpolationSetupProvider, // setup
        public swift::misc::CIdentifiable
    {
        Q_OBJECT
        Q_INTERFACES(swift::misc::simulation::ISimulationEnvironmentProvider)
        Q_INTERFACES(swift::misc::simulation::IInterpolationSetupProvider)
 
    public:
        enum SimulatorStatusFlag
        {
            Unspecified = 0, 
            Disconnected = 1 << 0, 
            Connected = 1 << 1, 
            Simulating = 1 << 2, 
            Paused = 1 << 3, 
        };
        Q_DECLARE_FLAGS(SimulatorStatus, SimulatorStatusFlag)
        Q_FLAG(SimulatorStatus)
 
        
        static const QStringList &getLogCategories();
 
        ~ISimulator() override;
 
        virtual SimulatorStatus getSimulatorStatus() const;
 
        virtual const swift::misc::simulation::CSimulatorInternals &getSimulatorInternals() const
        {
            return m_simulatorInternals;
        }
 
        virtual bool connectTo() = 0;
 
        virtual bool disconnectFrom();
 
        virtual bool logicallyAddRemoteAircraft(const swift::misc::simulation::CSimulatedAircraft &remoteAircraft);
 
        virtual bool logicallyRemoveRemoteAircraft(const swift::misc::aviation::CCallsign &callsign);
 
        virtual bool logicallyReAddRemoteAircraft(const swift::misc::aviation::CCallsign &callsign);
 
        int removeAllRemoteAircraft() { return this->physicallyRemoveAllRemoteAircraft(); }
 
        virtual bool changeRemoteAircraftModel(const swift::misc::simulation::CSimulatedAircraft &aircraft);
 
        virtual bool changeRemoteAircraftEnabled(const swift::misc::simulation::CSimulatedAircraft &aircraft);
 
        virtual bool updateOwnSimulatorCockpit(const swift::misc::simulation::CSimulatedAircraft &aircraft,
                                               const swift::misc::CIdentifier &originator) = 0;
 
        virtual bool updateOwnSimulatorSelcal(const swift::misc::aviation::CSelcal &selcal,
                                              const swift::misc::CIdentifier &originator) = 0;
 
        virtual void displayStatusMessage(const swift::misc::CStatusMessage &message) const = 0;
 
        virtual void displayTextMessage(const swift::misc::network::CTextMessage &message) const = 0;
 
        virtual bool isPhysicallyRenderedAircraft(const swift::misc::aviation::CCallsign &callsign) const = 0;
 
        virtual swift::misc::aviation::CCallsignSet physicallyRenderedAircraft() const = 0;
 
        virtual bool followAircraft(const swift::misc::aviation::CCallsign &callsign);
 
        virtual void recalculateAllAircraft();
 
        virtual void setFlightNetworkConnected(bool connected);
 
        virtual void setOwnCallsign(const swift::misc::aviation::CCallsign &callsign);
 
        bool isFlightNetworkConnected() const { return m_networkConnected; }
 
        swift::misc::simulation::settings::CSpecializedSimulatorSettings getSimulatorSettings() const
        {
            return m_multiSettings.getSpecializedSettings(this->getSimulatorInfo());
        }
 
        virtual void unload();
 
        virtual bool isConnected() const = 0;
 
        virtual bool isPaused() const = 0;
 
        virtual bool isSimulating() const { return this->isConnected(); }
 
        void setTestMode(bool test) { m_test = test; }
 
        bool isTestMode() const { return m_test; }
 
        double getAverageFPS() const { return m_averageFps; }
 
        double getSimTimeRatio() const { return m_simTimeRatio; }
 
        double getTrackMilesShort() const { return m_trackMilesShort; }
 
        double getMinutesLate() const { return m_minutesLate; }
 
        virtual bool testSendSituationAndParts(const swift::misc::aviation::CCallsign &callsign,
                                               const swift::misc::aviation::CAircraftSituation &situation,
                                               const swift::misc::aviation::CAircraftParts &parts) = 0;
 
        void setTestEnablePseudoElevation(bool enable) { m_enablePseudoElevation = enable; }
 
        void setTestElevation(const swift::misc::aviation::CAltitude &altitude) { m_pseudoElevation = altitude; }
 
        virtual swift::misc::CStatusMessageList debugVerifyStateAfterAllAircraftRemoved() const;
 
        virtual bool isShuttingDown() const { return (!sApp || sApp->isShuttingDown()); }
 
        virtual bool isShuttingDownOrDisconnected() const { return (this->isShuttingDown() || !this->isConnected()); }
 
        virtual bool isShuttingDownDisconnectedOrNoAircraft() const
        {
            return (this->isShuttingDownOrDisconnected() || this->getAircraftInRangeCount() < 1);
        }
 
        virtual bool isShuttingDownDisconnectedOrNoAircraft(bool isProbe) const
        {
            return isProbe ? this->isShuttingDownOrDisconnected() :
                             (this->isShuttingDownOrDisconnected() || this->getAircraftInRangeCount() < 1);
        }
 
        bool requestElevation(const swift::misc::geo::ICoordinateGeodetic &reference,
                              const swift::misc::aviation::CCallsign &callsign) override;
 
        bool requestElevation(const swift::misc::aviation::CAircraftSituation &situation)
        {
            return this->requestElevation(situation, situation.getCallsign());
        }
 
        virtual void callbackReceivedRequestedElevation(const swift::misc::geo::CElevationPlane &plane,
                                                        const swift::misc::aviation::CCallsign &callsign, bool isWater);
 
        virtual QString getStatisticsSimulatorSpecific() const { return {}; }
 
        virtual void resetAircraftStatistics();
 
        QObject *asQObject() override { return this; }
 
        bool isEmulatedDriver() const;
 
        virtual bool parseCommandLine(const QString &commandLine, const swift::misc::CIdentifier &originator);
 
        swift::misc::simulation::CInterpolationAndRenderingSetupPerCallsign
        getInterpolationSetupConsolidated(const swift::misc::aviation::CCallsign &callsign, bool forceFullUpdate) const;
 
        bool setInterpolationSetupGlobal(
            const swift::misc::simulation::CInterpolationAndRenderingSetupGlobal &setup) override;
 
        virtual swift::misc::CStatusMessageList
        getInterpolationMessages(const swift::misc::aviation::CCallsign &callsign) const = 0;
 
        const swift::misc::simulation::CAutoPublishData &getPublishData() const { return m_autoPublishing; }
 
        int getStatisticsPhysicallyAddedAircraft() const { return m_statsPhysicallyAddedAircraft; }
 
        int getStatisticsPhysicallyRemovedAircraft() const { return m_statsPhysicallyRemovedAircraft; }
 
        qint64 getStatisticsCurrentUpdateTimeMs() const { return m_statsCurrentUpdateTimeMs; }
 
        double getStatisticsAverageUpdateTimeMs() const { return m_statsUpdateAircraftTimeAvgMs; }
 
        qint64 getStatisticsTotalUpdateTimeMs() const { return m_statsUpdateAircraftTimeTotalMs; }
 
        qint64 getStatisticsMaxUpdateTimeMs() const { return m_statsMaxUpdateTimeMs; }
 
        int getStatisticsUpdateRuns() const { return m_statsUpdateAircraftRuns; }
 
        qint64 getStatisticsAircraftUpdatedRequestedDeltaMs() const { return m_statsUpdateAircraftRequestedDeltaMs; }
 
        swift::misc::aviation::CAircraftSituationList
        getLoopbackSituations(const swift::misc::aviation::CCallsign &callsign) const;
 
        const swift::misc::simulation::CInterpolationLogger &interpolationLogger() const
        {
            return m_interpolationLogger;
        }
 
        QString latestLoggedDataFormatted(const swift::misc::aviation::CCallsign &cs) const;
 
        QString updateAircraftLimitationInfo() const;
 
        void resetLastSentValues();
 
        void resetLastSentValues(const swift::misc::aviation::CCallsign &callsign);
 
        static void registerHelp();
 
        static QString statusToString(SimulatorStatus status);
 
        static bool isAnyConnectedStatus(SimulatorStatus status);
 
        static const swift::misc::aviation::CCallsign &getTestCallsign();
 
    signals:
        void simulatorStatusChanged(
            swift::core::ISimulator::SimulatorStatus status); // use emitSimulatorCombinedStatus to emit
 
        void ownAircraftModelChanged(const swift::misc::simulation::CAircraftModel &model);
 
        void renderRestrictionsChanged(bool restricted, bool enabled, int maxAircraft,
                                       const swift::misc::physical_quantities::CLength &maxRenderedDistance);
 
        void interpolationAndRenderingSetupChanged();
 
        void aircraftRenderingChanged(const swift::misc::simulation::CSimulatedAircraft &aircraft);
 
        void physicallyAddingRemoteModelFailed(const swift::misc::simulation::CSimulatedAircraft &remoteAircraft,
                                               bool disabled, bool requestFailover,
                                               const swift::misc::CStatusMessage &message);
 
        void airspaceSnapshotHandled();
 
        void driverMessages(const swift::misc::CStatusMessageList &messages);
 
        void requestedElevation(const swift::misc::aviation::CCallsign &callsign);
 
        void receivedRequestedElevation(const swift::misc::geo::CElevationPlane &plane,
                                        const swift::misc::aviation::CCallsign &callsign);
 
        void autoPublishDataWritten(const swift::misc::simulation::CSimulatorInfo &simulator);
 
        void insufficientFrameRateDetected(bool fatal);
 
    protected:
        ISimulator(const swift::misc::simulation::CSimulatorPluginInfo &pluginInfo,
                   swift::misc::simulation::IOwnAircraftProvider *ownAircraftProvider,
                   swift::misc::simulation::IRemoteAircraftProvider *remoteAircraftProvider,
                   swift::misc::network::IClientProvider *clientProvider, QObject *parent = nullptr);
 
        virtual void onSwiftDbAllDataRead();
        virtual void onSwiftDbModelMatchingEntitiesRead();
 
        virtual void initSimulatorInternals();
 
        virtual bool parseDetails(const swift::misc::CSimpleCommandParser &parser) = 0;
 
        virtual void onRecalculatedRenderedAircraft(const swift::misc::simulation::CAirspaceAircraftSnapshot &snapshot);
 
        virtual bool physicallyAddRemoteAircraft(const swift::misc::simulation::CSimulatedAircraft &remoteAircraft) = 0;
 
        virtual bool physicallyRemoveRemoteAircraft(const swift::misc::aviation::CCallsign &callsign) = 0;
 
        virtual int physicallyRemoveMultipleRemoteAircraft(const swift::misc::aviation::CCallsignSet &callsigns);
 
        virtual void clearAllRemoteAircraftData();
 
        virtual int physicallyRemoveAllRemoteAircraft();
 
        void rememberElevationAndSimulatorCG(const swift::misc::aviation::CCallsign &callsign,
                                             const swift::misc::simulation::CAircraftModel &model,
                                             bool likelyOnGroundElevation,
                                             const swift::misc::geo::CElevationPlane &elevation,
                                             const swift::misc::physical_quantities::CLength &simulatorCG);
 
        void emitSimulatorCombinedStatus(SimulatorStatus oldStatus = Unspecified);
 
        void emitInterpolationSetupChanged() override;
 
        void debugLogMessage(const QString &msg);
 
        void debugLogMessage(const QString &funcInfo, const QString &msg);
 
        bool showDebugLogMessage() const;
 
        void resetAircraftFromProvider(const swift::misc::aviation::CCallsign &callsign);
 
        virtual void clearData(const swift::misc::aviation::CCallsign &callsign);
 
        bool addLoopbackSituation(const swift::misc::aviation::CAircraftSituation &situation);
 
        bool addLoopbackSituation(const swift::misc::aviation::CCallsign &callsign,
                                  const swift::misc::geo::CElevationPlane &elevationPlane,
                                  const swift::misc::physical_quantities::CLength &cg);
 
        virtual void reset();
 
        bool isUpdateAllRemoteAircraft(qint64 currentTimestamp = -1) const;
 
        void setUpdateAllRemoteAircraft(qint64 currentTimestamp = -1, qint64 forMs = -1);
 
        void resetUpdateAllRemoteAircraft();
 
        void safeKillTimer();
 
        bool isEqualLastSent(const swift::misc::aviation::CAircraftSituation &compare) const;
 
        bool isEqualLastSent(const swift::misc::aviation::CAircraftParts &compare,
                             const swift::misc::aviation::CCallsign &callsign) const;
 
        void rememberLastSent(const swift::misc::aviation::CAircraftSituation &sent);
 
        void rememberLastSent(const swift::misc::aviation::CAircraftParts &sent,
                              const swift::misc::aviation::CCallsign &callsign);
 
        swift::misc::aviation::CAircraftSituationList getLastSentCanLikelySkipNearGroundInterpolation() const;
 
        bool isUpdateAircraftLimited(qint64 timestamp = -1);
 
        bool isUpdateAircraftLimitedWithStats(qint64 startTime = -1);
 
        bool limitToUpdatesPerSecond(int numberPerSecond);
 
        void reverseLookupAndUpdateOwnAircraftModel(const swift::misc::simulation::CAircraftModel &model);
 
        void reverseLookupAndUpdateOwnAircraftModel(const QString &modelString);
 
        QString getInvalidSituationLogMessage(const swift::misc::aviation::CCallsign &callsign,
                                              const swift::misc::simulation::CInterpolationStatus &status,
                                              const QString &details = {}) const;
 
        void finishUpdateRemoteAircraftAndSetStatistics(qint64 startTime, bool limited = false);
 
        virtual void onOwnModelChanged(const swift::misc::simulation::CAircraftModel &newModel);
 
        bool updateOwnSituationAndGroundElevation(const swift::misc::aviation::CAircraftSituation &situation);
 
        swift::misc::simulation::CAircraftModelList getModelSet() const;
 
        bool validateModelOfAircraft(const swift::misc::simulation::CSimulatedAircraft &aircraft) const;
 
        void logAddingAircraftModel(const swift::misc::simulation::CSimulatedAircraft &aircraft) const;
 
        bool isAircraftInRangeOrTestMode(const swift::misc::aviation::CCallsign &callsign) const;
 
        static swift::misc::simulation::CAircraftModel
        reverseLookupModel(const swift::misc::simulation::CAircraftModel &model);
 
        bool m_updateRemoteAircraftInProgress = false; 
        bool m_enablePseudoElevation = false; 
        int m_timerId = -1; 
        int m_statsUpdateAircraftRuns = 0; 
        int m_statsUpdateAircraftLimited = 0; 
        double m_statsUpdateAircraftTimeAvgMs = 0; 
        double m_averageFps = -1.0; 
        double m_simTimeRatio = 1.0; 
        double m_trackMilesShort = 0.0; 
        double m_minutesLate = 0.0; 
        qint64 m_updateAllRemoteAircraftUntil = 0; 
        qint64 m_statsUpdateAircraftTimeTotalMs = 0; 
        qint64 m_statsCurrentUpdateTimeMs = 0; 
        qint64 m_statsMaxUpdateTimeMs = 0; 
        qint64 m_lastRecordedGndElevationMs = 0; 
        qint64 m_statsLastUpdateAircraftRequestedMs = 0; 
        qint64 m_statsUpdateAircraftRequestedDeltaMs = 0; 
 
        swift::misc::aviation::CAltitude m_pseudoElevation {
            swift::misc::aviation::CAltitude::null()
        }; 
        swift::misc::simulation::CSimulatorInternals m_simulatorInternals; 
        swift::misc::simulation::CInterpolationLogger m_interpolationLogger; 
        swift::misc::simulation::CAutoPublishData m_autoPublishing; 
        swift::misc::aviation::CAircraftSituationPerCallsign
            m_lastSentSituations; 
        swift::misc::aviation::CAircraftPartsPerCallsign m_lastSentParts; 
 
        // some optional functionality which can be used by the simulators as needed
        swift::misc::simulation::CSimulatedAircraftList
            m_addAgainAircraftWhenRemoved; 
 
        // loopback situations, situations which are received from simulator for remote aircraft
        swift::misc::aviation::CAircraftSituationListPerCallsign m_loopbackSituations; 
 
        // limit the update aircraft to a maximum per second
        swift::misc::CTokenBucket m_limitUpdateAircraftBucket { 5, 100, 5 }; 
        bool m_limitUpdateAircraft = false; 
 
        // general settings
        swift::misc::simulation::settings::CMultiSimulatorSettings m_multiSettings {
            this
        }; 
 
    private:
        // remote aircraft provider ("rap") bound
        void rapOnRecalculatedRenderedAircraft(const swift::misc::simulation::CAirspaceAircraftSnapshot &snapshot);
 
        // call with counters updated
        void callPhysicallyAddRemoteAircraft(const swift::misc::simulation::CSimulatedAircraft &remoteAircraft);
        void callPhysicallyRemoveRemoteAircraft(const swift::misc::aviation::CCallsign &remoteCallsign);
 
        void displayLoggedSituationInSimulator(const swift::misc::aviation::CCallsign &cs, bool stopLogging,
                                               int times = 40);
 
        // statistics values of how often those functions are called
        // those are the added counters, overflow will not be an issue here (discussed in T171 review)
        int m_statsPhysicallyAddedAircraft = 0; 
        int m_statsPhysicallyRemovedAircraft = 0; 
 
        // misc.
        bool m_networkConnected = false; 
        bool m_test = false; 
        swift::misc::aviation::CCallsignSet m_callsignsToBeRendered; 
        swift::misc::CConnectionGuard m_remoteAircraftProviderConnections; 
    };
 
    class SWIFT_CORE_EXPORT ISimulatorListener : public QObject
    {
        Q_OBJECT
 
    public:
        ~ISimulatorListener() override = default;
 
        const swift::misc::simulation::CSimulatorPluginInfo &getPluginInfo() const { return m_info; }
 
        virtual QString backendInfo() const;
 
        bool isRunning() const { return m_isRunning; }
 
    public slots:
        void start();
 
        void stop();
 
        void check();
 
    signals:
        void simulatorStarted(const swift::misc::simulation::CSimulatorPluginInfo &info);
 
    protected:
        explicit ISimulatorListener(const swift::misc::simulation::CSimulatorPluginInfo &info);
 
        virtual bool isShuttingDown() const;
 
        virtual void startImpl() = 0;
 
        virtual void stopImpl() = 0;
 
        virtual void checkImpl() = 0;
 
    private:
        void onAboutToShutdown();
 
        swift::misc::simulation::CSimulatorPluginInfo m_info;
        std::atomic_bool m_isRunning { false };
        std::atomic_bool m_aboutToShutdown { false }; // swift will shutdown
    };
 
    class SWIFT_CORE_EXPORT ISimulatorFactory
    {
    public:
        virtual ~ISimulatorFactory() = default;
 
        ISimulatorFactory(const ISimulatorFactory &) = delete;
        ISimulatorFactory &operator=(const ISimulatorFactory &) = delete;
 
        virtual ISimulator *create(const swift::misc::simulation::CSimulatorPluginInfo &info,
                                   swift::misc::simulation::IOwnAircraftProvider *ownAircraftProvider,
                                   swift::misc::simulation::IRemoteAircraftProvider *remoteAircraftProvider,
                                   swift::misc::network::IClientProvider *clientProvider) = 0;
 
        virtual ISimulatorListener *createListener(const swift::misc::simulation::CSimulatorPluginInfo &info) = 0;
 
    protected:
        ISimulatorFactory() {} // NOLINT(modernize-use-equals-default)
    };
} // namespace swift::core
 
Q_DECLARE_METATYPE(swift::core::ISimulator::SimulatorStatusFlag)
Q_DECLARE_METATYPE(swift::core::ISimulator::SimulatorStatus)
Q_DECLARE_INTERFACE(swift::core::ISimulator, "org.swift-project.swift_core.simulator")
Q_DECLARE_INTERFACE(swift::core::ISimulatorFactory, "org.swift-project.swift_core.simulatorfactory")
Q_DECLARE_OPERATORS_FOR_FLAGS(swift::core::ISimulator::SimulatorStatus)
 
#endif // SWIFT_CORE_SIMULATOR_H