v2_nim_api.hpp

浏览该文件的文档.

#ifndef V2_NIM_API_H
#define V2_NIM_API_H
#include "v2_nim_ai_service.hpp"
#include "v2_nim_chatroom_queue_service.hpp"
#include "v2_nim_chatroom_service.hpp"
#include "v2_nim_conversation_group_service.hpp"
#include "v2_nim_conversation_service.hpp"
#include "v2_nim_friend_service.hpp"
#include "v2_nim_local_conversation_service.hpp"
#include "v2_nim_login_service.hpp"
#include "v2_nim_message_service.hpp"
#include "v2_nim_notification_service.hpp"
#include "v2_nim_passthrough_service.hpp"
#include "v2_nim_setting_service.hpp"
#include "v2_nim_signalling_service.hpp"
#include "v2_nim_statistics_service.hpp"
#include "v2_nim_storage_service.hpp"
#include "v2_nim_subscription_service.hpp"
#include "v2_nim_team_service.hpp"
#include "v2_nim_user_service.hpp"
#if defined(WIN32) || defined(_WIN32)
#include "wtypes.h"
#else
#include <dlfcn.h>
#endif
#ifdef ENABLE_NIM_V1
#include "nim_wrapper_util/nim_sdk_util.h"
namespace nim {
extern nim::SDKInstance* nim_sdk_instance;
}  // namespace nim
#endif
namespace v2 {
class V2NIMClient {
public:
    static V2NIMClient& get();
 
    nstd::optional<V2NIMError> init(const V2NIMInitOption& option) {
        auto error = initImpl(option);
#ifdef ENABLE_NIM_V1
        if (!error && !nim::nim_sdk_instance) {
            nim::nim_sdk_instance = new nim::SDKInstance();
            if (!nim::nim_sdk_instance->LoadSdkDll("", internal::NIM_SDK_NAME)) {
                delete nim::nim_sdk_instance;
                nim::nim_sdk_instance = nullptr;
                throw std::runtime_error("[V2NIMClient] load v1 sdk failed");
            }
        }
#endif
        return error;
    }
 
    virtual nstd::optional<V2NIMError> initImpl(const V2NIMInitOption& option) = 0;
 
    nstd::optional<V2NIMError> uninit() {
        auto error = uninitImpl();
#ifdef ENABLE_NIM_V1
        if (!error && nim::nim_sdk_instance) {
            nim::nim_sdk_instance->UnLoadSdkDll();
            delete nim::nim_sdk_instance;
            nim::nim_sdk_instance = nullptr;
        }
#endif
        return error;
    }
 
    virtual nstd::optional<V2NIMError> uninitImpl() = 0;
 
    virtual nstd::optional<V2NIMError> updateAppKey(const nstd::string& appKey) = 0;
 
    virtual V2NIMLoginService& getLoginService() const = 0;
 
    virtual V2NIMConversationService& getConversationService() const = 0;
 
    virtual V2NIMLocalConversationService& getLocalConversationService() const = 0;
 
    virtual V2NIMConversationGroupService& getConversationGroupService() const = 0;
 
    virtual V2NIMMessageService& getMessageService() const = 0;
 
    virtual V2NIMNotificationService& getNotificationService() const = 0;
 
    virtual V2NIMStorageService& getStorageService() const = 0;
 
    virtual V2NIMTeamService& getTeamService() const = 0;
 
    virtual V2NIMSettingService& getSettingService() const = 0;
 
    virtual V2NIMUserService& getUserService() const = 0;
 
    virtual V2NIMFriendService& getFriendService() const = 0;
 
    virtual V2NIMAIService& getAIService() const = 0;
 
    virtual V2NIMSignallingService& getSignallingService() const = 0;
 
    virtual V2NIMSubscriptionService& getSubscriptionService() const = 0;
 
    virtual V2NIMPassthroughService& getPassthroughService() const = 0;
 
    virtual V2NIMStatisticsService& getStatisticsService() const = 0;
};
 
class V2NIMChatroomClient {
public:
    virtual ~V2NIMChatroomClient() = default;
    static nstd::optional<V2NIMError> init(const V2NIMInitOption& option);
 
    static void uninit();
 
    static nstd::shared_ptr<V2NIMChatroomClient> newInstance();
 
    static void destroyInstance(uint32_t instanceId);
 
    static nstd::shared_ptr<V2NIMChatroomClient> getInstance(uint32_t instanceId);
 
    static nstd::vector<nstd::shared_ptr<V2NIMChatroomClient>> getInstanceList();
 
    static void destroyAll();
 
    virtual uint32_t getInstanceId() = 0;
 
    virtual nstd::optional<V2NIMError> updateAppKey(const nstd::string& appKey) = 0;
 
    virtual void enter(nstd::string roomId,
        V2NIMChatroomEnterParams enterParams,
        V2NIMSuccessCallback<V2NIMChatroomEnterResult> success,
        V2NIMFailureCallback failure) = 0;
 
    virtual void exit() = 0;
 
    virtual V2NIMChatroomInfo getChatroomInfo() = 0;
 
    virtual V2NIMChatroomService& getChatroomService() = 0;
 
    virtual V2NIMStorageService& getStorageService() = 0;
 
    virtual V2NIMChatroomQueueService& getChatroomQueueService() = 0;
 
    virtual void addChatroomClientListener(V2NIMChatroomClientListener listener) = 0;
 
    virtual void removeChatroomClientListener(V2NIMChatroomClientListener listener) = 0;
};
 
namespace internal {
class V2NIMChatroomSdkExport {
public:
    virtual nstd::optional<V2NIMError> init(const V2NIMInitOption& option) = 0;
    virtual void uninit() = 0;
    virtual nstd::shared_ptr<V2NIMChatroomClient> newInstance() = 0;
    virtual void destroyInstance(uint32_t instanceId) = 0;
    virtual nstd::shared_ptr<V2NIMChatroomClient> getInstance(uint32_t instanceId) = 0;
    virtual nstd::vector<nstd::shared_ptr<V2NIMChatroomClient>> getInstanceList() = 0;
    virtual void destroyAll() = 0;
};
inline V2NIMChatroomSdkExport* internalChatroomSdkExport{nullptr};
}  // namespace internal
 
inline V2NIMClient& V2NIMClient::get() {
    static const char* sdkFunctionV2InstanceGet = "v2_nim_instance_impl_get";
    static V2NIMClient* nimInstance{nullptr};
    if (nimInstance == nullptr) {
        void** instances = internal::callSdkFunction<void**>(internal::NIM_SDK_NAME, sdkFunctionV2InstanceGet);
        if (instances) {
            nimInstance = reinterpret_cast<V2NIMClient*>(instances[internal::V2_NIM_INTERNEL_INSTANCE]);
            internal::internalClientAntispamUtil =
                reinterpret_cast<internal::V2NIMClientAntispamUtilInternal*>(instances[internal::V2_NIM_INTERNEL_CLIENT_ANTI_SPAM_UTIL]);
            internal::internalConversationIdUtil =
                reinterpret_cast<internal::V2NIMConversationIdUtilInternal*>(instances[internal::V2_NIM_INTERNEL_CONVERSATION_ID_UTIL]);
            internal::internalMessageUtil = reinterpret_cast<internal::V2NIMMessageUtilInternal*>(instances[internal::V2_NIM_INTERNEL_MESSAGE_UTIL]);
        }
    }
    if (!nimInstance) {
        throw std::runtime_error("[V2NIMClient] get instance failed");
    }
    return *nimInstance;
}
 
inline nstd::optional<V2NIMError> V2NIMChatroomClient::init(const V2NIMInitOption& option) {
    static const char* sdkFunctionV2InstanceGet = "v2_nim_chatroom_instance_impl_get";
    if (internal::internalChatroomSdkExport == nullptr) {
        void** instances = internal::callSdkFunction<void**>(internal::NIM_CHATROOM_SDK_NAME, sdkFunctionV2InstanceGet);
        if (instances) {
            internal::internalChatroomSdkExport =
                reinterpret_cast<internal::V2NIMChatroomSdkExport*>(instances[internal::V2_NIM_CHATROOM_SDK_EXPORT]);
            internal::internalChatroomMessageUtil =
                reinterpret_cast<internal::V2NIMChatroomMessageUtilInternal*>(instances[internal::V2_NIM_CHATROOM_MESSAGE_UTIL]);
        }
    }
    if (!internal::internalChatroomSdkExport) {
        throw std::runtime_error("[V2NIMChatroomClient] init, internalChatroomSdkExport is null");
    }
    return internal::internalChatroomSdkExport->init(option);
}
 
inline void V2NIMChatroomClient::uninit() {
    if (!internal::internalChatroomSdkExport) {
        throw std::runtime_error("[V2NIMChatroomClient] uninit, internalChatroomSdkExport is null");
    }
    internal::internalChatroomSdkExport->uninit();
}
 
inline nstd::shared_ptr<V2NIMChatroomClient> V2NIMChatroomClient::newInstance() {
    if (!internal::internalChatroomSdkExport) {
        throw std::runtime_error("[V2NIMChatroomClient] newInstance, internalChatroomSdkExport is null");
    }
    return internal::internalChatroomSdkExport->newInstance();
}
 
inline void V2NIMChatroomClient::destroyInstance(uint32_t instanceId) {
    if (!internal::internalChatroomSdkExport) {
        throw std::runtime_error("[V2NIMChatroomClient] destroyInstance, internalChatroomSdkExport is null");
    }
    internal::internalChatroomSdkExport->destroyInstance(instanceId);
}
 
inline nstd::shared_ptr<V2NIMChatroomClient> V2NIMChatroomClient::getInstance(uint32_t instanceId) {
    if (!internal::internalChatroomSdkExport) {
        throw std::runtime_error("[V2NIMChatroomClient] getInstance, internalChatroomSdkExport is null");
    }
    return internal::internalChatroomSdkExport->getInstance(instanceId);
}
 
inline nstd::vector<nstd::shared_ptr<V2NIMChatroomClient>> V2NIMChatroomClient::getInstanceList() {
    if (!internal::internalChatroomSdkExport) {
        throw std::runtime_error("[V2NIMChatroomClient] getInstanceList, internalChatroomSdkExport is null");
    }
    return internal::internalChatroomSdkExport->getInstanceList();
}
 
inline void V2NIMChatroomClient::destroyAll() {
    if (!internal::internalChatroomSdkExport) {
        throw std::runtime_error("[V2NIMChatroomClient] destroyAll, internalChatroomSdkExport is null");
    }
    internal::internalChatroomSdkExport->destroyAll();
}
}  // namespace v2
#endif