airspacemonitor_8h_source.html

 // 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_AIRSPACE_MONITOR_H

 #define SWIFT_CORE_AIRSPACE_MONITOR_H


 #include <QHash>

 #include <QJsonObject>

 #include <QMetaObject>

 #include <QObject>

 #include <QQueue>

 #include <QString>

 #include <QTimer>

 #include <QtGlobal>


 #include "core/swiftcoreexport.h"

 #include "misc/aviation/aircraftpartslist.h"

 #include "misc/aviation/aircraftsituationlist.h"

 #include "misc/aviation/atcstation.h"

 #include "misc/aviation/atcstationlist.h"

 #include "misc/aviation/callsignset.h"

 #include "misc/aviation/flightplan.h"

 #include "misc/geo/coordinategeodetic.h"

 #include "misc/identifier.h"

 #include "misc/network/clientprovider.h"

 #include "misc/network/connectionstatus.h"

 #include "misc/network/ecosystem.h"

 #include "misc/network/server.h"

 #include "misc/network/userlist.h"

 #include "misc/pq/angle.h"

 #include "misc/pq/frequency.h"

 #include "misc/pq/length.h"

 #include "misc/simplecommandparser.h"

 #include "misc/simulation/aircraftmodel.h"

 #include "misc/simulation/aircraftmodelsetprovider.h"

 #include "misc/simulation/airspaceaircraftsnapshot.h"

 #include "misc/simulation/matchinglog.h"

 #include "misc/simulation/ownaircraftprovider.h"

 #include "misc/simulation/remoteaircraftprovider.h"

 #include "misc/simulation/settings/modelmatchersettings.h"

 #include "misc/simulation/simulatedaircraftlist.h"

 #include "misc/simulation/simulationenvironmentprovider.h"


 namespace swift::core

 {

     namespace fsd

     {

         class CFSDClient;

     }

     class CAirspaceAnalyzer;


     class SWIFT_CORE_EXPORT CAirspaceMonitor final :

         public swift::misc::simulation::CRemoteAircraftProvider, // those data will be provided from the class

                                                                  // CAirspaceMonitor

         public swift::misc::network::CClientProvider, // those data will be provided from the class CAirspaceMonitor

         public swift::misc::simulation::COwnAircraftAware, // used to obtain in memory information about own aircraft

         public swift::misc::simulation::CSimulationEnvironmentAware // elevation info etc. from simulator

     {

         // CRemoteAircraftProvider is QObject

         Q_OBJECT

         Q_INTERFACES(swift::misc::network::IClientProvider)

         Q_INTERFACES(swift::misc::simulation::IRemoteAircraftProvider)


     public:

         static const QStringList &getLogCategories();


         CAirspaceMonitor(swift::misc::simulation::IOwnAircraftProvider *ownAircraft,

                          swift::misc::simulation::IAircraftModelSetProvider *modelSetProvider,

                          fsd::CFSDClient *fsdClient, QObject *parent);


         QObject *asQObject() override { return this; }

         misc::simulation::CAirspaceAircraftSnapshot getLatestAirspaceAircraftSnapshot() const override;

         bool updateFastPositionEnabled(const misc::aviation::CCallsign &callsign,

                                        bool enableFastPositonUpdates) override;


         misc::network::CUserList getUsers() const;


         misc::network::CUserList getUsersForCallsigns(const misc::aviation::CCallsignSet &callsigns) const;


         misc::aviation::CFlightPlan loadFlightPlanFromNetwork(const misc::aviation::CCallsign &callsign);


         misc::aviation::CFlightPlanRemarks tryToGetFlightPlanRemarks(const misc::aviation::CCallsign &callsign) const;


         misc::aviation::CAtcStationList getAtcStationsOnline() const { return m_atcStationsOnline; }


         misc::aviation::CAtcStationList getAtcStationsOnlineRecalculated();


         misc::aviation::CAtcStation getAtcStationForComUnit(const misc::aviation::CComSystem &comSystem) const;


         void clear();


         void requestAircraftDataUpdates();


         void requestAtisUpdates();


         CAirspaceAnalyzer *analyzer() const { return m_analyzer; }


         void gracefulShutdown();


         int reInitializeAllAircraft();


         void setMaxRange(const swift::misc::physical_quantities::CLength &range);


         void testCreateDummyOnlineAtcStations(int number);


         void testAddAircraftParts(const swift::misc::aviation::CCallsign &callsign,

                                   const swift::misc::aviation::CAircraftParts &parts, bool incremental);


         enum MatchingReadinessFlag

         {

             NotReady = 0,

             ReceivedIcaoCodes = 1 << 0,

             ReceivedFsInnPacket = 1 << 1,

             ReadyForMatchingSent = 1 << 2,

             RecursiveCall = 1 << 3,

             ReceivedAll = ReceivedIcaoCodes | ReceivedFsInnPacket,

             Verified = 1 << 4,

         };

         Q_DECLARE_FLAGS(MatchingReadiness, MatchingReadinessFlag)


         static const QString &enumFlagToString(MatchingReadinessFlag r);

         static QString enumToString(MatchingReadiness r);


         bool parseCommandLine(const QString &commandLine, const swift::misc::CIdentifier &originator);


         static void registerHelp()

         {

             if (swift::misc::CSimpleCommandParser::registered("swift::core::fsd::CFSDClient")) { return; }

             swift::misc::CSimpleCommandParser::registerCommand({ ".fsd range distance", "FSD max. range" });

         }


     signals:

         void changedAtcStationsOnline();


         void atcStationDisconnected(const swift::misc::aviation::CAtcStation &station);


         void requestedNewAircraft(const swift::misc::aviation::CCallsign &callsign, const QString &aircraftDesignator,

                                   const QString &airlineDesignator, const QString &livery);


         void readyForModelMatching(const swift::misc::simulation::CSimulatedAircraft &remoteAircraft);


         void changedAtisReceived(const swift::misc::aviation::CCallsign &callsign);


     private:

         struct FsInnPacket

         {

             FsInnPacket() {}


             FsInnPacket(const QString &aircraftIcaoDesignator, const QString &airlineIcaoDesignator,

                         const QString &combinedCode, const QString &modelString);


             QString aircraftIcaoDesignator;

             QString airlineIcaoDesignator;

             QString combinedCode;

             QString modelString;

         };


         struct Readiness

         {

         private:

             qint64 ts = -1;

             MatchingReadiness readyness = NotReady;


         public:

             Readiness &addFlag(MatchingReadinessFlag flag)

             {

                 if (flag == RecursiveCall) { return *this; }

                 if (ts < 0) { ts = QDateTime::currentMSecsSinceEpoch(); }

                 readyness.setFlag(flag, true);

                 return *this;

             }


             void resetTimestampToNow() { ts = QDateTime::currentMSecsSinceEpoch(); }


             Readiness &setFlag(MatchingReadinessFlag flag)

             {

                 if (flag == RecursiveCall) { return *this; }

                 readyness = NotReady;

                 this->addFlag(flag);

                 return *this;

             }


             bool receivedAll() const

             {

                 return readyness.testFlag(ReceivedIcaoCodes) && readyness.testFlag(ReceivedFsInnPacket);

             }


             bool receivedIcaoCodes() const { return readyness.testFlag(ReceivedIcaoCodes); }


             bool wasMatchingSent() const { return readyness.testFlag(ReadyForMatchingSent); }


             bool wasVerified() const { return readyness.testFlag(Verified); }


             qint64 getAgeMs() const

             {

                 if (ts < 0) { return -1; }

                 return QDateTime::currentMSecsSinceEpoch() - ts;

             }


             QString toQString() const

             {

                 return QStringLiteral("ts: %1 ready: %2").arg(ts).arg(CAirspaceMonitor::enumToString(readyness));

             }

         };


         swift::misc::aviation::CAtcStationList m_atcStationsOnline;

         QHash<swift::misc::aviation::CCallsign, FsInnPacket> m_tempFsInnPackets;

         QHash<swift::misc::aviation::CCallsign, swift::misc::aviation::CFlightPlan>

             m_flightPlanCache;

         QHash<swift::misc::aviation::CCallsign, Readiness> m_readiness;

         swift::misc::CSettingReadOnly<swift::misc::simulation::settings::TModelMatching> m_matchingSettings {

             this

         };

         QQueue<swift::misc::aviation::CCallsign> m_queryAtis;

         QQueue<swift::misc::aviation::CCallsign> m_queryPilot;

         misc::simulation::IAircraftModelSetProvider *m_modelSetProvider = nullptr;

         fsd::CFSDClient *m_fsdClient = nullptr;

         CAirspaceAnalyzer *m_analyzer = nullptr;

         int m_maxDistanceNM = 125;

         int m_maxDistanceNMHysteresis = qRound(1.1 * m_maxDistanceNM);

         int m_foundInNonMovingAircraft = 0;

         int m_foundInElevationsOnGnd = 0;


         // Processing for queries etc. (fast)

         static constexpr int FastProcessIntervalMs = 50;

         QTimer m_fastProcessTimer;


         void fastProcessing();


         // Processing for validations etc. (slow)

         static constexpr int SlowProcessIntervalMs = 125 * 1000;

         QTimer m_slowProcessTimer;


         void slowProcessing();


         // model matching times

         static constexpr qint64 MMCheckAgainMs = 2000;

         static constexpr qint64 MMMaxAgeMs = MMCheckAgainMs * 3;

         static constexpr qint64 MMMaxAgeThresholdMs = MMCheckAgainMs * 10;

         static constexpr qint64 MMVerifyMs = MMCheckAgainMs * 12;


         void removeAllOnlineAtcStations();


         void removeAllAircraft();


         void removeFromAircraftCachesAndLogs(const swift::misc::aviation::CCallsign &callsign);


         void sendInitialAtcQueries(const swift::misc::aviation::CCallsign &callsign);


         void queryAllOnlineAtcStations();


         bool sendNextStaggeredAtisQuery();


         void sendInitialPilotQueries(const swift::misc::aviation::CCallsign &callsign, bool withIcaoQuery,

                                      bool withFsInn);


         bool sendNextStaggeredPilotDataQuery();


         bool isConnected() const;


         bool isConnectedAndNotShuttingDown() const;


         const swift::misc::network::CServer &getConnectedServer() const;


         const swift::misc::network::CEcosystem &getCurrentEcosystem() const;


         bool supportsVatsimDataFile() const;


         swift::misc::physical_quantities::CLength

         calculateDistanceToOwnAircraft(const swift::misc::aviation::CAircraftSituation &situation) const;


         swift::misc::physical_quantities::CAngle

         calculateBearingToOwnAircraft(const swift::misc::aviation::CAircraftSituation &situation) const;


         virtual swift::misc::aviation::CAircraftSituation

         storeAircraftSituation(const swift::misc::aviation::CAircraftSituation &situation,

                                bool allowTestOffset = true) override;


         swift::misc::simulation::CSimulatedAircraft

         addOrUpdateAircraftInRange(const swift::misc::aviation::CCallsign &callsign, const QString &aircraftIcao,

                                    const QString &airlineIcao, const QString &livery, const QString &modelString,

                                    swift::misc::simulation::CAircraftModel::ModelType modelType,

                                    swift::misc::CStatusMessageList *log);


         bool addNewAircraftInRange(const swift::misc::simulation::CSimulatedAircraft &aircraft);


         void asyncReInitializeAllAircraft(const swift::misc::simulation::CSimulatedAircraftList &aircraft,

                                           bool readyForModelMatching);


         int updateOnlineStation(const swift::misc::aviation::CCallsign &callsign,

                                 const swift::misc::CPropertyIndexVariantMap &vm, bool skipEqualValues = true,

                                 bool sendSignal = true);


         bool handleMaxRange(const swift::misc::aviation::CAircraftSituation &situation);


         bool recallFsInnPacket(const swift::misc::aviation::CCallsign &callsign);


         void sendReadyForModelMatching(const swift::misc::aviation::CCallsign &callsign, MatchingReadinessFlag rf);


         void verifyReceivedIcaoData(const swift::misc::aviation::CCallsign &callsign);


         swift::misc::simulation::CAircraftModel

         reverseLookupModelWithFlightplanData(const swift::misc::aviation::CCallsign &callsign,

                                              const QString &aircraftIcao, const QString &airlineIcao,

                                              const QString &liveryString, const QString &modelString,

                                              swift::misc::simulation::CAircraftModel::ModelType type,

                                              swift::misc::CStatusMessageList *log, bool runMatchinScript = true);


         bool isCopilotAircraft(const swift::misc::aviation::CCallsign &callsign) const;


         Readiness &addMatchingReadinessFlag(const swift::misc::aviation::CCallsign &callsign,

                                             MatchingReadinessFlag mrf);


         static bool extrapolateElevation(swift::misc::aviation::CAircraftSituationList &situations,

                                          const swift::misc::aviation::CAircraftSituationChange &change);


         static bool extrapolateElevation(swift::misc::aviation::CAircraftSituation &situationToBeUpdated,

                                          const swift::misc::aviation::CAircraftSituation &oldSituation,

                                          const swift::misc::aviation::CAircraftSituation &olderSituation,

                                          const swift::misc::aviation::CAircraftSituationChange &oldChange);


         void onAircraftUpdateReceived(const swift::misc::aviation::CAircraftSituation &situation,

                                       const swift::misc::aviation::CTransponder &transponder);


         void onAtcPositionUpdate(const swift::misc::aviation::CCallsign &callsign,

                                  const swift::misc::physical_quantities::CFrequency &frequency,

                                  const swift::misc::geo::CCoordinateGeodetic &position,

                                  const swift::misc::physical_quantities::CLength &range);


         void onCustomFSInnPacketReceived(const swift::misc::aviation::CCallsign &callsign,

                                          const QString &airlineIcaoDesignator, const QString &aircraftIcaoDesignator,

                                          const QString &combinedAircraftType, const QString &modelString);


         void onRealNameReplyReceived(const swift::misc::aviation::CCallsign &callsign, const QString &realname);

         void onCapabilitiesReplyReceived(const swift::misc::aviation::CCallsign &callsign,

                                          swift::misc::network::CClient::Capabilities clientCaps);

         void onServerReplyReceived(const swift::misc::aviation::CCallsign &callsign, const QString &server);

         void onFlightPlanReceived(const swift::misc::aviation::CCallsign &callsign,

                                   const swift::misc::aviation::CFlightPlan &flightPlan);

         void onAtcControllerDisconnected(const swift::misc::aviation::CCallsign &callsign);

         void onAtisReceived(const swift::misc::aviation::CCallsign &callsign,

                             const swift::misc::aviation::CInformationMessage &atisMessage);

         void onAtisLogoffTimeReceived(const swift::misc::aviation::CCallsign &callsign, const QString &zuluTime);

         void onIcaoCodesReceived(const swift::misc::aviation::CCallsign &callsign,

                                  const QString &aircraftIcaoDesignator, const QString &airlineIcaoDesignator,

                                  const QString &livery);

         void onPilotDisconnected(const swift::misc::aviation::CCallsign &callsign);

         void onFrequencyReceived(const swift::misc::aviation::CCallsign &callsign,

                                  const swift::misc::physical_quantities::CFrequency &frequency);

         void onReceivedVatsimDataFile();

         void onAircraftConfigReceived(const swift::misc::aviation::CCallsign &callsign, const QJsonObject &jsonObject,

                                       qint64 currentOffsetMs);

         void onAircraftInterimUpdateReceived(const swift::misc::aviation::CAircraftSituation &situation);

         void onAircraftVisualUpdateReceived(const swift::misc::aviation::CAircraftSituation &situation);

         void onAircraftSimDataUpdateReceived(const swift::misc::aviation::CAircraftSituation &situation,

                                              const swift::misc::aviation::CAircraftParts &parts, qint64 currentOffsetMs,

                                              const QString &aircraftIcao, const QString &airlineIcao);

         void onConnectionStatusChanged(swift::misc::network::CConnectionStatus oldStatus,

                                        swift::misc::network::CConnectionStatus newStatus);

         void onRevBAircraftConfigReceived(const swift::misc::aviation::CCallsign &callsign, const QString &config,

                                           qint64 currentOffsetMs);

     };

 } // namespace swift::core


 Q_DECLARE_METATYPE(swift::core::CAirspaceMonitor::MatchingReadinessFlag)

 Q_DECLARE_OPERATORS_FOR_FLAGS(swift::core::CAirspaceMonitor::MatchingReadiness)


 #endif // SWIFT_CORE_AIRSPACE_MONITOR_H

aircraftmodel.h

aircraftmodelsetprovider.h

aircraftpartslist.h

aircraftsituationlist.h

airspaceaircraftsnapshot.h

angle.h

atcstation.h

atcstationlist.h

callsignset.h

QHash< swift::misc::aviation::CCallsign, FsInnPacket >

swift::core::CAirspaceAnalyzer
Class monitoring and analyzing (closest aircraft, outdated aircraft / watchdog) airspace in backgroun...
Definition: airspaceanalyzer.h:54

swift::core::CAirspaceMonitor
Keeps track of other entities in the airspace: aircraft, ATC stations, etc. Central instance of data ...
Definition: airspacemonitor.h:62

swift::core::CAirspaceMonitor::MatchingReadinessFlag
MatchingReadinessFlag
Matching readiness.
Definition: airspacemonitor.h:143

swift::core::CAirspaceMonitor::getAtcStationsOnline
misc::aviation::CAtcStationList getAtcStationsOnline() const
Returns the current online ATC stations.
Definition: airspacemonitor.h:103

swift::core::CAirspaceMonitor::asQObject
QObject * asQObject()
Members not implenented or fully implenented by CRemoteAircraftProvider.
Definition: airspacemonitor.h:80

swift::core::CAirspaceMonitor::atcStationDisconnected
void atcStationDisconnected(const swift::misc::aviation::CAtcStation &station)
ATC station disconnected.

swift::core::CAirspaceMonitor::analyzer
CAirspaceAnalyzer * analyzer() const
Analyzer.
Definition: airspacemonitor.h:121

swift::core::CAirspaceMonitor::readyForModelMatching
void readyForModelMatching(const swift::misc::simulation::CSimulatedAircraft &remoteAircraft)
Ready for model matching.

swift::core::CAirspaceMonitor::changedAtisReceived
void changedAtisReceived(const swift::misc::aviation::CCallsign &callsign)
An ATIS has been received.

swift::core::CAirspaceMonitor::changedAtcStationsOnline
void changedAtcStationsOnline()
Online ATC stations were changed.

swift::core::CAirspaceMonitor::enumToString
static QString enumToString(MatchingReadiness r)
As string.
Definition: airspacemonitor.cpp:349

swift::core::CAirspaceMonitor::registerHelp
static void registerHelp()
Register help.
Definition: airspacemonitor.h:168

swift::core::fsd::CFSDClient
FSD client Todo: Send (interim) data updates automatically Todo Check ':' in FSD messages....
Definition: fsdclient.h:85

swift::misc::CIdentifier
Value object encapsulating information identifying a component of a modular distributed swift process...
Definition: identifier.h:29

swift::misc::CPropertyIndexVariantMap
Specialized value object compliant map for variants, based on indexes.
Definition: propertyindexvariantmap.h:39

swift::misc::CSettingReadOnly< swift::misc::simulation::settings::TModelMatching >

swift::misc::CSimpleCommandParser::registerCommand
static void registerCommand(const CommandHtmlHelp &command)
Register a command.
Definition: simplecommandparser.cpp:128

swift::misc::CSimpleCommandParser::registered
static bool registered(const QString &helpContext)
Help already registered.
Definition: simplecommandparser.cpp:138

swift::misc::CStatusMessageList
Status messages, e.g. from Core -> GUI.
Definition: statusmessagelist.h:33

swift::misc::aviation::CAircraftParts
Value object encapsulating information of aircraft's parts.
Definition: aircraftparts.h:26

swift::misc::aviation::CAircraftSituationChange
Value object about changes in situations.
Definition: aircraftsituationchange.h:36

swift::misc::aviation::CAircraftSituation
Value object encapsulating information of an aircraft's situation.
Definition: aircraftsituation.h:54

swift::misc::aviation::CAircraftSituationList
List of aircraft situations.
Definition: aircraftsituationlist.h:42

swift::misc::aviation::CAtcStation
Value object encapsulating information about an ATC station.
Definition: atcstation.h:38

swift::misc::aviation::CAtcStationList
Value object for a list of ATC stations.
Definition: atcstationlist.h:32

swift::misc::aviation::CCallsign
Value object encapsulating information of a callsign.
Definition: callsign.h:30

swift::misc::aviation::CCallsignSet
Value object for a set of callsigns.
Definition: callsignset.h:26

swift::misc::aviation::CComSystem
COM system (aka "radio")
Definition: comsystem.h:37

swift::misc::aviation::CFlightPlan
Value object for a flight plan.
Definition: flightplan.h:148

swift::misc::aviation::CFlightPlanRemarks
Flight plan remarks, parsed values.
Definition: flightplan.h:46

swift::misc::aviation::CInformationMessage
Value object encapsulating information message (ATIS, METAR, TAF)
Definition: informationmessage.h:26

swift::misc::aviation::CTransponder
Transponder.
Definition: transponder.h:28

swift::misc::geo::CCoordinateGeodetic
Geodetic coordinate.
Definition: coordinategeodetic.h:232

swift::misc::network::CClientProvider
Direct in memory access to client (network client) data.
Definition: clientprovider.h:88

swift::misc::network::CConnectionStatus
Value object encapsulating information about a connection status.
Definition: connectionstatus.h:18

swift::misc::network::CEcosystem
Ecosystem of server belonging together.
Definition: ecosystem.h:21

swift::misc::network::CServer
Value object encapsulating information of a server.
Definition: server.h:28

swift::misc::network::CUserList
Value object encapsulating a list of voice rooms.
Definition: userlist.h:26

swift::misc::network::IClientProvider
Direct in memory access to client (network client) data.
Definition: clientprovider.h:26

swift::misc::physical_quantities::CAngle
Physical unit angle (radians, degrees)
Definition: angle.h:23

swift::misc::physical_quantities::CFrequency
Physical unit frequency.
Definition: frequency.h:18

swift::misc::physical_quantities::CLength
Physical unit length (length)
Definition: length.h:18

swift::misc::simulation::CAircraftModel
Aircraft model (used by another pilot, my models on disk)
Definition: aircraftmodel.h:71

swift::misc::simulation::CAircraftModel::ModelType
ModelType
Model type.
Definition: aircraftmodel.h:75

swift::misc::simulation::CAirspaceAircraftSnapshot
Current situation in the skies analyzed.
Definition: airspaceaircraftsnapshot.h:29

swift::misc::simulation::COwnAircraftAware
Delegating class which can be directly used to access an.
Definition: ownaircraftprovider.h:128

swift::misc::simulation::CRemoteAircraftProvider
Implementaion of the interface, which can also be used for testing.
Definition: remoteaircraftprovider.h:309

swift::misc::simulation::CSimulatedAircraft
Comprehensive information of an aircraft.
Definition: simulatedaircraft.h:60

swift::misc::simulation::CSimulatedAircraftList
Value object encapsulating a list of aircraft.
Definition: simulatedaircraftlist.h:42

swift::misc::simulation::CSimulationEnvironmentAware
Class which can be directly used to access an.
Definition: simulationenvironmentprovider.h:337

swift::misc::simulation::IAircraftModelSetProvider
Value object encapsulating a list of aircraft models.
Definition: aircraftmodelsetprovider.h:17

swift::misc::simulation::IOwnAircraftProvider
Direct threadsafe in memory access to own aircraft.
Definition: ownaircraftprovider.h:38

swift::misc::simulation::IRemoteAircraftProvider
Direct thread safe in memory access to remote aircraft.
Definition: remoteaircraftprovider.h:45

clientprovider.h

connectionstatus.h

coordinategeodetic.h

ecosystem.h

frequency.h

identifier.h

length.h

matchinglog.h

flightplan.h

modelmatchersettings.h

swift::core
Backend services of the swift project, like dealing with the network or the simulators.
Definition: actionbind.cpp:7

ownaircraftprovider.h

remoteaircraftprovider.h

server.h

simplecommandparser.h

simulatedaircraftlist.h

simulationenvironmentprovider.h

swiftcoreexport.h

SWIFT_CORE_EXPORT
#define SWIFT_CORE_EXPORT
Export a class or function from the library.
Definition: swiftcoreexport.h:20

userlist.h