contextaudio.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_CONTEXTAUDIO_H
#define SWIFT_CORE_CONTEXT_CONTEXTAUDIO_H
 
#include <QCommandLineOption>
#include <QString>
 
#include "core/actionbind.h"
#include "core/afv/audio/receiversampleprovider.h"
#include "core/audio/audiosettings.h"
#include "core/context/context.h"
#include "core/corefacade.h"
#include "core/corefacadeconfig.h"
#include "core/swiftcoreexport.h"
#include "misc/audio/audiodeviceinfolist.h"
#include "misc/audio/audiosettings.h"
#include "misc/audio/notificationsounds.h"
#include "misc/aviation/callsignset.h"
#include "misc/aviation/comsystem.h"
#include "misc/aviation/selcal.h"
#include "misc/genericdbusinterface.h"
#include "misc/identifiable.h"
#include "misc/identifier.h"
#include "misc/input/actionhotkeydefs.h"
#include "misc/network/connectionstatus.h"
#include "misc/network/userlist.h"
#include "misc/simplecommandparser.h"
#include "sound/notificationplayer.h"
#include "sound/selcalplayer.h"
 
// clazy:excludeall=const-signal-or-slot
 
#define SWIFT_CORE_CONTEXTAUDIO_INTERFACENAME "org.swift_project.swift_core.contextaudio"
 
#define SWIFT_CORE_CONTEXTAUDIO_OBJECTPATH "/audio"
 
class QDBusConnection;
 
namespace swift::misc
{
    class CDBusServer;
}
namespace swift::core
{
    namespace afv::clients
    {
        class CAfvClient;
    }
    namespace context
    {
        class SWIFT_CORE_EXPORT IContextAudio : public IContext
        {
            Q_OBJECT
            Q_CLASSINFO("D-Bus Interface", SWIFT_CORE_CONTEXTAUDIO_INTERFACENAME)
 
            friend class swift::core::CCoreFacade;
 
        public:
            static const QString &InterfaceName();
 
            static const QString &ObjectPath();
 
            QString getPathAndContextId() const override { return this->buildPathAndContextId(ObjectPath()); }
 
            static IContextAudio *create(CCoreFacade *runtime, CCoreFacadeConfig::ContextMode mode,
                                         swift::misc::CDBusServer *server, QDBusConnection &connection);
 
            // ------------- only use DBus signals here -------------
        signals:
            void voiceClientFailure(const swift::misc::CStatusMessage &msg);
 
        public slots:
            // ------------- DBus ---------------
 
            virtual swift::misc::audio::CAudioDeviceInfoList getRegisteredDevices() const = 0;
 
            virtual void registerDevices(const swift::misc::audio::CAudioDeviceInfoList &devices) = 0;
 
            virtual void unRegisterDevices(const swift::misc::audio::CAudioDeviceInfoList &devices) = 0;
 
            virtual void unRegisterDevicesFor(const swift::misc::CIdentifier &identifier) = 0;
 
            virtual void registerAudioCallsign(const swift::misc::aviation::CCallsign &callsign,
                                               const swift::misc::CIdentifier &identifier) = 0;
 
            virtual void unRegisterAudioCallsign(const swift::misc::aviation::CCallsign &callsign,
                                                 const swift::misc::CIdentifier &identifier) = 0;
 
            virtual bool hasRegisteredAudioCallsign(const swift::misc::aviation::CCallsign &callsign) const = 0;
 
            // ------------- DBus ---------------
 
        protected:
            IContextAudio(CCoreFacadeConfig::ContextMode mode, CCoreFacade *runtime);
 
            void onChangedLocalDevices(const swift::misc::audio::CAudioDeviceInfoList &devices);
        };
 
        class SWIFT_CORE_EXPORT CContextAudioBase : public IContextAudio, public swift::misc::CIdentifiable
        {
            Q_OBJECT
            friend class swift::core::CCoreFacade;
 
        protected:
            CContextAudioBase(CCoreFacadeConfig::ContextMode mode, CCoreFacade *runtime);
 
        public:
            ~CContextAudioBase() override;
 
            CContextAudioBase(const CContextAudioBase &) = delete;
            CContextAudioBase &operator=(const CContextAudioBase &) = delete;
 
            CContextAudioBase(CContextAudioBase &&) = delete;
            CContextAudioBase &operator=(CContextAudioBase &&) = delete;
 
            void gracefulShutdown();
 
            void setRxTx(bool rx1, bool tx1, bool rx2, bool tx2);
            void getRxTx(bool &rx1, bool &tx1, bool &rx2, bool &tx2) const;
 
            // -------- parts which can run in core and GUI, referring to local voice client ------------
 
            swift::misc::audio::CAudioDeviceInfoList getAudioDevices() const;
            swift::misc::audio::CAudioDeviceInfoList getAudioInputDevices() const;
            swift::misc::audio::CAudioDeviceInfoList getAudioOutputDevices() const;
 
            swift::misc::audio::CAudioDeviceInfoList getCurrentAudioDevices() const;
 
            void setCurrentAudioDevices(const swift::misc::audio::CAudioDeviceInfo &inputDevice,
                                        const swift::misc::audio::CAudioDeviceInfo &outputDevice);
 
            void setMasterOutputVolume(int volume);
            void setComOutputVolume(swift::misc::aviation::CComSystem::ComUnit comUnit, int volume);
            int getMasterOutputVolume() const;
            int getComOutputVolume(swift::misc::aviation::CComSystem::ComUnit comUnit) const;
            void setOutputMute(bool muted);
            bool isOutputMuted() const;
 
            void playSelcalTone(const swift::misc::aviation::CSelcal &selcal);
 
            void playNotification(swift::misc::audio::CNotificationSounds::NotificationFlag notification,
                                  bool considerSettings, int volume = -1);
 
            void enableAudioLoopback(bool enable = true);
            bool isAudioLoopbackEnabled() const;
 
            QString audioRunsWhereInfo() const;
 
            const swift::misc::CIdentifier &audioRunsWhere() const;
 
            bool isEnabledComUnit(swift::misc::aviation::CComSystem::ComUnit comUnit) const;
 
            bool isTransmittingComUnit(swift::misc::aviation::CComSystem::ComUnit comUnit) const;
 
            bool connectAudioWithNetworkCredentials();
 
            bool isAudioConnected() const;
 
            bool isAudioStarted() const;
 
            bool isAudioEnabled() const { return m_voiceClient != nullptr; }
 
            bool isComUnitIntegrated() const;
 
            afv::clients::CAfvClient *afvClient() const { return m_voiceClient; }
 
            static const QList<QCommandLineOption> &getCmdLineOptions();
 
            static bool isNoAudioSet();
 
            static void registerHelp()
            {
                if (swift::misc::CSimpleCommandParser::registered("swift::core::context::CContextAudioBase"))
                {
                    return;
                }
                swift::misc::CSimpleCommandParser::registerCommand({ ".mute", "mute audio" });
                swift::misc::CSimpleCommandParser::registerCommand({ ".unmute", "unmute audio" });
                swift::misc::CSimpleCommandParser::registerCommand({ ".vol volume", "volume 0..100" });
            }
 
            // -------- parts which can run in core and GUI, referring to local voice client ------------
 
        public slots:
            // ------------- DBus ---------------
 
            bool parseCommandLine(const QString &commandLine, const swift::misc::CIdentifier &originator) override;
 
            // ------------- DBus ---------------
 
            // ------------ local signals -------
        signals:
            void changedAudioVolume(int volume);
 
            void changedOutputMute(bool muted);
 
            void changedLocalAudioDevices(const swift::misc::audio::CAudioDeviceInfoList &devices);
 
            void startedAudio(const swift::misc::audio::CAudioDeviceInfo &input,
                              const swift::misc::audio::CAudioDeviceInfo &output);
 
            void stoppedAudio();
 
            void ptt(bool active, const swift::misc::CIdentifier &identifier);
 
            // ------------ local signals -------
 
        private:
            void initVoiceClient();
 
            void terminateVoiceClient();
 
            void setVoiceTransmission(bool enable);
 
            void changeDeviceSettings();
 
            void onChangedAudioSettings();
 
            void audioIncreaseVolume(bool enabled);
            void audioDecreaseVolume(bool enabled);
            void audioIncreaseVolumeCom1(bool enabled);
            void audioDecreaseVolumeCom1(bool enabled);
            void audioIncreaseVolumeCom2(bool enabled);
            void audioDecreaseVolumeCom2(bool enabled);
 
            void xCtxNetworkConnectionStatusChanged(const swift::misc::network::CConnectionStatus &from,
                                                    const swift::misc::network::CConnectionStatus &to);
 
            void onAfvConnectionStatusChanged(int status);
 
            void onAfvConnectionFailure(const swift::misc::CStatusMessage &msg);
 
            CActionBind m_actionPtt { swift::misc::input::pttHotkeyAction(), swift::misc::input::pttHotkeyIcon(), this,
                                      &CContextAudioBase::setVoiceTransmission };
            CActionBind m_actionAudioVolumeIncrease { swift::misc::input::audioVolumeIncreaseHotkeyAction(),
                                                      swift::misc::input::audioVolumeIncreaseHotkeyIcon(), this,
                                                      &CContextAudioBase::audioIncreaseVolume };
            CActionBind m_actionAudioVolumeDecrease { swift::misc::input::audioVolumeDecreaseHotkeyAction(),
                                                      swift::misc::input::audioVolumeDecreaseHotkeyIcon(), this,
                                                      &CContextAudioBase::audioDecreaseVolume };
            CActionBind m_actionAudioVolumeIncreaseCom1 { swift::misc::input::audioVolumeIncreaseCom1HotkeyAction(),
                                                          swift::misc::input::audioVolumeIncreaseHotkeyIcon(), this,
                                                          &CContextAudioBase::audioIncreaseVolumeCom1 };
            CActionBind m_actionAudioVolumeDecreaseCom1 { swift::misc::input::audioVolumeDecreaseCom1HotkeyAction(),
                                                          swift::misc::input::audioVolumeDecreaseHotkeyIcon(), this,
                                                          &CContextAudioBase::audioDecreaseVolumeCom1 };
            CActionBind m_actionAudioVolumeIncreaseCom2 { swift::misc::input::audioVolumeIncreaseCom2HotkeyAction(),
                                                          swift::misc::input::audioVolumeIncreaseHotkeyIcon(), this,
                                                          &CContextAudioBase::audioIncreaseVolumeCom2 };
            CActionBind m_actionAudioVolumeDecreaseCom2 { swift::misc::input::audioVolumeDecreaseCom2HotkeyAction(),
                                                          swift::misc::input::audioVolumeDecreaseHotkeyIcon(), this,
                                                          &CContextAudioBase::audioDecreaseVolumeCom2 };
 
            int m_outMasterVolumeBeforeMute = 50;
            static constexpr int MinUnmuteVolume = 20; 
 
            static bool isRunningWithLocalCore();
 
            // settings
            swift::misc::CSetting<swift::misc::audio::TSettings> m_audioSettings {
                this, &CContextAudioBase::onChangedAudioSettings
            };
 
            swift::misc::CSetting<audio::TInputDevice> m_inputDeviceSetting {
                this, &CContextAudioBase::changeDeviceSettings
            };
            swift::misc::CSetting<audio::TOutputDevice> m_outputDeviceSetting {
                this, &CContextAudioBase::changeDeviceSettings
            };
 
            // AFV
            afv::clients::CAfvClient *m_voiceClient = nullptr;
            bool m_winCoInitialized = false;
            swift::misc::audio::CAudioDeviceInfoList m_activeLocalDevices;
 
            // Players
            swift::sound::CSelcalPlayer *m_selcalPlayer = nullptr;
            swift::sound::CNotificationPlayer m_notificationPlayer;
        };
    } // namespace context
} // namespace swift::core
 
#endif // SWIFT_CORE_CONTEXT_CONTEXTAUDIO_H