nim_chatroom_helper.h

Go to the documentation of this file.

 
#ifndef WRAPPER_NIM_CHATROOM_CPP_WRAPPER_HELPER_NIM_CHATROOM_HELPER_H_
#define WRAPPER_NIM_CHATROOM_CPP_WRAPPER_HELPER_NIM_CHATROOM_HELPER_H_
 
#include <algorithm>
#include <functional>
#include <list>
#include <map>
#include <string>
#include <utility>
#include <vector>
#if !defined(_WIN32) && !defined(WIN32)
#include <pthread.h>
#endif
#include "nim_chatroom_cpp_wrapper/nim_chatroom_sdk_cpp_wrapper.h"
#include "nim_chatroom_def_include.h"
#include "nim_wrapper_util/nim_json_util.h"
 
namespace nim_chatroom {
 
struct NIM_CHATROOM_SDK_CPPWRAPPER_DLL_API ChatRoomEnterInfo {
    void SetNick(const std::string& nick) { values_[kNIMChatRoomEnterKeyNick] = nick; }
 
    void SetAvatar(const std::string& avatar) { values_[kNIMChatRoomEnterKeyAvatar] = avatar; }
 
    void SetExt(const nim_cpp_wrapper_util::Json::Value& ext) { values_[kNIMChatRoomEnterKeyExt] = nim::GetJsonStringWithNoStyled(ext); }
 
    void SetNotifyExt(const nim_cpp_wrapper_util::Json::Value& notify_ext) {
        values_[kNIMChatRoomEnterKeyNotifyExt] = nim::GetJsonStringWithNoStyled(notify_ext);
    }
 
    void SetLoginTag(const std::list<std::string>& login_tags) {
        for (auto& tag : login_tags) {
            values_[kNIMChatRoomEnterLoginTags].append(tag);
        }
    }
 
    void SetNotifyTags(const std::string& expression) { values_[kNIMChatRoomEnterNotifyTags] = expression; }
 
    void SetLocation(NIMChatRoomLocation location) {
        values_[kNIMChatRoomEnterLocationX] = location.x_;
        values_[kNIMChatRoomEnterLocationY] = location.y_;
        values_[kNIMChatRoomEnterLocationZ] = location.z_;
        values_[kNIMChatRoomEnterLocationDistance] = location.distance_;
    }
 
    void EnableLocation(bool enable) { values_[kNIMChatRoomEnterEnableLocation] = enable; }
 
    void SetAuthType(int auth_type) { values_[kNIMChatRoomEnterAuthType] = auth_type; }
 
    void SetLoginExt(const std::string& login_ext) { values_[kNIMChatRoomEnterLoginExt] = login_ext; }
 
    void SetAntiSpamBusinessID(const std::string& anti_spam_business_id) { values_[kNIMChatRoomEnterAntiSpamBusinessID] = anti_spam_business_id; }
 
    std::string ToJsonString() const { return values_.empty() ? "" : nim::GetJsonStringWithNoStyled(values_); }
 
private:
    nim_cpp_wrapper_util::Json::Value values_;
};
 
struct NIM_CHATROOM_SDK_CPPWRAPPER_DLL_API ChatRoomIndependentEnterInfo {
    std::list<std::string> address_; 
    std::string app_data_file_;      
    int sdk_log_level_;              
    std::string app_key_;            
    std::string accid_;              
    std::string token_;              
    std::list<std::string> login_tags_; 
    std::string notify_tags_;           
    NIMChatRoomLocation location_;      
    bool enable_location_; 
    int auth_type_; 
    std::string login_ext_;             
    std::string anti_spam_business_id_; 
    ChatRoomIndependentEnterInfo() {
        sdk_log_level_ = 5;
        location_ = {0};
        enable_location_ = false;
        auth_type_ = 0;
    }
 
    std::string ToJsonString() const {
        nim_cpp_wrapper_util::Json::Value values;
        nim_cpp_wrapper_util::Json::FastWriter fw;
        std::string addr_str;
        for (auto& address : address_) {
            values[kNIMChatRoomEnterKeyAddress].append(address);
        }
        std::string login_tags;
        nim::StrListToJsonString(login_tags_, login_tags);
        values[kNIMChatRoomEnterLoginTags] = login_tags;
        values[kNIMChatRoomEnterKeyAppDataPath] = app_data_file_;
        values[kNIMChatRoomEnterKeyLogLevel] = sdk_log_level_;
        values[kNIMChatRoomEnterKeyAppKey] = app_key_;
        values[kNIMChatRoomEnterKeyAccID] = accid_;
        values[kNIMChatRoomEnterKeyToken] = token_;
        values[kNIMChatRoomEnterNotifyTags] = notify_tags_;
        values[kNIMChatRoomEnterLocationX] = location_.x_;
        values[kNIMChatRoomEnterLocationY] = location_.y_;
        values[kNIMChatRoomEnterLocationZ] = location_.z_;
        values[kNIMChatRoomEnterLocationDistance] = location_.distance_;
        values[kNIMChatRoomEnterEnableLocation] = enable_location_;
        values[kNIMChatRoomEnterAuthType] = auth_type_;
        values[kNIMChatRoomEnterLoginExt] = login_ext_;
        values[kNIMChatRoomEnterAntiSpamBusinessID] = anti_spam_business_id_;
        return fw.write(values);
    }
};
 
struct NIM_CHATROOM_SDK_CPPWRAPPER_DLL_API ChatRoomAnoymityEnterInfo {
    std::list<std::string> address_; 
    std::string
        app_data_file_;   
    int sdk_log_level_;   
    std::string app_key_; 
    bool random_id_;      
    std::string accid_;   
    std::string token_;   
    ChatRoomAnoymityEnterInfo() {
        sdk_log_level_ = 5;
        random_id_ = false;
    }
 
    std::string ToJsonString() const {
        nim_cpp_wrapper_util::Json::Value values;
        nim_cpp_wrapper_util::Json::FastWriter fw;
        std::string addr_str;
        for (auto& address : address_) {
            values[kNIMChatRoomEnterKeyAddress].append(address);
        }
        std::string login_tags;
        values[kNIMChatRoomEnterLoginTags] = login_tags;
        values[kNIMChatRoomEnterKeyAppDataPath] = app_data_file_;
        values[kNIMChatRoomEnterKeyLogLevel] = sdk_log_level_;
        values[kNIMChatRoomEnterKeyAppKey] = app_key_;
        values[kNIMChatRoomEnterKeyRandomID] = random_id_ ? 1 : 0;
        if (!accid_.empty())
            values[kNIMChatRoomEnterKeyAccID] = accid_;
        if (!token_.empty())
            values[kNIMChatRoomEnterKeyToken] = token_;
        return fw.write(values);
    }
};
 
struct NIM_CHATROOM_SDK_CPPWRAPPER_DLL_API ChatRoomInfo {
    int64_t id_;                
    std::string name_;          
    std::string announcement_;  
    std::string broadcast_url_; 
    std::string creator_id_;    
    int valid_flag_;            
    std::string ext_;           
    int online_count_;          
    int mute_all_;              
    int queuelevel;             
    ChatRoomInfo()
        : id_(0)
        , valid_flag_(0)
        , mute_all_(0)
        , queuelevel(1) {}
 
    void ParseFromJsonValue(const nim_cpp_wrapper_util::Json::Value& values) {
        id_ = values[kNIMChatRoomInfoKeyID].asUInt64();
        name_ = values[kNIMChatRoomInfoKeyName].asString();
        announcement_ = values[kNIMChatRoomInfoKeyAnnouncement].asString();
        broadcast_url_ = values[kNIMChatRoomInfoKeyBroadcastUrl].asString();
        creator_id_ = values[kNIMChatRoomInfoKeyCreatorID].asString();
        valid_flag_ = values[kNIMChatRoomInfoKeyValidFlag].asUInt();
        ext_ = values[kNIMChatRoomInfoKeyExt].asString();
        online_count_ = values[kNIMChatRoomInfoKeyOnlineCount].asUInt();
        mute_all_ = values[kNIMChatRoomInfoKeyMuteAll].asUInt();
        queuelevel = values[kNIMChatRoomInfoKeyQueuelevel].asInt();
    }
 
    std::string ToJsonString() const {
        nim_cpp_wrapper_util::Json::Value values;
        values[kNIMChatRoomInfoKeyID] = id_;
        values[kNIMChatRoomInfoKeyName] = name_;
        values[kNIMChatRoomInfoKeyAnnouncement] = announcement_;
        values[kNIMChatRoomInfoKeyBroadcastUrl] = broadcast_url_;
        values[kNIMChatRoomInfoKeyCreatorID] = creator_id_;
        values[kNIMChatRoomInfoKeyValidFlag] = valid_flag_;
        values[kNIMChatRoomInfoKeyExt] = ext_;
        values[kNIMChatRoomInfoKeyOnlineCount] = online_count_;
        values[kNIMChatRoomInfoKeyMuteAll] = mute_all_;
        values[kNIMChatRoomInfoKeyQueuelevel] = queuelevel;
        return nim::GetJsonStringWithNoStyled(values);
    }
};
 
struct NIM_CHATROOM_SDK_CPPWRAPPER_DLL_API ChatRoomNotification {
    NIMChatRoomNotificationId id_; 
    std::string ext_;              
    std::string operator_id_;      
    std::string operator_nick_;    
    std::list<std::string> target_nick_; 
    std::list<std::string> target_ids_;  
    int64_t temp_mute_duration_; 
    bool muted_;               
    bool temp_muted_;          
    std::string queue_change_; 
    std::string target_tag_; 
    std::string msg_id_;   
    uint64_t msg_timetag_; 
    ChatRoomNotification()
        : temp_mute_duration_(0)
        , muted_(false)
        , temp_muted_(false)
        , msg_timetag_(0) {}
 
    void ParseFromJsonValue(const nim_cpp_wrapper_util::Json::Value& values) {
        id_ = (NIMChatRoomNotificationId)values[kChatRoomNotificationKeyID].asUInt();
        ext_ = values[kChatRoomNotificationKeyData][kChatRoomNotificationDataKeyExt].asString();
        operator_id_ = values[kChatRoomNotificationKeyData][kChatRoomNotificationDataKeyOpt].asString();
        operator_nick_ = values[kChatRoomNotificationKeyData][kChatRoomNotificationDataKeyOptNick].asString();
        nim::JsonStrArrayToList(values[kChatRoomNotificationKeyData][kChatRoomNotificationDataKeyTargetNick], target_nick_);
        nim::JsonStrArrayToList(values[kChatRoomNotificationKeyData][kChatRoomNotificationDataKeyTarget], target_ids_);
        if (id_ == kNIMChatRoomNotificationIdMemberTempMute || id_ == kNIMChatRoomNotificationIdMemberTempUnMute)
            temp_mute_duration_ = values[kChatRoomNotificationKeyData][kChatRoomNotificationDataKeyTempMuteDuration].asInt64();
        if (id_ == kNIMChatRoomNotificationIdMemberIn) {
            if (values[kChatRoomNotificationKeyData].isMember(kChatRoomNotificationDataKeyMuteFlag))
                muted_ = values[kChatRoomNotificationKeyData][kChatRoomNotificationDataKeyMuteFlag].asUInt() == 1;
            if (values[kChatRoomNotificationKeyData].isMember(kChatRoomNotificationDataKeyTempMutedFlag))
                temp_muted_ = values[kChatRoomNotificationKeyData][kChatRoomNotificationDataKeyTempMutedFlag].asUInt() == 1;
            temp_mute_duration_ = values[kChatRoomNotificationKeyData][kChatRoomNotificationDataKeyMemberInTempMutedDuration].asInt64();
        }
        if (id_ == kNIMChatRoomNotificationIdQueueChanged || id_ == kNIMChatRoomNotificationIdQueueBatchChanged ||
            id_ == kNIMChatRoomNotificationIdQueueBatchOffer) {
            queue_change_ = values[kChatRoomNotificationKeyData][kChatRoomNotificationDataKeyQueueChange].asString();
        }
        if (id_ == kNIMChatRoomNotificationIdTagTempMuteAdd || id_ == kNIMChatRoomNotificationIdTagTempMuteRemove) {
            if (values[kChatRoomNotificationKeyData].isMember(kChatRoomNotificationDataKeyTargetTag)) {
                target_tag_ = values[kChatRoomNotificationKeyData][kChatRoomNotificationDataKeyTargetTag].asString();
            }
        }
        if (id_ == kNIMChatRoomNotificationIdRecallMessage) {
            if (values[kChatRoomNotificationKeyData].isMember(kChatRoomNotificationDataKeyMsgTimetag)) {
                msg_timetag_ = values[kChatRoomNotificationKeyData][kChatRoomNotificationDataKeyMsgTimetag].asUInt64();
            }
            if (values[kChatRoomNotificationKeyData].isMember(kChatRoomNotificationDataKeyMsgId)) {
                msg_id_ = values[kChatRoomNotificationKeyData][kChatRoomNotificationDataKeyMsgId].asString();
            }
        }
    }
 
    std::string ToJsonString() const {
        nim_cpp_wrapper_util::Json::Value values;
        values[kNIMChatRoomInfoKeyID] = id_;
        values[kChatRoomNotificationDataKeyExt] = ext_;
        values[kChatRoomNotificationDataKeyOpt] = operator_id_;
        values[kChatRoomNotificationDataKeyOptNick] = operator_nick_;
        for (const auto& nick : target_nick_) {
            values[kChatRoomNotificationDataKeyTargetNick].append(nick);
        }
        for (const auto& id : target_ids_) {
            values[kChatRoomNotificationDataKeyTarget].append(id);
        }
        values[kChatRoomNotificationDataKeyTempMuteDuration] = temp_mute_duration_;
        values[kChatRoomNotificationDataKeyMuteFlag] = muted_;
        values[kChatRoomNotificationDataKeyTempMutedFlag] = temp_muted_;
        values[kChatRoomNotificationDataKeyQueueChange] = queue_change_;
        if (!target_tag_.empty())
            values[kChatRoomNotificationDataKeyTargetTag] = target_tag_;
        if (!msg_id_.empty()) {
            values[kChatRoomNotificationDataKeyMsgTimetag] = msg_timetag_;
            values[kChatRoomNotificationDataKeyMsgId] = msg_id_;
        }
 
        return nim::GetJsonStringWithNoStyled(values);
    }
};
 
struct NIM_CHATROOM_SDK_CPPWRAPPER_DLL_API ChatRoomQueueOfferOption {
public:
    bool transient_; 
    std::string element_accid_; 
    ChatRoomQueueOfferOption()
        : transient_(false) {}
    std::string ToJsonString() const {
        nim_cpp_wrapper_util::Json::Value values;
        nim_cpp_wrapper_util::Json::FastWriter writer;
        values[kNIMChatRoomQueueOfferOptionTransient] = transient_;
        if (!element_accid_.empty())
            values[kNIMChatRoomQueueOfferOptionElementAccId] = element_accid_;
        return writer.write(values);
    }
};
 
struct NIM_CHATROOM_SDK_CPPWRAPPER_DLL_API ChatRoomQueueChangedNotification {
    std::string type_;  
    std::string key_;   
    std::string value_; 
    void ParseFromNotification(const ChatRoomNotification& notification) {
        nim_cpp_wrapper_util::Json::Value values;
        nim_cpp_wrapper_util::Json::Reader reader;
        if (reader.parse(notification.queue_change_, values) && values.isObject()) {
            type_ = values[kNIMChatRoomNotificationQueueChangedKeyType].asString();
            key_ = values[kNIMChatRoomNotificationQueueChangedKeyKey].asString();
            value_ = values[kNIMChatRoomNotificationQueueChangedKeyValue].asString();
        }
    }
};
 
struct NIM_CHATROOM_SDK_CPPWRAPPER_DLL_API ChatRoomQueueBatchChangedNotification {
    std::string type_;                                  
    std::string key_;                                   
    std::string value_;                                 
    std::map<std::string, std::string> changed_values_; 
    void ParseFromNotification(const ChatRoomNotification& notification) {
        nim_cpp_wrapper_util::Json::Value values;
        nim_cpp_wrapper_util::Json::Reader reader;
        if (reader.parse(notification.queue_change_, values) && values.isObject()) {
            type_ = values[kNIMChatRoomNotificationQueueBatchChangedKeyType].asString();
            if (values.isMember(kNIMChatRoomNotificationQueueBatchChangedKeyKey))
                key_ = values[kNIMChatRoomNotificationQueueBatchChangedKeyKey].asString();
            if (values.isMember(kNIMChatRoomNotificationQueueBatchChangedKeyValue))
                value_ = values[kNIMChatRoomNotificationQueueBatchChangedKeyValue].asString();
            if (values.isMember(kNIMChatRoomNotificationQueueBatchChangedKeyObject)) {
                auto members_name = values[kNIMChatRoomNotificationQueueBatchChangedKeyObject].getMemberNames();
                auto it = members_name.begin();
                while (it != members_name.end()) {
                    changed_values_.insert(std::make_pair(*it, values[kNIMChatRoomNotificationQueueBatchChangedKeyObject][*it].asString()));
                    it++;
                }
            }
        }
    }
};
 
struct NIM_CHATROOM_SDK_CPPWRAPPER_DLL_API ChatRoomMessageSetting {
    bool resend_flag_;              
    std::string ext_;               
    bool anti_spam_enable_;         
    std::string anti_spam_content_; 
    bool history_save_;             
    std::string anti_spam_bizid_;   
    int anti_spam_using_yidun_; 
    int high_priority_; 
    std::string yidun_anti_cheating_; 
    std::string env_config_;          
    std::string anti_spam_ext_;       
    NIMChatRoomLocation location_;    
    std::list<std::string> to_accids; 
    ChatRoomMessageSetting()
        : resend_flag_(false)
        , anti_spam_enable_(false)
        , history_save_(true)
        , anti_spam_bizid_("")
        , anti_spam_using_yidun_(1)
        , high_priority_(0)
        , yidun_anti_cheating_("")
        , anti_spam_ext_("")
        , location_({0}) {}
 
    void ToJsonValue(nim_cpp_wrapper_util::Json::Value& message) const {
        message[kNIMChatRoomMsgKeyResendFlag] = resend_flag_ ? 1 : 0;
        message[kNIMChatRoomMsgKeyExt] = ext_;
        message[kNIMChatRoomMsgKeyAntiSpamEnable] = anti_spam_enable_ ? 1 : 0;
        message[kNIMChatRoomMsgKeyAntiSpamContent] = anti_spam_content_;
        if (!anti_spam_bizid_.empty())
            message[kNIMChatRoomMsgKeyAntiSpamBizId] = anti_spam_bizid_;
        message[kNIMChatRoomMsgKeyHistorySave] = history_save_ ? 1 : 0;
        message[kNIMChatRoomMsgKeyAntiSpamUsingYiDun] = anti_spam_using_yidun_;
        if (!yidun_anti_cheating_.empty())
            message[kNIMChatRoomMsgKeyYiDunAntiCheating] = yidun_anti_cheating_;
        if (!env_config_.empty())
            message[kNIMChatRoomMsgKeyEnvConfig] = env_config_;
        if (!anti_spam_ext_.empty())
            message[kNIMChatRoomMsgKeyAntiSpamExt] = anti_spam_ext_;
        message[kNIMChatRoomMsgKeyLocationX] = location_.x_;
        message[kNIMChatRoomMsgKeyLocationY] = location_.y_;
        message[kNIMChatRoomMsgKeyLocationZ] = location_.z_;
        std::string to_accids_str;
        nim::StrListToJsonString(to_accids, to_accids_str);
        message[kNIMChatRoomMsgKeyToAccids] = to_accids_str;
    }
 
    void ParseMessageSetting(const nim_cpp_wrapper_util::Json::Value& message) {
        resend_flag_ = message[kNIMChatRoomMsgKeyResendFlag].asUInt() == 1;
        ext_ = message[kNIMChatRoomMsgKeyExt].asString();
        if (message.isMember(kNIMChatRoomMsgKeyAntiSpamEnable))
            anti_spam_enable_ = message[kNIMChatRoomMsgKeyAntiSpamEnable].asInt() == 1;
        anti_spam_content_ = message[kNIMChatRoomMsgKeyAntiSpamContent].asString();
        high_priority_ = message[kNIMChatRoomMsgKeyHighPriorityFlag].asInt();
        if (message.isMember(kNIMChatRoomMsgKeyYiDunAntiCheating))
            yidun_anti_cheating_ = message[kNIMChatRoomMsgKeyYiDunAntiCheating].asString();
        if (message.isMember(kNIMChatRoomMsgKeyEnvConfig))
            env_config_ = message[kNIMChatRoomMsgKeyEnvConfig].asString();
        if (message.isMember(kNIMChatRoomMsgKeyAntiSpamExt))
            anti_spam_ext_ = message[kNIMChatRoomMsgKeyAntiSpamExt].asString();
        if (message.isMember(kNIMChatRoomMsgKeyLocationX))
            location_.x_ = message[kNIMChatRoomMsgKeyLocationX].asFloat();
        if (message.isMember(kNIMChatRoomMsgKeyLocationY))
            location_.y_ = message[kNIMChatRoomMsgKeyLocationY].asFloat();
        if (message.isMember(kNIMChatRoomMsgKeyLocationZ))
            location_.z_ = message[kNIMChatRoomMsgKeyLocationZ].asFloat();
        if (message.isMember(kNIMChatRoomMsgKeyToAccids)) {
            to_accids.clear();
            nim::JsonStrArrayToList(message[kNIMChatRoomMsgKeyToAccids], to_accids);
        }
    }
};
 
struct NIM_CHATROOM_SDK_CPPWRAPPER_DLL_API ChatRoomMessage {
public:
    int64_t room_id_;                        
    std::string from_id_;                    
    int64_t timetag_;                        
    NIMChatRoomClientType from_client_type_; 
    std::string from_nick_;                  
    std::string from_avatar_;                
    std::string from_ext_;                   
    // v7.8 <--
    std::string third_party_callback_ext_; 
    // --> v7.8
    // v8.4.0 <--
    std::string notify_tags_; 
    // --> v8.4.0
    std::string anti_spam_res_; 
public:
    NIMChatRoomMsgType msg_type_;        
    std::string msg_attach_;             
    std::string client_msg_id_;          
    std::string msg_body_;               
    ChatRoomMessageSetting msg_setting_; 
    // v7.8 <--
    int32_t sub_type_; 
    // --> v7.8
public:
    std::string local_res_path_; 
    std::string local_res_id_;   
    ChatRoomMessage()
        : room_id_(-1)
        , from_client_type_(kNIMChatRoomClientTypeDefault)
        , timetag_(0)
        , third_party_callback_ext_("")
        , sub_type_(0) {}
 
    void ParseFromJsonValue(const nim_cpp_wrapper_util::Json::Value& values) {
        room_id_ = values[kNIMChatRoomMsgKeyRoomID].asUInt64();
        from_id_ = values[kNIMChatRoomMsgKeyFromAccount].asString();
        timetag_ = values[kNIMChatRoomMsgKeyTime].asUInt64();
        from_client_type_ = (NIMChatRoomClientType)values[kNIMChatRoomMsgKeyFromClientType].asUInt();
        from_nick_ = values[kNIMChatRoomMsgKeyFromNick].asString();
        from_avatar_ = values[kNIMChatRoomMsgKeyFromAvatar].asString();
        from_ext_ = values[kNIMChatRoomMsgKeyFromExt].asString();
        msg_type_ = (NIMChatRoomMsgType)values[kNIMChatRoomMsgKeyType].asUInt();
        msg_attach_ = values[kNIMChatRoomMsgKeyAttach].asString();
        client_msg_id_ = values[kNIMChatRoomMsgKeyClientMsgid].asString();
        local_res_path_ = values[kNIMChatRoomMsgKeyLocalFilePath].asString();
        local_res_id_ = values[kNIMChatRoomMsgKeyLocalResId].asString();
        msg_body_ = values[kNIMChatRoomMsgKeyBody].asString();
        msg_setting_.ParseMessageSetting(values);
        if (values.isMember(kNIMChatRoomMsgKeyThirdPartyCBEXT))
            third_party_callback_ext_ = values[kNIMChatRoomMsgKeyThirdPartyCBEXT].asString();
        if (values.isMember(kNIMChatRoomMsgKeySubType))
            sub_type_ = values[kNIMChatRoomMsgKeySubType].asInt();
        if (values.isMember(kNIMChatRoomMsgKeyNotifyTags))
            notify_tags_ = values[kNIMChatRoomMsgKeyNotifyTags].asString();
        if (values.isMember(kNIMChatRoomMsgKeyAntiSpamRes))
            anti_spam_res_ = values[kNIMChatRoomMsgKeyAntiSpamRes].asString();
    }
 
    std::string ToJsonString() const {
        nim_cpp_wrapper_util::Json::Value values;
        values[kNIMChatRoomMsgKeyType] = msg_type_;
        values[kNIMChatRoomMsgKeyTime] = timetag_;
        values[kNIMChatRoomMsgKeyAttach] = msg_attach_;
        values[kNIMChatRoomMsgKeyClientMsgid] = client_msg_id_;
        values[kNIMChatRoomMsgKeyLocalFilePath] = local_res_path_;
        values[kNIMChatRoomMsgKeyLocalResId] = local_res_id_;
        values[kNIMChatRoomMsgKeyBody] = msg_body_;
        values[kNIMChatRoomMsgKeyThirdPartyCBEXT] = third_party_callback_ext_;
        values[kNIMChatRoomMsgKeySubType] = sub_type_;
        values[kNIMChatRoomMsgKeyAntiSpamRes] = anti_spam_res_;
        msg_setting_.ToJsonValue(values);
        return nim::GetJsonStringWithNoStyled(values);
    }
};
 
struct NIM_CHATROOM_SDK_CPPWRAPPER_DLL_API ChatRoomGetMembersParameters {
    NIMChatRoomGetMemberType type_; 
    int64_t timestamp_offset_;      
    int limit_;                     
    ChatRoomGetMembersParameters()
        : timestamp_offset_(0)
        , limit_(0) {}
 
    std::string ToJsonString() const {
        nim_cpp_wrapper_util::Json::Value values;
        values[kNIMChatRoomGetMembersKeyType] = type_;
        values[kNIMChatRoomGetMembersKeyOffset] = timestamp_offset_;
        values[kNIMChatRoomGetMembersKeyLimit] = limit_;
        return nim::GetJsonStringWithNoStyled(values);
    }
};
 
struct NIM_CHATROOM_SDK_CPPWRAPPER_DLL_API ChatRoomGetMembersByTagParameters {
    std::string tag_;          
    int64_t timestamp_offset_; 
    int limit_;                
    ChatRoomGetMembersByTagParameters()
        : timestamp_offset_(0)
        , limit_(0) {}
 
    std::string ToJsonString() const {
        nim_cpp_wrapper_util::Json::Value values;
        values[kNIMChatRoomGetMembersKeyTag] = tag_;
        values[kNIMChatRoomGetMembersKeyOffset] = timestamp_offset_;
        values[kNIMChatRoomGetMembersKeyLimit] = limit_;
        return nim::GetJsonStringWithNoStyled(values);
    }
};
 
struct NIM_CHATROOM_SDK_CPPWRAPPER_DLL_API ChatRoomGetMsgHistoryParameters {
    int64_t start_timetag_;                     
    int limit_;                                 
    bool reverse_;                              
    std::vector<NIMChatRoomMsgType> msg_types_; 
    ChatRoomGetMsgHistoryParameters()
        : start_timetag_(0)
        , limit_(0)
        , reverse_(false) {
        if (kMsg_Types_List.empty()) {
            kMsg_Types_List.emplace_back(kNIMChatRoomMsgTypeText);
            kMsg_Types_List.emplace_back(kNIMChatRoomMsgTypeImage);
            kMsg_Types_List.emplace_back(kNIMChatRoomMsgTypeAudio);
            kMsg_Types_List.emplace_back(kNIMChatRoomMsgTypeVideo);
            kMsg_Types_List.emplace_back(kNIMChatRoomMsgTypeLocation);
            kMsg_Types_List.emplace_back(kNIMChatRoomMsgTypeNotification);
            kMsg_Types_List.emplace_back(kNIMChatRoomMsgTypeFile);
            kMsg_Types_List.emplace_back(kNIMChatRoomMsgTypeRobot);
            kMsg_Types_List.emplace_back(kNIMChatRoomMsgTypeTips);
            kMsg_Types_List.emplace_back(kNIMChatRoomMsgTypeCustom);
        }
        msg_types_.assign(kMsg_Types_List.begin(), kMsg_Types_List.end());
    }
    // 考虑到兼容以前版本，只提供删除类型接口，如果所有类型都被删除，会添加Unknown类型以区别之前的版本
    void RemoveMessageType(NIMChatRoomMsgType type) {
        auto it = std::find_if(msg_types_.begin(), msg_types_.end(), [&](const NIMChatRoomMsgType& item) {
            return item == type;
        });
        if (it != msg_types_.end())
            msg_types_.erase(it);
        if (msg_types_.empty())
            msg_types_.emplace_back(kNIMChatRoomMsgTypeUnknown);
    }
    std::string ToJsonString() const {
        nim_cpp_wrapper_util::Json::Value values;
        values[kNIMChatRoomGetMsgHistoryKeyStartTime] = start_timetag_;
        values[kNIMChatRoomGetMsgHistoryKeyLimit] = limit_;
        values[kNIMChatRoomGetMsgHistoryKeyReverse] = reverse_;
        auto it = msg_types_.begin();
        while (it != msg_types_.end()) {
            values[kNIMChatRoomGetMsgHistoryKeyMsgtypes].append(nim_cpp_wrapper_util::Json::Value(*it));
            it++;
        }
        return nim::GetJsonStringWithNoStyled(values);
    }
 
private:
    static std::vector<NIMChatRoomMsgType> kMsg_Types_List;
};
 
struct NIM_CHATROOM_SDK_CPPWRAPPER_DLL_API ChatRoomSetMemberAttributeParameters {
    std::string account_id_;               
    NIMChatRoomMemberAttribute attribute_; 
    bool opt_;                             
    std::string notify_ext_;               
    ChatRoomSetMemberAttributeParameters()
        : level_(0) {}
 
    std::string ToJsonString() const {
        nim_cpp_wrapper_util::Json::Value values;
        values[kNIMChatRoomSetMemberAttributeKeyAccoutID] = account_id_;
        values[kNIMChatRoomSetMemberAttributeKeyAttribute] = attribute_;
        values[kNIMChatRoomSetMemberAttributeKeyOpt] = opt_;
        values[kNIMChatRoomSetMemberAttributeKeyNotifyExt] = notify_ext_;
        return nim::GetJsonStringWithNoStyled(values);
    }
 
private:
    int level_; 
};
 
struct NIM_CHATROOM_SDK_CPPWRAPPER_DLL_API ChatRoomMemberInfo {
    int64_t room_id_;        
    std::string account_id_; 
    std::string tags_;       
    int type_; 
    int level_;                    
    std::string nick_;             
    std::string avatar_;           
    std::string ext_;              
    std::string notify_tags_;      
    NIMChatRoomOnlineState state_; 
    NIMChatRoomGuestFlag guest_flag_; 
    int64_t enter_timetag_;       
    bool is_blacklist_;           
    bool is_muted_;               
    bool is_valid_;               
    int64_t update_timetag_;      
    bool temp_muted_;             
    int64_t temp_muted_duration_; 
    ChatRoomMemberInfo()
        : room_id_(0)
        , type_(-2)
        , level_(0)
        , state_(kNIMChatRoomOnlineStateOffline)
        , guest_flag_(kNIMChatRoomGuestFlagGuest)
        , enter_timetag_(0)
        , is_blacklist_(false)
        , is_muted_(false)
        , is_valid_(false)
        , update_timetag_(0)
        , temp_muted_(false)
        , temp_muted_duration_(0) {}
 
    void ParseFromJsonValue(const nim_cpp_wrapper_util::Json::Value& value) {
        if (value.isMember(kNIMChatRoomMemberInfoKeyRoomID))
            room_id_ = value[kNIMChatRoomMemberInfoKeyRoomID].asUInt64();
        if (value.isMember(kNIMChatRoomMemberInfoKeyAccID))
            account_id_ = value[kNIMChatRoomMemberInfoKeyAccID].asString();
        if (value.isMember(kNIMChatRoomMemberInfoKeyType))
            type_ = value[kNIMChatRoomMemberInfoKeyType].asInt();
        if (value.isMember(kNIMChatRoomMemberInfoKeyLevel))
            level_ = value[kNIMChatRoomMemberInfoKeyLevel].asInt();
        if (value.isMember(kNIMChatRoomMemberInfoKeyNick))
            nick_ = value[kNIMChatRoomMemberInfoKeyNick].asString();
        if (value.isMember(kNIMChatRoomMemberInfoKeyAvatar))
            avatar_ = value[kNIMChatRoomMemberInfoKeyAvatar].asString();
        if (value.isMember(kNIMChatRoomMemberInfoKeyExt))
            ext_ = value[kNIMChatRoomMemberInfoKeyExt].asString();
        if (value.isMember(kNIMChatRoomMemberInfoKeyOnlineState))
            state_ = (NIMChatRoomOnlineState)value[kNIMChatRoomMemberInfoKeyOnlineState].asInt();
        if (value.isMember(kNIMChatRoomMemberInfoKeyGuestFlag))
            guest_flag_ = (NIMChatRoomGuestFlag)value[kNIMChatRoomMemberInfoKeyGuestFlag].asInt();
        if (value.isMember(kNIMChatRoomMemberInfoKeyEnterTimetag))
            enter_timetag_ = value[kNIMChatRoomMemberInfoKeyEnterTimetag].asUInt64();
        if (value.isMember(kNIMChatRoomMemberInfoKeyBlacklist))
            is_blacklist_ = value[kNIMChatRoomMemberInfoKeyBlacklist].asInt() == 1;
        if (value.isMember(kNIMChatRoomMemberInfoKeyMuted))
            is_muted_ = value[kNIMChatRoomMemberInfoKeyMuted].asInt() == 1;
        if (value.isMember(kNIMChatRoomMemberInfoKeyValid))
            is_valid_ = value[kNIMChatRoomMemberInfoKeyValid].asInt() == 1;
        if (value.isMember(kNIMChatRoomMemberInfoKeyUpdateTimetag))
            update_timetag_ = value[kNIMChatRoomMemberInfoKeyUpdateTimetag].asUInt64();
        if (value.isMember(kNIMChatRoomMemberInfoKeyTempMute))
            temp_muted_ = value[kNIMChatRoomMemberInfoKeyTempMute].asInt() == 1;
        if (value.isMember(kNIMChatRoomMemberInfoKeyTempMuteRestDuration))
            temp_muted_duration_ = value[kNIMChatRoomMemberInfoKeyTempMuteRestDuration].asInt64();
        if (value.isMember(kNIMChatRoomMemberInfoKeyTag))
            tags_ = value[kNIMChatRoomMemberInfoKeyTag].asString();
        if (value.isMember(kNIMChatRoomMemberInfoKeyNotifyTags))
            notify_tags_ = value[kNIMChatRoomMemberInfoKeyNotifyTags].asString();
    }
 
    std::string ToJsonString() const {
        nim_cpp_wrapper_util::Json::Value values;
        values[kNIMChatRoomMemberInfoKeyRoomID] = room_id_;
        values[kNIMChatRoomMemberInfoKeyAccID] = account_id_;
        values[kNIMChatRoomMemberInfoKeyType] = type_;
        values[kNIMChatRoomMemberInfoKeyLevel] = level_;
        values[kNIMChatRoomMemberInfoKeyNick] = nick_;
        values[kNIMChatRoomMemberInfoKeyAvatar] = avatar_;
        values[kNIMChatRoomMemberInfoKeyExt] = ext_;
        values[kNIMChatRoomMemberInfoKeyOnlineState] = state_;
        values[kNIMChatRoomMemberInfoKeyGuestFlag] = guest_flag_;
        values[kNIMChatRoomMemberInfoKeyEnterTimetag] = enter_timetag_;
        values[kNIMChatRoomMemberInfoKeyBlacklist] = is_blacklist_ ? 1 : 0;
        values[kNIMChatRoomMemberInfoKeyMuted] = is_muted_ ? 1 : 0;
        values[kNIMChatRoomMemberInfoKeyValid] = is_valid_ ? 1 : 0;
        values[kNIMChatRoomMemberInfoKeyUpdateTimetag] = update_timetag_;
        values[kNIMChatRoomMemberInfoKeyTempMute] = temp_muted_ ? 1 : 0;
        values[kNIMChatRoomMemberInfoKeyTempMuteRestDuration] = temp_muted_duration_;
        return nim::GetJsonStringWithNoStyled(values);
    }
};
 
struct NIM_CHATROOM_SDK_CPPWRAPPER_DLL_API ChatRoomQueueElement {
    std::string key_;   
    std::string value_; 
};
 
struct NIM_CHATROOM_SDK_CPPWRAPPER_DLL_API ChatRoomUpdateTagsInfo {
    std::list<std::string> tags_;    
    std::string notify_target_tags_; 
    int need_notify_{0};             
    std::string ext_;                
};
 
typedef std::list<ChatRoomQueueElement> ChatRoomQueue;
 
struct NIM_CHATROOM_SDK_CPPWRAPPER_DLL_API NIMChatRoomExitReasonInfo {
    std::string notify_ext_;     
    NIMChatRoomExitReason code_; 
    operator NIMChatRoomExitReason() const { return code_; }
};
 
NIM_CHATROOM_SDK_CPPWRAPPER_DLL_API bool operator==(const NIMChatRoomExitReasonInfo& info, NIMChatRoomExitReason code);
 
NIM_CHATROOM_SDK_CPPWRAPPER_DLL_API bool ParseChatRoomEnterCallbackResultInfo(const std::string& result,
    ChatRoomInfo& room_info,
    ChatRoomMemberInfo& my_info);
 
NIM_CHATROOM_SDK_CPPWRAPPER_DLL_API bool ParseChatRoomMemberInfos(const std::string& infos_json_str, std::list<ChatRoomMemberInfo>& infos);
 
NIM_CHATROOM_SDK_CPPWRAPPER_DLL_API bool ParseChatRoomMsgs(const std::string& msgs_json_str, std::list<ChatRoomMessage>& msgs);
 
struct NIM_CHATROOM_SDK_CPPWRAPPER_DLL_API RobotInfo {
public:
    void SetAccid(const std::string& accid) { robot_info_[kNIMRobotInfoKeyAccid] = accid; }
 
    std::string GetAccid() const { return robot_info_[kNIMRobotInfoKeyAccid].asString(); }
 
    void SetName(const std::string& name) { robot_info_[kNIMRobotInfoKeyName] = name; }
 
    std::string GetName() const { return robot_info_[kNIMRobotInfoKeyName].asString(); }
 
    void SetIcon(const std::string& icon) { robot_info_[kNIMRobotInfoKeyIcon] = icon; }
 
    std::string GetIcon() const { return robot_info_[kNIMRobotInfoKeyIcon].asString(); }
 
    void SetIntro(const std::string& intro) { robot_info_[kNIMRobotInfoKeyIntro] = intro; }
 
    std::string GetIntro() const { return robot_info_[kNIMRobotInfoKeyIntro].asString(); }
 
    void SetRobotID(const std::string& id) { robot_info_[kNIMRobotInfoKeyRobotId] = id; }
 
    std::string GetRobotID() const { return robot_info_[kNIMRobotInfoKeyRobotId].asString(); }
 
    void SetCreateTime(const uint64_t time) { robot_info_[kNIMRobotInfoKeyCreateTime] = time; }
 
    uint64_t GetCreateTime() const { return robot_info_[kNIMRobotInfoKeyCreateTime].asUInt64(); }
 
    void SetUpdateTime(const uint64_t time) { robot_info_[kNIMRobotInfoKeyUpdateTime] = time; }
 
    uint64_t GetUpdateTime() const { return robot_info_[kNIMRobotInfoKeyUpdateTime].asUInt64(); }
 
private:
    nim_cpp_wrapper_util::Json::Value robot_info_;
};
 
typedef std::list<RobotInfo> RobotInfos;
 
NIM_CHATROOM_SDK_CPPWRAPPER_DLL_API bool ParseRobotInfosStringToRobotInfos(const std::string& infos_json, RobotInfos& infos);
 
NIM_CHATROOM_SDK_CPPWRAPPER_DLL_API bool ParseRobotInfoStringToRobotInfo(const std::string& info_json, RobotInfo& info);
 
typedef ChatRoomQueueElement ChatRoomMember;
struct NIM_CHATROOM_SDK_CPPWRAPPER_DLL_API ChatRoomBatchMembers {
    std::map<std::string, std::string> members_values_;
    ChatRoomBatchMembers() { members_values_.clear(); }
    explicit ChatRoomBatchMembers(const std::map<std::string, std::string>& members)
        : members_values_(members) {}
 
    void ParseFromJsonValue(const nim_cpp_wrapper_util::Json::Value& json_str) { assert(false); }
 
    std::string ToJsonString() const {
        nim_cpp_wrapper_util::Json::Value values;
        int i = 0;
        for (auto it = members_values_.begin(); it != members_values_.end(); ++it) {
            values[i][kNIMChatRoomQueueElementKey] = it->first.c_str();
            values[i][kNIMChatRoomQueueElementValue] = it->second.c_str();
            i++;
        }
        return nim::GetJsonStringWithNoStyled(values);
    }
};
 
NIM_CHATROOM_SDK_CPPWRAPPER_DLL_API bool ParseBatchInfosStringToNotMembers(const std::string& infos_json, std::list<std::string>& lst_members);
 
}  // namespace nim_chatroom
 
#endif  //_NIM_CHATROOM_SDK_CPP_HELPER_H_