Conference.h

//
// Conference.h
// ZDK
//
 
#ifndef ZDK_NET_Conference_h
#define ZDK_NET_Conference_h
 
#include "native_shared_ptr.h"
#include "PublicInterfaces.h"
#include "Call.h"
#include "BrandingInfo.h"
#include "CallStatus.h"
#include "AudioVideoCodecs.h"
#include "VideoCallInfo.h"
#include "Account.h"
#include "ConferenceEventsHandler.h"
#include "CallEventsHandler.h"
#include "VideoRendererEventsHandler.h"
#include "VideoFrameFormat.h"
#include "OriginType.h"
#include "DTMFCodes.h"
#include "AudioFileFormat.h"
#include "Result.h"
#include "CameraSensorLocation.h"
#include "ZHandle.h"
 
using namespace System::Collections::Generic;
 
namespace ZDK_NET
{
    ref class BrandingInfo;
    ref class CallStatus;
    ref class VideoCallInfo;
    ref class Account;
    ref class Call;
    ref class ConferenceEventsHandler;
    ref class CallEventsHandler;
    ref class VideoRendererEventsHandler;
    ref class Result;
 
    public ref class Conference : ZHandle
    {
    private:
        //LISTENERS:
        static GeneralStatusEventListener *ConferenceEventsHandler_Listener = nullptr;
        static GeneralStatusEventListener *CallEventsHandler_Listener = nullptr;
        static GeneralStatusEventListener *VideoRendererEventsHandler_Listener = nullptr;
 
        static bool RegisterEventListeners()
        {
            std::shared_ptr<GeneralStatusEventListener> ConferenceEventsHandler_Listener_tmp = std::make_shared<GeneralStatusEventListener>();
            ConferenceEventsHandler_Listener = ConferenceEventsHandler_Listener_tmp.get();
            listenersMap->try_emplace(reinterpret_cast<intptr_t>(ConferenceEventsHandler_Listener), std::move(ConferenceEventsHandler_Listener_tmp));
            std::shared_ptr<GeneralStatusEventListener> CallEventsHandler_Listener_tmp = std::make_shared<GeneralStatusEventListener>();
            CallEventsHandler_Listener = CallEventsHandler_Listener_tmp.get();
            listenersMap->try_emplace(reinterpret_cast<intptr_t>(CallEventsHandler_Listener), std::move(CallEventsHandler_Listener_tmp));
            std::shared_ptr<GeneralStatusEventListener> VideoRendererEventsHandler_Listener_tmp = std::make_shared<GeneralStatusEventListener>();
            VideoRendererEventsHandler_Listener = VideoRendererEventsHandler_Listener_tmp.get();
            listenersMap->try_emplace(reinterpret_cast<intptr_t>(VideoRendererEventsHandler_Listener), std::move(VideoRendererEventsHandler_Listener_tmp));
            return true;
        }
 
        static bool RegisteredEventListeners = RegisterEventListeners();
    public:
        ZDK::IConference* cppRef = nullptr;
 
        Conference(ZDK::Shared::Conference src);
        ~Conference();
        !Conference();
 
        property long long ConferenceHandle
        {
            long long get();
        }
 
        property int CallsCount
        {
            int get();
        }
 
        property List<Call^>^ Calls
        {
            List<Call^>^ get();
        }
 
        property long long CallHandle
        {
            long long get();
        }
 
        property ZDK_NET::BrandingInfo^ Branding
        {
            ZDK_NET::BrandingInfo^ get();
            void set(ZDK_NET::BrandingInfo^ value);
        }
 
        property ZDK_NET::CallStatus^ Status
        {
            ZDK_NET::CallStatus^ get();
        }
 
        property System::String^ CalleeNumber
        {
            System::String^ get();
        }
 
        property System::String^ CalleeName
        {
            System::String^ get();
        }
 
        property ZDK_NET::AudioVideoCodecs CodecInUse
        {
            ZDK_NET::AudioVideoCodecs get();
        }
 
        property bool OnSpeaker
        {
            bool get();
            void set(bool value);
        }
 
        property bool Held
        {
            bool get();
            void set(bool value);
        }
 
        property bool Muted
        {
            bool get();
            void set(bool value);
        }
 
        property ZDK_NET::VideoCallInfo^ VideoCallInfo
        {
            ZDK_NET::VideoCallInfo^ get();
        }
 
        property bool IsFirstClass
        {
            bool get();
        }
 
        property ZDK_NET::Account^ Owner
        {
            ZDK_NET::Account^ get();
        }
 
        property System::String^ RecordFileName
        {
            void set(System::String^ value);
        }
 
        ZDK_NET::Result^ AddCall(ZDK_NET::Call^ hCall);
 
        ZDK_NET::Result^ RemoveCall(ZDK_NET::Call^ hCall, bool hangUp);
 
        ZDK_NET::Result^ MuteCall(ZDK_NET::Call^ hCall);
 
        ZDK_NET::Result^ UnmuteCall(ZDK_NET::Call^ hCall);
 
        bool IsCallFromConference(long long hCall);
 
        ZDK_NET::Result^ AcquireVideoSinkMngrFromCall(ZDK_NET::Call^ call);
 
        void SetConferenceEventsListener(ZDK_NET::ConferenceEventsHandler^ confEventHandler);
 
        void DropConferenceEventsListener(ZDK_NET::ConferenceEventsHandler^ confEventHandler);
 
        void SetCallStatusListener(ZDK_NET::CallEventsHandler^ value);
 
        void DropCallStatusListener(ZDK_NET::CallEventsHandler^ value);
 
        void DropAllEventListeners();
 
        void SetVideoRendererNotificationsListener(ZDK_NET::VideoRendererEventsHandler^ value);
 
        ZDK_NET::Result^ Ringing();
 
        ZDK_NET::Result^ AcceptCall();
 
        ZDK_NET::Result^ HangUp();
 
        ZDK_NET::Call^ AcceptCallTransfer();
 
        ZDK_NET::Result^ RejectCallTransfer();
 
        ZDK_NET::Result^ AttendedTransfer(ZDK_NET::Call^ transferee);
 
        ZDK_NET::Result^ BlindTransfer(System::String^ transferee);
 
        ZDK_NET::Result^ AcceptVideo(bool accept);
 
        ZDK_NET::Result^ OfferVideo();
 
        void SendVideoFrame(unsigned char* bytes, int byteCount, ZDK_NET::VideoFrameFormat type);
 
        ZDK_NET::Result^ VideoToggleCamera();
 
        ZDK_NET::CameraSensorLocation VideoGetCameraLocation();
 
        ZDK_NET::Result^ RestartVideoCapture();
 
        bool HasVideo(ZDK_NET::OriginType origin);
 
        void StopHandlingVoipPhoneCallEvents();
 
        void StartHandlingVoipPhoneCallEvents();
 
        ZDK_NET::Result^ NotifyAccountOfOwnershipChange();
 
        ZDK_NET::Result^ SendDTMF(ZDK_NET::DTMFCodes dtmf);
 
        ZDK_NET::Result^ StartRecording();
 
        ZDK_NET::Result^ StopRecording();
 
        ZDK_NET::Result^ EnableZrtp(bool enabled);
 
        ZDK_NET::Result^ ConfirmZrtpSas(bool confirmed);
 
        ZDK_NET::Result^ ConfigureCallRecordFormat(ZDK_NET::AudioFileFormat format);
 
        virtual long long Handle() override;
 
        virtual void Initialize() override;
 
        virtual void ReleaseReference() override;
 
    };
}
 
#endif