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_define_include.h"
#include "nim_cpp_wrapper/helper/nim_sdk_loader_helper.h"
#include "nim_cpp_wrapper/nim_sdk_cpp_wrapper.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_;                  
    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_;
        }
    }
};
 
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_;    
    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_;
        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_; 
    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();
        return param;
    }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SignalingCallResParam : SignalingJoinResParam {};
 
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_; 
    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();
        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_