nim_talk_helper.h

浏览该文件的文档.

 
#ifndef _NIM_SDK_CPP_TALK_HELPER_H_
#define _NIM_SDK_CPP_TALK_HELPER_H_
 
#include <functional>
#include <list>
#include <string>
#include "nim_cpp_wrapper/helper/nim_ai_helper.h"
#include "nim_cpp_wrapper/helper/nim_sdk_loader_helper.h"
#include "nim_cpp_wrapper/nim_sdk_cpp_wrapper.h"
#include "nim_define_include.h"
#include "nim_wrapper_util/nim_json_util.h"
namespace nim {
 
struct NIM_SDK_CPPWRAPPER_DLL_API MessageSetting {
    BoolStatus resend_flag_;
    BoolStatus server_history_saved_;
    BoolStatus roaming_;
    BoolStatus self_sync_;
    BoolStatus need_push_;
    BoolStatus push_need_badge_;
    BoolStatus push_need_prefix_;
    BoolStatus routable_;
    BoolStatus is_blacklisted_;
    BoolStatus need_offline_;
    nim_cpp_wrapper_util::Json::Value push_payload_;
    std::string push_content_;
    nim_cpp_wrapper_util::Json::Value server_ext_;
    std::string local_ext_;
    BoolStatus is_force_push_;
    std::list<std::string> force_push_ids_list_;
    std::string force_push_content_;
    BoolStatus anti_spam_enable_;
    std::string anti_spam_content_;
    std::string anti_apam_biz_id_;
    int anti_apam_using_yidun_;
    BoolStatus client_anti_spam_hitting_;
    BoolStatus team_msg_need_ack_;
    BoolStatus team_msg_ack_sent_;
    int team_msg_unread_count_;
    BoolStatus is_update_session_;
    std::string yidun_anti_cheating_;
    std::string env_config_;
    std::string anti_spam_ext;
    std::string anti_spam_res;
 
    MessageSetting()
        : resend_flag_(BS_NOT_INIT)
        , server_history_saved_(BS_NOT_INIT)
        , roaming_(BS_NOT_INIT)
        , self_sync_(BS_NOT_INIT)
        , need_push_(BS_NOT_INIT)
        , push_need_badge_(BS_NOT_INIT)
        , push_need_prefix_(BS_NOT_INIT)
        , routable_(BS_NOT_INIT)
        , is_blacklisted_(BS_NOT_INIT)
        , need_offline_(BS_NOT_INIT)
        , is_force_push_(BS_NOT_INIT)
        , anti_spam_enable_(BS_NOT_INIT)
        , anti_apam_using_yidun_(1)
        , client_anti_spam_hitting_(BS_NOT_INIT)
        , team_msg_need_ack_(BS_NOT_INIT)
        , team_msg_ack_sent_(BS_NOT_INIT)
        , team_msg_unread_count_(-1)
        , is_update_session_(BS_NOT_INIT) {}
 
    void ToJsonValue(nim_cpp_wrapper_util::Json::Value& message) const {
        if (server_history_saved_ != BS_NOT_INIT)
            message[kNIMMsgKeyHistorySave] = server_history_saved_;
        if (roaming_ != BS_NOT_INIT)
            message[kNIMMsgKeyMsgRoaming] = roaming_;
        if (self_sync_ != BS_NOT_INIT)
            message[kNIMMsgKeyMsgSync] = self_sync_;
        if (push_need_badge_ != BS_NOT_INIT)
            message[kNIMMsgKeyPushNeedBadge] = push_need_badge_;
        if (need_push_ != BS_NOT_INIT)
            message[kNIMMsgKeyPushEnable] = need_push_;
        if (push_need_prefix_ != BS_NOT_INIT)
            message[kNIMMsgKeyPushNeedPrefix] = push_need_prefix_;
        if (resend_flag_ != BS_NOT_INIT)
            message[kNIMMsgKeyResendFlag] = resend_flag_;
        if (routable_ != BS_NOT_INIT)
            message[kNIMMsgKeyMsgRoutable] = routable_;
        if (is_blacklisted_ != BS_NOT_INIT)
            message[kNIMMsgKeyIsBlacklisted] = is_blacklisted_;
        if (need_offline_ != BS_NOT_INIT)
            message[kNIMMsgKeySetMsgOffline] = need_offline_;
        if (!push_payload_.empty())
            message[kNIMMsgKeyPushPayload] = GetJsonStringWithNoStyled(push_payload_);
        if (!push_content_.empty())
            message[kNIMMsgKeyPushContent] = push_content_;
        if (!server_ext_.empty())
            message[kNIMMsgKeyServerExt] = GetJsonStringWithNoStyled(server_ext_);
        if (!local_ext_.empty())
            message[kNIMMsgKeyLocalExt] = local_ext_;
        if (is_force_push_ != BS_NOT_INIT)
            message[kNIMMsgKeyIsForcePush] = is_force_push_ == BS_TRUE ? 1 : 0;
        if (!force_push_content_.empty())
            message[kNIMMsgKeyForcePushContent] = force_push_content_;
        if (!force_push_ids_list_.empty()) {
            std::string ids_json;
            StrListToJsonString(force_push_ids_list_, ids_json);
            message[kNIMMsgKeyForcePushList] = ids_json;
        }
        if (anti_spam_enable_ != BS_NOT_INIT)
            message[kNIMMsgKeyAntiSpamEnable] = anti_spam_enable_ == BS_TRUE ? 1 : 0;
        if (!anti_spam_content_.empty())
            message[kNIMMsgKeyAntiSpamContent] = anti_spam_content_;
        if (!anti_apam_biz_id_.empty())
            message[kNIMMsgKeyAntiSpamBizId] = anti_apam_biz_id_;
        message[kNIMMsgKeyAntiSpamUsingYiDun] = anti_apam_using_yidun_;
        if (client_anti_spam_hitting_ != BS_NOT_INIT)
            message[kNIMMsgKeyClientAntiSpam] = client_anti_spam_hitting_;
        if (team_msg_need_ack_ != BS_NOT_INIT)
            message[kNIMMsgKeyTeamMsgAck] = team_msg_need_ack_;
        if (team_msg_ack_sent_ != BS_NOT_INIT)
            message[kNIMMsgKeyLocalKeyTeamMsgAckSent] = team_msg_ack_sent_;
        if (team_msg_unread_count_ > -1)
            message[kNIMMsgKeyLocalKeyTeamMsgUnreadCount] = team_msg_unread_count_;
        if (is_update_session_ != BS_NOT_INIT)
            message[kNIMMsgKeyIsUpdateSession] = is_update_session_;
        if (!yidun_anti_cheating_.empty())
            message[kNIMMsgKeyAntiCheatingYiDun] = yidun_anti_cheating_;
        if (!anti_spam_ext.empty())
            message[kNIMMsgKeyAntiSpamExt] = anti_spam_ext;
        if (!anti_spam_res.empty())
            message[kNIMMsgKeyAntiSpamRes] = anti_spam_res;
        if (!env_config_.empty())
            message[kNIMMsgKeyEnv] = env_config_;
    }
    nim_cpp_wrapper_util::Json::Value ToJsonValue() const {
        nim_cpp_wrapper_util::Json::Value value;
        ToJsonValue(value);
        return value;
    }
 
    void ParseMessageSetting(const nim_cpp_wrapper_util::Json::Value& message) {
        if (message.isMember(kNIMMsgKeyHistorySave))
            server_history_saved_ = message[kNIMMsgKeyHistorySave].asInt() == 1 ? BS_TRUE : BS_FALSE;
        if (message.isMember(kNIMMsgKeyMsgRoaming))
            roaming_ = message[kNIMMsgKeyMsgRoaming].asInt() == 1 ? BS_TRUE : BS_FALSE;
        if (message.isMember(kNIMMsgKeyMsgSync))
            self_sync_ = message[kNIMMsgKeyMsgSync].asInt() == 1 ? BS_TRUE : BS_FALSE;
        if (message.isMember(kNIMMsgKeyPushNeedBadge))
            push_need_badge_ = message[kNIMMsgKeyPushNeedBadge].asInt() == 1 ? BS_TRUE : BS_FALSE;
        if (message.isMember(kNIMMsgKeyPushEnable))
            need_push_ = message[kNIMMsgKeyPushEnable].asInt() == 1 ? BS_TRUE : BS_FALSE;
        if (message.isMember(kNIMMsgKeyPushNeedPrefix))
            push_need_prefix_ = message[kNIMMsgKeyPushNeedPrefix].asInt() == 1 ? BS_TRUE : BS_FALSE;
        if (message.isMember(kNIMMsgKeyResendFlag))
            resend_flag_ = message[kNIMMsgKeyResendFlag].asInt() == 1 ? BS_TRUE : BS_FALSE;
        if (message.isMember(kNIMMsgKeyMsgRoutable))
            routable_ = message[kNIMMsgKeyMsgRoutable].asInt() == 1 ? BS_TRUE : BS_FALSE;
        if (message.isMember(kNIMMsgKeyIsBlacklisted))
            is_blacklisted_ = message[kNIMMsgKeyIsBlacklisted].asInt() == 1 ? BS_TRUE : BS_FALSE;
        if (message.isMember(kNIMMsgKeySetMsgOffline))
            need_offline_ = message[kNIMMsgKeySetMsgOffline].asInt() == 1 ? BS_TRUE : BS_FALSE;
        if (message.isMember(kNIMMsgKeyServerExt) && !message[kNIMMsgKeyServerExt].asString().empty()) {
            nim::ParseJsonValue(message[kNIMMsgKeyServerExt].asString(), server_ext_);
        }
        if (message.isMember(kNIMMsgKeyPushPayload) && !message[kNIMMsgKeyPushPayload].asString().empty()) {
            nim::ParseJsonValue(message[kNIMMsgKeyPushPayload].asString(), push_payload_);
        }
        local_ext_ = message[kNIMMsgKeyLocalExt].asString();
        push_content_ = message[kNIMMsgKeyPushContent].asString();
        if (message.isMember(kNIMMsgKeyIsForcePush))
            is_force_push_ = message[kNIMMsgKeyIsForcePush].asInt() == 1 ? BS_TRUE : BS_FALSE;
        force_push_content_ = message[kNIMMsgKeyForcePushContent].asString();
        if (message[kNIMMsgKeyForcePushList].isString()) {
            nim_cpp_wrapper_util::Json::Value values;
            if (nim::ParseJsonValue(message[kNIMMsgKeyForcePushList].asString(), values) && values.isArray())
                JsonStrArrayToList(values, force_push_ids_list_);
            else {
                // assert(0);
            }
        }
        if (message.isMember(kNIMMsgKeyAntiSpamEnable))
            anti_spam_enable_ = message[kNIMMsgKeyAntiSpamEnable].asInt() == 1 ? BS_TRUE : BS_FALSE;
        anti_spam_content_ = message[kNIMMsgKeyAntiSpamContent].asString();
        if (message.isMember(kNIMMsgKeyClientAntiSpam))
            client_anti_spam_hitting_ = message[kNIMMsgKeyClientAntiSpam].asInt() == 1 ? BS_TRUE : BS_FALSE;
        if (message.isMember(kNIMMsgKeyTeamMsgAck))
            team_msg_need_ack_ = message[kNIMMsgKeyTeamMsgAck].asInt() == 1 ? BS_TRUE : BS_FALSE;
        if (message.isMember(kNIMMsgKeyLocalKeyTeamMsgAckSent))
            team_msg_ack_sent_ = message[kNIMMsgKeyLocalKeyTeamMsgAckSent].asInt() == 1 ? BS_TRUE : BS_FALSE;
        if (message.isMember(kNIMMsgKeyLocalKeyTeamMsgUnreadCount))
            team_msg_unread_count_ = message[kNIMMsgKeyLocalKeyTeamMsgUnreadCount].asInt();
        if (message.isMember(kNIMMsgKeyIsUpdateSession))
            is_update_session_ = message[kNIMMsgKeyIsUpdateSession].asBool() ? BS_TRUE : BS_FALSE;
        if (message.isMember(kNIMMsgKeyAntiCheatingYiDun))
            yidun_anti_cheating_ = message[kNIMMsgKeyAntiCheatingYiDun].asString();
        if (message.isMember(kNIMMsgKeyAntiSpamExt))
            anti_spam_ext = message[kNIMMsgKeyAntiSpamExt].asString();
        if (message.isMember(kNIMMsgKeyAntiSpamRes))
            anti_spam_res = message[kNIMMsgKeyAntiSpamRes].asString();
        if (message.isMember(kNIMMsgKeyEnv))
            env_config_ = message[kNIMMsgKeyEnv].asString();
    }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API IMMessageThreadInfo {
    std::string reply_msg_from_account_;
    std::string reply_msg_to_account_;
    uint64_t reply_msg_time_{0};
    uint64_t reply_msg_id_server_{0};
    std::string reply_msg_id_client_;
 
    std::string thread_msg_from_account_;
    std::string thread_msg_to_account_;
    uint64_t thread_msg_time_{0};
    uint64_t thread_msg_id_server_{0};
    std::string thread_msg_id_client_;
    int deleted_;
    IMMessageThreadInfo()
        : reply_msg_from_account_("")
        , reply_msg_to_account_("")
        , reply_msg_time_(0)
        , reply_msg_id_server_(0)
        , reply_msg_id_client_("")
        , thread_msg_from_account_("")
        , thread_msg_to_account_("")
        , thread_msg_time_(0)
        , thread_msg_id_server_(0)
        , thread_msg_id_client_("")
        , deleted_(0) {}
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API IMMessageRobotInfo {
    // 机器人 function
    std::string function_;
    // 机器人消息 topic
    std::string topic_;
    // 机器人自定义字段
    std::string custom_content_;
    // 机器人账号, 单聊忽略, 群聊需指定
    std::string account_;
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API NIMAIStreamingMessageChunk {
    std::string content_;
    time_t message_time_{0};
    time_t chunk_time_{0};
    int type_{0};
    uint32_t index_{0};
    void ToJsonValue(nim_cpp_wrapper_util::Json::Value& values) const {
        if (content_.empty())
            return;
        values[kNIMAICallKeyStreamingMessageChunkContent] = content_;
        values[kNIMAICallKeyStreamingMessageChunkMessageTime] = static_cast<int64_t>(message_time_);
        values[kNIMAICallKeyStreamingMessageChunkChunkTime] = static_cast<int64_t>(chunk_time_);
        values[kNIMAICallKeyStreamingMessageChunkType] = type_;
        values[kNIMAICallKeyStreamingMessageChunkIndex] = index_;
    }
    void FromJsonValue(const nim_cpp_wrapper_util::Json::Value& values) {
        if (values.isMember(kNIMAICallKeyStreamingMessageChunkContent))
            content_ = values[kNIMAICallKeyStreamingMessageChunkContent].asString();
        if (values.isMember(kNIMAICallKeyStreamingMessageChunkMessageTime))
            message_time_ = values[kNIMAICallKeyStreamingMessageChunkMessageTime].asInt64();
        if (values.isMember(kNIMAICallKeyStreamingMessageChunkChunkTime))
            chunk_time_ = values[kNIMAICallKeyStreamingMessageChunkChunkTime].asInt64();
        if (values.isMember(kNIMAICallKeyStreamingMessageChunkType))
            type_ = values[kNIMAICallKeyStreamingMessageChunkType].asInt();
        if (values.isMember(kNIMAICallKeyStreamingMessageChunkIndex))
            index_ = values[kNIMAICallKeyStreamingMessageChunkIndex].asUInt();
    }
};
 
using NIMStreamingMessageChunk = NIMAIStreamingMessageChunk;
 
struct NIM_SDK_CPPWRAPPER_DLL_API IMMessageAIConfig {
    std::string account_id_;
    NIMAIMessageStatus ai_status_{kNIMMessageAIStatusUnknown};
    bool streaming_{false};
    NIMAIStreamingMessageStatus streaming_message_status_{kNIMAIStreamingMessageNone};
    std::list<NIMAIMessageRAGInfo> rags_;
    NIMAIStreamingMessageChunk chunk_;
    void ToJsonValue(nim_cpp_wrapper_util::Json::Value& ai_config) const {
        ai_config[kNIMAICallKeyAccountID] = account_id_;
        ai_config[kNIMAICallKeyStatus] = ai_status_;
        ai_config[kNIMAICallKeyStreaming] = streaming_;
        ai_config[kNIMAICallKeyStreamingMessageStatus] = streaming_message_status_;
        for (const auto& rag : rags_) {
            nim_cpp_wrapper_util::Json::Value rag_info;
            rag.ToJsonValue(rag_info);
            ai_config[kNIMAICallKeyAIRAGs].append(rag_info);
        }
        nim_cpp_wrapper_util::Json::Value chunks_values;
        chunk_.ToJsonValue(chunks_values);
        if (!chunks_values.isNull())
            ai_config[kNIMAICallKeyStreamingMessageChunk] = chunks_values;
    }
    nim_cpp_wrapper_util::Json::Value ToJsonValue() const {
        nim_cpp_wrapper_util::Json::Value value;
        ToJsonValue(value);
        return value;
    }
    void ParseIMMessageAIConfig(const nim_cpp_wrapper_util::Json::Value& ai_config) {
        account_id_ = ai_config[kNIMAICallKeyAccountID].asString();
        ai_status_ = static_cast<NIMAIMessageStatus>(ai_config[kNIMAICallKeyStatus].asInt());
        streaming_ = ai_config[kNIMAICallKeyStreaming].asBool();
        streaming_message_status_ = static_cast<NIMAIStreamingMessageStatus>(ai_config[kNIMAICallKeyStreamingMessageStatus].asInt());
        if (ai_config.isMember(kNIMAICallKeyAIRAGs) && ai_config[kNIMAICallKeyAIRAGs].isArray()) {
            for (const auto& rag : ai_config[kNIMAICallKeyAIRAGs]) {
                NIMAIMessageRAGInfo rag_info;
                rag_info.FromJsonValue(rag);
                rags_.emplace_back(rag_info);
            }
        }
        if (ai_config.isMember(kNIMAICallKeyStreamingMessageChunk)) {
            chunk_.FromJsonValue(ai_config[kNIMAICallKeyStreamingMessageChunk]);
        }
    }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API IMMessageStreamingConfig {
    bool streaming_{false};
    NIMStreamingMessageStatus status_{kNIMAIStreamingMessageStreaming};
    NIMStreamingMessageChunk chunk_;
    void ToJsonValue(nim_cpp_wrapper_util::Json::Value& ai_config) const {
        ai_config[kNIMAICallKeyStreaming] = streaming_;
        ai_config[kNIMAICallKeyStreamingMessageStatus] = status_;
        nim_cpp_wrapper_util::Json::Value chunks_values;
        chunk_.ToJsonValue(chunks_values);
        if (!chunks_values.isNull())
            ai_config[kNIMAICallKeyStreamingMessageChunk] = chunks_values;
    }
    nim_cpp_wrapper_util::Json::Value ToJsonValue() const {
        nim_cpp_wrapper_util::Json::Value value;
        ToJsonValue(value);
        return value;
    }
    void ParseIMMessageStreamingConfig(const nim_cpp_wrapper_util::Json::Value& streaming_config) {
        streaming_ = streaming_config[kNIMAICallKeyStreaming].asBool();
        status_ = static_cast<NIMStreamingMessageStatus>(streaming_config[kNIMAICallKeyStreamingMessageStatus].asInt());
        if (streaming_config.isMember(kNIMAICallKeyStreamingMessageChunk))
            chunk_.FromJsonValue(streaming_config[kNIMAICallKeyStreamingMessageChunk]);
    }
};
 
using IMMessageAIConfigParam = NIMAIModelCallBase;
 
struct NIM_SDK_CPPWRAPPER_DLL_API IMMessageSendOption {
    IMMessageAIConfigParam ai_config_;
    void ToJsonValue(nim_cpp_wrapper_util::Json::Value& message_value) const {
        nim_cpp_wrapper_util::Json::Value ai_config;
        ai_config_.ToJsonValue(ai_config);
        message_value[kNIMMsgKeyAIConfig] = ai_config;
    }
    nim_cpp_wrapper_util::Json::Value ToJsonValue() const {
        nim_cpp_wrapper_util::Json::Value value;
        ToJsonValue(value);
        return value;
    }
};
 
using ReplyMessageOption = IMMessageSendOption;
 
struct NIM_SDK_CPPWRAPPER_DLL_API IMMessage {
    NIMResCode rescode_;
    NIMMessageFeature feature_;
    NIMSessionType session_type_;
    std::string receiver_accid_;
    std::string sender_accid_;
    int64_t timetag_;
    int64_t update_timetag_{0};
    std::string update_accid_;
    std::string content_;
    NIMMessageType type_;
    std::string attach_;
    std::string client_msg_id_;
    MessageSetting msg_setting_;
    std::string third_party_callback_ext_;
    int32_t sub_type_{0};
    std::string local_res_path_;
    std::string local_talk_id_;
    std::string local_res_id_;
    NIMMsgLogStatus status_;
    NIMMsgLogSubStatus sub_status_;
    IMMessageThreadInfo thread_info_;
    IMMessageRobotInfo robot_info_;
    IMMessageAIConfig ai_config_;
    IMMessageStreamingConfig streaming_config_;
    NIMClientType readonly_sender_client_type_;
    std::string readonly_sender_device_id_;
    std::string readonly_sender_nickname_;
    uint64_t readonly_server_id_;
 
    IMMessage()
        : rescode_((NIMResCode)0)
        , feature_(kNIMMessageFeatureDefault)
        , readonly_sender_client_type_(kNIMClientTypeDefault)
        , readonly_server_id_(0)
        , session_type_(kNIMSessionTypeP2P)
        , timetag_(0)
        , type_(kNIMMessageTypeUnknown)
        , status_(nim::kNIMMsgLogStatusNone)
        , sub_status_(nim::kNIMMsgLogSubStatusNone) {}
 
    IMMessage(const std::string& json_msg)
        : rescode_((NIMResCode)0)
        , feature_(kNIMMessageFeatureDefault)
        , readonly_sender_client_type_(kNIMClientTypeDefault)
        , readonly_server_id_(0)
        , session_type_(kNIMSessionTypeP2P)
        , timetag_(0)
        , type_(kNIMMessageTypeUnknown)
        , status_(nim::kNIMMsgLogStatusNone)
        , sub_status_(nim::kNIMMsgLogSubStatusNone) {
        nim_cpp_wrapper_util::Json::Value values;
        if (nim::ParseJsonValue(json_msg, values) && values.isObject()) {
            session_type_ = (NIMSessionType)values[kNIMMsgKeyToType].asUInt();
            receiver_accid_ = values[kNIMMsgKeyToAccount].asString();
            sender_accid_ = values[kNIMMsgKeyFromAccount].asString();
            readonly_sender_client_type_ = (NIMClientType)values[kNIMMsgKeyFromClientType].asUInt();
            readonly_sender_device_id_ = values[kNIMMsgKeyFromDeviceId].asString();
            readonly_sender_nickname_ = values[kNIMMsgKeyFromNick].asString();
            timetag_ = values[kNIMMsgKeyTime].asUInt64();
            update_timetag_ = values[kNIMMsgKeyUpdateTime].asUInt64();
            update_accid_ = values[kNIMMsgKeyUpdateAccountID].asString();
            type_ = (NIMMessageType)values[kNIMMsgKeyType].asUInt();
            content_ = values[kNIMMsgKeyBody].asString();
            attach_ = values[kNIMMsgKeyAttach].asString();
            client_msg_id_ = values[kNIMMsgKeyClientMsgid].asString();
            readonly_server_id_ = values[kNIMMsgKeyServerMsgid].asUInt64();
            local_res_path_ = values[kNIMMsgKeyLocalFilePath].asString();
            local_talk_id_ = values[kNIMMsgKeyLocalTalkId].asString();
            local_res_id_ = values[kNIMMsgKeyLocalResId].asString();
            status_ = (NIMMsgLogStatus)values[kNIMMsgKeyLocalLogStatus].asUInt();
            sub_status_ = (NIMMsgLogSubStatus)values[kNIMMsgKeyLocalLogSubStatus].asUInt();
            msg_setting_.ParseMessageSetting(values);
            // v7.8 <--
            third_party_callback_ext_ = values[kNIMMsgKeyThirdPartyCBEXT].asString();
            sub_type_ = values[kNIMMsgKeySubType].asInt();
            // --> v7.8
            if (values.isMember(kNIMMsgKeyThreadInfo)) {
                thread_info_.reply_msg_from_account_ = values[kNIMMsgKeyThreadInfo][kNIMMsgKeyReplyMsgFromAccount].asString();
                thread_info_.reply_msg_to_account_ = values[kNIMMsgKeyThreadInfo][kNIMMsgKeyReplyMsgToAccount].asString();
                thread_info_.reply_msg_time_ = values[kNIMMsgKeyThreadInfo][kNIMMsgKeyReplyMsgTime].asUInt64();
                thread_info_.reply_msg_id_server_ = values[kNIMMsgKeyThreadInfo][kNIMMsgKeyReplyMsgIdServer].asUInt64();
                thread_info_.reply_msg_id_client_ = values[kNIMMsgKeyThreadInfo][kNIMMsgKeyReplyMsgIdClient].asString();
                thread_info_.thread_msg_from_account_ = values[kNIMMsgKeyThreadInfo][kNIMMsgKeyThreadMsgFromAccount].asString();
                thread_info_.thread_msg_to_account_ = values[kNIMMsgKeyThreadInfo][kNIMMsgKeyThreadMsgToAccount].asString();
                thread_info_.thread_msg_time_ = values[kNIMMsgKeyThreadInfo][kNIMMsgKeyThreadMsgTime].asUInt64();
                thread_info_.thread_msg_id_server_ = values[kNIMMsgKeyThreadInfo][kNIMMsgKeyThreadMsgIdServer].asUInt64();
                thread_info_.thread_msg_id_client_ = values[kNIMMsgKeyThreadInfo][kNIMMsgKeyThreadMsgIdClient].asString();
                thread_info_.deleted_ = values[kNIMMsgKeyThreadInfo][kNIMMsgKeyDeleted].asInt();
            }
            if (values.isMember(kNIMMsgKeyRobotInfo)) {
                robot_info_.function_ = values[kNIMMsgKeyRobotInfo][kNIMMsgKeyRobotFunction].asString();
                robot_info_.topic_ = values[kNIMMsgKeyRobotInfo][kNIMMsgKeyRobotTopic].asString();
                robot_info_.custom_content_ = values[kNIMMsgKeyRobotInfo][kNIMMsgKeyRobotCustomContent].asString();
                robot_info_.account_ = values[kNIMMsgKeyRobotInfo][kNIMMsgKeyRobotAccount].asString();
            }
            if (values.isMember(kNIMMsgKeyAIConfig) && values[kNIMMsgKeyAIConfig].isObject()) {
                ai_config_.ParseIMMessageAIConfig(values[kNIMMsgKeyAIConfig]);
            }
            if (values.isMember(kNIMMsgKeyStreamingConfig) && values[kNIMMsgKeyStreamingConfig].isObject()) {
                streaming_config_.ParseIMMessageStreamingConfig(values[kNIMMsgKeyStreamingConfig]);
            }
        }
    }
 
    nim_cpp_wrapper_util::Json::Value ToJsonObject(bool use_to_send) const {
        nim_cpp_wrapper_util::Json::Value values;
        values[kNIMMsgKeyLocalRescode] = rescode_;
        values[kNIMMsgKeyToType] = session_type_;
        values[kNIMMsgKeyToAccount] = receiver_accid_;
        values[kNIMMsgKeyFromAccount] = sender_accid_;
        values[kNIMMsgKeyTime] = timetag_;
        values[kNIMMsgKeyType] = type_;
        values[kNIMMsgKeyUpdateTime] = update_timetag_;
        values[kNIMMsgKeyUpdateAccountID] = update_accid_;
        values[kNIMMsgKeyBody] = content_;
        values[kNIMMsgKeyAttach] = attach_;
        values[kNIMMsgKeyClientMsgid] = client_msg_id_;
        values[kNIMMsgKeyLocalFilePath] = local_res_path_;
        values[kNIMMsgKeyLocalTalkId] = local_talk_id_;
        values[kNIMMsgKeyLocalResId] = local_res_id_;
        values[kNIMMsgKeyLocalLogStatus] = status_;
        values[kNIMMsgKeyLocalLogSubStatus] = sub_status_;
        values[kNIMMsgKeySubType] = sub_type_;
        msg_setting_.ToJsonValue(values);
        if (!use_to_send) {
            values[kNIMMsgKeyFromClientType] = readonly_sender_client_type_;
            values[kNIMMsgKeyFromDeviceId] = readonly_sender_device_id_;
            values[kNIMMsgKeyFromNick] = readonly_sender_nickname_;
            values[kNIMMsgKeyServerMsgid] = readonly_server_id_;
            values[kNIMMsgKeyThirdPartyCBEXT] = third_party_callback_ext_;
        }
        values[kNIMMsgKeyThreadInfo][kNIMMsgKeyReplyMsgFromAccount] = thread_info_.reply_msg_from_account_;
        values[kNIMMsgKeyThreadInfo][kNIMMsgKeyReplyMsgToAccount] = thread_info_.reply_msg_to_account_;
        values[kNIMMsgKeyThreadInfo][kNIMMsgKeyReplyMsgTime] = thread_info_.reply_msg_time_;
        values[kNIMMsgKeyThreadInfo][kNIMMsgKeyReplyMsgIdServer] = thread_info_.reply_msg_id_server_;
        values[kNIMMsgKeyThreadInfo][kNIMMsgKeyReplyMsgIdClient] = thread_info_.reply_msg_id_client_;
        values[kNIMMsgKeyThreadInfo][kNIMMsgKeyThreadMsgFromAccount] = thread_info_.thread_msg_from_account_;
        values[kNIMMsgKeyThreadInfo][kNIMMsgKeyThreadMsgToAccount] = thread_info_.thread_msg_to_account_;
        values[kNIMMsgKeyThreadInfo][kNIMMsgKeyThreadMsgTime] = thread_info_.thread_msg_time_;
        values[kNIMMsgKeyThreadInfo][kNIMMsgKeyThreadMsgIdServer] = thread_info_.thread_msg_id_server_;
        values[kNIMMsgKeyThreadInfo][kNIMMsgKeyThreadMsgIdClient] = thread_info_.thread_msg_id_client_;
        values[kNIMMsgKeyThreadInfo][kNIMMsgKeyDeleted] = thread_info_.deleted_;
        values[kNIMMsgKeyRobotInfo][kNIMMsgKeyRobotFunction] = robot_info_.function_;
        values[kNIMMsgKeyRobotInfo][kNIMMsgKeyRobotTopic] = robot_info_.topic_;
        values[kNIMMsgKeyRobotInfo][kNIMMsgKeyRobotCustomContent] = robot_info_.custom_content_;
        values[kNIMMsgKeyRobotInfo][kNIMMsgKeyRobotAccount] = robot_info_.account_;
        if (!ai_config_.account_id_.empty()) {
            nim_cpp_wrapper_util::Json::Value ai_config = ai_config_.ToJsonValue();
            values[kNIMMsgKeyAIConfig] = ai_config;
        }
        values[kNIMMsgKeyStreamingConfig] = streaming_config_.ToJsonValue();
        return values;
    }
 
    std::string ToJsonString(bool use_to_send) const {
        nim_cpp_wrapper_util::Json::Value values = ToJsonObject(use_to_send);
        return GetJsonStringWithNoStyled(values);
    }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API IMFile {
    std::string md5_;
    int64_t size_;
    std::string url_;
    std::string display_name_;
    std::string file_extension_;
    std::string msg_attachment_tag_;
    IMFile()
        : size_(0)
        , msg_attachment_tag_(kNIMNosDefaultTagIM) {}
 
    std::string ToJsonString(nim_cpp_wrapper_util::Json::Value& attach) const {
        // 以下客户端可以选填
        if (!display_name_.empty())
            attach[kNIMFileMsgKeyDisplayName] = display_name_;
        if (!file_extension_.empty())
            attach[kNIMFileMsgKeyExt] = file_extension_;
        if (!md5_.empty())
            attach[kNIMFileMsgKeyMd5] = md5_;
        if (size_ > 0)
            attach[kNIMFileMsgKeySize] = size_;
        if (!url_.empty())
            attach[kNIMMsgAttachKeyUrl] = url_;
        if (!msg_attachment_tag_.empty())
            attach[kNIMMsgAttachKeyTag] = msg_attachment_tag_;
        return GetJsonStringWithNoStyled(attach);
    }
 
    std::string ToJsonString() const {
        nim_cpp_wrapper_util::Json::Value attach;
        attach[kNIMFileMsgKeyDisplayName] = display_name_;
        return ToJsonString(attach);
    }
 
    bool operator==(const IMFile& rhs) const {
        return md5_ == rhs.md5_ && size_ == rhs.size_ && url_ == rhs.url_ && display_name_ == rhs.display_name_ &&
               file_extension_ == rhs.file_extension_ && msg_attachment_tag_ == rhs.msg_attachment_tag_;
    }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API IMImage : IMFile {
    int width_;
    int height_;
 
    IMImage()
        : width_(0)
        , height_(0) {}
 
    std::string ToJsonString() const {
        nim_cpp_wrapper_util::Json::Value attach;
        attach[kNIMImgMsgKeyWidth] = width_;
        attach[kNIMImgMsgKeyHeight] = height_;
 
        return IMFile::ToJsonString(attach);  // remove the Visual C++ __super keyword.
    }
 
    bool operator==(const IMImage& rhs) const { return IMFile::operator==(rhs) && width_ == rhs.width_ && height_ == rhs.height_; }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API IMLocation {
    std::string description_;
    double latitude_;
    double longitude_;
 
    IMLocation()
        : latitude_(0)
        , longitude_(0) {}
 
    std::string ToJsonString() const {
        nim_cpp_wrapper_util::Json::Value attach;
        attach[kNIMLocationMsgKeyTitle] = description_;
        attach[kNIMLocationMsgKeyLatitude] = latitude_;
        attach[kNIMLocationMsgKeyLongitude] = longitude_;
 
        return GetJsonStringWithNoStyled(attach);
    }
 
    bool operator==(const IMLocation& rhs) const {
        return description_ == rhs.description_ && latitude_ == rhs.latitude_ && longitude_ == rhs.longitude_;
    }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API IMAudio : IMFile {
    int duration_;
 
    IMAudio()
        : duration_(0) {}
 
    std::string ToJsonString() const {
        nim_cpp_wrapper_util::Json::Value attach;
        attach[kNIMAudioMsgKeyDuration] = duration_;
 
        return IMFile::ToJsonString(attach);  // remove the Visual C++ __super keyword.
    }
 
    bool operator==(const IMAudio& rhs) const { return IMFile::operator==(rhs) && duration_ == rhs.duration_; }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API IMVideo : IMFile {
    int duration_;
    int width_;
    int height_;
 
    IMVideo()
        : duration_(0)
        , width_(0)
        , height_(0) {}
 
    std::string ToJsonString() const {
        nim_cpp_wrapper_util::Json::Value attach;
        attach[kNIMVideoMsgKeyWidth] = width_;
        attach[kNIMVideoMsgKeyHeight] = height_;
        attach[kNIMVideoMsgKeyDuration] = duration_;
 
        return IMFile::ToJsonString(attach);  // remove the Visual C++ __super keyword.
    }
 
    bool operator==(const IMVideo& rhs) const {
        return IMFile::operator==(rhs) && duration_ == rhs.duration_ && width_ == rhs.width_ && height_ == rhs.height_;
    }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API IMBotRobot {
    bool out_msg_;
    std::string robot_accid_;
    nim_cpp_wrapper_util::Json::Value sent_param_;
 
    std::string related_msg_id_;
    std::string robot_msg_flag_;
    nim_cpp_wrapper_util::Json::Value robot_msg_content_;
 
    IMBotRobot()
        : out_msg_(false) {}
 
    std::string ToJsonString() const {
        nim_cpp_wrapper_util::Json::Value attach;
        attach[kNIMBotRobotMsgKeyRobotID] = robot_accid_;
        attach[kNIMBotRobotSentMsgKeyParam] = sent_param_;
        attach[kNIMBotRobotReceivedMsgKeyMsgOut] = out_msg_;
        attach[kNIMBotRobotReceivedMsgKeyClientMsgID] = related_msg_id_;
        attach[kNIMBotRobotReceivedMsgKeyRobotMsgFlag] = robot_msg_flag_;
        attach[kNIMBotRobotReceivedMsgKeyRobotMsgMessage] = robot_msg_content_;
 
        return GetJsonStringWithNoStyled(attach);
    }
 
    bool operator==(const IMBotRobot& rhs) const {
        return out_msg_ == rhs.out_msg_ && robot_accid_ == rhs.robot_accid_ && sent_param_ == rhs.sent_param_ &&
               related_msg_id_ == rhs.related_msg_id_ && robot_msg_flag_ == rhs.robot_msg_flag_ && robot_msg_content_ == rhs.robot_msg_content_;
    }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API BroadcastMessage {
    std::string body_;
    int64_t time_;
    int64_t id_;
    std::string from_id_;
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API StopStreamingMessageParam {
    NIMStopStreamingMessageOptType operation_type_{kNIMStopStreamingMessageOptTypeDefault};
    std::string update_content_;
    std::string ToJsonString() const {
        nim_cpp_wrapper_util::Json::Value values;
        values[kNIMStopStreamingMessageOptType] = operation_type_;
        if (operation_type_ == kNIMStopStreamingMessageOptTypeUpdate) {
            values[kNIMStopStreamingMessageUpdateContent] = update_content_;
        }
        return GetJsonStringWithNoStyled(values);
    }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API RedoAIMessageParam {
    NIMRedoAIMessageOptType operation_type_{kNIMRedoAIMessageOptTypeUpdate};
    std::string ToJsonString() const {
        nim_cpp_wrapper_util::Json::Value values;
        values[kNIMStopStreamingMessageOptType] = operation_type_;
        return GetJsonStringWithNoStyled(values);
    }
};
 
NIM_SDK_CPPWRAPPER_DLL_API bool ParseMessage(const std::string& msg_json, IMMessage& message);
 
NIM_SDK_CPPWRAPPER_DLL_API bool ParseReceiveMessage(const std::string& msg_json, IMMessage& message);
 
NIM_SDK_CPPWRAPPER_DLL_API void ParseReceiveMessage(const nim_cpp_wrapper_util::Json::Value& msg_json_value, IMMessage& message);
 
NIM_SDK_CPPWRAPPER_DLL_API void ParseMessage(const nim_cpp_wrapper_util::Json::Value& msg_json, IMMessage& message);
 
}  // namespace nim
 
#endif  //_NIM_SDK_CPP_TALK_HELPER_H_