AudioEndpointControl.h

//
// AudioEndpointControl.h
// ZDK
//
 
#ifndef ZDK_NET_AudioEndpointControl_h
#define ZDK_NET_AudioEndpointControl_h
 
#include "native_shared_ptr.h"
#include "PublicInterfaces.h"
#include "AudioRoutingEndpoint.h"
#include "EchoCancellationType.h"
#include "AudioSourcePresetType.h"
#include "AudioDevice.h"
#include "AutomaticGainControlType.h"
#include "HostAPI.h"
#include "AudioResampler.h"
#include "AudioFileFormat.h"
#include "Sound.h"
#include "AudioOutputDeviceType.h"
#include "AudioEventsHandler.h"
#include "Result.h"
#include "ZHandle.h"
 
using namespace System::Collections::Generic;
 
namespace ZDK_NET
{
    ref class AudioDevice;
    ref class Sound;
    ref class AudioEventsHandler;
    ref class Result;
 
    public ref class AudioEndpointControl : ZHandle
    {
    private:
        //LISTENERS:
        static GeneralStatusEventListener *AudioEventsHandler_Listener = nullptr;
 
        static bool RegisterEventListeners()
        {
            std::shared_ptr<GeneralStatusEventListener> AudioEventsHandler_Listener_tmp = std::make_shared<GeneralStatusEventListener>();
            AudioEventsHandler_Listener = AudioEventsHandler_Listener_tmp.get();
            listenersMap->try_emplace(reinterpret_cast<intptr_t>(AudioEventsHandler_Listener), std::move(AudioEventsHandler_Listener_tmp));
            return true;
        }
 
        static bool RegisteredEventListeners = RegisterEventListeners();
    public:
        ZDK::IAudioEndpointControl* cppRef = nullptr;
 
        AudioEndpointControl(ZDK::Shared::AudioEndpointControl src);
        ~AudioEndpointControl();
        !AudioEndpointControl();
 
        property ZDK_NET::AudioRoutingEndpoint AudioEndpoint
        {
            ZDK_NET::AudioRoutingEndpoint get();
            void set(ZDK_NET::AudioRoutingEndpoint value);
        }
 
        property double MicLevel
        {
            double get();
            void set(double value);
        }
 
        property double OutputLevel
        {
            double get();
            void set(double value);
        }
 
        property double RingLevel
        {
            double get();
            void set(double value);
        }
 
        property ZDK_NET::EchoCancellationType EchoCancellation
        {
            ZDK_NET::EchoCancellationType get();
            void set(ZDK_NET::EchoCancellationType value);
        }
 
        property bool HighPassFilter
        {
            bool get();
            void set(bool value);
        }
 
        property float PreAmplifier
        {
            float get();
            void set(float value);
        }
 
        property bool NoiseSuppression
        {
            bool get();
            void set(bool value);
        }
 
        property ZDK_NET::AudioSourcePresetType AudioSourcePreset
        {
            ZDK_NET::AudioSourcePresetType get();
            void set(ZDK_NET::AudioSourcePresetType value);
        }
 
        property List<AudioDevice^>^ AudioDevices
        {
            List<AudioDevice^>^ get();
        }
 
        property bool MicBoost
        {
            bool get();
            void set(bool value);
        }
 
        property bool EnableFixedSpeakerGain
        {
            bool get();
            void set(bool value);
        }
 
        property double FixedSpeakerGain
        {
            double get();
            void set(double value);
        }
 
        ZDK_NET::AutomaticGainControlType GetAutomaticGainControlMode();
 
        float GetAutomaticGainControlGain();
 
        ZDK_NET::Result^ SetAutomaticGainControlMode(ZDK_NET::AutomaticGainControlType type, float gain);
 
        ZDK_NET::Result^ HostApi(ZDK_NET::HostAPI value);
 
        ZDK_NET::Result^ Resampler(ZDK_NET::AudioResampler value);
 
        ZDK_NET::AudioDevice^ GetDeviceByName(System::String^ name);
 
        ZDK_NET::AudioDevice^ GetCurrentInputDevice();
 
        ZDK_NET::Result^ SetCurrentInputDevice(ZDK_NET::AudioDevice^ device);
 
        ZDK_NET::AudioDevice^ GetCurrentOutputDevice();
 
        ZDK_NET::Result^ SetCurrentOutputDevice(ZDK_NET::AudioDevice^ device);
 
        ZDK_NET::AudioDevice^ GetCurrentRingDevice();
 
        ZDK_NET::Result^ SetCurrentRingDevice(ZDK_NET::AudioDevice^ device);
 
        ZDK_NET::Sound^ AddSoundFromMemory(unsigned char* data, int length, int sampleLen, int frequency, bool repeat, int pauseMs);
 
        ZDK_NET::Sound^ AddSoundFromFile(System::String^ filePath, ZDK_NET::AudioFileFormat fileFormat, bool repeat, int pauseMs);
 
        ZDK_NET::Result^ StartSound(ZDK_NET::Sound^ sound, ZDK_NET::AudioOutputDeviceType outputType);
 
        ZDK_NET::Result^ StopSound(ZDK_NET::Sound^ sound, ZDK_NET::AudioOutputDeviceType outputType);
 
        ZDK_NET::Result^ StartPlayback(ZDK_NET::Sound^ sound, ZDK_NET::AudioOutputDeviceType monitorDevice);
 
        ZDK_NET::Result^ StopPlayback();
 
        ZDK_NET::Result^ SetCallRecordingNotifySound(ZDK_NET::Sound^ sound, ZDK_NET::AudioOutputDeviceType monitorDevice);
 
        ZDK_NET::Result^ MuteInput(bool value);
 
        ZDK_NET::Result^ MuteOutput(bool value);
 
        void AddStatusListener(ZDK_NET::AudioEventsHandler^ value);
 
        void DropStatusListener(ZDK_NET::AudioEventsHandler^ value);
 
        virtual long long Handle() override;
 
        virtual void Initialize() override;
 
        virtual void ReleaseReference() override;
 
    };
}
 
#endif