nim_qchat_client_cpp_def.h

Go to the documentation of this file.

 
#ifndef __NIM_QCHAT_CLIENT_CPP_DEF_H__
#define __NIM_QCHAT_CLIENT_CPP_DEF_H__
 
#include "nim_qchat_client_def.h"
#include "nim_qchat_cpp_wrapper/helper/nim_qchat_public_cpp_def.h"
#include "nim_qchat_helper.h"
 
namespace nim_qchat {
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatCustomTokenResp {
    std::string appkey;
    std::string accid;
    std::string token;
    QChatCustomTokenResp() = default;
    QChatCustomTokenResp(const NIMQChatCustomTokenResp& c_resp) {
        appkey = c_resp.appkey;
        accid = c_resp.accid;
        token = "";
    }
    NIMQChatCustomTokenResp ToCParam() const {
        NIMQChatCustomTokenResp c_resp;
        c_resp.appkey = const_cast<char*>(appkey.c_str());
        c_resp.accid = const_cast<char*>(accid.c_str());
        c_resp.token = const_cast<char*>(token.c_str());
        return c_resp;
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatLoginClientInfo {
    NIMQChatClientType client_type{kQChatClientTypeUnknown};
    std::string device_id{""};
    std::string client_ip{""};
    uint16_t client_port{0};
    std::string consid{""};
    uint64_t timestamp{0};
    uint32_t custom_client_type{0};
    std::string custom_tag{""};
    std::string os_name{""};
    QChatLoginClientInfo() = default;
    QChatLoginClientInfo(const NIMQChatLoginClientInfo& c_param) {
        client_type = c_param.client_type;
        device_id = c_param.device_id;
        client_ip = c_param.client_ip ? c_param.client_ip : "";
        client_port = c_param.client_port;
        consid = c_param.consid_ ? c_param.consid_ : "";
        timestamp = c_param.timestamp;
        custom_client_type = c_param.custom_client_type_;
        custom_tag = c_param.custom_tag_ ? c_param.custom_tag_ : "";
        os_name = c_param.os_name_ ? c_param.os_name_ : "";
    }
    const NIMQChatLoginClientInfo ToCParam() const {
        NIMQChatLoginClientInfo c_param = {};
        c_param.client_type = client_type;
        c_param.device_id = const_cast<char*>(device_id.c_str());
        c_param.client_ip = const_cast<char*>(client_ip.c_str());
        c_param.client_port = client_port;
        c_param.consid_ = const_cast<char*>(consid.c_str());
        c_param.timestamp = timestamp;
        c_param.custom_client_type_ = custom_client_type;
        c_param.custom_tag_ = const_cast<char*>(custom_tag.c_str());
        c_param.os_name_ = const_cast<char*>(os_name.c_str());
        return c_param;
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatKickedResp {
    uint32_t client_type{0};
    uint32_t kick_reason{0};
    std::string ext{""};
    uint32_t custom_client_type{0};
    QChatKickedResp() = default;
    QChatKickedResp(const NIMQChatKickedResp& c_resp) {
        client_type = c_resp.client_type;
        kick_reason = c_resp.kick_reason;
        ext = c_resp.ext ? c_resp.ext : "";
        custom_client_type = c_resp.custom_client_type;
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatLoginStatusResp {
    NIMQChatLoginStatus login_status{kLoginStatusUnlogin};
    QChatLoginStatusResp() = default;
    QChatLoginStatusResp(const NIMQChatLoginStatusResp& c_resp) { login_status = c_resp.login_status; }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatMultispotLoginResp {
    uint32_t res_code{0};
    uint32_t notify_type{0};
    QChatLoginClientInfo client_info{};
    QChatMultispotLoginResp() = default;
    QChatMultispotLoginResp(const NIMQChatMultispotLoginResp& c_resp) {
        notify_type = c_resp.notify_type;
        client_info = c_resp.client_info;
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatLoginResp {
    uint32_t res_code{0};
    QChatLoginClientInfo client_info{};
    std::list<QChatLoginClientInfo> other_clients{};
    QChatLoginResp() = default;
    QChatLoginResp(const NIMQChatLoginResp& c_resp) {
        res_code = c_resp.res_code;
        if (c_resp.res_code != kNIMResSuccess)
            return;
        client_info = c_resp.client_info;
        for (size_t i = 0; i < c_resp.other_clients_count; i++) {
            other_clients.emplace_back(c_resp.other_clients[i]);
        }
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatLogoutResp {
    uint32_t res_code{0};
    QChatLogoutResp() = default;
    QChatLogoutResp(const NIMQChatLogoutResp& c_resp) { res_code = c_resp.res_code; }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatKickResp {
    uint32_t res_code{0};
    std::list<std::string> kicked_device_ids{};
    QChatKickResp() = default;
    QChatKickResp(const NIMQChatKickResp& c_resp) {
        res_code = c_resp.res_code;
        if (c_resp.res_code != kNIMResSuccess)
            return;
        for (size_t i = 0; i < c_resp.kicked_device_ids_count; i++)
            kicked_device_ids.push_back(c_resp.kicked_device_ids[i]);
    }
    NIMQChatKickResp ToCParam() const {
        NIMQChatKickResp c_param = {};
        c_param.res_code = res_code;
        vec_kicked_device_ids.clear();
        for (auto&& device_id : kicked_device_ids)
            vec_kicked_device_ids.push_back(const_cast<char*>(device_id.c_str()));
        c_param.kicked_device_ids_count = vec_kicked_device_ids.size();
        c_param.kicked_device_ids = vec_kicked_device_ids.data();
        return c_param;
    }
 
protected:
    // 以下字段为内部使用
    mutable std::vector<char*> vec_kicked_device_ids;
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSDKLogResp {
    std::string log_content{""};
    QChatSDKLogResp() = default;
    QChatSDKLogResp(const NIMQChatSDKLogResp& c_resp) { log_content = c_resp.log_content ? c_resp.log_content : ""; }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatGetRTCTokenResp {
    uint32_t res_code;
    std::string token;
    uint32_t ttl{0};
    QChatGetRTCTokenResp() = default;
    QChatGetRTCTokenResp(const NIMQChatGetRTCTokenResp& c_resp) {
        res_code = c_resp.res_code;
        token = c_resp.token ? c_resp.token : "";
        ttl = c_resp.ttl;
    }
    const NIMQChatGetRTCTokenResp ToCParam() const {
        NIMQChatGetRTCTokenResp c_response{};
        c_response.res_code = res_code;
        c_response.token = const_cast<char*>(token.c_str());
        c_response.ttl = ttl;
        return c_response;
    }
};
 
typedef std::function<QChatCustomTokenResp(const QChatCustomTokenResp&)> CustomTokenCallback;
typedef std::function<void(const QChatKickedResp&)> KickedCallback;
typedef std::function<void(const QChatLoginStatusResp&)> LoginStatusCallback;
typedef std::function<void(const QChatMultispotLoginResp&)> MultispotLoginCallback;
typedef std::function<void(const QChatSDKLogResp&)> SDKLogCallback;
typedef std::function<void(const QChatLoginResp&)> LoginCallback;
typedef std::function<void(const QChatLogoutResp&)> LogoutCallback;
typedef std::function<void(const QChatKickResp&)> KickCallback;
using GetRTCTokenCallback = std::function<void(const QChatGetRTCTokenResp&)>;
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatRegCustomTokenCbParam {
    CustomTokenCallback cb{nullptr};
    const NIMQChatRegCustomTokenCbParam ToCParam() const {
        static CustomTokenCallback cb_holder = nullptr;
        static QChatCustomTokenResp resp_holder{};
        cb_holder = cb;
        NIMQChatRegCustomTokenCbParam param = {};
        param.cb = [](const NIMQChatCustomTokenResp& resp) {
            if (cb_holder)
                resp_holder = cb_holder(resp);
            return resp_holder.ToCParam();
        };
        return param;
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatEncryptionConfiguration {
    NIMQChatExchangeKeyEncryptionAlgorithm nego_key_neca = kNIMQChatEncryptionAlgorithmRSA;
    NIMQChatCommEncryptionAlgorithm comm_neca = kNIMQChatCommEncryptionAlgorithmRC4;
    NIMQChatHandShakeType hand_shake_type = kNIMQChatHandShakeTypeMulti;
    std::string nego_key_neca_key_parta;
    std::string nego_key_neca_key_partb;
    uint32_t nego_key_neca_key_version = 0;
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatFCSConfiguration {
    uint32_t thumbnail_width = 150;
    uint32_t thumbnail_height = 100;
    bool auto_download_history_msg_attach_ = false;
    bool auto_download_image_thumb = true;
    bool auto_download_video_thumb = true;
    bool auto_download_image = false;
    bool auto_download_audio = false;
    bool auto_download_video = false;
    bool auto_download_file = false;
    NIMQChatFCSAuthenticationType fcs_auth_type = kNIMQChatFCSAuthenticationTypeToken;
    std::string mock_ua;
    std::string mock_refer;
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatMessageCacheConfiguration {
    bool enable_message_cache = false;
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatInitParam {
    std::string app_data_path{""};
    uint32_t custom_timeout{0};
    uint32_t auth_timeout{0};
    std::string database_encrypt_key;
    QChatEncryptionConfiguration encryption_configuration;
    QChatFCSConfiguration fcs_configuration;
    QChatMessageCacheConfiguration message_cache_configuration;
    const NIMQChatInitParam ToCParam() const {
        NIMQChatInitParam param = {};
        param.app_data_path = const_cast<char*>(app_data_path.c_str());
        param.custom_timeout = custom_timeout;
        param.auth_timeout = auth_timeout;
        param.database_encrypt_key = const_cast<char*>(database_encrypt_key.c_str());
        param.encrypt_configuration.nego_key_neca = encryption_configuration.nego_key_neca;
        param.encrypt_configuration.comm_neca = encryption_configuration.comm_neca;
        param.encrypt_configuration.hand_shake_type = encryption_configuration.hand_shake_type;
        param.encrypt_configuration.nego_key_neca_key_parta = const_cast<char*>(encryption_configuration.nego_key_neca_key_parta.c_str());
        param.encrypt_configuration.nego_key_neca_key_partb = const_cast<char*>(encryption_configuration.nego_key_neca_key_partb.c_str());
        param.encrypt_configuration.nego_key_neca_key_version = encryption_configuration.nego_key_neca_key_version;
        param.fcs_configuration.thumbnail_width = fcs_configuration.thumbnail_width;
        param.fcs_configuration.thumbnail_height = fcs_configuration.thumbnail_height;
        param.fcs_configuration.auto_download_history_msg_attach_ = fcs_configuration.auto_download_history_msg_attach_;
        param.fcs_configuration.auto_download_image_thumb = fcs_configuration.auto_download_image_thumb;
        param.fcs_configuration.auto_download_video_thumb = fcs_configuration.auto_download_video_thumb;
        param.fcs_configuration.auto_download_image = fcs_configuration.auto_download_image;
        param.fcs_configuration.auto_download_audio = fcs_configuration.auto_download_audio;
        param.fcs_configuration.auto_download_video = fcs_configuration.auto_download_video;
        param.fcs_configuration.auto_download_file = fcs_configuration.auto_download_file;
        param.fcs_configuration.fcs_auth_type = fcs_configuration.fcs_auth_type;
        param.fcs_configuration.mock_ua = const_cast<char*>(fcs_configuration.mock_ua.c_str());
        param.fcs_configuration.mock_refer = const_cast<char*>(fcs_configuration.mock_refer.c_str());
        param.message_cache_configuration.enable_message_cache = message_cache_configuration.enable_message_cache;
        return param;
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatRegKickedCbParam {
    KickedCallback cb{nullptr};
    const NIMQChatRegKickedCbParam ToCParam() const {
        static KickedCallback cb_holder = nullptr;
        cb_holder = cb;
        NIMQChatRegKickedCbParam param = {};
        param.cb = [](const NIMQChatKickedResp& resp) {
            if (cb_holder)
                cb_holder(resp);
        };
        return param;
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatRegLoginStatusCbParam {
    LoginStatusCallback cb{nullptr};
    const NIMQChatRegLoginStatusCbParam ToCParam() const {
        static LoginStatusCallback cb_holder = nullptr;
        cb_holder = cb;
        NIMQChatRegLoginStatusCbParam param = {};
        param.cb = [](const NIMQChatLoginStatusResp& resp) {
            if (cb_holder)
                cb_holder(resp);
        };
        return param;
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatRegMultispotLoginCbParam {
    MultispotLoginCallback cb{nullptr};
    const NIMQChatRegMultispotLoginCbParam ToCParam() const {
        static MultispotLoginCallback cb_holder = nullptr;
        cb_holder = cb;
        NIMQChatRegMultispotLoginCbParam param = {};
        param.cb = [](const NIMQChatMultispotLoginResp& resp) {
            if (cb_holder)
                cb_holder(resp);
        };
        return param;
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatCleanupParam {
    const NIMQChatCleanupParam ToCParam() const {
        NIMQChatCleanupParam param = {};
        return param;
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatLoginParam {
    LoginCallback cb{nullptr};
    std::string appkey{""};
    std::string accid{""};
    NIMQChatLoginAuthType auth_type{kNIMQChatLoginAuthTypeDefault};
    std::string login_token{""};
    std::string login_ext{""};
    std::list<std::string> link_address{};
    const NIMQChatLoginParam ToCParam() const {
        static LoginCallback cb_holder = nullptr;
        cb_holder = cb;
        link_address_json_array.clear();
        nim::StrListToJsonString(link_address, link_address_json_array);
        NIMQChatLoginParam param = {};
        param.cb = [](const NIMQChatLoginResp& resp) {
            if (cb_holder)
                cb_holder(resp);
        };
        param.appkey = const_cast<char*>(appkey.c_str());
        param.accid = const_cast<char*>(accid.c_str());
        param.auth_type = auth_type;
        param.login_token = const_cast<char*>(login_token.c_str());
        param.login_ext = const_cast<char*>(login_ext.c_str());
        param.link_address = const_cast<char*>(link_address_json_array.c_str());
        return param;
    }
 
protected:
    // 以下字段为内部使用
    mutable std::string link_address_json_array;
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatLogoutParam {
    LogoutCallback cb{nullptr};
    const NIMQChatLogoutParam ToCParam() const {
        static LogoutCallback cb_holder = nullptr;
        cb_holder = cb;
        NIMQChatLogoutParam param = {};
        param.cb = [](const NIMQChatLogoutResp& resp) {
            if (cb_holder)
                cb_holder(resp);
        };
        return param;
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatKickParam {
    KickCallback cb{nullptr};
    std::list<std::string> device_ids{};
    QChatKickParam() = default;
    QChatKickParam(const NIMQChatKickParam& c_param) {
        for (size_t i = 0; i < c_param.device_ids_count; i++)
            device_ids.push_back(c_param.device_ids[i]);
        cb = [c_callback = c_param.cb, user_data = c_param.user_data](const QChatKickResp& response) {
            auto c_response = response.ToCParam();
            c_response.user_data = user_data;
            c_callback(c_response);
        };
    }
    const NIMQChatKickParam ToCParam() const {
        auto cb_holder = new KickCallback(cb);
        NIMQChatKickParam param = {};
        vec_device_ids.clear();
        for (auto&& accid : device_ids)
            vec_device_ids.push_back(const_cast<char*>(accid.c_str()));
        param.device_ids_count = vec_device_ids.size();
        param.device_ids = vec_device_ids.data();
        param.user_data = cb_holder;
        param.cb = [](const NIMQChatKickResp& resp) {
            InvokeCallback<KickCallback, NIMQChatKickResp>(resp);
        };
        return param;
    }
 
protected:
    // 以下字段为内部使用
    mutable std::vector<char*> vec_device_ids;
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatGetRTCTokenParam {
    GetRTCTokenCallback cb{nullptr};
    std::string device_id{""};
    QChatGetRTCTokenParam() = default;
    QChatGetRTCTokenParam(const NIMQChatGetRTCTokenParam& c_param) {
        cb = [c_callback = c_param.cb, user_data = c_param.user_data](const QChatGetRTCTokenResp& response) {
            auto c_response = response.ToCParam();
            c_response.user_data = user_data;
            c_callback(c_response);
        };
        device_id = c_param.device_id ? c_param.device_id : "";
    }
    const NIMQChatGetRTCTokenParam ToCParam() const {
        auto cb_holder = new GetRTCTokenCallback(cb);
        NIMQChatGetRTCTokenParam param = {};
        param.user_data = cb_holder;
        param.cb = [](const NIMQChatGetRTCTokenResp& resp) {
            InvokeCallback<GetRTCTokenCallback, NIMQChatGetRTCTokenResp>(resp);
        };
        param.device_id = const_cast<char*>(device_id.c_str());
        return param;
    }
};
 
}  // namespace nim_qchat
 
#endif  // __NIM_QCHAT_CLIENT_CPP_DEF_H__