nim_signaling_helper.h

Go to the documentation of this file.

 
#ifndef _NIM_SDK_CPP_SIGNALING_HELPER_H_
#define _NIM_SDK_CPP_SIGNALING_HELPER_H_
 
#include <functional>
#include <list>
#include <memory>
#include <string>
#include "nim_cpp_wrapper/helper/nim_sdk_loader_helper.h"
#include "nim_cpp_wrapper/nim_sdk_cpp_wrapper.h"
#include "nim_define_include.h"
 
namespace nim {
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingChannelInfo {
    NIMSignalingType channel_type_;
    std::string channel_name_;
    std::string channel_id_;
    std::string channel_ext_;
    uint64_t create_timestamp_;
    uint64_t expire_timestamp_;
    std::string creator_id_;
    bool invalid_;
    uint64_t nertc_token_ttl_{600};
    std::string nertc_token_;
    std::string nertc_join_room_resp_;
    SignalingChannelInfo() {
        channel_type_ = kNIMSignalingTypeAudio;
        create_timestamp_ = 0;
        expire_timestamp_ = 0;
        invalid_ = true;
    }
    SignalingChannelInfo(const NIMSignalingChannelInfo* info) {
        if (info) {
            channel_type_ = info->channel_type_;
            channel_name_ = info->channel_name_;
            channel_id_ = info->channel_id_;
            channel_ext_ = info->channel_ext_;
            create_timestamp_ = info->create_timestamp_;
            expire_timestamp_ = info->expire_timestamp_;
            creator_id_ = info->creator_id_;
            invalid_ = info->invalid_;
            nertc_token_ttl_ = info->nertc_token_ttl_;
            nertc_token_ = info->nertc_token_;
            nertc_join_room_resp_ = info->nertc_join_room_resp_;
        }
    }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingMemberInfo {
    std::string account_id_;
    int64_t uid_;
    uint64_t create_timestamp_;
    uint64_t expire_timestamp_;
    SignalingMemberInfo() {
        uid_ = 0;
        create_timestamp_ = 0;
        expire_timestamp_ = 0;
    }
    SignalingMemberInfo(NIMSignalingMemberInfo* info) {
        SignalingMemberInfo();
        if (info) {
            account_id_ = info->account_id_;
            uid_ = info->uid_;
            create_timestamp_ = info->create_timestamp_;
            expire_timestamp_ = info->expire_timestamp_;
        }
    }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingChannelDetailedinfo {
    SignalingChannelInfo channel_info_;
    std::list<SignalingMemberInfo> members_;
    SignalingChannelDetailedinfo() {}
    SignalingChannelDetailedinfo(const NIMSignalingChannelDetailedinfo* info) {
        if (info) {
            channel_info_ = SignalingChannelInfo(&info->channel_info_);
            for (int32_t i = 0; i < info->member_size_; ++i) {
                SignalingMemberInfo member(&info->members_[i]);
                members_.push_back(member);
            }
        }
    }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingPushInfo {
    bool need_push_;
    std::string push_title_;
    std::string push_content_;
    std::string push_payload_;
    bool need_badge_;
    SignalingPushInfo() {
        need_push_ = false;
        need_badge_ = true;
    }
    SignalingPushInfo(NIMSignalingPushInfo* info) {
        SignalingPushInfo();
        if (info) {
            need_push_ = info->need_push_;
            if (need_push_) {
                push_title_ = info->push_title_;
                push_content_ = info->push_content_;
                push_payload_ = info->push_payload_;
                need_badge_ = info->need_badge_;
            }
        }
    }
    NIMSignalingPushInfo GetCParam() {
        NIMSignalingPushInfo info;
        info.need_push_ = need_push_;
        info.push_title_ = (char*)push_title_.c_str();
        info.push_content_ = (char*)push_content_.c_str();
        info.push_payload_ = (char*)push_payload_.c_str();
        info.need_badge_ = need_badge_;
        return info;
    }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingNotifyInfo {
    enum NIMSignalingEventType event_type_;
    struct SignalingChannelInfo channel_info_;
    std::string from_account_id_;
    std::string custom_info_;
    uint64_t timestamp_;
    static std::shared_ptr<SignalingNotifyInfo> GetSharedPtr(const NIMSignalingNotifyInfo* c_info);
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingNotifyInfoClose : SignalingNotifyInfo {};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingNotifyInfoJoin : SignalingNotifyInfo {
    SignalingMemberInfo member_;
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingNotifyInfoInvite : SignalingNotifyInfo {
    std::string to_account_id_;
    std::string request_id_;
    SignalingPushInfo push_info_;
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingNotifyInfoCancelInvite : SignalingNotifyInfo {
    std::string to_account_id_;
    std::string request_id_;
};
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingNotifyInfoReject : SignalingNotifyInfo {
    std::string to_account_id_;
    std::string request_id_;
};
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingNotifyInfoAccept : SignalingNotifyInfo {
    std::string to_account_id_;
    std::string request_id_;
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingNotifyInfoLeave : SignalingNotifyInfo {};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingNotifyInfoControl : SignalingNotifyInfo {};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingResParam {
    static std::shared_ptr<SignalingResParam> GetOptParam(void* opt_res_param) { return nullptr; }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingCreateParam {
    NIMSignalingType channel_type_;
    std::string channel_name_;
    std::string channel_ext_;
    NIMSignalingCreateParam GetCParam() {
        NIMSignalingCreateParam param;
        param.channel_type_ = channel_type_;
        param.channel_name_ = (char*)channel_name_.c_str();
        param.channel_ext_ = (char*)channel_ext_.c_str();
        return param;
    }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingCreateResParam : SignalingResParam {
    SignalingChannelInfo channel_info_;
    static std::shared_ptr<SignalingResParam> GetOptParam(void* opt_res_param) {
        if (opt_res_param == nullptr) {
            return nullptr;
        }
        std::shared_ptr<SignalingCreateResParam> res_param(new SignalingCreateResParam);
        res_param->channel_info_ = SignalingChannelInfo(&((NIMSignalingCreateResParam*)opt_res_param)->channel_info_);
        return res_param;
    }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingCloseParam {
    std::string channel_id_;
    std::string custom_info_;
    bool offline_enabled_;
    NIMSignalingCloseParam GetCParam() {
        NIMSignalingCloseParam param;
        param.channel_id_ = (char*)channel_id_.c_str();
        param.custom_info_ = (char*)custom_info_.c_str();
        param.offline_enabled_ = offline_enabled_;
        return param;
    }
};
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingCloseResParam : SignalingResParam {};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingJoinParam {
    std::string channel_id_;
    std::string custom_info_;
    int64_t uid_;
    bool offline_enabled_;
    std::string nertc_channel_name_;
    uint64_t nertc_token_ttl_{600};
    std::string nertc_join_room_query_param_;
    NIMSignalingJoinParam GetCParam() {
        NIMSignalingJoinParam param;
        param.channel_id_ = (char*)channel_id_.c_str();
        param.custom_info_ = (char*)custom_info_.c_str();
        param.uid_ = uid_;
        param.offline_enabled_ = offline_enabled_;
        param.nertc_channel_name_ = (char*)nertc_channel_name_.c_str();
        param.nertc_token_ttl_ = nertc_token_ttl_;
        param.nertc_join_room_query_param_ = (char*)nertc_join_room_query_param_.c_str();
        return param;
    }
};
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingJoinResParam : SignalingResParam {
    SignalingChannelDetailedinfo info_;
    static std::shared_ptr<SignalingResParam> GetOptParam(void* opt_res_param) {
        if (opt_res_param == nullptr) {
            return nullptr;
        }
        std::shared_ptr<SignalingJoinResParam> res_param(new SignalingJoinResParam);
        res_param->info_ = SignalingChannelDetailedinfo(&((NIMSignalingJoinResParam*)opt_res_param)->info_);
        return res_param;
    }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingLeaveParam {
    std::string channel_id_;
    std::string custom_info_;
    bool offline_enabled_;
    NIMSignalingLeaveParam GetCParam() {
        NIMSignalingLeaveParam param;
        param.channel_id_ = (char*)channel_id_.c_str();
        param.custom_info_ = (char*)custom_info_.c_str();
        param.offline_enabled_ = offline_enabled_;
        return param;
    }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingLeaveResParam : SignalingResParam {};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingQueryChannelInfoParam {
    std::string channel_name_;
    NIMSignalingQueryChannelInfoParam GetCParam() {
        NIMSignalingQueryChannelInfoParam param;
        param.channel_name_ = (char*)channel_name_.c_str();
        return param;
    }
};
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingQueryChannelInfoResParam : SignalingResParam {
    SignalingChannelDetailedinfo info_;
    static std::shared_ptr<SignalingResParam> GetOptParam(void* opt_res_param) {
        if (opt_res_param == nullptr) {
            return nullptr;
        }
        std::shared_ptr<SignalingQueryChannelInfoResParam> res_param(new SignalingQueryChannelInfoResParam);
        res_param->info_ = SignalingChannelDetailedinfo(&((NIMSignalingQueryChannelInfoResParam*)opt_res_param)->info_);
        return res_param;
    }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingCallParam {
    NIMSignalingType channel_type_;
    std::string channel_name_;
    std::string channel_ext_;
    int64_t uid_;
    std::string account_id_;
    std::string request_id_;
    std::string custom_info_;
    bool offline_enabled_;
    SignalingPushInfo push_info_;
    std::string nertc_channel_name_;
    uint64_t nertc_token_ttl_{600};
    std::string nertc_join_room_query_param_;
    NIMSignalingCallParam GetCParam() {
        NIMSignalingCallParam param;
        param.channel_type_ = channel_type_;
        param.channel_name_ = (char*)channel_name_.c_str();
        param.channel_ext_ = (char*)channel_ext_.c_str();
        param.uid_ = uid_;
        param.account_id_ = (char*)account_id_.c_str();
        param.request_id_ = (char*)request_id_.c_str();
        param.custom_info_ = (char*)custom_info_.c_str();
        param.offline_enabled_ = offline_enabled_;
        param.push_info_ = push_info_.GetCParam();
        param.nertc_channel_name_ = (char*)nertc_channel_name_.c_str();
        param.nertc_token_ttl_ = nertc_token_ttl_;
        param.nertc_join_room_query_param_ = (char*)nertc_join_room_query_param_.c_str();
        return param;
    }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingCallResParam : SignalingJoinResParam {};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingCallExResParam : SignalingResParam {
    SignalingChannelDetailedinfo info_;
    uint32_t call_status_;
    static std::shared_ptr<SignalingResParam> GetOptParam(void* opt_res_param) {
        if (opt_res_param == nullptr) {
            return nullptr;
        }
        std::shared_ptr<SignalingCallExResParam> res_param(new SignalingCallExResParam);
        res_param->info_ = SignalingChannelDetailedinfo(&((NIMSignalingCallResParam*)opt_res_param)->info_);
        res_param->call_status_ = ((NIMSignalingCallResParam*)opt_res_param)->call_status_;
        return res_param;
    }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingJoinAndAcceptParam {
    std::string channel_id_;
    std::string custom_info_;
    int64_t uid_;
    bool offline_enabled_;
    std::string account_id_;
    std::string request_id_;
    std::string nertc_channel_name_;
    uint64_t nertc_token_ttl_{600};
    std::string nertc_join_room_query_param_;
    NIMSignalingJoinAndAcceptParam GetCParam() {
        NIMSignalingJoinAndAcceptParam param;
        param.channel_id_ = (char*)channel_id_.c_str();
        param.custom_info_ = (char*)custom_info_.c_str();
        param.uid_ = uid_;
        param.offline_enabled_ = offline_enabled_;
        param.account_id_ = (char*)account_id_.c_str();
        param.request_id_ = (char*)request_id_.c_str();
        param.nertc_channel_name_ = (char*)nertc_channel_name_.c_str();
        param.nertc_token_ttl_ = nertc_token_ttl_;
        param.nertc_join_room_query_param_ = (char*)nertc_join_room_query_param_.c_str();
        return param;
    }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingJoinAndAcceptResParam : SignalingResParam {
    SignalingChannelDetailedinfo info_;
    uint32_t call_status_{0};
    static std::shared_ptr<SignalingResParam> GetOptParam(void* opt_res_param) {
        if (opt_res_param == nullptr) {
            return nullptr;
        }
        std::shared_ptr<SignalingJoinAndAcceptResParam> res_param(new SignalingJoinAndAcceptResParam);
        res_param->info_ = SignalingChannelDetailedinfo(&((NIMSignalingJoinAndAcceptResParam*)opt_res_param)->info_);
        res_param->call_status_ = ((NIMSignalingJoinAndAcceptResParam*)opt_res_param)->call_status_;
        return res_param;
    }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingInviteParam {
    std::string channel_id_;
    std::string account_id_;
    std::string request_id_;
    std::string custom_info_;
    bool offline_enabled_;
    struct SignalingPushInfo push_info_;
    NIMSignalingInviteParam GetCParam() {
        NIMSignalingInviteParam param;
        param.channel_id_ = (char*)channel_id_.c_str();
        param.account_id_ = (char*)account_id_.c_str();
        param.request_id_ = (char*)request_id_.c_str();
        param.custom_info_ = (char*)custom_info_.c_str();
        param.offline_enabled_ = offline_enabled_;
        param.push_info_ = push_info_.GetCParam();
        return param;
    }
};
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingInviteResParam : SignalingResParam {};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingCancelInviteParam {
    std::string channel_id_;
    std::string account_id_;
    std::string request_id_;
    std::string custom_info_;
    bool offline_enabled_;
    NIMSignalingCancelInviteParam GetCParam() {
        NIMSignalingCancelInviteParam param;
        param.channel_id_ = (char*)channel_id_.c_str();
        param.account_id_ = (char*)account_id_.c_str();
        param.request_id_ = (char*)request_id_.c_str();
        param.custom_info_ = (char*)custom_info_.c_str();
        param.offline_enabled_ = offline_enabled_;
        return param;
    }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingCancelInviteResParam : SignalingResParam {};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingRejectParam {
    std::string channel_id_;
    std::string account_id_;
    std::string request_id_;
    std::string custom_info_;
    bool offline_enabled_;
    NIMSignalingRejectParam GetCParam() {
        NIMSignalingRejectParam param;
        param.channel_id_ = (char*)channel_id_.c_str();
        param.account_id_ = (char*)account_id_.c_str();
        param.request_id_ = (char*)request_id_.c_str();
        param.custom_info_ = (char*)custom_info_.c_str();
        param.offline_enabled_ = offline_enabled_;
        return param;
    }
};
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingRejectResParam : SignalingResParam {};
struct SignalingAcceptParam {
    std::string channel_id_;
    std::string account_id_;
    std::string request_id_;
    std::string accept_custom_info_;
    bool offline_enabled_;
    bool auto_join_;
    int64_t uid_;
    std::string join_custom_info_;
    std::string nertc_channel_name_;
    uint64_t nertc_token_ttl_{600};
    std::string nertc_join_room_query_param_;
    NIMSignalingAcceptParam GetCParam() {
        NIMSignalingAcceptParam param;
        param.channel_id_ = (char*)channel_id_.c_str();
        param.account_id_ = (char*)account_id_.c_str();
        param.request_id_ = (char*)request_id_.c_str();
        param.accept_custom_info_ = (char*)accept_custom_info_.c_str();
        param.offline_enabled_ = offline_enabled_;
        param.auto_join_ = auto_join_;
        param.uid_ = uid_;
        param.join_custom_info_ = (char*)join_custom_info_.c_str();
        param.nertc_channel_name_ = (char*)nertc_channel_name_.c_str();
        param.nertc_token_ttl_ = nertc_token_ttl_;
        param.nertc_join_room_query_param_ = (char*)nertc_join_room_query_param_.c_str();
        return param;
    }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingAcceptResParam : SignalingJoinResParam {};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingControlParam {
    std::string channel_id_;
    std::string account_id_;
    std::string custom_info_;
    NIMSignalingControlParam GetCParam() {
        NIMSignalingControlParam param;
        param.channel_id_ = (char*)channel_id_.c_str();
        param.account_id_ = (char*)account_id_.c_str();
        param.custom_info_ = (char*)custom_info_.c_str();
        return param;
    }
};
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingControlResParam : SignalingResParam {};
 
}  // namespace nim
 
#endif  //_NIM_SDK_CPP_SIGNALING_HELPER_H_