nim_talk_helper.h

Go to the documentation of this file.

 
#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_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 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)
        , need_offline_(BS_NOT_INIT)
        , is_force_push_(BS_NOT_INIT)
        , anti_spam_enable_(BS_NOT_INIT)
        , anti_apam_biz_id_("")
        , 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)
        , yidun_anti_cheating_("")
        , env_config_("") {}
 
    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 (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_;
    }
 
    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(kNIMMsgKeySetMsgOffline))
            need_offline_ = message[kNIMMsgKeySetMsgOffline].asInt() == 1 ? BS_TRUE : BS_FALSE;
        if (message.isMember(kNIMMsgKeyServerExt) && !message[kNIMMsgKeyServerExt].asString().empty())
            if ((!nim::ParseJsonValue(message[kNIMMsgKeyServerExt].asString(), server_ext_) || !server_ext_.isObject())) {
            } else {
            }
        if (message.isMember(kNIMMsgKeyPushPayload) && !message[kNIMMsgKeyPushPayload].asString().empty())
            if (!nim::ParseJsonValue(message[kNIMMsgKeyPushPayload].asString(), push_payload_) || !push_payload_.isObject()) {
            }
        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[kNIMMsgKeyTeamMsgAck].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_;
    uint64_t reply_msg_id_server_;
    std::string reply_msg_id_client_;
 
    std::string thread_msg_from_account_;
    std::string thread_msg_to_account_;
    uint64_t thread_msg_time_;
    uint64_t thread_msg_id_server_;
    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 IMMessage {
public:
    NIMResCode rescode_;
    NIMMessageFeature feature_;
 
public:
    NIMSessionType session_type_;
    std::string receiver_accid_;
    std::string sender_accid_;
    int64_t timetag_;
    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};
 
public:
    std::string local_res_path_;
    std::string local_talk_id_;
    std::string local_res_id_;
    NIMMsgLogStatus status_;
    NIMMsgLogSubStatus sub_status_;
 
public:
    IMMessageThreadInfo thread_info_;
 
public:
    NIMClientType readonly_sender_client_type_;
    std::string readonly_sender_device_id_;
    std::string readonly_sender_nickname_;
    int64_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();
 
            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
        }
    }
 
    nim_cpp_wrapper_util::Json::Value ToJsonObject(bool use_to_send) const {
        nim_cpp_wrapper_util::Json::Value values;
        values[kNIMMsgKeyToType] = session_type_;
        values[kNIMMsgKeyToAccount] = receiver_accid_;
        values[kNIMMsgKeyFromAccount] = sender_accid_;
        values[kNIMMsgKeyTime] = timetag_;
        values[kNIMMsgKeyType] = type_;
        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_;
        }
        // thread
        {
            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_;
        }
        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);
    }
};
 
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.
    }
};
 
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);
    }
};
 
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.
    }
};
 
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.
    }
};
 
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_;
 
        return GetJsonStringWithNoStyled(attach);
    }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API BroadcastMessage {
    std::string body_;
    int64_t time_;
    int64_t id_;
    std::string from_id_;
};
 
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_