Javavoid addSignallingListener(V2NIMSignallingListener listener);

Objective-C- (void)addSignallingListener:(id<V2NIMSignallingListener>)listener;

cppvirtual void addSignallingListener(const V2NIMSignallingListener& listener) = 0;

JavaNIMClient.getService(V2NIMSignallingService.class).addSignallingListener(listener);

Objective-C@interface Clazz:NSObject<V2NIMSignallingListener>
- (void)addSignallingListener;
- (void)removeSignallingListener;
@end

@implementation Clazz
- (void)addSignallingListener
{
    [[NIMSDK sharedSDK].v2SignallingService addSignallingListener:self];
}

- (void)removeSignallingListener
{
    [[NIMSDK sharedSDK].v2SignallingService removeSignallingListener:self];
}

- (void)onMultiClientEvent:(nonnull V2NIMSignallingEvent *)event {
    // Your Code
}

- (void)onOfflineEvent:(nonnull NSArray<V2NIMSignallingEvent *> *)event { 
    // Your Code
}

- (void)onOnlineEvent:(nonnull V2NIMSignallingEvent *)event { 
    // Your Code
}

- (void)onSyncRoomInfoList:(nonnull NSArray<V2NIMSignallingRoomInfo *> *)channelRooms { 
    // Your Code
}

@end

cppsignallingService.addSignallingListener(listener);

Javavoid removeSignallingListener(V2NIMSignallingListener listener);

Objective-C- (void)removeSignallingListener:(id<V2NIMSignallingListener>)listener;

cppvirtual void removeSignallingListener(const V2NIMSignallingListener& listener) = 0;

JavaNIMClient.getService(V2NIMSignallingService.class).removeSignallingListener(listener);

Objective-C@interface Clazz:NSObject<V2NIMSignallingListener>
- (void)addSignallingListener;
- (void)removeSignallingListener;
@end

@implementation Clazz
- (void)addSignallingListener
{
    [[NIMSDK sharedSDK].v2SignallingService addSignallingListener:self];
}

- (void)removeSignallingListener
{
    [[NIMSDK sharedSDK].v2SignallingService removeSignallingListener:self];
}

- (void)onMultiClientEvent:(nonnull V2NIMSignallingEvent *)event {
    // Your Code
}

- (void)onOfflineEvent:(nonnull NSArray<V2NIMSignallingEvent *> *)event { 
    // Your Code
}

- (void)onOnlineEvent:(nonnull V2NIMSignallingEvent *)event { 
    // Your Code
}

- (void)onSyncRoomInfoList:(nonnull NSArray<V2NIMSignallingRoomInfo *> *)channelRooms { 
    // Your Code
}

@end

cppsignallingService.removeSignallingListener(listener);

typescriptinterface V2NIMSignallingService extends EventEmitter3<V2NIMSignallingListener>

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
}

typescriptnim.V2NIMSignallingService.on("onOnlineEvent", function (event: V2NIMSignallingEvent) {})
nim.V2NIMSignallingService.on("onOfflineEvent", function (event: V2NIMSignallingEvent[]]) {})
nim.V2NIMSignallingService.on("onMultiClientEvent", function (event: V2NIMSignallingEvent) {})
nim.V2NIMSignallingService.on("onSyncRoomInfoList", function (roomInfoList: V2NIMSignallingRoomInfo[]) {})

typescriptsignallingService.on("onOnlineEvent", function (event: V2NIMSignallingEvent) {})
signallingService.on("onOfflineEvent", function (event: V2NIMSignallingEvent[]]) {})
signallingService.on("onMultiClientEvent", function (event: V2NIMSignallingEvent) {})
signallingService.on("onSyncRoomInfoList", function (roomInfoList: V2NIMSignallingRoomInfo[]) {})

typescriptinterface V2NIMSignallingService extends EventEmitter3<V2NIMSignallingListener>

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
}

typescriptnim.V2NIMSignallingService.off("onOnlineEvent")
nim.V2NIMSignallingService.off("onOfflineEvent")
nim.V2NIMSignallingService.off("onMultiClientEvent")
nim.V2NIMSignallingService.off("onSyncRoomInfoList")

typescriptsignallingService.off("onOnlineEvent", function (event: V2NIMSignallingEvent) {})
signallingService.off("onOfflineEvent", function (event: V2NIMSignallingEvent[]]) {})
signallingService.off("onMultiClientEvent", function (event: V2NIMSignallingEvent) {})
signallingService.off("onSyncRoomInfoList", function (roomInfoList: V2NIMSignallingRoomInfo[]) {})

javavoid call(V2NIMSignallingCallParams params, V2NIMSuccessCallback<V2NIMSignallingCallResult> success, V2NIMFailureCallback failure);

objective-c- (void)call:(V2NIMSignallingCallParams*)param
     success:(V2NIMSignallingCallSuccess)success
     failure:(V2NIMFailureCallback)failure;

cppvirtual void v2::V2NIMSignallingService::call	(	const V2NIMSignallingCallParams & 	params,
                                                const V2NIMSuccessCallback< const V2NIMSignallingCallResult & > & 	success,
                                                const V2NIMFailureCallback & 	failure)	

typescriptcall(params: V2NIMSignallingCallParams): Promise<V2NIMSignallingCallResult>

typescriptcall(params: V2NIMSignallingCallParams): Promise<V2NIMSignallingCallResult>

java//被呼叫者账号ID不能填自己的账号ID
String calleeAccountId = "test";
//请求ID
String requestId = "123456";
//频道类型
V2NIMSignallingChannelType channelType = V2NIMSignallingChannelType.V2NIM_SIGNALLING_CHANNEL_TYPE_VIDEO;
//推送配置
V2NIMSignallingPushConfig v2NIMSignallingPushConfig = new V2NIMSignallingPushConfig();
//信令配置
V2NIMSignallingConfig v2NIMSignallingConfig = new V2NIMSignallingConfig();
//音视频配置
V2NIMSignallingRtcConfig v2NIMSignallingRtcConfig = new V2NIMSignallingRtcConfig("rtcChannelName",60 * 60L,null);

V2NIMSignallingCallParams params = new V2NIMSignallingCallParams.Builder(calleeAccountId, requestId, channelType)
    .channelExtension("channelExtension")
    .channelName("channelName")
    .serverExtension("serverExtension")
    .pushConfig(v2NIMSignallingPushConfig)
    .signallingConfig(v2NIMSignallingConfig)
    .rtcConfig(v2NIMSignallingRtcConfig)
    .build();
NIMClient.getService(V2NIMSignallingService.class).call(params, new V2NIMSuccessCallback<V2NIMSignallingCallResult>() {
    @Override
    public void onSuccess(V2NIMSignallingCallResult v2NIMSignallingCallResult) {
        //call success
    }
}, new V2NIMFailureCallback() {
    @Override
    public void onFailure(V2NIMError error) {
        //call failure
    }
});

objective-cV2NIMSignallingCallParams* param = [[V2NIMSignallingCallParams alloc] init];
// 被呼叫者账号ID不能填自己的账号ID
param.calleeAccountId = @"Account ID";
param.requestId = @"Request ID";
// 创建音频频道
V.channelType = V2NIM_SIGNALLING_CHANNEL_TYPE_AUDIO;
param.channelName = @"Channel Name";

[[NIMSDK sharedSDK].v2SignallingService call:param success:^(V2NIMSignallingCallResult *result) {
    // Your Code
} failure:^(V2NIMError *error) {
    // Your Code
}];

cppV2NIMSignallingCallParams callParameter;
callParameter.calleeAccountId = "calleeAccountId";
callParameter.requestId = "request UUID";
callParameter.channelType = V2NIM_SIGNALLING_CHANNEL_TYPE_AUDIO;
signallingService.call(
    callParameter,
    [](const V2NIMSignallingCallResult& result) {
        // call success
    },
    [](V2NIMError error) {
        // call failed, handle error
    });

typescriptconst params: V2NIMSignallingCallParams = {
  calleeAccountId: this.calleeAccountId,
  requestId: this.requestId,
  channelType: this.channelType,
  channelName: this.channelName,
  channelExtension: this.channelExtension,
  serverExtension: this.serverExtension,
  signallingConfig: {
    unreadEnabled: this.unreadEnabled,
    offlineEnabled: this.offlineEnabled,
    selfUid: this.selfUid
  },
  pushConfig: {
    pushEnabled: this.pushEnabled,
    pushTitle: this.pushTitle,
    pushContent: this.pushContent,
    pushPayload: this.pushPayload
  },
  rtcConfig: {
    rtcChannelName: this.rtcChannelName,
    rtcTokenTtl: this.rtcTokenTtl,
    rtcParams: this.rtcParams
  }
}

const result:V2NIMSignallingCallResult = await nimsdk.signallingService.call(params)

typescriptconst params: V2NIMSignallingCallParams = {
  calleeAccountId: this.calleeAccountId,
  requestId: this.requestId,
  channelType: this.channelType,
  channelName: this.channelName,
  channelExtension: this.channelExtension,
  serverExtension: this.serverExtension,
  signallingConfig: {
    unreadEnabled: this.unreadEnabled,
    offlineEnabled: this.offlineEnabled,
    selfUid: this.selfUid
  },
  pushConfig: {
    pushEnabled: this.pushEnabled,
    pushTitle: this.pushTitle,
    pushContent: this.pushContent,
    pushPayload: this.pushPayload
  },
  rtcConfig: {
    rtcChannelName: this.rtcChannelName,
    rtcTokenTtl: this.rtcTokenTtl,
    rtcParams: this.rtcParams
  }
}

const result:V2NIMSignallingCallResult = await nimsdk.signallingService.call(params)

无返回值

Promise<V2NIMSignallingCallResult>

• 请求成功，返回 V2NIMSuccessCallback 回调，包含 V2NIMSignallingCallResult 结果。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含信令相关错误码。

• 请求成功，返回 V2NIMSignallingCallSuccess 回调，可自定义。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含信令相关错误码。

无

javavoid callSetup(V2NIMSignallingCallSetupParams params, V2NIMSuccessCallback<V2NIMSignallingCallSetupResult> success, V2NIMFailureCallback failure);

objective-c- (void)callSetup:(V2NIMSignallingCallSetupParams*)param
          success:(V2NIMSignallingCallSetupSuccess)success
          failure:(V2NIMFailureCallback)failure;

cppvirtual void v2::V2NIMSignallingService::callSetup	(	const V2NIMSignallingCallSetupParams & 	params,
                                                      const V2NIMSuccessCallback< V2NIMSignallingCallSetupResult > & 	success,
                                                      const V2NIMFailureCallback & 	failure )	

typescriptcallSetup(params: V2NIMSignallingCallSetupParams): Promise<V2NIMSignallingCallSetupResult>

typescriptcallSetup(params: V2NIMSignallingCallSetupParams): Promise<V2NIMSignallingCallSetupResult>

javaString channelId = "channelId";
//被呼叫者账号ID不能填自己的账号ID
String callerAccountId = "caller account id";
//请求ID
String requestId = "123456";
//信令配置
V2NIMSignallingConfig v2NIMSignallingConfig = new V2NIMSignallingConfig();
//音视频配置
V2NIMSignallingRtcConfig v2NIMSignallingRtcConfig = new V2NIMSignallingRtcConfig("rtcChannelName",60 * 60L,null);


V2NIMSignallingCallSetupParams setupParams = new V2NIMSignallingCallSetupParams.Builder(channelId, callerAccountId, requestId)
    .serverExtension("serverExtension")
    .signallingConfig(v2NIMSignallingConfig)
    .rtcConfig(v2NIMSignallingRtcConfig)
    .build();

NIMClient.getService(V2NIMSignallingService.class).callSetup(setupParams, new V2NIMSuccessCallback<V2NIMSignallingCallSetupResult>() {
    @Override
    public void onSuccess(V2NIMSignallingCallSetupResult v2NIMSignallingCallSetupResult) {
        //call setup success
    }
}, new V2NIMFailureCallback() {
    @Override
    public void onFailure(V2NIMError error) {
        //call setup failure
    }
});

objective-cV2NIMSignallingCallSetupParams* param = [[V2NIMSignallingCallSetupParams alloc] init];
param.channelId = @"Channel ID";
// 接受的呼叫者账号ID，不能填自己的账号ID
param.callerAccountId = @"Account ID";
param.requestId = @"Request ID";

[[NIMSDK sharedSDK].v2SignallingService callSetup:param success:^(V2NIMSignallingCallSetupResult *result) {
    // Your Code
} failure:^(V2NIMError *error) {
    // Your Code
}];

cppV2NIMSignallingCallSetupParams callSetupParams;
callSetupParams.channelId = "channelId";
callSetupParams.callerAccountId = "callerAccountId";
callSetupParams.requestId = "request UUID";
signallingService.callSetup(
    callSetupParams,
    [](const V2NIMSignallingCallSetupResult& result) {
        // call setup success
    },
    [](V2NIMError error) {
        // call setup failed, handle error
    });

typescriptconst params: V2NIMSignallingCallSetupParams = {
  callerAccountId: this.callerAccountId,
  requestId: this.requestId,
  channelId: this.channelId,
  serverExtension: this.serverExtension,
  signallingConfig: {
    unreadEnabled: this.unreadEnabled,
    offlineEnabled: this.offlineEnabled,
    selfUid: this.selfUid
  },
  rtcConfig: {
    rtcChannelName: this.rtcChannelName,
    rtcTokenTtl: this.rtcTokenTtl,
    rtcParams: this.rtcParams
  }
}

const result:V2NIMSignallingCallSetupResult = await nimsdk.signallingService.callSetup(params)

typescriptconst params: V2NIMSignallingCallSetupParams = {
  callerAccountId: this.callerAccountId,
  requestId: this.requestId,
  channelId: this.channelId,
  serverExtension: this.serverExtension,
  signallingConfig: {
    unreadEnabled: this.unreadEnabled,
    offlineEnabled: this.offlineEnabled,
    selfUid: this.selfUid
  },
  rtcConfig: {
    rtcChannelName: this.rtcChannelName,
    rtcTokenTtl: this.rtcTokenTtl,
    rtcParams: this.rtcParams
  }
}

const result:V2NIMSignallingCallSetupResult = await nimsdk.signallingService.callSetup(params)

无返回值

Promise<V2NIMSignallingCallSetupResult>

• 请求成功，返回 V2NIMSuccessCallback 回调，包含 V2NIMSignallingCallSetupResult 结果。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含信令相关错误码。

• 请求成功，返回 V2NIMSignallingCallSetupSuccess 回调，可自定义。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含信令相关错误码。

无

javavoid createRoom(V2NIMSignallingChannelType channelType, String channelName, String channelExtension, V2NIMSuccessCallback<V2NIMSignallingChannelInfo> success, V2NIMFailureCallback  failure);

objective-c- (void)createRoom:(V2NIMSignallingChannelType)channelType
       channelName:(nullable NSString *)channelName
  channelExtension:(nullable NSString *)channelExtension
           success:(V2NIMSignallingCreateRoomSuccess)success
           failure:(V2NIMFailureCallback)failure;

cppvirtual void v2::V2NIMSignallingService::createRoom	(	V2NIMSignallingChannelType 	channelType,
                                                      const nstd::optional< nstd::string > & 	channelName,
                                                      const nstd::optional< nstd::string > & 	channelExtension,
                                                      const V2NIMSuccessCallback< const V2NIMSignallingChannelInfo & > & 	success,
                                                      const V2NIMFailureCallback & 	failure )	

typescriptcreateRoom(channelType: V2NIMSignallingChannelType, channelName?: string, channelExtension?: string): Promise<V2NIMSignallingChannelInfo>

typescriptcreateRoom(channelType: V2NIMSignallingChannelType,
    channelName?: string,
    channelExtension?: string): Promise<V2NIMSignallingChannelInfo>

java//频道类型
V2NIMSignallingChannelType channelType = V2NIMSignallingChannelType.V2NIM_SIGNALLING_CHANNEL_TYPE_VIDEO;
//频道名称
String channelName = "channelName";
//频道扩展字段
String channelExtension = "channelExtension";
NIMClient.getService(V2NIMSignallingService.class).createRoom(channelType, channelName, channelExtension, new V2NIMSuccessCallback<V2NIMSignallingChannelInfo>() {
    @Override
    public void onSuccess(V2NIMSignallingChannelInfo v2NIMSignallingChannelInfo) {
        //create room success
    }
}, new V2NIMFailureCallback() {
    @Override
    public void onFailure(V2NIMError error) {
        //create room failure
    }
});

objective-c// 创建视频频道
V2NIMSignallingChannelType channelType = V2NIM_SIGNALLING_CHANNEL_TYPE_VIDEO;
NSString *channelName = @"Channel Name";
NSString *channelExtension = @"{\"key\": \"value\"}";
[[NIMSDK sharedSDK].v2SignallingService createRoom:channelType channelName:channelName channelExtension:channelExtension success:^(V2NIMSignallingChannelInfo *result) {
    // Your Code
} failure:^(V2NIMError *error) {
    // Your Code
}];

cppsignallingService.createRoom(
    V2NIM_SIGNALLING_CHANNEL_TYPE_AUDIO,
    "channelName",
    "{\"key\":\"value\"}",
    [](const V2NIMSignallingChannelInfo& result) {
        // create room success
    },
    [](V2NIMError error) {
        // create room failed, handle error
    });

typescriptconst result:V2NIMSignallingChannelInfo = await nimsdk.signallingService.createRoom(this.channelType,
  this.channelName, this.channelExt)

typescriptconst result:V2NIMSignallingChannelInfo = await nimsdk.signallingService.createRoom(this.channelType,
    this.channelName, this.channelExt)

无返回值

Promise<V2NIMSignallingChannelInfo>

• 请求成功，返回 V2NIMSuccessCallback 回调，包含 V2NIMSignallingChannelInfo 结果。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含信令相关错误码。

• 请求成功，返回 V2NIMSignallingCreateRoomSuccess 回调，可自定义。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含信令相关错误码。

无

javavoid closeRoom(String channelId, boolean offlineEnabled,String serverExtension,V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

objective-c- (void)closeRoom:(NSString *)channelId
   offlineEnabled:(BOOL)offlineEnabled
  serverExtension:(nullable NSString *)serverExtension
          success:(V2NIMSuccessCallback)success
          failure:(V2NIMFailureCallback)failure;

cppvirtual void v2::V2NIMSignallingService::closeRoom	(	const nstd::string & 	channelId,
                                                      const nstd::optional< bool > & 	offlineEnabled,
                                                      const nstd::optional< nstd::string > & 	serverExtension,
                                                      const V2NIMSuccessCallback< void > & 	success,
                                                      const V2NIMFailureCallback & 	failure )	

typescriptcloseRoom(channelId: string, offlineEnabled?: boolean, serverExtension?: string): Promise<void>

typescriptcloseRoom(channelId: string, offlineEnabled?: boolean, serverExtension?: string): Promise<void>

javaString channelId = "channelId";
//是否需要存离线消息。如果存离线，则用户离线再上线会收到该通知
boolean offlineEnabled = true;
//服务端扩展字段， 长度限制4096
String serverExtension = "serverExtension";

NIMClient.getService(V2NIMSignallingService.class).closeRoom(channelId, true, "serverExtension", new V2NIMSuccessCallback<Void>() {
    @Override
    public void onSuccess(Void aVoid) {
        //close room success
    }
}, new V2NIMFailureCallback() {
    @Override
    public void onFailure(V2NIMError error) {
        //close room failure
    }
});

objective-cNSString * channelId = @"Channel ID";
BOOL offlineEnabled = YES;
NSString *serverExtension = @"{\"key\": \"value\"}";
[[NIMSDK sharedSDK].v2SignallingService closeRoom:channelId offlineEnabled:offlineEnabled serverExtension:serverExtension success:^() {
    // Your Code
} failure:^(V2NIMError *error) {
    // Your Code
}];

cppsignallingService.closeRoom(
    "channelId",
    true,
    "{\"key\":\"value\"}",
    []() {
        // close room success
    },
    [](V2NIMError error) {
        // close room failed, handle error
    });

typescriptconst channelId = 'XXX_Id'
const offlineEnabled = false 
const serverExtension = ''
await nimsdk.signallingService.closeRoom(channelId, offlineEnabled, serverExtension)

typescriptconst channelId = 'XXX_Id'
const offlineEnabled = false 
const serverExtension = ''
await nimsdk.signallingService.closeRoom(channelId, offlineEnabled, serverExtension)

无返回值

Promise<void>

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

无

javavoid joinRoom(V2NIMSignallingJoinParams params, V2NIMSuccessCallback<V2NIMSignallingRoomInfo> success, V2NIMFailureCallback failure);

objective-c- (void)joinRoom:(V2NIMSignallingJoinParams *)param
         success:(V2NIMSignallingJoinRoomSuccess)success
         failure:(V2NIMFailureCallback)failure;

cppvirtual void v2::V2NIMSignallingService::joinRoom	(	const V2NIMSignallingJoinParams & 	params,
                                                    const V2NIMSuccessCallback< const V2NIMSignallingRoomInfo & > & 	success,
                                                    const V2NIMFailureCallback & 	failure )	

typescriptjoinRoom(params: V2NIMSignallingJoinParams): Promise<V2NIMSignallingRoomInfo>

typescriptjoinRoom(params: V2NIMSignallingJoinParams): Promise<V2NIMSignallingRoomInfo>

javaString channelId = "channelId";
//信令配置
V2NIMSignallingConfig v2NIMSignallingConfig = new V2NIMSignallingConfig();
//音视频配置
V2NIMSignallingRtcConfig v2NIMSignallingRtcConfig = new V2NIMSignallingRtcConfig("rtcChannelName",60 * 60L,null);

V2NIMSignallingJoinParams params = new V2NIMSignallingJoinParams.Builder(channelId)
    .serverExtension("serverExtension")
    .signallingConfig(v2NIMSignallingConfig)
    .rtcConfig(v2NIMSignallingRtcConfig)
    .build();
NIMClient.getService(V2NIMSignallingService.class).joinRoom(params, new V2NIMSuccessCallback<V2NIMSignallingRoomInfo>() {
    @Override
    public void onSuccess(V2NIMSignallingRoomInfo v2NIMSignallingRoomInfo) {
        //join room success
    }
}, new V2NIMFailureCallback() {
    @Override
    public void onFailure(V2NIMError error) {
        //join room failure
    }
});

objective-cV2NIMSignallingJoinParams * param = [[V2NIMSignallingJoinParams alloc] init];
param.channelId = @"Channel ID";
param.serverExtension = @"{\"key\": \"value\"}";
[[NIMSDK sharedSDK].v2SignallingService joinRoom:param success:^(V2NIMSignallingRoomInfo *result) {
    // Your Code
} failure:^(V2NIMError *error) {
    // Your Code
}];

cppV2NIMSignallingJoinParams joinParameter;
joinParams.channelId = "channelId";
signallingService.joinRoom(
    joinParameter,
    [](const V2NIMSignallingChannelInfo& result) {
        // join room success
    },
    [](V2NIMError error) {
        // join room failed, handle error
    });

typescriptconst signallingConfig = {
  offlineEnabled : this.offlineEnabled,
  unreadEnabled: this.unreadEnabled,
  selfUid: this.selfUid
} as V2NIMSignallingConfig

const rtcConfig= {
  rtcChannelName: this.rtcChannelName,
  rtcTokenTtl: this.rtcTokenTtl,
  rtcParams: this.rtcParams
} as V2NIMSignallingRtcConfig

const params: V2NIMSignallingJoinParams = {
  channelId: this.channelId,
  serverExtension: this.serverExtension,
  signallingConfig: signallingConfig,
  rtcConfig: rtcConfig
}

const result:V2NIMSignallingRoomResult = await nimsdk.signallingService.joinRoom(params)

typescriptconst signallingConfig = {
  offlineEnabled : this.offlineEnabled,
  unreadEnabled: this.unreadEnabled,
  selfUid: this.selfUid
} as V2NIMSignallingConfig

const rtcConfig= {
  rtcChannelName: this.rtcChannelName,
  rtcTokenTtl: this.rtcTokenTtl,
  rtcParams: this.rtcParams
} as V2NIMSignallingRtcConfig

const params: V2NIMSignallingJoinParams = {
  channelId: this.channelId,
  serverExtension: this.serverExtension,
  signallingConfig: signallingConfig,
  rtcConfig: rtcConfig
}

const result:V2NIMSignallingRoomResult = await nimsdk.signallingService.joinRoom(params)

无返回值

Promise<V2NIMSignallingRoomInfo>

• 请求成功，返回 V2NIMSuccessCallback 回调，结果包含 V2NIMSignallingRoomInfo。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含信令相关错误码。

• 请求成功，返回 V2NIMSignallingJoinRoomSuccess 回调，可自定义。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含信令相关错误码。

无

javavoid leaveRoom(String channelId, boolean offlineEnabled,String serverExtension,V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

objective-c- (void)leaveRoom:(NSString *)channelId
   offlineEnabled:(BOOL)offlineEnabled
  serverExtension:(nullable NSString *)serverExtension
          success:(V2NIMSuccessCallback)success
          failure:(V2NIMFailureCallback)failure;

cppvirtual void v2::V2NIMSignallingService::leaveRoom	(	const nstd::string & 	channelId,
                                                      const nstd::optional< bool > & 	offlineEnabled,
                                                      const nstd::optional< nstd::string > & 	serverExtension,
                                                      const V2NIMSuccessCallback< void > & 	success,
                                                      const V2NIMFailureCallback & 	failure )	

typescriptleaveRoom(channelId: string, offlineEnabled?: boolean, serverExtension?: string): Promise<void>

typescriptleaveRoom(channelId: string, offlineEnabled?: boolean, serverExtension?: string): Promise<void>

javaString channelId = "channelId";
//是否需要存离线消息。如果存离线，则用户离线再上线会收到该通知
boolean offlineEnabled = true;
//服务端扩展字段， 长度限制4096
String serverExtension = "serverExtension";

NIMClient.getService(V2NIMSignallingService.class).leaveRoom(channelId,offlineEnabled,serverExtension, new V2NIMSuccessCallback<Void>() {
    @Override
    public void onSuccess(Void aVoid) {
        //leave room success
    }
}, new V2NIMFailureCallback() {
    @Override
    public void onFailure(V2NIMError error) {
        //leave room failure
    }
});

objective-cNSString * channelId = @"Channel ID";
BOOL offlineEnabled = YES;
NSString *serverExtension = @"{\"key\": \"value\"}";
[[NIMSDK sharedSDK].v2SignallingService leaveRoom:channelId offlineEnabled:offlineEnabled serverExtension:serverExtension success:^() {
    // Your Code
} failure:^(V2NIMError *error) {
    // Your Code
}];

cppsignallingService.leaveRoom(
    "channelId",
    true,
    "{\"key\":\"value\"}",
    []() {
        // leave room success
    },
    [](V2NIMError error) {
        // leave room failed, handle error
    });

typescriptawait nimsdk.signallingService.leaveRoom(this.channelId, this.offlineEnabled, this.serverExtension)

typescriptawait nimsdk.signallingService.leaveRoom(this.channelId, this.offlineEnabled, this.serverExtension)

无返回值

Promise<void>

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

无

javavoid invite(V2NIMSignallingInviteParams params, V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

objective-c- (void)invite:(V2NIMSignallingInviteParams *)param
       success:(V2NIMSuccessCallback)success
       failure:(V2NIMFailureCallback)failure;

cppvirtual void v2::V2NIMSignallingService::invite	(	const V2NIMSignallingInviteParams & 	params,
                                                  const V2NIMSuccessCallback< void > & 	success,
                                                  const V2NIMFailureCallback & 	failure )	

typescriptinvite(params: V2NIMSignallingInviteParams): Promise<void>

typescriptinvite(params: V2NIMSignallingInviteParams): Promise<void>

javaString channelId = "channelId";
//被邀请者账号ID
String inviteeAccountId = "inviteeAccountId";
//请求ID
String requestId = "123456";
//服务端扩展字段
String serverExtension = "serverExtension";
//推送配置
V2NIMSignallingPushConfig v2NIMSignallingPushConfig = new V2NIMSignallingPushConfig();
//信令配置
V2NIMSignallingConfig v2NIMSignallingConfig = new V2NIMSignallingConfig();

V2NIMSignallingInviteParams params = new V2NIMSignallingInviteParams.Builder(channelId, inviteeAccountId, requestId)
    .serverExtension("serverExtension")
    .signallingConfig(new V2NIMSignallingConfig())
    .pushConfig(new V2NIMSignallingPushConfig())
    .build();

NIMClient.getService(V2NIMSignallingService.class).invite(params, new V2NIMSuccessCallback<Void>() {
    @Override
    public void onSuccess(Void unused) {

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

objective-cV2NIMSignallingInviteParams * param = [[V2NIMSignallingInviteParams alloc] init];
param.channelId = @"Channel ID";
// 被邀请者账号ID，不能填自己的账号ID
param.inviteeAccountId = @"Account ID";
param.requestId = @"Request ID";
param.serverExtension = @"{\"key\": \"value\"}";
[[NIMSDK sharedSDK].v2SignallingService invite:param success:^() {
    // Your Code
} failure:^(V2NIMError *error) {
    // Your Code
}];

cppV2NIMSignallingInviteParams inviteParameter;
inviteParameter.channelId = "channelId";
inviteParameter.accountId = "accountId";
inviteParameter.requestId = "request UUID";
signallingService.invite(
    inviteParameter,
    []() {
        // invite success
    },
    [](V2NIMError error) {
        // invite failed, handle error
    });

typescriptconst params: V2NIMSignallingInviteParams = {
  channelId: this.channelId,
  inviteeAccountId: this.inviteeAccountId,
  requestId: this.requestId,
  serverExtension: this.serverExtension,
  pushConfig: {
    pushEnabled: this.pushEnabled,
    pushTitle: this.pushTitle,
    pushContent: this.pushContent,
    pushPayload: this.pushPayload
  },
  signallingConfig: {
    offlineEnabled: this.offlineEnabled,
    unreadEnabled: this.unreadEnabled,
    selfUid: this.selfUid
  }
}

await nimsdk.signallingService.invite(params)

typescriptconst params: V2NIMSignallingInviteParams = {
  channelId: this.channelId,
  inviteeAccountId: this.inviteeAccountId,
  requestId: this.requestId,
  serverExtension: this.serverExtension,
  pushConfig: {
    pushEnabled: this.pushEnabled,
    pushTitle: this.pushTitle,
    pushContent: this.pushContent,
    pushPayload: this.pushPayload
  },
  signallingConfig: {
    offlineEnabled: this.offlineEnabled,
    unreadEnabled: this.unreadEnabled,
    selfUid: this.selfUid
  }
}

await nimsdk.signallingService.invite(params)

无返回值

Promise<void>

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

无

javavoid cancelInvite(V2NIMSignallingCancelInviteParams params, V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure)

objective-c- (void)cancelInvite:(V2NIMSignallingCancelInviteParams*)param
             success:(V2NIMSuccessCallback)success
             failure:(V2NIMFailureCallback)failure;

cppvirtual void v2::V2NIMSignallingService::cancelInvite	(	const V2NIMSignallingCancelInviteParams & 	params,
                                                        const V2NIMSuccessCallback< void > & 	success,
                                                        const V2NIMFailureCallback & 	failure )		

typescriptcancelInvite(params: V2NIMSignallingCancelInviteParams): Promise<void>

typescriptcancelInvite(params: V2NIMSignallingCancelInviteParams): Promise<void>

javaString channelId = "channelId";
//被邀请者账号ID
String inviteeAccountId = "inviteeAccountId";
//请求ID
String requestId = "123456";
//服务端扩展字段
String serverExtension = "serverExtension";
//是否需要存离线消息。如果存离线，则用户离线再上线会收到该通知
boolean offlineEnabled = true;

V2NIMSignallingCancelInviteParams params = new V2NIMSignallingCancelInviteParams.Builder(channelId,inviteeAccountId,requestId)
    .serverExtension("serverExtension")
    .offlineEnabled(offlineEnabled)
    .build();
NIMClient.getService(V2NIMSignallingService.class).cancelInvite(params, new V2NIMSuccessCallback<Void>() {
    @Override
    public void onSuccess(Void unused) {

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

objective-cV2NIMSignallingCancelInviteParams* param = [[V2NIMSignallingCancelInviteParams alloc] init];
param.channelId = @"Channel ID";
// 被邀请者账号ID，不能填自己的账号ID
param.inviteeAccountId = @"Account ID";
param.requestId = @"Request ID";
param.serverExtension = @"{\"key\": \"value\"}";
param.offlineEnabled = YES;

[[NIMSDK sharedSDK].v2SignallingService cancelInvite:param success:^() {
    // Your Code
} failure:^(V2NIMError *error) {
    // Your Code
}];

cppV2NIMSignallingCancelInviteParams cancelInviteParameter;
cancelInviteParameter.channelId = "channelId";
cancelInviteParameter.accountId = "accountId";
cancelInviteParameter.requestId = "request UUID";
signallingService.cancelInvite(
    cancelInviteParameter,
    []() {
        // cancel invite success
    },
    [](V2NIMError error) {
        // cancel invite failed, handle error
    });

typescriptconst params: V2NIMSignallingCancelInviteParams = {
  channelId: this.channelId,
  inviteeAccountId: this.inviteeAccountId,
  requestId: this.requestId,
  serverExtension: this.serverExtension,
  offlineEnabled: this.offlineEnabled
}

await nimsdk.signallingService.cancelInvite(params)

typescriptconst params: V2NIMSignallingCancelInviteParams = {
  channelId: this.channelId,
  inviteeAccountId: this.inviteeAccountId,
  requestId: this.requestId,
  serverExtension: this.serverExtension,
  offlineEnabled: this.offlineEnabled
}

await nimsdk.signallingService.cancelInvite(params)

无返回值

Promise<void>

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

无

javavoid rejectInvite(V2NIMSignallingRejectInviteParams params, V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

objective-c- (void)rejectInvite:(V2NIMSignallingRejectInviteParams*)param
             success:(V2NIMSuccessCallback)success
             failure:(V2NIMFailureCallback)failure;

cppvirtual void v2::V2NIMSignallingService::rejectInvite	(	const V2NIMSignallingRejectInviteParams & 	params,
                                                        const V2NIMSuccessCallback< void > & 	success,
                                                        const V2NIMFailureCallback & 	failure )	

typescriptrejectInvite(params: V2NIMSignallingRejectInviteParams): Promise<void>

typescriptrejectInvite(params: V2NIMSignallingRejectInviteParams): Promise<void>

javaString channelId = "channelId";
//被邀请者账号ID
String inviteeAccountId = "inviteeAccountId";
//请求ID
String requestId = "123456";
//服务端扩展字段
String serverExtension = "serverExtension";
//是否需要存离线消息。如果存离线，则用户离线再上线会收到该通知
boolean offlineEnabled = true;

V2NIMSignallingRejectInviteParams params = new V2NIMSignallingRejectInviteParams.Builder(channelId, inviteeAccountId, requestId)
    .serverExtension(serverExtension)
    .offlineEnabled(offlineEnabled)
    .build();

NIMClient.getService(V2NIMSignallingService.class).rejectInvite(params, new V2NIMSuccessCallback<Void>() {
    @Override
    public void onSuccess(Void unused) {

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

    }
});

objective-cV2NIMSignallingRejectInviteParams* param = [[V2NIMSignallingRejectInviteParams alloc] init];
param.channelId = @"Channel ID";
// 邀请者账号ID，不能填自己的账号ID
param.inviterAccountId = @"Account ID";
param.requestId = @"Request ID";
param.serverExtension = @"{\"key\": \"value\"}";
[[NIMSDK sharedSDK].v2SignallingService rejectInvite:param success:^() {
    // Your Code
} failure:^(V2NIMError *error) {
    // Your Code
}];

cppV2NIMSignallingRejectInviteParams rejectInviteParameter;
rejectInviteParameter.channelId = "channelId";
rejectInviteParameter.accountId = "accountId";
rejectInviteParameter.requestId = "request UUID";
signallingService.rejectInvite(
    rejectInviteParameter,
    []() {
        // reject invite success
    },
    [](V2NIMError error) {
        // reject invite failed, handle error
    });

typescriptconst params: V2NIMSignallingRejectInviteParams = {
  channelId: this.channelId,
  inviterAccountId: this.inviterAccountId,
  requestId: this.requestId,
  serverExtension: this.serverExtension,
  offlineEnabled: this.offlineEnabled
}

await nimsdk.signallingService.rejectInvite(params)

typescriptconst params: V2NIMSignallingRejectInviteParams = {
  channelId: this.channelId,
  inviterAccountId: this.inviterAccountId,
  requestId: this.requestId,
  serverExtension: this.serverExtension,
  offlineEnabled: this.offlineEnabled
}

await nimsdk.signallingService.rejectInvite(params)

无返回值

Promise<void>

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

无

javavoid acceptInvite(V2NIMSignallingAcceptInviteParams params, V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

objective-c- (void)acceptInvite:(V2NIMSignallingAcceptInviteParams*)param
             success:(V2NIMSuccessCallback)success
             failure:(V2NIMFailureCallback)failure;

cppvirtual void v2::V2NIMSignallingService::acceptInvite	(	const V2NIMSignallingAcceptInviteParams & 	params,
                                                        const V2NIMSuccessCallback< void > & 	success,
                                                        const V2NIMFailureCallback & 	failure )	

typescriptacceptInvite(params: V2NIMSignallingAcceptInviteParams): Promise<void>

typescriptacceptInvite(params: V2NIMSignallingAcceptInviteParams): Promise<void>

javaString channelId = "channelId";
//被邀请者账号ID
String inviterAccountId = "inviterAccountId";
//请求ID
String requestId = "123456";
//服务端扩展字段
String serverExtension = "serverExtension";
//是否需要存离线消息。如果存离线，则用户离线再上线会收到该通知
boolean offlineEnabled = true;

V2NIMSignallingAcceptInviteParams params = new V2NIMSignallingAcceptInviteParams.Builder(channelId, inviterAccountId, requestId)
    .serverExtension(serverExtension)
    .offlineEnabled(offlineEnabled)
    .build();
NIMClient.getService(V2NIMSignallingService.class).acceptInvite(params, new V2NIMSuccessCallback<Void>() {
    @Override
    public void onSuccess(Void unused) {

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

    }
});

objective-cV2NIMSignallingAcceptInviteParams* param = [[V2NIMSignallingAcceptInviteParams alloc] init];
param.channelId = @"Channel ID";
// 邀请者账号ID，不能填自己的账号ID
param.inviterAccountId = @"Account ID";
param.requestId = @"Request ID";
param.serverExtension = @"{\"key\": \"value\"}";
param.offlineEnabled = YES;


[[NIMSDK sharedSDK].v2SignallingService acceptInvite:param success:^() {
    // Your Code
} failure:^(V2NIMError *error) {
    // Your Code
}];

cppV2NIMSignallingAcceptInviteParams acceptInviteParameter;
acceptInviteParameter.channelId = "channelId";
acceptInviteParameter.accountId = "accountId";
acceptInviteParameter.requestId = "request UUID";
signallingService.acceptInvite(
    acceptInviteParameter,
    []() {
        // accept invite success
    },
    [](V2NIMError error) {
        // accept invite failed, handle error
    });

typescriptconst params: V2NIMSignallingAcceptInviteParams = {
  channelId: this.channelId,
  inviterAccountId: this.inviterAccountId,
  requestId: this.requestId,
  serverExtension: this.serverExtension,
  offlineEnabled: this.offlineEnabled
}

await nimsdk.signallingService.acceptInvite(params)

typescriptconst params: V2NIMSignallingAcceptInviteParams = {
  channelId: this.channelId,
  inviterAccountId: this.inviterAccountId,
  requestId: this.requestId,
  serverExtension: this.serverExtension,
  offlineEnabled: this.offlineEnabled
}

await nimsdk.signallingService.acceptInvite(params)

无返回值

Promise<void>

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

无

javavoid sendControl(String channelId, String receiverAccountId, String serverExtension, V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

objective-c- (void)sendControl:(NSString *)channelId
  receiverAccountId:(nullable NSString *)receiverAccountId
    serverExtension:(nullable NSString *)serverExtension
            success:(V2NIMSuccessCallback)success
            failure:(V2NIMFailureCallback)failure;

cppvirtual void v2::V2NIMSignallingService::sendControl	(	const nstd::string & 	channelId,
                                                        const nstd::optional< nstd::string > & 	receiverAccountId,
                                                        const nstd::optional< nstd::string > & 	serverExtension,
                                                        const V2NIMSuccessCallback< void > & 	success,
                                                        const V2NIMFailureCallback & 	failure )	

typescriptsendControl(channelId: string, receiverAccountId?: string, serverExtension?: string): Promise<void>

typescriptsendControl(channelId: string, receiverAccountId?: string, serverExtension?: string): Promise<void>

java//发送控制消息
String channelId = "channelId";
//接受者账号ID
String receiverAccountId = "receiverAccountId";
//服务端扩展字段
String serverExtension = "serverExtension";

NIMClient.getService(V2NIMSignallingService.class).sendControl(channelId, receiverAccountId, serverExtension, new V2NIMSuccessCallback<Void>() {
    @Override
    public void onSuccess(Void unused) {

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

    }
});

objective-cNSString *channelId = @"Channel ID";
NSString *receiverAccountId = @"Account ID";
NSString *serverExtension = @"{\"key\": \"value\"}";
[[NIMSDK sharedSDK].v2SignallingService sendControl:channelId receiverAccountId:receiverAccountId serverExtension:serverExtension  success:^() {
    // Your Code
} failure:^(V2NIMError *error) {
    // Your Code
}];

cppsignallingService.sendControl(
    "channelId",
    "receiverAccountId",
    "{\"key\":\"value\"}",
    []() {
        // send control success
    },
    [](V2NIMError error) {
        // send control failed, handle error
    });

typescriptawait nimsdk.signallingService.sendControl(this.channelId, this.receiverAccountId, this.serverExtension)

typescriptawait nimsdk.signallingService.sendControl(this.channelId, this.receiverAccountId, this.serverExtension)

无返回值

Promise<void>

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

无

javavoid getRoomInfoByChannelName(String channelName, V2NIMSuccessCallback<V2NIMSignallingRoomInfo> success, V2NIMFailureCallback failure);

objective-c- (void)getRoomInfoByChannelName:(NSString *)channelName
                         success:(V2NIMSignallingGetRoomInfoByChannelNameSuccess)success
                         failure:(V2NIMFailureCallback)failure;

cppvirtual void v2::V2NIMSignallingService::getRoomInfoByChannelName	(	const nstd::string & 	channelName,
                                                                    const V2NIMSuccessCallback< const V2NIMSignallingRoomInfo & > & 	success,
                                                                    const V2NIMFailureCallback & 	failure )	

typescriptgetRoomInfoByChannelName(channelName: string): Promise<V2NIMSignallingRoomInfo>

typescriptgetRoomInfoByChannelName(channelName: string): Promise<V2NIMSignallingRoomInfo>

javaNIMClient.getService(V2NIMSignallingService.class).getRoomInfoByChannelName("channelName", new V2NIMSuccessCallback<V2NIMSignallingRoomInfo>() {
    @Override
    public void onSuccess(V2NIMSignallingRoomInfo v2NIMSignallingRoomInfo) {
        //get room info success
    }
}, new V2NIMFailureCallback() {
    @Override
    public void onFailure(V2NIMError error) {
        //get room info failure
    }
});

objective-cNSString * channelName = @"Channel Name";
[[NIMSDK sharedSDK].v2SignallingService getRoomInfoByChannelName:channelName success:^(V2NIMSignallingRoomInfo *result) {
    // Your Code
} failure:^(V2NIMError *error) {
    // Your Code
}];

cppsignallingService.getRoomInfoByChannelName(
    "channelName",
    [](const V2NIMSignallingRoomInfo& result) {
        // get room info success
    },
    [](V2NIMError error) {
        // get room info failed, handle error
    });

typescriptconst result = await nim.V2NIMSignallingService.getRoomInfoByChannelName("YOUR_CHANNEL_NAME")

typescriptconst result:V2NIMSignallingRoomResult = await nimsdk.signallingService.getRoomInfoByChannelName(this.channelName)

无返回值

Promise<V2NIMSignallingRoomInfo>

• 请求成功，返回 V2NIMSuccessCallback 回调，包含 V2NIMSignallingRoomInfo。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含信令相关错误码。

• 请求成功，返回 V2NIMSignallingGetRoomInfoByChannelNameSuccess 回调，可自定义。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含信令相关错误码。

无

javapublic class V2NIMSignallingCallParams {
  private static final String TAG = "V2NIMSignallingCallParams";
  private final String calleeAccountId;
  private final String requestId;
  private final V2NIMSignallingChannelType channelType;
  private String channelName;
  private String channelExtension;
  private String serverExtension;
  private V2NIMSignallingConfig signallingConfig;
  private V2NIMSignallingPushConfig pushConfig;
  private V2NIMSignallingRtcConfig rtcConfig;
  private V2NIMSignallingCallParams() {
   this(null, null, null);
  }
  public V2NIMSignallingCallParams(String calleeAccountId, String requestId, V2NIMSignallingChannelType channelType) {
   this.calleeAccountId = calleeAccountId;
   this.requestId = requestId;
   this.channelType = channelType;
  }
  public String getCalleeAccountId() {
   return calleeAccountId;
  }
  public String getRequestId() {
   return requestId;
  }
  public V2NIMSignallingChannelType getChannelType() {
   return channelType;
  }
  public String getChannelName() {
   return channelName;
  }
  public void setChannelName(String channelName) {
   this.channelName = channelName;
  }
  public String getChannelExtension() {
   return channelExtension;
  }
  public void setChannelExtension(String channelExtension) {
   this.channelExtension = channelExtension;
  }
  public String getServerExtension() {
   return serverExtension;
  }
  public void setServerExtension(String serverExtension) {
   this.serverExtension = serverExtension;
  }
  public V2NIMSignallingConfig getSignallingConfig() {
   return signallingConfig;
  }
  public void setSignallingConfig(V2NIMSignallingConfig signallingConfig) {
   this.signallingConfig = signallingConfig;
  }
  public V2NIMSignallingPushConfig getPushConfig() {
   return pushConfig;
  }
  public void setPushConfig(V2NIMSignallingPushConfig pushConfig) {
   this.pushConfig = pushConfig;
  }
  public V2NIMSignallingRtcConfig getRtcConfig() {
   return rtcConfig;
  }
  public void setRtcConfig(V2NIMSignallingRtcConfig rtcConfig) {
   this.rtcConfig = rtcConfig;
  }
  public boolean isValid() {
   if(TextUtils.isEmpty(calleeAccountId)){
    NimLog.e(TAG, "calleeAccountId is empty");
    return false;
   }
   if(calleeAccountId.equals(SDKCacheUI.getAccount())){
    NimLog.e(TAG, "calleeAccountId is self");
    return false;
   }
   if(TextUtils.isEmpty(requestId)){
    NimLog.e(TAG, "requestId is empty");
    return false;
   }
   if(channelType == null){
    NimLog.e(TAG, "channelType is null");
    return false;
   }
   return true;
  }

  public static class Builder {

   private final V2NIMSignallingCallParams params;
   public Builder(String calleeAccountId, String requestId, V2NIMSignallingChannelType channelType) {
    params = new V2NIMSignallingCallParams(calleeAccountId, requestId, channelType);
   }

   public Builder channelName(String channelName) {
    params.setChannelName(channelName);
    return this;
   }

   public Builder channelExtension(String channelExtension) {
    params.setChannelExtension(channelExtension);
    return this;
   }

   public Builder serverExtension(String serverExtension) {
    params.setServerExtension(serverExtension);
    return this;
   }

   public Builder signallingConfig(V2NIMSignallingConfig signallingConfig) {
    params.setSignallingConfig(signallingConfig);
    return this;
   }

   public Builder pushConfig(V2NIMSignallingPushConfig pushConfig) {
    params.setPushConfig(pushConfig);
    return this;
   }

   public Builder rtcConfig(V2NIMSignallingRtcConfig rtcConfig) {
    params.setRtcConfig(rtcConfig);
    return this;
   }

   public V2NIMSignallingCallParams build() {
    return params;
   }
  }
}

objective-c@interface V2NIMSignallingCallParams : NSObject
@property (nonatomic,copy) NSString *calleeAccountId;
@property (nonatomic,copy) NSString *requestId;
@property (nonatomic,assign) V2NIMSignallingChannelType channelType;
@property (nonatomic,copy,nullable) NSString *channelName;
@property (nonatomic,copy,nullable) NSString *channelExtension;
@property (nonatomic,copy,nullable) NSString *serverExtension;
@property (nonatomic,strong,nullable) V2NIMSignallingConfig *signallingConfig;
@property (nonatomic,strong,nullable) V2NIMSignallingPushConfig *pushConfig;
@property (nonatomic,strong,nullable) V2NIMSignallingRtcConfig *rtcConfig;
@end

cppstruct V2NIMSignallingCallParams {
    nstd::string calleeAccountId;
    nstd::string requestId;
    V2NIMSignallingChannelType channelType{V2NIM_SIGNALLING_CHANNEL_TYPE_UNKNOWN};
    nstd::optional<nstd::string> channelName;
    nstd::optional<nstd::string> channelExtension;
    nstd::optional<nstd::string> serverExtension;
    nstd::optional<V2NIMSignallingConfig> signallingConfig;
    nstd::optional<V2NIMSignallingPushConfig> pushConfig;
    nstd::optional<V2NIMSignallingRtcConfig> rtcConfig;
};

typescriptexport type V2NIMSignallingCallParams = {
  calleeAccountId: string
  requestId: string
  channelType: V2NIMSignallingChannelType
  channelName?: string
  channelExtension?: string
  serverExtension?: string
  signallingConfig?: V2NIMSignallingConfig
  pushConfig?: V2NIMSignallingPushConfig
  rtcConfig?: V2NIMSignallingRtcConfig
}

typescriptexport interface V2NIMSignallingCallParams {
  calleeAccountId: string
  requestId: string
  channelType: V2NIMSignallingChannelType
  channelName?: string
  channelExtension?: string
  serverExtension?: string
  signallingConfig?: V2NIMSignallingConfig
  pushConfig?: V2NIMSignallingPushConfig
  rtcConfig?: V2NIMSignallingRtcConfig
}

javapublic class V2NIMSignallingConfig {
  private boolean offlineEnabled = true;
  private boolean unreadEnabled  = true;
  private Long    selfUid;
  public V2NIMSignallingConfig() {
  }
  public V2NIMSignallingConfig(boolean offlineEnabled, boolean unreadEnabled, long selfUid) {
   this.offlineEnabled = offlineEnabled;
   this.unreadEnabled = unreadEnabled;
   this.selfUid = selfUid;
  }
  public boolean isOfflineEnabled() {
   return offlineEnabled;
  }
  public void setOfflineEnabled(boolean offlineEnabled) {
   this.offlineEnabled = offlineEnabled;
  }
  public boolean isUnreadEnabled() {
   return unreadEnabled;
  }
  public void setUnreadEnabled(boolean unreadEnabled) {
   this.unreadEnabled = unreadEnabled;
  }
  public Long getSelfUid() {
   return selfUid;
  }
  public void setSelfUid(Long selfUid) {
   this.selfUid = selfUid;
  }

  @NonNull
  @Override
  public String toString() {
   final StringBuilder sb = new StringBuilder("V2NIMSignallingConfig{");
   sb.append("offlineEnabled=").append(offlineEnabled);
   sb.append(", unreadEnabled=").append(unreadEnabled);
   sb.append(", selfUid=").append(selfUid);
   sb.append('}');
   return sb.toString();
  }
}

objective-c@interface V2NIMSignallingConfig : NSObject
@property (nonatomic,assign) BOOL offlineEnabled;
@property (nonatomic,assign) BOOL unreadEnabled;
@property (nonatomic,assign) NSInteger selfUid;
@end

cppstruct V2NIMSignallingConfig {
    nstd::optional<bool> offlineEnabled;
    nstd::optional<bool> unreadEnabled;
    nstd::optional<int64_t> selfUid;
};

typescriptexport type V2NIMSignallingConfig = {
  offlineEnabled?: boolean
  unreadEnabled?: boolean
  selfUid?: number
}

typescriptexport interface V2NIMSignallingConfig{
  offlineEnabled?: boolean
  unreadEnabled?: boolean
  selfUid?: number
}

javapublic class V2NIMSignallingPushConfig {
  private boolean pushEnabled = true;
  private String pushTitle;
  private String pushContent;
  private String pushPayload;

  public V2NIMSignallingPushConfig() {
  }

  public V2NIMSignallingPushConfig(boolean pushEnabled, String pushTitle, String pushContent, String pushPayload) {
   this.pushEnabled = pushEnabled;
   this.pushTitle = pushTitle;
   this.pushContent = pushContent;
   this.pushPayload = pushPayload;
  }

  public boolean isPushEnabled() {
   return pushEnabled;
  }

  public void setPushEnabled(boolean pushEnabled) {
   this.pushEnabled = pushEnabled;
  }

  public String getPushTitle() {
   return pushTitle;
  }

  public void setPushTitle(String pushTitle) {
   this.pushTitle = pushTitle;
  }

  public String getPushContent() {
   return pushContent;
  }

  public void setPushContent(String pushContent) {
   this.pushContent = pushContent;
  }

  public String getPushPayload() {
   return pushPayload;
  }

  public void setPushPayload(String pushPayload) {
   this.pushPayload = pushPayload;
  }

  @NonNull
  @Override
  public String toString() {
   if(NimLog.isDebuggable()){
    final StringBuilder sb = new StringBuilder("V2NIMSignallingPushConfig{");
    sb.append("pushEnabled=").append(pushEnabled);
    sb.append(", pushTitle='").append(pushTitle).append('\'');
    sb.append(", pushContent='").append(pushContent).append('\'');
    sb.append(", pushPayload='").append(pushPayload).append('\'');
    sb.append('}');
    return sb.toString();
   }else{
    return super.toString();
   }
  }
}

objective-c@interface V2NIMSignallingPushConfig : NSObject
@property (nonatomic,assign) BOOL pushEnabled;
@property (nonatomic,copy,nullable) NSString *pushTitle;
@property (nonatomic,copy,nullable) NSString *pushContent;
@property (nonatomic,copy,nullable) NSString *pushPayload;
@end

cppstruct V2NIMSignallingPushConfig {
    bool pushEnabled{false};
    nstd::optional<nstd::string> pushTitle;
    nstd::optional<nstd::string> pushContent;
    nstd::optional<nstd::string> pushPayload;
};

typescriptexport type V2NIMSignallingPushConfig = {
  pushEnabled?: boolean
  pushTitle?: string
  pushContent?: string
  pushPayload?: string
}

typescriptexport interface V2NIMSignallingPushConfig{
  pushEnabled?: boolean
  pushTitle?: string
  pushContent?: string
  pushPayload?: string
}

javapublic class V2NIMSignallingRtcConfig {

  private String rtcChannelName;
  private Long rtcTokenTtl;
  private String rtcParams;

  public V2NIMSignallingRtcConfig() {
  }

  public V2NIMSignallingRtcConfig(String rtcChannelName, Long rtcTokenTtl, String rtcParams) {
   this.rtcChannelName = rtcChannelName;
   this.rtcTokenTtl = rtcTokenTtl;
   this.rtcParams = rtcParams;
  }

  public String getRtcChannelName() {
   return rtcChannelName;
  }

  public void setRtcChannelName(String rtcChannelName) {
   this.rtcChannelName = rtcChannelName;
  }

  public Long getRtcTokenTtl() {
   return rtcTokenTtl;
  }

  public void setRtcTokenTtl(Long rtcTokenTtl) {
   this.rtcTokenTtl = rtcTokenTtl;
  }

  public String getRtcParams() {
   return rtcParams;
  }

  public void setRtcParams(String rtcParams) {
   this.rtcParams = rtcParams;
  }

  @NonNull
  @Override
  public String toString() {
   final StringBuilder sb = new StringBuilder("V2NIMSignallingRtcConfig{");
   if (NimLog.isDebuggable()){
    sb.append("rtcChannelName='").append(rtcChannelName).append('\'');
    sb.append(", rtcTokenTtl=").append(rtcTokenTtl);
    sb.append(", rtcParams='").append(rtcParams).append('\'');
   }else{
    sb.append("rtcChannelName='").append(rtcChannelName).append('\'');
    sb.append(", rtcTokenTtl=").append(rtcTokenTtl);
   }
   sb.append('}');
   return sb.toString();
  }
}

objective-c@interface V2NIMSignallingRtcConfig : NSObject
@property (nonatomic,copy,nullable) NSString *rtcChannelName;
@property (nonatomic,assign) long rtcTokenTtl;
@property (nonatomic,copy,nullable) NSString *rtcParams;
@end

cppstruct V2NIMSignallingRtcConfig {
    nstd::optional<nstd::string> rtcChannelName;
    nstd::optional<uint32_t> rtcTokenTtl;
    nstd::optional<nstd::string> rtcParams;
};

typescriptexport type V2NIMSignallingRtcConfig = {
  rtcChannelName?: string
  rtcTokenTtl?: number
  rtcParams?: string
}

typescriptexport interface V2NIMSignallingRtcConfig {
  rtcChannelName?: string
  rtcTokenTtl?: number
  rtcParams?: string
}

javapublic interface V2NIMSignallingCallResult {

  V2NIMSignallingRoomInfo getRoomInfo();
  V2NIMSignallingRtcInfo getRtcInfo();
  int getCallStatus();
}

objective-c@interface V2NIMSignallingCallResult : NSObject
@property (nonatomic,strong,readonly) V2NIMSignallingRoomInfo *roomInfo;
@property (nonatomic,strong,nullable,readonly) V2NIMSignallingRtcInfo *rtcInfo;
@property (nonatomic,assign,readonly) int callStatus;
@end

cppstruct V2NIMSignallingCallResult {
    V2NIMSignallingRoomInfo roomInfo;
    nstd::optional<V2NIMSignallingRtcInfo> rtcInfo;
    int32_t callStatus{0};
};

typescriptexport type V2NIMSignallingCallResult = {

  roomInfo: V2NIMSignallingRoomInfo
  rtcInfo?: V2NIMSignallingRtcInfo
  callStatus?: number
}

typescriptexport interface V2NIMSignallingCallResult {

  roomInfo: V2NIMSignallingRoomInfo
  rtcInfo?: V2NIMSignallingRtcInfo
  callStatus?: number
}

javapublic interface V2NIMSignallingChannelInfo {

  String getChannelName();
  String getChannelId();
  V2NIMSignallingChannelType getChannelType();
  String getChannelExtension();
  long getCreateTime();
  long getExpireTime();
  String getCreatorAccountId();
}

objective-c@interface V2NIMSignallingChannelInfo : NSObject
@property (nonatomic, copy, nullable, readonly) NSString *channelName;
@property (nonatomic, copy, readonly) NSString *channelId;
@property (nonatomic, assign, readonly) V2NIMSignallingChannelType channelType;
@property (nonatomic, copy, nullable) NSString *channelExtension;
@property (nonatomic, assign) NSTimeInterval createTime;
@property (nonatomic, assign) NSTimeInterval expireTime;
@property (nonatomic, copy) NSString *creatorAccountId;
@end

cppstruct V2NIMSignallingChannelInfo {
    nstd::string channelId;
    V2NIMSignallingChannelType channelType;
    nstd::optional<nstd::string> channelName;
    nstd::optional<nstd::string> channelExtension;
    time_t createTime{0};
    time_t expireTime{0};
    nstd::string creatorAccountId;
};

typescriptexport type V2NIMSignallingChannelInfo = {

  channelName?: string
  channelId: string
  channelType: V2NIMSignallingChannelType
  channelExtension?: string
  createTime: number
  expireTime: number
  creatorAccountId: string
}

typescriptexport interface V2NIMSignallingChannelInfo {

  channelName?: string
  channelId: string
  channelType: V2NIMSignallingChannelType
  channelExtension?: string
  createTime: number
  expireTime: number
  creatorAccountId: string
}

javapublic interface V2NIMSignallingRtcInfo {

  String getRtcToken();
  Long getRtcTokenTtl();
  String getRtcParams();
}

objective-c@interface V2NIMSignallingRtcInfo : NSObject

@property (nonatomic, copy, nullable) NSString *rtcToken;
@property (nonatomic, assign) long rtcTokenTtl;
@property (nonatomic, copy, nullable) NSString *rtcParams;
@end

cppstruct V2NIMSignallingRtcInfo {
    nstd::optional<nstd::string> rtcToken;
    nstd::optional<uint32_t> rtcTokenTtl;
    nstd::optional<nstd::string> rtcParams;
};

typescriptexport type V2NIMSignallingRtcInfo = {

  rtcToken?: string
  rtcTokenTtl?: number
  rtcParams?: string
}

typescriptexport interface V2NIMSignallingRtcInfo {

  rtcToken?: string
  rtcTokenTtl?: number
  rtcParams?: string,
}

javapublic class V2NIMSignallingCallSetupParams {
  private static final String TAG = "V2NIMSignallingCallSetupParams";
  private final String channelId;
  private final String callerAccountId;
  private final String requestId;
  private String serverExtension;
  private V2NIMSignallingConfig signallingConfig;
  private V2NIMSignallingRtcConfig rtcConfig;

  private V2NIMSignallingCallSetupParams() {
   this(null, null, null);
  }

  public V2NIMSignallingCallSetupParams(String channelId, String callerAccountId, String requestId) {
   this.channelId = channelId;
   this.callerAccountId = callerAccountId;
   this.requestId = requestId;
  }

  public String getChannelId() {
   return channelId;
  }

  public String getCallerAccountId() {
   return callerAccountId;
  }

  public String getRequestId() {
   return requestId;
  }

  public String getServerExtension() {
   return serverExtension;
  }

  public void setServerExtension(String serverExtension) {
   this.serverExtension = serverExtension;
  }

  public V2NIMSignallingConfig getSignallingConfig() {
   return signallingConfig;
  }

  public void setSignallingConfig(V2NIMSignallingConfig signallingConfig) {
   this.signallingConfig = signallingConfig;
  }

  public V2NIMSignallingRtcConfig getRtcConfig() {
   return rtcConfig;
  }

  public void setRtcConfig(V2NIMSignallingRtcConfig rtcConfig) {
   this.rtcConfig = rtcConfig;
  }

  public boolean isValid() {
   if (TextUtils.isEmpty(channelId)){
    NimLog.e(TAG, "channelId is empty");
    return false;
   }
   if (TextUtils.isEmpty(callerAccountId)){
    NimLog.e(TAG, "callerAccountId is empty");
    return false;
   }
   if(callerAccountId.equals(SDKCacheUI.getAccount())){
    NimLog.e(TAG, "callerAccountId is equal to self account");
    return false;
   }
   if (TextUtils.isEmpty(requestId)){
    NimLog.e(TAG, "requestId is empty");
    return false;
   }
   return true;
  }

  public static class Builder {

   private final String channelId;
   private final String callerAccountId;
   private final String requestId;
   private String serverExtension;
   private V2NIMSignallingConfig signallingConfig;
   private V2NIMSignallingRtcConfig rtcConfig;

   public Builder(String channelId, String callerAccountId, String requestId) {
    this.channelId = channelId;
    this.callerAccountId = callerAccountId;
    this.requestId = requestId;
   }

   public Builder serverExtension(String serverExtension) {
    this.serverExtension = serverExtension;
    return this;
   }

   public Builder signallingConfig(V2NIMSignallingConfig signallingConfig) {
    this.signallingConfig = signallingConfig;
    return this;
   }

   public Builder rtcConfig(V2NIMSignallingRtcConfig rtcConfig) {
    this.rtcConfig = rtcConfig;
    return this;
   }

   public V2NIMSignallingCallSetupParams build() {
    V2NIMSignallingCallSetupParams params = new V2NIMSignallingCallSetupParams(channelId, callerAccountId, requestId);
    params.setServerExtension(serverExtension);
    params.setSignallingConfig(signallingConfig);
    params.setRtcConfig(rtcConfig);
    return params;
   }
  }
}

objective-c@interface V2NIMSignallingCallSetupParams : NSObject
@property (nonatomic, copy) NSString *channelId;
@property (nonatomic, copy) NSString *callerAccountId;
@property (nonatomic, copy) NSString *requestId;
@property (nonatomic, copy, nullable) NSString *serverExtension;
@property (nonatomic, strong, nullable) V2NIMSignallingConfig *signallingConfig;
@property (nonatomic, strong, nullable) V2NIMSignallingRtcConfig *rtcConfig;
@end

cppstruct V2NIMSignallingCallSetupParams {
    nstd::string channelId;
    nstd::string callerAccountId;
    nstd::string requestId;
    nstd::optional<nstd::string> serverExtension;
    nstd::optional<V2NIMSignallingConfig> signallingConfig;
    nstd::optional<V2NIMSignallingRtcConfig> rtcConfig;
};

typescriptexport type V2NIMSignallingCallSetupParams = {

  channelId: string
  callerAccountId: string
  requestId: string
  serverExtension?: string
  signallingConfig?: V2NIMSignallingConfig
  rtcConfig?: V2NIMSignallingRtcConfig
}

typescriptexport interface V2NIMSignallingCallSetupParams {

  channelId: string
  callerAccountId: string
  requestId: string
  serverExtension?: string
  signallingConfig?: V2NIMSignallingConfig
  rtcConfig?: V2NIMSignallingRtcConfig
}

javapublic interface V2NIMSignallingCallSetupResult {

    V2NIMSignallingRoomInfo getRoomInfo();
    V2NIMSignallingRtcInfo getRtcInfo();
    int getCallStatus();
}

objective-c@interface V2NIMSignallingCallSetupResult : NSObject
@property (nonatomic, strong, readonly) V2NIMSignallingRoomInfo *roomInfo;
@property (nonatomic, strong, readonly, nullable) V2NIMSignallingRtcInfo *rtcInfo;
@property (nonatomic, assign, readonly) int callStatus;
@end

cppstruct V2NIMSignallingCallSetupResult {
    V2NIMSignallingRoomInfo roomInfo;
    nstd::optional<V2NIMSignallingRtcInfo> rtcInfo;
    nstd::optional<uint32_t> callStatus;
};

typescriptexport type V2NIMSignallingCallSetupResult = {

  roomInfo: V2NIMSignallingRoomInfo
  rtcInfo?: V2NIMSignallingRtcInfo
  callStatus?: number
}

typescriptexport interface V2NIMSignallingCallSetupResult {

  roomInfo: V2NIMSignallingRoomInfo
  rtcInfo?: V2NIMSignallingRtcInfo
  callStatus?: number
}

javapublic interface V2NIMSignallingMember {

  String getAccountId();
  long getUid();
  long getJoinTime();
  long getExpireTime();
  String getDeviceId();
}

objective-c@interface V2NIMSignallingMember : NSObject
@property (nonatomic, copy, readonly) NSString *accountId;
@property (nonatomic, assign, readonly) long uid;
@property (nonatomic, assign, readonly) NSTimeInterval joinTime;
@property (nonatomic, assign, readonly) NSTimeInterval expireTime;
@property (nonatomic, copy, readonly) NSString *deviceId;
@end

cppstruct V2NIMSignallingMember {
    nstd::string accountId;
    int64_t uid{0};
    time_t joinTime{0};
    time_t expireTime{0};
    nstd::string deviceId;
};

typescriptexport type V2NIMSignallingMember = {

  accountId: string
  uid: number
  joinTime: number
  expireTime: number
  deviceId: string
}

typescriptexport interface V2NIMSignallingMember {

  accountId: string
  uid: number
  joinTime: number
  expireTime: number
  deviceId: string
}

javapublic interface V2NIMSignallingRoomInfo {

  V2NIMSignallingChannelInfo getChannelInfo();
  List<V2NIMSignallingMember> getMembers();
}

objective-c@interface V2NIMSignallingRoomInfo : NSObject
@property (nonatomic, strong, readonly) V2NIMSignallingChannelInfo *channelInfo;
@property (nonatomic, strong, readonly) NSArray<V2NIMSignallingMember *> *members;
@end

cppstruct V2NIMSignallingRoomInfo {
    V2NIMSignallingChannelInfo channelInfo;
    nstd::vector<V2NIMSignallingMember> members;
};

typescriptexport type V2NIMSignallingRoomInfo = {

  channelInfo: V2NIMSignallingChannelInfo
  members: V2NIMSignallingMember[]
}

typescriptexport interface V2NIMSignallingRoomInfo {

  channelInfo: V2NIMSignallingChannelInfo
  members: V2NIMSignallingMember[]
}

javapublic class V2NIMSignallingJoinParams {
  private static final String TAG = "V2NIMSignallingJoinParams";
  private final String channelId;
  private String serverExtension;
  private V2NIMSignallingConfig signallingConfig;
  private V2NIMSignallingRtcConfig rtcConfig;

  private V2NIMSignallingJoinParams() {
   this(null);
  }

  public V2NIMSignallingJoinParams(String channelId) {
   this.channelId = channelId;
  }

  public String getChannelId() {
   return channelId;
  }

  public String getServerExtension() {
   return serverExtension;
  }

  public void setServerExtension(String serverExtension) {
   this.serverExtension = serverExtension;
  }

  public V2NIMSignallingConfig getSignallingConfig() {
   return signallingConfig;
  }

  public void setSignallingConfig(V2NIMSignallingConfig signallingConfig) {
   this.signallingConfig = signallingConfig;
  }

  public V2NIMSignallingRtcConfig getRtcConfig() {
   return rtcConfig;
  }

  public void setRtcConfig(V2NIMSignallingRtcConfig rtcConfig) {
   this.rtcConfig = rtcConfig;
  }

  public boolean isValid() {
   if(TextUtils.isEmpty(channelId)){
    NimLog.e(TAG,"channelId is invalid");
    return false;
   }
   return true;
  }

  public static class Builder {
   private final V2NIMSignallingJoinParams params;

   public Builder(String channelId) {
    params = new V2NIMSignallingJoinParams(channelId);
   }

   public Builder serverExtension(String serverExtension) {
    params.setServerExtension(serverExtension);
    return this;
   }

   public Builder signallingConfig(V2NIMSignallingConfig signallingConfig) {
    params.setSignallingConfig(signallingConfig);
    return this;
   }

   public Builder rtcConfig(V2NIMSignallingRtcConfig rtcConfig) {
    params.setRtcConfig(rtcConfig);
    return this;
  }

   public V2NIMSignallingJoinParams build() {
    return params;
   }
  }
}

objective-c@interface V2NIMSignallingJoinParams : NSObject
@property (nonatomic, copy) NSString *channelId;
@property (nonatomic, copy, nullable) NSString *serverExtension;
@property (nonatomic, strong, nullable) V2NIMSignallingConfig *signallingConfig;
@property (nonatomic, strong, nullable) V2NIMSignallingRtcConfig *rtcConfig;
@end

cppstruct V2NIMSignallingJoinParams {
    nstd::string channelId;
    nstd::optional<nstd::string> serverExtension;
    nstd::optional<V2NIMSignallingConfig> signallingConfig;
    nstd::optional<V2NIMSignallingRtcConfig> rtcConfig;
};

typescriptexport type V2NIMSignallingJoinParams = {

  channelId: string
  serverExtension?: string
  signallingConfig?: V2NIMSignallingConfig
  rtcConfig?: V2NIMSignallingRtcConfig
}

typescriptexport interface  V2NIMSignallingJoinParams {

  channelId: string
  serverExtension?: string
  signallingConfig?: V2NIMSignallingConfig
  rtcConfig?: V2NIMSignallingRtcConfig
}

javapublic class V2NIMSignallingInviteParams {
  private static final String TAG = "V2NIMSignallingInviteParams";
  private final String channelId;
  private final String inviteeAccountId;
  private final String requestId;
  private String serverExtension;
  private V2NIMSignallingConfig signallingConfig;
  private V2NIMSignallingPushConfig pushConfig;
  private V2NIMSignallingInviteParams() {
   this(null, null, null);
  }

  public V2NIMSignallingInviteParams(String channelId, String inviteeAccountId, String requestId) {
   this.channelId = channelId;
   this.inviteeAccountId = inviteeAccountId;
   this.requestId = requestId;

  }

  public String getChannelId() {
   return channelId;
  }

  public String getInviteeAccountId() {
   return inviteeAccountId;
  }

  public String getRequestId() {
   return requestId;
  }

  public String getServerExtension() {
   return serverExtension;
  }

  public void setServerExtension(String serverExtension) {
   this.serverExtension = serverExtension;
  }

  public V2NIMSignallingConfig getSignallingConfig() {
   return signallingConfig;
  }

  public void setSignallingConfig(V2NIMSignallingConfig signallingConfig) {
   this.signallingConfig = signallingConfig;
  }

  public V2NIMSignallingPushConfig getPushConfig() {
   return pushConfig;
  }

  public void setPushConfig(V2NIMSignallingPushConfig pushConfig) {
   this.pushConfig = pushConfig;
  }

  public boolean isValid() {
   if(TextUtils.isEmpty(channelId)){
    NimLog.e(TAG,"channelId is invalid");
    return false;
   }
   if(TextUtils.isEmpty(inviteeAccountId)){
    NimLog.e(TAG,"inviterAccountId is invalid");
    return false;
   }
   if(Objects.equals(inviteeAccountId, SDKCacheUI.getAccount())){
    NimLog.e(TAG,"inviterAccountId can not be self account");
    return false;
   }
   if(TextUtils.isEmpty(requestId)){
    NimLog.e(TAG,"requestId is invalid");
    return false;
   }
   return true;
  }

  public static class Builder {
   private final V2NIMSignallingInviteParams params;

   public Builder(String channelId, String inviteeAccountId, String requestId) {
    params = new V2NIMSignallingInviteParams(channelId, inviteeAccountId, requestId);
   }

   public Builder serverExtension(String serverExtension) {
    params.setServerExtension(serverExtension);
    return this;
   }

   public Builder signallingConfig(V2NIMSignallingConfig signallingConfig) {
    params.setSignallingConfig(signallingConfig);
    return this;
   }

   public Builder pushConfig(V2NIMSignallingPushConfig pushConfig) {
    params.setPushConfig(pushConfig);
    return this;
   }

   public V2NIMSignallingInviteParams build() {
    return params;
   }
  }
}

objective-c@interface V2NIMSignallingInviteParams : NSObject
@property (nonatomic, copy) NSString *channelId;
@property (nonatomic, copy) NSString *inviteeAccountId;
@property (nonatomic, copy) NSString *requestId;
@property (nonatomic, copy,nullable) NSString *serverExtension;
@property (nonatomic, strong,nullable) V2NIMSignallingConfig *signallingConfig;
@property (nonatomic, strong,nullable) V2NIMSignallingPushConfig *pushConfig;
@end

cppstruct V2NIMSignallingInviteParams {
    nstd::string channelId;
    nstd::string inviteeAccountId;
    nstd::string requestId;
    nstd::optional<nstd::string> serverExtension;
    nstd::optional<V2NIMSignallingConfig> signallingConfig;
    nstd::optional<V2NIMSignallingPushConfig> pushConfig;
};

typescriptexport type V2NIMSignallingInviteParams = {

  channelId: string
  inviteeAccountId: string
  requestId: string
  serverExtension?: string
  signallingConfig?: V2NIMSignallingConfig
  pushConfig?: V2NIMSignallingPushConfig
}

typescriptexport interface V2NIMSignallingInviteParams {

  channelId: string
  inviteeAccountId: string
  requestId: string
  serverExtension?: string
  signallingConfig?: V2NIMSignallingConfig
  pushConfig?: V2NIMSignallingPushConfig
}

javapublic class V2NIMSignallingCancelInviteParams {
  private static final String TAG = "V2NIMSignallingCancelInviteParams";
  private final String channelId;
  private final String inviteeAccountId;
  private final String requestId;
  private String serverExtension;
  private boolean offlineEnabled = true;

  private V2NIMSignallingCancelInviteParams() {
   this(null, null, null);
  }

  public V2NIMSignallingCancelInviteParams(String channelId, String inviteeAccountId, String requestId) {
   this.channelId = channelId;
   this.inviteeAccountId = inviteeAccountId;
   this.requestId = requestId;
  }

  public String getChannelId() {
   return channelId;
  }

  public String getInviteeAccountId() {
   return inviteeAccountId;
  }

  public String getRequestId() {
   return requestId;
  }

  public String getServerExtension() {
   return serverExtension;
  }

  public void setServerExtension(String serverExtension) {
   this.serverExtension = serverExtension;
  }

  public boolean isOfflineEnabled() {
   return offlineEnabled;
  }

  public void setOfflineEnabled(boolean offlineEnabled) {
   this.offlineEnabled = offlineEnabled;
  }

  public boolean isValid(){
   if(TextUtils.isEmpty(channelId)){
    NimLog.e(TAG,"channelId is invalid");
    return false;
   }
   if(TextUtils.isEmpty(inviteeAccountId)){
    NimLog.e(TAG,"inviterAccountId is invalid");
    return false;
   }
   if(Objects.equals(inviteeAccountId, SDKCacheUI.getAccount())){
    NimLog.e(TAG,"inviterAccountId can not be self account");
    return false;
   }
   if(TextUtils.isEmpty(requestId)){
    NimLog.e(TAG,"requestId is invalid");
    return false;
   }
   return true;
  }

  public static class Builder {
   private final V2NIMSignallingCancelInviteParams params;

   public Builder(String channelId, String inviteeAccountId, String requestId) {
    params = new V2NIMSignallingCancelInviteParams(channelId, inviteeAccountId, requestId);
   }

   public Builder serverExtension(String serverExtension) {
    params.setServerExtension(serverExtension);
    return this;
   }

   public Builder offlineEnabled(boolean offlineEnabled) {
    params.setOfflineEnabled(offlineEnabled);
    return this;
   }

   public V2NIMSignallingCancelInviteParams build() {
    return params;
   }
  }
}

objective-c@interface V2NIMSignallingCancelInviteParams : NSObject
@property (nonatomic, copy) NSString *channelId;
@property (nonatomic, copy) NSString *inviteeAccountId;
@property (nonatomic, copy) NSString *requestId;
@property (nonatomic, copy, nullable) NSString *serverExtension;
@property (nonatomic, assign) BOOL offlineEnabled;
@end

cppstruct V2NIMSignallingCancelInviteParams {
    nstd::string channelId;
    nstd::string inviteeAccountId;
    nstd::string requestId;
    nstd::optional<nstd::string> serverExtension;
    nstd::optional<bool> offlineEnabled;
};

typescriptexport type V2NIMSignallingCancelInviteParams = {

  channelId: string
  inviteeAccountId: string
  requestId: string
  serverExtension?: string
  offlineEnabled?: boolean
}

typescriptexport interface V2NIMSignallingCancelInviteParams {

  channelId: string
  inviteeAccountId: string
  requestId: string
  serverExtension?: string
  offlineEnabled?: boolean
}

javapublic class V2NIMSignallingRejectInviteParams {
  private static final String TAG = "V2NIMSignallingRejectInviteParams";
  private final String channelId;
  private final String inviterAccountId;
  private final String requestId;
  private String serverExtension;
  private boolean offlineEnabled = true;

  private V2NIMSignallingRejectInviteParams() {
   this(null, null, null);
  }

  public V2NIMSignallingRejectInviteParams(String channelId, String inviterAccountId, String requestId) {
   this.channelId = channelId;
   this.inviterAccountId = inviterAccountId;
   this.requestId = requestId;
  }

  public String getChannelId() {
   return channelId;
  }

  public String getInviterAccountId() {
   return inviterAccountId;
  }

  public String getRequestId() {
   return requestId;
  }

  public String getServerExtension() {
   return serverExtension;
  }

  public void setServerExtension(String serverExtension) {
   this.serverExtension = serverExtension;
  }

  public boolean isOfflineEnabled() {
   return offlineEnabled;
  }

  public void setOfflineEnabled(boolean offlineEnabled) {
   this.offlineEnabled = offlineEnabled;
  }

  public boolean isValid(){
   if(TextUtils.isEmpty(channelId)){
    NimLog.e(TAG,"channelId is invalid");
    return false;
   }
   if(TextUtils.isEmpty(inviterAccountId)){
    NimLog.e(TAG,"inviterAccountId is invalid");
    return false;
   }
   if(Objects.equals(inviterAccountId, SDKCacheUI.getAccount())){
    NimLog.e(TAG,"inviterAccountId can not be self account");
    return false;
   }
   if(TextUtils.isEmpty(requestId)){
    NimLog.e(TAG,"requestId is invalid");
    return false;
   }
   return true;
  }

  public static class Builder {
   private final V2NIMSignallingRejectInviteParams params;

   public Builder(String channelId, String inviterAccountId, String requestId) {
    params = new V2NIMSignallingRejectInviteParams(channelId, inviterAccountId, requestId);
   }

   public Builder serverExtension(String serverExtension) {
    params.setServerExtension(serverExtension);
    return this;
   }

   public Builder offlineEnabled(boolean offlineEnabled) {
    params.setOfflineEnabled(offlineEnabled);
    return this;
   }

   public V2NIMSignallingRejectInviteParams build() {
    return params;
   }
  }
}

objective-c@interface V2NIMSignallingRejectInviteParams : NSObject

@property (nonatomic, copy) NSString *channelId;
@property (nonatomic, copy) NSString *inviterAccountId;
@property (nonatomic, copy) NSString *requestId;
@property (nonatomic, copy, nullable) NSString *serverExtension;
@property (nonatomic, assign) BOOL offlineEnabled;
@end

cppstruct V2NIMSignallingRejectInviteParams {
    nstd::string channelId;
    nstd::string inviterAccountId;
    nstd::string requestId;
    nstd::optional<nstd::string> serverExtension;
    nstd::optional<bool> offlineEnabled;
};