Use a callback template (OnTeamEventCallback) and call the RegTeamEventCb method to listen for group event notifications.

For information about group events, see TeamEvent.

Sample code:

void OnTeamEventCallback(const nim::TeamEvent& result)
{
	···
}

foo()
{
	nim::Team::RegTeamEventCb(&OnTeamEventCallback);
}

For some query interfaces, separate callback templates are avaiable. For more information, see nim::Team.

Use the callback function (nim_team_event_cb_func) and call the nim_team_reg_team_event_cb method to listen for group event notifications.

For the enumeration of group notification events, see NIMNotificationId.

Sample code:

void CallbackTeamEvent(int error, int team_event, const char *tid, const char* str, const char *json_exten, const void *user_data)
{
	switch (team_event)
	{
	case kNIMNotificationIdLocalCreateTeam:
		...
	...	
	}
}

typedef void(*nim_team_reg_team_event_cb)(const char *json_extension, nim_team_event_cb_func cb, const void *user_data);

void foo()
{
	nim_team_reg_team_event_cb func = (nim_team_reg_team_event_cb) GetProcAddress(hInst, "nim_team_reg_team_event_cb");
	func(nullptr, &CallbackTeamEvent, nullptr);
}

For some query interfaces, separate callback function definitions are available. For more information, see nim_team_def.

Create a group by calling the CreateTeamAsync method. The creator becomes the group owner.

Parameters:

** Sample code:**

void OnTeamEventCallback(const nim::TeamEvent& result)
{
	...
}
void foo()
{
	std::list<std::string> id_list;
	id_list.push_back("test1");
	id_list.push_back("test2");

	nim::TeamInfo tinfo;
	tinfo.SetName("test");
	tinfo.SetType(nim::kNIMTeamTypeNormal);
	nim::Team::CreateTeamAsync(tinfo, id_list, "", &OnTeamEventCallback);
}

Error codes

Create a group by calling the nim_team_create_team_async method, The creator becomes the group owner.

** Sample code:**

void CallbackCreateTeam(int error, int team_event, const char *tid, const char* str, const char *json_exten, const void *user_data)
{
	...
}	
typedef void(*nim_team_create_team_async)(const char *team_info, const char *jsonlist_uids, const char *invitation_postscript, const char *json_extension, nim_team_event_cb_func cb, const void* user_data);
void foo()
{
	Json::Value team_info;
	team_info[kNIMTeamInfoKeyName] = ; // Group name
	team_info[kNIMTeamInfoKeyType] = ; // Group type
	team_info[kNIMTeamInfoKeyIntro] = ; // Introduction
	team_info[kNIMTeamInfoKeyJoinMode] = ; // Verification type
	team_info[kNIMTeamInfoKeyAnnouncement] = ; // Announcement

	Json::Value team_member;
	team_member.append("litianyi01");	
	team_member.append("litianyi02");

	nim_team_create_team_async func = (nim_team_create_team_async) GetProcAddress(hInst, "nim_team_create_team_async");
	func(team_info.toStyledString().c_str(), team_member.toStyledString().c_str(), "welcome to new team", nullptr, &CallbackCreateTeam, nullptr);
}

Invite users to join a group by calling the InviteAsync method.

• If the invitation mode NIMTeamBeInviteMode of the group is kNIMTeamBeInviteModeNotNeedAgree, users can join the group without verification.
• If the invitation mode NIMTeamBeInviteMode of the group is set to ``kNIMTeamBeInviteModeNeedAgree`, the invited user must accpets the invitation before joining the group.

If an invited member has reached the upper limit of joined groups, the accounts failing to join the group are returned.

Parameters:

• After the invitation is sent, the invited user will receive a NIMSysMsgTypesystem notification of kNIMSysMsgTypeTeamInvite type.
• The invited user can join the group by call the AcceptInvitationAsync method to accept the invitation. All group members will receive a notification of kNIMMessageTypeNotification and the trigger event is kNIMNotificationIdTeamInviteAccept.
• The invited user can also reject the invitation by calling the RejectInvitationAsync method. If rejecting the invitation, the invited user receives a system notification NIMSysMsgType of type kNIMSysMsgTypeTeamInviteReject.

** Sample code:**

void OnTeamEventCallback(const nim::TeamEvent& result)
{
	···
}

void foo()
{
	const std::list<std::string> friend_list;
	friend_list.push_back("test1");
	friend_list.push_back("test2");
	nim::Team::InviteAsync("123445", friend_list, "", &OnTeamEventCallback);
}

//Accept an invitation
void TeamEventCb(const nim::TeamEvent& team_event)
{
	···
}

void foo()
{
	nim::Team::AcceptInvitationAsync("12345", "my_id", &TeamEventCb);
}

//Reject the invitation
void TeamEventCb(const nim::TeamEvent& team_event)
{
	···
}

void foo()
{
	nim::Team::RejectInvitationAsync("12345", "my_id", "", &TeamEventCb);
}

Error codes

Invite users to join a group by calling the nim_team_invite_async method.

• If the invitation mode NIMTeamBeInviteMode of the group is kNIMTeamBeInviteModeNotNeedAgree, users can join the group without verification.

• If the invitation mode NIMTeamBeInviteMode of the group is set to ``kNIMTeamBeInviteModeNeedAgree`, the invited user must accpets the invitation before joining the group.

• After the invitation is sent, the invited user will receive a NIMSysMsgTypesystem notification of kNIMSysMsgTypeTeamInvite type.

• The invited user can join the group by call the nim_team_accept_invitation_async method. All group members will receive a notification of kNIMMessageTypeNotification and the trigger event is kNIMNotificationIdTeamInviteAccept.

• The invited user can also reject the invitation by calling the nim_team_reject_invitation_async method. If rejecting the invitation, the invited user receives a system notification NIMSysMsgType of type kNIMSysMsgTypeTeamInviteReject.

** Sample code:**

void CallbackTeamChange(int res_code, int notification_id, const char *tid, const char *result, const char *json_extension, const void *user_data)
{
	//
}

typedef void(*nim_team_invite_async)(const char *tid, const char *jsonlist_uids, const char *invitation_postscript, const char *json_extension, nim_team_event_cb_func cb, const void* user_data);

void foo()
{
	Json::Value friend_list;
	friend_list.append("litianyi01");	
	friend_list.append("litianyi02");

	nim_team_invite_async func = (nim_team_invite_async) GetProcAddress(hInst, "nim_team_invite_async");
	func("12345", friend_list.toStyledString().c_str(), "welcome to new team", "", &CallbackCreateTeam, nullptr);
}

//Accept an invitation
void TeamEventCb(int res_code, int notification_id, const char *tid, const char *result, const char *json_extension, const void *user_data)
{
	···
}

typedef void(*nim_team_accept_invitation_async)(const char *tid, const char *invitor, const char *json_extension, nim_team_event_cb_func cb, const void* user_data);

void foo()
{
	nim_team_accept_invitation_async func = (nim_team_accept_invitation_async) GetProcAddress(hInst, "nim_team_accept_invitation_async");
	func("12345", "my_id", "", &TeamEventCb, nullptr);
}

//Reject the invitation
void TeamEventCb(int res_code, int notification_id, const char *tid, const char *result, const char *json_extension, const void *user_data)
{
	···
}

typedef void(*nim_team_reject_invitation_async)(const char *tid, const char *invitor, const char *reason, const char *json_extension, nim_team_event_cb_func cb, const void* user_data);

void foo()
{
	nim_team_reject_invitation_async func = (nim_team_reject_invitation_async) GetProcAddress(hInst, "nim_team_reject_invitation_async");
	func("12345", "my_id", "", "", &TeamEventCb, nullptr);
}

You can request to join a group by calling the ApplyJoinAsync method.

• If the option for NIMTeamJoinMode is kNIMTeamJoinModeNoAuth, users can join the group without verification.
• If the option for NIMTeamJoinMode is set to kNIMTeamJoinModeNeedAuth, the group owner or administrators must approve requests to join the group.
• If the option for NIMTeamJoinMode is kNIMTeamJoinModeRejectAll, the group does not accept requests. Users can only join the group by invitation.

Parameters:

• If a user sends a join request, the group owner and administrators receive a system notification NIMSysMsgType of type kNIMSysMsgTypeTeamApply .
• The group owner and administrators can approve the request by calling the PassJoinApplyAsync method. All group members will receive a notification of kNIMMessageTypeNotification and the trigger event is kNIMNotificationIdTeamApplyPass.
• The group owner and group administrators can also reject the request by calling the RejectJoinApplyAsync method. If a request is rejected, the requester receives a system notification NIMSysMsgType of type kNIMSysMsgTypeTeamReject .

** Sample code:**

void OnApplyJoinCb(const nim::TeamEvent& team_event)
{
	QLOG_APP(L"apply join: {0}") << team_event.res_code_;
	
	switch (team_event.res_code_)
	{
	case nim::kNIMResTeamAlreadyIn:
	{
		···
	}
	break;
	case nim::kNIMResSuccess:
	{
		···
	}
	break;
	case nim::kNIMResTeamApplySuccess:
		···
		break;
	default:
	{
		···
	}
	break;
	}
}

void foo()
{
	nim::Team::ApplyJoinAsync("12345", "", &OnApplyJoinCb);
}

// Approve a request

void TeamEventCb(const nim::TeamEvent& team_event)
{
	switch (team_event.res_code_)
	{
	case nim::kNIMResTeamAlreadyIn:
	{
		···
	}
	break;
	case nim::kNIMResSuccess:
	{
		···
	}
	break;
	case nim::kNIMResTeamApplySuccess:
		···
		break;
	default:
	{
		···
	}
	break;
	}
}

void foo()
{
	nim::Team::PassJoinApplyAsync("12345", "my_id", &TeamEventCb);
}

//Reject a request

void TeamEventCb(const nim::TeamEvent& team_event)
{
	switch (team_event.res_code_)
	{
	case nim::kNIMResTeamAlreadyIn:
	{
		···
	}
	break;
	case nim::kNIMResSuccess:
	{
		···
	}
	break;
	case nim::kNIMResTeamApplySuccess:
		···
		break;
	default:
	{
		···
	}
	break;
	}
}

void foo()
{
	nim::Team::RejectJoinApplyAsync("12345", "sender_id", "", &TeamEventCb);
}

Error codes

You can request to join a group by calling the nim_team_apply_join_async method.

• If the option for NIMTeamJoinMode is kNIMTeamJoinModeNoAuth, users can join the group without verification.

• If the option for NIMTeamJoinMode is set to kNIMTeamJoinModeNeedAuth, the group owner or administrators must approve requests to join the group.

• If the option for NIMTeamJoinMode is kNIMTeamJoinModeRejectAll, the group does not accept requests. Users can only join the group by invitation.

• If a user sends a join request, the group owner and administrators receive a system notification NIMSysMsgType of type kNIMSysMsgTypeTeamApply .

• The group owner and administrators can approve the request by calling the nim_team_pass_join_apply_async method. All group members will receive a notification of kNIMMessageTypeNotification and the trigger event is kNIMNotificationIdTeamApplyPass.

• The group owner and group administrators can also reject the request by calling the nim_team_reject_join_apply_async method. If a request is rejected, the requester receives a system notification NIMSysMsgType of type kNIMSysMsgTypeTeamReject .

** Sample code:**

void TeamEventCb(int res_code, int notification_id, const char *tid, const char *result, const char *json_extension, const void *user_data)
{
	···
}

typedef void(*nim_team_apply_join_async)(const char *tid, const char *reason, const char *json_extension, nim_team_event_cb_func cb, const void* user_data);

void foo()
{
	nim_team_apply_join_async func = (nim_team_apply_join_async) GetProcAddress(hInst, "nim_team_apply_join_async");
	func("12345", "", "", &TeamEventCb, nullptr);
}

// Approve the request
void TeamEventCb(int res_code, int notification_id, const char *tid, const char *result, const char *json_extension, const void *user_data)
{
	···
}

typedef void(*nim_team_pass_join_apply_async)(const char *tid, const char *applicant_id, const char *json_extension, nim_team_event_cb_func cb, const void* user_data);

void foo()
{
	nim_team_pass_join_apply_async func = (nim_team_pass_join_apply_async) GetProcAddress(hInst, "nim_team_pass_join_apply_async");
	func("12345", "my_id", "", &TeamEventCb, nullptr);
}

// Reject the request
void TeamEventCb(int res_code, int notification_id, const char *tid, const char *result, const char *json_extension, const void *user_data)
{
	···
}

typedef void(*nim_team_reject_join_apply_async)(const char *tid, const char *applicant_id, const char *reason, const char *json_extension, nim_team_event_cb_func cb, const void* user_data);

void foo()
{
	nim_team_reject_join_apply_async func = (nim_team_reject_join_apply_async) GetProcAddress(hInst, "nim_team_reject_join_apply_async");
	func("12345", "sender_id", "", &TeamEventCb, nullptr);
}

The group owner can transfer the ownership of a group by calling TransferTeamAsync method.

• After the ownership of the group is transferred, all group members will receive a notification of kNIMMessageTypeNotification and the trigger event is kNIMNotificationIdTeamOwnerTransfer.
• If you leave the group while transferring the ownership, call [quitTeam](https://doc.yunxin.163.com/docs/interface/IM_Android/com/netease/nimlib/sdk /team/TeamService.html#quitTeam-java.lang.String-) to leave the group. All group members will receive a notification of kNIMMessageTypeNotification and the trigger event is kNIMNotificationIdTeamLeave.

Parameters:

** Sample code:**

void OnTeamEventCallback(const nim::TeamEvent& result)
{
	···
}

foo()
{
	nim::Team::TransferTeamAsync("tid_", "user_id", false, &OnTeamEventCallback);
}

Error codes

The group owner can transfer the ownership of a group by calling nim_team_transfer_team_async method.

• After the ownership of the group is transferred, all group members will receive a notification of kNIMMessageTypeNotification and the trigger event is kNIMNotificationIdTeamOwnerTransfer.
• If the group owner leaves the group while transferring the ownership, call the nim_team_leave_async method. All group members will receive a notification of kNIMMessageTypeNotification and the trigger event is kNIMNotificationIdTeamLeave.

** Sample code:**

void CallbackTeamOperate(int error, int team_operate, const char *tid, const char* str, const char *json_exten, const void *user_data)
{
	if (error == kNIMResSuccess)
	{
		...
	}
	else
	{
		...
	}
}

typedef void(*nim_team_transfer_team_async)(const char *tid, const char *new_owner, bool is_leave, const char *json_extension, nim_team_event_cb_func cb, const void* user_data);

void foo()
{
	nim_team_transfer_team_async func = (nim_team_transfer_team_async) GetProcAddress(hInst, "nim_team_transfer_team_async");
	func("tid", "user_id", false, nullptr, &CallbackTeamOperate, nullptr);
}

Remove a member from a group by calling the KickAsync method.

Parameters:

** Sample code:**

Team::KickAsync("tid", {123456, 456789}, [this](const TeamEvent& team_event) {
	// process team_event
});

Error codes

Remove a member from a group by calling the nim_team_kick_async method.

** Sample code:**

void TeamEventCb(int res_code, int notification_id, const char *tid, const char *result, const char *json_extension, const void *user_data)
{
	···
}

typedef void(*nim_team_kick_async)(const char *tid, const char *jsonlist_uids, const char *json_extension, nim_team_event_cb_func cb, const void* user_data);

void foo()
{
	nim_team_kick_async func = (nim_team_kick_async) GetProcAddress(hInst, "nim_team_kick_async");

	Json::Value json_value;
	json_value.append("litianyi01");	
	json_value.append("litianyi02");

	func("12345", json_value.toStyledString().c_str(), "", &TeamEventCb, nullptr);
}

Leave a group by calling the LeaveAsync method.

Parameters:

** Sample code:**

void TeamEventCb(const nim::TeamEvent& team_event)
{
	···
}

void foo()
{
	nim::Team::LeaveAsync("12345", &TeamEventCb);
}

Error codes

Leave a group by calling the nim_team_leave_async method.

** Sample code:**

void TeamEventCb(int res_code, int notification_id, const char *tid, const char *result, const char *json_extension, const void *user_data)
{
	···
}

typedef void(*nim_team_leave_async)(const char *tid, const char *json_extension, nim_team_event_cb_func cb, const void* user_data);

void foo()
{
	nim_team_leave_async func = (nim_team_leave_async) GetProcAddress(hInst, "nim_team_leave_async");

	func("12345", "", &TeamEventCb, nullptr);
}

Delete a group by calling the DismissAsync method.

Parameters:

** Sample code:**

void OnTeamEventCallback(const nim::TeamEvent& result)
{
	···
}

foo()
{
	nim::Team::DismissAsync("tid_", &OnTeamEventCallback);
}

Error codes

Delete a group by calling the nim_team_dismiss_async method.

** Sample code:**

void CallbackTeamOperate(int error, int team_operate, const char *tid, const char* str, const char *json_exten, const void *user_data)
{
	if (error == kNIMResSuccess)
	{
		...
	}
	else
	{
		...
	}
}

typedef void(*nim_team_dismiss_async)(const char *tid, const char *json_extension, nim_team_event_cb_func cb, const void* user_data);

void foo()
{
	nim_team_dismiss_async func = (nim_team_dismiss_async) GetProcAddress(hInst, "nim_team_dismiss_async");
	func("tid", nullptr, &CallbackTeamOperate, nullptr);
}

Update the group profile by calling the UpdateTeamInfoAsync method.

Parameters:

** Sample code:**

void OnUpdateBroadCb(const nim::TeamEvent& team_event)
{
	if (team_event.res_code_ == 200)
	{
		···
	}
}

void foo()
{
	Json::Value broad;
	broad["title"] = "title";
	broad["content"] = "Content ";
	broad["creator"] = "test_user";

	Json::Value broads;
	broads.append(broad);

	Json::FastWriter writer;
	nim::TeamInfo param;
	param.SetAnnouncement(writer.write(broads));
	param.SetTeamID("tid_");

	nim::Team::UpdateTeamInfoAsync("tid_", param, &OnUpdateBroadCb);
}

Error codes

Update the group profile by calling the nim_team_update_team_info_async method.

** Sample code:**

void CallbackTeamOperate(int error, int team_operate, const char *tid, const char* str, const char *json_exten, const void *user_data)
{
	if (error == kNIMResSuccess)
	{
		...
	}
	else
	{
		...
	}
}

typedef void(*nim_team_update_team_info_async)(const char *tid, const char *json_info, const char *json_extension, nim_team_event_cb_func cb_func, const void* user_data);

void foo()
{
	Json::Value values;
	values[kNIMTeamInfoKeyID] = "tid";	
	values[kNIMTeamInfoKeyAnnouncement] = "123"; //Edit the group announcement. Similarly, the group name and introduction can be modified. For details, see the API document.

	nim_team_update_team_info_async func = (nim_team_update_team_info_async) GetProcAddress(hInst, "nim_team_update_team_info_async");
	func("tid", values.toStyledString().c_str(), nullptr, &CallbackTeamOperate, nullptr);
}

Query all groups the current user has joined from the local database by calling the QueryAllMyTeamsAsync method.

Sample code:

Team::QueryAllMyTeamsAsync([this](int count, const std::list<std::string>& team_id_list) {
	std::string ids;
	for (auto&& tid : team_id_list) {
		ids += tid + ";";
	}
	std::cout << "[Team] QueryAllMyTeamsAsync. count: " << count << ", team_ids: " << ids << std::endl;
});

Query all groups the current user has joined from the local database by calling the nim_team_query_all_my_teams_async method.

Sample code:

static void CallbackFunc(int team_count, const char* result, const char* json_extension, const void* user_data){
    printf("team_count: %d\n", team_count);
    printf("result: %s\n", result);
};
nim_team_query_all_my_teams_async("", &CallbackFunc, nullptr);

Query all groups the current user has joined from the local database by calling the QueryAllMyTeamsInfoAsync method.

Sample code:

Team::QueryAllMyTeamsInfoAsync([this](int count, const std::list<TeamInfo>& team_info_list) {
	std::cout << "count: " << count << std::endl;
	for (auto& info : team_info_list) {
		// process team_info
	}
});

Query all groups the current user has joined from the local database by calling the nim_team_query_all_my_teams_info_async method.

Sample code:

static void CallbackFunc(int team_count, const char* result, const char* json_extension, const void* user_data){
	printf("team_count: %d, result: %s, json_extension: %s\n", team_count, result, json_extension);
};
nim_team_query_all_my_teams_info_async("", &CallbackFunc, nullptr);

Query the information about a specified group by asynchronous calling the QueryTeamInfoAsync method or synchronous calling the QueryTeamInfoBlock method.

Sample code:

// asynchronous call
Team::QueryTeamInfoAsync(params["tid"].asString(), [this](const std::string& tid, const TeamInfo& result) {
	std::cout << "[Team] QueryTeamInfoAsync. team_id: " << tid << std::endl;
});

//synchronous call
TeamInfo result = Team::QueryTeamInfoBlock("tid");
std::cout << "[Team] QueryTeamInfoAsync. team_id: " << result.GetTeamID() << std::endl;

Query the information about a specified group by asynchronous calling the nim_team_query_team_info_async method or synchronous calling the nim_team_query_team_info_block method.

Sample code:

// asynchronous call
static void CallbackFunc(const char* tid, const char* result, const char* json_extension, const void* callback){
	std::cout << "tid:" << tid << std::endl;
};
nim_team_query_team_info_async("tid", "", &CallbackFunc, nullptr);

//synchronous call
const char* team_info = nim_team_query_team_info_block("tid");
prinf("team_info: %s\n", team_info);

Query the information about specified groups by group ID by calling the GetTeaminfoList method.

Sample code:

Team::GetTeaminfoList({"tid1", "tid2", "tid3"}, [](NIMResCode error_code, const std::list<nim::TeamInfo>& team_info_list, const std::list<std::string>& fail_list){
	std::cout << "GetTeaminfoList error_code:" << error_code << std::endl;
});

Query the information about specified groups by group ID by calling the nim_team_get_team_info_list method.

Sample code:

static void CallbackFunc(int code, const char* tinfo_list, const char* fail_tid_list, const void* user_data){
	printf("nim_team_get_team_info_list code: %d", code);
};
nim_team_get_team_info_list("[\"tid1\", \"tid2\", \"tid3\"]", &CallbackFunc, NULL);

Query a specified group from the IM server by calling the QueryTeamInfoOnlineAsync method. Sample code:

Team::QueryTeamInfoOnlineAsync("tid", [this](const TeamEvent& team_event) {
	// process team_event
});

Query a specified group from the IM server by calling the nim_team_query_team_info_online_async method. Sample code:

static void CallbackTeamChange(int res_code,
    int notification_id,
    const char* tid,
    const char* result,
    const char* json_extension,
    const void* user_data) {
    // process result
}
nim_team_query_team_info_online_async("tid", "", &CallbackTeamChange, NULL);

Query all groups using keywords by calling the QueryTeamInfoByKeywordAsync method. Sample code:

Team::QueryTeamInfoByKeywordAsync("keyword", [this](int count, const std::list<TeamInfo>& team_info_list) {
	std::cout << "QueryTeamInfoByKeywordAsync count: " << count << std::endl;
});

Query all groups using keywords by calling the nim_team_query_teams_info_by_keyword method. Sample code:

static void CallbackQueryAllMyTeamsInfo(int team_count, const char* result, const char* json_extension, const void* user_data) {
    // process result
}
nim_team_query_teams_info_by_keyword("keyword", &CallbackQueryAllMyTeamsInfo, "", NULL);