- (void)getGroupMemberList:(uint32_t)seq {
    // 通过 filter 参数指定拉取全部成员
    [[V2TIMManager sharedInstance] getGroupMemberList:@"groupA" filter:V2TIM_GROUP_MEMBER_FILTER_ALL nextSeq:seq succ:^(uint64_t nextSeq, NSArray<V2TIMGroupMemberFullInfo *> *memberList) {
        if (nextSeq ！= 0) {
            // 继续分页拉取
            [self getGroupMemberList:nextSeq];
            //...
        } else {
            // 拉取结束
        }
    } fail:^(int code, NSString *desc) {
        // 拉取失败
    }];
}

template <class T>
class ValueCallback final : public V2TIMValueCallback<T> {
public:
    using SuccessCallback = std::function<void(const T&)>;
    using ErrorCallback = std::function<void(int, const V2TIMString&)>;

    ValueCallback() = default;
    ~ValueCallback() override = default;

    void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback) {
        success_callback_ = std::move(success_callback);
        error_callback_ = std::move(error_callback);
    }

    void OnSuccess(const T& value) override {
        if (success_callback_) {
            success_callback_(value);
        }
    }
    void OnError(int error_code, const V2TIMString& error_message) override {
        if (error_callback_) {
            error_callback_(error_code, error_message);
        }
    }

private:
    SuccessCallback success_callback_;
    ErrorCallback error_callback_;
};

V2TIMString groupID = "testGroup";
// 通过 filter 参数指定拉取全部成员
uint32_t filter = V2TIMGroupMemberFilter::V2TIM_GROUP_MEMBER_FILTER_ALL;
uint64_t nextSeq = 0;

auto callback = new ValueCallback<V2TIMGroupMemberInfoResult>{};
callback->SetCallback(
    [=](const V2TIMGroupMemberInfoResult& groupMemberInfoResult) {
        if (groupMemberInfoResult.nextSequence != 0) {
            // 继续分页拉取 ...
        }

        delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
        // 拉取失败
        delete callback;
    });

V2TIMManager::GetInstance()->GetGroupManager()->GetGroupMemberList(groupID, filter, nextSeq, callback);

// 禁言群成员 user1 1分钟
[[V2TIMManager sharedInstance] muteGroupMember:@"groupA" member:@"user1" muteTime:60 succ:^{
    // 禁言群成员成功
} fail:^(int code, NSString *desc) {
    // 禁言群成员失败
}];

// 全员禁言
[[V2TIMManager sharedInstance] muteAllGroupMembers:@"groupA" isMute:YES succ:^{
    // 全员禁言成功
} fail:^(int code, NSString *desc) {
    // 全员禁言失败
}];

[[V2TIMManager sharedInstance] addGroupListener:self];
- (void)onMemberInfoChanged:(NSString *)groupID changeInfoList:(NSArray <V2TIMGroupMemberChangeInfo *> *)changeInfoList {
    // 禁言群成员监听
    for (V2TIMGroupMemberChangeInfo *memberChangeInfo in changeInfoList) {
      // 被禁言用户 ID
      NSString *userID = memberChangeInfo.userID;
      // 禁言时间
        uint32_t muteTime = memberChangeInfo.muteTime;
    }
}

- (void)onAllGroupMembersMuted:(NSString *)groupID isMute:(BOOL)isMute {
    // 全员禁言监听
}

class Callback final : public V2TIMCallback {
public:
    using SuccessCallback = std::function<void()>;
    using ErrorCallback = std::function<void(int, const V2TIMString&)>;

    Callback() = default;
    ~Callback() override = default;

    void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback) {
        success_callback_ = std::move(success_callback);
        error_callback_ = std::move(error_callback);
    }

    void OnSuccess() override {
        if (success_callback_) {
            success_callback_();
        }
    }
    void OnError(int error_code, const V2TIMString& error_message) override {
        if (error_callback_) {
            error_callback_(error_code, error_message);
        }
    }

private:
    SuccessCallback success_callback_;
    ErrorCallback error_callback_;
};

// 禁言群成员 userB 1分钟
auto callback = new Callback;
callback->SetCallback(
    [=]() {
        // 禁言群成员成功
        delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
        // 禁言群成员失败
        delete callback;
    });
V2TIMManager::GetInstance()->GetGroupManager()->MuteGroupMember("groupA", "userB", 60, callback);

// 全员禁言
auto callback = new Callback;
callback->SetCallback(
    [=]() {
        // 全员禁言成功
        delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
        // 全员禁言失败
        delete callback;
    });
V2TIMManager::GetInstance()->GetGroupManager()->muteAllGroupMembers("groupA", true, callback);

// 监听禁言群成员/全员禁言通知
class GroupListener final : public V2TIMGroupListener {
public:
    GroupListener() = default;
    ~GroupListener() override = default;

    void OnMemberInfoChanged(const V2TIMString& groupID,
                             const V2TIMGroupMemberChangeInfoVector& groupMemberChangeInfoList) override {
        // 禁言群成员监听
        for (size_t i = 0; i < groupMemberChangeInfoList.Size(); ++i) {
            const V2TIMGroupMemberChangeInfo& groupMemberChangeInfo = groupMemberChangeInfoList[i];
            // 被禁言用户 ID
            V2TIMString userID = groupMemberChangeInfo.userID;
            // 禁言时间
            uint32_t muteTime = groupMemberChangeInfo.muteTime;
        }
    }
    void onAllGroupMembersMuted(const V2TIMString& groupID,
                                bool isMute) override {
        // 全员禁言监听
    }
    // 其他成员 ...
};
// 添加群事件监听器，注意在移除监听器之前需要保持 groupListener 的生命期，以免接收不到事件回调
GroupListener groupListener;
V2TIMManager::GetInstance()->AddGroupListener(&groupListener);

[[V2TIMManager sharedInstance] kickGroupMember:@"groupA" memberList:@[@"user1"] reason:@"" succ:^(NSArray<V2TIMGroupMemberOperationResult *> *resultList) {
    // 踢人成功
} fail:^(int code, NSString *desc) {
    // 踢人失败
}];

[[V2TIMManager sharedInstance] addGroupListener:self];
- (void)onMemberKicked:(NSString *)groupID opUser:(V2TIMGroupMemberInfo *)opUser memberList:(NSArray<V2TIMGroupMemberInfo *>*)memberList {
    // 群成员被踢通知
}

template <class T>
class ValueCallback final : public V2TIMValueCallback<T> {
public:
    using SuccessCallback = std::function<void(const T&)>;
    using ErrorCallback = std::function<void(int, const V2TIMString&)>;
    
    ValueCallback() = default;
    ~ValueCallback() override = default;
    
    void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback) {
        success_callback_ = std::move(success_callback);
        error_callback_ = std::move(error_callback);
    }
    
    void OnSuccess(const T& value) override {
        if (success_callback_) {
            success_callback_(value);
        }
    }
    
    void OnError(int error_code, const V2TIMString& error_message) override {
        if (error_callback_) {
            error_callback_(error_code, error_message);
        }
    }

private:
    SuccessCallback success_callback_;
    ErrorCallback error_callback_;
};

V2TIMString groupID = "groupA";
V2TIMStringVector memberList;
memberList.PushBack("userB");

auto callback = new ValueCallback<V2TIMGroupMemberOperationResultVector>{};
callback->SetCallback(
[=](const V2TIMGroupMemberOperationResultVector& groupMemberOperationResultList) {
    // 踢人成功
    delete callback;
},
[=](int error_code, const V2TIMString& error_message) {
    // 踢人失败
    delete callback;
});

V2TIMManager::GetInstance()->GetGroupManager()->KickGroupMember(groupID, memberList, {}, callback);

// 监听群成员被踢通知
class GroupListener final : public V2TIMGroupListener {
public:
    GroupListener() = default;
    ~GroupListener() override = default;
    
    void OnMemberKicked(const V2TIMString& groupID, const V2TIMGroupMemberInfo& opUser, const V2TIMGroupMemberInfoVector& memberList) override {
        // 群成员被踢通知
    }
};

// 添加群事件监听器，注意在移除监听器之前需要保持 groupListener 的生命期，以免接收不到事件回调
GroupListener groupListener;
V2TIMManager::GetInstance()->AddGroupListener(&groupListener);