JavaV2NIMChatroomClient chatroomClient = V2NIMChatroomClient.newInstance();

Objective-CV2NIMChatroomClient *chatroomClient = [V2NIMChatroomClient newInstance];

C++auto chatroomClient = V2NIMChatroomClient::newInstance();
if (!chatroomClient) {
    // create instance failed
    // ...
    return;
}
auto instanceId = chatroomClient->getInstanceId();
// save instanceId to cache
// ...

需要在创建实例时传入聊天室初始化参数。

TypeScriptconst chatroom = V2NIMChatroomClient.newInstance(
    {
        appkey: 'YOUR_APPKEY'
    }
)

TypeScript// 引入 node-nim
const NIM = require('node-nim')

const appkey = 'Your appkey'
const account = 'Your account ID'
const token = 'Token of your account ID'
const chatroomId = 'Chatroom ID'

// 初始化聊天室
NIM.V2NIMChatroomClient.init({ appkey })

// 创建聊天室实例
const chatroomInstance = NIM.V2NIMChatroomClient.newInstance()

需要在创建实例时传入聊天室初始化参数。

TypeScriptconst context: common.Context = getContext(this).getApplicationContext()
const chatroom = V2NIMChatroomClient.newInstance(context，
    {
        appkey: 'YOUR_APPKEY'
    }
)

DartchatroomClient = (await V2NIMChatroomClient.newInstance()).data;

调用 addChatroomClientListener 方法注册聊天室实例监听器，包括聊天室连接状态变更、进出聊天室、被踢出聊天室。

JavachatroomClient.addChatroomClientListener(new V2NIMChatroomClientListener() {
    @Override
    public void onChatroomStatus(V2NIMChatroomStatus status, V2NIMError error) {
    }
    @Override
    public void onChatroomEntered() {
    }
    @Override
    public void onChatroomExited(V2NIMError error) {
    }
    @Override
    public void onChatroomKicked(V2NIMChatroomKickedInfo kickedInfo) {
    }
});

调用 addChatroomClientListener 方法注册聊天室实例监听器，包括聊天室连接状态变更、进出聊天室、被踢出聊天室。

Objective-C@interface ClientListener : NSObject <V2NIMChatroomClientListener>
- (void)addToClient:(NSInteger)clientId;
@end

@implementation ClientListener
- (void)addToClient:(NSInteger)clientId
{
    V2NIMChatroomClient *instance = [V2NIMChatroomClient getInstance:clientId];
    [instance addChatroomClientListener:self];
}
- (void)onChatroomStatus:(V2NIMChatroomStatus)status
                   error:(nullable V2NIMError *)error
{
}
- (void)onChatroomEntered
{
}
- (void)onChatroomExited:(nullable V2NIMError *)error
{
}
- (void)onChatroomKicked:(V2NIMChatroomKickedInfo *)kickedInfo
{
}
@end

调用 addChatroomClientListener 方法注册聊天室实例监听器，包括聊天室连接状态变更、进出聊天室、被踢出聊天室。

C++V2NIMChatroomClientListener listener;
listener.onChatroomStatus = [](V2NIMChatroomStatus status, nstd::optional<V2NIMError> error) {
    // handle chatroom status
};
listener.onChatroomEntered = []() {
    // handle chatroom entered
};
listener.onChatroomExited = [](nstd::optional<V2NIMError> error) {
   // handle chatroom exited
};
listener.onChatroomKicked = [](V2NIMChatroomKickedInfo kickedInfo) {
    // handle chatroom kicked
};
chatroomClient.addChatroomClientListener(listener);

调用 on("EventName") 方法注册聊天室实例监听器，包括聊天室连接状态变更、进出聊天室、被踢出聊天室。

TypeScriptchatroom.on("onChatroomStatus", function (status: V2NIMChatroomStatus, err?: V2NIMError) {})
chatroom.on("onChatroomEntered", function () {})
chatroom.on("onChatroomExited", function (err?: V2NIMError) {})
chatroom.on("onChatroomKicked", function (kickedInfo: V2NIMChatroomKickedInfo) {})

调用 on("EventName") 方法注册聊天室实例监听器，包括聊天室连接状态变更、进出聊天室、被踢出聊天室。

TypeScript// 在创建的实例对象上监听事件
chatroomInstance.on('chatroomStatus', (status, error) => {
    console.log('Chatroom status:', status, error)
})
chatroomInstance.on('chatroomEntered', () => {
    console.log('Chatroom entered successfully')
})
chatroomInstance.on('chatroomExited', (error) => {
    console.log('Chatroom exited:', error)
})
chatroomInstance.on('chatroomKicked', (kickedInfo) => {
    console.log('Chatroom kicked:', kickedInfo)
})

调用 on("EventName") 方法注册聊天室实例监听器，包括聊天室连接状态变更、进出聊天室、被踢出聊天室。

TypeScriptconst chatroom = this.getInstance(instanceId)
chatroom.on("onChatroomStatus", (status: V2NIMChatroomStatus, err?: V2NIMError) => {
})
chatroom.on("onChatroomEntered", ()=> {
})
chatroom.on("onChatroomExited", (err?: V2NIMError) => {
})
chatroom.on("onChatroomKicked", (kickedInfo: V2NIMChatroomKickedInfo)=> {
})

调用 addChatroomClientListener 方法注册聊天室实例监听器，包括聊天室连接状态变更、进出聊天室、被踢出聊天室。

Dart//首先添加监听
await chatroomClient.addChatroomClientListener();
//添加成功后可以监听回到
chatroomClient!.onChatroomEntered.listen((event) {
    //print('ChatroomClient:onChatroomEntered');
}),
chatroomClient!.onChatroomExited.listen((event) {
    // print('ChatroomClient:onChatroomExited');
}),
chatroomClient!.onChatroomStatus.listen((event) {
    //print('ChatroomClient:onChatroomStatus');
}),
chatroomClient!.onChatroomKicked.listen((event) {
    // print('ChatroomClient:onChatroomKicked');
})

如需移除聊天室实例相关监听器，可调用 removeChatroomClientListener。

JavachatroomClient.removeChatroomClientListener(chatroomClientListener);

如需移除聊天室实例相关监听器，可调用 removeChatroomClientListener。

Objective-C@interface ClientListener : NSObject <V2NIMChatroomClientListener>
- (void)addToClient:(NSInteger)clientId;
- (void)removeFromClient:(NSInteger)clientId;
@end

@implementation ClientListener
- (void)addToClient:(NSInteger)clientId
{
    V2NIMChatroomClient *instance = [V2NIMChatroomClient getInstance:clientId];
    [instance addChatroomClientListener:self];
}
- (void)removeFromClient:(NSInteger)clientId
{
    V2NIMChatroomClient *instance = [V2NIMChatroomClient getInstance:clientId];
    [instance removeChatroomClientListener:self];
}
- (void)onChatroomStatus:(V2NIMChatroomStatus)status
                   error:(nullable V2NIMError *)error
{
}
- (void)onChatroomEntered
{
}
- (void)onChatroomExited:(nullable V2NIMError *)error
{
}
- (void)onChatroomKicked:(V2NIMChatroomKickedInfo *)kickedInfo
{
}
@end

如需移除聊天室实例相关监听器，可调用 removeChatroomClientListener。

C++V2NIMChatroomClientListener listener;
// ...
chatroomClient.addChatroomClientListener(listener);
// ...
chatroomClient.removeChatroomClientListener(listener);

如需移除登录相关监听器，可调用 off("EventName")。

TypeScriptchatroom.off("onChatroomStatus", function (status: V2NIMChatroomStatus, err?: V2NIMError) {})
chatroom.off("onChatroomEntered", function () {})
chatroom.off("onChatroomExited", function (err?: V2NIMError) {})
chatroom.off("onChatroomKicked", function (kickedInfo: V2NIMChatroomKickedInfo) {})

如需移除登录相关监听器，可调用 off("EventName")。

TypeScript// 在已有实例上取消监听事件
chatroomInstance.off('chatroomStatus')
chatroomInstance.off('chatroomEntered')
chatroomInstance.off('chatroomExited')
chatroomInstance.off('chatroomKicked')
// 或移除所有事件监听
chatroomInstance.removeAllListeners()

如需移除登录相关监听器，可调用 off("EventName")。

TypeScriptchatroom.off("onChatroomStatus", function (status: V2NIMChatroomStatus, err?: V2NIMError) {})
chatroom.off("onChatroomEntered", function () {})
chatroom.off("onChatroomExited", function (err?: V2NIMError) {})
chatroom.off("onChatroomKicked", function (kickedInfo: V2NIMChatroomKickedInfo) {})

如需移除登录相关监听器，可调用 removeChatroomClientListener。

Dart//取消后 SDK 将不会再触发回调
chatroomClient!.removeChatroomClientListener();

从 10.9.20 版本开始，NIM SDK 支持以下两种地址获取方式：

• LBS 自动获取：设置 enableLbs = true，NIM SDK 自动获取最优服务器地址。
• Link Provider：自定义地址提供器，作为备用方案。

配置规则：

1. enableLbs 和 linkProvider 不能同时为空，至少必须指定其一。
2. 建议同时配置 LBS 和 Link Provider 确保连接稳定性。启用 LBS 后，如果 LBS 获取地址失败，将自动降级使用 linkProvider。

Java// 方式一：推荐配置（LBS + Link Provider 双重保障）
V2NIMChatroomEnterParams params =
        V2NIMChatroomEnterParams.V2NIMChatroomEnterParamsBuilder.builder(linkProvider)
                .withEnableLbs(true) // 启用 LBS 自动获取最优地址
                .withLoginOption(loginOption)
                .build();

// 方式二：仅使用 LBS（不推荐，缺少备用方案）
V2NIMChatroomEnterParams params =
        V2NIMChatroomEnterParams.V2NIMChatroomEnterParamsBuilder.builder(null)
                .withEnableLbs(true)
                .withLoginOption(loginOption)
                .build();

// 方式三：传统方式（仅使用 Link Provider）
V2NIMChatroomEnterParams params =
        V2NIMChatroomEnterParams.V2NIMChatroomEnterParamsBuilder.builder(linkProvider)
                .withLoginOption(loginOption)
                .build();

V2NIMChatroomClient.getInstance(client.getInstanceId()).enter(roomId, params, success, failure);

从 10.9.20 版本开始，NIM SDK 支持以下两种地址获取方式：

• LBS 自动获取：设置 enableLbs = true，NIM SDK 自动获取最优服务器地址。
• Link Provider：自定义地址提供器，作为备用方案。

配置规则：

1. enableLbs 和 linkProvider 不能同时为空，至少必须指定其一。
2. 建议同时配置 LBS 和 Link Provider 确保连接稳定性。启用 LBS 后，如果 LBS 获取地址失败，将自动降级使用 linkProvider。

Objective-C// 方式一：推荐配置（LBS + Link Provider 双重保障）
id<V2NIMChatroomLinkProvider> linkProvider = // NIM SDK 发起或通过服务端 API 获取

V2NIMChatroomEnterParams *params = [[V2NIMChatroomEnterParams alloc] init];
params.enableLbs = YES; // 启用 LBS 自动获取最优地址
params.linkProvider = linkProvider; // 备用地址提供器
params.loginOption = loginOption;

// 方式二：仅使用 LBS（不推荐，缺少备用方案）
V2NIMChatroomEnterParams *params = [[V2NIMChatroomEnterParams alloc] init];
params.linkProvider = nil;
params.loginOption = loginOption;

// 方式三：传统方式（仅使用 Link Provider）
V2NIMChatroomEnterParams *params = [[V2NIMChatroomEnterParams alloc] init];
params.linkProvider = linkProvider;
params.loginOption = loginOption;

[client enter:roomId
  enterParams:params
      success:^(V2NIMChatroomEnterResult * _Nonnull result) {
    // 登录成功
} failure:^(V2NIMError * _Nonnull error) {
    // 登录失败
}];

C++virtual void enter(std::string roomId,
                   V2NIMChatroomEnterParams enterParams,
                   V2NIMSuccessCallback<V2NIMChatroomEnterResult> success,
                   V2NIMFailureCallback failure) = 0;

TypeScriptenter(roomId: string, enterParams: V2NIMChatroomEnterParams): Promise<V2NIMChatroomEnterResult>

TypeScriptenter(roomId, enterParams): Promise<V2NIMChatroomEnterResult>

TypeScript// 登录聊天室
try {
    const result = await chatroomInstance.enter(chatroomId, {
        accountId: account,
        token: token,
        roomNick: 'Your nickname',
        roomAvatar: 'https://example.com/your-avatar.png',
        linkProvider: (roomId, account) => {
            return chatroomLinkAddresses
        }
    })
    console.log(result)
} catch (error) {
    console.error('Enter chatroom failed:', error)
}

DartFuture<NIMResult<V2NIMChatroomEnterResult>> enter(String roomId,V2NIMChatroomEnterParams enterParams)

Java//创建 V2NIMChatroomClient 注：不要每次都 newInstance，用完不再使用需要 destroyInstance
V2NIMChatroomClient chatroomClient = V2NIMChatroomClient.newInstance();
//获取 chatroomClient 的实例 ID，可以缓存起来，后面通过 instanceId 可以得到 V2NIMChatroomClient
int instanceId = chatroomClient.getInstanceId()

……

V2NIMChatroomLinkProvider chatroomLinkProvider = new V2NIMChatroomLinkProvider() {
    @Override
    public List<String> getLinkAddress(String roomId, String accountId) {
        return "聊天室 Link 地址";
    }
};
V2NIMChatroomEnterParams enterParams = V2NIMChatroomEnterParams.V2NIMChatroomEnterParamsBuilder.builder(chatroomLinkProvider)
.withAccountId("账号名")
.withToken("静态 token")
// 按需设置
//.withRoomNick("进入聊天室后显示的昵称")
//.withRoomAvatar("进入聊天室后显示的头像")
//.withTimeout("进入方法超时时间")
//.withServerExtension("用户扩展字段")
//.withNotificationExtension("通知扩展字段，进入聊天室通知开发者扩展字段")
//.withTagConfig("进入聊天室标签信息配置")
//.withLocationConfig("进入聊天室空间位置信息配置")
//.withAntispamConfig("用户资料反垃圾检测配置");
.build();

V2NIMChatroomClient chatroomClient = V2NIMChatroomClient.getInstance(instanceId);
if(chatroomClient != null){
    chatroomClient.enter(roomId, enterParams,
        new V2NIMSuccessCallback<V2NIMChatroomEnterResult>() {
            @Override
            public void onSuccess(V2NIMChatroomEnterResult result) {
                //进入成功
            }
        },
        new V2NIMFailureCallback() {
            @Override
            public void onFailure(V2NIMError error) {
                //进入失败
            }
        });
}

Objective-C@interface V2NIMEnterChatroom: NSObject <V2NIMChatroomLinkProvider>
@end
@implementation V2NIMEnterChatroom
- (void)enter
{
NSString *roomId = @"36";
//创建 V2NIMChatroomClient 注：不要每次都 newInstance，用完不再使用需要 destroyInstance
V2NIMChatroomClient *client = [V2NIMChatroomClient newInstance];
//获取 chatroomClient 的实例 ID，可以缓存起来，后面通过 instanceId 可以得到 V2NIMChatroomClient
NSInteger instanceId = client.getInstanceId;

V2NIMChatroomEnterParams *enterParams = [[V2NIMChatroomEnterParams alloc] init];
enterParams.linkProvider = self;
enterParams.accountId = @"账号名";
enterParams.token = @"静态 token";
// 按需设置
// enterParams.roomNick: 进入聊天室后显示的昵称
// enterParams.roomAvatar: 进入聊天室后显示的头像
// enterParams.timeout: 进入方法超时时间
// enterParams.serverExtension: 用户扩展字段
// enterParams.notificationExtension: 通知扩展字段，进入聊天室通知开发者扩展字段
// enterParams.tagConfig: 进入聊天室标签信息配置
// enterParams.locationConfig: 进入聊天室空间位置信息配置
// enterParams.antispamConfig: 用户资料反垃圾检测配置

V2NIMChatroomClient *chatroomClient = [V2NIMChatroomClient getInstance:instanceId];
[chatroomClient enter:roomId
          enterParams:enterParams
              success:^(V2NIMChatroomEnterResult *result)
              {
                  //进入成功
              }
              failure:^(V2NIMError *error)
              {
                    //进入失败
              }];
}
- (nullable NSArray<NSString *> *)getLinkAddress:(NSString *)roomId
                                       accountId:(NSString *)accountId
{
    return @[@"聊天室 Link 地址"];
}
@end

C++V2NIMChatroomEnterParams enterParams;
enterParams.accountId = "accountId";
enterParams.token = "token";
enterParams.roomNick = "nick";
enterParams.roomAvatar = "avatar";
enterParams.linkProvider = [](nstd::string roomId, nstd::string account) {
    nstd::vector<nstd::string> linkAddresses;
    // get link addresses
    // ...
    return linkAddresses;
};
enterParams.serverExtension = "server extension";
enterParams.notificationExtension = "notification extension";
chatroomClient.enter(
    "roomId",
    enterParams,
    [](V2NIMChatroomEnterResult result) {
        // enter succeeded
    },
    [](V2NIMError error) {
        // enter failed, handle error
    });

TypeScripttry {
    const chatroom = V2NIMChatroomClient.newInstance({
      appkey: 'YOUR_APPKEY',
      debugLevel: 'debug'
    })
    await chatroom.enter('YOUR_ROOM_ID', {
        accountId: 'YOUR_ACCOUNT_ID',
        token: 'YOUR_TOKEN'
    })
} catch (err) {
    // TODO failed, check code
    // console.log(err.code)
}

TypeScripttry {
    const result = await chatroomInstance.enter(chatroomId, {
        accountId: account,
        token: token,
        roomNick: 'Your nickname',
        roomAvatar: 'https://example.com/your-avatar.png',
        linkProvider: (roomId, account) => {
            return chatroomLinkAddresses
        }
    })
    console.log(result)
} catch (error) {
    console.error('Enter chatroom failed:', error)
    return
}

TypeScripttry {
    const chatroom = V2NIMChatroomClient.newInstance({
      appkey: 'YOUR_APPKEY',
      debugLevel: 'debug'
    })
    await chatroom.enter('YOUR_ROOM_ID', {
        accountId: 'YOUR_ACCOUNT_ID',
        token: 'YOUR_TOKEN'
    })
} catch (err) {
    // TODO failed, check code
    // console.log(err.code)
}

Dartfinal links = await NimCore.instance.loginService
          .getChatroomLinkAddress(chatroomId1);

      final enterParams = V2NIMChatroomEnterParams(
          authType: NIMLoginAuthType.authTypeDefault,
          accountId: 'account',
          token: 'token');

      chatroomClient!.linkProvider =
          (int instanceId, String roomId, String accountId) async {
        return links.data!;
      };

      final enterResult = await chatroomClient!.enter(chatroomId1, enterParams);

Java//创建 V2NIMChatroomClient 注：不要每次都 newInstance，用完不再使用需要 destroyInstance
V2NIMChatroomClient chatroomClient = V2NIMChatroomClient.newInstance();
//获取 chatroomClient 的实例 ID，可以缓存起来，后面通过 instanceId 可以得到 V2NIMChatroomClient
int instanceId = chatroomClient.getInstanceId()

……

V2NIMChatroomLinkProvider chatroomLinkProvider = new V2NIMChatroomLinkProvider() {
    @Override
    public List<String> getLinkAddress(String roomId, String accountId) {
        return "聊天室 Link 地址";
    }
};
V2NIMChatroomLoginOption loginOption = V2NIMChatroomLoginOption.V2NIMChatroomLoginOptionBuilder.builder()
.withAuthType(V2NIMLoginAuthType.V2NIM_LOGIN_AUTH_TYPE_DYNAMIC_TOKEN)
.withTokenProvider(new V2NIMChatroomTokenProvider() {
    @Override
    public String getToken(String roomId, String account) {
        return "动态登录 Token"
    }
})
.build();

V2NIMChatroomEnterParams enterParams = V2NIMChatroomEnterParams.V2NIMChatroomEnterParamsBuilder.builder(chatroomLinkProvider)
.withAccountId("账号名")
.withLoginOption(loginOption)
// 按需设置
//.withRoomNick("进入聊天室后显示的昵称")
//.withRoomAvatar("进入聊天室后显示的头像")
//.withTimeout("进入方法超时时间")
//.withServerExtension("用户扩展字段")
//.withNotificationExtension("通知扩展字段，进入聊天室通知开发者扩展字段")
//.withTagConfig("进入聊天室标签信息配置")
//.withLocationConfig("进入聊天室空间位置信息配置")
//.withAntispamConfig("用户资料反垃圾检测配置");
.build();

V2NIMChatroomClient chatroomClient = V2NIMChatroomClient.getInstance(instanceId);
if(chatroomClient != null){
    chatroomClient.enter(roomId, enterParams,
        new V2NIMSuccessCallback<V2NIMChatroomEnterResult>() {
            @Override
            public void onSuccess(V2NIMChatroomEnterResult result) {
                //进入成功
            }
        },
        new V2NIMFailureCallback() {
            @Override
            public void onFailure(V2NIMError error) {
                //进入失败
            }
        });
}

Objective-C@interface V2NIMEnterChatroom: NSObject <V2NIMChatroomLinkProvider, V2NIMChatroomTokenProvider>
@end
@implementation V2NIMEnterChatroom
- (void)enter
{
    NSString *roomId = @"36";
    //创建 V2NIMChatroomClient 注：不要每次都 newInstance，用完不再使用需要 destroyInstance
    V2NIMChatroomClient *client = [V2NIMChatroomClient newInstance];
    //获取 chatroomClient 的实例 ID，可以缓存起来，后面通过 instanceId 可以得到 V2NIMChatroomClient
    NSInteger instanceId = client.getInstanceId;

    ……

    V2NIMChatroomLoginOption *option = [[V2NIMChatroomLoginOption alloc] init];
    option.authType = V2NIM_LOGIN_AUTH_TYPE_DYNAMIC_TOKEN;
    option.tokenProvider = self;

    V2NIMChatroomEnterParams *enterParams = [[V2NIMChatroomEnterParams alloc] init];
    enterParams.linkProvider = self;
    enterParams.accountId = @"账号名";
    enterParams.loginOption = option;
    // 按需设置
    // enterParams.roomNick: 进入聊天室后显示的昵称
    // enterParams.roomAvatar: 进入聊天室后显示的头像
    // enterParams.timeout: 进入方法超时时间
    // enterParams.serverExtension: 用户扩展字段
    // enterParams.notificationExtension: 通知扩展字段，进入聊天室通知开发者扩展字段
    // enterParams.tagConfig: 进入聊天室标签信息配置
    // enterParams.locationConfig: 进入聊天室空间位置信息配置
    // enterParams.antispamConfig: 用户资料反垃圾检测配置

    V2NIMChatroomClient *chatroomClient = [V2NIMChatroomClient getInstance:instanceId];
    [chatroomClient enter:roomId
              enterParams:enterParams
                  success:^(V2NIMChatroomEnterResult *result)
                  {
                      //进入成功
                  }
                  failure:^(V2NIMError *error)
                  {
                        //进入失败
                  }];
    }

- (nullable NSArray<NSString *> *)getLinkAddress:(NSString *)roomId
                                       accountId:(NSString *)accountId
{
    return @[@"聊天室 Link 地址"];
}
- (nullable NSString *)getToken:(NSString *)roomId accountId:(NSString *)accountId {
    return @"动态登录 Token";
}
@end

C++V2NIMChatroomEnterParams enterParams;
enterParams.accountId = "accountId";
enterParams.roomNick = "nick";
enterParams.roomAvatar = "avatar";
enterParams.linkProvider = [](nstd::string roomId, nstd::string account) {
    nstd::vector<nstd::string> linkAddresses;
    // get link addresses
    // ...
    return linkAddresses;
};
enterParams.loginOption.authType = V2NIM_LOGIN_AUTH_TYPE_DYNAMIC_TOKEN;
enterParams.loginOption.tokenProvider = [](nstd::string roomId, nstd::string account) {
    nstd::string dynamicToken;
    // get dynamic token
    // ...
    // return null on fail
    return dynamicToken;
};
enterParams.serverExtension = "server extension";
enterParams.notificationExtension = "notification extension";
chatroomClient.enter(
    "roomId",
    enterParams,
    [](V2NIMChatroomEnterResult result) {
        // enter succeeded
    },
    [](V2NIMError error) {
        // enter failed, handle error
    });

TypeScripttry {
    const chatroom = V2NIMChatroomClient.newInstance({
      appkey: 'YOUR_APPKEY',
      debugLevel: 'debug'
    })
    await chatroom.enter('YOUR_ROOM_ID', {
        accountId: 'YOUR_ACCOUNT_ID',
        loginOption: {
            // authType == 1 时，登录方式为动态 token
            authType: 1,
            // 服务器动态签算动态 token
            tokenProvider: async function(appkey, roomId, account) {
                return await fetch('YOUR_SERVER_URL', {
                    body: JSON.stringify({
                        appkey, roomId, account
                    })
                })
            }
        }
    })
} catch (err) {
    // TODO failed, check code
    // console.log(err.code)
}

TypeScripttry {
    const result = await chatroomInstance.enter(chatroomId, {
        accountId: account,
        roomNick: 'Your nickname',
        roomAvatar: 'https://example.com/your-avatar.png',
        linkProvider: (roomId, account) => {
            return chatroomLinkAddresses
        },
        loginOption: {
            authType: 1, // V2NIMLoginAuthType.V2NIM_LOGIN_AUTH_TYPE_DYNAMIC_TOKEN
            tokenProvider: async () => {
                // 从应用服务器获取动态Token
                const response = await fetch('https://your-server.com/api/get-dynamic-token', {
                    method: 'POST',
                    headers: { 'Content-Type': 'application/json' },
                    body: JSON.stringify({ roomId, accountId })
                })
                const data = await response.json()
                return data.token
            }
        }
    })
    console.log(result)
} catch (error) {
    console.error('Enter chatroom failed:', error)
    return
}

TypeScripttry {
    const chatroom = V2NIMChatroomClient.newInstance({
      appkey: 'YOUR_APPKEY',
      debugLevel: 'debug'
    })
    await chatroom.enter('YOUR_ROOM_ID', {
        accountId: 'YOUR_ACCOUNT_ID',
        loginOption: {
            // authType == 1 时，登录方式为动态 token
            authType: 1,
            // 服务器动态签算动态 token
            tokenProvider: async function(appkey, roomId, account) {
                return await fetch('YOUR_SERVER_URL', {
                    body: JSON.stringify({
                        appkey, roomId, account
                    })
                })
            }
        }
    })
} catch (err) {
    // TODO failed, check code
    // console.log(err.code)
}

Dart final links = await NimCore.instance.loginService
          .getChatroomLinkAddress(chatroomId1);

      final enterParams = V2NIMChatroomEnterParams(
          authType: NIMLoginAuthType.authTypeDynamicToken,
          accountId: 'account');

      chatroomClient!.linkProvider =
          (int instanceId, String roomId, String accountId) async {
        return links.data!;
      };

      chatroomClient!.tokenProvider = (int instanceId, String roomId, String accountId) async {
        return 'token';
      };

      final enterResult = await chatroomClient!.enter(chatroomId1, enterParams);

Java//创建 V2NIMChatroomClient 注：不要每次都 newInstance，用完不再使用需要 destroyInstance
V2NIMChatroomClient chatroomClient = V2NIMChatroomClient.newInstance();
//获取 chatroomClient 的实例 ID，可以缓存起来，后面通过 instanceId 可以得到 V2NIMChatroomClient
int instanceId = chatroomClient.getInstanceId()

……

V2NIMChatroomLinkProvider chatroomLinkProvider = new V2NIMChatroomLinkProvider() {
    @Override
    public List<String> getLinkAddress(String roomId, String accountId) {
        return "聊天室 Link 地址";
    }
};
V2NIMChatroomLoginOption loginOption = V2NIMChatroomLoginOption.V2NIMChatroomLoginOptionBuilder.builder()
.withAuthType(V2NIMLoginAuthType.V2NIM_LOGIN_AUTH_TYPE_THIRD_PARTY)
.withTokenProvider(new V2NIMChatroomTokenProvider() {
    @Override
    public String getToken(String roomId, String account) {
        return "第三方登录 Token"
    }
})
.withLoginExtensionProvider(new V2NIMChatroomLoginExtensionProvider() {
    @Override
    public String getLoginExtension(String roomId, String accountId) {
        return "聊天室登录扩展"
    }
});
.build();

V2NIMChatroomEnterParams enterParams = V2NIMChatroomEnterParams.V2NIMChatroomEnterParamsBuilder.builder(chatroomLinkProvider)
.withAccountId("账号名")
.withLoginOption(loginOption)
// 按需设置
//.withRoomNick("进入聊天室后显示的昵称")
//.withRoomAvatar("进入聊天室后显示的头像")
//.withTimeout("进入方法超时时间")
//.withServerExtension("用户扩展字段")
//.withNotificationExtension("通知扩展字段，进入聊天室通知开发者扩展字段")
//.withTagConfig("进入聊天室标签信息配置")
//.withLocationConfig("进入聊天室空间位置信息配置")
//.withAntispamConfig("用户资料反垃圾检测配置");
.build();

V2NIMChatroomClient chatroomClient = V2NIMChatroomClient.getInstance(instanceId);
if(chatroomClient != null){
    chatroomClient.enter(roomId, enterParams,
        new V2NIMSuccessCallback<V2NIMChatroomEnterResult>() {
            @Override
            public void onSuccess(V2NIMChatroomEnterResult result) {
                //进入成功
            }
        },
        new V2NIMFailureCallback() {
            @Override
            public void onFailure(V2NIMError error) {
                //进入失败
            }
        });
}

Objective-C@interface V2NIMEnterChatroom: NSObject <V2NIMChatroomLinkProvider, V2NIMChatroomTokenProvider, V2NIMChatroomLoginExtensionProvider>
@end
@implementation V2NIMEnterChatroom

- (void)enter
{
    NSString *roomId = @"36";
    //创建 V2NIMChatroomClient 注：不要每次都 newInstance，用完不再使用需要 destroyInstance
    V2NIMChatroomClient *client = [V2NIMChatroomClient newInstance];
    //获取 chatroomClient 的实例 ID，可以缓存起来，后面通过 instanceId 可以得到 V2NIMChatroomClient
    NSInteger instanceId = client.getInstanceId;

    V2NIMChatroomLoginOption *option = [[V2NIMChatroomLoginOption alloc] init];
    option.authType = V2NIM_LOGIN_AUTH_TYPE_THIRD_PARTY;
    option.tokenProvider = self;
    option.loginExtensionProvider = self;

    V2NIMChatroomEnterParams *enterParams = [[V2NIMChatroomEnterParams alloc] init];
    enterParams.linkProvider = self;
    enterParams.accountId = @"账号名";
    enterParams.loginOption = option;
    // 按需设置
    // enterParams.roomNick: 进入聊天室后显示的昵称
    // enterParams.roomAvatar: 进入聊天室后显示的头像
    // enterParams.timeout: 进入方法超时时间
    // enterParams.serverExtension: 用户扩展字段
    // enterParams.notificationExtension: 通知扩展字段，进入聊天室通知开发者扩展字段
    // enterParams.tagConfig: 进入聊天室标签信息配置
    // enterParams.locationConfig: 进入聊天室空间位置信息配置
    // enterParams.antispamConfig: 用户资料反垃圾检测配置

    V2NIMChatroomClient *chatroomClient = [V2NIMChatroomClient getInstance:instanceId];
    [chatroomClient enter:roomId
              enterParams:enterParams
                  success:^(V2NIMChatroomEnterResult *result)
                  {
                      //进入成功
                  }
                  failure:^(V2NIMError *error)
                  {
                        //进入失败
                  }];
    }

- (nullable NSArray<NSString *> *)getLinkAddress:(NSString *)roomId
                                       accountId:(NSString *)accountId
{
    return @[@"聊天室 Link 地址"];
}
- (nullable NSString *)getToken:(NSString *)roomId accountId:(NSString *)accountId {
    return @"动态登录 Token";
}
- (nullable NSString *)getLoginExtension:(NSString *)roomId accountId:(NSString *)accountId {
    return @"聊天室登录扩展";
}
@end

C++V2NIMChatroomEnterParams enterParams;
enterParams.accountId = "accountId";
enterParams.roomNick = "nick";
enterParams.roomAvatar = "avatar";
enterParams.linkProvider = [](nstd::string roomId, nstd::string account) {
    nstd::vector<nstd::string> linkAddresses;
    // get link addresses
    // ...
    return linkAddresses;
};
enterParams.loginOption.authType = V2NIM_LOGIN_AUTH_TYPE_THIRD_PARTY;
enterParams.loginOption.loginExtensionProvider = [](nstd::string roomId, nstd::string account) {
    nstd::string loginExtension;
    // get login extension
    // ...
    // return null on fail
    return loginExtension;
};
enterParams.serverExtension = "server extension";
enterParams.notificationExtension = "notification extension";
chatroomClient.enter(
    "roomId",
    enterParams,
    [](V2NIMChatroomEnterResult result) {
        // enter succeeded
    },
    [](V2NIMError error) {
        // enter failed, handle error
    });

TypeScripttry {
    const chatroom = V2NIMChatroomClient.newInstance({
      appkey: 'YOUR_APPKEY',
      debugLevel: 'debug'
    })
    await chatroom.enter('YOUR_ROOM_ID', {
        accountId: 'YOUR_ACCOUNT_ID',
        loginOption: {
            // authType == 2 时，登录方式为通过第三方回调鉴权
            authType: 2,
            // 服务器动态签算动态 token
            loginExtensionProvider: async function(account) {
                return await fetch('YOUR_SERVER_URL', {
                    body: JSON.stringify({
                        account
                    })
                })
            }
        }
    })
} catch (err) {
    // TODO failed, check code
    // console.log(err.code)
}

TypeScripttry {
    const result = await chatroomInstance.enter(chatroomId, {
        accountId: account,
        roomNick: 'Your nickname',
        roomAvatar: 'https://example.com/your-avatar.png',
        linkProvider: (roomId, account) => {
            return chatroomLinkAddresses
        },
        loginOption: {
            authType: 2, // V2NIMLoginAuthType.V2NIM_LOGIN_AUTH_TYPE_THIRD_PARTY
            tokenProvider: async () => {
                // 获取登录扩展数据用于第三方服务器鉴权
                const response = await fetch('https://your-server.com/api/get-login-extension', {
                    method: 'POST',
                    headers: { 'Content-Type': 'application/json' },
                    body: JSON.stringify({ roomId, accountId })
                })
                const data = await response.json()
                return data.loginExtension
            }
        }
    })
    console.log(result)
} catch (error) {
    console.error('Enter chatroom failed:', error)
    return
}

TypeScripttry {
    const chatroom = V2NIMChatroomClient.newInstance({
      appkey: 'YOUR_APPKEY',
      debugLevel: 'debug'
    })
    await chatroom.enter('YOUR_ROOM_ID', {
        accountId: 'YOUR_ACCOUNT_ID',
        loginOption: {
            // authType == 2 时，登录方式为通过第三方回调鉴权
            authType: 2,
            // 服务器动态签算动态 token
            loginExtensionProvider: async function(account) {
                return await fetch('YOUR_SERVER_URL', {
                    body: JSON.stringify({
                        account
                    })
                })
            }
        }
    })
} catch (err) {
    // TODO failed, check code
    // console.log(err.code)
}

Dartfinal links = await NimCore.instance.loginService
          .getChatroomLinkAddress(chatroomId1);

      final enterParams = V2NIMChatroomEnterParams(
          authType: NIMLoginAuthType.authTypeThirdParty,
          accountId: 'account');

      chatroomClient!.linkProvider =
          (int instanceId, String roomId, String accountId) async {
        return links.data!;
      };

      chatroomClient!.tokenProvider = (int instanceId, String roomId, String accountId) async {
        return 'third token';
      };

      final enterResult = await chatroomClient!.enter(chatroomId1, enterParams);

JavaV2NIMChatroomService chatroomService = chatroomClient.getChatroomService()

Objective-C[[V2NIMChatroomClient getInstance:instanceId] getChatroomService];

C++auto& chatroomService = client.getChatroomService();

Web/uni-app/小程序可跳过此步骤。

TypeScriptconst chatroomService = chatroomInstance.getChatroomService()

TypeScriptconst client: V2NIMChatroomClient = this.getInstance(instanceId)
const ret = client.chatroomService

Dartvar chatroomService = chatroomClient?.getChatroomService()

JavachatroomCore.exit();

Objective-C[[V2NIMChatroomClient getInstance:instanceId] exit];

C++chatroomClient.exit();

TypeScriptchatroom.exit()

TypeScriptchatroomInstance.exit()

TypeScriptconst client = this.getInstance(instanceId)
client.exit()

DartchatroomClient!.exit();

JavaV2NIMChatroomClient.destroyInstance(instanceId);

Objective-C[V2NIMChatroomClient destroyInstance:instanceId];

C++uint32_t instanceId{0};
// get instanceId from cache
// ...
V2NIMChatroomClient::destroyInstance(instanceId);

TypeScriptV2NIMChatroomClient.destroyInstance(this.instanceId)

TypeScript// 销毁聊天室实例，NIM is required from node-nim
NIM.V2NIMChatroomClient.destroyInstance(chatroomInstance.getInstanceId())
NIM.V2NIMChatroomClient.uninit()

TypeScriptV2NIMChatroomClient.destroyInstance(this.instanceId)

DartV2NIMChatroomClient.destroyInstance(instanceId);