Javavoid addTeamListener(V2NIMTeamListener listener);

Objective-C- (void)addTeamListener:(id<V2NIMTeamListener>)listener;

C++virtual void addTeamListener(V2NIMTeamListener listener) = 0;

JavaV2NIMTeamService v2TeamService = NIMClient.getService(V2NIMTeamService.class);
V2NIMTeamListener listener = new V2NIMTeamListener() {
    @Override
    public void onSyncStarted() {
        // 开始同步群组信息
    }

    @Override
    public void onSyncFinished() {
        // 同步群组信息完成
    }

    @Override
    public void onSyncFailed(V2NIMError error) {
        // 同步群组信息失败
    }

    @Override
    public void onTeamCreated(V2NIMTeam team) {
        // 创建群组成功
    }

    @Override
    public void onTeamDismissed(V2NIMTeam team) {
        // 解散群组成功
    }

    @Override
    public void onTeamJoined(V2NIMTeam team) {
        // 加入群组成功
    }

    @Override
    public void onTeamLeft(V2NIMTeam team, boolean isKicked) {
        // 离开群组成功
    }

    @Override
    public void onTeamInfoUpdated(V2NIMTeam team) {
        // 群组信息更新回调
    }

    @Override
    public void onTeamMemberJoined(List<V2NIMTeamMember> teamMembers) {
        // 群组成员加入回调
    }

    @Override
    public void onTeamMemberKicked(String operatorAccountId, List<V2NIMTeamMember> teamMembers) {
        // 群组成员被踢回调
    }

    @Override
    public void onTeamMemberLeft(List<V2NIMTeamMember> teamMembers) {
        // 群组成员退出群组回调
    }

    @Override
    public void onTeamMemberInfoUpdated(List<V2NIMTeamMember> teamMembers) {
        // 群组成员信息更新回调
    }

    @Override
    public void onReceiveTeamJoinActionInfo(V2NIMTeamJoinActionInfo joinActionInfo) {
        // 入群操作回调
    }
};
v2TeamService.addTeamListener(listener);

Objective-C[[[NIMSDK sharedSDK] v2TeamService] addTeamListener:self];
- (void)onSyncStarted{};

/**
 * 同步完成
 */
- (void)onSyncFinished{};

/**
 * 同步失败
 *
 * @param error 错误
 */
- (void)onSyncFailed:(V2NIMError *)error{};

/**
 * 群组创建回调
 *
 * @param team 新创建的群组
 */
- (void)onTeamCreated:(V2NIMTeam *)team{};

/**
 * 群组解散回调
 *
 * @param team 解散的群组
 *
 * @discussion 仅 teamId 和 teamType 字段有效
 */
- (void)onTeamDismissed:(V2NIMTeam *)team{};

/**
 * 加入群组回调
 *
 * @param team 加入的群组
 */
- (void)onTeamJoined:(V2NIMTeam *)team{};

/**
 * 离开群组回调
 *
 * @param team 离开的群组
 * @param isKicked 是否被踢出群组
 *
 * @discussion 主动离开群组或被管理员踢出群组
 */
- (void)onTeamLeft:(V2NIMTeam *)team
          isKicked:(BOOL)isKicked{};

/**
 * 群组信息更新回调
 *
 * @param team 更新信息群组
 */
- (void)onTeamInfoUpdated:(V2NIMTeam *)team{};

/**
 * 群组成员加入回调
 *
 * @param teamMembers 加入的群组成员列表
 */
- (void)onTeamMemberJoined:(NSArray<V2NIMTeamMember *> *)teamMembers{};

/**
 * 群组成员被踢回调
 *
 * @param operatorAccountId 操作账号 ID
 * @param teamMembers teamMembers 的群组成员列表
 */
- (void)onTeamMemberKicked:(NSString *)operatorAccountId
               teamMembers:(NSArray<V2NIMTeamMember *> *)teamMembers{};

/**
 * 群组成员退出回调
 *
 * @param teamMembers 退出的群组成员列表
 */
- (void)onTeamMemberLeft:(NSArray<V2NIMTeamMember *> *)teamMembers{};

/**
 * 群组成员信息变更回调
 *
 * @param teamMembers 信息变更的群组成员列表
 */
- (void)onTeamMemberInfoUpdated:(NSArray<V2NIMTeamMember *> *)teamMembers{};

/**
 * 入群操作回调
 *
 * @param joinActionInfo 入群操作信息
 */
- (void)onReceiveTeamJoinActionInfo:(V2NIMTeamJoinActionInfo *)joinActionInfo{};

C++V2NIMTeamListener listener;
listener.onSyncStarted = []() {
    // team sync started
};
listener.onSyncFinished = []() {
    // team sync finished
};
listener.onSyncFailed = [](V2NIMError error) {
    // team sync failed, handle error
};
listener.onTeamCreated = [](V2NIMTeam team) {
    // team created
};
listener.onTeamDismissed = [](nstd::vector<V2NIMTeam> teams) {
    // team dismissed
};
listener.onTeamJoined = [](V2NIMTeam team) {
    // team joined
};
listener.onTeamLeft = [](V2NIMTeam team, bool isKicked) {
    // team left
};
listener.onTeamInfoUpdated = [](V2NIMTeam team) {
    // team info updated
};
listener.onTeamMemberJoined = [](nstd::vector<V2NIMTeamMember> teamMembers) {
    // team member joined
};
listener.onTeamMemberKicked = [](nstd::string operateAccountId, nstd::vector<V2NIMTeamMember> teamMembers) {
    team member kicked
};
listener.onTeamMemberLeft = [](nstd::vector<V2NIMTeamMember> teamMembers) {
    // team member left
};
listener.onTeamMemberInfoUpdated = [](nstd::vector<V2NIMTeamMember> teamMembers) {
    // team member info updated
};
listener.onReceiveTeamJoinActionInfo = [](V2NIMTeamJoinActionInfo joinActionInfo) {
    // receive team join action info
};
teamService.addTeamListener(listener);

Javavoid removeTeamListener(V2NIMTeamListener listener);

Objective-C- (void)removeTeamListener:(id<V2NIMTeamListener>)listener;

C++virtual void removeTeamListener(V2NIMTeamListener listener) = 0;

JavaV2NIMTeamService v2TeamService = NIMClient.getService(V2NIMTeamService.class);
v2TeamService.removeTeamListener(listener);

Objective-C[[[NIMSDK sharedSDK] v2TeamService] removeTeamListener:self];

C++V2NIMTeamListener listener;
// ...
teamService.removeTeamListener(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
}

TypeScriptnim.V2NIMTeamService.on('onSyncStarted', () => { console.log("recv onSyncStarted") })
nim.V2NIMTeamService.on('onSyncFinished', () => { console.log("recv onSyncFinished") })
nim.V2NIMTeamService.on('onSyncFailed', (error) => { console.log("recv onSyncFailed", error) })
nim.V2NIMTeamService.on('onTeamCreated', (team) => { console.log("recv onTeamCreated", team) })
nim.V2NIMTeamService.on('onTeamJoined', (team) => { console.log("recv onTeamJoined", team) })
nim.V2NIMTeamService.on('onTeamLeft', (team, isKicked) => { console.log("recv onTeamLeft", team, isKicked) })
nim.V2NIMTeamService.on('onTeamInfoUpdated', (team) => { console.log("recv onTeamInfoUpdated", team) })
nim.V2NIMTeamService.on('onTeamMemberJoined', (teamMembers) => { console.log("recv onTeamMemberJoined", teamMembers) })
nim.V2NIMTeamService.on('onTeamMemberKicked', (operateAccountId, teamMembers) => { console.log("recv onTeamMemberKicked", operateAccountId, teamMembers) })
nim.V2NIMTeamService.on('onTeamMemberLeft', (teamMembers) => { console.log("recv onTeamMemberLeft", teamMembers) })
nim.V2NIMTeamService.on('onTeamMemberInfoUpdated', (teamMembers) => { console.log("recv onTeamMemberInfoUpdated", teamMembers) })
nim.V2NIMTeamService.on('onReceiveTeamJoinActionInfo', (joinActionInfo) => { console.log("recv onReceiveTeamJoinActionInfo", joinActionInfo) })

TypeScriptnim.teamService.on('onSyncStarted', () => { console.log("recv onSyncStarted") })
nim.teamService.on('onSyncFinished', () => { console.log("recv onSyncFinished") })
nim.teamService.on('onSyncFailed', (error) => { console.log("recv onSyncFailed", error) })
nim.teamService.on('onTeamCreated', (team) => { console.log("recv onTeamCreated", team) })
nim.teamService.on('onTeamDismissed', (team) => { console.log("recv onTeamDismissed", team) })
nim.teamService.on('onTeamJoined', (team) => { console.log("recv onTeamJoined", team) })
nim.teamService.on('onTeamLeft', (team, isKicked) => { console.log("recv onTeamLeft", team, isKicked) })
nim.teamService.on('onTeamInfoUpdated', (team) => { console.log("recv onTeamInfoUpdated", team) })
nim.teamService.on('onTeamMemberJoined', (teamMembers) => { console.log("recv onTeamMemberJoined", teamMembers) })
nim.teamService.on('onTeamMemberKicked', (operateAccountId, teamMembers) => { console.log("recv onTeamMemberKicked", operateAccountId, teamMembers) })
nim.teamService.on('onTeamMemberLeft', (teamMembers) => { console.log("recv onTeamMemberLeft", teamMembers) })
nim.teamService.on('onTeamMemberInfoUpdated', (teamMembers) => { console.log("recv onTeamMemberInfoUpdated", teamMembers) })
nim.teamService.on('onReceiveTeamJoinActionInfo', (joinActionInfo) => { console.log("recv onReceiveTeamJoinActionInfo", joinActionInfo) })

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
}

TypeScript// remove one listeners
nim.V2NIMTeamService.off("onSyncStarted")
// remove all listeners
nim.V2NIMTeamService.removeAllListeners()

TypeScript// remove one listeners
nim.teamService.off('onSyncStarted', theListner)
nim.teamService.off('onSyncFinished', theListner)
nim.teamService.off('onSyncFailed', theListner)
nim.teamService.off('onTeamCreated', theListner)
nim.teamService.off('onTeamDismissed', theListner)
nim.teamService.off('onTeamJoined', theListner)
nim.teamService.off('onTeamLeft', theListner)
nim.teamService.off('onTeamInfoUpdated', theListner)
nim.teamService.off('onTeamMemberJoined', theListner)
nim.teamService.off('onTeamMemberKicked', theListner)
nim.teamService.off('onTeamMemberLeft', theListner)
nim.teamService.off('onTeamMemberInfoUpdated', theListner})
nim.teamService.off('onReceiveTeamJoinActionInfo', theListner)
// remove all listeners
nim.teamService.removeAllListeners()

Javavoid createTeam(V2NIMCreateTeamParams createTeamParams, List<String> inviteeAccountIds, String postscript, V2NIMAntispamConfig antispamConfig, V2NIMSuccessCallback<V2NIMCreateTeamResult> success, V2NIMFailureCallback failure);

Objective-C- (void)createTeam:(V2NIMCreateTeamParams *)createTeamParams
 inviteeAccountIds:(nullable NSArray<NSString *> *)inviteeAccountIds
        postscript:(nullable NSString *)postscript
    antispamConfig:(nullable V2NIMAntispamConfig *)antispamConfig
           success:(nullable V2NIMCreateTeamResultCallback)success
           failure:(nullable V2NIMFailureCallback)failure;

C++virtual void createTeam(V2NIMCreateTeamParams createTeamParams,
                        std::vector<std::string> inviteeAccountIds,
                        std::string postscript,
                        V2NIMAntispamConfig antispamConfig,
                        V2NIMSuccessCallback<V2NIMCreateTeamResult> success,
                        V2NIMFailureCallback failure) = 0;

TypeScriptcreateTeam(
  createTeamParams: V2NIMCreateTeamParams,
  inviteeAccountIds?: string[],
  postscript?: string,
  antispamConfig?: V2NIMAntispamConfig
): Promise<V2NIMCreateTeamResult>

TypeScriptcreateTeam(
  createTeamParams: V2NIMCreateTeamParams,
  inviteeAccountIds?: string[],
  postscript?: string,
  antispamConfig?: V2NIMAntispamConfig
): Promise<V2NIMCreateTeamResult>

JavaV2NIMTeamService v2TeamService = NIMClient.getService(V2NIMTeamService.class);
// 创建群组参数
V2NIMCreateTeamParams createTeamParams = new V2NIMCreateTeamParams();
createTeamParams.setName("test");
createTeamParams.setTeamType(V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL);
createTeamParams.setMemberLimit(100);
createTeamParams.setIntro("test");
createTeamParams.setAnnouncement("test");
createTeamParams.setAvatar("http://test.png");
createTeamParams.setServerExtension("test");
createTeamParams.setAgreeMode(V2NIMTeamAgreeMode.V2NIM_TEAM_AGREE_MODE_AUTH);
createTeamParams.setJoinMode(V2NIMTeamJoinMode.V2NIM_TEAM_JOIN_MODE_INVITE);
createTeamParams.setInviteMode(V2NIMTeamInviteMode.V2NIM_TEAM_INVITE_MODE_MANAGER);
createTeamParams.setUpdateInfoMode(V2NIMTeamUpdateInfoMode.V2NIM_TEAM_UPDATE_INFO_MODE_MANAGER);
createTeamParams.setUpdateExtensionMode(V2NIMTeamUpdateExtensionMode.V2NIM_TEAM_UPDATE_EXTENSION_MODE_MANAGER);
// 创建群组时，同时被邀请加入群的成员列表
List<String> inviteeAccountIds = new ArrayList<>();
inviteeAccountIds.add("test1");
inviteeAccountIds.add("test2");
String postscript = "test";
// 易盾反垃圾配置，如果不审核，该配置不需要配置。如果开启了安全通，默认采用安全通，该配置不需要配置。如果需要审核，且直接对接易盾，则配置该配置
V2NIMAntispamConfig antispamConfig = null;
v2TeamService.createTeam(createTeamParams, inviteeAccountIds, postscript, antispamConfig, result -> {
    // 创建群组成功
}, error -> {
    // 创建群组失败
});

Objective-CV2NIMCreateTeamParams *teamParams = [V2NIMCreateTeamParams new];
    teamParams.name = @"test";
    teamParams.teamType = V2NIM_TEAM_TYPE_NORMAL;
    teamParams.memberLimit = 100;
    teamParams.intro = @"test";
    teamParams.announcement = @"test";
    teamParams.avatar = @"http://test.png";
    teamParams.agreeMode = V2NIM_TEAM_AGREE_MODE_AUTH;
    teamParams.joinMode = V2NIM_TEAM_JOIN_MODE_FREE;
    teamParams.inviteMode = V2NIM_TEAM_INVITE_MODE_MANAGER;
    teamParams.updateInfoMode = V2NIM_TEAM_UPDATE_INFO_MODE_MANAGER;
    teamParams.updateExtensionMode = V2NIM_TEAM_UPDATE_EXTENSION_MODE_MANAGER;
    V2NIMAntispamConfig *config = [V2NIMAntispamConfig new];
    [[[NIMSDK sharedSDK] v2TeamService] createTeam:teamParams inviteeAccountIds:@[@"test1",@"test2"] postscript:@"test" antispamConfig:config success:^(V2NIMCreateTeamResult * _Nonnull result) {
            // 群组创建成功
        } failure:^(V2NIMError * _Nonnull error) {
            // 群组创建失败
        }];

C++V2NIMCreateTeamParams createTeamParams;
createTeamParams.name = "teamName";
nstd::vector<nstd::string> inviteeAccountIds;
inviteeAccountIds.push_back("account1");
V2NIMAntispamConfig antispamConfig;
teamService.createTeam(
    createTeamParams,
    inviteeAccountIds,
    "postscript",
    antispamConfig,
    [](V2NIMCreateTeamResult result) {
        // do something
    },
    [](V2NIMError error) {
        // get message list failed, handle error
    });

TypeScriptawait nim.V2NIMTeamService.createTeam(
  {
    "name": "群名" ,
    "teamType": 1,
    "memberLimit": 200,
  }
)

TypeScripttry {
    const params: V2NIMCreateTeamParams = {
    name: this.name,
    teamType: this.teamType,
    memberLimit: this.memberLimit,
    intro: this.intro,
    announcement: this.announcement,
    avatar: this.avatar,
    serverExtension: this.serverExtension,
    joinMode: this.joinMode,
    agreeMode: this.agreeMode,
    inviteMode: this.inviteMode,
    updateInfoMode: this.updateInfoMode,
    updateExtensionMode: this.updateExtensionMode,
    chatBannedMode: this.chatBannedMode
  }

  const result:V2NIMCreateTeamResult = await nim.teamService.createTeam(params, [], '')
  // success
} catch (error) {
  // fail
}

无返回值

Promise<V2NIMCreateTeamResult> 群组创建结果

• 请求成功，返回 V2NIMSuccessCallback 回调，包含 V2NIMCreateTeamResult。创建成功，返回 onTeamCreated 回调。
• 请求失败，返回 V2NIMFailureCallback 回调，包含群组相关错误码。

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

创建成功，返回 onTeamCreated 回调。

Javavoid leaveTeam(String teamId, V2NIMTeamType teamType,V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)leaveTeam:(NSString *)teamId
         teamType:(V2NIMTeamType)teamType
          success:(nullable V2NIMSuccessCallback)success
          failure:(nullable V2NIMFailureCallback)failure;

C++virtual void leaveTeam(nstd::string teamId, V2NIMTeamType teamType, V2NIMSuccessCallback<void> success, V2NIMFailureCallback failure) = 0;

TypeScriptleaveTeam(teamId: string, teamType: V2NIMTeamType): Promise<V2NIMLeaveTeamResult>

TypeScriptleaveTeam(teamId: string, teamType: V2NIMTeamType): Promise<void>

JavaV2NIMTeamService v2TeamService = NIMClient.getService(V2NIMTeamService.class);
String teamId = "123456";
V2NIMTeamType teamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL;
v2TeamService.leaveTeam(teamId,teamType, result -> {
    // 离开群组成功
}, error -> {
    // 离开群组失败
});

Objective-C[[[NIMSDK sharedSDK] v2TeamService] leaveTeam:@"teamId" teamType:V2NIM_TEAM_TYPE_NORMAL success:^{
        // 离开群组成功
    } failure:^(V2NIMError * _Nonnull error) {
        // 离开群组失败
    }];

C++teamService.leaveTeam(
    "teamId",
    V2NIM_TEAM_TYPE_NORMAL,
    []() {
        // leave team success
    },
    [](V2NIMError error) {
        // leave team failed, handle error
    }
);

TypeScriptawait nim.V2NIMTeamService.leaveTeam("123456", 1)

TypeScriptconst teamId = "123456"
const teamType: V2NIMTeamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL
try {
  await nim.teamService.leaveTeam(teamId, teamType)
  // success
} catch (error) {
  // fail
}

无返回值

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调。退出群组成功，返回 onTeamLeft 回调。
• 请求失败，返回 V2NIMFailureCallback 回调，包含群组相关错误码。

退出群组成功，返回 onTeamLeft 回调。

Javavoid updateTeamInfo(String teamId, V2NIMTeamType teamType, V2NIMUpdateTeamInfoParams updateTeamInfoParams, V2NIMAntispamConfig antispamConfig,V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)updateTeamInfo:(NSString *)teamId
              teamType:(V2NIMTeamType)teamType
  updateTeamInfoParams:(V2NIMUpdateTeamInfoParams *)updateTeamInfoParams
        antispamConfig:(nullable V2NIMAntispamConfig *)antispamConfig
               success:(nullable V2NIMSuccessCallback)success
               failure:(nullable V2NIMFailureCallback)failure;

C++virtual void updateTeamInfo(std::string teamId,
                            V2NIMTeamType teamType,
                            V2NIMUpdateTeamInfoParams updateTeamInfoParams,
                            V2NIMAntispamConfig antispamConfig,
                            V2NIMSuccessCallback<void> success,
                            V2NIMFailureCallback failure) = 0;

TypeScriptupdateTeamInfo(teamId: string, teamType: V2NIMTeamType, updateTeamInfoParams: V2NIMUpdateTeamInfoParams, antispamConfig?: V2NIMAntispamConfig): Promise<void>

TypeScriptupdateTeamInfo(teamId: string, teamType: V2NIMTeamType, updateTeamInfoParams: V2NIMUpdateTeamInfoParams, antispamConfig?: V2NIMAntispamConfig): Promise<void>

JavaV2NIMTeamService v2TeamService = NIMClient.getService(V2NIMTeamService.class);
String teamId = "123456";
V2NIMTeamType teamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL;
V2NIMUpdateTeamInfoParams updateTeamInfoParams = new V2NIMUpdateTeamInfoParams();
updateTeamInfoParams.setName("test_update");
updateTeamInfoParams.setMemberLimit(100);
updateTeamInfoParams.setIntro("test");
updateTeamInfoParams.setAnnouncement("test");
updateTeamInfoParams.setAvatar("http://test.png");
updateTeamInfoParams.setServerExtension("test");
updateTeamInfoParams.setAgreeMode(V2NIMTeamAgreeMode.V2NIM_TEAM_AGREE_MODE_AUTH);
updateTeamInfoParams.setJoinMode(V2NIMTeamJoinMode.V2NIM_TEAM_JOIN_MODE_INVITE);
updateTeamInfoParams.setInviteMode(V2NIMTeamInviteMode.V2NIM_TEAM_INVITE_MODE_MANAGER);
updateTeamInfoParams.setUpdateInfoMode(V2NIMTeamUpdateInfoMode.V2NIM_TEAM_UPDATE_INFO_MODE_MANAGER);
updateTeamInfoParams.setUpdateExtensionMode(V2NIMTeamUpdateExtensionMode.V2NIM_TEAM_UPDATE_EXTENSION_MODE_MANAGER);
// 易盾反垃圾配置，如果不审核，该配置不需要配置。如果开启了安全通，默认采用安全通，该配置不需要配置。如果需要审核，且直接对接易盾，则配置该配置
V2NIMAntispamConfig antispamConfig = null;
v2TeamService.updateTeamInfo(teamId,teamType, updateTeamInfoParams, antispamConfig, result -> {
    // 修改群组信息成功
}, error -> {
    // 修改群组信息失败
});

Objective-C[[[NIMSDK sharedSDK] v2TeamService] updateTeamInfo:@"teamId" teamType:V2NIM_TEAM_TYPE_NORMAL updateTeamInfoParams:infoParams antispamConfig:config success:^{
    // 修改群组信息成功
} failure:^(V2NIMError * _Nonnull error) {
    // 修改群组信息失败
}];

C++V2NIMUpdateTeamInfoParams updateTeamInfoParams;
updateTeamInfoParams.name = "new team name";
V2NIMAntispamConfig antispamConfig;
teamService.updateTeamInfo(
    "teamId",
    V2NIM_TEAM_TYPE_NORMAL,
    updateTeamInfoParams,
    antispamConfig,
    []() {
        // update team info success
    },
    [](V2NIMError error) {
        // update team info failed, handle error
    });

TypeScriptawait nim.V2NIMTeamService.updateTeamInfo(
  "123456",
  1,
  {
    "name": "群名 1",
    "memberLimit": 200,
    "joinMode": 0,
    "agreeMode": 0,
    "inviteMode": 0,
    "updateInfoMode": 0,
    "updateExtensionMode": 0,
    "chatBannedMode": 0
  }
)

TypeScripttry {
  console.info(`----update team---- \n`)
  const params: V2NIMUpdateTeamInfoParams = {
    name: this.name,
    memberLimit: this.memberLimit,
    intro: this.intro,
    announcement: this.announcement,
    avatar: this.avatar,
    serverExtension: this.serverExtension,
    joinMode: this.joinMode,
    agreeMode: this.agreeMode,
    inviteMode: this.inviteMode,
    updateInfoMode: this.updateInfoMode,
    updateExtensionMode: this.updateExtensionMode,
  }

  await nim.teamService.updateTeamInfo(this.teamId, this.teamType, params )
  // success
} catch (error) {
  // fail
}

无返回值

Promise<void>

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

更新成功，返回 onTeamInfoUpdated 回调。

Javavoid getTeamInfo(String teamId, V2NIMTeamType teamType,V2NIMSuccessCallback<V2NIMTeam> success, V2NIMFailureCallback failure);

Objective-C- (void)getTeamInfo:(NSString *)teamId
           teamType:(V2NIMTeamType)teamType
            success:(nullable V2NIMTeamInfoCallback)success
            failure:(nullable V2NIMFailureCallback)failure;

C++virtual void getTeamInfo(nstd::string teamId, V2NIMTeamType teamType, V2NIMSuccessCallback<V2NIMTeam> success, V2NIMFailureCallback failure) = 0;

TypeScriptgetTeamInfo(teamId: string, teamType: V2NIMTeamType): Promise<V2NIMTeam>

TypeScriptgetTeamInfo(teamId: string, teamType: V2NIMTeamType): Promise<V2NIMTeam>

JavaV2NIMTeamService v2TeamService = NIMClient.getService(V2NIMTeamService.class);
String teamId = "123456";
V2NIMTeamType teamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL;
v2TeamService.getTeamInfo(teamId,teamType, result -> {
    // 获取群组信息成功
}, error -> {
    // 获取群组信息失败
});

Objective-C[[[NIMSDK sharedSDK] v2TeamService] getTeamInfo:@"teamId" teamType:V2NIM_TEAM_TYPE_NORMAL success:^(V2NIMTeam * _Nonnull team) {
    // 获取群组信息成功
} failure:^(V2NIMError * _Nonnull error) {
    // 获取群组信息失败
}];

C++teamService.getTeamInfo(
    "teamId",
    V2NIM_TEAM_TYPE_NORMAL,
    [](V2NIMTeam team) {
        // get team info success
    },
    [](V2NIMError error) {
        // get team info failed, handle error
    });

TypeScriptawait nim.V2NIMTeamService.getTeamInfo("123456", 1)

TypeScriptconst teamId = "123456"
const teamType: V2NIMTeamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL
try {
  const team: V2NIMTeam = await nim.teamService.getTeamInfo(teamId, teamType)
  // success
} catch (error) {
  // fail
}

无返回值

Promise<V2NIMTeam> 群组信息

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

• 请求成功，返回 V2NIMTeamInfoCallback 回调，可自定义设置。
• 请求失败，返回 V2NIMFailureCallback 回调，包含群组相关错误码。

无

Javavoid getTeamInfoByIds(List<String> teamIds, V2NIMTeamType teamType,V2NIMSuccessCallback<List<V2NIMTeam>> success, V2NIMFailureCallback failure);

Objective-C- (void)getTeamInfoByIds:(NSArray<NSString *> *)teamIds
                teamType:(V2NIMTeamType)teamType
                 success:(nullable V2NIMTeamInfoListCallback)success
                 failure:(nullable V2NIMFailureCallback)failure;

C++virtual void getTeamInfoByIds(std::vector<std::string> teamIds,
    V2NIMTeamType teamType,
    V2NIMSuccessCallback<std::vector<V2NIMTeam>> success,
    V2NIMFailureCallback failure) = 0;

TypeScriptgetTeamInfoByIds(teamIds: string[], teamType: V2NIMTeamType): Promise<V2NIMTeam[]>

TypeScriptgetTeamInfoByIds(teamIds: string[], teamType: V2NIMTeamType): Promise<V2NIMTeam[]>

JavaV2NIMTeamService v2TeamService = NIMClient.getService(V2NIMTeamService.class);
List<String> teamIds = new ArrayList<>();
teamIds.add("123456");
teamIds.add("654321");
V2NIMTeamType teamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL;
v2TeamService.getTeamInfoByIds(teamIds,teamType, result -> {
    // 根据群组 ID 获取群组信息成功
}, error -> {
    // 根据群组 ID 获取群组信息失败
});

Objective-C[[[NIMSDK sharedSDK] v2TeamService]getTeamInfoByIds:@[@"teamId1",@"teamId2"] teamType:V2NIM_TEAM_TYPE_NORMAL success:^(NSArray<V2NIMTeam *> * _Nonnull teamList) {
        // 根据群组 ID 获取群组信息成功
    } failure:^(V2NIMError * _Nonnull error) {
        // 根据群组 ID 获取群组信息失败
    }];

C++nstd::vector<nstd::string> teamIds;
teamIds.push_back("teamId1");
teamIds.push_back("teamId2");
teamService.getTeamInfoByIds(
    teamIds,
    V2NIM_TEAM_TYPE_NORMAL,
    [](nstd::vector<V2NIMTeam> teamList) {
        // get team info success
    },
    [](V2NIMError error) {
        // get team info failed, handle error
    });

TypeScriptawait nim.V2NIMTeamService.getTeamInfoByIds(["123456"], 1)

TypeScriptconst teamIds = ["123456", "7890"]
const teamType: V2NIMTeamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL
try {
  const teams: V2NIMTeam[] = await nim.teamService.getTeamInfoByIds(teamIds, teamType)
  // success
} catch (error) {
  // fail
}

无返回值

Promise<V2NIMTeam[]> 群组信息列表

• 请求成功，返回 V2NIMSuccessCallback 回调，包含 V2NIMTeam 列表。
• 请求失败，返回 V2NIMFailureCallback 回调，包含群组相关错误码。

• 请求成功，返回 V2NIMTeamInfoListCallback 回调，可自定义设置。
• 请求失败，返回 V2NIMFailureCallback 回调，包含群组相关错误码。

无

Javavoid dismissTeam(String teamId, V2NIMTeamType teamType,V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)dismissTeam:(NSString *)teamId
           teamType:(V2NIMTeamType)teamType
            success:(nullable V2NIMSuccessCallback)success
            failure:(nullable V2NIMFailureCallback)failure;

C++virtual void dismissTeam(nstd::string teamId, V2NIMTeamType teamType, V2NIMSuccessCallback<void> success, V2NIMFailureCallback failure) = 0;

TypeScriptdismissTeam(teamId: string, teamType: V2NIMTeamType): Promise<void>

TypeScriptdismissTeam(teamId: string, teamType: V2NIMTeamType): Promise<void>

JavaV2NIMTeamService v2TeamService = NIMClient.getService(V2NIMTeamService.class);
String teamId = "123456";
V2NIMTeamType teamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL;
v2TeamService.dismissTeam(teamId,teamType, result -> {
    // 解散群组成功
}, error -> {
    // 解散群组失败
});

Objective-C[[[NIMSDK sharedSDK] v2TeamService] dismissTeam:@"teamId" teamType:V2NIM_TEAM_TYPE_NORMAL success:^{
    // 解散群组成功
} failure:^(V2NIMError * _Nonnull error) {
    // 解散群组失败
}];

C++teamService.dismissTeam(
    "teamId",
    V2NIM_TEAM_TYPE_NORMAL,
    []() {
        // dismiss team success
    },
    [](V2NIMError error) {
        // dismiss team failed, handle error
    });

TypeScriptawait nim.V2NIMTeamService.dismissTeam("123456", 1)

TypeScriptconst teamId = "123456"
const teamType: V2NIMTeamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL
try {
  await nim.teamService.dismissTeam(teamId, teamType)
  // success
} catch (error) {
  // fail
}

无返回值

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调。解散成功，返回 onTeamDismissed 回调。
• 请求失败，返回 V2NIMFailureCallback 回调，包含群组相关错误码。

删除成功，返回 onTeamDismissed 回调。

Javavoid inviteMember(String teamId, V2NIMTeamType teamType, List<String> inviteeAccountIds, String postscript,V2NIMSuccessCallback<List<String>> success, V2NIMFailureCallback failure);

Objective-C- (void)inviteMember:(NSString *)teamId
            teamType:(V2NIMTeamType)teamType
   inviteeAccountIds:(NSArray<NSString *> *)inviteeAccountIds
          postscript:(nullable NSString *)postscript
             success:(nullable V2NIMTeamInviteMemberCallback)success
             failure:(nullable V2NIMFailureCallback)failure;

C++virtual void inviteMember(nstd::string teamId,
                          V2NIMTeamType teamType,
                          nstd::vector<nstd::string> inviteeAccountIds,
                          nstd::string postscript,
                          V2NIMSuccessCallback<nstd::vector<nstd::string>> success,
                          V2NIMFailureCallback failure) = 0;

TypeScriptinviteMember(teamId: string, teamType: V2NIMTeamType, inviteeAccountIds: string[], postscript?: string): Promise<string[]>

TypeScriptinviteMember(teamId: string, teamType: V2NIMTeamType, inviteeAccountIds: string[], postscript?: string): Promise<string[]>

JavaV2NIMTeamService v2TeamService = NIMClient.getService(V2NIMTeamService.class);
String teamId = "123456";
V2NIMTeamType teamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL;
List<String> inviteeAccountIds = new ArrayList<>();
inviteeAccountIds.add("test1");
inviteeAccountIds.add("test2");
String postscript = "test";
v2TeamService.inviteMember(teamId,teamType, inviteeAccountIds, postscript, result -> {
    // 邀请成员加入群组成功
}, error -> {
    // 邀请成员加入群组失败
});

Objective-C[[[NIMSDK sharedSDK] v2TeamService] inviteMember:@"teamId" teamType:V2NIM_TEAM_TYPE_NORMAL inviteeAccountIds:@[@"accountId1"] postscript:@"test" success:^(NSArray<NSString *> * _Nonnull failedList) {
        // 邀请成员加入群组成功
    } failure:^(V2NIMError * _Nonnull error) {
        // 邀请成员加入群组失败
    }];

C++nstd::vector<nstd::string> inviteeAccountIds;
inviteeAccountIds.push_back("account1");
teamService.inviteMember(
    "teamId",
    V2NIM_TEAM_TYPE_NORMAL,
    inviteeAccountIds,
    "postscript",
    [](nstd::vector<nstd::string> failedList) {
        // invite member success
    },
    [](V2NIMError error) {
        // invite member failed, handle error
    });

TypeScriptawait nim.V2NIMTeamService.inviteMember("123456", 1, ["accountId1"])

TypeScripttry {
  const teamId: string = "123456"
  const teamType: V2NIMTeamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL
  const inviteeAccountIds: string[] = ["acc1", "acc2"]
  const postscript: string | undefined = "postscript"

  const res = await teamService.inviteMember(teamId, teamType, inviteeAccountIds, postscript)
  // success
}
catch (err) {
  // fail
}

无返回值

Promise<string[]> 邀请失败的用户账号（accountId）列表

• 请求成功，返回 V2NIMSuccessCallback 回调，包含邀请失败的用户账号（accountId）列表。
• 请求失败，返回 V2NIMFailureCallback 回调，包含群组相关错误码。

• 请求成功，返回 V2NIMTeamInviteMemberCallback 回调，包含邀请失败的用户账号（accountId）列表，可自定义设置。
• 请求失败，返回 V2NIMFailureCallback 回调，包含群组相关错误码。

无

Javavoid acceptInvitation(V2NIMTeamJoinActionInfo invitationInfo,V2NIMSuccessCallback<V2NIMTeam> success, V2NIMFailureCallback failure);

Objective-C- (void)acceptInvitation:(V2NIMTeamJoinActionInfo *)invitationInfo
                 success:(nullable V2NIMTeamInfoCallback)success
                 failure:(nullable V2NIMFailureCallback)failure;

C++virtual void acceptInvitation(V2NIMTeamJoinActionInfo invitationInfo, V2NIMSuccessCallback<V2NIMTeam> success, V2NIMFailureCallback failure) = 0;

TypeScriptacceptInvitation(invitationInfo: V2NIMTeamJoinActionInfo): Promise<V2NIMTeam>

TypeScriptacceptInvitation(invitationInfo: V2NIMTeamJoinActionInfo): Promise<V2NIMTeam>

JavaV2NIMTeamService v2TeamService = NIMClient.getService(V2NIMTeamService.class);
// 收到的邀请信息
V2NIMTeamJoinActionInfo invitationInfo = getInvitationInfo();
v2TeamService.acceptInvitation(invitationInfo, result -> {
    // 同意邀请入群成功
}, error -> {
    // 同意邀请入群失败
});

Objective-C[[[NIMSDK sharedSDK] v2TeamService] acceptInvitation:invitationInfo success:^(V2NIMTeam * _Nonnull team) {
    // 同意邀请入群成功
} failure:^(V2NIMError * _Nonnull error) {
    // 同意邀请入群失败
}];

C++V2NIMTeamJoinActionInfo invitationInfo;
// get invitationInfo from notification or query
// ...
teamService.acceptInvitation(
    invitationInfo,
    [](V2NIMTeam team) {
        // accept invitation success
    },
    [](V2NIMError error) {
        // accept invitation failed, handle error
    });

TypeScriptawait nim.V2NIMTeamService.acceptInvitation(
  {
    "teamId": "123456",
    "teamType": 1,
    "operatorAccountId": "accountId1",
    "actionType": 2
  }
)

TypeScripttry{
  const invitationInfo: V2NIMTeamJoinActionInfo = {
    actionType: V2NIMTeamJoinActionType.V2NIM_TEAM_JOIN_ACTION_TYPE_INVITATION,
    teamId: "123456",
    teamType: V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL,
    operatorAccountId: "account1",
  }

  const team: V2NIMTeam = await nim.teamService.acceptInvitation(invitationInfo)
  // success
}
catch (err) {
  // fail
}

无返回值

Promise<V2NIMTeam>

• 请求成功，返回 V2NIMSuccessCallback 回调，包含 V2NIMTeam。接受入群邀请成功，收到加入群组成功回调 onTeamJoined。
• 请求失败，返回 V2NIMFailureCallback 回调，包含群组相关错误码。

• 请求成功，返回 V2NIMTeamInfoCallback 回调，可自定义设置。接受入群邀请成功，收到加入群组成功回调 onTeamJoined。
• 请求失败，返回 V2NIMFailureCallback 回调，包含群组相关错误码。

无

Javavoid rejectInvitation(V2NIMTeamJoinActionInfo invitationInfo, String postscript,V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)rejectInvitation:(V2NIMTeamJoinActionInfo *)invitationInfo
              postscript:(nullable NSString *)postscript
                 success:(nullable V2NIMSuccessCallback)success
                 failure:(nullable V2NIMFailureCallback)failure;

C++virtual void rejectInvitation(V2NIMTeamJoinActionInfo invitationInfo,
                             std::string postscript,
                             V2NIMSuccessCallback<void> success,
                             V2NIMFailureCallback failure) = 0;

TypeScriptrejectInvitation(invitationInfo: V2NIMTeamJoinActionInfo, postscript?: string): Promise<void>

TypeScriptrejectInvitation(invitationInfo: V2NIMTeamJoinActionInfo, postscript?: string): Promise<void>

JavaV2NIMTeamService v2TeamService = NIMClient.getService(V2NIMTeamService.class);
// 收到的邀请信息
V2NIMTeamJoinActionInfo invitationInfo = getInvitationInfo();
String postscript = "test";
v2TeamService.rejectInvitation(invitationInfo, postscript, result -> {
    // 拒绝邀请入群成功
}, error -> {
    // 拒绝邀请入群失败
});

Objective-C[[[NIMSDK sharedSDK] v2TeamService] rejectInvitation:invitationInfo postscript:@"test" success:^{
    // 拒绝邀请入群成功
} failure:^(V2NIMError * _Nonnull error) {
    // 拒绝邀请入群失败
}];

C++V2NIMTeamJoinActionInfo invitationInfo;
// get invitationInfo from notification or query
// ...
teamService.rejectInvitation(
    invitationInfo,
    "postscript",
    []() {
        // reject invitation success
    },
    [](V2NIMError error) {
        // reject invitation failed, handle error
    });

TypeScriptawait nim.V2NIMTeamService.rejectInvitation(
  {
    "teamId": "123456",
    "teamType": 1,
    "operatorAccountId": "accountId1",
    "actionType": 2
  },
  "test postscript"
)

TypeScripttry{
  const invitationInfo: V2NIMTeamJoinActionInfo = {
    actionType: V2NIMTeamJoinActionType.V2NIM_TEAM_JOIN_ACTION_TYPE_INVITATION,
    teamId: "123456",
    teamType: V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL,
    operatorAccountId: "account1",
  }

  await nim.teamService.rejectInvitation(invitationInfo)
  // success
}
catch (err) {
  // fail
}

无返回值

Promise<void>

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

无

Javavoid kickMember(String teamId, V2NIMTeamType teamType, List<String> memberAccountIds, V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)kickMember:(NSString *)teamId
          teamType:(V2NIMTeamType)teamType
  memberAccountIds:(nullable NSArray<NSString *> *)memberAccountIds
           success:(nullable V2NIMSuccessCallback)success
           failure:(nullable V2NIMFailureCallback)failure;

C++virtual void kickMember(nstd::string teamId,
                        V2NIMTeamType teamType,
                        nstd::vector<nstd::string> memberAccountIds,
                        V2NIMSuccessCallback<void> success,
                        V2NIMFailureCallback failure) = 0;

TypeScriptkickMember(teamId: string, teamType: V2NIMTeamType, memberAccountIds: string[]): Promise<void>

TypeScriptkickMember(teamId: string, teamType: V2NIMTeamType, memberAccountIds: string[]): Promise<void>

JavaV2NIMTeamService v2TeamService = NIMClient.getService(V2NIMTeamService.class);
String teamId = "123456";
V2NIMTeamType teamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL;
List<String> memberAccountIds = new ArrayList<>();
memberAccountIds.add("test1");
memberAccountIds.add("test2");
v2TeamService.kickMember(teamId,teamType, memberAccountIds, result -> {
    // 踢出群组成员成功
}, error -> {
    // 踢出群组成员失败
});

Objective-C[[[NIMSDK sharedSDK] v2TeamService] kickMember:@"teamId" teamType:V2NIM_TEAM_TYPE_NORMAL memberAccountIds:@[@"accountId1"] success:^{
    // 踢出群组成员成功
} failure:^(V2NIMError * _Nonnull error) {
    // 踢出群组成员失败
}];

C++nstd::vector<nstd::string> memberAccountIds;
memberAccountIds.push_back("account1");
teamService.kickMember(
    "teamId",
    V2NIM_TEAM_TYPE_NORMAL,
    memberAccountIds,
    []() {
        // kick member success
    },
    [](V2NIMError error) {
        // kick member failed, handle error
    });

TypeScriptawait nim.V2NIMTeamService.kickMember("123456", 1, ["accountId1"])

TypeScripttry{
  const teamId = "123456",
  const teamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL,
  const accounts = ["aaa", "bbb"]

  await nim.teamService.kickMember(teamId, teamType, accounts)
  // success
}
catch (err) {
  // fail
}

无返回值

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调。踢出群组成功，返回 onTeamMemberKicked 回调。
• 请求失败，返回 V2NIMFailureCallback 回调，包含群组相关错误码。

踢出群组成功，返回 onTeamMemberKicked 回调。

Javavoid applyJoinTeam(String teamId, V2NIMTeamType teamType, String postscript,V2NIMSuccessCallback<V2NIMTeam> success, V2NIMFailureCallback failure);

Objective-C- (void)applyJoinTeam:(NSString *)teamId
             teamType:(V2NIMTeamType)teamType
           postscript:(nullable NSString *)postscript
              success:(nullable V2NIMTeamInfoCallback)success
              failure:(nullable V2NIMFailureCallback)failure;

C++virtual void applyJoinTeam(nstd::string teamId,
                           V2NIMTeamType teamType,
                           nstd::string postscript,
                           V2NIMSuccessCallback<V2NIMTeam> success,
                           V2NIMFailureCallback failure) = 0;

TypeScriptapplyJoinTeam(teamId: string, teamType: V2NIMTeamType, postscript?: string): Promise<V2NIMTeam>

TypeScriptapplyJoinTeam(teamId: string, teamType: V2NIMTeamType, postscript?: string): Promise<V2NIMTeam>

JavaV2NIMTeamService v2TeamService = NIMClient.getService(V2NIMTeamService.class);
String teamId = "123456";
V2NIMTeamType teamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL;
String postscript = "test";
v2TeamService.applyJoinTeam(teamId, teamType, postscript, result -> {
    // 申请加入群组成功
}, error -> {
    // 申请加入群组失败
});

Objective-C[[[NIMSDK sharedSDK] v2TeamService] applyJoinTeam:@"teamId" teamType:V2NIM_TEAM_TYPE_NORMAL postscript:@"test" success:^(V2NIMTeam * _Nonnull team) {
    // 申请加入群组成功
} failure:^(V2NIMError * _Nonnull error) {
    // 申请加入群组失败
}];

C++teamService.applyJoinTeam(
    "teamId",
    V2NIM_TEAM_TYPE_NORMAL,
    "postscript",
    [](V2NIMTeam team) {
        // apply join team success
    },
    [](V2NIMError error) {
        // apply join team failed, handle error
    }
);

TypeScriptawait nim.V2NIMTeamService.applyJoinTeam("123456", 1, "test postscript")

TypeScripttry{
  const teamId = "123456",
  const teamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL,
  const postscript = "postscript"

  await nim.teamService.applyJoinTeam(teamId, teamType, postscript)
  // success
}
catch (err) {
  // fail
}

无返回值

Promise<V2NIMTeam>

• 请求成功，返回 V2NIMSuccessCallback 回调，包含 V2NIMTeam。加入群组成功，返回 onTeamJoined
• 请求失败，返回 V2NIMFailureCallback 回调，包含群组相关错误码。

• 请求成功，返回 V2NIMTeamInfoCallback 回调，可自定义设置。加入群组成功，返回 onTeamJoined。
• 请求失败，返回 V2NIMFailureCallback 回调，包含群组相关错误码。

无

Javavoid acceptJoinApplication(V2NIMTeamJoinActionInfo applicationInfo,V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)acceptJoinApplication:(V2NIMTeamJoinActionInfo *)applicationInfo
                      success:(nullable V2NIMSuccessCallback)success
                      failure:(nullable V2NIMFailureCallback)failure;

C++virtual void acceptJoinApplication(V2NIMTeamJoinActionInfo applicationInfo, V2NIMSuccessCallback<void> success, V2NIMFailureCallback failure) = 0;

TypeScriptacceptJoinApplication(applicationInfo: V2NIMTeamJoinActionInfo): Promise<void>

TypeScriptacceptJoinApplication(applicationInfo: V2NIMTeamJoinActionInfo): Promise<void>

JavaV2NIMTeamService v2TeamService = NIMClient.getService(V2NIMTeamService.class);
// 收到的入群申请信息
V2NIMTeamJoinActionInfo applicationInfo = getApplicationInfo();
v2TeamService.acceptJoinApplication(applicationInfo, result -> {
    // 接受入群申请成功
}, error -> {
    // 接受入群申请失败
});

Objective-C[[[NIMSDK sharedSDK] v2TeamService] acceptJoinApplication:info success:^{
    // 接受入群申请成功
} failure:^(V2NIMError * _Nonnull error) {
    // 接受入群申请失败
}];

C++V2NIMTeamJoinActionInfo applicationInfo;
// get applicationInfo from notification or query
// ...
teamService.acceptJoinApplication(
    applicationInfo,
    []() {
        // accept join application success
    },
    [](V2NIMError error) {
        // accept join application failed, handle error
    });

TypeScriptawait nim.V2NIMTeamService.acceptJoinApplication(
  {
    "teamId": "123456",
    "teamType": 1,
    "operatorAccountId": "accountId1",
    "actionType": 0
  }
)

TypeScripttry{
  const applicationInfo: V2NIMTeamJoinActionInfo = {
    actionType: V2NIMTeamJoinActionType.V2NIM_TEAM_JOIN_ACTION_TYPE_APPLICATION,
    teamId: "123456",
    teamType: V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL,
    operatorAccountId: "account1",
  }

  await nim.teamService.acceptJoinApplication(applicationInfo)
  // success
}
catch (err) {
  // fail
}

无返回值

Promise<void>

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

无

Javavoid rejectJoinApplication(V2NIMTeamJoinActionInfo applicationInfo, String postscript,V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)rejectJoinApplication:(NSString *)teamId
                     teamType:(V2NIMTeamType)teamType
               applyAccountId:(NSString *)applyAccountId
                   postscript:(nullable NSString *)postscript
                      success:(nullable V2NIMSuccessCallback)success
                      failure:(nullable V2NIMFailureCallback)failure;

C++virtual void rejectJoinApplication(V2NIMTeamJoinActionInfo applicationInfo,
                                  std::string postscript,
                                  V2NIMSuccessCallback<void> success,
                                  V2NIMFailureCallback failure) = 0;

TypeScriptrejectJoinApplication(applicationInfo: V2NIMTeamJoinActionInfo, postscript?: string): Promise<void>

TypeScriptrejectJoinApplication(applicationInfo: V2NIMTeamJoinActionInfo, postscript?: string): Promise<void>

JavaV2NIMTeamService v2TeamService = NIMClient.getService(V2NIMTeamService.class);
// 收到的入群申请信息
V2NIMTeamJoinActionInfo applicationInfo = getApplicationInfo();
String postscript = "test";
v2TeamService.rejectInvitation(applicationInfo, postscript, result -> {
    // 拒绝入群申请成功
}, error -> {
    // 拒绝入群申请失败
});

Objective-C[[[NIMSDK sharedSDK] v2TeamService] rejectJoinApplication:@"teamId"
                                                teamType:V2NIM_TEAM_TYPE_NORMAL
                                         applyAccountId:@"accountId"
                                             postscript:@"test"
                                                 success:^{
                                                     // 拒绝入群申请成功
                                                 }
                                                 failure:^(V2NIMError * _Nonnull error) {
                                                     // 拒绝入群申请失败
                                                 }];

C++V2NIMTeamJoinActionInfo applicationInfo;
// get applicationInfo from notification or query
// ...
teamService.rejectJoinApplication(
    applicationInfo,
    "postscript",
    []() {
        // reject join application success
    },
    [](V2NIMError error) {
        // reject join application failed, handle error
    });

TypeScriptawait nim.V2NIMTeamService.rejectJoinApplication(
  {
    "teamId": "123456",
    "teamType": 1,
    "operatorAccountId": "accountId1",
    "actionType": 0
  },
  "test postscript"
)

TypeScripttry{
  const applicationInfo: V2NIMTeamJoinActionInfo = {
    actionType: V2NIMTeamJoinActionType.V2NIM_TEAM_JOIN_ACTION_TYPE_APPLICATION,
    teamId: "123456",
    teamType: V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL,
    operatorAccountId: "account1",
  }
  const postscript = "postscript"

  await nim.teamService.rejectJoinApplication(applicationInfo, postscript)
  // success
}
catch (err) {
  // fail
}

无返回值

Promise<void>

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

无

Javavoid updateTeamMemberRole(String teamId, V2NIMTeamType teamType, List<String> memberAccountIds, V2NIMTeamMemberRole memberRole,V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)updateTeamMemberRole:(NSString *)teamId
                    teamType:(V2NIMTeamType)teamType
            memberAccountIds:(NSArray<NSString *> *)memberAccountIds
                  memberRole:(V2NIMTeamMemberRole)memberRole
                     success:(nullable V2NIMSuccessCallback)success
                     failure:(nullable V2NIMFailureCallback)failure;

C++virtual void updateTeamMemberRole(nstd::string teamId,
                                 V2NIMTeamType teamType,
                                 nstd::vector<nstd::string> memberAccountId,
                                 V2NIMTeamMemberRole memberRole,
                                 V2NIMSuccessCallback<void> success,
                                 V2NIMFailureCallback failure) = 0;

TypeScriptupdateTeamMemberRole(teamId: string, teamType: V2NIMTeamType, memberAccountIds: string[], memberRole: V2NIMTeamMemberRole): Promise<void>

TypeScriptupdateTeamMemberRole(teamId: string, teamType: V2NIMTeamType, memberAccountIds: string[], memberRole: V2NIMTeamMemberRole): Promise<void>

JavaV2NIMTeamService v2TeamService = NIMClient.getService(V2NIMTeamService.class);
String teamId = "123456";
V2NIMTeamType teamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL;
List<String> memberAccountIds = new ArrayList<>();
memberAccountIds.add("test1");
V2NIMTeamMemberRole memberRole = V2NIMTeamMemberRole.V2NIM_TEAM_MEMBER_ROLE_MANAGER;
v2TeamService.updateTeamMemberRole(teamId, teamType, memberAccountIds, memberRole, result -> {
    // 更新群组成员角色成功
}, error -> {
    // 更新群组成员角色失败
});

Objective-C[[[NIMSDK sharedSDK] v2TeamService] updateTeamMemberRole:@"teamId" teamType:V2NIM_TEAM_TYPE_NORMAL memberAccountIds:@[@"accountId"] memberRole:V2NIM_TEAM_MEMBER_ROLE_NORMAL success:^{
    // 更新群组成员角色成功
} failure:^(V2NIMError * _Nonnull error) {
    // 更新群组成员角色失败
}];

C++std::vector<std::string> memberAccountIds;
memberAccountIds.push_back("account1");
teamService.updateTeamMemberRole(
    "teamId",
    V2NIM_TEAM_TYPE_NORMAL,
    memberAccountIds,
    V2NIM_TEAM_MEMBER_ROLE_MANAGER,
    []() {
        // update team member role success
    },
    [](V2NIMError error) {
        // update team member role failed, handle error
    }
);

TypeScriptawait nim.V2NIMTeamService.updateTeamMemberRole("123456", 1, ["accountId1"], 0)

TypeScripttry {
  const teamId: string = "123456"
  const teamType: V2NIMTeamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL
  const memberAccountIds: string[] = ["aaa", "bbb"]
  const memberRole: V2NIMTeamMemberRole = V2NIMTeamMemberRole.V2NIM_TEAM_MEMBER_ROLE_MANAGER

  await nim.teamService.updateTeamMemberRole(teamId, teamType, memberAccountIds, memberRole)
  // success
}
catch (err) {
  // fail
}

无返回值

Promise<void>

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

更新成功，返回 onTeamMemberInfoUpdated 回调。

Javavoid transferTeamOwner(String teamId, V2NIMTeamType teamType, String accountId, boolean leave, V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)transferTeamOwner:(NSString *)teamId
                 teamType:(V2NIMTeamType)teamType
                accountId:(NSString *)accountId
                    leave:(BOOL)leave
                  success:(nullable V2NIMSuccessCallback)success
                  failure:(nullable V2NIMFailureCallback)failure;

C++virtual void transferTeamOwner(nstd::string teamId,
                               V2NIMTeamType teamType,
                               nstd::string accountId,
                               bool leave,
                               V2NIMSuccessCallback<void> success,
                               V2NIMFailureCallback failure) = 0;

TypeScripttransferTeamOwner(teamId: string, teamType: V2NIMTeamType, accountId: string, leave?: boolean): Promise<void>

TypeScripttransferTeamOwner(teamId: string, teamType: V2NIMTeamType, accountId: string, leave?: boolean): Promise<void>

JavaV2TeamService v2TeamService = NIMClient.getService(V2TeamService.class);
String teamId = "123456";
V2TeamType teamType = V2TeamType.NORMAL;
String account = "test";
boolean leave = false;
v2TeamService.transferTeamOwner(teamId, teamType, account, leave, result -> {
    // 转移群组群主成功
}, error -> {
    // 转移群组群主失败
});

Objective-C[[[NIMSDK sharedSDK] v2TeamService] transferTeamOwner:@"teamId" teamType:V2NIM_TEAM_TYPE_NORMAL accountId:@"accountId" leave:YES success:^{
    // 转移群组群主成功
} failure:^(V2NIMError * _Nonnull error) {
    // 转移群组群主失败
}];

C++teamService.transferTeamOwner(
    "teamId",
    V2NIM_TEAM_TYPE_NORMAL,
    "accountId",
    false,
    []() {
        // transfer team owner success
    },
    [](V2NIMError error) {
        // transfer team owner failed, handle error
    });

TypeScriptawait nim.V2NIMTeamService.transferTeamOwner("123456", 1, "accountId1", true)

TypeScripttry {
  const teamId: string = "123456"
  const teamType: V2NIMTeamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL
  const newAccountId: string = "aaa"
  const isLeave: boolean = true

  await nim.teamService.transferTeamOwner(teamId, teamType, newAccountId, isLeave)
  // success
} catch (error) {
  // fail
}

无返回值

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调。转让成功，返回群信息更新回调 onTeamInfoUpdated 和群成员信息变更回调 onTeamMemberInfoUpdated。
• 请求失败，返回 V2NIMFailureCallback 回调，包含群组相关错误码。

转让成功，返回群信息更新回调 onTeamInfoUpdated 和群成员信息变更回调 onTeamMemberInfoUpdated。

Javavoid updateSelfTeamMemberInfo(String teamId, V2NIMTeamType teamType, V2NIMUpdateSelfMemberInfoParams memberInfoParams,V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)updateSelfTeamMemberInfo:(NSString *)teamId
                        teamType:(V2NIMTeamType)teamType
                memberInfoParams:(V2NIMUpdateSelfMemberInfoParams *)memberInfoParams
                         success:(nullable V2NIMSuccessCallback)success
                         failure:(nullable V2NIMFailureCallback)failure;

C++virtual void updateSelfTeamMemberInfo(std::string teamId,
                                      V2NIMTeamType teamType,
                                      V2NIMUpdateSelfMemberInfoParams memberInfoParams,
                                      V2NIMSuccessCallback<void> success,
                                      V2NIMFailureCallback failure) = 0;

TypeScriptupdateSelfTeamMemberInfo(teamId: string, teamType: V2NIMTeamType, memberInfoParams: V2NIMUpdateSelfMemberInfoParams): Promise<void>

TypeScriptupdateSelfTeamMemberInfo(teamId: string, teamType: V2NIMTeamType, memberInfoParams: V2NIMUpdateSelfMemberInfoParams): Promise<void>

JavaV2NIMTeamService v2TeamService = NIMClient.getService(V2NIMTeamService.class);
String teamId = "123456";
V2NIMTeamType teamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL;
V2NIMUpdateSelfMemberInfoParams memberInfoParams = new V2NIMUpdateSelfMemberInfoParams();
memberInfoParams.setTeamNick("test nick");
memberInfoParams.setServerExtension("test");
v2TeamService.updateSelfTeamMemberInfo(teamId,teamType, memberInfoParams, result -> {
    // 修改自己的群成员信息成功
}, error -> {
    // 修改自己的群成员信息失败
});

Objective-C[[[NIMSDK sharedSDK] v2TeamService] updateSelfTeamMemberInfo:@"teamId" teamType:V2NIM_TEAM_TYPE_NORMAL memberInfoParams:infoParams success:^{
    // 修改自己的群成员信息成功
} failure:^(V2NIMError * _Nonnull error) {
    // 修改自己的群成员信息失败
}];

C++V2NIMUpdateSelfMemberInfoParams memberInfoParams;
memberInfoParams.teamNick = "new nick";
teamService.updateSelfTeamMemberInfo(
    "teamId",
    V2NIM_TEAM_TYPE_NORMAL,
    memberInfoParams,
    []() {
        // update self team member info success
    },
    [](V2NIMError error) {
        // update self team member info failed, handle error
    });

TypeScriptawait nim.V2NIMTeamService.updateSelfTeamMemberInfo("123456", 1, {
  "teamNick": "test nick"
})

TypeScripttry {
  const teamId: string = "123456"
  const teamType: V2NIMTeamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL
  const memberInfoParams: V2NIMUpdateSelfMemberInfoParams = {
    teamNick: "nick",
    serverExtension: "ext"
  }

  await teamService.updateSelfTeamMemberInfo(teamId, teamType, memberInfoParams)
  // success
} catch (err) {
  // fail
}

无返回值

Promise<void>

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

更新成功，返回 onTeamMemberInfoUpdated 回调。

Javavoid updateTeamMemberNick(String teamId, V2NIMTeamType teamType, String accountId, String teamNick,V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)updateTeamMemberNick:(NSString *)teamId
                    teamType:(V2NIMTeamType)teamType
                   accountId:(NSString *)accountId
                    teamNick:(NSString *)teamNick
                     success:(nullable V2NIMSuccessCallback)success
                     failure:(nullable V2NIMFailureCallback)failure;

C++virtual void updateTeamMemberNick(nstd::string teamId,
                                 V2NIMTeamType teamType,
                                 nstd::string accountId,
                                 nstd::string teamNick,
                                 V2NIMSuccessCallback<void> success,
                                 V2NIMFailureCallback failure) = 0;

TypeScriptupdateTeamMemberNick(teamId: string, teamType: V2NIMTeamType, accountId: string, nick: string): Promise<void>

TypeScriptupdateTeamMemberNick(teamId: string, teamType: V2NIMTeamType, accountId: string, nick: string): Promise<void>

JavaV2NIMTeamService v2TeamService = NIMClient.getService(V2NIMTeamService.class);
String teamId = "123456";
V2NIMTeamType teamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL;
String account = "test";
String teamNick = "test nick";
v2TeamService.updateTeamMemberNick(teamId, teamType, account, teamNick, result -> {
    // 修改群成员昵称成功
}, error -> {
    // 修改群成员昵称失败
});

Objective-C[[[NIMSDK sharedSDK] v2TeamService] updateTeamMemberNick:@"teamId" teamType:V2NIM_TEAM_TYPE_NORMAL accountId:@"accountId" teamNick:@"test" success:^{
    // 修改群成员昵称成功
} failure:^(V2NIMError * _Nonnull error) {
    // 修改群成员昵称失败
}];

C++teamService.updateTeamMemberNick(
    "teamId",
    V2NIM_TEAM_TYPE_NORMAL,
    "accountId",
    "new nick",
    []() {
        // update team member nick success
    },
    [](V2NIMError error) {
        // update team member nick failed, handle error
    });

TypeScriptawait nim.V2NIMTeamService.updateTeamMemberNick("123456", 1, "accountId1", "test nick")

TypeScripttry {
  const teamId: string = "123456"
  const teamType: V2NIMTeamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL
  const account: string = "aaa"
  const nick: string = "new nick"

  await teamService.updateTeamMemberNick(teamId, teamType, account, nick)
  // success
} catch (err) {
  // fail
}

无返回值

Promise<void>

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