C++void OnMultiportPushConfigChange(int rescode, bool switch_on)
{
	if (rescode == nim::kNIMResSuccess)
	{
		···
	}
}

void OnInit()
{
	//登录前注册的全局回调获取当前多端推送开关状态
	nim::Client::RegSyncMultiportPushConfigCb(&OnMultiportPushConfigChange);
}

void SetMultiportConfig(bool switch_on)
{
	//当PC/Web端在线时，可以配置消息是否推送给移动端
	nim::Client::SetMultiportPushConfigAsync(switch_on, &OnMultiportPushConfigChange);
}

void GetMultiportConfig()
{
	//主动获取当前多端推送开关状态
	nim::Client::GetMultiportPushConfigAsync(&OnMultiportPushConfigChange);
}

C#public delegate void ConfigMultiportPushDelegate(ResponseCode response,ConfigMultiportPushParam param)
{
		if (response == ResponseCode.kNIMResSuccess)
	{
		···
	｝
}

/// <summary>
/// 开启多端推送
/// </summary>
/// <param name="cb">操作结果委托</param>
public static void EnableMultiportPush(ConfigMultiportPushDelegate cb)
{
	ConfigMultiportPushParam param = new ConfigMultiportPushParam();
	param.Enabled = true;
	var ptr = DelegateConverter.ConvertToIntPtr(cb);
	ClientNativeMethods.nim_client_set_multiport_push_config(param.Serialize(), null, ConfigMultiportPushCb, ptr);
}

/// <summary>
/// 禁止多端推送
/// </summary>
/// <param name="cb">操作结果委托</param>
public static void DisableMultiportPush(ConfigMultiportPushDelegate cb)
{
	ConfigMultiportPushParam param = new ConfigMultiportPushParam();
	param.Enabled = false;
	var ptr = DelegateConverter.ConvertToIntPtr(cb);
	ClientNativeMethods.nim_client_set_multiport_push_config(param.Serialize(), null, ConfigMultiportPushCb, ptr);
}

/// <summary>
/// 获取多端推送控制开关
/// </summary>
/// <param name="cb"></param>
public static void IsMultiportPushEnabled(ConfigMultiportPushDelegate cb)
{
	var ptr = DelegateConverter.ConvertToIntPtr(cb);
	ClientNativeMethods.nim_client_get_multiport_push_config(null, ConfigMultiportPushCb, ptr);
}

/// <summary>
/// 注册多端推送设置同步回调
/// </summary>
/// <param name="cb"></param>
public static void RegMulitiportPushEnableChangedCb(ConfigMultiportPushDelegate cb)
{
	var ptr = DelegateConverter.ConvertToIntPtr(cb);
	ClientNativeMethods.nim_client_reg_sync_multiport_push_config_cb(null, OnMultiportPushEnableChanged, ptr);
}

Cstatic void CallbackMultiportPushConfig(int rescode, const char *content, const char *json_extension, const void *user_data)
{
	Json::Value values;
	Json::Reader reader;
	if (rescode == nim::kNIMResSuccess && reader.parse(content, values) && values.isObject())
	{
		bool open = values[kNIMMultiportPushConfigContentKeyOpen].asInt() == 1;
		···
	}
}

typedef void(*nim_client_reg_sync_multiport_push_config_cb)(const char *json_extension, nim_client_multiport_push_config_cb_func cb, const void *user_data);
typedef void(*nim_client_set_multiport_push_config)(const char *switch_content, const char *json_extension, nim_client_multiport_push_config_cb_func cb, const void *user_data);
typedef void(*nim_client_get_multiport_push_config)(const char *json_extension, nim_client_multiport_push_config_cb_func cb, const void *user_data);

void OnInit()
{
	//登录前注册的全局回调获取当前多端推送开关状态
	nim_client_reg_sync_multiport_push_config_cb func = (nim_client_reg_sync_multiport_push_config_cb) GetProcAddress(hInst, "nim_client_reg_sync_multiport_push_config_cb");
	func("", &CallbackMultiportPushConfig, nullptr);
}

void SetMultiportConfig(bool switch_on)
{
	//当PC/Web端在线时，可以配置消息是否推送给移动端
	nim_client_set_multiport_push_config func = (nim_client_set_multiport_push_config) GetProcAddress(hInst, "nim_client_set_multiport_push_config");
	func(switch_on, "", &CallbackMultiportPushConfig, nullptr);
}

void GetMultiportConfig()
{
	//主动获取当前多端推送开关状态
	nim_client_get_multiport_push_config func = (nim_client_get_multiport_push_config) GetProcAddress(hInst, "nim_client_get_multiport_push_config");
	func("", &CallbackMultiportPushConfig, nullptr);
}

接收在线消息的回调函数：

static void RegReceiveCb (const ReceiveMsgCallback &cb, const std::string &json_extension="")

离线、同步消息的回调函数：

static void RegReceiveMessagesCb (const ReceiveMsgsCallback &cb, const std::string &json_extension="")

File:nim_cpp_talk.h

Namespace:NIM

Class：Talk

接收在线消息的回调函数：

static EventHandler< NIMReceiveMessageEventArgs> OnReceiveMessageHandler [get, set]

离线、同步消息的回调函数：

static void RegReceiveBatchMessagesCb (ReceiveBatchMesaagesDelegate cb)

Namespace:NIM

Class：TalkAPI

接收在线消息的回调函数：

NIM_SDK_DLL_API void nim_talk_reg_receive_cb (const char *json_extension, nim_talk_receive_cb_func cb, const void *user_data)

离线、同步消息的回调函数：

NIM_SDK_DLL_API void nim_talk_reg_receiv_msgs_cb (const char *json_extension, nim_talk_receive_cb_func cb, const void *user_data)

File:nim_talk.h

C++void OnReceiveMsgCallback(const nim::IMMessage& message)
{
	std::string id = GetSessionId(message);

	if (message.feature_ == nim::kNIMMessageFeatureDefault)
	{
		···
	}
	else if (message.feature_ == nim::kNIMMessageFeatureSyncMsg || message.feature_ == nim::kNIMMessageFeatureRoamMsg)
	{
		···
	}
	else if (message.feature_ == nim::kNIMMessageFeatureCustomizedMsg)
	{
		···
	}
}

void foo()
{
	nim::Talk::RegReceiveCb(&OnReceiveMsgCallback);
}

C#void OnReceiveMessage(object sender, NIM.NIMReceiveMessageEventArgs args)
{
	if (args.Message.MessageContent.SessionType == NIM.Session.NIMSessionType.kNIMSessionTypeP2P && args.Message.MessageContent.SenderID != _peerId)
		return;
	if (args.Message.MessageContent.SessionType == NIM.Session.NIMSessionType.kNIMSessionTypeTeam && args.Message.MessageContent.ReceiverID != _peerId)
		return;
	//处理自定义消息
	if (args.Message != null && args.Message.MessageContent.MessageType == NIMMessageType.kNIMMessageTypeCustom)
	{
		···
	}
	if (args.Message != null && args.Message.MessageContent.MessageType == NIM.NIMMessageType.kNIMMessageTypeText)
	{
		···
	}
}

private void foo()
{
	NIM.TalkAPI.OnReceiveMessageHandler += OnReceiveMessage;
}

Cvoid CallbackReceiveMsg(const char* msg, const char *json_exten, const void *user_data)
{
	Json::Value value;
	Json::Reader reader;
	if (reader.parse(msg, value))
	{
		int rescode = value[nim::kNIMMsgKeyLocalRescode].asInt();
		int feature = value[nim::kNIMMsgKeyLocalMsgFeature].asInt();

		switch (feature)
		{
		case kNIMMessageFeatureDefault:
			...
		case kNIMMessageFeatureSyncMsg:
			...
		...
		}
	}
}

typedef void(*nim_talk_reg_receive_cb)(const char *json_extension, nim_talk_receive_cb_func cb, const void* user_data);

void foo()
{
	nim_talk_reg_receive_cb func = (nim_talk_reg_receive_cb) GetProcAddress(hInst, "nim_talk_reg_receive_cb");
	func(nullptr, &CallbackReceiveMsg, nullptr);
}

接收在线广播消息的回调：

RegReceiveBroadcastMsgCb

离线、同步广播消息的回调：

RegReceiveBroadcastMsgsCb

接收在线广播消息的回调：

RegReceiveBroadcastCb

离线、同步广播消息的回调：

RegReceiveBroadcastMsgsCb

接收在线广播消息的回调：

nim_talk_reg_receive_broadcast_cb

离线、同步广播消息的回调：

nim_talk_reg_receive_broadcast_msgs_cb

C++Talk::RegReceiveBroadcastMsgCb([this](const BroadcastMessage& msg) {
	// process msg
	// ...
});

Talk::RegReceiveBroadcastMsgsCb([this](const std::list<BroadcastMessage>& msgs) {
	// process msgs
	// ...
});

C#private void foo()
{
	NIM.TalkAPI.RegReceiveBroadcastCb((List<NIMBroadcastMessage> msg) => {
		// process message
		// ...
	});
}

Cvoid CallbackReceiveBroadCastMsg(const char* msg, const char *json_exten, const void *user_data)
{
    // process msg
    // ...
}

typedef void(*nim_talk_reg_receive_broadcast_cb)(const char *json_extension, nim_talk_receive_broadcast_cb_func cb, const void* user_data);

void foo()
{
	nim_talk_reg_receive_broadcast_cb func = (nim_talk_reg_receive_broadcast_cb)GetProcAddress(hInst, "nim_talk_reg_receive_broadcast_cb");
	func(nullptr, &CallbackReceiveBroadCastMsg, nullptr);
}

/** @fn static std::string CreateRetweetMessage(const std::string& src_msg_json , const std::string& client_msg_id , const NIMSessionType retweet_to_session_type , const std::string& retweet_to_session_id , const MessageSetting& msg_setting , int64_t timetag = 0)

• 由其他消息生成转发消息
• @param[in] src_msg_json 原消息json
• @param[in] client_msg_id 新的客户端消息id,建议uuid
• @param[in] retweet_to_session_type 转发目标会话类型 NIMSessionType
• @param[in] retweet_to_session_id 转发目标ID
• @param[in] msg_setting 消息属性设置
• @param[in] timetag 消息时间
• @return std::string 位置消息Json字符串 */ static std::string CreateRetweetMessage (const std::string &src_msg_json, const std::string &client_msg_id, const NIMSessionType retweet_to_session_type, const std::string &retweet_to_session_id, const MessageSetting &msg_setting, int64_t timetag=0)

Define: NIMSessionType ; MessageSetting

File:nim_cpp_talk.h

Namespace:NIM

Class：Talk

/** @fn

• 由其他消息生成转发消息
• @param[in] srcMsg 原始消息对象
• @param[in] msgSetting 新的消息属性
• @param[in] msgId 新的客户端消息id,建议uuid
• @param[in] sessionId 转发目标
• @param[in] sessionType 转发目标会话类型
• @param[in] timetag 消息时间
• @return 新的消息对象 */ static NIMIMMessage CreateRetweetMessage (NIMIMMessage srcMsg, NIMMessageSetting msgSetting, string msgId, string sessionId, Session.NIMSessionType sessionType, long timetag)

Define: NIMIMMessage ; NIMMessageSetting ; NIMSessionType

Namespace:NIM

Class：TalkAPI

/** @fn char nim_talk_create_retweet_msg(const char src_msg_json, const char* client_msg_id, enum NIMSessionType retweet_to_session_type, const char* retweet_to_session_id, const char* msg_setting, int64_t timetag)

• 由其他消息生成转发消息
• @param[in] src_msg_json 原消息json
• @param[in] client_msg_id 新的客户端消息id,建议uuid
• @param[in] retweet_to_session_type 转发目标会话类型 NIMSessionType
• @param[in] retweet_to_session_id 转发目标ID
• @param[in] msg_setting 消息属性设置
• @param[in] timetag 消息时间
• @return char * 位置消息Json字符串,需要上层调用nim_global.h提供的内存释放接口释放。 / NIM_SDK_DLL_API char nim_talk_create_retweet_msg(const char src_msg_json, const char client_msg_id, enum NIMSessionType retweet_to_session_type, const char* retweet_to_session_id, const char* msg_setting, int64_t timetag);

Define: NIMSessionType

File:nim_talk.h

C++void foo(nim::IMMessage msg)
{
	std::string send_msg = nim::Talk::CreateRetweetMessage(msg.ToJsonString(false), QString::GetGUID(), nim::kNIMSessionTypeP2P, session_id, msg.msg_setting_, 1000 * nbase::Time::Now().ToTimeT());
	nim::Talk::SendMsg(send_msg);
}

C#void foo(NIMImageMessage msg)
{
	NIM.NIMMessageSetting setting = new NIMMessageSetting();
	NIMImageMessage send_msg = TalkAPI.CreateRetweetMessage(msg, setting, NimUtility.Utilities.GenerateGuid(), session_id, NIM.Session.NIMSessionType.kNIMSessionTypeP2P, 0);
	TalkAPI.SendMessage(send_msg);  
}

Ctypedef char*(*nim_talk_create_retweet_msg)(const char* src_msg_json, const char* client_msg_id, const NIMSessionType retweet_to_session_type, const char* retweet_to_session_id, const char* msg_setting, __int64 timetag);
typedef	void (*nim_global_free_buf)(void *data);

void foo(const char *src_msg_json, const char *msg_id, NIMSessionType session_type, const char *session_id, const char* msg_sessiong_json, __int64 timetag)
{
	nim_talk_create_retweet_msg func = (nim_talk_create_retweet_msg) GetProcAddress(hInst, "nim_talk_create_retweet_msg");
	nim_global_free_buf free_func = (nim_global_free_buf) GetProcAddress(hInst, "nim_global_free_buf");

	const char *msg = func(src_msg_json, msg_id, session_type, session_id, msg_sessiong_json, timetag);
	free_func((void *)msg);
}

主动撤回消息接口：

static void RecallMsg (const IMMessage &msg, const std::string &notify, const RecallMsgsCallback &cb, const std::string &json_extension="")

注册撤回消息通知：

static void RegRecallMsgsCallback (const RecallMsgsCallback &cb, const std::string &json_extension="")

File:nim_cpp_talk.h

Namespace:NIM

Class：Talk

主动撤回消息接口：

static void RecallMessage (string msgId, string notify, RecallMessageDelegate cb)

注册撤回消息通知：

static void RegRecallMessageCallback (RecallMessageDelegate cb)

Namespace:NIM

Class：TalkAPI

C++void OnReceiveRecallMsgCallback(nim::NIMResCode code, const std::list<nim::RecallMsgNotify>& message)
{
	for (auto notify : message)
	{
		if (code == nim::kNIMResSuccess)
		{
			···
		}
	}
}

void OnInit()
{
	nim::Talk::RegRecallMsgsCallback(&OnReceiveRecallMsgCallback);
}

void foo(const nim::IMMessage& msg)
{
	nim::Talk::RecallMsg(msg, "test notify when recall", &OnReceiveRecallMsgCallback);
}

C#private void OnRecallMessage(ResponseCode result, RecallNotification[] notify)
{
	···
}

void OnInit()
{
	NIM.TalkAPI.RegRecallMessageCallback(OnRecallMessage);
}

private void OnRecallMessageCompleted(ResponseCode result, RecallNotification[] notify)
{
	···
}

void foo(string msg_id)
{
	NIM.TalkAPI.RecallMessage(msg_id, "撤回消息", OnRecallMessageCompleted);
}

Cvoid nim_talk_recall_msg(const char *json_msg, const char *notify, const char *json_extension, nim_talk_recall_msg_func cb, const void *user_data);

void nim_talk_reg_recall_msg_cb(const char *json_extension, nim_talk_recall_msg_func cb, const void *user_data);

void OnInit()
{
	nim_talk_reg_recall_msg_cb func = (nim_talk_reg_recall_msg_cb) GetProcAddress(hInst, "nim_talk_reg_recall_msg_cb");

	func("", &OnReceiveRecallMsgCallback, nullptr);
}

void foo(const nim::IMMessage& msg)
{
	nim_talk_recall_msg func = (nim_talk_recall_msg) GetProcAddress(hInst, "nim_talk_recall_msg");

	func(msg, "test notify when recall", "", &OnReceiveRecallMsgCallback, nullptr);
}

• P2P消息已读回执

  发送已读回执：

  static void SendReceiptAsync (const std::string &json_msg, const MessageStatusChangedCallback &cb)

  注册消息已读通知：

  static void RegMessageStatusChangedCb (const MessageStatusChangedCallback &cb, const std::string &json_extension="")

  查询消息是否已读：

  static bool QuerySentMessageBeReaded (const IMMessage &msg)

  File:nim_cpp_msglog.h

  Namespace:NIM

  Class：MsgLog

• 群消息已读回执

  发送已读回执：

  static void TeamMsgAckRead(const std::string& tid, const std::list& msgs, const TeamEventCallback& cb, const std::string& json_extension = "");

  群消息已读回执通知：

  static void RegTeamEventCb(const TeamEventCallback& cb, const std::string& json_extension = "");

  通知ID：

  kNIMNotificationIdLocalGetTeamMsgUnreadCount = 2010, /**< 获取群消息未读数 {[{"client_msg_id":"", "count":int, "read_accid":"当前已读成员的accid"},...]}*/

  kNIMNotificationIdLocalGetTeamMsgUnreadList = 2011, /**< 获取群消息未读列表 {"client_msg_id":"", "read":["id1",...], "unread":["id2",...]}*/

  获取群消息已读信息（未读已读Accid列表）：

  static void TeamMsgQueryUnreadList(const std::string& tid, const IMMessage& msg, const TeamEventCallback& cb, const std::string& json_extension = "");

  File:nim_cpp_team.h

  Namespace:NIM

  Class：Team

发送已读回执：

static void SendReceipt (NIMIMMessage msg, MsglogStatusChangedDelegate cb, string jsonExtension=null)

注册消息已读通知：

static void RegMsglogStatusChangedCb (MsglogStatusChangedDelegate cb)

查询消息是否已读：

static bool IsMessageBeReaded (NIMIMMessage msg, string jsonExtension=null)

Namespace:NIM

Class：MessagelogAPI

• P2P消息已读回执

  C++//发送已读回执
  void foo(nim::IMMessage msg)
  {
  	nim::MsgLog::SendReceiptAsync(msg.ToJsonString(false), [](const nim::MessageStatusChangedResult& res) {
  	auto iter = res.results_.begin();	
  	});
  }
  
  //查询消息是否已读
  bool IsMsgReaded(nim::IMMessage &msg)
  {
  	if (nim::MsgLog::QueryMessageBeReaded(msg))
  	{
  		return true;
  	}
  
  	return false;
  }
  
  //通过提前注册的消息状态变更广播通知获取消息被已读的状态
  void OnMsgStatusChangedCallback(const nim::MessageStatusChangedResult& res)
  {
  	for (auto res : res.results_)
  	{
  		if (res.status_ == kNIMMsgLogStatusReceipt)
  		{
  			...
  		}
  	}
  }
  
  void OnInit()
  {
  	nim::MsgLog::RegMessageStatusChangedCb(&OnMsgStatusChangedCallback);
  }
  

• 群消息已读回执

  C++//批量标记群消息已读
  void SessionBox::InvokeSetRead(const std::list<nim::IMMessage> &msgs)
  {
  	nim::Team::TeamMsgAckRead(session_id_, msgs, nim::Team::TeamEventCallback());
  }
  
  //通过提前注册的群时间广播获取群消息已读的状态
  void TeamCallback::OnTeamEventCallback(const nim::TeamEvent& result)
  {
  	if (result.notification_id_ == nim::kNIMNotificationIdLocalGetTeamMsgUnreadCount)
  	{
  		...
  	}
  }
  
  void Init()
  {
  	//注册群事件的回调
  	nim::Team::RegTeamEventCb(nbase::Bind(&nim_comp::TeamCallback::OnTeamEventCallback, std::placeholders::_1));
  }
  
  //获取群消息已读未读列表
  void UnreadForm::DoLoadList()
  {
  	nim::Team::TeamMsgQueryUnreadList(msg_.receiver_accid_, msg_, nbase::Bind(&UnreadForm::OnTeamEventCallback, std::placeholders::_1));
  }
  
  void UnreadForm::OnTeamEventCallback(const nim::TeamEvent& result)
  {
  	UnreadForm * win = (UnreadForm *)nim_comp::WindowsManager::GetInstance()->GetWindow(UnreadForm::kClassName, UnreadForm::kClassName);
  	if (win)
  		win->OnLoadListCallback(result);
  }
  

C#//发送已读回执

//查询消息是否已读
bool IsMsgReaded(NIM.NIMTextMessage msg)
{
	return NIM.Messagelog.MessagelogAPI.IsMessageBeReaded(msg);
}

//通过提前注册的消息状态变更广播通知获取消息被已读的状态
void OnInit()
{
	NIM.Messagelog.MessagelogAPI.RegMsglogStatusChangedCb((res, result) =>
	{
		···
	});
}

C//发送已读回执

typedef bool(*nim_msglog_query_be_readed)(const char *json_msg, const char *json_extension);

bool foo(const char *json_msg)
{
	nim_msglog_query_be_readed func = (nim_msglog_query_be_readed) GetProcAddress(hInst, "nim_msglog_query_be_readed");

	return func(json_msg, "");
}

//通过提前注册的消息状态变更广播通知获取消息被已读的状态
void CallbackMsgStatusChanged(int rescode, const char *result, const char *json_extent, const void *callback)
{
	// 解析result
}

typedef void(*nim_msglog_reg_status_changed_cb)(const char *json_extension, nim_msglog_status_changed_cb_func cb, const void *user_data);

void foo(const char *json_msg)
{
	nim_msglog_reg_status_changed_cb func = (nim_msglog_reg_status_changed_cb) GetProcAddress(hInst, "nim_msglog_reg_status_changed_cb");

	func( "", &CallbackMsgStatusChanged, nullptr);
}

C++void foo(nim::IMMessage &msg_data)
{
	nim::IMAudio audio;
	nim::Talk::ParseAudioMessageAttach(msg_data, audio);
	nim::AudioInfo audio_info;
	audio_info.samplerate_ = "16000";
	audio_info.url_ = audio.url_;
	audio_info.duration_ = audio.duration_;
	audio_info.mime_type_ = audio.file_extension_;

	nim::Tool::GetAudioTextAsync(audio_info, ToWeakCallback([this](int rescode, const std::string& text) {
		if (rescode == nim::kNIMResSuccess) {
			···
		}
		else {
			···
		}
	}));
}

C#private void foo(NIM.NIMIMMessage msg)
{
	NIM.NIMAudioInfo info = new NIMAudioInfo();
	info.Duration = 1000;
	info.SampleRate = "16000";
	info.URL = "···";
	info.MimeType = "aac";
	NIM.ToolsAPI.GetAudioTextAsync(info, "", OnGetText);
}
private void OnGetText(int rescode, string text, string json_extension, IntPtr user_data)
{
}

Cvoid CallbackGetAudioText(int rescode, const char *text, const char *json_extension, const void *user_data)
{
	...
}

typedef void(*nim_tool_get_audio_text_async)(const char *json_audio_info, const char *json_extension, nim_tool_get_audio_text_cb_func cb, const void *user_data);

void foo()
{
	Json::Value json_value;
	json_value[nim::kNIMTransAudioKeyMime] = ; //mime类型
	json_value[nim::kNIMTransAudioKeySample] = ; //采样率
	json_value[nim::kNIMTransAudioKeyAudioUrl] = ; //下载地址
	json_value[nim::kNIMTransAudioKeyDuration] = ; //时长（毫秒）

	nim_tool_get_audio_text_async func = (nim_tool_get_audio_text_async) GetProcAddress(hInst, "nim_tool_get_audio_text_async");
	func(json_value.toStyledString().c_str(), nullptr, &CallbackGetAudioText, nullptr);
}