Javavoid addUserListener(V2NIMUserListener listener);

Objective-C- (void)addUserListener:(id<V2NIMUserListener>)listener;

C++virtual void addUserListener(V2NIMUserListener listener) = 0;

JavaNIMClient.getService(V2NIMUserService.class).addUserListener(new V2NIMUserListener() {
    @Override
    public void onUserProfileChanged(List<V2NIMUser> users) {

    }

    @Override
    public void onBlockListAdded(V2NIMUser user) {

    }

    @Override
    public void onBlockListRemoved(String accountId) {

    }
});

Objective-C[[[NIMSDK sharedSDK] v2UserService] addUserListener:self];
- (void)onUserProfileChanged:(NSArray<V2NIMUser *> *)users {
}
- (void)onBlockListAdded:(V2NIMUser *)user {
}
- (void)onBlockListRemoved:(NSString *)accountId {
}

C++V2NIMUserListener listener;
listener.onUserProfileChanged = [](std::vector<V2NIMUser> users) {
    // user profile changed
};
listener.onBlockListAdded = [](V2NIMUser user) {
    // user added to blocklist
};
listener.onBlockListRemoved = [](std::string accountId) {
    // user removed from blocklist
};
userService.addUserListener(listener);

Javavoid removeUserListener(V2NIMUserListener listener);

Objective-C- (void)removeUserListener:(id<V2NIMUserListener>)listener;

C++virtual void removeUserListener(V2NIMUserListener listener) = 0;

JavaNIMClient.getService(V2NIMUserService.class).removeUserListener(listener);

Objective-C[[[NIMSDK sharedSDK] v2UserService] removeUserListener:self];

C++V2NIMUserListener listener;
// ...
userService.addUserListener(listener);
// ...
userService.removeUserListener(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.V2NIMUserService.on("onUserProfileChanged", function (users: V2NIMUser[]) {})
nim.V2NIMUserService.on("onBlockListAdded", function (user: V2NIMUser) {})
nim.V2NIMUserService.on("onBlockListRemoved", function (accountId: string) {})

TypeScriptnim.userService.on("onUserProfileChanged", function (users: V2NIMUser[]) {})
nim.userService.on("onBlockListAdded", function (user: V2NIMUser) {})
nim.userService.on("onBlockListRemoved", function (accountId: string) {})

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
}

TypeScriptnim.V2NIMUserService.off("onUserProfileChanged", function (users: V2NIMUser[]) {})
nim.V2NIMUserService.off("onBlockListAdded", function (user: V2NIMUser) {})
nim.V2NIMUserService.off("onBlockListRemoved", function (accountId: string) {})

TypeScriptnim.userService.off("onUserProfileChanged", function (users: V2NIMUser[]) {})
nim.userService.off("onBlockListAdded", function (user: V2NIMUser) {})
nim.userService.off("onBlockListRemoved", function (accountId: string) {})

Javavoid getUserList(List<String> accountIds, V2NIMSuccessCallback<List<V2NIMUser>> success, V2NIMFailureCallback failure);

Objective-C- (void)getUserList:(NSArray<NSString *> *)accountIds
            success:(nullable V2NIMGetUserListSuccess)success
            failure:(nullable V2NIMFailureCallback)failure;

C++virtual void getUserList(nstd::vector<nstd::string> accountIds,
    V2NIMSuccessCallback<nstd::vector<V2NIMUser>> success,
    V2NIMFailureCallback failure) = 0;

TypeScriptgetUserList(accountIds: string[]): Promise<V2NIMUser[]>

TypeScriptgetUserList(accountIds: string[]): Promise<V2NIMUser[]>

JavaNIMClient.getService(V2NIMUserService.class).getUserList(accountIds,
    new V2NIMSuccessCallback<List<V2NIMUser>>() {
        @Override
        public void onSuccess(List<V2NIMUser> v2NIMUsers) {
            // TODO: Implement onSuccess logic
        }
    },
    new V2NIMFailureCallback() {
        @Override
        public void onFailure(V2NIMError error) {
            // TODO: Implement onFailure logic
        }
    });

Objective-C[[[NIMSDK sharedSDK] v2UserService] getUserList:@[@"accountId1",@"accountId2"] success:^(NSArray<V2NIMUser *> * _Nonnull result) {
    // 成功回调
} failure:^(V2NIMError * _Nonnull error) {
    // 失败回调
}];

C++nstd::vector<nstd::string> accountIds = {"test1", "test2"};
userService.getUserList(
    accountIds,
    [](nstd::vector<V2NIMUser> users) {
        for (auto&& user : users) {
            // do something
        }
    },
    [](V2NIMError error) {
        // get user list failed, handle error
    });

TypeScriptconst userProfiles = await nim.V2NIMUserService.getUserList(['accid1', 'accid2'])

TypeScriptconst userProfiles = await nim.userService.getUserList(['accid1', 'accid2'])

无返回值

Promise<V2NIMUser[]>：查询到的用户资料列表。

• 请求成功，返回 V2NIMSuccessCallback 回调，包含 V2NIMUser 用户资料列表。
• 请求失败，返回 V2NIMFailureCallback 回调，包含用户资料知相关错误码。

• 请求成功，返回 V2NIMGetUserListSuccess 回调，可自定义设置。
• 请求失败，返回 V2NIMFailureCallback 回调，包含用户资料知相关错误码。

无

Javavoid updateSelfUserProfile(V2NIMUserUpdateParams updateParams, V2NIMSuccessCallback<List<Void>> success, V2NIMFailureCallback failure);

Objective-C- (void)updateSelfUserProfile:(V2NIMUserUpdateParams *)updateParams
                     success:(nullable V2NIMSuccessCallback)success
                     failure:(nullable V2NIMFailureCallback)failure;

C++virtual void updateSelfUserProfile(V2NIMUserUpdateParams updateParams, V2NIMSuccessCallback<void> success, V2NIMFailureCallback failure) = 0;

TypeScriptupdateSelfUserProfile(updateParams: V2NIMUserUpdateParams): Promise<void>

TypeScriptupdateSelfUserProfile(updateParams: V2NIMUserUpdateParams): Promise<void>

JavaV2NIMUserUpdateParams updateParams = V2NIMUserUpdateParams.V2NIMUserUpdateParamsBuilder.builder()
    .withAvatar(avatar)
    .withBirthday(birthday)
    .withEmail(email)
    .withGender(gender)
    .withMobile(mobile)
    .withName(name)
    .withServerExtension(serverExtension)
    .withSign(sign)
    .build();

NIMClient.getService(V2NIMUserService.class).updateSelfUserProfile(updateParams,
new V2NIMSuccessCallback<List<Void>>() {
    @Override
    public void onSuccess(List<Void> voids) {
        // 处理成功回调
    }
},
new V2NIMFailureCallback() {
    @Override
    public void onFailure(V2NIMError error) {
        // 处理失败回调
    }
});

Objective-C[[[NIMSDK sharedSDK] v2UserService] updateSelfUserProfile:userService success:^{
    //成功回调
} failure:^(V2NIMError * _Nonnull error) {
    //失败回调
}];

C++V2NIMUserUpdateParams updateParams;
updateParams.name = "name";
userService.updateSelfUserProfile(
    updateParams,
    []() {
        // update success
    },
    [](V2NIMError error) {
        // update failed, handle error
    });

TypeScriptnim.V2NIMUserService.updateSelfUserProfile({
    name: 'ab',
});

TypeScriptnim.userService.updateSelfUserProfile({
    name: 'ab'
})

无返回值

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调。更新成功，返回 onUserProfileChanged 回调。
• 请求失败，返回 V2NIMFailureCallback 回调，包含用户资料知相关错误码。

更新成功，返回 onUserProfileChanged 回调。

Javavoid addUserToBlockList(String accountId, V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)addUserToBlockList:(NSString *)accountId
                   success:(nullable V2NIMSuccessCallback)success
                   failure:(nullable V2NIMFailureCallback)failure;

C++virtual void addUserToBlockList(nstd::string accountId, V2NIMSuccessCallback<void> success, V2NIMFailureCallback failure) = 0;

TypeScriptaddUserToBlockList(accountId: string): Promise<void>

TypeScriptaddUserToBlockList(accountId: string): Promise<void>

JavaNIMClient.getService(V2NIMUserService.class).addUserToBlockList(accountId,
new V2NIMSuccessCallback<Void>() {
    @Override
    public void onSuccess(Void unused) {

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

    }
});

Objective-C[[[NIMSDK sharedSDK] v2UserService] addUserToBlockList:@"accountId" success:^{

    } failure:^(V2NIMError * _Nonnull error) {

    }];

C++userService.addUserToBlockList(
    "account1",
    []() {
        // add user to blocklist success
    },
    [](V2NIMError error) {
        // add user to blocklist failed, handle error
    }
);

TypeScriptnim.V2NIMUserService.addUserToBlockList('accid');

TypeScriptnim.userService.addUserToBlockList('accid')

无返回值

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调。
• 请求失败，返回 V2NIMFailureCallback 回调，包含用户资料知相关错误码。

无

Javavoid removeUserFromBlockList(String accountId, V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)removeUserFromBlockList:(NSString *)accountId
                        success:(nullable V2NIMSuccessCallback)success
                        failure:(nullable V2NIMFailureCallback)failure;

C++virtual void removeUserFromBlockList(nstd::string accountId, V2NIMSuccessCallback<void> success, V2NIMFailureCallback failure) = 0;

TypeScriptremoveUserFromBlockList(accountId: string): Promise<void>

TypeScriptremoveUserFromBlockList(accountId: string): Promise<void>

JavaNIMClient.getService(V2NIMUserService.class).removeUserFromBlockList(accountId, new V2NIMSuccessCallback<Void>() {
    @Override
    public void onSuccess(Void unused) {

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

    }
});

Objective-C[[[NIMSDK sharedSDK] v2UserService] removeUserFromBlockList:@"accountId" success:^{

    } failure:^(V2NIMError * _Nonnull error) {

    }];

C++userService.removeUserFromBlockList(
    "account1",
    []() {
        // remove user from blocklist success
    },
    [](V2NIMError error) {
        // remove user from blocklist failed, handle error
    });

TypeScriptnim.V2NIMUserService.removeUserFromBlockList('accid');

TypeScriptnim.userService.removeUserFromBlockList('accid')

无返回值

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调。
• 请求失败，返回 V2NIMFailureCallback 回调，包含用户资料知相关错误码。

无

Javavoid getBlockList(V2NIMSuccessCallback<List<String>> success, V2NIMFailureCallback failure);

Objective-C- (void)getBlockList:(nullable V2NIMGetBlockListSuccess)success
             failure:(nullable V2NIMFailureCallback)failure;

C++virtual void getBlockList(V2NIMSuccessCallback<nstd::vector<nstd::string>> success, V2NIMFailureCallback failure) = 0;

TypeScriptgetBlockList(): Promise<string[]>

TypeScriptgetBlockList(): Promise<string[]>

JavaNIMClient.getService(V2NIMUserService.class).getBlockList(
    new V2NIMSuccessCallback<List<String>>() {
        @Override
        public void onSuccess(List<String> strings) {

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

        }
    }
);

Objective-C[[[NIMSDK sharedSDK] v2UserService] getBlockList:^(NSArray<NSString *> * _Nonnull result) {

} failure:^(V2NIMError * _Nonnull error) {

}];

C++userService.getBlockList(
    [](std::vector<std::string> accountIds) {
        for (auto&& accountId : accountIds) {
            // do something
        }
    },
    [](V2NIMError error) {
        // get blocklist failed, handle error
    });

TypeScriptconst blockList = await nim.V2NIMUserService.getBlockList()

TypeScriptconst blockList = await nim.userService.getBlockList()

无返回值

Promise<string[]>：查询到的黑名单用户账号 ID 列表。

• 请求成功，返回 V2NIMSuccessCallback 回调，包含黑名单用户账号 ID 列表。
• 请求失败，返回 V2NIMFailureCallback 回调，包含用户资料知相关错误码。

• 请求成功，返回 V2NIMGetBlockListSuccess 回调，可自定义设置。
• 请求失败，返回 V2NIMFailureCallback 回调，包含用户资料知相关错误码。

无

Javavoid searchUserByOption(V2NIMUserSearchOption userSearchOption, V2NIMSuccessCallback<List<V2NIMUser>> success, V2NIMFailureCallback failure);

Objective-C- (void)searchUserByOption:(V2NIMUserSearchOption *)userSearchOption
            success:(nullable V2NIMGetUserListSuccess)success
            failure:(nullable V2NIMFailureCallback)failure;

C++virtual void searchUserByOption(const V2NIMUserSearchOption& option,V2NIMSuccessCallback<nstd::vector<V2NIMUser>> success,V2NIMFailureCallback failure) = 0;

TypeScriptsearchUserByOption(option: V2NIMUserSearchOption): Promise<V2NIMUser[]>

JavaV2NIMUserSearchOption option = V2NIMUserSearchOption.V2NIMUserSearchOptionBuilder.builder("搜索关键字")
//             按需配置
//            .withSearchAccountId()
//            .withSearchMobile()
//            .withSearchName()
            .build();
    NIMClient.getService(V2NIMUserService.class).searchUserByOption(option,
            new V2NIMSuccessCallback<List<V2NIMUser>>() {
                @Override
                public void onSuccess(List<V2NIMUser> v2NIMUsers) {

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

                }
            });

Objective-CV2NIMUserSearchOption *option = [V2NIMUserSearchOption optionWithKeyword:@"keyword"];
// 按需配置
option.searchName = YES;
option.searchAccountId = YES;
option.searchMobile = YES;
[NIMSDK.sharedSDK.v2UserService searchUserByOption:option
                                           success:^(NSArray <V2NIMUser *> *result)
                                           {

                                           }
                                           failure:^(V2NIMError *error)
                                           {

                                           }];

C++V2NIMUserSearchOption option;
option.keyword = "test";
userService.searchUserByOption(
   option,
   [](nstd::vector<V2NIMUser> users) {
   for (auto&& user : users) {
   // do something
   }
   },
   [](V2NIMError error) {
   // search user failed, handle error
   });

TypeScripttry {
    const users = await nim.V2NIMUserService.searchUserByOption({
        keyword: 'nick',
        searchName: true,
        searchAccountId: false,
        searchMobile: true
    })
} catch(err) {
    console.error('searchUserByOption Error:', err)
}

无返回值

Promise<V2NIMUser[]>：查询到的用户信息列表。

• 请求成功，返回 V2NIMSuccessCallback 回调，包含 V2NIMUser 列表。
• 请求失败，返回 V2NIMFailureCallback 回调，包含用户信息相关错误码。

• 请求成功，，返回 V2NIMGetUserListSuccess 回调，可自定义设置。
• 请求失败，返回 V2NIMFailureCallback 回调，包含用户信息相关错误码。

无

Javavoid getUserListFromCloud(List<String> accountIds, V2NIMSuccessCallback<List<V2NIMUser>> success, V2NIMFailureCallback failure);

Objective-C- (void)getUserListFromCloud:(NSArray<NSString *> *)accountIds
                     success:(nullable V2NIMGetUserListSuccess)success
                     failure:(nullable V2NIMFailureCallback)failure;

C++virtual void v2::V2NIMUserService::getUserListFromCloud (nstd::vector< nstd::string > accountIds,
                                                            V2NIMSuccessCallback< nstd::vector< V2NIMUser > > success,
                                                            V2NIMFailureCallback     failure )

TypeScriptgetUserListFromCloud(accountIds: string[]): Promise<V2NIMUser[]>

JavaList<String> accountIds = new ArrayList<>();
accountIds.add("test01");
accountIds.add("test02");
NIMClient.getService(V2NIMUserService.class).getUserListFromCloud(accountIds, users -> {
    //Query successful
}, error -> {
    //Query failed
});

Objective-C[NIMSDK.sharedSDK.v2UserService getUserListFromCloud:@[@"accounId1",@"accountId2"] success:^(NSArray<V2NIMUser *> * _Nonnull result) {
        // 成功回调
    } failure:^(V2NIMError * _Nonnull error) {
        // 失败回调
    }];

C++nstd::vector<nstd::string> accountIds = {"test1", "test2"};
userService.getUserListFromCloud(
    accountIds,
    [](nstd::vector<V2NIMUser> usersList) {
        for (auto&& user : usersList) {
            // do something
        }
    },
    [](V2NIMError error) {
        // get UserListFromCloud failed, handle error
    });

TypeScriptconst users = await nim.V2NIMUserService.getUserListFromCloud(["AccountID1", "AccountID2"])

无返回值

Promise<V2NIMUser[]>：查询到的用户信息列表。

• 请求成功，返回 V2NIMSuccessCallback 回调，包含用户信息列表。
• 请求失败，返回 V2NIMFailureCallback 回调，包含用户资料相关错误码。

• 请求成功，返回 V2NIMGetUserListSuccess 回调，可自定义设置。
• 请求失败，返回 V2NIMFailureCallback 回调，包含用户资料相关错误码。

无