javaV2NIMChatroomClient v2ChatroomClient = V2NIMChatroomClient.getInstance(instanceId);
V2NIMChatroomService v2ChatroomService = v2ChatroomClient.getChatroomService();

V2NIMChatroomListener listener = new V2NIMChatroomListener() {

    @Override
    public void onChatroomMemberEnter(V2NIMChatroomMember member) {

    }

    @Override
    public void onChatroomMemberExit(String accountId) {

    }

    @Override
    public void onChatroomMemberRoleUpdated(V2NIMChatroomMemberRole previousRole, V2NIMChatroomMember member) {

    }

    @Override
    public void onChatroomMemberInfoUpdated(V2NIMChatroomMember member) {

    }

    @Override
    public void onSelfChatBannedUpdated(boolean chatBanned) {

    }

    @Override
    public void onSelfTempChatBannedUpdated(boolean tempChatBanned, long tempChatBannedDuration) {

    }

    @Override
    public void onChatroomChatBannedUpdated(boolean chatBanned) {

    }
};

v2ChatroomService.addChatroomListener(listener);

objective-c@interface Listener: NSObject<V2NIMChatroomListener>
- (void)addToService;
@end

@implementation Listener

- (void)addToService
{
    id <V2NIMChatroomService> service = [[V2NIMChatroomClient getInstance:1] getChatroomService];
    [service addChatroomListener:self];
}

- (void)onChatroomMemberEnter:(V2NIMChatroomMember *)member
{

}

- (void)onChatroomMemberExit:(NSString *)accountId
{

}

- (void)onChatroomMemberRoleUpdated:(V2NIMChatroomMemberRole)previousRole
                             member:(V2NIMChatroomMember *)member
{

}
- (void)onChatroomMemberInfoUpdated:(V2NIMChatroomMember *)member
{

}

- (void)onSelfChatBannedUpdated:(BOOL)chatBanned
{

}

- (void)onSelfTempChatBannedUpdated:(BOOL)tempChatBanned
             tempChatBannedDuration:(NSInteger)tempChatBannedDuration
{

}

- (void)onChatroomChatBannedUpdated:(BOOL)chatBanned
{

}

- (void)onMessageRevokedNotification:(NSString *)messageClientId
                         messageTime:(NSTimeInterval)messageTime
{

}

@end

cppV2NIMChatroomListener listener;
listener.onChatroomMemberEnter = [](V2NIMChatroomMember member) {
    // handle chatroom member enter
};
listener.onChatroomMemberExit = [](nstd::string accountId) {
    // handle chatroom member exit
};
listener.onChatroomMemberRoleUpdated = [](V2NIMChatroomMemberRole previousRole, V2NIMChatroomMember member) {
    // handle chatroom member role updated
};
listener.onChatroomMemberInfoUpdated = [](V2NIMChatroomMember member) {
    // handle chatroom member info updated
};
listener.onSelfChatBannedUpdated = [](bool chatBanned) {
    // handle self chat banned updated
};
listener.onSelfTempChatBannedUpdated = [](bool tempChatBanned, uint64_t tempChatBannedDuration) {
    // handle self temp chat banned updated
};
listener.onChatroomChatBannedUpdated = [](bool chatBanned) {
    // handle chatroom chat banned updated
};
listener.onMessageRevokedNotification = [](nstd::string messageClientId, uint64_t messageTime) {
    // handle message revoked notification
};
chatroomService.addChatroomListener(listener);

typescriptchatroom.V2NIMChatroomService.on('onChatroomMemberEnter', function (member: V2NIMChatroomMember){})
chatroom.V2NIMChatroomService.on('onChatroomMemberExit', function (accountId: string){})
chatroom.V2NIMChatroomService.on('onChatroomMemberRoleUpdated', function (previousRole: V2NIMChatroomMemberRole, currentMember: V2NIMChatroomMember){})
chatroom.V2NIMChatroomService.on('onChatroomMemberInfoUpdated', function (member: V2NIMChatroomMember){})
chatroom.V2NIMChatroomService.on('onSelfChatBannedUpdated', function (chatBanned: boolean){})
chatroom.V2NIMChatroomService.on('onSelfTempChatBannedUpdated', function (tempChatBanned: boolean, tempChatBannedDuration: number){})
chatroom.V2NIMChatroomService.on('onChatroomChatBannedUpdated', function (chatBanned: boolean){})

typescriptchatroom.chatroomService.on('onChatroomMemberEnter', (member: V2NIMChatroomMember) => {})
chatroom.chatroomService.on('onChatroomMemberExit', (accountId: string) => {})
chatroom.chatroomService.on('onChatroomMemberRoleUpdated', (previousRole: V2NIMChatroomMemberRole, currentMember: V2NIMChatroomMember) => {})
chatroom.chatroomService.on('onChatroomMemberInfoUpdated', (member: V2NIMChatroomMember) => {})
chatroom.chatroomService.on('onSelfChatBannedUpdated', (chatBanned: boolean) => {})
chatroom.chatroomService.on('onSelfTempChatBannedUpdated', (tempChatBanned: boolean, tempChatBannedDuration: number) => {})
chatroom.chatroomService.on('onChatroomChatBannedUpdated', (chatBanned: boolean) => {})

java// 通过实例 ID 获取聊天室实例
V2NIMChatroomClient v2ChatroomClient = V2NIMChatroomClient.getInstance(instanceId);
V2NIMChatroomService v2ChatroomService = v2ChatroomClient.getChatroomService();

V2NIMChatroomMemberQueryOption queryOption = new V2NIMChatroomMemberQueryOption();
// 设置需要查询的成员类型，如果列表为空，表示查询所有类型的成员
List<V2NIMChatroomMemberRole> memberRoles = getMemberRoles();
queryOption.setMemberRoles(memberRoles);
// 是否只返回黑名单成员, 默认false
queryOption.setOnlyBlocked(false);
// 是否只返回禁言用户, 默认false
queryOption.setOnlyChatBanned(false);
// 是否只返回在线成员, 默认false
queryOption.setOnlyOnline(false);
// 设置查询数量
queryOption.setLimit(100);
// 设置分页标识，首页传""，下一页传上次返回的 pageToken
queryOption.setPageToken("");

v2ChatroomService.getMemberListByOption(queryOption, new V2NIMSuccessCallback<V2NIMChatroomMemberListResult>() {
    @Override
    public void onSuccess(V2NIMChatroomMemberListResult v2NIMChatroomMemberListResult) {
        // 查询成功
        List<V2NIMChatroomMember> memberList = v2NIMChatroomMemberListResult.getMemberList();
    }
}, new V2NIMFailureCallback() {
    @Override
    public void onFailure(V2NIMError error) {
        // 查询失败
    }
});

objective-c// 通过实例 ID 获取聊天室服务
id <V2NIMChatroomService> service = [[V2NIMChatroomClient getInstance:1] getChatroomService];

V2NIMChatroomMemberQueryOption *queryOption = [[V2NIMChatroomMemberQueryOption alloc] init];
// 设置需要查询的成员类型,如果列表为空，表示查询所有类型的成员
queryOption.memberRoles = @[@(V2NIM_CHATROOM_MEMBER_ROLE_NORMAL_GUEST), @(V2NIM_CHATROOM_MEMBER_ROLE_ANONYMOUS_GUEST)];
// 是否只返回黑名单成员, 默认false
queryOption.onlyBlocked = NO;
// 是否只返回禁言用户, 默认false
queryOption.onlyChatBanned = NO;
// 是否只返回在线成员, 默认false
queryOption.onlyOnline = NO;
// 设置查询数量
queryOption.limit = 100;
// 设置分页标识，首页传""，下一页传上次返回的 pageToken
queryOption.pageToken = @"";
[service getMemberListByOption:queryOption
                       success:^(V2NIMChatroomMemberListResult *result)
                       {
                           // 查询成功
                       }
                       failure:^(V2NIMError *error)
                       {
                           // 查询失败
                       }];

cppV2NIMChatroomMemberQueryOption queryOption;
queryOption.pageToken = 0; // first page
queryOption.limit = 10;
chatroomService.getMemberListByOption(
    queryOption,
    [](V2NIMChatroomMemberListResult result) {
        // get member list succeeded
    },
    [](V2NIMError error) {
        // get member list failed, handle error
    });

typescriptawait chatroom.V2NIMChatroomService.getMemberListByOption({
    // 普通成员
    memberRoles: [V2NIMChatroomMemberRole.V2NIM_CHATROOM_MEMBER_ROLE_NORMAL],
    onlyBlocked: false,
    onlyChatBanned: false,
    onlyOnline: false,
    limit: 100
})

typescriptawait this.chatroomClient.chatroomService.getMemberListByOption({
    // 普通成员
    memberRoles: [V2NIMChatroomMemberRole.V2NIM_CHATROOM_MEMBER_ROLE_NORMAL],
    onlyBlocked: false,
    onlyChatBanned: false,
    onlyOnline: false,
    limit: 100
})

javaV2NIMChatroomClient v2ChatroomClient = V2NIMChatroomClient.getInstance(instanceId);
V2NIMChatroomService v2ChatroomService = v2ChatroomClient.getChatroomService();
// 待查询的账号列表，为空或者 size==0，或者 size>200，返回参数错误
List<String> accountIds = getAccountIds();
v2ChatroomService.getMemberByIds(accountIds, new V2NIMSuccessCallback<List<V2NIMChatroomMember>>() {
    @Override
    public void onSuccess(List<V2NIMChatroomMember> v2NIMChatroomMembers) {
        // 查询成功
    }
}, new V2NIMFailureCallback() {
    @Override
    public void onFailure(V2NIMError error) {
        // 查询失败
    }
});

objective-c// 通过实例 ID 获取聊天室实例
id <V2NIMChatroomService> service = [[V2NIMChatroomClient getInstance:1] getChatroomService];

// 待查询的账号列表，为空或者 size==0，或者 size>200，返回参数错误
NSArray<NSString *> *accountIds = @[@"accountId0", @"accountId1", @"accountId2"];

[service getMemberByIds:accountIds
                success:^(NSArray<V2NIMChatroomMember *> *members) {
                    // 获取成功
                }
                failure:^(V2NIMError *error) {
                    // 获取失败
                }];

cppchatroomService.getMemberByIds(
    {"accountId1", "accountId2"},
    [](nstd::vector<V2NIMChatroomMember> members) {
        // get members by account ids succeeded
    },
    [](V2NIMError error) {
        // get members by account ids failed, handle error
    });

typescriptgetMemberByIds(accountIds: string[]): Promise<V2NIMChatroomMember[]>

typescriptconst members = await this.chatroomClient.chatroomService.getMemberByIds(['accid1', 'accid2'])

java// 通过实例 ID 获取聊天室实例
V2NIMChatroomClient v2ChatroomClient = V2NIMChatroomClient.getInstance(instanceId);
V2NIMChatroomService v2ChatroomService = v2ChatroomClient.getChatroomService();

V2NIMChatroomMemberQueryOption queryOption = new V2NIMChatroomMemberQueryOption();
// 设置需要查询的成员类型，如果列表为空，表示查询所有类型的成员
List<V2NIMChatroomMemberRole> memberRoles = getMemberRoles();
queryOption.setMemberRoles(memberRoles);
// 是否只返回黑名单成员, 默认false
queryOption.setOnlyBlocked(false);
// 是否只返回禁言用户, 默认false
queryOption.setOnlyChatBanned(false);
// 是否只返回在线成员, 默认false
queryOption.setOnlyOnline(false);
// 设置查询数量
queryOption.setLimit(100);
// 设置分页标识，首页传""，下一页传上次返回的 pageToken
queryOption.setPageToken("");

v2ChatroomService.getMemberListByOption(queryOption, new V2NIMSuccessCallback<V2NIMChatroomMemberListResult>() {
    @Override
    public void onSuccess(V2NIMChatroomMemberListResult v2NIMChatroomMemberListResult) {
        // 查询成功
        List<V2NIMChatroomMember> memberList = v2NIMChatroomMemberListResult.getMemberList();
    }
}, new V2NIMFailureCallback() {
    @Override
    public void onFailure(V2NIMError error) {
        // 查询失败
    }
});

objective-c// 通过实例 ID 获取聊天室服务
id <V2NIMChatroomService> service = [[V2NIMChatroomClient getInstance:1] getChatroomService];

V2NIMChatroomMemberQueryOption *queryOption = [[V2NIMChatroomMemberQueryOption alloc] init];
// 设置需要查询的成员类型,如果列表为空，表示查询所有类型的成员
queryOption.memberRoles = @[@(V2NIM_CHATROOM_MEMBER_ROLE_NORMAL_GUEST), @(V2NIM_CHATROOM_MEMBER_ROLE_ANONYMOUS_GUEST)];
// 是否只返回黑名单成员, 默认false
queryOption.onlyBlocked = NO;
// 是否只返回禁言用户, 默认false
queryOption.onlyChatBanned = NO;
// 是否只返回在线成员, 默认false
queryOption.onlyOnline = NO;
// 设置查询数量
queryOption.limit = 100;
// 设置分页标识，首页传""，下一页传上次返回的 pageToken
queryOption.pageToken = @"";
[service getMemberListByOption:queryOption
                       success:^(V2NIMChatroomMemberListResult *result)
                       {
                           // 查询成功
                       }
                       failure:^(V2NIMError *error)
                       {
                           // 查询失败
                       }];

cppV2NIMChatroomMemberQueryOption queryOption;
queryOption.pageToken = 0; // first page
queryOption.limit = 10;
chatroomService.getMemberListByOption(
    queryOption,
    [](V2NIMChatroomMemberListResult result) {
        // get member list succeeded
    },
    [](V2NIMError error) {
        // get member list failed, handle error
    });

typescriptawait chatroom.V2NIMChatroomService.getMemberListByOption({
    // 普通成员
    memberRoles: [V2NIMChatroomMemberRole.V2NIM_CHATROOM_MEMBER_ROLE_NORMAL],
    onlyBlocked: false,
    onlyChatBanned: false,
    onlyOnline: false,
    limit: 100
})

typescriptawait this.chatroomClient.chatroomService.getMemberListByOption({
    // 普通成员
    memberRoles: [V2NIMChatroomMemberRole.V2NIM_CHATROOM_MEMBER_ROLE_NORMAL],
    onlyBlocked: false,
    onlyChatBanned: false,
    onlyOnline: false,
    limit: 100
})

javaV2NIMChatroomClient v2ChatroomClient = V2NIMChatroomClient.getInstance(instanceId);
V2NIMChatroomService v2ChatroomService = v2ChatroomClient.getChatroomService();
// 查询的 tag，必传字段，传 null 或者 ""，会返回参数错误
String tag = "xxx";
v2ChatroomService.getMemberCountByTag(tag, new V2NIMSuccessCallback<Long>() {
    @Override
    public void onSuccess(Long count) {
        // 查询成功
    }
}, new V2NIMFailureCallback() {
    @Override
    public void onFailure(V2NIMError error) {
        // 查询失败
    }
});

objective-c// 通过实例 ID 获取聊天室实例
id <V2NIMChatroomService> service = [[V2NIMChatroomClient getInstance:1] getChatroomService];

// 查询的 tag，必传字段，传 null 或者 ""，会返回参数错误
NSString *tag = @"xxx";
[service getMemberCountByTag:tag
                    success:^(NSInteger memberCount)
                    {
                        // 获取成功
                    }
                    failure:^(V2NIMError *error)
                    {
                        // 获取失败
                    }];

cppchatroomService.getMemberCountByTag(
    "tag1",
    [](uint64_t count) {
        // get member count by tag succeeded
    },
    [](V2NIMError error) {
        // get member count by tag failed, handle error
    });

typescriptconst count = await chatroom.V2NIMChatroomService.getMemberCountByTag('tagName')

typescriptconst count = await this.chatroomClient.chatroomService.getMemberCountByTag('tagName')

javaV2NIMChatroomClient v2ChatroomClient = V2NIMChatroomClient.getInstance(instanceId);
V2NIMChatroomService v2ChatroomService = v2ChatroomClient.getChatroomService();

V2NIMChatroomSelfMemberUpdateParams updateParams = new V2NIMChatroomSelfMemberUpdateParams();
// 设置聊天室中显示的昵称
updateParams.setRoomNick("xxx");
// 设置头像
updateParams.setRoomAvatar("xxx");
// 设置成员扩展字段
updateParams.setServerExtension("xxx");
// 以上三个字段至少需要设置一个，否则会返回参数错误

// 设置是否需要通知
updateParams.setNotificationEnabled(true);
// 设置本次操作生成的通知中的扩展字段
updateParams.setNotificationExtension("xxx");
// 设置更新信息持久化， 只针对固定成员身份生效
updateParams.setPersistence(true);

// 反垃圾配置，可不传
V2NIMAntispamConfig antispamConfig = new V2NIMAntispamConfig();

v2ChatroomService.updateSelfMemberInfo(updateParams, antispamConfig, new V2NIMSuccessCallback<Void>() {
    @Override
    public void onSuccess(Void unused) {
        // 更新成功
    }
}, new V2NIMFailureCallback() {
    @Override
    public void onFailure(V2NIMError error) {
        // 更新失败
    }
});

objective-c// 通过实例 ID 获取聊天室实例
id <V2NIMChatroomService> service = [[V2NIMChatroomClient getInstance:1] getChatroomService];

V2NIMChatroomSelfMemberUpdateParams *updateParams = [[V2NIMChatroomSelfMemberUpdateParams alloc] init];
// 设置聊天室中显示的昵称
updateParams.roomNick = @"xxx";
// 设置头像
updateParams.roomAvatar = @"xxx";
// 设置成员扩展字段
updateParams.serverExtension = @"xxx";
// 以上三个字段至少需要设置一个，否则会返回参数错误

// 设置是否需要通知
updateParams.notificationEnabled = YES;
// 设置本次操作生成的通知中的扩展字段
updateParams.notificationExtension = @"xxx";
// 设置更新信息持久化， 只针对固定成员身份生效
updateParams.persistence = YES;

// 反垃圾配置，可不传
V2NIMAntispamConfig *antispamConfig = [[V2NIMAntispamConfig alloc] init];
[service updateSelfMemberInfo:updateParams
               antispamConfig:antispamConfig
                      success:^() 
                      {
                          // 更新成功
                      }
                      failure:^(V2NIMError *error) 
                      {
                          // 更新失败
                      }];

cppV2NIMChatroomSelfMemberUpdateParams updateParams;
updateParams.roomNick = "roomNick";
V2NIMAntispamConfig antispamConfig;
chatroomService.updateSelfMemberInfo(
    updateParams,
    antispamConfig,
    []() {
        // update self member info succeeded
    },
    [](V2NIMError error) {
        // update self member info failed, handle error
    });

typescriptawait chatroom.V2NIMChatroomService.updateSelfMemberInfo({
    roomNick: 'nick', // 聊天室昵称
    roomAvatar: 'https://www.xxx.com/1.jpg', // 头像
    serverExtension: 'extension', // 扩展字段
    notificationEnabled: true, // 是否通知
    persistence: true // 是否持久化。若为否，则信息在下线后失效
})

typescriptawait this.chatroomClient.chatroomService.updateSelfMemberInfo({
    roomNick: 'nick', // 聊天室昵称
    roomAvatar: 'https://www.xxx.com/1.jpg', // 头像
    serverExtension: 'extension', //扩展字段
    notificationEnabled: true, //是否通知
    persistence: true //是否持久化。若为否，则信息在下线后失效
})

java// 通过实例 ID 获取聊天室实例
V2NIMChatroomClient v2ChatroomClient = V2NIMChatroomClient.getInstance(instanceId);
V2NIMChatroomService v2ChatroomService = v2ChatroomClient.getChatroomService();
// 被操作的账号 ID
String accountId = "test";
V2NIMChatroomMemberRoleUpdateParams updateParams = new V2NIMChatroomMemberRoleUpdateParams();
// 设置成员角色，必传字段，如果不传，会返回参数错误
// 不支持设置为
// V2NIMChatroomMemberRole.V2NIM_CHATROOM_MEMBER_ROLE_CREATOR
// V2NIMChatroomMemberRole.V2NIM_CHATROOM_MEMBER_ROLE_ANONYMOUS_GUEST
// V2NIMChatroomMemberRole.V2NIM_CHATROOM_MEMBER_ROLE_VIRTUAL
updateParams.setMemberRole(V2NIMChatroomMemberRole.V2NIM_CHATROOM_MEMBER_ROLE_MANAGER);
// 设置成员等级,可不传
updateParams.setMemberLevel(1);
// 设置通知扩展字段，可不传
updateParams.setNotificationExtension("xxx");

v2ChatroomService.updateMemberRole(accountId, updateParams, new V2NIMSuccessCallback<Void>() {
    @Override
    public void onSuccess(Void unused) {
        //更新成功
    }
}, new V2NIMFailureCallback() {
    @Override
    public void onFailure(V2NIMError error) {
        //更新失败
    }
});

objective-c// 通过实例 ID 获取聊天室实例
id <V2NIMChatroomService> service = [[V2NIMChatroomClient getInstance:instanceId] getChatroomService];
// 被操作的账号 ID
NSString *accountId = @"test";
V2NIMChatroomMemberRoleUpdateParams *updateParams = [[V2NIMChatroomMemberRoleUpdateParams alloc] init];
// 设置成员角色，必传字段，如果不传，会返回参数错误
// 不支持设置为
// V2NIMChatroomMemberRole.V2NIM_CHATROOM_MEMBER_ROLE_CREATOR
// V2NIMChatroomMemberRole.V2NIM_CHATROOM_MEMBER_ROLE_ANONYMOUS_GUEST
// V2NIMChatroomMemberRole.V2NIM_CHATROOM_MEMBER_ROLE_VIRTUAL
updateParams.memberRole = V2NIM_CHATROOM_MEMBER_ROLE_MANAGER;
// 设置成员等级,可不传
updateParams.memberLevel = 1;
// 设置通知扩展字段，可不传
updateParams.notificationExtension = @"xxx";
[service updateMemberRole:accountId
             updateParams:updateParams
                 success:^()
                 {
                     // 更新成功
                 }
                 failure:^(V2NIMError *error)
                 {
                     // 更新失败
                 }];

cppV2NIMChatroomMemberRoleUpdateParams updateParams;
updateParams.memberRole = V2NIM_CHATROOM_MEMBER_ROLE_MANAGER;
chatroomService.updateMemberRole(
    "accountId",
    updateParams,
    []() {
        // update member role succeeded
    },
    [](V2NIMError error) {
        // update member role failed, handle error
    });

typescriptawait chatroom.V2NIMChatroomService.updateMemberRole('accid', {
    // 设置为管理员
    memberRole: V2NIMChatroomMemberRole.V2NIM_CHATROOM_MEMBER_ROLE_MANAGER,
    // 用户登记
    memberLevel: 10,
    // 通知的扩展字段
    notificationExtension: 'ps'
})

typescriptawait this.chatroomClient.chatroomService.updateMemberRole('accid', {
    // 设置为管理员
    memberRole: V2NIMChatroomMemberRole.V2NIM_CHATROOM_MEMBER_ROLE_MANAGER,
    // 用户登记
    memberLevel: 10,
    // 通知的扩展字段
    notificationExtension: 'ps'
})

java// 通过实例 ID 获取聊天室实例
V2NIMChatroomClient v2ChatroomClient = V2NIMChatroomClient.getInstance(instanceId);
V2NIMChatroomService v2ChatroomService = v2ChatroomClient.getChatroomService();

// 被操作的账号 ID
String accountId = "test";
// 设置黑名单状态
boolean blocked = true;
// 设置通知扩展字段，可不传
String notificationExtension = "xxx";

v2ChatroomService.setMemberBlockedStatus(accountId, blocked, notificationExtension, new V2NIMSuccessCallback<Void>() {
    @Override
    public void onSuccess(Void unused) {
        // 设置成功
    }
}, new V2NIMFailureCallback() {
    @Override
    public void onFailure(V2NIMError error) {
        // 设置失败
    }
});

objective-c// 通过实例 ID 获取聊天室实例
id <V2NIMChatroomService> service = [[V2NIMChatroomClient getInstance:1] getChatroomService];
// 被操作的账号 ID
NSString *accountId = @"test";
// 设置黑名单状态
BOOL blocked = YES;
// 设置通知扩展字段，可不传
NSString *notificationExtension = @"xxx";
[service setMemberBlockedStatus:accountId
                        blocked:blocked
          notificationExtension:notificationExtension
                        success:^()
                        {
                            // 设置成功
                        }
                        failure:^(V2NIMError *error)
                        {
                            // 设置失败
                        }];

cppchatroomService.setMemberBlockedStatus(
    "accountId",
    true,
    "notificationExtension",
    []() {
        // set member blocked status succeeded
    },
    [](V2NIMError error) {
        // set member blocked status failed, handle error
    });

typescriptawait chatroom.V2NIMChatroomService.setMemberBlockedStatus('accountId', true, 'extension')

typescriptawait this.chatroomClient.chatroomService.setMemberBlockedStatus('accid', true, 'extension')

javaV2NIMChatroomClient v2ChatroomClient = V2NIMChatroomClient.getInstance(instanceId);
V2NIMChatroomService v2ChatroomService = v2ChatroomClient.getChatroomService();

// 被操作的账号ID
String accountId = "test";
// 设置禁言状态
boolean chatBanned = true;
// 设置通知扩展字段，可不传
String notificationExtension = "xxx";

v2ChatroomService.setMemberChatBannedStatus(accountId, chatBanned, notificationExtension, new V2NIMSuccessCallback<Void>() {
    @Override
    public void onSuccess(Void unused) {
        // 设置成功
    }
}, new V2NIMFailureCallback() {
    @Override
    public void onFailure(V2NIMError error) {
        // 设置失败
    }
});

objective-c// 通过实例 ID 获取聊天室实例
id <V2NIMChatroomService> service = [[V2NIMChatroomClient getInstance:1] getChatroomService];
// 被操作的账号 ID
NSString *accountId = @"test";
//设置禁言状态
BOOL chatBanned = YES;
// 设置通知扩展字段，可不传
NSString *notificationExtension = @"xxx";
[service setMemberChatBannedStatus:accountId
                        chatBanned:chatBanned
          notificationExtension:notificationExtension
                        success:^()
                        {
                            // 设置成功
                        }
                        failure:^(V2NIMError *error)
                        {
                            // 设置失败
                        }];

cppchatroomService.setMemberChatBannedStatus(
    "accountId",
    true,
    "notificationExtension",
    []() {
        // set member chat banned status succeeded
    },
    [](V2NIMError error) {
        // set member chat banned status failed, handle error
    });

typescriptawait chatroom.V2NIMChatroomService.setMemberChatBannedStatus('accid', true, 'extension')

typescriptawait this.chatroomClient.chatroomService.setMemberChatBannedStatus('accid', true, 'extension')

java// 通过实例 ID 获取聊天室实例
V2NIMChatroomClient v2ChatroomClient = V2NIMChatroomClient.getInstance(instanceId);
V2NIMChatroomService v2ChatroomService = v2ChatroomClient.getChatroomService();

// 被操作的账号 ID
String accountId = "test";
// 设置临时禁言时长，单位：秒，单次最大：30天，取消则设置为：0
long tempChatBannedDuration = 1000L;
// 是否需要发送广播通知，true：通知，false：不通知
boolean notificationEnabled = true;
// 设置通知扩展字段，可不传
String notificationExtension = "xxx";

v2ChatroomService.setMemberTempChatBanned(accountId, tempChatBannedDuration, notificationEnabled, notificationExtension, new V2NIMSuccessCallback<Void>() {
    @Override
    public void onSuccess(Void unused) {
        // 设置成功
    }
}, new V2NIMFailureCallback() {
    @Override
    public void onFailure(V2NIMError error) {
        // 设置失败
    }
});

objective-c// 通过实例 ID 获取聊天室实例
id <V2NIMChatroomService> service = [[V2NIMChatroomClient getInstance:1] getChatroomService];
// 被操作的账号 ID
NSString *accountId = @"test";
// 设置临时禁言时长，单位：秒，单次最大：30天，取消则设置为：0
long tempChatBannedDuration = 1000L;
// 是否需要发送广播通知，true：通知，false：不通知
BOOL notificationEnabled = YES;
// 设置通知扩展字段，可不传
NSString *notificationExtension = @"xxx";
[service setMemberTempChatBanned:accountId
          tempChatBannedDuration:tempChatBannedDuration
             notificationEnabled:notificationEnabled
           notificationExtension:notificationExtension
                         success:^() 
                         {
                             // 设置成功
                         }
                         failure:^(V2NIMError *error) 
                         {
                             // 设置失败
                         }];

cppchatroomService.setMemberTempChatBanned(
    "accountId",
    60,
    true,
    "notificationExtension",
    []() {
        // set member temp chat banned succeeded
    },
    [](V2NIMError error) {
        // set member temp chat banned failed, handle error
    });

typescriptawait chatroom.V2NIMChatroomService.setMemberTempChatBanned('accid', 60 * 1000, true, 'extension')

typescriptawait this.chatroomClient.chatroomService.setMemberTempChatBanned('accid', 60 * 1000, true, 'extension')

javaV2NIMChatroomClient v2ChatroomClient = V2NIMChatroomClient.getInstance(instanceId);
V2NIMChatroomService v2ChatroomService = v2ChatroomClient.getChatroomService();

// 被踢的成员ID
String accountId = "test";
// 设置通知扩展字段，可不传
String notificationExtension = "xxx";

v2ChatroomService.kickMember(accountId, notificationExtension, new V2NIMSuccessCallback<Void>() {
    @Override
    public void onSuccess(Void unused) {
        // 踢出成功
    }
}, new V2NIMFailureCallback() {
    @Override
    public void onFailure(V2NIMError error) {
        // 踢出失败
    }
});

objective-c// 通过实例 ID 获取聊天室实例
id <V2NIMChatroomService> service = [[V2NIMChatroomClient getInstance:1] getChatroomService];

// 被踢的成员 ID
NSString *accountId = @"accountId";
// 设置通知扩展字段，可不传
NSString *notificationExtension = @"xxx";
[service kickMember:accountId
notificationExtension:notificationExtension
            success:^() {
                // 踢出成功
            }
            failure:^(V2NIMError *error) {
                // 踢出失败
            }];

cppchatroomService.kickMember(
    "accountId",
    "notificationExtension",
    []() {
        // kick member succeeded
    },
    [](V2NIMError error) {
        // kick member failed, handle error
    });

typescriptawait chatroom.V2NIMChatroomService.kickMember('account', 'notificationExtension')

typescriptawait this.chatroomClient.chatroomService.kickMember('account', 'notificationExtension')