Javapublic void addChatroomClientListener(V2NIMChatroomClientListener listener)

Objective-C- (void)addChatroomClientListener:(id<V2NIMChatroomClientListener>)listener;

C++virtual void addChatroomClientListener(V2NIMChatroomClientListener listener) = 0;

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

    }
});

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

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

Javapublic void removeChatroomClientListener(V2NIMChatroomClientListener listener)

Objective-C- (void)removeChatroomClientListener:(id<V2NIMChatroomClientListener>)listener;

C++virtual void removeChatroomClientListener(V2NIMChatroomClientListener listener) = 0;

JavachatroomClient.removeChatroomClientListener(chatroomClientListener);

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

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

TypeScriptexport interface NIMEBaseServiceInterface<I extends NIMEBaseListener> {
  /**
   * 继承自 EventEmitter3 的监听事件方法。
   */
  on<T extends keyof I>(eventName: T, fn: (...args: I[T]) => void): void;
  /**
   * 继承自 EventEmitter3 的监听事件方法。
   */
  once<T extends keyof I>(eventName: T, fn: (...args: I[T]) => void): void;
}

TypeScriptexport interface NIMEBaseServiceInterface<I extends NIMEBaseListener> {
  /**
   * 继承自 EventEmitter3 的监听事件方法。
   */
  on<T extends keyof I>(eventName: T, fn: (...args: I[T]) => void): void;
  /**
   * 继承自 EventEmitter3 的监听事件方法。
   */
  once<T extends keyof I>(eventName: T, fn: (...args: I[T]) => void): void;
}

TypeScriptexport interface NIMEBaseServiceInterface<I extends NIMEBaseListener> {
  /**
   * 继承自 eventEmitter3 的监听事件方法
   */
  on<T extends keyof I>(eventName: T, fn: (...args: I[T]) => void): void
  /**
   * 继承自 eventEmitter3 的监听事件方法
   */
  once<T extends keyof I>(eventName: T, fn: (...args: I[T]) => void): void
}

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

TypeScriptchatroom.on("chatroomStatus", function (status: V2NIMChatroomStatus, err?: V2NIMError) {})
chatroom.on("chatroomEntered", function () {})
chatroom.on("chatroomExited", function (err?: V2NIMError) {})
chatroom.on("chatroomKicked", function (kickedInfo: V2NIMChatroomKickedInfo) {})

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

TypeScriptexport interface NIMEBaseServiceInterface<I extends NIMEBaseListener> {
  /**
   * 继承自 EventEmitter3 的取消监听方法。
   */
  off<T extends keyof I>(eventName: T, fn: (...args: I[T]) => void): void;
  /**
   * 继承自 EventEmitter3 的移除事件方法。
   */
  removeAllListeners<T extends keyof I>(eventName?: T): void;
}

TypeScriptexport interface NIMEBaseServiceInterface<I extends NIMEBaseListener> {
  /**
   * 继承自 EventEmitter3 的取消监听方法。
   */
  off<T extends keyof I>(eventName: T, fn: (...args: I[T]) => void): void;
  /**
   * 继承自 EventEmitter3 的移除事件方法。
   */
  removeAllListeners<T extends keyof I>(eventName?: T): void;
}

TypeScriptexport interface NIMEBaseServiceInterface<I extends NIMEBaseListener> {
  /**
   * 继承自 eventEmitter3 的取消监听方法
   */
  off<T extends keyof I>(eventName: T, fn: (...args: I[T]) => void): void
  /**
   * 继承自 eventEmitter3 的移除事件方法
   */
  removeAllListeners<T extends keyof I>(eventName?: T): void
}

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

TypeScriptchatroom.off("chatroomStatus", function (status: V2NIMChatroomStatus, err?: V2NIMError) {})
chatroom.off("chatroomEntered", function () {})
chatroom.off("chatroomExited", function (err?: V2NIMError) {})
chatroom.off("chatroomKicked", function (kickedInfo: V2NIMChatroomKickedInfo) {})

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

Javapublic synchronized static V2NIMChatroomClient newInstance()

Objective-C+ (instancetype)newInstance;

C++static nstd::shared_ptr<V2NIMChatroomClient> newInstance();

TypeScriptstatic newInstance(initParams: V2NIMChatroomInitParams): V2NIMChatroomClient

TypeScriptstatic newInstance(): V2NIMChatroomClient

TypeScriptstatic newInstance(context:common.Context, initParams: V2NIMChatroomInitParams): V2NIMChatroomClient

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

TypeScriptconst chatroomClient = V2NIMChatroomClient.newInstance()

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

Javapublic synchronized static void destroyInstance(int instanceId)

Objective-C+ (void)destroyInstance:(NSInteger)instanceId;

C++static void destroyInstance(uint32_t instanceId);

TypeScriptstatic destroyInstance(instanceId: number): void

TypeScriptstatic destroyInstance(instanceId): void

TypeScriptstatic destroyInstance(instanceId: number): void

JavaV2NIMChatroomClient.destroyInstance(instanceId);

Objective-C[V2NIMChatroomClient destroyInstance:instanceId];

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

TypeScriptV2NIMChatroomClient.destroyInstance(this.instanceId)

TypeScriptV2NIMChatroomClient.destroyInstance(instanceId)

TypeScriptV2NIMChatroomClient.destroyInstance(this.instanceId)

Javapublic synchronized static V2NIMChatroomClient getInstance(int instanceId)

Objective-C+ (instancetype)getInstance:(NSInteger)instanceId;

C++static nstd::shared_ptr<V2NIMChatroomClient> getInstance(uint32_t instanceId);

TypeScriptstatic getInstance(instanceId?: number): V2NIMChatroomClient

TypeScriptstatic getInstance(instanceId): null | V2NIMChatroomClient

TypeScriptstatic getInstance(instanceId: number): V2NIMChatroomClient

JavaV2NIMChatroomClient chatroomClient = V2NIMChatroomClient.getInstance(roomClientId)

Objective-CV2NIMChatroomClient *client = [V2NIMChatroomClient getInstance:roomClientId];

C++uint32_t instanceId{0};
// get instanceId from cache
// ...
auto chatroomClient = V2NIMChatroomClient::getInstance(instanceId);
if (!chatroomClient) {
    // instance not found
    // ...
    return;
}

TypeScriptconst chatroom = V2NIMChatroomClient.getInstance(instanceId)

TypeScriptconst chatroomClient = V2NIMChatroomClient.getInstance(instanceId)

TypeScriptconst chatroom = V2NIMChatroomClient.getInstance(instanceId)

Javapublic synchronized static List<V2NIMChatroomClient> getInstanceList()

Objective-C+ (NSArray<V2NIMChatroomClient *> *)getInstanceList;

C++static nstd::vector<nstd::shared_ptr<V2NIMChatroomClient>> getInstanceList();

TypeScriptstatic getInstanceList(): V2NIMChatroomClient[]

TypeScriptstatic getInstanceList(): V2NIMChatroomClient[]

TypeScriptstatic getInstanceList(): V2NIMChatroomClient[]

JavaList<V2NIMChatroomClient> chatroomClients = V2NIMChatroomClient.getInstanceList();

Objective-CNSArray<V2NIMChatroomClient *> *clients = [V2NIMChatroomClient getInstanceList];

C++auto chatroomClients = V2NIMChatroomClient::getInstanceList();

TypeScriptconst chatroomArr = V2NIMChatroomClient.getInstanceList()

TypeScriptconst instanceList = V2NIMChatroomClient.getInstanceList()

TypeScriptconst chatroomArr = V2NIMChatroomClient.getInstanceList()

Javapublic synchronized static void destroyAll()

Objective-C+ (void)destroyAll;

C++static void destroyAll();

TypeScriptstatic destroyAll(): void

TypeScriptstatic destroyAll(): void

TypeScriptstatic destroyAll(): void

JavaV2NIMChatroomClient.destroyAll();

Objective-C[V2NIMChatroomClient destroyAll];

C++V2NIMChatroomClient::destroyAll();

TypeScriptV2NIMChatroomClient.destroyAll()

TypeScriptV2NIMChatroomClient.destroyAll()

TypeScriptV2NIMChatroomClient.destroyAll()

Javapublic void enter(String roomId, V2NIMChatroomEnterParams enterParams, V2NIMSuccessCallback<V2NIMChatroomEnterResult> success, V2NIMFailureCallback failure)

Objective-C- (void)enter:(NSString *)roomId
  enterParams:(V2NIMChatroomEnterParams *)enterParams
      success:(nullable V2NIMChatroomEnterResultCallback)success
      failure:(nullable V2NIMFailureCallback)failure;

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

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

TypeScriptenter(roomId, enterParams): Promise<V2NIMChatroomEnterResult>

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

JavaV2NIMChatroomLinkProvider chatroomLinkProvider = new V2NIMChatroomLinkProvider() {
    @Override
    public List<String> getLinkAddress(String roomId, String accountId) {
        return "聊天室 link 地址";
    }
};

V2NIMChatroomLoginOption loginOption = V2NIMChatroomLoginOption.V2NIMChatroomLoginOptionBuilder.builder()
// 按需设置
//                .withAuthType()
//                .withLoginExtensionProvider()
//                .withTokenProvider()
        .build();

V2NIMChatroomEnterParams enterParams = V2NIMChatroomEnterParams.V2NIMChatroomEnterParamsBuilder.builder(chatroomLinkProvider)
// 按需设置
//                .withAccountId()
//                .withAnonymousMode()
//                .withAntispamConfig()
//                .withLocationConfig()
//                .withLoginOption(loginOption)
//                .withNotificationExtension()
//                .withRoomAvatar()
//                .withRoomNick()
//                .withServerExtension()
//                .withTagConfig()
//                .withTimeout()
//                .withToken()
        .build();

V2NIMChatroomClient.newInstance().enter(roomId, enterParams,
        new V2NIMSuccessCallback<V2NIMChatroomEnterResult>() {
            @Override
            public void onSuccess(V2NIMChatroomEnterResult result) {

            }
        },
        new V2NIMFailureCallback() {
            @Override
            public void onFailure(V2NIMError error) {

            }
        });

Objective-C// 配置 link 地址回调
@interface ChatroomLinkProvider : NSObject <V2NIMChatroomLinkProvider>
@end

@implementation ChatroomLinkProvider
- (nullable NSArray<NSString *> *)getLinkAddress:(NSString *)roomId accountId:(NSString *)accountId {
    return @[@"link0", @"link1"];
}
@end
// 进入聊天室
NSString *roomId = @"2024";

V2NIMChatroomLoginOption *loginOption = [[V2NIMChatroomLoginOption alloc] init];
//默认鉴权方式进入聊天室
loginOption.authType = V2NIM_LOGIN_AUTH_TYPE_DEFAULT;
V2NIMChatroomEnterParams *enterParams = [[V2NIMChatroomEnterParams alloc] init];
// 账号
enterParams.accountId = @"accountId";
// token
enterParams.token = @"token";
// 动态设置 link 地址
enterParams.linkProvider = [[ChatroomLinkProvider alloc] init];

[[V2NIMChatroomClient newInstance] enter:roomId
                             enterParams:enterParams
                                 success:^(V2NIMChatroomEnterResult *result)
                                 {
                                     //进入聊天室成功
                                 }
                                 failure:^(V2NIMError *error)
                                 {
                                     //进入聊天室失败
                                 }];

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

TypeScriptconst res = await instance.enter(roomId, {
    accountId: 'ACCID',
    token: 'TOKEN',
    roomNick: 'YOUR_NICK',
    roomAvatar: 'YOUR_IMG_URL',
    linkProvider: function() {
        return Promise.resolve(['chatweblink12.netease.im])
    }
});

TypeScriptconst result = await chatroomClient.enter('your room id', {
    accountId: 'your account id',
    token: 'your token',
    roomNick: 'your room nick',
    linkProvider: (roomId, account) => {
        return ['chatroom link...']
    }
})
if (result) {
    console.error(result)
}

TypeScriptconst client = this.getInstance(instanceId)
const enterParams: V2NIMChatroomEnterParams = {
  accountId: accountId,
  roomNick: roomNick,
  roomAvatar: roomAvatar,
  token: token,
  linkProvider: function() {
    return Promise.resolve(linkAddressArray)
  },
  serverExtension: serverExtension,
  notificationExtension: notificationExtension,
  tagConfig: {
    tags: tags,
    notifyTargetTags: notifyTargetTags
  },
  locationConfig: {
    distance: distance,
    locationInfo: {
      x: x,
      y: y,
      z: z
    }
  }
}

return await client.enter(roomId, enterParams)

无返回值。

Promise<V2NIMChatroomEnterResult> 进入聊天室结果

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

• 请求成功，返回 V2NIMChatroomEnterResultCallback 回调，可自定义设置。创建成功，返回 onTeamCreated 回调。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含群组相关错误码。

无。

Javapublic void exit()

Objective-C- (void)exit;

C++virtual void exit() = 0;

TypeScriptexit(): void

TypeScriptexit(): void

TypeScriptexit(): void

JavachatroomCore.exit();

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

C++chatroomClient.exit();

TypeScriptchatroom.exit()

TypeScriptchatroomClient.exit()

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

Javapublic V2NIMChatroomInfo getChatroomInfo()

Objective-C- (V2NIMChatroomInfo *)getChatroomInfo;

C++virtual V2NIMChatroomInfo getChatroomInfo() = 0;

TypeScriptgetChatroomInfo(): V2NIMChatroomInfo | null

TypeScriptgetChatroomInfo(): V2NIMChatroomInfo

TypeScriptgetChatroomInfo(): V2NIMChatroomInfo | null

JavaV2NIMChatroomInfo chatroomInfo = chatroomClient.getChatroomInfo();

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

C++auto chatroomInfo = chatroomClient.getChatroomInfo();

TypeScriptconst chatroomInfo = chatroom.getChatroomInfo()

TypeScriptconst chatroomInfo = chatroomClient.getChatroomInfo()

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

Javapublic V2NIMChatroomService getChatroomService()

Objective-C- (id<V2NIMChatroomService>)getChatroomService;

C++virtual V2NIMChatroomService& getChatroomService() = 0;

TypeScriptgetChatroomService(): V2NIMChatroomService

TypeScriptpublic chatroomService: V2NIMChatroomService

JavaV2NIMChatroomService chatroomService = chatroomClient.getChatroomService()

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

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

TypeScriptconst chatroomService = chatroomClient.getChatroomService()

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

Javapublic V2NIMStorageService getStorageService()

Objective-C- (id<V2NIMStorageService>)getStorageService;

C++virtual V2NIMStorageService& getStorageService() = 0;

TypeScriptgetStorageService(): V2NIMStorageService

TypeScriptpublic storageService: V2NIMChatroomStorageService

JavaV2NIMStorageService storageService = chatroomClient.getStorageService()

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

C++auto& storageService = client.getStorageService();

TypeScriptconst storageService = chatroomClient.getStorageService()

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