contextsimulatorimpl.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_CONTEXT_CONTEXTSIMULATOR_IMPL_H
#define SWIFT_CORE_CONTEXT_CONTEXTSIMULATOR_IMPL_H
 
#include <QPair>
#include <QPointer>
#include <QString>
 
#include "core/aircraftmatcher.h"
#include "core/application/applicationsettings.h"
#include "core/context/contextsimulator.h"
#include "core/corefacadeconfig.h"
#include "core/simulator.h"
#include "core/swiftcoreexport.h"
#include "misc/aviation/airportlist.h"
#include "misc/identifier.h"
#include "misc/network/connectionstatus.h"
#include "misc/network/textmessagelist.h"
#include "misc/pixmap.h"
#include "misc/pq/length.h"
#include "misc/pq/time.h"
#include "misc/settingscache.h"
#include "misc/simulation/aircraftmodellist.h"
#include "misc/simulation/aircraftmodelsetprovider.h"
#include "misc/simulation/backgroundvalidation.h"
#include "misc/simulation/data/modelcaches.h"
#include "misc/simulation/interpolation/interpolationsetuplist.h"
#include "misc/simulation/remoteaircraftprovider.h"
#include "misc/simulation/settings/interpolationrenderingsetupsettings.h"
#include "misc/simulation/settings/modelmatchersettings.h"
#include "misc/simulation/settings/simulatorsettings.h"
#include "misc/simulation/simulatorinternals.h"
#include "misc/simulation/simulatorplugininfolist.h"
#include "misc/worker.h"
 
// clazy:excludeall=const-signal-or-slot
 
namespace swift::misc
{
    class CDBusServer;
    namespace aviation
    {
        class CCallsign;
    }
    namespace simulation
    {
        class CSimulatedAircraft;
    }
} // namespace swift::misc
 
namespace swift::core
{
    class CCoreFacade;
    class CPluginManagerSimulator;
 
    namespace context
    {
        class SWIFT_CORE_EXPORT CContextSimulator :
            public IContextSimulator,
            public swift::misc::simulation::IAircraftModelSetProvider,
            public swift::misc::simulation::CRemoteAircraftAware, // gain access to in memory remote aircraft data
            public swift::misc::CIdentifiable
        {
            Q_OBJECT
            Q_INTERFACES(swift::misc::simulation::IAircraftModelSetProvider)
            Q_CLASSINFO("D-Bus Interface", SWIFT_CORE_CONTEXTSIMULATOR_INTERFACENAME)
            friend class swift::core::CCoreFacade;
            friend class IContextSimulator;
 
        public slots:
            swift::misc::simulation::CSimulatorPluginInfo getSimulatorPluginInfo() const override;
 
            swift::misc::simulation::CSimulatorPluginInfoList getAvailableSimulatorPlugins() const override;
 
            swift::misc::simulation::settings::CSimulatorSettings getSimulatorSettings() const override;
 
            bool setSimulatorSettings(const swift::misc::simulation::settings::CSimulatorSettings &settings,
                                      const swift::misc::simulation::CSimulatorInfo &simulator) override;
 
            bool startSimulatorPlugin(const swift::misc::simulation::CSimulatorPluginInfo &simulatorInfo) override;
 
            void stopSimulatorPlugin(const swift::misc::simulation::CSimulatorPluginInfo &simulatorInfo) override;
 
            int checkListeners() override;
 
            ISimulator::SimulatorStatus getSimulatorStatus() const override;
 
            swift::misc::simulation::CSimulatorInternals getSimulatorInternals() const override;
 
            swift::misc::simulation::CSimulatorInfo getModelSetLoaderSimulator() const override;
 
            void setModelSetLoaderSimulator(const swift::misc::simulation::CSimulatorInfo &simulator) override;
 
            swift::misc::simulation::CSimulatorInfo simulatorsWithInitializedModelSet() const override;
 
            swift::misc::CStatusMessageList verifyPrerequisites() const override;
 
            QStringList getModelSetStrings() const override;
 
            QStringList getModelSetCompleterStrings(bool sorted) const override;
 
            bool isKnownModelInSet(const QString &modelString) const override;
 
            int removeModelsFromSet(const swift::misc::simulation::CAircraftModelList &removeModels) override;
 
            void disableModelsForMatching(const swift::misc::simulation::CAircraftModelList &removedModels,
                                          bool incremental) override;
 
            swift::misc::simulation::CAircraftModelList getDisabledModelsForMatching() const override;
 
            void restoreDisabledModels() override;
 
            bool isValidationInProgress() const override;
 
            bool triggerModelSetValidation(const swift::misc::simulation::CSimulatorInfo &simulator) override;
 
            swift::misc::simulation::CAircraftModelList
            getModelSetModelsStartingWith(const QString &modelString) const override;
 
            swift::misc::simulation::CInterpolationAndRenderingSetupGlobal
            getInterpolationAndRenderingSetupGlobal() const override;
 
            swift::misc::simulation::CInterpolationSetupList
            getInterpolationAndRenderingSetupsPerCallsign() const override;
 
            swift::misc::simulation::CInterpolationAndRenderingSetupPerCallsign
            getInterpolationAndRenderingSetupPerCallsignOrDefault(
                const swift::misc::aviation::CCallsign &callsign) const override;
 
            bool setInterpolationAndRenderingSetupsPerCallsign(
                const swift::misc::simulation::CInterpolationSetupList &setups, bool ignoreSameAsGlobal) override;
 
            void setInterpolationAndRenderingSetupGlobal(
                const swift::misc::simulation::CInterpolationAndRenderingSetupGlobal &setup) override;
 
            swift::misc::CStatusMessageList
            getInterpolationMessages(const swift::misc::aviation::CCallsign &callsign) const override;
 
            bool followAircraft(const swift::misc::aviation::CCallsign &callsign) override;
 
            void recalculateAllAircraft() override;
 
            bool resetToModelMatchingAircraft(const swift::misc::aviation::CCallsign &callsign) override;
 
            bool requestElevationBySituation(const swift::misc::aviation::CAircraftSituation &situation) override;
 
            swift::misc::geo::CElevationPlane
            findClosestElevationWithinRange(const swift::misc::geo::CCoordinateGeodetic &reference,
                                            const swift::misc::physical_quantities::CLength &range) const override;
 
            int doMatchingsAgain() override;
 
            bool doMatchingAgain(const swift::misc::aviation::CCallsign &callsign) override;
 
            swift::misc::CStatusMessageList
            getMatchingMessages(const swift::misc::aviation::CCallsign &callsign) const override;
 
            swift::misc::simulation::MatchingLog isMatchingMessagesEnabled() const override;
 
            void enableMatchingMessages(swift::misc::simulation::MatchingLog enabled) override;
 
            swift::misc::simulation::CMatchingStatistics getCurrentMatchingStatistics(bool missingOnly) const override;
 
            void setMatchingSetup(const swift::misc::simulation::CAircraftMatcherSetup &setup) override;
 
            swift::misc::simulation::CAircraftMatcherSetup getMatchingSetup() const override;
 
            bool testRemoteAircraft(const swift::misc::simulation::CSimulatedAircraft &aircraft, bool add) override;
 
            bool testUpdateRemoteAircraft(const swift::misc::aviation::CCallsign &cs,
                                          const swift::misc::aviation::CAircraftSituation &situation,
                                          const swift::misc::aviation::CAircraftParts &parts) override;
 
            swift::misc::simulation::CAircraftModelList getModelSet() const override;
 
            int getModelSetCount() const override;
 
            bool parseCommandLine(const QString &commandLine, const swift::misc::CIdentifier &originator) override;
            // ----------------------------- context interface -----------------------------
 
        public:
            ~CContextSimulator() override;
 
            void gracefulShutdown();
 
            QPointer<ISimulator> simulator() const;
 
            bool hasSimulator() const { return this->simulator(); }
 
            static void registerHelp()
            {
                if (swift::misc::CSimpleCommandParser::registered("swift::core::CContextSimulator")) { return; }
                swift::misc::CSimpleCommandParser::registerCommand(
                    { ".ris", "rendering/interpolation setup (global setup)" });
                swift::misc::CSimpleCommandParser::registerCommand(
                    { ".ris debug on|off", "rendering/interpolation debug messages (global setup)" });
                swift::misc::CSimpleCommandParser::registerCommand(
                    { ".ris parts on|off", "aircraft parts (global setup)" });
            }
 
        protected:
            CContextSimulator(CCoreFacadeConfig::ContextMode, CCoreFacade *runtime);
 
            bool isSimulatorPluginAvailable() const;
 
        private:
            static constexpr int MatchingLogMaxModelSetSize = 250; 
            static constexpr int MaxModelAddedFailoverTrials = 3; 
 
            //  ------------ slots connected with network or other contexts ---------
 
            void xCtxAddedRemoteAircraftReadyForModelMatching(
                const swift::misc::simulation::CSimulatedAircraft &remoteAircraft);
 
            void xCtxRemovedRemoteAircraft(const swift::misc::aviation::CCallsign &callsign);
 
            void xCtxChangedRemoteAircraftModel(const swift::misc::simulation::CSimulatedAircraft &aircraft,
                                                const swift::misc::CIdentifier &originator);
 
            void xCtxChangedOwnAircraftModel(const swift::misc::simulation::CAircraftModel &aircraftModel,
                                             const swift::misc::CIdentifier &originator);
 
            void xCtxChangedRemoteAircraftEnabled(const swift::misc::simulation::CSimulatedAircraft &aircraft);
 
            void xCtxNetworkConnectionStatusChanged(const swift::misc::network::CConnectionStatus &from,
                                                    const swift::misc::network::CConnectionStatus &to);
 
            void xCtxUpdateSimulatorCockpitFromContext(const swift::misc::simulation::CSimulatedAircraft &ownAircraft,
                                                       const swift::misc::CIdentifier &originator);
 
            void xCtxUpdateSimulatorSelcalFromContext(const swift::misc::aviation::CSelcal &selcal,
                                                      const swift::misc::CIdentifier &originator);
 
            void xCtxNetworkRequestedNewAircraft(const swift::misc::aviation::CCallsign &callsign,
                                                 const QString &aircraftIcao, const QString &airlineIcao,
                                                 const QString &livery);
 
            void xCtxTextMessagesReceived(const swift::misc::network::CTextMessageList &textMessages);
            //  ------------ slots connected with network or other contexts ---------
 
            void onSimulatorStatusChanged(ISimulator::SimulatorStatus status);
 
            void onSimulatorStarted(const swift::misc::simulation::CSimulatorPluginInfo &info);
 
            void onOwnSimulatorModelChanged(const swift::misc::simulation::CAircraftModel &model);
 
            void onAddingRemoteAircraftFailed(const swift::misc::simulation::CSimulatedAircraft &remoteAircraft,
                                              bool disabled, bool requestFailover,
                                              const swift::misc::CStatusMessage &message);
 
            void relayStatusMessageToSimulator(const swift::misc::CStatusMessage &message);
 
            void changeEnabledSimulators();
 
            void restoreSimulatorPlugins();
 
            bool loadSimulatorPlugin(const swift::misc::simulation::CSimulatorPluginInfo &simulatorPluginInfo);
 
            void unloadSimulatorPlugin();
 
            bool listenForSimulator(const swift::misc::simulation::CSimulatorPluginInfo &simulatorInfo);
 
            void listenForAllSimulators();
 
            void stopSimulatorListeners();
 
            void addMatchingMessages(const swift::misc::aviation::CCallsign &callsign,
                                     const swift::misc::CStatusMessageList &messages);
 
            void clearMatchingMessages(const swift::misc::aviation::CCallsign &callsign);
 
            swift::misc::simulation::CAircraftModel
            reverseLookupModel(const swift::misc::simulation::CAircraftModel &model);
 
            void initByLastUsedModelSet();
 
            void setValidator(const swift::misc::simulation::CSimulatorInfo &simulator);
 
            QPair<swift::misc::simulation::CSimulatorPluginInfo, QPointer<ISimulator>>
                m_simulatorPlugin; 
            QMap<swift::misc::aviation::CCallsign, swift::misc::CStatusMessageList>
                m_matchingMessages; 
            QMap<swift::misc::aviation::CCallsign, int> m_failoverAddingCounts;
            CPluginManagerSimulator *m_plugins = nullptr; 
            swift::misc::CRegularThread m_listenersThread; 
            CAircraftMatcher m_aircraftMatcher { this }; 
 
            bool m_wasSimulating = false;
            bool m_initallyAddAircraft = false;
            swift::misc::simulation::MatchingLog m_logMatchingMessages = swift::misc::simulation::MatchingLogSimplified;
 
            QString m_networkSessionId; 
            swift::misc::simulation::CBackgroundValidation *m_validator = nullptr;
 
            // settings
            swift::misc::CSettingReadOnly<application::TEnabledSimulators> m_enabledSimulators {
                this, &CContextSimulator::changeEnabledSimulators
            };
            swift::misc::CSetting<swift::misc::simulation::settings::TModelMatching> m_matchingSettings {
                this
            }; 
            swift::misc::CData<swift::misc::simulation::data::TSimulatorLastSelection> m_modelSetSimulator {
                this
            }; 
            swift::misc::simulation::settings::CMultiSimulatorSettings m_multiSimulatorSettings {
                this
            }; 
            swift::misc::CSetting<swift::misc::simulation::settings::TInterpolationAndRenderingSetupGlobal>
                m_renderSettings { this }; 
            swift::misc::CSettingReadOnly<swift::misc::simulation::settings::TSimulatorMessages> m_messageSettings {
                this
            }; 
        };
    } // namespace context
} // namespace swift::core
 
#endif // SWIFT_CORE_CONTEXT_CONTEXTSIMULATOR_IMPL_H