afvclient.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2019 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_CORE_AFV_CLIENTS_AFVCLIENT_H
#define SWIFT_CORE_AFV_CLIENTS_AFVCLIENT_H
 
#include <atomic>
 
#include <QObject>
#include <QString>
#include <QVector>
 
#include "core/afv/audio/input.h"
#include "core/afv/audio/output.h"
#include "core/afv/audio/soundcardsampleprovider.h"
#include "core/afv/connection/clientconnection.h"
#include "core/afv/dto.h"
#include "core/context/contextownaircraft.h"
#include "core/swiftcoreexport.h"
#include "misc/audio/audiodeviceinfo.h"
#include "misc/audio/audiosettings.h"
#include "misc/aviation/comsystem.h"
#include "misc/identifiable.h"
#include "misc/settingscache.h"
#include "misc/worker.h"
#include "sound/sampleprovider/volumesampleprovider.h"
 
namespace swift::core::afv::clients
{
    class SWIFT_CORE_EXPORT CAfvClient final : public swift::misc::CContinuousWorker, public swift::misc::CIdentifiable
    {
        Q_OBJECT
 
        Q_PROPERTY(double inputVolumePeakVU READ getInputVolumePeakVU NOTIFY inputVolumePeakVU)
        Q_PROPERTY(double outputVolumePeakVU READ getOutputVolumePeakVU NOTIFY outputVolumePeakVU)
        Q_PROPERTY(swift::core::afv::clients::CAfvClient::ConnectionStatus connectionStatus READ getConnectionStatus
                       NOTIFY connectionStatusChanged)
        Q_PROPERTY(QString receivingCallsignsCom1 READ getReceivingCallsignsStringCom1 NOTIFY receivingCallsignsChanged)
        Q_PROPERTY(QString receivingCallsignsCom2 READ getReceivingCallsignsStringCom2 NOTIFY receivingCallsignsChanged)
 
    public:
        static const QStringList &getLogCategories();
 
        enum ConnectionStatus
        {
            Disconnected,
            Connected
        };
        Q_ENUM(ConnectionStatus)
 
        
        CAfvClient(const QString &apiServer, QObject *owner);
 
        ~CAfvClient() override { this->stopAudio(); }
 
        CAfvClient(const CAfvClient &) = delete;
        CAfvClient &operator=(const CAfvClient &) = delete;
 
        CAfvClient(const CAfvClient &&) = delete;
        CAfvClient &operator=(const CAfvClient &&) = delete;
 
        QString getCallsign() const;
        void setCallsign(const QString &getCallsign);
 
        bool isConnected() const;
 
        ConnectionStatus getConnectionStatus() const;
 
        Q_INVOKABLE void connectTo(const QString &cid, const QString &password, const QString &callsign,
                                   const QString &client);
 
        void disconnectFrom(bool stop);
        Q_INVOKABLE void disconnectFrom() { this->disconnectFrom(false); }
        void disconnectFromAndStop() { this->disconnectFrom(true); }
 
        Q_INVOKABLE QStringList availableInputDevices() const;
        Q_INVOKABLE QStringList availableOutputDevices() const;
 
        Q_INVOKABLE void setBypassEffects(bool value);
 
        bool isStarted() const { return m_isStarted; }
 
        bool isOutputMuted() const;
        void setOutputMuted(bool mute);
 
        void startAudio();
        void startAudio(const swift::misc::audio::CAudioDeviceInfo &inputDevice,
                        const swift::misc::audio::CAudioDeviceInfo &outputDevice);
        Q_INVOKABLE void startAudio(const QString &inputDeviceName, const QString &outputDeviceName);
        void stopAudio();
        void restartAudio();
 
        bool isComUnitIntegrated() const { return m_integratedComUnit; }
 
        /* NOT used
        double getDeviceInputVolume() const;
        bool   setDeviceInputVolume(double volume);
        double getDeviceOutputVolume() const;
        bool   setDeviceOutputVolume(double volume);
        */
 
        void setReceiveAudio(bool receive);
 
        Q_INVOKABLE void enableTransceiver(quint16 id, bool enable);
        void enableComUnit(swift::misc::aviation::CComSystem::ComUnit comUnit, bool enable);
        bool isEnabledTransceiver(quint16 id) const;
        bool isEnabledComUnit(swift::misc::aviation::CComSystem::ComUnit comUnit) const;
 
        void setTransmittingTransceiver(quint16 transceiverID);
        void setTransmittingComUnit(swift::misc::aviation::CComSystem::ComUnit comUnit);
        void setTransmittingTransceivers(const QVector<TxTransceiverDto> &transceivers);
 
        bool isTransmittingTransceiver(quint16 id) const;
        bool isTransmittingComUnit(swift::misc::aviation::CComSystem::ComUnit comUnit) const;
 
        void setRxTx(bool rx1, bool tx1, bool rx2, bool tx2);
        void getRxTx(bool &rx1, bool &tx1, bool &rx2, bool &tx2) const;
 
        QVector<TransceiverDto> getTransceivers() const;
        QVector<TxTransceiverDto> getTransmittingTransceivers() const;
        QSet<quint16> getEnabledTransceivers() const;
 
        Q_INVOKABLE void updateComFrequency(quint16 id, quint32 frequencyHz);
        void updateComFrequency(swift::misc::aviation::CComSystem::ComUnit comUnit,
                                const swift::misc::physical_quantities::CFrequency &comFrequency);
        void updateComFrequency(swift::misc::aviation::CComSystem::ComUnit comUnit,
                                const swift::misc::aviation::CComSystem &comSystem);
 
        Q_INVOKABLE void updatePosition(double latitudeDeg, double longitudeDeg, double heightMeters);
 
        void updateFromOwnAircraft(const swift::misc::simulation::CSimulatedAircraft &aircraft,
                                   bool withSignals = true);
 
        Q_INVOKABLE void setPtt(bool active);
 
        Q_INVOKABLE void setLoopBack(bool on) { m_loopbackOn = on; }
        Q_INVOKABLE bool isLoopback() const { return m_loopbackOn; }
 
        double getInputVolumeDb() const;
        Q_INVOKABLE bool setInputVolumeDb(double valueDb);
 
        double getComOutputVolumeDb(swift::misc::aviation::CComSystem::ComUnit comUnit) const;
        Q_INVOKABLE bool setComOutputVolumeDb(swift::misc::aviation::CComSystem::ComUnit comUnit, double valueDb);
 
        double getOutputGainRatio(swift::misc::aviation::CComSystem::ComUnit comUnit) const;
 
        int getNormalizedInputVolume() const;
        int getNormalizedComOutputVolume(swift::misc::aviation::CComSystem::ComUnit comUnit) const;
        int getNormalizedMasterOutputVolume() const;
        bool setNormalizedInputVolume(int volume);
        bool setNormalizedComOutputVolume(swift::misc::aviation::CComSystem::ComUnit comUnit, int volume);
        bool setNormalizedMasterOutputVolume(int volume);
 
        double getInputVolumePeakVU() const;
        double getOutputVolumePeakVU() const;
 
        const swift::misc::audio::CAudioDeviceInfo &getInputDevice() const;
        const swift::misc::audio::CAudioDeviceInfo &getOutputDevice() const;
        bool usesSameDevices(const swift::misc::audio::CAudioDeviceInfo &inputDevice,
                             const swift::misc::audio::CAudioDeviceInfo &outputDevice);
 
        QString getReceivingCallsignsStringCom1() const;
        QString getReceivingCallsignsStringCom2() const;
        swift::misc::aviation::CCallsignSet getReceivingCallsignsCom1() const;
        swift::misc::aviation::CCallsignSet getReceivingCallsignsCom2() const;
        QStringList getReceivingCallsignsStringCom1Com2() const;
 
        bool updateVoiceServerUrl(const QString &url);
 
        void gracefulShutdown();
 
    signals:
        void receivingCallsignsChanged(const swift::core::afv::audio::TransceiverReceivingCallsignsChangedArgs &args);
 
        void receivedCallsignsChanged(const swift::misc::aviation::CCallsignSet &com1Callsigns,
                                      const swift::misc::aviation::CCallsignSet &com2Callsigns);
 
        void connectionStatusChanged(ConnectionStatus status);
 
        void afvConnectionFailure(const swift::misc::CStatusMessage &msg);
 
        void updatedFromOwnAircraftCockpit();
 
        void ptt(bool active, const swift::misc::CIdentifier &identifier);
 
        void inputVolumePeakVU(double value);
        void outputVolumePeakVU(double value);
 
        void startedAudio(const swift::misc::audio::CAudioDeviceInfo &inputDevice,
                          const swift::misc::audio::CAudioDeviceInfo &outputDevice);
 
        void stoppedAudio();
 
        void changedOutputMute(bool muted);
 
    protected:
        void initialize() override;
 
        void cleanup() override;
 
    private:
        void opusDataAvailable(const audio::OpusDataAvailableArgs &args); // threadsafe
        void audioOutDataAvailable(const AudioRxOnTransceiversDto &dto); // threadsafe
        void inputVolumeStream(const audio::InputVolumeStreamArgs &args);
        void outputVolumeStream(const audio::OutputVolumeStreamArgs &args);
 
        void onTimerUpdate();
        void onSettingsChanged();
        void autoLogoffWithoutFsdNetwork();
 
        void updateTransceivers(bool updateFrequencies = true);
        void onUpdateTransceiversFromContext(const swift::misc::simulation::CSimulatedAircraft &aircraft,
                                             const swift::misc::CIdentifier &originator);
        void onReceivingCallsignsChanged(const swift::core::afv::audio::TransceiverReceivingCallsignsChangedArgs &args);
 
        void retryConnectTo(const QString &cid, const QString &password, const QString &callsign, const QString &client,
                            const QString &reason);
 
        void reconnectTo(const QString &cid, const QString &password, const QString &callsign, const QString &client,
                         int delayMs, const swift::misc::CStatusMessage &msg);
 
        void toggleTransmissionCapability(bool disableTransmission);
 
        QVector<StationDto> getAliasedStations() const;
        void setAliasedStations(const QVector<StationDto> &stations);
 
        quint32 getAliasFrequencyHz(quint32 frequencyHz) const;
 
        bool isVoiceServerAlive() const;
 
        const QString &getVoiceServerUrl() const;
 
        bool fuzzyMatchCallsign(const QString &callsign, const QString &compareTo) const;
        void getPrefixSuffix(const QString &callsign, QString &prefix, QString &suffix) const;
 
        static constexpr int PositionUpdatesMs = 20000; 
        static constexpr int SampleRate = 48000;
        static constexpr int FrameSize = static_cast<int>(SampleRate * 0.02); 
        static constexpr double MinDbIn = -18.0;
        static constexpr double MaxDbIn = 18.0;
        static constexpr double MinDbOut = -60.0;
        static constexpr double MaxDbOut = 18.0;
        static constexpr quint32 UniCom = 122800000;
 
        static quint16 comUnitToTransceiverId(swift::misc::aviation::CComSystem::ComUnit comUnit);
        static swift::misc::aviation::CComSystem::ComUnit transceiverIdToComUnit(quint16 id);
 
        connection::CClientConnection *m_connection = nullptr;
        swift::misc::CSetting<swift::misc::audio::TSettings> m_audioSettings { this, &CAfvClient::onSettingsChanged };
        QString m_callsign;
 
        audio::CInput *m_input = nullptr;
        audio::COutput *m_output = nullptr;
 
        audio::CSoundcardSampleProvider *m_soundcardSampleProvider = nullptr;
        swift::sound::sample_provider::CVolumeSampleProvider *m_outputSampleProvider = nullptr;
 
        std::atomic_bool m_transmit { false };
        std::atomic_bool m_transmitHistory { false };
        std::atomic_bool m_disableTransmissionCapability { false }; 
        QVector<TxTransceiverDto> m_transmittingTransceivers;
        QVector<TransceiverDto> m_transceivers;
        QSet<quint16> m_enabledTransceivers;
        static const QVector<quint16> &allTransceiverIds()
        {
            static const QVector<quint16> transceiverIds { 0, 1 };
            return transceiverIds;
        }
 
        std::atomic_int m_fsdConnectMismatches { 0 }; 
        std::atomic_int m_retryConnectAttempt { 0 }; 
        std::atomic_int m_heartBeatFailures { 0 }; 
        std::atomic_bool m_isStarted { false };
        std::atomic_bool m_loopbackOn { false };
        std::atomic_bool m_winCoInitialized { false }; 
        std::atomic_bool m_integratedComUnit { false }; 
 
        double m_inputVolumeDb = 0.0;
        int m_outputMasterVolumeNormalized = 0;
        int m_outputVolumeCom1Normalized = 0;
        int m_outputVolumeCom2Normalized = 0;
        double m_outputVolumeDbCom1 = 0.0;
        double m_outputGainRatioCom1 = 1.0; 
        double m_outputVolumeDbCom2 = 0.0;
        double m_outputGainRatioCom2 = 1.0; 
        double m_maxDbReadingInPTTInterval = -100;
 
        QTimer *m_voiceServerTimer = nullptr;
        QVector<StationDto> m_aliasedStations;
 
        audio::InputVolumeStreamArgs m_inputVolumeStream;
        audio::OutputVolumeStreamArgs m_outputVolumeStream;
 
        void checkServerHeartbeat();
        void deferredInit();
        void initTransceivers();
        void connectWithContexts();
        void fetchSimulatorSettings();
        static bool hasContexts();
 
        std::atomic_bool m_connectedWithContext { false };
 
        mutable QRecursiveMutex m_mutex;
        mutable QRecursiveMutex m_mutexInputStream;
        mutable QRecursiveMutex m_mutexOutputStream;
        mutable QRecursiveMutex m_mutexTransceivers;
        mutable QRecursiveMutex m_mutexCallsign;
        mutable QRecursiveMutex m_mutexConnection;
        mutable QRecursiveMutex m_mutexVolume;
        mutable QRecursiveMutex m_mutexSampleProviders;
    };
} // namespace swift::core::afv::clients
 
#endif // SWIFT_CORE_AFV_CLIENTS_AFVCLIENT_H