simulatorfsxcommon.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_FSXCOMMON_SIMULATORFSXCOMMON_H
#define SWIFT_SIMPLUGIN_FSXCOMMON_SIMULATORFSXCOMMON_H
 
#include <QFutureWatcher>
#include <QHash>
#include <QList>
#include <QObject>
#include <QtPlugin>
 
#include "config/buildconfig.h"
#include "core/simulator.h"
#include "misc/aviation/airportlist.h"
#include "misc/aviation/altitude.h"
#include "misc/network/client.h"
#include "misc/pixmap.h"
#include "misc/pq/frequency.h"
#include "misc/simulation/aircraftmodel.h"
#include "misc/simulation/interpolation/interpolatorlinear.h"
#include "misc/simulation/settings/simulatorsettings.h"
#include "misc/simulation/simulatedaircraft.h"
#include "misc/simulation/simulatorplugininfo.h"
#include "misc/statusmessage.h"
#include "plugins/simulator/fscommon/simulatorfscommon.h"
#include "plugins/simulator/fsxcommon/fsxcommonexport.h"
#include "plugins/simulator/fsxcommon/simconnectdatadefinition.h"
#include "plugins/simulator/fsxcommon/simconnectobject.h"
#include "plugins/simulator/fsxcommon/simconnectwindows.h"
 
namespace swift::simplugin::fsxcommon
{
    enum EventIds
    {
        SystemEventSimStatus,
        SystemEventObjectAdded,
        SystemEventObjectRemoved,
        SystemEventSlewToggle,
        SystemEventFrame,
        SystemEventPause,
        SystemEventFlightLoaded,
        EventPauseToggle,
        EventFreezeLatLng,
        EventFreezeAlt,
        EventFreezeAtt,
        EventSetCom1Active,
        EventSetCom2Active,
        EventSetCom1Standby,
        EventSetCom2Standby,
        EventSetTransponderCode,
        EventTextMessage,
        EventSetTimeZuluYear,
        EventSetTimeZuluDay,
        EventSetTimeZuluHours,
        EventSetTimeZuluMinutes,
        // ------------ lights -------------
        EventLandingLightsOff,
        EventLandinglightsOn,
        EventLandingLightsSet,
        EventLandingLightsToggle,
        EventPanelLightsOff,
        EventPanelLightsOn,
        EventPanelLightsSet,
        EventStrobesOff,
        EventStrobesOn,
        EventStrobesSet,
        EventStrobesToggle,
        EventToggleBeaconLights,
        EventToggleCabinLights,
        EventToggleLogoLights,
        EventToggleNavLights,
        EventToggleRecognitionLights,
        EventToggleTaxiLights,
        EventToggleWingLights,
        // ------------- flaps -------------
        EventFlapsSet,
        // ---------- end marker -----------
        EventFSXEndMarker
    };
 
    struct TraceFsxSendId
    {
        TraceFsxSendId(DWORD sendId, const CSimConnectObject &simObject, const QString &comment)
            : sendId(sendId), simObject(simObject), comment(comment)
        {}
 
        // DWORD is unsigned
        DWORD sendId = 0; 
        CSimConnectObject simObject; 
        QString comment; 
 
        bool isForProbe() const { return simObject.getType() == CSimConnectObject::TerrainProbe; }
 
        bool isForAircraft() const { return simObject.getType() == CSimConnectObject::AircraftNonAtc; }
 
        bool isInvalid() const { return sendId == 0 && simObject.isInvalid() == 0 && comment.isEmpty(); }
 
        bool isValid() const { return !this->isInvalid(); }
 
        static const TraceFsxSendId &invalid()
        {
            static const TraceFsxSendId i(0, CSimConnectObject(), "");
            return i;
        }
    };
 
    class FSXCOMMON_EXPORT CSimulatorFsxCommon : public fscommon::CSimulatorFsCommon
    {
        Q_OBJECT
        Q_INTERFACES(swift::core::ISimulator)
        Q_INTERFACES(swift::misc::simulation::ISimulationEnvironmentProvider)
        Q_INTERFACES(swift::misc::simulation::IInterpolationSetupProvider)
 
    public:
        CSimulatorFsxCommon(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 ~CSimulatorFsxCommon() override;
 
        virtual bool connectTo() override;
        virtual bool disconnectFrom() 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 bool updateOwnSimulatorCockpit(const swift::misc::simulation::CSimulatedAircraft &ownAircraft,
                                               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 swift::misc::CStatusMessageList debugVerifyStateAfterAllAircraftRemoved() const override;
        virtual QString getStatisticsSimulatorSpecific() const override;
        virtual void resetAircraftStatistics() override;
        virtual void setFlightNetworkConnected(bool connected) 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 &aircraftCallsign) override;
 
        bool isTracingSendId() const;
 
        bool isTraceSendId() const { return m_traceSendId; }
 
        void setTractingSendId(bool trace);
 
        bool isUsingFsxTerrainProbe() const { return m_useFsxTerrainProbe; }
 
        void setUsingFsxTerrainProbe(bool use) { m_useFsxTerrainProbe = use; }
 
        bool isUsingSbOffsetValues() const { return m_useSbOffsets; }
 
        void setUsingSbOffsetValues(bool use);
 
        int receivedSBPackets() const { return m_sbDataReceived; }
 
        bool isAddingAsSimulatedObjectEnabled() const { return m_useAddSimulatedObj; }
 
        void setAddingAsSimulatedObjectEnabled(bool enabled);
 
        static bool isRequestForSimObjAircraft(DWORD requestId)
        {
            return requestId >= RequestSimObjAircraftStart && requestId <= RequestSimObjAircraftRangeEnd;
        }
 
        static bool isRequestForSimObjTerrainProbe(DWORD requestId)
        {
            return requestId >= RequestSimObjTerrainProbeStart && requestId <= RequestSimObjTerrainProbeRangeEnd;
        }
 
        static bool isRequestForSimConnectObject(DWORD requestId)
        {
            return isRequestForSimObjAircraft(requestId) || isRequestForSimObjTerrainProbe(requestId);
        }
 
        static CSimConnectDefinitions::SimObjectRequest requestToSimObjectRequest(DWORD requestId);
 
        static DWORD unitTestRequestId(CSimConnectObject::SimObjectType type);
 
        static QString fsxCharToQString(const char *fsxChar, int size = -1);
 
    protected:
        static void CALLBACK SimConnectProc(SIMCONNECT_RECV *pData, DWORD cbData, void *pContext);
 
        virtual bool isConnected() const override;
        virtual bool isSimulating() const override;
 
        virtual void reset() override;
        virtual void initSimulatorInternals() override;
        virtual void clearAllRemoteAircraftData() override;
        virtual void onOwnModelChanged(const swift::misc::simulation::CAircraftModel &newModel) override;
 
        virtual void timerEvent(QTimerEvent *event) override;
 
        virtual HRESULT initEventsP3D();
 
        virtual bool parseDetails(const swift::misc::CSimpleCommandParser &parser) override;
 
        bool triggerAutoTraceSendId(qint64 traceTimeMs = AutoTraceOffsetMs);
 
        swift::misc::aviation::CCallsign getCallsignForPendingProbeRequests(DWORD requestId, bool remove);
 
        SIMCONNECT_DATA_REQUEST_ID obtainRequestIdForSimObjAircraft();
 
        SIMCONNECT_DATA_REQUEST_ID obtainRequestIdForSimObjTerrainProbe();
 
        virtual bool releaseAIControl(const CSimConnectObject &simObject, SIMCONNECT_DATA_REQUEST_ID requestId);
 
        bool isValidSimObjectNotPendingRemoved(const CSimConnectObject &simObject) const;
 
        CSimConnectObject getSimObjectForTrace(const TraceFsxSendId &trace) const;
 
        bool removeSimObjectForTrace(const TraceFsxSendId &trace);
 
        virtual void removeCamera(CSimConnectObject &simObject);
 
        virtual void removeObserver(CSimConnectObject &simObject);
 
        HRESULT logAndTraceSendId(HRESULT hr, const QString &warningMsg, const QString &functionName,
                                  const QString &functionDetails = {});
 
        HRESULT logAndTraceSendId(HRESULT hr, const CSimConnectObject &simObject, const QString &warningMsg,
                                  const QString &functionName, const QString &functionDetails = {});
 
        HRESULT logAndTraceSendId(HRESULT hr, bool traceSendId, const CSimConnectObject &simObject,
                                  const QString &warningMsg, const QString &functionName,
                                  const QString &functionDetails = {});
 
        static QByteArray toFsxChar(const QString &string);
 
        static void registerHelp();
 
        static bool is32bit() { return (swift::config::CBuildConfig::buildWordSize() == 32); }
        static bool is64bit() { return (swift::config::CBuildConfig::buildWordSize() == 64); }
 
        static SIMCONNECT_DATA_INITPOSITION
        aircraftSituationToFsxPosition(const swift::misc::aviation::CAircraftSituation &situation, bool sendGnd = true,
                                       bool forceUnderflowDetection = false,
                                       swift::misc::CStatusMessage *details = nullptr);
 
        static SIMCONNECT_DATA_PBH
        aircraftSituationToFsxPBH(const swift::misc::aviation::CAircraftSituation &situation);
 
        static SIMCONNECT_DATA_INITPOSITION
        coordinateToFsxPosition(const swift::misc::geo::ICoordinateGeodetic &coordinate);
 
        static SIMCONNECT_DATA_LATLONALT
        coordinateToFsxLatLonAlt(const swift::misc::geo::ICoordinateGeodetic &coordinate);
 
        static bool isValidFsxPosition(const SIMCONNECT_DATA_INITPOSITION &fsxPos);
 
        static bool isValid180Deg(double deg) { return deg > -180.0 && deg <= 180.0; }
 
        static constexpr qint64 AutoTraceOffsetMs = 10 * 1000; 
        HANDLE m_hSimConnect = nullptr; 
        DispatchProc m_dispatchProc = &CSimulatorFsxCommon::SimConnectProc; 
        CSimConnectObjects m_simConnectObjects; 
 
        // probes
        bool m_useFsxTerrainProbe = is32bit(); 
        bool m_initFsxTerrainProbes = false; 
        int m_addedProbes = 0; 
        QMap<DWORD, swift::misc::aviation::CCallsign>
            m_pendingProbeRequests; 
 
        swift::misc::physical_quantities::CLength m_altitudeDelta; 
 
    private:
        enum AircraftAddMode
        {
            ExternalCall, 
            AddByTimer, 
            AddAfterAdded, 
            AddedAfterRemoved 
        };
 
        static const QString &modeToString(AircraftAddMode mode);
 
        void dispatch();
 
        bool physicallyAddRemoteAircraftImpl(const swift::misc::simulation::CSimulatedAircraft &newRemoteAircraft,
                                             AircraftAddMode addMode,
                                             const CSimConnectObject &correspondingSimObject = {});
 
        bool physicallyAddAITerrainProbe(const swift::misc::geo::ICoordinateGeodetic &coordinate, int number);
 
        int physicallyInitAITerrainProbes(const swift::misc::geo::ICoordinateGeodetic &coordinate, int number);
 
        swift::misc::aviation::CCallsignSet physicallyRemoveAircraftNotInProvider();
 
        void physicallyRemoveAircraftNotInProviderAsync();
 
        void verifyAddedRemoteAircraft(const swift::misc::simulation::CSimulatedAircraft &remoteAircraftIn);
 
        void addingAircraftFailed(const CSimConnectObject &simObject);
 
        bool verifyFailedAircraftInfo(const CSimConnectObject &simObject, swift::misc::CStatusMessage &details) const;
 
        bool logVerifyFailedAircraftInfo(const CSimConnectObject &simObject) const;
 
        void verifyAddedTerrainProbe(const swift::misc::simulation::CSimulatedAircraft &remoteAircraftIn);
 
        void timerBasedObjectAddOrRemove();
 
        void addPendingAircraftAfterAdded();
 
        void addPendingAircraft(AircraftAddMode mode);
 
        CSimConnectObject removeFromAddPendingAndAddAgainAircraft(const swift::misc::aviation::CCallsign &callsign);
 
        void setSimConnected();
 
        void onSimRunning();
 
        void onSimRunningDeferred(qint64 referenceTs);
 
        void onSimFrame();
 
        void onSimStopped();
 
        void onSimExit();
 
        HRESULT initWhenConnected();
 
        HRESULT initEvents();
 
        HRESULT initDataDefinitionsWhenConnected();
 
        void updateRemoteAircraft();
 
        bool updateRemoteAircraftParts(const CSimConnectObject &simObject,
                                       const swift::misc::simulation::CInterpolationResult &result, bool forcedUpdate);
 
        bool sendRemoteAircraftPartsToSimulator(const CSimConnectObject &simObject,
                                                const swift::misc::aviation::CAircraftParts &parts);
 
        bool sendRemoteAircraftAtcDataToSimulator(const CSimConnectObject &simObject);
 
        void sendToggledLightsToSimulator(const CSimConnectObject &simObject,
                                          const swift::misc::aviation::CAircraftLights &lightsWanted,
                                          bool force = false);
 
        void triggerUpdateRemoteAircraftFromSimulator(const CSimConnectObject &simObject,
                                                      const DataDefinitionPosData &remoteAircraftData);
 
        void triggerUpdateRemoteAircraftFromSimulator(const CSimConnectObject &simObject,
                                                      const DataDefinitionRemoteAircraftModel &remoteAircraftModel);
 
        void updateRemoteAircraftFromSimulator(const CSimConnectObject &simObject,
                                               const DataDefinitionPosData &remoteAircraftData);
 
        void updateRemoteAircraftFromSimulator(const CSimConnectObject &simObject,
                                               const DataDefinitionRemoteAircraftModel &remoteAircraftModel);
 
        void updateProbeFromSimulator(const swift::misc::aviation::CCallsign &callsign,
                                      const DataDefinitionPosData &remoteAircraftData);
 
        virtual void
        setTrueAltitude(swift::misc::aviation::CAircraftSituation &aircraftSituation,
                        const swift::simplugin::fsxcommon::DataDefinitionOwnAircraft &simulatorOwnAircraft);
 
        void updateOwnAircraftFromSimulator(const DataDefinitionOwnAircraft &simulatorOwnAircraft);
 
        void updateOwnAircraftFromSimulator(const DataDefinitionClientAreaSb &sbDataArea);
 
        void updateTransponderMode(const misc::aviation::CTransponder::TransponderMode xpdrMode);
 
        void updateMSFSTransponderMode(const DataDefinitionMSFSTransponderMode transponderMode);
 
        bool simulatorReportedObjectAdded(DWORD objectId);
 
        bool simulatorReportedObjectRemoved(DWORD objectID);
 
        bool setSimConnectObjectId(DWORD requestId, DWORD objectId);
 
        bool setCurrentLights(const swift::misc::aviation::CCallsign &callsign,
                              const swift::misc::aviation::CAircraftLights &lights);
 
        bool setLightsAsSent(const swift::misc::aviation::CCallsign &callsign,
                             const swift::misc::aviation::CAircraftLights &lights);
 
        bool stillDisplayReceiveExceptions();
 
        const CSimConnectObjects &getSimConnectObjects() const { return m_simConnectObjects; }
 
        CSimConnectObject getSimObjectForObjectId(DWORD objectId) const;
 
        bool requestPositionDataForSimObject(const CSimConnectObject &simObject,
                                             SIMCONNECT_PERIOD period = SIMCONNECT_PERIOD_SECOND);
 
        bool requestTerrainProbeData(const CSimConnectObject &simObject,
                                     const swift::misc::aviation::CCallsign &aircraftCallsign);
 
        bool requestLightsForSimObject(const CSimConnectObject &simObject);
 
        bool requestModelInfoForSimObject(const CSimConnectObject &simObject);
 
        bool stopRequestingDataForSimObject(const CSimConnectObject &simObject);
 
        static QString fsxPositionToString(const SIMCONNECT_DATA_INITPOSITION &position);
 
        swift::misc::aviation::CCallsignSet getCallsignsMissingInProvider() const;
 
        void setTraceSendId(bool traceSendId) { m_traceSendId = traceSendId; }
 
        void traceSendId(const CSimConnectObject &simObject, const QString &functionName, const QString &details = {},
                         bool forceTrace = false);
 
        TraceFsxSendId getSendIdTrace(DWORD sendId) const;
 
        QString getSendIdTraceDetails(const TraceFsxSendId &trace) const;
 
        QString getSendIdTraceDetails(DWORD sendId) const;
 
        int removeAllProbes();
 
        CSimConnectObject insertNewSimConnectObject(const swift::misc::simulation::CSimulatedAircraft &aircraft,
                                                    DWORD requestId, CSimConnectObject::SimObjectType type,
                                                    const CSimConnectObject &removedPendingObject = {});
 
        bool updateCOMFromSwiftToSimulator(const swift::misc::physical_quantities::CFrequency &newFreq,
                                           const swift::misc::physical_quantities::CFrequency &lastSimFreq,
                                           swift::misc::physical_quantities::CFrequency &last25kHzSimFreq, EventIds id);
 
        static const swift::misc::aviation::CAltitude &terrainProbeAltitude();
 
        static constexpr int GuessRemoteAircraftPartsCycle = 20; 
        static constexpr int SkipUpdateCyclesForCockpit = 10; 
        static constexpr int IgnoreReceiveExceptions = 10; 
        static constexpr int MaxSendIdTraces = 10000; 
        static constexpr DWORD MaxSimObjAircraft = 10000; 
        static constexpr DWORD MaxSimObjProbes = 100; 
 
        // -- second chance tresholds --
        static constexpr int ThresholdAddException = 1; 
        static constexpr int ThresholdAddedAndDirectlyRemoved = 2; 
 
        // -- range for sim data, each sim object will get its own request id and use the offset ranges
        static constexpr int RequestSimObjAircraftStart = static_cast<int>(CSimConnectDefinitions::RequestEndMarker);
        static constexpr int RequestSimObjAircraftEnd = RequestSimObjAircraftStart - 1 + MaxSimObjAircraft;
        static constexpr int RequestSimObjAircraftRangeEnd =
            RequestSimObjAircraftStart - 1 +
            static_cast<int>(CSimConnectDefinitions::SimObjectEndMarker) * MaxSimObjAircraft;
 
        // -- range for probe data, each probe object will get its own request id and use the offset ranges
        static constexpr int RequestSimObjTerrainProbeStart = RequestSimObjAircraftRangeEnd + 1;
        static constexpr int RequestSimObjTerrainProbeEnd = RequestSimObjTerrainProbeStart - 1 + MaxSimObjProbes;
        static constexpr int RequestSimObjTerrainProbeRangeEnd =
            RequestSimObjTerrainProbeStart - 1 +
            static_cast<int>(CSimConnectDefinitions::SimObjectEndMarker) * MaxSimObjProbes;
 
        // times
        static constexpr int AddPendingAircraftIntervalMs = 20 * 1000;
        static constexpr int DispatchIntervalMs = 10; 
        static constexpr int DeferSimulatingFlagMs =
            1500; 
        static constexpr int DeferResendingLights =
            2500; 
 
        QString m_simConnectVersion; 
        bool m_simConnected = false; 
        bool m_simSimulating = false; 
        bool m_useSbOffsets = true; 
        bool m_logSbOffsets = false; 
        bool m_traceSendId = false; 
        bool m_useAddSimulatedObj = false; 
        qint64 m_traceAutoUntilTs = -1; 
        qint64 m_simulatingChangedTs = -1; 
        int m_sbDataReceived = 0; 
 
        // tracing dispatch performance
        int m_dispatchErrors = 0; 
        int m_dispatchProcCount = 0; 
        int m_dispatchProcEmptyCount = 0; 
        qint64 m_dispatchTimeMs = -1; 
        qint64 m_dispatchMaxTimeMs = -1; 
        qint64 m_dispatchProcTimeMs = -1; 
        qint64 m_dispatchProcMaxTimeMs = -1; 
 
        SIMCONNECT_RECV_ID m_dispatchReceiveIdLast = SIMCONNECT_RECV_ID_NULL; 
        SIMCONNECT_RECV_ID m_dispatchReceiveIdMaxTime =
            SIMCONNECT_RECV_ID_NULL; 
        DWORD m_dispatchRequestIdLast =
            CSimConnectDefinitions::RequestEndMarker; 
        DWORD m_dispatchRequestIdMaxTime =
            CSimConnectDefinitions::RequestEndMarker; 
 
        // sending via SimConnect
        QList<TraceFsxSendId> m_sendIdTraces; 
        int m_receiveExceptionCount = 0; 
        int m_requestSimObjectDataCount = 0; 
 
        // settings
        swift::misc::simulation::settings::CMultiSimulatorDetailsSettings m_detailsSettings;
 
        // objects
        CSimConnectObjects m_simConnectObjectsPositionAndPartsTraces; 
        CSimConnectObjects m_addPendingAircraft; 
        SIMCONNECT_DATA_REQUEST_ID m_requestIdSimObjAircraft = static_cast<SIMCONNECT_DATA_REQUEST_ID>(
            RequestSimObjAircraftStart); 
        SIMCONNECT_DATA_REQUEST_ID m_requestIdSimObjTerrainProbe = static_cast<SIMCONNECT_DATA_REQUEST_ID>(
            RequestSimObjTerrainProbeStart); 
        QTimer m_simObjectTimer; 
 
        // Last selected frequencies in simulator before setting 8.33 kHz spacing frequency
        swift::misc::physical_quantities::CFrequency m_lastCom1Active {
            0, swift::misc::physical_quantities::CFrequencyUnit::nullUnit()
        }; 
        swift::misc::physical_quantities::CFrequency m_lastCom1Standby {
            0, swift::misc::physical_quantities::CFrequencyUnit::nullUnit()
        }; 
        swift::misc::physical_quantities::CFrequency m_lastCom2Active {
            0, swift::misc::physical_quantities::CFrequencyUnit::nullUnit()
        }; 
        swift::misc::physical_quantities::CFrequency m_lastCom2Standby {
            0, swift::misc::physical_quantities::CFrequencyUnit::nullUnit()
        }; 
 
        static QString requestIdToString(DWORD requestId);
 
    public:
        static DWORD offsetSimObjAircraft(CSimConnectDefinitions::SimObjectRequest req)
        {
            return MaxSimObjAircraft * static_cast<DWORD>(req);
        }
        static DWORD offsetSimObjTerrainProbe(CSimConnectDefinitions::SimObjectRequest req)
        {
            return MaxSimObjProbes * static_cast<DWORD>(req);
        }
    };
 
    class FSXCOMMON_EXPORT CSimulatorFsxCommonListener : public swift::core::ISimulatorListener
    {
        Q_OBJECT
 
    public:
        CSimulatorFsxCommonListener(const swift::misc::simulation::CSimulatorPluginInfo &info);
 
        virtual QString backendInfo() const override;
 
    protected:
        virtual void startImpl() override;
 
        virtual void stopImpl() override;
 
        virtual void checkImpl() override;
 
    private:
        void checkConnection();
 
        bool checkVersionAndSimulator() const;
 
        bool checkSimConnectDll() const;
 
        bool connectToSimulator();
 
        bool disconnectFromSimulator();
 
        void adjustTimerInterval(qint64 checkTimeMs);
 
        static constexpr int MinQueryIntervalMs = 5 * 1000; // 5 seconds
 
        QTimer m_timer { this }; 
        QString m_simulatorVersion;
        QString m_simConnectVersion;
        QString m_simulatorName;
        QString m_simulatorDetails;
        HANDLE m_hSimConnect;
        bool m_simConnected = false; 
        swift::misc::CStatusMessage m_lastMessage; 
 
        static void CALLBACK SimConnectProc(SIMCONNECT_RECV *pData, DWORD cbData, void *pContext);
    };
} // namespace swift::simplugin::fsxcommon
 
#endif // SWIFT_SIMPLUGIN_FSXCOMMON_SIMULATORFSXCOMMON_H