javavoid addChatroomListener(V2NIMChatroomListener listener);

objective-c- (void)addChatroomListener:(id<V2NIMChatroomListener>)listener;

cppvirtual void addChatroomListener(V2NIMChatroomListener listener) = 0;

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

V2NIMChatroomListener listener = new V2NIMChatroomListener() {
    @Override
    public void onReceiveMessages(List<V2NIMChatroomMessage> messages) {

    }

    @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 onChatroomInfoUpdated(V2NIMChatroomInfo chatroom) {

    }

    @Override
    public void onChatroomChatBannedUpdated(boolean chatBanned) {

    }

    @Override
    public void onMessageRevokedNotification(String messageClientId, long messageTime) {

    }

    @Override
    public void onChatroomTagsUpdated(List<String> tags) {

    }
};

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)onReceiveMessages:(NSArray *)messages
{

}

- (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)onChatroomInfoUpdated:(V2NIMChatroomInfo *)chatroomInfo
{

}

- (void)onChatroomChatBannedUpdated:(BOOL)chatBanned
{

}

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

}
- (void)onChatroomTagsUpdated:(NSArray<NSString *> *)tags
{

}

@end

cppV2NIMChatroomListener listener;
listener.onReceiveMessages = [](nstd::vector<V2NIMChatroomMessage> messages) {
    // handle receive messages
};
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.onChatroomInfoUpdated = [](V2NIMChatroomInfo chatroomInfo) {
    // handle chatroom info updated
};
listener.onChatroomChatBannedUpdated = [](bool chatBanned) {
    // handle chatroom chat banned updated
};
listener.onMessageRevokedNotification = [](nstd::string messageClientId, uint64_t messageTime) {
    // handle message revoked notification
};
listener.onChatroomTagsUpdated = [](nstd::vector<nstd::string> tags) {
    // handle chatroom tags updated
};
chatroomService.addChatroomListener(listener);

javavoid removeChatroomListener(V2NIMChatroomListener listener);

objective-c- (void)removeChatroomListener:(id<V2NIMChatroomListener>)listener;

cppvirtual void removeChatroomListener(V2NIMChatroomListener listener) = 0;

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

v2ChatroomService.removeChatroomListener(listener);

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

@implementation Listener

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

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

- (void)onReceiveMessages:(NSArray *)messages
{

}

@end

cppV2NIMChatroomListener listener;
// ...
chatroomService.addChatroomListener(listener);
// ...
chatroomService.removeChatroomListener(listener);

javavoid sendMessage(V2NIMChatroomMessage message, V2NIMSendChatroomMessageParams params, V2NIMSuccessCallback<V2NIMSendChatroomMessageResult> success,
    V2NIMFailureCallback failure,
    V2NIMProgressCallback progress);

objective-c- (void)sendMessage:(V2NIMChatroomMessage *)message
            params:(V2NIMSendChatroomMessageParams*)params
            success:(nullable V2NIMSendChatroomMessageSuccess)success
            failure:(nullable V2NIMFailureCallback)failure
            progress:(nullable V2NIMProgressCallback)progress;

cppvirtual void sendMessage(V2NIMChatroomMessage message,
    V2NIMSendChatroomMessageParams params,
    V2NIMSuccessCallback<V2NIMSendChatroomMessageResult> success,
    V2NIMFailureCallback failure,
    V2NIMProgressCallback progress) = 0;

typescriptsendMessage(
  message: V2NIMChatroomMessage,
  params?: V2NIMSendChatroomMessageParams,
  progress?: (percentage: number) => void
): Promise<V2NIMSendChatroomMessageResult>

java// 新建一个聊天室实例，注意：每次 newInstance 都会返回一个新的实例，实际使用中请一个聊天室对应一个V2NIMChatroomClient实例，使用中需要临时缓存
V2NIMChatroomClient v2ChatroomClient = V2NIMChatroomClient.newInstance();
// 获取聊天室服务
V2NIMChatroomService v2ChatroomService = v2ChatroomClient.getChatroomService();
// 创建一条文本消息
V2NIMChatroomMessage v2Message = V2NIMChatroomMessageCreator.createTextMessage("xxx");

V2NIMChatroomMessageConfig messageConfig = new V2NIMChatroomMessageConfig();
// 根据实际情况配置
// 设置是否需要在服务端保存历史消息，默认true
// messageConfig.setHistoryEnabled(true);
// 设置是否是高优先级消息，默认false
// messageConfig.setHighPriority(false);

V2NIMMessageRouteConfig routeConfig = V2NIMMessageRouteConfig.V2NIMMessageRouteConfigBuilder.builder()
// 根据实际情况配置
// .withRouteEnabled()
// .withRouteEnvironment()
.build();

V2NIMMessageAntispamConfig antispamConfig = V2NIMMessageAntispamConfig.V2NIMMessageAntispamConfigBuilder.builder()
// 根据实际情况配置
// .withAntispamBusinessId()
// .withAntispamCheating()
// .withAntispamCustomMessage()
// .withAntispamEnabled()
// .withAntispamExtension()
.build();

V2NIMSendChatroomMessageParams params = new V2NIMSendChatroomMessageParams();
// 设置消息相关配置
// params.setMessageConfig(messageConfig);
// 设置路由抄送相关配置
// params.setRouteConfig(routeConfig);
// 设置反垃圾相关配置
// params.setAntispamConfig(antispamConfig);
// 是否开启本地反垃圾，默认false
// params.setClientAntispamEnabled(false);
// 本地反垃圾的替换文本
// params.setClientAntispamReplace("xxx");
//设置聊天室定向消息接收者账号ID列表
// params.setReceiverIds(receiverIds);
// 设置消息的目标标签表达式
// params.setNotifyTargetTags("xxx");
// 设置位置信息
// params.setLocationInfo(locationInfo);
v2ChatroomService.sendMessage(v2Message,params,
new V2NIMSuccessCallback<V2NIMSendChatroomMessageResult>() {
    @Override
    public void onSuccess(V2NIMSendChatroomMessageResult result) {
        // 发送成功
    }
},
new V2NIMFailureCallback() {
    @Override
    public void onFailure(V2NIMError error) {
        // 发送失败
    }
},
new V2NIMProgressCallback() {
    @Override
    public void onProgress(int progress) {
        // 发送进度
    }
});

objective-c// 通过实例 ID 获取聊天室服务
id <V2NIMChatroomService> service = [[V2NIMChatroomClient getInstance:instanceId] getChatroomService];
// 创建一条文本消息
V2NIMChatroomMessage *message = [V2NIMChatroomMessageCreator createTextMessage:@"xxx"];
V2NIMChatroomMessageConfig *messageConfig = [V2NIMChatroomMessageConfig new];
// 根据实际情况配置
// 设置是否需要在服务端保存历史消息，默认 true
// messageConfig.historyEnabled = YES;
// 设置是否是高优先级消息，默认 false
// messageConfig.highPriority = NO;
V2NIMMessageRouteConfig *routeConfig = [V2NIMMessageRouteConfig new];
// 根据实际情况配置
// routeConfig.routeEnabled
// routeConfig.routeEnvironment
V2NIMMessageAntispamConfig *antispamConfig = [V2NIMMessageAntispamConfig new];
// 根据实际情况配置
// antispamConfig.antispamBusinessId
// antispamConfig.antispamCheating
// antispamConfig.antispamCustomMessage
// antispamConfig.antispamEnabled
// antispamConfig.antispamExtension

V2NIMSendChatroomMessageParams *params = [V2NIMSendChatroomMessageParams new];
// 设置消息相关配置
// params.messageConfig = messageConfig;
// 设置路由抄送相关配置
// params.routeConfig = routeConfig;
// 设置反垃圾相关配置
// params.antispamConfig = antispamConfig;
// 是否开启本地反垃圾，默认false
// params.clientAntispamEnabled = false;
// 本地反垃圾的替换文本
// params.clientAntispamReplace = @"xxx";
// 设置聊天室定向消息接收者账号ID列表
// params.receiverIds = receiverIds;
// 设置消息的目标标签表达式
// params.notifyTargetTags = @"xxx";
// 设置位置信息
// params.locationInfo = locationInfo;
[service sendMessage:message
            params:params
            success:^(V2NIMSendChatroomMessageResult *result)
            {
                // 发送成功
            }
            failure:^(V2NIMError *error)
            {
                // 发送失败
            }
            progress:^(NSUInteger progress)
            {
                // 上传进度
            }];        

cpp// 创建一条文本消息
auto message = V2NIMChatroomMessageCreator::createTextMessage("hello world");
auto params = V2NIMSendChatroomMessageParams();
// 发送消息
chatroomService.sendMessage(
    message,
    params,
    [](V2NIMSendChatroomMessageResult result) {
        // send message succeeded
    },
    [](V2NIMError error) {
        // send message failed, handle error
    },
    [](uint32_t progress) {
        // upload progress
    });

typescriptawait chatroom.V2NIMChatroomService.sendMessage(
    message,
    // V2NIMSendChatroomMessageParams
    {
        locationInfo: {x: 0, y: 100, z: 0}
    },
    progress: (percentage) => {console.log('上传进度: ' + percentage)}
)

无返回值

Promise<V2NIMSendChatroomMessageResult> 聊天室消息发送结果

• 请求成功，返回 V2NIMSuccessCallback 回调，包含 V2NIMSendChatroomMessageResult。
• 请求失败，返回 V2NIMFailureCallback 回调，包含聊天室消息相关错误码。

• 请求成功，返回 V2NIMSendChatroomMessageSuccess 回调，可自定义设置。
• 请求失败，返回 V2NIMFailureCallback 回调，包含聊天室消息相关错误码。

无

javavoid cancelMessageAttachmentUpload(V2NIMChatroomMessage message,V2NIMSuccessCallback<Void> success,
V2NIMFailureCallback failure);

objective-c- (void)cancelMessageAttachmentUpload:(V2NIMChatroomMessage *)message
                              success:(nullable V2NIMSuccessCallback)success
                              failure:(nullable V2NIMFailureCallback)failure;

cppvirtual void cancelMessageAttachmentUpload(V2NIMChatroomMessage message, V2NIMSuccessCallback<void> success, V2NIMFailureCallback failure) = 0;

typescriptcancelMessageAttachmentUpload(message: V2NIMChatroomMessage): Promise<void>

java// 通过实例ID获取聊天室实例
V2NIMChatroomClient v2ChatroomClient = V2NIMChatroomClient.getInstance(instanceId);
V2NIMChatroomService v2ChatroomService = v2ChatroomClient.getChatroomService();
v2ChatroomService.cancelMessageAttachmentUpload(v2Message, 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];
[service cancelMessageAttachmentUpload:message
                               success:^{
                                   // 取消成功
                               }
                               failure:^(V2NIMError *error) {
                                   // 取消失败
                               }];

cppV2NIMChatroomMessage message;
// ...
chatroomService.cancelMessageAttachmentUpload(
    message,
    []() {
        // cancel message attachment upload succeeded
    },
    [](V2NIMError error) {
        // cancel message attachment upload failed, handle error
    });

typescriptawait chatroom.V2NIMChatroomService.cancelMessageAttachmentUpload(message)

无返回值

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调。
• 请求失败，返回 V2NIMFailureCallback 回调，包含消息相关错误码。

无

javavoid getMessageList(V2NIMChatroomMessageListOption option, V2NIMSuccessCallback<List<V2NIMChatroomMessage>> success,
V2NIMFailureCallback failure);

objective-c- (void)getMessageList:(V2NIMChatroomMessageListOption *)option
               success:(nullable V2NIMChatroomMessageListCallback)success
               failure:(nullable V2NIMFailureCallback)failure;

cppvirtual void getMessageList(V2NIMChatroomMessageListOption option,
    V2NIMSuccessCallback<nstd::vector<V2NIMChatroomMessage>> success,
    V2NIMFailureCallback failure) = 0;

typescriptgetMessageList(option: V2NIMChatroomMessageListOption): Promise<V2NIMChatroomMessage[]>

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

V2NIMChatroomMessageListOption option = new V2NIMChatroomMessageListOption();
// 设置查询数量
option.setLimit(100);
// 设置消息查询起始时间
option.setBeginTime(0L);
// 设置消息查询方向
option.setDirection(V2NIMMessageQueryDirection.V2NIM_QUERY_DIRECTION_DESC);
// 设置查询的消息类型，如果列表为空，表示查询所有类型的消息
List<V2NIMMessageType> messageTypes = getMessageTypes();
option.setMessageTypes(messageTypes);

v2ChatroomService.getMessageList(option, new V2NIMSuccessCallback<List<V2NIMChatroomMessage>>() {
    @Override
    public void onSuccess(List<V2NIMChatroomMessage> v2NIMChatroomMessages) {
        //查询成功
    }
}, new V2NIMFailureCallback() {
    @Override
    public void onFailure(V2NIMError error) {
        //查询失败
    }
});

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

V2NIMChatroomMessageListOption *option = [[V2NIMChatroomMessageListOption alloc] init];
// 设置查询数量
option.limit = 100;
// 设置消息查询起始时间
option.beginTime = 0L;
// 设置消息查询方向
option.direction = V2NIM_QUERY_DIRECTION_DESC;
// 设置查询的消息类型，如果列表为空，表示查询所有类型的消息
option.messageTypes = @[
    @(V2NIM_MESSAGE_TYPE_TEXT),
    @(V2NIM_MESSAGE_TYPE_IMAGE),
    @(V2NIM_MESSAGE_TYPE_LOCATION),
    @(V2NIM_MESSAGE_TYPE_NOTIFICATION),
    @(V2NIM_MESSAGE_TYPE_FILE),
    @(V2NIM_MESSAGE_TYPE_TIP),
    @(V2NIM_MESSAGE_TYPE_CUSTOM)
];
[service getMessageList:option
                success:^(NSArray<V2NIMChatroomMessage *> *messages)
                {
                    // 查询成功
                }
                failure:^(V2NIMError *error)
                {
                    // 查询失败
                }];

cppV2NIMChatroomMessageListOption option;
option.beginTime = 0;
option.limit = 10;
chatroomService.getMessageList(
    option,
    [](nstd::vector<V2NIMChatroomMessage> messages) {
        // get message list succeeded
    },
    [](V2NIMError error) {
        // get message list failed, handle error
    });

typescriptconst messageArr = await chatroom.V2NIMChatroomService.getMessageList({
    // 0 是降序查找。从最新的消息开始查询
    direction: V2NIMQueryDirection.V2NIM_QUERY_DIRECTION_DESC,
    // 查询开始时间
    beginTime: 0,
    limit: 100
})

无返回值

//消息列表 Promise<V2NIMChatroomMessage[]>

• 请求成功，返回 V2NIMSuccessCallback 回调，包含 V2NIMChatroomMessage 列表。
• 请求失败，返回 V2NIMFailureCallback 回调，包含聊天室消息相关错误码。

• 请求成功，返回 V2NIMChatroomMessageListCallback 回调，可自定义设置。
• 请求失败，返回 V2NIMFailureCallback 回调，包含聊天室消息相关错误码。

无

javavoid getMessageListByTag(V2NIMChatroomTagMessageOption messageOption, V2NIMSuccessCallback<List<V2NIMChatroomMessage>> success,
V2NIMFailureCallback failure);

objective-c- (void)getMessageListByTag:(V2NIMChatroomTagMessageOption *)option
               success:(nullable V2NIMChatroomMessageListCallback)success
               failure:(nullable V2NIMFailureCallback)failure;

cppvirtual void getMessageListByTag(V2NIMChatroomTagMessageOption messageOption,
    V2NIMSuccessCallback<nstd::vector<V2NIMChatroomMessage>> success,
    V2NIMFailureCallback failure) = 0;

typescriptgetMessageListByTag(messageOption: V2NIMChatroomTagMessageOption): Promise<V2NIMChatroomMessage[]>

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

V2NIMChatroomTagMessageOption messageOption = new V2NIMChatroomTagMessageOption();
// tag 列表
List<String> tags = getTags();
// 设置查询的 tag 列表，必传字段，传 null 或者 size 为 0，会返回参数错误
messageOption.setTags(tags);
// 设置查询数量
messageOption.setLimit(100);
List<V2NIMMessageType> messageTypes = getMessageTypes();
// 设置查询的消息类型，如果列表为空，表示查询所有类型的消息
messageOption.setMessageTypes(messageTypes);
messageOption.setDirection(V2NIMMessageQueryDirection.V2NIM_QUERY_DIRECTION_DESC);
// 设置查询开始时间，首次传0，单位毫秒
messageOption.setBeginTime(0L);
// 设置查询结束时间，默认0表示当前时间，单位毫秒
messageOption.setEndTime(0L);

v2ChatroomService.getMessageListByTag(messageOption, new V2NIMSuccessCallback<List<V2NIMChatroomMessage>>() {
    @Override
    public void onSuccess(List<V2NIMChatroomMessage> v2NIMChatroomMessages) {
        // 查询成功
    }
}, new V2NIMFailureCallback() {
    @Override
    public void onFailure(V2NIMError error) {
        // 查询失败
    }
});

objective-c// 通过实例ID获取聊天室实例
id <V2NIMChatroomService> service = [[V2NIMChatroomClient getInstance:1] getChatroomService];
V2NIMChatroomTagMessageOption *messageOption = [[V2NIMChatroomTagMessageOption alloc] init];
// 设置查询的 tag 列表，必传字段，传 null 或者 size 为 0，会返回参数错误
messageOption.tags = @[@"tag1", @"tag2"];
// 设置查询数量
messageOption.limit = 100;
// 设置查询的消息类型，如果列表为空，表示查询所有类型的消息
messageOption.messageTypes = @[@(V2NIM_MESSAGE_TYPE_TEXT), @(V2NIM_MESSAGE_TYPE_FILE)];
// 设置查询方向
messageOption.direction = V2NIM_QUERY_DIRECTION_DESC;
// 设置查询开始时间，单位秒
messageOption.beginTime = 0;
// 设置查询结束时间，默认0表示当前时间，单位秒
messageOption.endTime = 0;
[service getMessageListByTag:messageOption
                     success:^(NSArray<V2NIMChatroomMessage *> *messages)
                     {
                         // 查询成功
                     }
                     failure:^(V2NIMError *error)
                     {
                         // 查询失败
                     }];

cppV2NIMChatroomTagMessageOption messageOption;
messageOption.tags = {"tag1", "tag2"};
messageOption.limit = 10;
chatroomService.getMessageListByTag(
    messageOption,
    [](nstd::vector<V2NIMChatroomMessage> messages) {
        // get message list by tag succeeded
    },
    [](V2NIMError error) {
        // get message list by tag failed, handle error
    });

typescriptconst messages = await chatroom.V2NIMChatroomService.getMessageListByTag({
    tags: ['tag1', 'tag2'], // 查询的 tags
    limit: 100,
    direction: V2NIMQueryDirection.V2NIM_QUERY_DIRECTION_DESC
})

无返回值

Promise<V2NIMChatroomMessage[]>

• 请求成功，返回 V2NIMSuccessCallback 回调，包含 V2NIMChatroomMessage 列表。
• 请求失败，返回 V2NIMFailureCallback 回调，包含聊天室消息相关错误码。

• 请求成功，返回 V2NIMChatroomMessageListCallback 回调，可自定义设置。
• 请求失败，返回 V2NIMFailureCallback 回调，包含聊天室消息相关错误码。

无

javavoid kickMember(String accountId, String notificationExtension, V2NIMSuccessCallback<Void> success,
V2NIMFailureCallback failure);

objective-c- (void)kickMember:(NSString *)accountId
notificationExtension:(nullable NSString *)notificationExtension
           success:(nullable V2NIMSuccessCallback)success
           failure:(nullable V2NIMFailureCallback)failure;

cppvirtual void kickMember(nstd::string accountId,
    nstd::string notificationExtension,
    V2NIMSuccessCallback<void> success,
    V2NIMFailureCallback failure) = 0;

typescriptkickMember(accountId: string, notificationExtension?: string): Promise<void>

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')

无返回值

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调；踢出聊天室成功，返回 onChatroomKicked 回调和 onChatroomExited 回调。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含聊天室相关错误码。

踢出聊天室成功，返回 onChatroomKicked 回调和 onChatroomExited 回调。

javavoid getMemberListByOption(V2NIMChatroomMemberQueryOption queryOption, V2NIMSuccessCallback<V2NIMChatroomMemberListResult> success,
V2NIMFailureCallback failure);

objective-c- (void)getMemberListByOption:(V2NIMChatroomMemberQueryOption *)queryOption
                      success:(nullable V2NIMChatroomMemberListResultCallback)success
                      failure:(nullable V2NIMFailureCallback)failure;

cppvirtual void getMemberListByOption(V2NIMChatroomMemberQueryOption queryOption,
    V2NIMSuccessCallback<V2NIMChatroomMemberListResult> success,
    V2NIMFailureCallback failure) = 0;

typescriptgetMemberListByOption(option: V2NIMChatroomMemberQueryOption): Promise<V2NIMChatroomMemberListResult>

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
})

无返回值

Promise<V2NIMChatroomMemberListResult> 聊天室成员查询结果

• 请求成功，返回 V2NIMSuccessCallback 回调，包含 V2NIMChatroomMemberListResult。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含聊天室相关错误码。

• 请求成功，返回 V2NIMChatroomMemberListResultCallback 回调，可自定义设置。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含聊天室相关错误码。

无

javavoid getMemberByIds(List<String> accountIds, V2NIMSuccessCallback<List<V2NIMChatroomMember>> success,
V2NIMFailureCallback failure);

objective-c- (void)getMemberByIds:(NSArray<NSString *> *)accountIds
               success:(nullable V2NIMChatroomMemberListCallback)success
               failure:(nullable V2NIMFailureCallback)failure;

cppvirtual void getMemberByIds(nstd::vector<nstd::string> accountIds,
    V2NIMSuccessCallback<nstd::vector<V2NIMChatroomMember>> success,
    V2NIMFailureCallback failure) = 0;

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

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[]>

无返回值

Promise<V2NIMChatroomMember[]> 聊天室信息列表

• 请求成功，返回 V2NIMSuccessCallback 回调，包含 V2NIMChatroomMember 列表。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含聊天室相关错误码。

• 请求成功，返回 V2NIMChatroomMemberListCallback 回调，可自定义设置。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含聊天室相关错误码。

无

javavoid getMemberListByTag(V2NIMChatroomTagMemberOption option, V2NIMSuccessCallback<V2NIMChatroomMemberListResult> success,
V2NIMFailureCallback failure);

objective-c- (void)getMemberListByTag:(V2NIMChatroomTagMemberOption *)option
                   success:(nullable V2NIMChatroomMemberListResultCallback)success
                   failure:(nullable V2NIMFailureCallback)failure;

cppvirtual void getMemberListByTag(V2NIMChatroomTagMemberOption option,
    V2NIMSuccessCallback<V2NIMChatroomMemberListResult> success,
    V2NIMFailureCallback failure) = 0;

typescriptgetMemberListByTag(option: V2NIMChatroomTagMemberOption): Promise<V2NIMChatroomMemberListResult>

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

V2NIMChatroomTagMemberOption option = new V2NIMChatroomTagMemberOption();
// 设置查询 Tag，必传字段，如果不传，会返回参数错误
option.setTag("xxx");
// 设置查询数量
option.setLimit(100);
// 设置分页标识，首页传""，下一页传上次返回的 pageToken
option.setPageToken("");

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

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

V2NIMChatroomTagMemberOption *option = [[V2NIMChatroomTagMemberOption alloc] init];
// 设置查询 Tag，必传字段，如果不传，会返回参数错误
option.tag = @"xxx";
// 设置查询数量
option.limit = 100;
// 设置分页标识，首页传""，下一页传上次返回的 pageToken
option.pageToken = @"";

[service getMemberListByTag:option
                    success:^(V2NIMChatroomMemberListResult *result)
                    {
                        // 获取成功
                    }
                    failure:^(V2NIMError *error)
                    {
                        // 获取失败
                    }];

cppV2NIMChatroomTagMemberOption option;
option.tag = "tag1";
option.pageToken = "";
option.limit = 10;
chatroomService.getMemberListByTag(
    option,
    [](V2NIMChatroomMemberListResult result) {
        // get member list by tag succeeded
    },
    [](V2NIMError error) {
        // get member list by tag failed, handle error
    });

typescriptconst result = await chatroom.V2NIMChatroom.getMemberListByTag({
    tag: 'abc', // 查询的 tag
    limit: 100
})

无返回值

Promise<V2NIMChatroomMemberListResult> 聊天室成员查询结果

• 请求成功，返回 V2NIMSuccessCallback 回调，包含 V2NIMChatroomMemberListResult。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含聊天室相关错误码。

• 请求成功，返回 V2NIMChatroomMemberListResultCallback 回调，可自定义设置。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含聊天室相关错误码。

无

javavoid getMemberCountByTag(String tag, V2NIMSuccessCallback<Long> success,
V2NIMFailureCallback failure);

objective-c- (void)getMemberCountByTag:(NSString *)tag
                    success:(nullable V2NIMChatroomMemberCountCallback)success
                    failure:(nullable V2NIMFailureCallback)failure;

cppvirtual void getMemberCountByTag(nstd::string tag, V2NIMSuccessCallback<uint64_t> success, V2NIMFailureCallback failure) = 0;

typescriptgetMemberCountByTag(tag: string): Promise<number>

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')

聊天室成员人数

Promise 聊天室成员人数

javavoid updateMemberRole(String accountId, V2NIMChatroomMemberRoleUpdateParams updateParams, V2NIMSuccessCallback<Void> success,
V2NIMFailureCallback failure);

objective-c- (void)updateMemberRole:(NSString *)accountId
            updateParams:(V2NIMChatroomMemberRoleUpdateParams *)updateParams
                 success:(nullable V2NIMSuccessCallback)success
                 failure:(nullable V2NIMFailureCallback)failure;

cppvirtual void updateMemberRole(nstd::string accountId,
    V2NIMChatroomMemberRoleUpdateParams upadateParams,
    V2NIMSuccessCallback<void> success,
    V2NIMFailureCallback failure) = 0;

typescriptupdateMemberRole(accountId: string, updateParams: V2NIMChatroomMemberRoleUpdateParams): Promise<void>

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'
})

无返回值

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调；更新成功，返回 onChatroomMemberRoleUpdated 回调。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含群组相关错误码。

更新成功，返回 onChatroomMemberRoleUpdated 回调。

javavoid setMemberBlockedStatus(String accountId, boolean blocked,String notificationExtension, V2NIMSuccessCallback<Void> success,
V2NIMFailureCallback failure);

objective-c- (void)setMemberBlockedStatus:(NSString *)accountId
                       blocked:(BOOL)blocked
         notificationExtension:(nullable NSString *)notificationExtension
                       success:(nullable V2NIMSuccessCallback)success
                       failure:(nullable V2NIMFailureCallback)failure;

cppvirtual void setMemberBlockedStatus(nstd::string accountId,
    bool blocked,
    nstd::string notificationExtension,
    V2NIMSuccessCallback<void> success,
    V2NIMFailureCallback failure) = 0;

typescriptsetMemberBlockedStatus(accountId: string, blocked: boolean, notificationExtension?: string): Promise<void>

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')

无返回值

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调；设置成功，返回 onChatroomMemberInfoUpdated 回调。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含聊天室相关错误码。

设置成功，返回 onChatroomMemberInfoUpdated 回调。

javavoid setMemberChatBannedStatus(String accountId, boolean chatBanned,String notificationExtension, V2NIMSuccessCallback<Void> success,
V2NIMFailureCallback failure);

objective-c- (void)setMemberChatBannedStatus:(NSString *)accountId
                       chatBanned:(BOOL)chatBanned
            notificationExtension:(nullable NSString *)notificationExtension
                          success:(nullable V2NIMSuccessCallback)success
                          failure:(nullable V2NIMFailureCallback)failure;

cpp    virtual void setMemberChatBannedStatus(nstd::string accountId,
        bool chatBanned,
        nstd::string notificationExtension,
        V2NIMSuccessCallback<void> success,
        V2NIMFailureCallback failure) = 0;

typescriptsetMemberChatBannedStatus(accountId: string, chatBanned: boolean, notificationExtension?: string): Promise<void>

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')

无返回值

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调；设置成功，返回 onSelfChatBannedUpdated 和 onChatroomMemberInfoUpdated 回调。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含聊天室相关错误码。

设置成功，返回 onChatroomMemberInfoUpdated 回调。

javavoid setMemberTempChatBanned(String accountId, long tempChatBannedDuration,boolean notificationEnabled,String notificationExtension, V2NIMSuccessCallback<Void> success,
V2NIMFailureCallback failure);

objective-c- (void)setMemberTempChatBanned:(NSString *)accountId
         tempChatBannedDuration:(NSInteger)tempChatBannedDuration
            notificationEnabled:(BOOL)notificationEnabled
          notificationExtension:(nullable NSString *)notificationExtension
                        success:(nullable V2NIMSuccessCallback)success
                        failure:(nullable V2NIMFailureCallback)failure;

cppvirtual void setMemberTempChatBanned(nstd::string accountId,
    uint64_t tempChatBannedDuration,
    bool notificationEnabled,
    nstd::string notificationExtension,
    V2NIMSuccessCallback<void> success,
    V2NIMFailureCallback failure) = 0;

typescriptsetMemberTempChatBanned(accountId: string, tempChatBannedDuration: number, notificationEnabled: boolean, notificationExtension?: string): Promise<void>

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')

无返回值

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调；设置成功，返回 onSelfTempChatBannedUpdated 和 onChatroomMemberInfoUpdated 回调。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含聊天室相关错误码。

设置成功，返回 onChatroomMemberInfoUpdated 回调。

javavoid setTempChatBannedByTag(V2NIMChatroomTagTempChatBannedParams params, V2NIMSuccessCallback<Void> success,
  V2NIMFailureCallback failure);

objective-c- (void)setTempChatBannedByTag:(V2NIMChatroomTagTempChatBannedParams *)params
                       success:(nullable V2NIMSuccessCallback)success
                       failure:(nullable V2NIMFailureCallback)failure;

cppvirtual void setTempChatBannedByTag(V2NIMChatroomTagTempChatBannedParams params,
    V2NIMSuccessCallback<void> success,
    V2NIMFailureCallback failure) = 0;

typescriptsetTempChatBannedByTag(params: V2NIMChatroomTagTempChatBannedParams): Promise<void>

javaV2NIMChatroomClient v2ChatroomClient = V2NIMChatroomClient.getInstance(instanceId);
V2NIMChatroomService v2ChatroomService = v2ChatroomClient.getChatroomService();
V2NIMChatroomTagTempChatBannedParams params = new V2NIMChatroomTagTempChatBannedParams();
//设置禁言的tag,必传字段，如果不传，会返回参数错误
params.setTargetTag("xxx");
//设置禁言时长，单位：秒，单次最大：30天，取消则设置为：0
params.setDuration(1000);
//是否需要通知，true：通知，false：不通知
params.setNotificationEnabled(true);
//设置通知扩展字段，可不传
params.setNotificationExtension("xxx");

v2ChatroomService.setTempChatBannedByTag(params, 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];

V2NIMChatroomTagTempChatBannedParams *params = [[V2NIMChatroomTagTempChatBannedParams alloc] init];
//设置禁言的tag,必传字段，如果不传，会返回参数错误
params.targetTag = @"xxx";
//设置禁言时长，单位：秒，单次最大：30天，取消则设置为：0
params.duration = 1000;
//是否需要通知，true：通知，false：不通知
params.notificationEnabled = YES;
//设置通知扩展字段，可不传
params.notificationExtension = @"xxx";
[service setTempChatBannedByTag:params
                        success:^()
                        {
                            // 设置成功
                        }
                        failure:^(V2NIMError *error)
                        {
                            // 设置失败
                        }];

cppV2NIMChatroomTagTempChatBannedParams params;
params.tags = "tag1";
params.duration = 60;
params.notificationEnabled = true;
params.notificationExtension = "notificationExtension";
chatroomService.setTempChatBannedByTag(
    params,
    []() {
        // set temp chat banned by tag succeeded
    },
    [](V2NIMError error) {
        // set temp chat banned by tag failed, handle error
    });

typescriptawait chatroomV2.V2NIMChatroomService.setTempChatBannedByTag(
  {
    "targetTag": "ccc",  // 被禁言 tag
    "notifyTargetTags": "{tag: \"ccc\"}", // 接收通知的目标表达式
    "duration": 1000, // 禁言时长
    "notificationEnabled": true // 是否通知
  }
)

无返回值

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调；设置成功，返回 onSelfTempChatBannedUpdated 和 onChatroomMemberInfoUpdated 回调。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含聊天室相关错误码。

设置成功，返回 onChatroomMemberInfoUpdated 回调。

javavoid updateSelfMemberInfo(V2NIMChatroomSelfMemberUpdateParams updateParams, V2NIMAntispamConfig antispamConfig,V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

objective-c- (void)updateSelfMemberInfo:(V2NIMChatroomSelfMemberUpdateParams *)updateParams
              antispamConfig:(nullable V2NIMAntispamConfig *)antispamConfig
                     success:(nullable V2NIMSuccessCallback)success
                     failure:(nullable V2NIMFailureCallback)failure;

cppvirtual void updateSelfMemberInfo(V2NIMChatroomSelfMemberUpdateParams updateParams,
    V2NIMAntispamConfig antispamConfig,
    V2NIMSuccessCallback<void> success,
    V2NIMFailureCallback failure) = 0;

typescriptupdateSelfMemberInfo(updateParams: V2NIMChatroomSelfMemberUpdateParams, antispamConfig?: V2NIMAntispamConfig): Promise<void>

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 // 是否持久化。若为否，则信息在下线后失效
})

无返回值

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调；更新成功，返回 onChatroomMemberInfoUpdated 回调。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含聊天室相关错误码。

更新成功，返回 onChatroomMemberInfoUpdated 回调。

javavoid updateChatroomInfo(V2NIMChatroomUpdateParams updateParams, V2NIMAntispamConfig antispamConfig,V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

objective-c- (void)updateChatroomInfo:(V2NIMChatroomUpdateParams *)updateParams
            antispamConfig:(nullable V2NIMAntispamConfig *)antispamConfig
                   success:(nullable V2NIMSuccessCallback)success
                   failure:(nullable V2NIMFailureCallback)failure;

cppvirtual void updateChatroomInfo(V2NIMChatroomUpdateParams updateParams,
    V2NIMAntispamConfig antispamConfig,
    V2NIMSuccessCallback<void> success,
    V2NIMFailureCallback failure) = 0;

typescriptupdateChatroomInfo(updateParams: V2NIMChatroomUpdateParams, antispamConfig?: V2NIMAntispamConfig): Promise<void>

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

V2NIMChatroomUpdateParams updateParams = new V2NIMChatroomUpdateParams();
// 设置聊天室名称
updateParams.setRoomName("xxx");
// 设置聊天室公告
updateParams.setAnnouncement("xxx");
// 设置聊天室扩展字段
updateParams.setServerExtension("xxx");
// 设置聊天室直播地址
updateParams.setLiveUrl("xxx");
// 以上四个字段至少需要设置一个，否则会返回参数错误

// 设置是否需要通知
updateParams.setNotificationEnabled(true);
// 设置本次操作生成的通知中的扩展字段
updateParams.setNotificationExtension("xxx");

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

v2ChatroomService.updateChatroomInfo(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];

V2NIMChatroomUpdateParams *updateParams = [[V2NIMChatroomUpdateParams alloc] init];
// 设置聊天室名称
updateParams.roomName = @"xxx";
// 设置聊天室公告
updateParams.announcement = @"xxx";
// 设置聊天室扩展字段
updateParams.serverExtension = @"xxx";
// 设置聊天室直播地址
updateParams.liveUrl = @"xxx";
// 以上四个字段至少需要设置一个，否则会返回参数错误

// 设置是否需要通知
updateParams.notificationEnabled = true;
// 设置本次操作生成的通知中的扩展字段
updateParams.notificationExtension = @"xxx";

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

cppV2NIMChatroomUpdateParams updateParams;
updateParams.roomName = "roomName";
V2NIMAntispamConfig antispamConfig;
chatroomService.updateChatroomInfo(
    updateParams,
    antispamConfig,
    []() {
        // update chatroom info succeeded
    },
    [](V2NIMError error) {
        // update chatroom info failed, handle error
    });

typescriptawait chatroom.V2NIMChatroomService.updateChatroomInfo(
    {
        roomName: 'name',
        annoucement: 'announcement',
        serverExtension: 'serverExtension',
        notificationEnabled: true,
        notificationExtension: 'notificationExtension'    
    }
)

无返回值

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调；更新成功，返回 onChatroomInfoUpdated 回调。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含聊天室相关错误码。

更新成功，返回 onChatroomMemberInfoUpdated 回调。

javavoid updateChatroomLocationInfo(V2NIMChatroomLocationConfig locationConfig, V2NIMSuccessCallback<Void> success,
V2NIMFailureCallback failure);

objective-c- (void)updateChatroomLocationInfo:(V2NIMChatroomLocationConfig *)locationConfig
                           success:(nullable V2NIMSuccessCallback)success
                           failure:(nullable V2NIMFailureCallback)failure;

cppvirtual void updateChatroomLocationInfo(V2NIMChatroomLocationConfig locationConfig,
    V2NIMSuccessCallback<void> success,
    V2NIMFailureCallback failure) = 0;

typescriptupdateChatroomLocationInfo(locationConfig: V2NIMChatroomLocationConfig): Promise<void>

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

V2NIMChatroomLocationConfig locationConfig = new V2NIMChatroomLocationConfig();
V2NIMLocationInfo locationInfo = new V2NIMLocationInfo(0.0, 0.0, 0,0);

locationConfig.setLocationInfo(locationInfo);
locationConfig.setDistance(100);
// 以上两个字段必填，否则会返回参数错误

v2ChatroomService.updateChatroomLocationInfo(locationConfig, 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];

V2NIMChatroomLocationConfig *locationConfig = [[V2NIMChatroomLocationConfig alloc] init];
V2NIMLocationInfo *locationInfo = [[V2NIMLocationInfo alloc] init];

locationConfig.locationInfo = locationInfo;
locationConfig.distance = 100;
// 以上两个字段必填，否则会返回参数错误
[service updateChatroomLocationInfo:locationConfig
                success:^()
                {
                    // 更新成功
                }
                failure:^(V2NIMError *error)
                {
                    // 更新失败
                }];

cppV2NIMChatroomLocationConfig locationConfig;
locationConfig.locationInfo.x = 1.0;
locationConfig.locationInfo.y = 1.0;
locationConfig.locationInfo.z = 1.0;
locationConfig.distance = 100;
chatroomService.updateChatroomLocationInfo(
    locationConfig,
    []() {
        // update chatroom location info succeeded
    },
    [](V2NIMError error) {
        // update chatroom location info failed, handle error
    });

typescriptawait chatroomV2.V2NIMChatroomService.updateChatroomLocationInfo(
  {
    "locationInfo": {
      "x": 33,
      "y": 44,
      "z": 55
    },
    "distance": 77
  }
)

无返回值

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含聊天室相关错误码。

无

javavoid updateChatroomTags(V2NIMChatroomTagsUpdateParams updateParams, V2NIMSuccessCallback<Void> success,
V2NIMFailureCallback failure);

objective-c- (void)updateChatroomTags:(V2NIMChatroomTagsUpdateParams *)updateParams
                   success:(nullable V2NIMSuccessCallback)success
                   failure:(nullable V2NIMFailureCallback)failure;

cppvirtual void updateChatroomTags(V2NIMChatroomTagsUpdateParams updateParams, V2NIMSuccessCallback<void> success, V2NIMFailureCallback failure) = 0;

typescriptupdateChatroomTags(updateParams: V2NIMChatroomtagsUpdateParams): Promise<void>

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

V2NIMChatroomTagsUpdateParams updateParams = new V2NIMChatroomTagsUpdateParams();
// tag 列表
List<String> tags = getTags();
updateParams.setTags(tags);
updateParams.setNotifyTargetTags("xxx");
// 以上两个字段至少需要设置一个，否则会返回参数错误

v2ChatroomService.updateChatroomTags(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:1] getChatroomService];

V2NIMChatroomTagsUpdateParams *updateParams = [[V2NIMChatroomTagsUpdateParams alloc] init];
// tag 列表
NSArray<NSString *> *tags = @[ @"tag0", @"tag1" ]];
updateParams.tags = tags;
updateParams.notifyTargetTags = @"xxx";
// 以上两个字段至少需要设置一个，否则会返回参数错误
[service updateChatroomTags:updateParams
            success:^()
            {
                // 更新成功
            }
            failure:^(V2NIMError *error)
            {
                // 更新失败
            }];

cppV2NIMChatroomTagsUpdateParams updateParams;
updateParams.tags = {"tag1", "tag2"};
updateParams.notifyTargetTags = R"({"tag": "tag1"})";
chatroomService.updateChatroomTags(
    updateParams,
    []() {
        // update chatroom tags succeeded
    },
    [](V2NIMError error) {
        // update chatroom tags failed, handle error
    });

typescriptawait chatroomV2.V2NIMChatroomService.updateChatroomTags(
  {
    "tags": [
      "tag1",
      "tag2"
    ],
    "notifyTargetTags": "{tag: \"tag1\"}",
    "notificationEnabled": true,
    "notificationExtension": "notificationExtension"
  }
)

无返回值

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调；更新成功，返回 onChatroomTagsUpdated 回调。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含聊天室相关错误码。

更新成功，返回 onChatroomTagsUpdated 回调。