AccountProvider.h

//
// AccountProvider.h
// ZDK
//
 
#ifndef ZDK_NET_AccountProvider_h
#define ZDK_NET_AccountProvider_h
 
#include "native_shared_ptr.h"
#include "PublicInterfaces.h"
#include "Account.h"
#include "String.h"
#include "SipMethodTypes.h"
#include "AccountProviderEventsHandler.h"
#include "AccountConfig.h"
#include "MSRPConfig.h"
#include "StunConfig.h"
#include "IAXConfig.h"
#include "SIPConfig.h"
#include "ZRTPConfig.h"
#include "PushConfig.h"
#include "HeaderField.h"
#include "ZHandle.h"
 
using namespace System::Collections::Generic;
 
namespace ZDK_NET
{
    ref class Account;
    ref class AccountProviderEventsHandler;
    ref class AccountConfig;
    ref class MSRPConfig;
    ref class StunConfig;
    ref class IAXConfig;
    ref class SIPConfig;
    ref class ZRTPConfig;
    ref class PushConfig;
    ref class HeaderField;
 
    public ref class AccountProvider : ZHandle
    {
    private:
        //LISTENERS:
        static GeneralStatusEventListener *AccountProviderEventsHandler_Listener = nullptr;
 
        static bool RegisterEventListeners()
        {
            std::shared_ptr<GeneralStatusEventListener> AccountProviderEventsHandler_Listener_tmp = std::make_shared<GeneralStatusEventListener>();
            AccountProviderEventsHandler_Listener = AccountProviderEventsHandler_Listener_tmp.get();
            listenersMap->try_emplace(reinterpret_cast<intptr_t>(AccountProviderEventsHandler_Listener), std::move(AccountProviderEventsHandler_Listener_tmp));
            return true;
        }
 
        static bool RegisteredEventListeners = RegisterEventListeners();
    public:
        ZDK::IAccountProvider* cppRef = nullptr;
 
        AccountProvider(ZDK::Shared::AccountProvider src);
        ~AccountProvider();
        !AccountProvider();
 
        property List<Account^>^ ListAccounts
        {
            List<Account^>^ get();
        }
 
        property int AccountsCount
        {
            int get();
        }
 
        property ZDK_NET::Account^ DefaultAccount
        {
            ZDK_NET::Account^ get();
        }
 
        ZDK_NET::Account^ CreateUserAccount();
 
        void DeleteUserAccount(ZDK_NET::Account^ account);
 
        ZDK_NET::Account^ GetAccount(long long hAccountId);
 
        bool SetAsDefaultAccount(ZDK_NET::Account^ account);
 
        void UnregisterAllAccounts();
 
        ZDK_NET::AccountConfig^ CreateAccountConfiguration();
 
        ZDK_NET::MSRPConfig^ CreateMSRPConfiguration();
 
        ZDK_NET::StunConfig^ CreateStunConfiguration();
 
        ZDK_NET::IAXConfig^ CreateIAXConfiguration();
 
        ZDK_NET::SIPConfig^ CreateSIPConfiguration();
 
        ZDK_NET::ZRTPConfig^ CreateZRTPConfiguration();
 
        ZDK_NET::PushConfig^ CreatePushConfiguration();
 
        ZDK_NET::HeaderField^ CreateSIPHeaderField(System::String^ name, List<System::String^>^ values, ZDK_NET::SipMethodTypes method);
 
        void AddAccountProviderListener(ZDK_NET::AccountProviderEventsHandler^ value);
 
        void DropAccountProviderListener(ZDK_NET::AccountProviderEventsHandler^ value);
 
        virtual long long Handle() override;
 
        virtual void Initialize() override;
 
        virtual void ReleaseReference() override;
 
    };
}
 
#endif