feat: impl cpp wrapper

c_cpp_wrapper/build_so.sh

@@ -5,5 +5,5 @@ go build -buildmode=c-shared -trimpath -ldflags="-s -w" -o openimsdk.so export.g
 
 
 # build cpp sdk
-# rm ./openimsdkcc.so
+rm ./openimsdkcc.so
-# g++ -fPIC -shared -o openimsdkcc.so openimsdkcc.cc ./openimsdk.so
+g++ -fPIC -shared -o openimsdkcc.so openimsdkcc.cc ./openimsdk.so

c_cpp_wrapper/openimsdkcc.cc

@@ -0,0 +1,864 @@
+#include "openimsdkcc.h"
+
+
+namespace openim {
+
+// // ===================================================== init ===============================================
+// must be called before use sdk
+
+// instance pattern
+OpenIMManager& OpenIMManager::GetInstance()
+{
+  static OpenIMManager instance;
+  return instance;
+}
+
+// must be called before use sdk
+bool OpenIMManager::InitSDK(const std::function<void(int,const std::string&)>& cCallback, const std::string &operationID, const std::string &config)
+{
+  char *operationID_cs = const_cast<char *>(operationID.c_str());
+  char *config_cs = const_cast<char *>(config.c_str());
+  int  ret=init_sdk(_wrapper_cpp_function(cCallback), operationID_cs, config_cs);
+  return (ret&1)==1;
+}
+
+
+
+// release resouces used by SDK
+void OpenIMManager::UnInitSDK(const std::string &operationID)
+{
+  // TODO: free all functions in function pool
+
+  char *operationID_cs = const_cast<char *>(operationID.c_str());
+  return un_init_sdk(operationID_cs);
+}
+
+// // ===================================================== set listener ===============================================
+// impl for set listener, this callback function will be keep in memory,until call SetXXXListener again
+
+// for debug
+// void OpenIMManager::SetPrint(const std::function<void(const std::string&)>& printCallBack)
+// {
+//   this->printCallBack = _wrapper_cpp_function(printCallBack);
+//   set_print((CB_S)((this->printCallBack).target<void(*)(const std::string&)>()));
+// }
+
+void OpenIMManager::SetAdvancedMsgListener(const std::function<void(int, const std::string &)>& advancedMsgListenerCallback)
+{
+  set_advanced_msg_listener(_wrapper_cpp_function(advancedMsgListenerCallback));
+}
+void OpenIMManager::SetBatchMsgListener(const std::function<void(int, const std::string &)>& batchMsgListenerCallback)
+{
+  set_batch_msg_listener(_wrapper_cpp_function(batchMsgListenerCallback));
+}
+void OpenIMManager::SetConversationListener(const std::function<void(int, const std::string &)>& conversationListenerCallback)
+{
+  set_conversation_listener(_wrapper_cpp_function(conversationListenerCallback));
+}
+void OpenIMManager::SetCustomBusinessListener(const std::function<void(int, const std::string &)>& customBusinessListenerCallback)
+{
+ set_custom_business_listener(_wrapper_cpp_function(customBusinessListenerCallback));
+}
+void OpenIMManager::SetFriendListener(const std::function<void(int, const std::string &)>& friendListenerCallback)
+{
+  set_friend_listener(_wrapper_cpp_function(friendListenerCallback));
+}
+void OpenIMManager::SetGroupListener(const std::function<void(int, const std::string &)>& groupListenerCallback)
+{
+  set_group_listener(_wrapper_cpp_function(groupListenerCallback));
+}
+void OpenIMManager::SetUserListener(const std::function<void(int, const std::string &)>& userListenerCallback)
+{
+  set_user_listener(_wrapper_cpp_function(userListenerCallback));
+}
+
+// // ===================================================== CallOnce Callback ===============================================
+// callback function arg below will be free after call once, so we need to wrapp it to onetime
+// // ===================================================== message ===============================================
+
+// // ===================================================== login logout ===============================================
+void OpenIMManager::Login(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& loginCallback, const std::string& operationID, const std::string& uid, const std::string& token)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* uid_cs=const_cast<char*>(uid.c_str());
+  char* token_cs=const_cast<char*>(token.c_str());
+  login(_wrapper_callonce_cpp_function(loginCallback),operationID_cs,uid_cs,token_cs);
+}
+
+void OpenIMManager::Logout(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& logoutCallback, const std::string& operationID)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  logout(_wrapper_callonce_cpp_function(logoutCallback),operationID_cs);
+}
+
+GoInt OpenIMManager::GetLoginStatus(const std::string& operationID)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  return get_login_status(operationID_cs);
+}
+
+std::string OpenIMManager::GetLoginUser()
+{
+  char* user=get_login_user();
+  std::string user_str(user);
+  free(user);
+  return get_login_user();
+}
+
+void OpenIMManager::NetworkStatusChanged(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& networkStatusCallback, const std::string& operationID)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  network_status_changed(_wrapper_callonce_cpp_function(networkStatusCallback),operationID_cs);
+}
+
+
+// // ===================================================== message ===============================================
+// //
+
+// create text message
+std::string OpenIMManager::CreateTextMessage(const std::string& operationID, const std::string& text)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* text_cs=const_cast<char*>(text.c_str());
+  char* result_cs=create_text_message(operationID_cs,text_cs);
+  std::string result(result_cs);
+  // release dynamic c string memory
+  free(result_cs);
+  return result;
+}
+
+// create advanced text message
+std::string OpenIMManager::CreateAdvancedTextMessage(const std::string& operationID, const std::string& text, const std::string& messageEntityList)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* text_cs=const_cast<char*>(text.c_str());
+  char* messageEntityList_cs=const_cast<char*>(messageEntityList.c_str());
+  char* result_cs=create_advanced_text_message(operationID_cs,text_cs,messageEntityList_cs);
+  std::string result(result_cs);
+  free(result_cs);
+  return result;
+}
+
+// create text at message
+std::string OpenIMManager::CreateTextAtMessage(const std::string& operationID, const std::string& text, const std::string& atUserList, const std::string& atUsersInfo, const std::string& message)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* text_cs=const_cast<char*>(text.c_str());
+  char* atUserList_cs=const_cast<char*>(atUserList.c_str());
+  char* atUsersInfo_cs=const_cast<char*>(atUsersInfo.c_str());
+  char* message_cs=const_cast<char*>(message.c_str());
+  char* result_cs=create_text_at_message(operationID_cs,text_cs,atUserList_cs,atUsersInfo_cs,message_cs);
+  std::string result(result_cs);
+  free(result_cs);
+  return result;
+}
+
+// create location message
+std::string OpenIMManager::CreateLocationMessage(const std::string& operationID, const std::string& description, double longitude, double latitude)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* description_cs=const_cast<char*>(description.c_str());
+  char* result_cs=create_location_message(operationID_cs,description_cs,longitude,latitude);
+  std::string result(result_cs);
+  free(result_cs);
+  return result;
+}
+
+// create custom message
+std::string OpenIMManager::CreateCustomMessage(const std::string& operationID, const std::string& data, const std::string& extension, const std::string& description)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* data_cs=const_cast<char*>(data.c_str());
+  char* extension_cs=const_cast<char*>(extension.c_str());
+  char* description_cs=const_cast<char*>(description.c_str());
+  char* result_cs=create_custom_message(operationID_cs,data_cs,extension_cs,description_cs);
+  std::string result(result_cs);
+  free(result_cs);
+  return result;
+}
+
+// create quote message
+std::string OpenIMManager::CreateQuoteMessage(const std::string& operationID, const std::string& text, const std::string& message)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* text_cs=const_cast<char*>(text.c_str());
+  char* message_cs=const_cast<char*>(message.c_str());
+  char* result_cs=create_quote_message(operationID_cs,text_cs,message_cs);
+  std::string result(result_cs);
+  free(result_cs);
+  return result;
+
+}
+
+// create advanced quote message
+std::string OpenIMManager::CreateAdvancedQuoteMessage(const std::string& operationID, const std::string& text, const std::string& message, const std::string& messageEntityList)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* text_cs=const_cast<char*>(text.c_str());
+  char* message_cs=const_cast<char*>(message.c_str());
+  char* messageEntityList_cs=const_cast<char*>(messageEntityList.c_str());
+  char* result_cs=create_advanced_quote_message(operationID_cs,text_cs,message_cs,messageEntityList_cs);
+  std::string result(result_cs);
+  free(result_cs);
+  return result;
+}
+
+// create card message
+std::string OpenIMManager::CreateCardMessage(const std::string& operationID, const std::string& cardInfo)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* cardInfo_cs=const_cast<char*>(cardInfo.c_str());
+  char* result_cs=create_card_message(operationID_cs,cardInfo_cs);
+  std::string result(result_cs);
+  free(result_cs);
+  return result;
+}
+
+// create video message from full path
+std::string OpenIMManager::CreateVideoMessageFromFullPath(const std::string& operationID, const std::string& videoFullPath, const std::string& videoType, long long int duration, const std::string& snapshotFullPath)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* videoFullPath_cs=const_cast<char*>(videoFullPath.c_str());
+  char* videoType_cs=const_cast<char*>(videoType.c_str());
+  char* snapshotFullPath_cs=const_cast<char*>(snapshotFullPath.c_str());
+  char* result_cs=create_video_message_from_full_path(operationID_cs,videoFullPath_cs,videoType_cs,duration,snapshotFullPath_cs);
+  std::string result(result_cs);
+  free(result_cs);
+  return result;
+}
+
+// create image message from full path
+std::string OpenIMManager::CreateImageMessageFromFullPath(const std::string& operationID, const std::string& imageFullPath)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* imageFullPath_cs=const_cast<char*>(imageFullPath.c_str());
+  char* result_cs=create_image_message_from_full_path(operationID_cs,imageFullPath_cs);
+  std::string result(result_cs);
+  free(result_cs);
+  return result;
+}
+
+// create sound message from full path  
+std::string OpenIMManager::CreateSoundMessageFromFullPath(const std::string& operationID, const std::string& soundPath, long long int duration)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* soundPath_cs=const_cast<char*>(soundPath.c_str());
+  char* result_cs=create_sound_message_from_full_path(operationID_cs,soundPath_cs,duration);
+  std::string result(result_cs);
+  free(result_cs);
+  return result;
+}
+
+// create file message from full path
+std::string OpenIMManager::CreateFileMessageFromFullPath(const std::string& operationID, const std::string& fileFullPath, const std::string& fileName)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* fileFullPath_cs=const_cast<char*>(fileFullPath.c_str());
+  char* fileName_cs=const_cast<char*>(fileName.c_str());
+  char* result_cs=create_file_message_from_full_path(operationID_cs,fileFullPath_cs,fileName_cs);
+  std::string result(result_cs);
+  free(result_cs);
+  return result;
+}
+
+// create image message
+std::string OpenIMManager::CreateImageMessage(const std::string& operationID, const std::string& imagePath)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* imagePath_cs=const_cast<char*>(imagePath.c_str());
+  char* result_cs=create_image_message(operationID_cs,imagePath_cs);
+  std::string result(result_cs);
+  free(result_cs);
+  return result;
+}
+
+// create image message by URL
+std::string OpenIMManager::CreateImageMessageByURL(const std::string& operationID, const std::string& sourcePicture, const std::string& bigPicture, const std::string& snapshotPicture)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* sourcePicture_cs=const_cast<char*>(sourcePicture.c_str());
+  char* bigPicture_cs=const_cast<char*>(bigPicture.c_str());
+  char* snapshotPicture_cs=const_cast<char*>(snapshotPicture.c_str());
+  char* result_cs=create_image_message_by_url(operationID_cs,sourcePicture_cs,bigPicture_cs,snapshotPicture_cs);
+  std::string result(result_cs);
+  free(result_cs);
+  return result;
+}
+
+// create sound message by URL
+std::string OpenIMManager::CreateSoundMessageByURL(const std::string& operationID, const std::string& soundBaseInfo)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* soundBaseInfo_cs=const_cast<char*>(soundBaseInfo.c_str());
+  char* result_cs=create_sound_message_by_url(operationID_cs,soundBaseInfo_cs);
+  std::string result(result_cs);
+  free(result_cs);
+  return result;
+}
+
+// create sound message
+std::string OpenIMManager::CreateSoundMessage(const std::string& operationID, const std::string& soundPath, long long int duration)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* soundPath_cs=const_cast<char*>(soundPath.c_str());
+  char* result_cs=create_sound_message(operationID_cs,soundPath_cs,duration);
+  std::string result(result_cs);
+  free(result_cs);
+  return result;
+}
+
+// create video message by URL
+std::string OpenIMManager::CreateVideoMessageByURL(const std::string& operationID, const std::string& videoBaseInfo)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* videoBaseInfo_cs=const_cast<char*>(videoBaseInfo.c_str());
+  char* result_cs=create_video_message_by_url(operationID_cs,videoBaseInfo_cs);
+  std::string result(result_cs);
+  free(result_cs);
+  return result;
+}
+
+// create video message
+std::string OpenIMManager::CreateVideoMessage(const std::string& operationID, const std::string& videoPath, const std::string& videoType, long long int duration, const std::string& snapshotPath)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* videoPath_cs=const_cast<char*>(videoPath.c_str());
+  char* videoType_cs=const_cast<char*>(videoType.c_str());
+  char* snapshotPath_cs=const_cast<char*>(snapshotPath.c_str());
+  char* result_cs=create_video_message(operationID_cs,videoPath_cs,videoType_cs,duration,snapshotPath_cs);
+  std::string result(result_cs);
+  free(result_cs);
+  return result;
+}
+
+// create file message by URL
+std::string OpenIMManager::CreateFileMessageByURL(const std::string& operationID, const std::string& fileBaseInfo)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* fileBaseInfo_cs=const_cast<char*>(fileBaseInfo.c_str());
+  char* result_cs=create_file_message_by_url(operationID_cs,fileBaseInfo_cs);
+  std::string result(result_cs);
+  free(result_cs);
+  return result;
+}
+
+// create file message
+std::string OpenIMManager::CreateFileMessage(const std::string& operationID, const std::string& filePath, const std::string& fileName)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* filePath_cs=const_cast<char*>(filePath.c_str());
+  char* fileName_cs=const_cast<char*>(fileName.c_str());
+  char* result_cs=create_file_message(operationID_cs,filePath_cs,fileName_cs);
+  std::string result(result_cs);
+  free(result_cs);
+  return result;
+}
+
+// create merger message
+std::string OpenIMManager::CreateMergerMessage(const std::string& operationID, const std::string& messageList, const std::string& title, const std::string& summaryList)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* messageList_cs=const_cast<char*>(messageList.c_str());
+  char* title_cs=const_cast<char*>(title.c_str());
+  char* summaryList_cs=const_cast<char*>(summaryList.c_str());
+  char* result_cs=create_merger_message(operationID_cs,messageList_cs,title_cs,summaryList_cs);
+  std::string result(result_cs);
+  free(result_cs);
+  return result;
+}
+
+// create face message
+std::string OpenIMManager::CreateFaceMessage(const std::string& operationID, int index, const std::string& data)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* data_cs=const_cast<char*>(data.c_str());
+  char* result_cs=create_face_message(operationID_cs,index,data_cs);
+  std::string result(result_cs);
+  free(result_cs);
+  return result;
+}
+
+// create forward message
+std::string OpenIMManager::CreateForwardMessage(const std::string& operationID, const std::string& m)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* m_cs=const_cast<char*>(m.c_str());
+  char* result_cs=create_forward_message(operationID_cs,m_cs);
+  std::string result(result_cs);
+  free(result_cs);
+  return result;
+}
+
+// get all conversation list
+void OpenIMManager::GetAllConversationList(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& getAllConversationListCallback, const std::string& operationID)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  get_all_conversation_list(_wrapper_callonce_cpp_function(getAllConversationListCallback),operationID_cs);
+}
+
+// get advanced history message list
+void OpenIMManager::GetAdvancedHistoryMessageList(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& getAdvancedHistoryCallback , const std::string& operationID, const std::string& getMessageOptions)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* getMessageOptions_cs=const_cast<char*>(getMessageOptions.c_str());
+  get_advanced_history_message_list(_wrapper_callonce_cpp_function(getAdvancedHistoryCallback),operationID_cs,getMessageOptions_cs);
+}
+
+// send message
+void SendMessage(const std::function<void(const std::string&, int, const std::string&, const std::string&,int)>& sendMessageCallback, const std::string& operationID, const std::string& message,const std::string& recvID,const std::string& groupID,const std::string& offlinePushInfo)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* message_cs=const_cast<char*>(message.c_str());
+  char* recvID_cs=const_cast<char*>(recvID.c_str());
+  char* groupID_cs=const_cast<char*>(groupID.c_str());
+  char* offlinePushInfo_cs=const_cast<char*>(offlinePushInfo.c_str());
+  send_message(_wrapper_callonce_cpp_function(sendMessageCallback),operationID_cs,message_cs,recvID_cs,groupID_cs,offlinePushInfo_cs);
+}
+
+// // ===================================================== user ===============================================
+// //
+
+// get users info
+void OpenIMManager::GetUsersInfo(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& userIDs)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* userIDs_cs=const_cast<char*>(userIDs.c_str());
+  get_users_info(_wrapper_callonce_cpp_function(callback),operationID_cs,userIDs_cs);
+}
+
+// get users info from server
+void OpenIMManager::GetUsersInfoFromServer(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID,const std::string& userIDs)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* userIDs_cs=const_cast<char*>(userIDs.c_str());
+  get_users_info_from_srv(_wrapper_callonce_cpp_function(callback),operationID_cs,userIDs_cs);
+}
+
+// set self info
+void OpenIMManager::SetSelfInfo(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback,const std::string& operationID, const std::string& selfInfo)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* selfInfo_cs=const_cast<char*>(selfInfo.c_str());
+  set_self_info(_wrapper_callonce_cpp_function(callback),operationID_cs,selfInfo_cs);
+}
+
+// get self user info
+void OpenIMManager::GetSelfUserInfo(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  get_self_user_info(_wrapper_callonce_cpp_function(callback),operationID_cs);
+}
+
+// update message sender info
+void OpenIMManager::UpdateMessageSenderInfo(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& nickname,const std::string& faceURL)
+{
+  //TODO
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* nickname_cs=const_cast<char*>(nickname.c_str());
+  char* faceURL_cs=const_cast<char*>(faceURL.c_str());
+  update_msg_sender_info(_wrapper_callonce_cpp_function(callback),operationID_cs,nickname_cs,faceURL_cs);
+}
+
+// subscribe users status
+void OpenIMManager::SubscribeUsersStatus(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback,const std::string& operationID, const std::string& userIDs)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* userIDs_cs=const_cast<char*>(userIDs.c_str());
+  subscribe_users_status(_wrapper_callonce_cpp_function(callback),operationID_cs,userIDs_cs);
+}
+
+// unsubscribe users status
+void OpenIMManager::UnsubscribeUsersStatus(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback,const std::string& operationID, const std::string& userIDs)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* userIDs_cs=const_cast<char*>(userIDs.c_str());
+  unsubscribe_users_status(_wrapper_callonce_cpp_function(callback),operationID_cs,userIDs_cs);
+}
+
+// get subscribe users status
+void OpenIMManager::GetSubscribeUsersStatus(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  get_subscribe_users_status(_wrapper_callonce_cpp_function(callback),operationID_cs);
+}
+
+// get user status
+void OpenIMManager::GetUserStatus(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback,const std::string& operationID, const std::string& userID)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* userID_cs=const_cast<char*>(userID.c_str());
+  get_user_status(_wrapper_callonce_cpp_function(callback),operationID_cs,userID_cs);
+}
+
+// // ===================================================== friend ===============================================
+// //
+
+// get specified friends info
+void OpenIMManager::GetSpecifiedFriendsInfo(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback,const std::string& operationID, const std::string& userIDs)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* userIDs_cs=const_cast<char*>(userIDs.c_str());
+  get_specified_friends_info(_wrapper_callonce_cpp_function(callback),operationID_cs,userIDs_cs);
+}
+
+// get friend list
+void OpenIMManager::GetFriendList(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  get_friend_list(_wrapper_callonce_cpp_function(callback),operationID_cs);
+}
+
+// get friend list page
+void OpenIMManager::GetFriendListPage(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, int offset, int count)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  get_friend_list_page(_wrapper_callonce_cpp_function(callback),operationID_cs,offset,count);
+}
+
+// search friends
+void OpenIMManager::SearchFriends(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback,const std::string& operationID, const std::string& searchParam)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* searchParam_cs=const_cast<char*>(searchParam.c_str());
+  search_friends(_wrapper_callonce_cpp_function(callback),operationID_cs,searchParam_cs);
+}
+
+// check friend
+void OpenIMManager::CheckFriend(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback,const std::string& operationID, const std::string& userID)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* userID_cs=const_cast<char*>(userID.c_str());
+  check_friend(_wrapper_callonce_cpp_function(callback),operationID_cs,userID_cs);
+}
+
+// add friend
+void OpenIMManager::AddFriend(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& friendInfo, const std::string& addFriendExtraInfo)
+{
+  char* friendInfo_cs=const_cast<char*>(friendInfo.c_str());
+  char* addFriendExtraInfo_cs=const_cast<char*>(addFriendExtraInfo.c_str());
+  add_friend(_wrapper_callonce_cpp_function(callback),friendInfo_cs,addFriendExtraInfo_cs);
+}
+
+// set friend remark
+void OpenIMManager::SetFriendRemark(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& userID, const std::string& remark)
+{
+  char* userID_cs=const_cast<char*>(userID.c_str());
+  char* remark_cs=const_cast<char*>(remark.c_str());
+  set_friend_remark(_wrapper_callonce_cpp_function(callback),userID_cs,remark_cs);
+}
+
+// delete friend
+void OpenIMManager::DeleteFriend(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& userID, const std::string& deleteFriendExtraInfo)
+{
+  char* userID_cs=const_cast<char*>(userID.c_str());
+  char* deleteFriendExtraInfo_cs=const_cast<char*>(deleteFriendExtraInfo.c_str());
+  delete_friend(_wrapper_callonce_cpp_function(callback),userID_cs,deleteFriendExtraInfo_cs);
+}
+
+// get friend application list as recipant
+void OpenIMManager::GetFriendApplicationListAsRecipant(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  get_friend_application_list_as_recipient(_wrapper_callonce_cpp_function(callback),operationID_cs);
+}
+
+// get friend application list as applicant
+void OpenIMManager::GetFriendApplicationListAsApplicant(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  get_friend_application_list_as_applicant(_wrapper_callonce_cpp_function(callback),operationID_cs);
+}
+
+// accept friend application
+void OpenIMManager::AcceptFriendApplication(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& friendApplicationID, const std::string& extraInfo)
+{
+  char* friendApplicationID_cs=const_cast<char*>(friendApplicationID.c_str());
+  char* extraInfo_cs=const_cast<char*>(extraInfo.c_str());
+  accept_friend_application(_wrapper_callonce_cpp_function(callback),friendApplicationID_cs,extraInfo_cs);
+}
+
+// refuse friend application
+void OpenIMManager::RefuseFriendApplication(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& friendApplicationID, const std::string& extraInfo)
+{
+  char* friendApplicationID_cs=const_cast<char*>(friendApplicationID.c_str());
+  char* extraInfo_cs=const_cast<char*>(extraInfo.c_str());
+  refuse_friend_application(_wrapper_callonce_cpp_function(callback),friendApplicationID_cs,extraInfo_cs);
+}
+
+// add black
+void OpenIMManager::AddBlack(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback,const std::string& operationID, const std::string& userIDs)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* userIDs_cs=const_cast<char*>(userIDs.c_str());
+  add_black(_wrapper_callonce_cpp_function(callback),operationID_cs,userIDs_cs);
+}
+
+// get black list
+void OpenIMManager::GetBlackList(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  get_black_list(_wrapper_callonce_cpp_function(callback),operationID_cs);
+}
+
+// remove black
+void OpenIMManager::RemoveBlack(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback,const std::string& operationID, const std::string& userIDs)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* userIDs_cs=const_cast<char*>(userIDs.c_str());
+  remove_black(_wrapper_callonce_cpp_function(callback),operationID_cs,userIDs_cs);
+}
+
+// // ===================================================== group ===============================================
+// // 
+
+// create group
+void OpenIMManager::CreateGroup(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& groupReqInfo)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* groupReqInfo_cs=const_cast<char*>(groupReqInfo.c_str());
+  create_group(_wrapper_callonce_cpp_function(callback),operationID_cs,groupReqInfo_cs);
+}
+
+// join group
+void OpenIMManager::JoinGroup(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& groupID, const std::string& reqMsg, int joinSource)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* groupID_cs=const_cast<char*>(groupID.c_str());
+  char* reqMsg_cs=const_cast<char*>(reqMsg.c_str());
+  join_group(_wrapper_callonce_cpp_function(callback),operationID_cs,groupID_cs,reqMsg_cs,joinSource);
+}
+
+// quit group
+void OpenIMManager::QuitGroup(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& groupID, const std::string& reqMsg)
+{
+  char* groupID_cs=const_cast<char*>(groupID.c_str());
+  char* reqMsg_cs=const_cast<char*>(reqMsg.c_str());
+  quit_group(_wrapper_callonce_cpp_function(callback),groupID_cs,reqMsg_cs);
+}
+
+// dismiss group
+void OpenIMManager::DismissGroup(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& groupID, const std::string& reqMsg)
+{
+  char* groupID_cs=const_cast<char*>(groupID.c_str());
+  char* reqMsg_cs=const_cast<char*>(reqMsg.c_str());
+  dismiss_group(_wrapper_callonce_cpp_function(callback),groupID_cs,reqMsg_cs);
+}
+
+// change group mute
+void OpenIMManager::ChangeGroupMute(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback,const std::string& operationID, const std::string& groupID, bool mute)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* groupID_cs=const_cast<char*>(groupID.c_str());
+  change_group_mute(_wrapper_callonce_cpp_function(callback),operationID_cs,groupID_cs,mute);
+}
+
+// change group member mute
+void OpenIMManager::ChangeGroupMemberMute(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback,const std::string& operationID, const std::string& groupID, const std::string& memberID, int mutedSeconds)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* groupID_cs=const_cast<char*>(groupID.c_str());
+  char* memberID_cs=const_cast<char*>(memberID.c_str());
+  change_group_member_mute(_wrapper_callonce_cpp_function(callback),operationID_cs,groupID_cs,memberID_cs,mutedSeconds);
+}
+
+
+// set the role level of a group member
+void OpenIMManager::SetGroupMemberRoleLevel(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback,const std::string& operationID, const std::string& groupID, const std::string& memberID, int roleLevel)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* groupID_cs=const_cast<char*>(groupID.c_str());
+  char* memberID_cs=const_cast<char*>(memberID.c_str());
+  set_group_member_role_level(_wrapper_callonce_cpp_function(callback),operationID_cs,groupID_cs,memberID_cs,roleLevel);
+}
+
+// set the information of a group member
+void OpenIMManager::SetGroupMemberInfo(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& groupMemberInfo)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* groupMemberInfo_cs=const_cast<char*>(groupMemberInfo.c_str());
+  set_group_member_info(_wrapper_callonce_cpp_function(callback),operationID_cs,groupMemberInfo_cs);
+}
+
+// get Joined Group List
+void OpenIMManager::GetJoinedGroupList(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  get_joined_group_list(_wrapper_callonce_cpp_function(callback),operationID_cs);
+}
+
+// get specified groups info
+void OpenIMManager::GetSpecifiedGroupsInfo(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback,const std::string& operationID, const std::string& groupIDList)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* groupIDList_cs=const_cast<char*>(groupIDList.c_str());
+  get_specified_groups_info(_wrapper_callonce_cpp_function(callback),operationID_cs,groupIDList_cs);
+}
+
+// search groups
+void OpenIMManager::SearchGroups(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback,const std::string& operationID, const std::string& searchParam)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* searchParam_cs=const_cast<char*>(searchParam.c_str());
+  search_groups(_wrapper_callonce_cpp_function(callback),operationID_cs,searchParam_cs);
+}
+
+// set group info
+void OpenIMManager::SetGroupInfo(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback,const std::string& operationID, const std::string& groupInfo)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* groupInfo_cs=const_cast<char*>(groupInfo.c_str());
+  set_group_info(_wrapper_callonce_cpp_function(callback),operationID_cs,groupInfo_cs);
+}
+
+// set group verification
+void OpenIMManager::SetGroupVerification(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback,const std::string& operationID, const std::string& groupID, int verification)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* groupID_cs=const_cast<char*>(groupID.c_str());
+  set_group_verification(_wrapper_callonce_cpp_function(callback),operationID_cs,groupID_cs,verification);
+}
+
+// set group look member info
+void OpenIMManager::SetGroupLookMemberInfo(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback,const std::string& operationID, const std::string& groupID, int lookInfo)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* groupID_cs=const_cast<char*>(groupID.c_str());
+  set_group_look_member_info(_wrapper_callonce_cpp_function(callback),operationID_cs,groupID_cs,lookInfo);
+}
+
+// set group apply member friend
+void OpenIMManager::SetGroupApplyMemberFriend(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback,const std::string& operationID, const std::string& groupID, int rule)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* groupID_cs=const_cast<char*>(groupID.c_str());
+  set_group_apply_member_friend(_wrapper_callonce_cpp_function(callback),operationID_cs,groupID_cs,rule);
+}
+
+// get group member list
+void OpenIMManager::GetGroupMemberList(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback,const std::string& operationID, const std::string& groupID,int filter,int offset,int count)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* groupID_cs=const_cast<char*>(groupID.c_str());
+  get_group_member_list(_wrapper_callonce_cpp_function(callback),operationID_cs,groupID_cs,filter,offset,count);
+}
+
+
+// get group member owner and admin
+void OpenIMManager::GetGroupMemberOwnerAndAdmin(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID,const std::string& groupID)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* groupID_cs=const_cast<char*>(groupID.c_str());
+  get_group_member_owner_and_admin(_wrapper_callonce_cpp_function(callback),operationID_cs,groupID_cs);
+}
+
+// get group application list
+void OpenIMManager::GetGroupMemberListByJoinTimeFilter(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& groupID, int offset, int count, long long int joinTimeBegin, long long int joinTimeEnd, const std::string& filteruserIDs)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* groupID_cs=const_cast<char*>(groupID.c_str());
+  char* filteruserIDs_cs=const_cast<char*>(filteruserIDs.c_str());
+  get_group_member_list_by_join_time_filter(_wrapper_callonce_cpp_function(callback),operationID_cs,groupID_cs,offset,count,joinTimeBegin,joinTimeEnd,filteruserIDs_cs);
+}
+
+// get specified group members info
+void OpenIMManager::GetSpecifiedGroupMembersInfo(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID,const std::string& groupID, const std::string& memberIDList)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* groupID_cs=const_cast<char*>(groupID.c_str());
+  char* memberIDList_cs=const_cast<char*>(memberIDList.c_str());
+  get_specified_group_members_info(_wrapper_callonce_cpp_function(callback),operationID_cs,groupID_cs,memberIDList_cs);
+}
+
+// kick group members
+void OpenIMManager::KickGroupMember(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& groupID, const std::string& reason, const std::string& userIDs)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* groupID_cs=const_cast<char*>(groupID.c_str());
+  char* reason_cs=const_cast<char*>(reason.c_str());
+  char* userIDs_cs=const_cast<char*>(userIDs.c_str());
+  kick_group_member(_wrapper_callonce_cpp_function(callback),operationID_cs,groupID_cs,reason_cs,userIDs_cs);
+}
+
+
+// transfers the ownership of a group
+void OpenIMManager::TransferGroupOwner(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& groupID, const std::string& memberID, const std::string& notifyMsg)
+{
+  char* groupID_cs=const_cast<char*>(groupID.c_str());
+  char* memberID_cs=const_cast<char*>(memberID.c_str());
+  char* notifyMsg_cs=const_cast<char*>(notifyMsg.c_str());
+  transfer_group_owner(_wrapper_callonce_cpp_function(callback),groupID_cs,memberID_cs,notifyMsg_cs);
+}
+
+// invites users to a group
+void OpenIMManager::InviteUserToGroup(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& groupID, const std::string& reason, const std::string& userIDs)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* groupID_cs=const_cast<char*>(groupID.c_str());
+  char* reason_cs=const_cast<char*>(reason.c_str());
+  char* userIDs_cs=const_cast<char*>(userIDs.c_str());
+  invite_user_to_group(_wrapper_callonce_cpp_function(callback),operationID_cs,groupID_cs,reason_cs,userIDs_cs);
+}
+
+// retrives the group application list as a recipient
+void OpenIMManager::GetGroupApplicationListAsRecipient(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback,const std::string& operationID)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  get_group_application_list_as_recipient(_wrapper_callonce_cpp_function(callback),operationID_cs);
+}
+
+// retrives the group application list as an applicant
+void OpenIMManager::GetGroupApplicationListAsApplicant(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback,const std::string& operationID)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  get_group_application_list_as_applicant(_wrapper_callonce_cpp_function(callback),operationID_cs);
+}
+
+// accept a group application
+void OpenIMManager::AcceptGroupApplication(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& groupID, const std::string& fromUserID, const std::string& handleMsg)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* groupID_cs=const_cast<char*>(groupID.c_str());
+  char* fromUserID_cs=const_cast<char*>(fromUserID.c_str());
+  char* handleMsg_cs=const_cast<char*>(handleMsg.c_str());
+  accept_group_application(_wrapper_callonce_cpp_function(callback),operationID_cs,groupID_cs,fromUserID_cs,handleMsg_cs);
+}
+
+
+// refuses a group application
+void OpenIMManager::RefuseGroupApplication(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& groupID, const std::string& fromUserID, const std::string& handleMsg)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* groupID_cs=const_cast<char*>(groupID.c_str());
+  char* fromUserID_cs=const_cast<char*>(fromUserID.c_str());
+  char* handleMsg_cs=const_cast<char*>(handleMsg.c_str());
+  refuse_group_application(_wrapper_callonce_cpp_function(callback),operationID_cs,groupID_cs,fromUserID_cs,handleMsg_cs);
+}
+
+// set group member nickname
+void OpenIMManager::SetGroupMemberNickname(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& groupID, const std::string& userID, const std::string& groupMemberNickname)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* groupID_cs=const_cast<char*>(groupID.c_str());
+  char* userID_cs=const_cast<char*>(userID.c_str());
+  char* groupMemberNickname_cs=const_cast<char*>(groupMemberNickname.c_str());
+  set_group_member_nickname(_wrapper_callonce_cpp_function(callback),operationID_cs,groupID_cs,userID_cs,groupMemberNickname_cs);
+}
+
+// search group members
+void OpenIMManager::SearchGroupMembers(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& searchParam)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* searchParam_cs=const_cast<char*>(searchParam.c_str());
+  search_group_members(_wrapper_callonce_cpp_function(callback),operationID_cs,searchParam_cs);
+}
+
+// check if the user has joined a certain group
+void OpenIMManager::IsJoinGroup(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback,const std::string& operationID, const std::string& groupID)
+{
+  char* operationID_cs=const_cast<char*>(operationID.c_str());
+  char* groupID_cs=const_cast<char*>(groupID.c_str());
+  is_join_group(_wrapper_callonce_cpp_function(callback),operationID_cs,groupID_cs);
+}
+
+
+}

c_cpp_wrapper/openimsdkcc.h

@@ -0,0 +1,623 @@
+#pragma onces
+
+#include "openimsdk.h"
+#include <functional>
+#include <string>
+#include <memory>
+#include <iostream>
+#include <bitset>
+#include <atomic>
+#include <thread>
+#include <chrono>
+#include <mutex>
+
+#define MAX_NUM_OF_CB_S 10
+#define MAX_NUM_OF_CB_I_S 10
+#define MAX_NUM_OF_CB_S_I_S_S 10
+#define MAX_NUM_OF_CB_S_I_S_S_I 10
+#define SLEEP_TIME_FOR_GET_INDEX 100 //ms
+
+// use recursive template to generate enough function pointer array
+// and define c type function interface
+// and define manager class to manage function pool
+namespace {
+  CB_S* _fps_cb_s=new CB_S[MAX_NUM_OF_CB_S];
+  CB_I_S* _fps_cb_i_s=new CB_I_S[MAX_NUM_OF_CB_I_S];
+  CB_S_I_S_S* _fps_cb_s_i_s_s=new CB_S_I_S_S[MAX_NUM_OF_CB_S_I_S_S];
+  CB_S_I_S_S_I* _fps_cb_s_i_s_s_i=new CB_S_I_S_S_I[MAX_NUM_OF_CB_S_I_S_S_I];
+  // c type func interface call cpp function
+  std::function<void(const std::string&)>* _cpp_function_cb_s=new std::function<void(const std::string&)>[MAX_NUM_OF_CB_S];
+  std::function<void(int,const std::string&)>* _cpp_function_cb_i_s=new std::function<void(int,const std::string&)>[MAX_NUM_OF_CB_I_S];
+  std::function<void(const std::string&,int,const std::string&,const std::string&)>* _cpp_function_cb_s_i_s_s=new std::function<void(const std::string&,int,const std::string&,const std::string&)>[MAX_NUM_OF_CB_S_I_S_S];
+  std::function<void(const std::string&,int,const std::string&,const std::string&,int)>* _cpp_function_cb_s_i_s_s_i=new std::function<void(const std::string&,int,const std::string&,const std::string&,int)>[MAX_NUM_OF_CB_S_I_S_S_I];
+
+  template<int N>
+  void _generate_cb_s(){
+    _fps_cb_s[N]=[](char* c_str){
+      _cpp_function_cb_s[N](std::string(c_str));
+    };
+    _generate_cb_s<N-1>();
+  }
+  template<>
+  void _generate_cb_s<0>(){
+    _fps_cb_s[0]=[](char* c_str){
+      _cpp_function_cb_s[0](std::string(c_str));
+    };
+  }
+
+  template<int N>
+  void _generate_cb_i_s(){
+    _fps_cb_i_s[N]=[](int code,char* c_str){
+      _cpp_function_cb_i_s[N](code,std::string(c_str));
+    };
+    _generate_cb_i_s<N-1>();
+  }
+  template<>
+  void _generate_cb_i_s<0>(){
+    _fps_cb_i_s[0]=[](int code,char* c_str){
+      _cpp_function_cb_i_s[0](code,std::string(c_str));
+    };
+  }
+  template<int N>
+  void _generate_cb_s_i_s_s(){
+    _fps_cb_s_i_s_s[N]=[](char* operationID,int code,char* c_str,char* c_str2){
+      _cpp_function_cb_s_i_s_s[N](std::string(operationID),code,std::string(c_str),std::string(c_str2));
+    };
+    _generate_cb_s_i_s_s<N-1>();
+  }
+  template<>
+  void _generate_cb_s_i_s_s<0>(){
+    _fps_cb_s_i_s_s[0]=[](char* operationID,int code,char* c_str,char* c_str2){
+      _cpp_function_cb_s_i_s_s[0](std::string(operationID),code,std::string(c_str),std::string(c_str2));
+    };
+  }
+  template<int N>
+  void _generate_cb_s_i_s_s_i(){
+    _fps_cb_s_i_s_s_i[N]=[](char* operationID,int code,char* c_str,char* c_str2,int c_int){
+      _cpp_function_cb_s_i_s_s_i[N](std::string(operationID),code,std::string(c_str),std::string(c_str2),c_int);
+    };
+    _generate_cb_s_i_s_s_i<N-1>();
+  }
+  template<>
+  void _generate_cb_s_i_s_s_i<0>(){
+    _fps_cb_s_i_s_s_i[0]=[](char* operationID,int code,char* c_str,char* c_str2,int c_int){
+      _cpp_function_cb_s_i_s_s_i[0](std::string(operationID),code,std::string(c_str),std::string(c_str2),c_int);
+    };
+  }
+
+  // init global function pointer array
+  void init(){
+    _generate_cb_s<MAX_NUM_OF_CB_S-1>();
+    _generate_cb_i_s<MAX_NUM_OF_CB_I_S-1>();
+    _generate_cb_s_i_s_s<MAX_NUM_OF_CB_S_I_S_S-1>();
+    _generate_cb_s_i_s_s_i<MAX_NUM_OF_CB_S_I_S_S_I-1>();
+  }
+  // define sigle instance class to manage function pool
+  class FuncPoolManager{
+    private:
+    // define a global bitmap, and support atomic operation, to manage cb_s pool
+    std::bitset<MAX_NUM_OF_CB_S> _cb_s_bitmap;
+    std::bitset<MAX_NUM_OF_CB_I_S> _cb_i_s_bitmap;
+    std::bitset<MAX_NUM_OF_CB_S_I_S_S> _cb_s_i_s_s_bitmap;
+    std::bitset<MAX_NUM_OF_CB_S_I_S_S_I> _cb_s_i_s_s_i_bitmap;
+    std::mutex _cb_s_mutex;
+    std::mutex _cb_i_s_mutex;
+    std::mutex _cb_s_i_s_s_mutex;
+    std::mutex _cb_s_i_s_s_i_mutex;
+    FuncPoolManager(){
+      init();
+    }
+    FuncPoolManager(const FuncPoolManager&){}
+    public:
+    static FuncPoolManager& get_instance(){
+      static FuncPoolManager instance;
+      return instance;
+    }
+    // get a available cb_s function index
+    int get_cb_s_index(){
+      std::lock_guard<std::mutex> lock(_cb_s_mutex);
+      int index=-1;
+      for(int i=0;i<_cb_s_bitmap.size();i++){
+        if(_cb_s_bitmap[i]==0){
+          _cb_s_bitmap[i]=1;
+          index=i;
+          break;
+        }
+      }
+      return index;
+    }
+    // get a available cb_i_s function index
+    int get_cb_i_s_index(){
+      std::lock_guard<std::mutex> lock(_cb_i_s_mutex);
+      int index=-1;
+      for(int i=0;i<_cb_i_s_bitmap.size();i++){
+        if(_cb_i_s_bitmap[i]==0){
+          _cb_i_s_bitmap[i]=1;
+          index=i;
+          break;
+        }
+      }
+      return index;
+    }
+    // get a available cb_s_i_s_s function index
+    int get_cb_s_i_s_s_index(){
+      std::lock_guard<std::mutex> lock(_cb_s_i_s_s_mutex);
+      int index=-1;
+      for(int i=0;i<_cb_s_i_s_s_bitmap.size();i++){
+        if(_cb_s_i_s_s_bitmap[i]==0){
+          _cb_s_i_s_s_bitmap[i]=1;
+          index=i;
+          break;
+        }
+      }
+      return index;
+    }
+    // get a available cb_s_i_s_s_i function index
+    int get_cb_s_i_s_s_i_index(){
+      std::lock_guard<std::mutex> lock(_cb_s_i_s_s_i_mutex);
+      int index=-1;
+      for(int i=0;i<_cb_s_i_s_s_i_bitmap.size();i++){
+        if(_cb_s_i_s_s_i_bitmap[i]==0){
+          _cb_s_i_s_s_i_bitmap[i]=1;
+          index=i;
+          break;
+        }
+      }
+      return index;
+    }
+    // release a available cb_s function index
+    int release_cb_s_index(int index){
+      std::lock_guard<std::mutex> lock(_cb_s_mutex);
+      if(index<0||index>=_cb_s_bitmap.size()){
+        return -1;
+      }
+      _cpp_function_cb_s[index]=nullptr;
+      _cb_s_bitmap[index]=0;
+      return 0;
+    }
+    // release a available cb_i_s function index
+    int release_cb_i_s_index(int index){
+      std::lock_guard<std::mutex> lock(_cb_i_s_mutex);
+      if(index<0||index>=_cb_i_s_bitmap.size()){
+        return -1;
+      }
+      _cpp_function_cb_i_s[index]=nullptr;
+      _cb_i_s_bitmap[index]=0;
+      return 0;
+    }
+    // release a available cb_s_i_s_s function index
+    int release_cb_s_i_s_s_index(int index){
+      std::lock_guard<std::mutex> lock(_cb_s_i_s_s_mutex);
+      if(index<0||index>=_cb_s_i_s_s_bitmap.size()){
+        return -1;
+      }
+      _cpp_function_cb_s_i_s_s[index]=nullptr;
+      _cb_s_i_s_s_bitmap[index]=0;
+      return 0;
+    }
+    // release a available cb_s_i_s_s_i function index
+    int release_cb_s_i_s_s_i_index(int index){
+      std::lock_guard<std::mutex> lock(_cb_s_i_s_s_i_mutex);
+      if(index<0||index>=_cb_s_i_s_s_i_bitmap.size()){
+        return -1;
+      }
+      _cpp_function_cb_s_i_s_s_i[index]=nullptr;
+      _cb_s_i_s_s_i_bitmap[index]=0;
+      return 0;
+    }
+  };
+  FuncPoolManager& instance=FuncPoolManager::get_instance();
+
+  // wrapper persistent function
+  // wrapp CB_S,if function pool is full,return nullptr
+  CB_S _wrapper_cpp_function(const std::function<void(const std::string&)>& cpp_function) {
+    int index=FuncPoolManager::get_instance().get_cb_s_index();
+    while(index<0){
+      std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME_FOR_GET_INDEX));
+      index=FuncPoolManager::get_instance().get_cb_s_index();
+    }
+    _cpp_function_cb_s[index]=cpp_function;
+    return _fps_cb_s[index];
+  }
+  // wrapp CB_I_S
+  CB_I_S _wrapper_cpp_function(const std::function<void(int,const std::string&)>& cpp_function)
+  {
+    int index=FuncPoolManager::get_instance().get_cb_i_s_index();
+    while(index<0){
+      std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME_FOR_GET_INDEX));
+      index=FuncPoolManager::get_instance().get_cb_i_s_index();
+    }
+    _cpp_function_cb_i_s[index]=cpp_function;
+    return _fps_cb_i_s[index];
+  }
+  // wrapp CB_S_I_S_S
+  CB_S_I_S_S _wrapper_cpp_function(const std::function<void(const std::string&,int,const std::string&,const std::string&)>& cpp_function)
+  {
+    int index=FuncPoolManager::get_instance().get_cb_s_i_s_s_index();
+    while(index<0){
+      std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME_FOR_GET_INDEX));
+      index=FuncPoolManager::get_instance().get_cb_s_i_s_s_index();
+    }
+    _cpp_function_cb_s_i_s_s[index]=cpp_function;
+    return _fps_cb_s_i_s_s[index];
+  }
+  // wrapp CB_S_I_S_S_I
+  CB_S_I_S_S_I _wrapper_cpp_function(const std::function<void(const std::string&,int,const std::string&,const std::string&,int)>& cpp_function)
+  {
+    int index=FuncPoolManager::get_instance().get_cb_s_i_s_s_i_index();
+    while(index<0){
+      std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME_FOR_GET_INDEX));
+      index=FuncPoolManager::get_instance().get_cb_s_i_s_s_i_index();
+    }
+    _cpp_function_cb_s_i_s_s_i[index]=cpp_function;
+    return _fps_cb_s_i_s_s_i[index];
+  }
+
+  // wrapp function to onetime function
+  CB_S _wrapper_callonce_cpp_function(const std::function<void(const std::string&)>& cpp_function) {
+    int index=FuncPoolManager::get_instance().get_cb_s_index();
+    while(index<0){
+      std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME_FOR_GET_INDEX));
+      index=FuncPoolManager::get_instance().get_cb_s_index();
+    }
+    _cpp_function_cb_s[index]=[cpp_function,index](const std::string& str)->void {
+      cpp_function(str);
+      FuncPoolManager::get_instance().release_cb_s_index(index);
+    };
+    return _fps_cb_s[index];
+  }
+  
+  CB_I_S _wrapper_callonce_cpp_function(const std::function<void(int,const std::string&)>& cpp_function)
+  {
+    int index=FuncPoolManager::get_instance().get_cb_i_s_index();
+    while(index<0){
+      std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME_FOR_GET_INDEX));
+      index=FuncPoolManager::get_instance().get_cb_i_s_index();
+    }
+    _cpp_function_cb_i_s[index]=[cpp_function,index](int code,const std::string& str)->void {
+      cpp_function(code,str);
+      FuncPoolManager::get_instance().release_cb_i_s_index(index);
+    };
+    return _fps_cb_i_s[index];
+  }
+  
+  CB_S_I_S_S _wrapper_callonce_cpp_function(const std::function<void(const std::string&,int,const std::string&,const std::string&)>& cpp_function)
+  {
+    int index=FuncPoolManager::get_instance().get_cb_s_i_s_s_index();
+    while(index<0){
+      std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME_FOR_GET_INDEX));
+      index=FuncPoolManager::get_instance().get_cb_s_i_s_s_index();
+    }
+    _cpp_function_cb_s_i_s_s[index]=[cpp_function,index](const std::string& operationID,int code,const std::string& str,const std::string& str2)->void {
+      cpp_function(operationID,code,str,str2);
+      FuncPoolManager::get_instance().release_cb_s_i_s_s_index(index);
+    };
+    return _fps_cb_s_i_s_s[index];
+  }
+  
+  CB_S_I_S_S_I _wrapper_callonce_cpp_function(const std::function<void(const std::string&,int,const std::string&,const std::string&,int)>& cpp_function)
+  {
+    int index=FuncPoolManager::get_instance().get_cb_s_i_s_s_i_index();
+    // while loop util get a available index
+    while(index<0){
+      std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME_FOR_GET_INDEX));
+      index=FuncPoolManager::get_instance().get_cb_s_i_s_s_i_index();
+    }
+    _cpp_function_cb_s_i_s_s_i[index]=[cpp_function,index](const std::string& operationID,int code,const std::string& str,const std::string& str2,int c_int)->void {
+      cpp_function(operationID,code,str,str2,c_int);
+      FuncPoolManager::get_instance().release_cb_s_i_s_s_i_index(index);
+    };
+    return _fps_cb_s_i_s_s_i[index];
+  }
+
+}
+
+
+namespace openim{
+
+class OpenIMManager
+{
+private:
+OpenIMManager(){}
+public:
+  // instance pattern
+  static OpenIMManager& GetInstance();
+
+  //must be called before use sdk
+  bool InitSDK(const std::function<void(int, const std::string&)>& cCallback,const std::string& operationID,const std::string& config);
+
+  void UnInitSDK(const std::string& operationID);
+
+  // // set print
+  // void SetPrint(const std::function<void(const std::string&)>& printCallBack);
+
+  // set group listener
+  void SetGroupListener(const std::function<void(int,const std::string&)>& groupListenerCallBack);
+
+  // set conversation listener
+  void SetConversationListener(const std::function<void(int, const std::string &)>& conversationListenerCallback);
+
+  // set advanced msg listener
+  void SetAdvancedMsgListener(const std::function<void(int, const std::string &)>& advancedMsgListenerCallback);
+
+  // set batch msg listener
+  void SetBatchMsgListener(const std::function<void(int, const std::string &)>& batchMsgListenerCallback);
+
+  // set user listener
+  void SetUserListener(const std::function<void(int, const std::string &)>& userListenerCallback);
+
+  // set friend listener
+  void SetFriendListener(const std::function<void(int, const std::string &)>& friendListenerCallback);
+
+  // set custom business listener
+  void SetCustomBusinessListener(const std::function<void(int, const std::string &)>& customBusinessListenerCallback);
+
+  // login
+  void Login(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& loginCallback, const std::string& operationID, const std::string& uid, const std::string& token);
+
+  // logout
+  void Logout(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& logoutCallback, const std::string& operationID);
+
+  // network status changed
+  void NetworkStatusChanged(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& networkStatusCallback, const std::string& operationID);
+
+  // get login status
+  GoInt GetLoginStatus(const std::string& operationID);
+
+  // get login user
+  std::string GetLoginUser();
+
+  // create text message
+  std::string CreateTextMessage(const std::string& operationID, const std::string& text);
+
+  // create advanced text message
+  std::string CreateAdvancedTextMessage(const std::string& operationID, const std::string& text, const std::string& messageEntityList);
+
+  // create text at message
+  std::string CreateTextAtMessage(const std::string& operationID, const std::string& text, const std::string& atUserList, const std::string& atUsersInfo, const std::string& message);
+
+  // create location message
+  std::string CreateLocationMessage(const std::string& operationID, const std::string& description, double longitude, double latitude);
+
+  // create custom message
+  std::string CreateCustomMessage(const std::string& operationID, const std::string& data, const std::string& extension, const std::string& description);
+
+  // create quote message
+  std::string CreateQuoteMessage(const std::string& operationID, const std::string& text, const std::string& message);
+
+  
+  // create advanced quote message
+  std::string CreateAdvancedQuoteMessage(const std::string& operationID, const std::string& text, const std::string& message, const std::string& messageEntityList);
+
+  // create card message
+  std::string CreateCardMessage(const std::string& operationID, const std::string& cardInfo);
+
+  // create video message from full path
+  std::string CreateVideoMessageFromFullPath(const std::string& operationID, const std::string& videoFullPath, const std::string& videoType, long long int duration, const std::string& snapshotFullPath);
+
+  // create image message from full path
+  std::string CreateImageMessageFromFullPath(const std::string& operationID, const std::string& imageFullPath);
+
+  // create sound message from full path
+  std::string CreateSoundMessageFromFullPath(const std::string& operationID, const std::string& soundPath, long long int duration);
+
+  // create file message from full path
+  std::string CreateFileMessageFromFullPath(const std::string& operationID, const std::string& fileFullPath, const std::string& fileName);
+
+  // create image message
+  std::string CreateImageMessage(const std::string& operationID, const std::string& imagePath);
+
+
+  // create image message by URL
+  std::string CreateImageMessageByURL(const std::string& operationID, const std::string& sourcePicture, const std::string& bigPicture, const std::string& snapshotPicture);
+
+  // create sound message by URL
+  std::string CreateSoundMessageByURL(const std::string& operationID, const std::string& soundBaseInfo);
+
+  // create sound message
+  std::string CreateSoundMessage(const std::string& operationID, const std::string& soundPath, long long int duration);
+
+  // create video message by URL
+  std::string CreateVideoMessageByURL(const std::string& operationID, const std::string& videoBaseInfo);
+
+  // create video message
+  std::string CreateVideoMessage(const std::string& operationID, const std::string& videoPath, const std::string& videoType, long long int duration, const std::string& snapshotPath);
+
+  // create file message by URL
+  std::string CreateFileMessageByURL(const std::string& operationID, const std::string& fileBaseInfo);
+
+  // create file message
+  std::string CreateFileMessage(const std::string& operationID, const std::string& filePath, const std::string& fileName);
+
+  // create merger message
+  std::string CreateMergerMessage(const std::string& operationID, const std::string& messageList, const std::string& title, const std::string& summaryList);
+
+  // create face message
+  std::string CreateFaceMessage(const std::string& operationID, int index, const std::string& data);
+
+  // create forward message
+  std::string CreateForwardMessage(const std::string& operationID, const std::string& m);
+
+  // get all conversation list
+  void GetAllConversationList(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& getAllConversationListCallback, const std::string& operationID);
+  
+  // get advanced history message list
+  void GetAdvancedHistoryMessageList(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& getAdvancedHistoryCallback , const std::string& operationID, const std::string& getMessageOptions);
+
+  // send message
+  void SendMessage(const std::function<void(const std::string&, int, const std::string&, const std::string&, int)>& callback, const std::string& operationID, const std::string& message, const std::string& recvID, const std::string& groupID, const std::string& offlinePushInfo);
+
+  // // =====================================================user===============================================
+  // //
+
+  // get users info
+  void GetUsersInfo(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& userIDs);
+
+  // get users info from server
+  void GetUsersInfoFromServer(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& userIDs);
+
+  // set self info
+  void SetSelfInfo(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& userInfo);
+
+  // get self user info
+  void GetSelfUserInfo(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID);
+
+  // update message sender info
+  void UpdateMessageSenderInfo(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& nickname, const std::string& faceURL);
+
+  // subscribe users status
+  void SubscribeUsersStatus(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& userIDs);
+
+
+  // unsubscribe users status
+  void UnsubscribeUsersStatus(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& userIDs);
+
+  // get subscribe users status
+  void GetSubscribeUsersStatus(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID);
+  
+  // get user status
+  void GetUserStatus(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& userIDs);
+
+  // // =====================================================friend===============================================
+  // //
+
+  // get specified friends info
+  void GetSpecifiedFriendsInfo(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& userIDs);
+
+  // get friend list
+  void GetFriendList(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID);
+
+  // get friend list page
+  void GetFriendListPage(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, int offset, int count);
+
+  // search friends
+  void SearchFriends(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& searchParam);
+
+  // check friend
+  void CheckFriend(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& userIDs);
+
+  // add friend
+  void AddFriend(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& userIDReqMsg);
+
+  // set friend remark
+  void SetFriendRemark(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& userIDRemark);
+
+  // delete friend
+  void DeleteFriend(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& friendUserID);
+
+  // get friend application list as recipient
+  void GetFriendApplicationListAsRecipant(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID);
+
+  // get friend application list as applicant
+  void GetFriendApplicationListAsApplicant(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID);
+
+  // accept friend application
+  void AcceptFriendApplication(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& userIDHandleMsg);
+
+  // refuse friend application
+  void RefuseFriendApplication(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& userIDHandleMsg);
+
+  // add black
+  void AddBlack(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& blackUserID);
+
+  // get black list
+  void GetBlackList(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID);
+
+  // remove black
+  void RemoveBlack(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& removeUserID);
+
+
+  // // =====================================================group===============================================
+  // // 
+
+  // create group
+  void CreateGroup(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& groupReqInfo);
+
+  // join group
+  void JoinGroup(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& groupID, const std::string& reqMsg, int joinSource);
+
+  // quit group
+  void QuitGroup(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& groupID);
+
+  // dismiss group
+  void DismissGroup(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& groupID);
+
+  // change group mute
+  void ChangeGroupMute(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& groupID, bool isMute);
+
+  // change group member mute
+  void ChangeGroupMemberMute(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& groupID, const std::string& userID, int mutedSeconds);
+
+  // SetGroupMemberRoleLevel sets the role level of a group member
+  void SetGroupMemberRoleLevel(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& groupID, const std::string& userID, int roleLevel);
+
+  // SetGroupMemberInfo sets the information of a group member
+  void SetGroupMemberInfo(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& groupMemberInfo);
+
+  // GetJoinedGroupList retrieves the list of joined groups
+  void GetJoinedGroupList(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID);
+
+  // GetSpecifiedGroupsInfo retrieves the information of specified groups
+  void GetSpecifiedGroupsInfo(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& groupIDList);
+
+  // SearchGroups searches for groups
+  void SearchGroups(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& searchParam);
+
+  // SetGroupInfo sets the information of a group
+  void SetGroupInfo(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& groupInfo);
+
+  // SetGroupVerification sets the verification mode of a group
+  void SetGroupVerification(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& groupID, int verification);
+
+
+  // SetGroupLookMemberInfo sets the member information visibility of a group
+  void SetGroupLookMemberInfo(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& groupID, int rule);
+
+  // SetGroupApplyMemberFriend sets the friend rule for group applicants
+  void SetGroupApplyMemberFriend(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& groupID, int rule);
+
+  // GetGroupMemberList retrieves the list of group members
+  void GetGroupMemberList(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& groupID, int filter, int offset, int count);
+
+  // GetGroupMemberOwnerAndAdmin retrieves the owner and admin members of a group
+  void GetGroupMemberOwnerAndAdmin(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& groupID);
+
+  // GetGroupMemberListByJoinTimeFilter retrieves the list of group members filtered by join time
+  void GetGroupMemberListByJoinTimeFilter(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& groupID, int offset, int count, long long int joinTimeBegin, long long int joinTimeEnd, const std::string& filteruserIDs);
+
+  // GetSpecifiedGroupMembersInfo retrieves the information of specified group members
+  void GetSpecifiedGroupMembersInfo(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& groupID, const std::string& userIDs);
+
+  // KickGroupMember kicks group members
+  void KickGroupMember(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& groupID, const std::string& reason, const std::string& userIDs);
+
+  // TransferGroupOwner transfers the ownership of a group
+  void TransferGroupOwner(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& groupID, const std::string& newOwnerUserID);
+
+  // InviteUserToGroup invites users to a group
+  void InviteUserToGroup(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& groupID, const std::string& reason, const std::string& userIDs);
+
+  // GetGroupApplicationListAsRecipient retrieves the group application list as a recipient
+  void GetGroupApplicationListAsRecipient(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID);
+
+  // GetGroupApplicationListAsApplicant retrieves the group application list as an applicant
+  void GetGroupApplicationListAsApplicant(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID);
+
+  // AcceptGroupApplication accepts a group application
+  void AcceptGroupApplication(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& groupID, const std::string& fromUserID, const std::string& handleMsg);
+
+  // RefuseGroupApplication refuses a group application
+  void RefuseGroupApplication(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& groupID, const std::string& fromUserID, const std::string& handleMsg);
+
+  // SetGroupMemberNickname sets the nickname of a group member
+  void SetGroupMemberNickname(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& groupID, const std::string& userID, const std::string& groupMemberNickname);
+
+  // SearchGroupMembers searches for group members
+  void SearchGroupMembers(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& searchParam);
+
+  // IsJoinGroup checks if the user has joined a group
+  void IsJoinGroup(const std::function<void(const std::string&, int, const std::string&, const std::string&)>& callback, const std::string& operationID, const std::string& groupID);
+
+};
+
+}

c_cpp_wrapper/test.cc

@@ -0,0 +1,44 @@
+#include <iostream>
+#include <functional>
+#include <thread>
+#include <chrono>
+#include "openimsdkcc.h"
+using namespace std;
+using namespace openim;
+
+// simple test
+int main(){
+  auto sdkMgr = OpenIMManager::GetInstance();
+  string operationID="12345";
+  string uid= "openIM123";
+  string token="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJVc2VySUQiOiJvcGVuSU0xMjMiLCJQbGF0Zm9ybUlEIjo2LCJleHAiOjE3MDkxMjQ2NzYsIm5iZiI6MTcwMTM0ODM3NiwiaWF0IjoxNzAxMzQ4Njc2fQ.EqlV5TlpiElYhUOHCEcSrZOWi9ldrUMR1L4q0blvxs0";
+  string jsonString="{\"platformID\": 6, \"apiAddr\": \"http://14.29.168.56:10002\", \"wsAddr\":\"ws://14.29.168.56:10001\",\"dataDir\": \"./\", \"logLevel\": 5, \"isLogStandardOutput\": true, \"logFilePath\": \"./\", \"isExternalExtensions\": true}";
+  bool init_result = sdkMgr.InitSDK([](int event,const string& data){
+    cout<<"init> "<<"event:"<<event<<" data:"<<data<<endl;
+  },operationID, jsonString);
+  cout<<"init_result:"<<init_result<<endl;
+
+  sdkMgr.SetConversationListener([](int event,const string& data){
+    cout<<"conversation> "<<"event:"<<event<<" data:"<<data<<endl;
+  });
+  sdkMgr.SetAdvancedMsgListener([](int event,const string& data){
+    cout<<"advancedMsg> "<<"event:"<<event<<" data:"<<data<<endl;
+  });
+  sdkMgr.Login([](const string& operationID ,int errCode,const string& errMsg, const string& data){
+    cout<<"login> " <<"operationID: "<<operationID<<" ,errCode: "<<errCode << "errMsg: "<<errMsg<< ", data: "<<data<<endl; 
+  },operationID,uid,token);
+  std::this_thread::sleep_for(std::chrono::seconds(10));
+
+  // can only execute below function after login
+  string loginUserID=sdkMgr.GetLoginUser();
+  cout<<"loginUserID:"<<loginUserID<<endl;
+  string operationID1="12345,create";
+  string messge=sdkMgr.CreateTextMessage(operationID1,"CCM");
+  string operationID2="12345,get_all_conversation_list";
+  sdkMgr.GetAllConversationList([](const string& operationID,int errCode ,const string& errMsg,const string& data){
+    cout<<"getAllConversationList> "<<"data:"<<data<<endl;
+  },operationID2);
+  // std::this_thread::sleep_for(std::chrono::seconds(1000));
+  while(true);
+  return 0;
+}