群组管理
功能简介
本文档适用于开发以下平台的应用:iOS、Android、macOS、Windows、Web。
ZIM SDK 提供了群组管理功能,支持用户创建/解散群组、加入/退出群组,持久化维系群组关系。
群组管理功能可应用于办公群、社交群、兴趣群以及粉丝群等场景中,群组成员数量上限请参考 计费说明。
创建群组
客户端 A 登录 ZIM SDK 后,调用 createGroup 接口,设置高级配置,创建一个群组,此时 A 就是 群主
;其他客户端可以根据 A 创建的群组 groupID 加入群组。
开发者可以通过 ZIMGroupCreatedResult ,判断群组是否创建成功。相关错误码请查看 常见错误码。
- “groupID” 支持开发者自定义规则生成,仅支持数字,英文字符和 '!'、'#'、'$'、'%'、'&'、'('、')'、'+'、'-'、':'、';'、'<'、'='、'.'、'>'、'?'、'@'、'['、']'、'^'、'_'、'{'、'}'、'|'、'~',且不能以 ’#‘ 开头;若该字段为空,ZIM 服务器会自动生成。建议开发者将 “groupID” 设置为一个有意义的值,可将其与自己的业务账号系统进行关联。
- 调用 createGroup 接口创建群组后,会直接加入群组,无需再调用 joinGroup 接口加入群组。
- 用户创建群组时,该用户即是该群组的“群主”。如果想要转让身份,请参考 转让群主。
- 如需规定群组人数上限,以及入群模式(包括验证模式、邀请模式和被邀请人是否需要同意),请集成 2.15.0 或以上版本的 SDK。
ZIMGroupInfo groupInfo = new ZIMGroupInfo();
groupInfo.groupID = "group_id";
groupInfo.groupName = "groupName";
groupInfo.groupAvatarUrl = "groupAvatarUrl";
ZIMGroupAdvancedConfig config = new ZIMGroupAdvancedConfig();
HashMap<String, String> attributes = new HashMap<>();
attributes.put("key_0", "value_0");
attributes.put("key_1", "value_1");
attributes.put("key_2", "value_2");
config.groupAttributes = attributes;
config.joinMode = ZIMGroupJoinMode.ANY;
config.inviteMode = ZIMGroupInviteMode.ANY;
config.beInviteMode = ZIMGroupBeInviteMode.NONE;
config.maxMemberCount = 300;
ArrayList<String> userList = new ArrayList<>();
userList.add("user_1");
userList.add("user_2");
zim.createGroup(groupInfo, userList, config, new ZIMGroupCreatedCallback() {
@Override
public void onGroupCreated(ZIMGroupFullInfo groupInfo, ArrayList<ZIMGroupMemberInfo> userIDs, ArrayList<ZIMErrorUserInfo> errorUserList, ZIMError errorInfo) {
}
});
123456789101112131415161718192021222324252627282930313233
ZIMGroupInfo groupInfo = ZIMGroupInfo();
groupInfo.groupID = 'groupID';
groupInfo.groupName = 'groupName';
List<String> inviteUserIDs = ['userID1', 'userID2'];
ZIMGroupAdvancedConfig advancedConfig = ZIMGroupAdvancedConfig();
advancedConfig.joinMode = ZIMGroupJoinMode.any;
advancedConfig.inviteMode = ZIMGroupInviteMode.any;
advancedConfig.beInviteMode = ZIMGroupBeInviteMode.none;
advancedConfig.maxMemberCount = 300;
try{
await ZIM.getInstance()!.createGroup(groupInfo, inviteUserIDs,advancedConfig);
} on PlatformException catch(onError){
onError.code;
onError.message;
}
123456789101112131415161718192021222324
zim::ZIMGroupInfo group_info;
group_info.groupID = "group_id";
group_info.groupName = "groupName";
group_info.groupAvatarUrl = "groupAvatarUrl";
zim::ZIMGroupAdvancedConfig config;
config.groupAttributes.emplace("key_0", "value_0");
config.groupAttributes.emplace("key_1", "value_1");
config.groupAttributes.emplace("key_2", "value_2");
config.joinMode = zim::ZIMGroupJoinMode::ZIM_GROUP_JOIN_MODE_AUTH;
config.inviteMode = zim::ZIMGroupInviteMode::ZIM_GROUP_INVITE_MODE_ADMIN;
config.beInviteMode = zim::ZIMGroupBeInviteMode::ZIM_GROUP_BE_INVITE_MODE_AUTH;
config.maxMemberCount = 100;
std::vector<std::string> user_list;
user_list.push_back("user_1");
user_list.push_back("user_2");
zim_->createGroup(group_info, user_list, config,
[=](const zim::ZIMGroupFullInfo &groupInfo,
const std::vector<zim::ZIMGroupMemberInfo> &userList,
const std::vector<zim::ZIMErrorUser> &errorUserList,
zim::ZIMError errorInfo {
int error_code = errorInfo.code;
});
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253
var groupInfo = { groupID: '', groupName: '', groupAvatarUrl: '' };
var userIDs = [];
var config1 = {
joinMode: 1,
inviteMode: 1,
beInviteMode: 1,
maxMemberCount: 100
};
zim.createGroup(groupInfo, userIDs, config1)
.then(function ({ groupInfo, userList, errorUserList }) {
})
.catch(function (err) {
});
12345678910111213141516171819202122232425262728293031323334353637383940
ZIMGroupInfo *groupInfo = [[ZIMGroupInfo alloc] init];
groupInfo.groupID = @"groupID";
groupInfo.groupName = @"groupName";
groupInfo.groupAvatarUrl = @"groupAvatarUrl";
ZIMGroupAdvancedConfig *advancedConfig = [[ZIMGroupAdvancedConfig alloc] init];
advancedConfig.joinMode = ZIMGroupJoinModeAny;
advancedConfig.inviteMode = ZIMGroupInviteModeAny;
advancedConfig.beInviteMode = ZIMGroupBeInviteModeNone;
advancedConfig.maxMemberCount = 300;
[[ZIM getInstance] createGroup:groupInfo userIDs:@[@"userID1",@"userID2"] config:advancedConfig callback:^(ZIMGroupFullInfo * _Nonnull groupInfo, NSArray<ZIMGroupMemberInfo *> * _Nonnull userList, NSArray<ZIMErrorUserInfo *> * _Nonnull errorUserList, ZIMError * _Nonnull errorInfo) {
}];
12345678910111213141516171819202122
加入群组
如需用户加入群组后自动获取群历史消息,请联系 ZEGO 技术支持进行配置。
其他用户登录 ZIM SDK 后,可以通过主动加入或被邀请加入由 A 创建的群组。
如果用户加入成功后,全体群成员(包括该新成员)都会收到 groupMemberStateChanged 和 groupStateChanged 的回调通知:
zim.setEventHandler(new ZIMEventHandler(){
public void onGroupMemberStateChanged(ZIM zim, ZIMGroupMemberState state, ZIMGroupMemberEvent event, ArrayList<ZIMGroupMemberInfo> userList, ZIMGroupOperatedInfo operatedInfo, String groupID) {
}
public void onGroupStateChanged(ZIM zim, ZIMGroupState state, ZIMGroupEvent event, ZIMGroupOperatedInfo operatedInfo, ZIMGroupFullInfo groupInfo) {
}
});
1234567891011
ZIMEventHandler.onGroupMemberStateChanged = (
ZIM zim,
ZIMGroupMemberState state,
ZIMGroupMemberEvent event,
List<ZIMGroupMemberInfo> userList,
ZIMGroupOperatedInfo operatedInfo,
String groupID
){};
ZIMEventHandler.onGroupStateChanged = (
ZIM zim,
ZIMGroupState state,
ZIMGroupEvent event,
ZIMGroupOperatedInfo operatedInfo,
ZIMGroupFullInfo groupInfo
){};
123456789101112131415161718
void onGroupMemberStateChanged(zim::ZIM *zim, zim::ZIMGroupMemberState state,
zim::ZIMGroupMemberEvent event,
const std::vector<zim::ZIMGroupMemberInfo> &userList,
const zim::ZIMGroupOperatedInfo &operatedInfo,
const std::string &groupID) override {
......
}
void onGroupStateChanged(zim::ZIM *zim, zim::ZIMGroupState state,
zim::ZIMGroupEvent event,
const zim::ZIMGroupOperatedInfo &operatedInfo,
const zim::ZIMGroupFullInfo &groupInfo) override {
......
}
1234567891011121314
zim.on('groupMemberStateChanged', function (zim, { groupID, state, event, userList, operatedInfo }) {
console.log('groupMemberStateChanged', groupID, state, event, userList, operatedInfo);
});
zim.on('groupStateChanged', function (zim, { state, event, groupInfo, operatedInfo }) {
console.log('groupStateChanged', state, event, groupInfo, operatedInfo);
});
1234567891011
- (void)zim:(ZIM *)zim
groupMemberStateChanged:(ZIMGroupMemberState)state
event:(ZIMGroupMemberEvent)event
userList:(NSArray<ZIMGroupMemberInfo *> *)userList
operatedInfo:(ZIMGroupOperatedInfo *)operatedInfo
groupID:(NSString *)groupID{
}
- (void)zim:(ZIM *)zim
groupStateChanged:(ZIMGroupState)state
event:(ZIMGroupEvent)event
operatedInfo:(ZIMGroupOperatedInfo *)operatedInfo
groupInfo:(ZIMGroupFullInfo *)groupInfo{
}
12345678910111213
方式 1:主动加入群组
根据群组的 joinMode ,外部用户需要选择相应的接口加入群组。
- 当
joinMode
为 0(ANY),用户调用 joinGroup 接口,传入 groupID(groupID 必须已经存在,否则会操作失败),即可直接加入群组。
开发者可以通过 ZIMGroupJoinedResult,判断用户加入群组是否成功。
zim.joinGroup("groupID", new ZIMGroupJoinedCallback() {
@Override
public void onGroupJoined(ZIMGroupFullInfo groupInfo, ZIMError errorInfo) {
}
});
1234567
ZIM.getInstance()
!.joinGroup('groupID')
.then((value){
})
.catchError((onError) {
});
123456789
// 其他客户端直接加入群组
zim_->joinGroup(group_id,
[=](const zim::ZIMGroupFullInfo &groupInfo, zim::ZIMError errorInfo) {
int error_code = errorInfo.code;
});
12345
var groupID = '';
zim.joinGroup(groupID)
.then(function ({ groupInfo }) {
})
.catch(function (err) {
});
1234567891011
[zim joinGroup:GroupID callback:^(ZIMGroupFullInfo * _Nonnull groupInfo, ZIMError * _Nonnull errorInfo) {
}];
1234
ZIMGroupJoinApplicationSendConfig config = new ZIMGroupJoinApplicationSendConfig();
config.wording = "请让我进群";
zim.sendGroupJoinApplication("groupID", config, new ZIMGroupJoinApplicationSentCallback() {
@Override
public void onGroupJoinApplicationSent(String groupID, ZIMError errorInfo){
}
});
12345678
ZIMGroupJoinApplicationSendConfig sendConfig = ZIMGroupJoinApplicationSendConfig();
sendConfig.wording = '请让我进群';
try{
var result = await ZIM.getInstance()!.sendGroupJoinApplication('groupID', sendConfig);
} on PlatformException catch (onError){
onError.code;
onError.message;
}
12345678
zim::ZIMGroupJoinApplicationSendConfig config;
config.wording = "wording";
zim_->sendGroupJoinApplication(
group_id, config,
[=](const std::string &groupID, const zim::ZIMError &errorInfo) {
int error_code = errorInfo.code;
});
12345678
var groupID = '';
var config = {
wording: 'XXXX 申请加入群组'
};
zim.sendGroupJoinApplication(groupID, config)
.then(function ({ groupID }) {
})
.catch(function (err) {
});
123456789101112
ZIMGroupJoinApplicationSendConfig *config = [[ZIMGroupJoinApplicationSendConfig alloc] init];
config.wording = @"请让我进群";
[zim sendGroupJoinApplicationToGroupID:groupID config:config callback:^(NSString * _Nonnull groupID, ZIMError *errorInfo) {
}];
12345
- 群主或管理员通过监听 groupApplicationListChanged 事件,得知新增申请待处理。
zim.setEventHandler(new ZIMEventHandler(){
public void onGroupApplicationListChanged(ZIM zim, ArrayList<ZIMGroupApplicationInfo> applicationList, ZIMGroupApplicationListChangeAction action) {
}
});
123456
ZIMEventHandler.onGroupApplicationListChanged = (ZIM zim,
List<ZIMGroupApplicationInfo> applicationList,
ZIMGroupApplicationListChangeAction action){};
123
void onGroupApplicationListChanged(
zim::ZIM * , const std::vector<zim::ZIMGroupApplicationInfo> & ,
zim::ZIMGroupApplicationListChangeAction ) override {
......
}
12345
zim.on('groupApplicationListChanged', (zim, { action, applicationList }) => {
console.log(action, applicationList);
});
12345
- (void)zim:(ZIM *)zim
groupApplicationListChanged:(NSArray<ZIMGroupApplicationInfo * > *)applicationList
action:(ZIMGroupApplicationListChangeAction)action{
}
12345
- 群主或管理员审批
ZIMGroupJoinApplicationAcceptConfig config = new ZIMGroupJoinApplicationAcceptConfig();
zim.acceptGroupJoinApplication("userID", "groupID", config, new ZIMGroupJoinApplicationAcceptedCallback(){
public void onGroupJoinApplicationAccepted(String groupID, String userID, ZIMError errorInfo){
};
});
1234567
try{
ZIMGroupJoinApplicationAcceptConfig acceptConfig = ZIMGroupJoinApplicationAcceptConfig();
var result = await ZIM.getInstance()!.acceptGroupJoinApplication('userID', 'groupID', acceptConfig);
} on PlatformException catch (onError){
onError.code;
onError.message;
}
12345678
zim::ZIMGroupJoinApplicationAcceptConfig config;
zim_->acceptGroupJoinApplication(
user_id, group_id, config,
[=](const std::string &groupID, const std::string &userID,
const zim::ZIMError &errorInfo) {
int error_code = errorInfo.code;
});
123456789
var userID = '';
var groupID = '';
var config = {};
zim.acceptGroupJoinApplication(userID, groupID, config)
.then(function ({ groupID, userID }) {
})
.catch(function (err) {
});
12345678910
[zim acceptGroupJoinApplicationFromUserID:userID groupID:groupID config:config callback:^(NSString * _Nonnull groupID, NSString * _Nonnull userID, ZIMError * _Nonnull errorInfo) {
}];
1234
ZIMGroupJoinApplicationRejectConfig config = new ZIMGroupJoinApplicationRejectConfig();
zim.rejectGroupJoinApplication("userID", "groupID", config, new ZIMGroupJoinApplicationRejectedCallback(){
public void onGroupJoinApplicationRejected(String groupID, String userID, ZIMError errorInfo) {
}
});
1234567
try{
ZIMGroupJoinApplicationRejectConfig rejectConfig = ZIMGroupJoinApplicationRejectConfig();
var result = await ZIM.getInstance()!.rejectGroupJoinApplication('userID', 'groupID', rejectConfig);
} on PlatformException catch (onError){
onError.code;
onError.message;
}
12345678
zim::ZIMGroupJoinApplicationRejectConfig config;
zim_->rejectGroupJoinApplication(
user_id, group_id, config,
[=](const std::string &groupID, const std::string &userID, const zim::ZIMError &errorInfo) {
int error_code = errorInfo.code;
});
12345678
var userID = '';
var groupID = '';
var config = {};
zim.rejectGroupJoinApplication(userID, groupID, config)
.then(function ({ groupID, userID }) {
})
.catch(function (err) {
});
12345678910
[zim rejectGroupJoinApplicationFromUserID:userID groupID:groupID config:config callback:^(NSString * _Nonnull groupID, NSString * _Nonnull userID, ZIMError * _Nonnull errorInfo) {
}];
1234
- 入群申请人、群主、管理员和接口调用者会收到 groupApplicationUpdated 回调通知。
zim.setEventHandler(new ZIMEventHandler(){
public void onGroupApplicationUpdated(ZIM zim, ArrayList<ZIMGroupApplicationInfo> applicationList){
}
});
123456
ZIMEventHandler.onGroupApplicationUpdated = (ZIM zim,
List<ZIMGroupApplicationInfo> applicationList){
};
12345
void onGroupApplicationUpdated(
zim::ZIM * ,
const std::vector<zim::ZIMGroupApplicationInfo> & ) override {
......
}
12345
zim.on('groupApplicationUpdated', (zim, { applicationList }) => {
console.log(applicationList);
});
12345
- (void)zim:(ZIM *)zim groupApplicationUpdated:(NSArray<ZIMGroupApplicationInfo *> *)applicationList{
}
1234
方式 2:由群内成员添加入群组(邀请入群)
- 群内用户可通过以下任意接口邀请用户入群:
请确认被邀请用户(以下称为“目标用户”)已通过 login 接口登录注册过,否则会操作失败。
开发者可以通过 ZIMGroupUsersInvitedResult,判断用户是否被成功加入到群组中。
ArrayList<String> userList = new ArrayList<>();
userList.add("user_1");
userList.add("user_2");
zim.inviteUsersIntoGroup(userList, "group_id", new ZIMGroupUsersInvitedCallback() {
@Override
public void onGroupUsersInvited(ArrayList<ZIMGroupMemberInfo> userList, ArrayList<ZIMErrorUserInfo> errorUserList, ZIMError errorInfo) {
}
});
12345678910
Developers can use ZIMGroupUsersInvitedResult to determine whether the user has been successfully added to the group.
List<String> userIDs = ['userID1', 'userID2'];
ZIM.getInstance()
!.inviteUsersIntoGroup(userIDs, 'groupID')
.then((value) => {
})
.catchError((onError) {
});
12345678910
std::vector<std::string> user_list;
user_list.push_back("user_1");
user_list.push_back("user_2");
zim_->inviteUsersIntoGroup(user_list, group_id, callback);
12345
var groupID = '';
var userIDs = [];
zim.inviteUsersIntoGroup(userIDs, groupID)
.then(function ({ groupID, userList, errorUserList }) {
})
.catch(function (err) {
});
1234567891011
[zim inviteUsersIntoGroup:userIDs groupID:groupID callback:^(NSArray<ZIMGroupMemberInfo *> * _Nonnull userList, NSArray<ZIMErrorUserInfo *> * _Nonnull errorUserList, ZIMError * _Nonnull errorInfo) {
}];
1234
ZIMGroupInviteApplicationSendConfig config = new ZIMGroupInviteApplicationSendConfig();
config.wording = "请加入我的群吧";
List<String> userIDs = new ArrList<String>();
userIDs.add("user1");
userIDs.add("user2");
zim.sendGroupInviteApplications(userIDs, "groupID", config, new ZIMGroupInviteApplicationsSentCallback(){
public void onGroupInviteApplicationsSent(String groupID, ArrayList<ZIMErrorUserInfo> errorUserList, ZIMError errorInfo){
}
});
1234567891011
ZIMGroupInviteApplicationSendConfig config = ZIMGroupInviteApplicationSendConfig();
config.wording = 'xxx邀请你加入群聊';
ZIMGroupInviteApplicationSendConfig applicationSendConfig = ZIMGroupInviteApplicationSendConfig();
try{
var result = await ZIM.getInstance()!.sendGroupInviteApplications(['userID1','userID2'], 'groupID', config);
} on PlatformException catch (onError) {
onError.code;
onError.message;
}
12345678910
std::vector<std::string> user_list;
user_list.push_back("user_1");
user_list.push_back("user_2");
zim::ZIMGroupInviteApplicationSendConfig config;
config.wording = "wording";
zim_->sendGroupInviteApplications(
user_list, group_id, config,
[=](const std::string &groupID, const std::vector<zim::ZIMErrorUserInfo> &errorUserList,
const zim::ZIMError &errorInfo) {
int error_code = errorInfo.code;
});
1234567891011121314
var userIDs = [];
var groupID = '';
var config = {
wording: '邀请加入群组'
};
zim.sendGroupInviteApplications(userIDs, groupID, config)
.then(function ({ groupID, errorUserList }) {
})
.catch(function (err) {
});
12345678910111213
ZIMGroupInviteApplicationSendConfig *config = [[ZIMGroupInviteApplicationSendConfig alloc] init];
config.wording = @"xxx邀请你加入群聊";
[zim sendGroupInviteApplicationsToUserIDs:@[@"userID1",@"userID2"] groupID:@"groupID" config:config callback:^(NSString * _Nonnull groupID, NSArray<ZIMErrorUserInfo *> * _Nonnull errorUserList, ZIMError * _Nonnull errorInfo) {
}];
123456
根据群组的 inviteMode 和 beInviteMode ,以及调用用户的群组角色,接口调用效果如下表所示:
beInviteMode | inviteMode | 调用接口 | 调用角色 | 结果 |
---|
0:NONE | 0:ANY | inviteUsersIntoGroup | 所有群成员 | 被邀请人自动成为群成员。 |
sendGroupInviteApplications | 被邀请人自动成为群成员,且不产生邀请入群申请记录。 |
1:ADMIN | inviteUsersIntoGroup | 普通成员 | 失败。 |
群主或管理员 | 被邀请人自动成为群成员。 |
sendGroupInviteApplications | 普通成员 | 失败。 |
群主或管理员 | 被邀请人自动成为群成员,且不产生邀请入群申请记录。 |
1:AUTH | 0:ANY | inviteUsersIntoGroup | 所有群成员 | 产生邀请入群申请记录,等待目标用户做出反应。 |
sendGroupInviteApplications | 产生邀请入群申请记录,等待目标用户做出反应。此外,如果调用者为群主或管理员时,会收到 onGroupApplicationListChanged。 |
1:ADMIN | inviteUsersIntoGroup | 普通成员 | 失败。 |
群主或管理员 | 产生邀请入群申请记录,等待目标用户做出反应。 |
sendGroupInviteApplications | 普通成员 | 失败。 |
群主或管理员 | 产生邀请入群申请记录,等待目标用户做出反应。此外,如果调用者为群主或管理员时,会收到 onGroupApplicationListChanged。 |
- beInviteMode 为 1(AUTH)时,目标用户和邀请人(仅当接口调用人为群主和群管理员时)会通过 groupApplicationListChanged 收到回调通知。目标用户需要审批该申请。
ZIMGroupInviteApplicationAcceptConfig config = new ZIMGroupInviteApplicationAcceptConfig();
zim.acceptGroupInviteApplication("inviterUserID", "groupID", config, new ZIMGroupInviteApplicationAcceptedCallback(){
public void onGroupInviteApplicationAccepted(ZIMGroupFullInfo groupInfo, String inviterUserID, ZIMError errorInfo){
}
});
12345678
try{
ZIMGroupInviteApplicationAcceptConfig acceptConfig = ZIMGroupInviteApplicationAcceptConfig();
var reuslt = await ZIM.getInstance()!.acceptGroupInviteApplication('inviterUserID', 'groupID', acceptConfig);
} on PlatformException catch(onError){
onError.code;
onError.message;
}
1234567
zim::ZIMGroupInviteApplicationAcceptConfig config;
zim_->acceptGroupInviteApplication(
user_id, group_id, config,
[=](const zim::ZIMGroupFullInfo &group, const std::string &inviterUserID,
const zim::ZIMError &errorInfo) {
int error_code = errorInfo.code;
});
123456789
var inviterUserID = '';
var groupID = '';
var config = {};
zim.acceptGroupInviteApplication(inviterUserID, groupID, config)
.then(function ({ groupInfo, inviterUserID }) {
})
.catch(function (err) {
});
123456789101112
[zim acceptGroupInviteApplicationFromInviterUserID:inviterUserID groupID:groupID config:config callback:^(ZIMGroupFullInfo * _Nonnull groupInfo, NSString * _Nonnull inviterUserID, ZIMError * _Nonnull errorInfo) {
}];
123
ZIMGroupInviteApplicationRejectConfig config = new ZIMGroupInviteApplicationRejectConfig();
zim.rejectGroupInviteApplication("inviterUserID", "groupID", config, new ZIMGroupInviteApplicationRejectedCallback(){
public void onGroupInviteApplicationRejected(String groupID, String inviterUserID, ZIMError errorInfo) {
}
});
1234567
try{
ZIMGroupInviteApplicationRejectConfig rejectConfig = ZIMGroupInviteApplicationRejectConfig();
var reuslt = await ZIM.getInstance()!.rejectGroupInviteApplication('inviterUserID', 'groupID', rejectConfig);
} on PlatformException catch(onError){
onError.code;
onError.message;
}
1234567
zim::ZIMGroupInviteApplicationRejectConfig config;
zim_->rejectGroupInviteApplication(
user_id, group_id, config,
[=](const std::string &groupID, const std::string &inviterUserID,
const zim::ZIMError &errorInfo) {
int error_code = errorInfo.code;
});
123456789
var inviterUserID = '';
var groupID = '';
var config = {};
zim.rejectGroupInviteApplication(inviterUserID, groupID, config)
.then(function ({ groupID, inviterUserID }) {
})
.catch(function (err) {
});
123456789101112
[zim rejectGroupInviteApplicationFromInviterUserID:inviterUserID groupID:groupID config:config callback:^(NSString * _Nonnull groupID, NSString * _Nonnull inviterUserID, ZIMError * _Nonnull errorInfo) {
}];
123
- beInviteMode 为 1(AUTH)时,该用户和邀请人(仅当接口调用人为群主和群管理员时)会通过 groupApplicationUpdated 收到回调通知上述审批事件。
zim.setEventHandler(new ZIMEventHandler(){
public void onGroupApplicationUpdated(ZIM zim,
ArrayList<ZIMGroupApplicationInfo> applicationList) {
}
});
123456
ZIMEventHandler.onGroupApplicationUpdated = (ZIM zim,
List<ZIMGroupApplicationInfo> applicationList){
};
1234
void onGroupApplicationUpdated(
zim::ZIM * ,
const std::vector<zim::ZIMGroupApplicationInfo> & ) override {
......
}
123456
zim.on('groupApplicationUpdated', (zim, { applicationList }) => {
console.log(applicationList);
});
12345
- (void)zim:(ZIM *)zim groupApplicationUpdated:(NSArray<ZIMGroupApplicationInfo *> *)applicationList{
}
123
退出群组
成员退出群组也存在两种方式(二选一),主动退出和被提出群组。
用户退出群组后,不会清除本地的会话列表,还可以看到退出之前的群内聊天记录。
方式 1:主动退出群组
成员登录 ZIM SDK 后,直接调用 leaveGroup 接口,传入 groupID(groupID 必须已经存在,否则会操作失败),主动退出群组。退出成功后,全体群成员(包括自己)都会收到 groupMemberStateChanged 的回调通知。
群主退出群组时,群主身份将自动转让给加入本群组最早的那个成员;所有成员退出群组时,群组自动解散。
zim.leaveGroup("groupID", new ZIMGroupLeftCallback() {
@Override
public void onGroupLeft(ZIMError errorInfo) {
}
});
1234567
Developers can use ZIMGroupLeftResult to determine whether the member successfully left the group.
ZIM.getInstance()
!.leaveGroup('groupID')
.then((value){
})
.catchError((onError) {
});
123456789
zim_->leaveGroup(group_id, [=](const std::string &groupID, zim::ZIMError errorInfo){
int error_code = errorInfo.code;
});
123456
var groupID = '';
zim.leaveGroup(groupID)
.then(function ({ groupID }) {
})
.catch(function (err) {
});
12345678910
[zim leaveGroup:groupID callback:^(ZIMError * _Nonnull errorInfo) {
}];
1234
方式 2:群主移除群内成员
群主调用 kickGroupMembers 接口,传入 groupID(groupID 必须已经存在,否则会操作失败)、userIDs(需要被移除的成员列表),移除这些成员。移除成功后,全体群成员(包括群主自己、被移除的成员)都会收到 groupMemberStateChanged 的回调通知。
开发者可以通过 ZIMGroupMemberKickedResult,判断用户是否被成功移除。
- 只有群主和管理员可以调用 kickGroupMembers 接口,移除群内成员;且移除成员时,该成员无需登录在线,也无需经过该成员同意,即可直接移除。
- 被移除的用户 userID,必须是存在于本群组的成员列表内,否则会操作失败。
ArrayList<String> user_list = new ArrayList<>();
user_list.add("user_1");
user_list.add("user_2");
zim.kickGroupMembers(user_list, "groupID", new ZIMGroupMemberKickedCallback() {
@Override
public void onGroupMemberKicked(ArrayList<String> kickedUserIDList, ArrayList<ZIMErrorUserInfo> errorUserList, ZIMError errorInfo) {
}
});
12345678910
ZIM.getInstance()
!.kickGroupMembers(userIDs, 'groupID')
.then((value){
})
.catchError((onError) {
});
123456789
std::vector<std::string> user_list;
user_list.push_back("user_1");
user_list.push_back("user_2");
zim_->kickGroupMembers(user_list, group_id,
[=](const std::string &groupID, const std::vector<std::string> &kickedMemberIDs,
const std::vector<ZIMErrorUser> &errorUserList, zim::ZIMError errorInfo) {
int error_code = errorInfo.code;
});
1234567891011
var groupID = '';
var userIDs = [];
zim.kickGroupMembers(userIDs, groupID)
.then(function ({ groupID, kickedUserIDs, errorUserList }) {
})
.catch(function (err) {
});
123456789101112
[zim kickGroupMembers:userIDs groupID:groupID callback:^(NSArray<NSString *> * _Nonnull kickedUserIDList, NSArray<ZIMErrorUserInfo *> * _Nonnull errorUserList, ZIMError * _Nonnull errorInfo) {
}];
1234
解散群组
群主登录 ZIM SDK 后,如果想要解散群组,可以通过 dismissGroup 接口,解散群组。解散群组成功后,全体群成员都会收到 groupStateChanged 回调通知。
开发者可以通过 ZIMGroupDismissedResult,判断解散群组是否成功。
- 只有群主才能调用 dismissGroup 接口,解散群组。
- 所有成员退出群组时,群组将自动解散。
- 群组解散后,不会清除本地的会话列表,用户还可以看到退出之前的群内聊天记录。
zim.dismissGroup("groupID", new ZIMGroupDismissedCallback() {
@Override
public void onGroupDismissed(ZIMError errorInfo) {
}
});
1234567
ZIM.getInstance()
!.dismissGroup('groupID')
.then((value){
})
.catchError((onError) {
});
123456789
zim_->dismissGroup(group_id, [=](const std::string &groupID, zim::ZIMError errorInfo) {
int error_code = errorInfo.code;
});
1234
var groupID = '';
zim.dismissGroup(groupID)
.then(function ({ groupID }) {
})
.catch(function (err) {
});
zim.on('groupStateChanged', function (zim, { state, event, groupInfo, operatedInfo }) {
console.log('groupStateChanged', state, event, groupInfo, operatedInfo);
});
12345678910111213
[zim dismissGroup:groupID callback:^(ZIMError * _Nonnull errorInfo) {
}];
1234
更多功能
查询已加入群组列表
用户登录 ZIM SDK 后,如果想要了解自己加入了哪些群组,可以通过 queryGroupList 接口,获取自己已加入的群组列表。
zim.queryGroupList(new ZIMGroupListQueriedCallback() {
@Override
public void onGroupListQueried(ArrayList<ZIMGroupInfo> groupList, ZIMError errorInfo) {
}
});
1234567
开发者可以通过 ZIMGroupListQueriedResult,获取查询结果。
ZIM.getInstance()
!.queryGroupList()
.then((value){
})
.catchError((onError) {
});
123456789
zim_->queryGroupList(
[=](const std::vector<ZIMGroupInfo> &groupList, zim::ZIMError errorInfo){
int error_code = errorInfo.code;
});
12345
zim.queryGroupList()
.then(function ({ groupList }) {
})
.catch(function (err) {
});
1234567
[zim queryGroupListByGroupID:^(NSArray<ZIMGroupInfo *> * _Nonnull groupList, ZIMError * _Nonnull errorInfo) {
}];
1234
搜索已加入群组
用户登录 ZIM SDK 后,如果想要根据条件对已加入的群组进行搜索,可以调用 searchLocalGroups 接口,传入 config、callback 搜索群组。
搜索结果将通过 ZIMGroupsSearchedResult 回调接口返回。
ZIM zim = getZIM();
ZIMGroupMemberSearchConfig config = new ZIMGroupMemberSearchConfig();
config.count = 10;
config.nextFlag = 0;
config.isAlsoMatchGroupMemberNickname = true;
config.isAlsoMatchGroupMemberUserName = true;
config.keywords.add("zego");
zim.searchLocalGroups(config, new ZIMGroupsSearchedCallback() {
@Override
public void onGroupsSearched(ArrayList<ZIMGroupSearchInfo> groupSearchInfoList, int nextFlag, ZIMError errorInfo) {
}
});
1234567891011121314
ZIMGroupSearchConfig config = ZIMGroupSearchConfig();
config.count = 10;
config.nextFlag = 0;
config.isAlsoMatchGroupMemberNickname = true;
config.isAlsoMatchGroupMemberUserName = true;
config.keywords.add("zego");
ZIM.getInstance()!.searchLocalGroups(config).then((result){
}).catchError((onError){
});
123456789101112
auto searchConfig = zim::ZIMGroupSearchConfig();
searchConfig.count = 10;
searchConfig.nextFlag = 0;
searchConfig.isAlsoMatchGroupMemberNickname = true;
searchConfig.isAlsoMatchGroupMemberUserName = true;
searchConfig.keywords.emplace_back("zego");
zim_->searchLocalGroups(searchConfig,
[=](const std::vector<zim::ZIMGroupSearchInfo> &groupSearchInfoList,
unsigned int nextFlag, const zim::ZIMError &errorInfo) {
});
12345678910111213141516
var config = {
count: 10,
nextFlag: 0,
keywords: ['zego'],
isAlsoMatchGroupMemberUserName: true,
isAlsoMatchGroupMemberNickname: false,
};
zim.searchLocalGroups(config)
.then(function ({ groupSearchInfoList, nextFlag }) {
})
.catch(function (err) {
});
1234567891011121314151617
ZIMGroupSearchConfig *config = [[ZIMGroupSearchConfig alloc] init];
config.count = 10;
config.nextFlag = 0;
config.isAlsoMatchGroupMemberNickname = true;
config.isAlsoMatchGroupMemberUserName = true;
config.keywords = @[@"zego"];
[[ZIM getInstance] searchLocalGroupsWithConfig:config callback:^(NSArray<ZIMGroupSearchInfo *> * _Nonnull groupSearchInfoList, unsigned int nextFlag, ZIMError * _Nonnull errorInfo) {
if(errorInfo.code == ZIMErrorCodeSuccess){
}else{
}
}];
1234567891011121314
禁言或解禁群组
禁言,是指让群组会话内的用户不能发言。
在登录 ZIM SDK 后,用户可以禁言自己管理的群组。只需调用 muteGroup 接口,传入相应参数设置群组 ID、禁言模式、持续时长和目标角色,即可禁言或解禁群组。
ZIM 支持 3 种群组禁言模式:
- 所有群组成员不能发言;
- 所有普通群组成员(
role
为 3)不能发言,;
- 指定角色的群成员不能发言。
禁言操作结果将通过 ZIMGroupMutedResult 回调接口返回。
ZIMGroupMuteConfig config = new ZIMGroupMuteConfig();
config.mode = ZIMGroupMuteMode.Custom;
config.duration = 30;
config.roles.add(3);
config.roles.add(5);
boolean isMute = true;
zim.muteGroup(isMute, "group_id", config, new ZIMGroupMutedCallback() {
@Override
public void onGroupMuted(String groupID, boolean isMute, ZIMGroupMuteInfo info, ZIMError errorInfo) {
}
});
1234567891011121314151617181920
try {
ZIMGroupMuteConfig config = ZIMGroupMuteConfig();
config.mode = ZIMGroupMuteMode.custom;
config.duration = 30;
config.roles = [3,5];
bool isMute = true;
ZIMGroupMutedResult result = await ZIM.getInstance()!.muteGroup(isMute, 'group_id', config);
} on PlatformException catch (onError){
onError.code;
onError.message;
}
1234567891011121314151617
zim::ZIMGroupMuteConfig config;
config.mode = zim::ZIMGroupMuteMode::ZIM_GROUP_MUTE_MODE_CUSTOM;
config.duration = 30;
config.roles.push_back(2);
config.roles.push_back(3);
bool is_mute = true;
zim_->muteGroup(is_mute, group_id, config,
[=](const std::string &groupID, bool is_muted,
const zim::ZIMGroupMuteInfo &info,
const zim::ZIMError &errorInfo) {
});
1234567891011121314151617181920
const config = {
mode: 3,
duration: 30,
roles:[3,5],
};
var isMute = true;
var groupID = 'group';
zim.muteGroup(isMute, groupID, config)
.then(function ({ groupID, isMute, mutedInfo }) {
})
.catch(function (err) {
});
123456789101112131415161718
ZIMGroupMuteConfig *muteConfig = [[ZIMGroupMuteConfig alloc] init];
muteConfig.mode = ZIMGroupMuteModeCustom;
muteConfig.duration = 30;
muteConfig.roles = @[@3,@5];
[[ZIM getInstance] muteGroup:YES groupID:@"groupID" config:muteConfig callback:^(NSString * _Nonnull groupID, BOOL isMute, ZIMGroupMuteInfo * _Nonnull info, ZIMError * _Nonnull errorInfo) {
}];
123456789101112
群组禁言或解禁成功后,全部群成员会收到 groupMutedInfoUpdated ,得知哪些角色无法在该群组发言或可恢复发言。
zim.setEventHandler(new ZIMEventHandler(){
public void onGroupMutedInfoUpdated(ZIM zim, ZIMGroupMuteInfo muteInfo,
ZIMGroupOperatedInfo operatedInfo, String groupID) {
}
});
1234567
ZIMEventHandler.onGroupMutedInfoUpdated = (ZIM zim, ZIMGroupMuteInfo groupMuteInfo, ZIMGroupOperatedInfo operatedInfo, String groupID){
};
123
void zim_event_handler::onGroupMutedInfoUpdated(zim::ZIM *, const zim::ZIMGroupMuteInfo &info,
const zim::ZIMGroupOperatedInfo &operatedInfo,
const std::string &groupID) {
}
123456
zim.on('groupMutedInfoUpdated', function (zim, { groupID, mutedInfo, operatedInfo}) {
console.log('groupMutedInfoUpdated', groupID, mutedInfo, event, userList, operatedInfo);
});
123
- (void)zim:(ZIM *)zim
groupMutedInfoUpdated:(ZIMGroupMuteInfo *)muteInfo
operatedInfo:(ZIMGroupOperatedInfo *)operatedInfo
groupID:(NSString *)groupID{
}
123456
确认群组会话是否可用
如需确认当前用户是否仍在所加入的群组会话中,请通过以下任意方法:
当会话类型是群类型时,从返回结果中的 ZIMGroupConversation 获取 isDisabled ,即会话是否可用。
isDisabled 值说明如下:
- 为 true 时,表示当前用户不在该群组会话。当前用户主动退出、被踢或群组解散都会导致会话不可用。
- 为 false 时,表示当前用户在该群组会话。
更新入群验证模式
群主和管理员登录 ZIM SDK 后,可以通过 updateGroupJoinMode 接口更新入群验证模式。
更新成功后,全体群成员都会收到 groupVerifyInfoUpdated 回调通知。
zim.setEventHandler(new ZIMEventHandler(){
public void onGroupVerifyInfoUpdated(ZIM zim, ZIMGroupVerifyInfo verifyInfo,
ZIMGroupOperatedInfo operatedInfo, String groupID) {
}
});
zim.updateGroupJoinMode(ZIMGroupJoinMode.AUTH, "groupID", new ZIMGroupJoinModeUpdatedCallback(){
public void onGroupJoinModeUpdated(String groupID, ZIMGroupJoinMode mode, ZIMError errorInfo){
}
});
123456789101112131415
ZIMEventHandler.onGroupVerifyInfoUpdated = (ZIM zim,
ZIMGroupVerifyInfo verifyInfo,
ZIMGroupOperatedInfo operatedInfo,
String groupID){};
try{
var reuslt = await ZIM.getInstance()!.updateGroupJoinMode(ZIMGroupJoinMode.auth, 'groupID');
} on PlatformException catch(onError){
onError.code;
onError.message;
}
12345678910111213
zim_->updateGroupJoinMode(
zim::ZIMGroupJoinMode::ZIM_GROUP_JOIN_MODE_AUTH, group_id,
[=](const std::string &groupID, zim::ZIMGroupJoinMode mode,
const zim::ZIMError &errorInfo) {
});
12345678
zim.on('groupVerifyInfoUpdated', (zim, { groupID, verifyInfo, operatedInfo }) => {
console.log(groupID, verifyInfo.joinMode);
});
var groupID = '';
var joinMode = 1;
zim.updateGroupJoinMode(joinMode, groupID)
.then(function ({ groupID, mode }) {
})
.catch(function (err) {
});
12345678910111213141516
- (void)zim:(ZIM *)zim
groupVerifyInfoUpdated:(ZIMGroupVerifyInfo *)verifyInfo
operatedInfo:(ZIMGroupOperatedInfo *)operatedInfo
groupID:(NSString *)groupID{
}
[zim updateGroupJoinMode:ZIMGroupJoinModeAuth groupID:@"groupID" callback:^(NSString * _Nonnull groupID, ZIMGroupJoinMode mode, ZIMError * _Nonnull errorInfo) {
}];
123456789101112
更新邀请模式
群主和管理员登录 ZIM SDK 后,可以通过 updateGroupInviteMode 接口更新邀请模式。
更新成功后,全体群成员都会收到 groupVerifyInfoUpdated 回调通知。
zim.setEventHandler(new ZIMEventHandler(){
public void onGroupVerifyInfoUpdated(ZIM zim, ZIMGroupVerifyInfo verifyInfo,
ZIMGroupOperatedInfo operatedInfo, String groupID) {
}
});
zim.updateGroupInviteMode(ZIMGroupInviteMode.ADMIN, "groupID", new ZIMGroupInviteModeUpdatedCallback(){
public void onGroupInviteModeUpdated(String groupID, ZIMGroupInviteMode mode, ZIMError errorInfo){
}
});
12345678910111213141516
ZIMEventHandler.onGroupVerifyInfoUpdated = (ZIM zim,
ZIMGroupVerifyInfo verifyInfo,
ZIMGroupOperatedInfo operatedInfo,
String groupID){};
try{
var result = await ZIM.getInstance()!.updateGroupInviteMode(ZIMGroupInviteMode.any, 'groupID');
} on PlatformException catch(onError){
onError.code;
onError.message;
}
12345678910111213
void onGroupVerifyInfoUpdated(zim::ZIM * ,
const zim::ZIMGroupVerifyInfo & ,
const zim::ZIMGroupOperatedInfo & ,
const std::string & ) override {
......
}
zim_->updateGroupInviteMode(
zim::ZIMGroupInviteMode::ZIM_GROUP_INVITE_MODE_ADMIN, group_id,
[=](const std::string &groupID, zim::ZIMGroupInviteMode mode,
const zim::ZIMError &errorInfo) {
});
12345678910111213141516
zim.on('groupVerifyInfoUpdated', (zim, { groupID, verifyInfo, operatedInfo }) => {
console.log(groupID, verifyInfo.inviteMode);
});
var groupID = '';
var inviteMode = 1;
zim.updateGroupInviteMode(inviteMode, groupID)
.then(function ({ groupID, mode }) {
})
.catch(function (err) {
});
12345678910111213141516
- (void)zim:(ZIM *)zim
groupVerifyInfoUpdated:(ZIMGroupVerifyInfo *)verifyInfo
operatedInfo:(ZIMGroupOperatedInfo *)operatedInfo
groupID:(NSString *)groupID{
}
[zim updateGroupInviteMode:ZIMGroupInviteModeNone groupID:@"groupID" callback:^(NSString * _Nonnull groupID, ZIMGroupInviteMode mode, ZIMError * _Nonnull errorInfo) {
}];
123456789101112
更新邀请目标用户验证模式
群主和管理员登录 ZIM SDK 后,可以通过 updateGroupBeInviteMode 接口更新目标用户验证模式。
更新成功后,全体群成员都会收到 groupVerifyInfoUpdated 回调通知。
zim.setEventHandler(new ZIMEventHandler(){
public void onGroupVerifyInfoUpdated(ZIM zim, ZIMGroupVerifyInfo verifyInfo,
ZIMGroupOperatedInfo operatedInfo, String groupID) {
}
});
zim.updateGroupBeInviteMode(ZIMGroupBeInviteMode.AUTH, "groupID", new ZIMGroupBeInviteModeUpdatedCallback(){
public void onGroupBeInviteModeUpdated(String groupID, ZIMGroupBeInviteMode mode, ZIMError errorInfo) {
}
});
123456789101112131415161718
ZIMEventHandler.onGroupVerifyInfoUpdated = (ZIM zim,
ZIMGroupVerifyInfo verifyInfo,
ZIMGroupOperatedInfo operatedInfo,
String groupID){};
try{
var result = await ZIM.getInstance()!.updateGroupBeInviteMode(ZIMGroupBeInviteMode.auth, 'groupID');
} on PlatformException catch(onError){
onError.code;
onError.message;
}
12345678910111213
void onGroupVerifyInfoUpdated(zim::ZIM * ,
const zim::ZIMGroupVerifyInfo & ,
const zim::ZIMGroupOperatedInfo & ,
const std::string & ) override {
......
}
zim_->updateGroupBeInviteMode(
zim::ZIMGroupBeInviteMode::ZIM_GROUP_BE_INVITE_MODE_AUTH, group_id,
[=](const std::string &groupID, zim::ZIMGroupBeInviteMode mode,
const zim::ZIMError &errorInfo) {
});
123456789101112131415
zim.on('groupVerifyInfoUpdated', (zim, { groupID, verifyInfo, operatedInfo }) => {
console.log(groupID, verifyInfo.beInviteMode);
});
var groupID = '';
var beInviteMode = 1;
zim.updateGroupBeInviteMode(beInviteMode, groupID)
.then(function ({ groupID, mode }) {
})
.catch(function (err) {
});
12345678910111213141516
- (void)zim:(ZIM *)zim
groupVerifyInfoUpdated:(ZIMGroupVerifyInfo *)verifyInfo
operatedInfo:(ZIMGroupOperatedInfo *)operatedInfo
groupID:(NSString *)groupID{
}
[zim updateGroupBeInviteMode:ZIMGroupBeInviteModeAuth groupID:@"groupID" callback:^(NSString * _Nonnull groupID, ZIMGroupBeInviteMode mode, ZIMError * _Nonnull errorInfo) {
}];
123456789101112
查询入群申请列表
用户登录 ZIM SDK 后,调用 queryGroupApplicationList 接口,可以查询入群申请列表,查询结果包含自己的入群申请和自己被邀请入群的申请。当用户是群主或管理员时,查询结果还会包含他人的入群申请和自己邀请他人入群的申请。
ZIMGroupApplicationListQueryConfig config = new ZIMGroupApplicationListQueryConfig();
config.count = 10;
conifg.nextFlag = 0;
zim.queryGroupApplicationList(config, new ZIMGroupApplicationListQueriedCallback() {
public void onGroupApplicationListQueried(ArrayList<ZIMGroupApplicationInfo> applicationList, int nextFlag, ZIMError errorInfo) {
}
})
123456789
try{
ZIMGroupApplicationListQueryConfig queryConfig = ZIMGroupApplicationListQueryConfig();
queryConfig.count = 100;
queryConfig.nextFlag = 0;
var result = await ZIM.getInstance()!.queryGroupApplicationList(queryConfig);
} on PlatformException catch(onError){
onError.code;
onError.message;
}
123456789
zim::ZIMGroupApplicationListQueryConfig config;
config.count = 100;
config.nextFlag = 0;
zim_->queryGroupApplicationList(
config, [=](const std::vector<zim::ZIMGroupApplicationInfo> &applicationList,
unsigned long long nextFlag, const zim::ZIMError &errorInfo) {
});
123456789
var config = {
count: 30,
nextFlag: 0
};
zim.queryGroupApplicationList(config)
.then(function ({ nextFlag, applicationList }) {
})
.catch(function (err) {
});
12345678910111213
ZIMGroupApplicationListQueryConfig *config = [[ZIMGroupApplicationListQueryConfig alloc] init];
config.count = 20;
[zim queryGroupApplicationListWithConfig:config callback:^(NSArray<ZIMGroupApplicationInfo *> * _Nonnull applicationList, unsigned int nextFlag, ZIMError * _Nonnull errorInfo) {
}];
12345